|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use MathType | |
|---|---|
| visad | The core VisAD package, providing support for VisAD's Data & MathType hierarchy, as well as for VisAD Displays and remote collaboration. |
| visad.bom | |
| visad.cluster | |
| visad.data | Provides for importing data to and exporting data from VisAD. |
| visad.data.dods | Supports read-only access to datasets on DODS servers by importing such datasets as VisAD data objects. |
| visad.data.gis | |
| visad.data.hdf5 | |
| visad.data.hdfeos | Provides for importing an HDF-EOS dataset into VisAD. |
| visad.data.in | Supports the creation of form-specific, read-only, data-access packages that import external dataset into VisAD as VisaD data objects. |
| visad.data.netcdf | Provides for importing a netCDF dataset into VisAD and for exporting a VisAD data object to a netCDF dataset. |
| visad.data.netcdf.in | Provides for importing a netCDF dataset into VisAD. |
| visad.data.visad.object | |
| visad.java2d | Provides support for two-dimensional VisAD Displays using Java2D. |
| visad.java3d | Provides support for two- and three-dimensional VisAD Displays using Java3D. |
| visad.jmet | |
| visad.meteorology | Provides classes that are useful in the field of meteorology. |
| visad.python | |
| visad.util | Provides a collection of useful utilities, many of them GUI widgets, to aid in VisAD application design. |
| Uses of MathType in visad |
|---|
| Subclasses of MathType in visad | |
|---|---|
class |
DisplayRealType
DisplayRealType is the class for display real scalar types. |
class |
DisplayTupleType
DisplayTupleType is the class for tuples of DisplayRealType's. |
class |
EarthVectorType
EarthVectorType is the VisAD data type for 2-D and 3-D wind or current vectors in Units convertable with meter / second whose first component is parallel to latitude lines, positive east, and whose second component is parallel to longitude lines, positive north. |
class |
FunctionType
FunctionType is the VisAD data type for functions. |
class |
GridVectorType
GridVectorType is the VisAD data type for 2-D and 3-D wind or current vectors in Units convertable with meter / second whose first component is parallel to grid rows, positive toward increasing column, and whose second component is parallel to grid columns, positive toward decreasing row. |
class |
RealTupleType
RealTupleType is the VisAD data type for tuples in R^n, for n>0. |
class |
RealType
RealType is the VisAD scalar data type for real number variables. |
class |
RealVectorType
RealVectorType is the VisAD data type for vector field tuple in R^n, for n>0. |
class |
ScalarType
ScalarType is the superclass of the VisAD hierarchy of scalar data types. |
class |
SetType
SetType is the VisAD data type for subsets of R^n for n>0. |
class |
TextType
TextType is the VisAD scalar data type for text string variables. |
class |
TupleType
TupleType is the general VisAD data type for vectors. |
| Methods in visad that return MathType | |
|---|---|
MathType |
TupleType.__getitem__(int index)
A wrapper around getComponent for JPython. |
MathType |
TupleType.binary(MathType type,
int op,
Vector names)
|
MathType |
TextType.binary(MathType type,
int op,
Vector names)
|
MathType |
SetType.binary(MathType type,
int op,
Vector names)
|
MathType |
RealType.binary(MathType type,
int op,
Vector names)
|
MathType |
RealTupleType.binary(MathType type,
int op,
Vector names)
Performs an arithmetic operation with another MathType. |
abstract MathType |
MathType.binary(MathType type,
int op,
Vector names)
|
MathType |
FunctionType.binary(MathType type,
int op,
Vector names)
|
MathType |
TupleType.cloneDerivative(RealType d_partial)
|
MathType |
TextType.cloneDerivative(RealType d_partial)
|
MathType |
SetType.cloneDerivative(RealType d_partial)
|
MathType |
RealType.cloneDerivative(RealType d_partial)
|
abstract MathType |
MathType.cloneDerivative(RealType d_partial)
|
MathType |
FunctionType.cloneDerivative(RealType d_partial)
|
MathType |
TupleType.getComponent(int i)
return component for i between 0 and getDimension() - 1 |
MathType[] |
TupleType.getComponents()
get array of components |
MathType |
FunctionType.getRange()
|
MathType |
ShadowType.getType()
|
MathType |
RemoteDataReferenceImpl.getType()
this is more efficient than getData().getType() for RemoteDataReferences |
MathType |
RemoteDataImpl.getType()
|
MathType |
DataReferenceImpl.getType()
this is more efficient than getData().getType() for RemoteDataReferences |
MathType |
DataReference.getType()
this is more efficient than getData().getType() for RemoteDataReferences |
MathType |
DataImpl.getType()
|
MathType |
DataDisplayLink.getType()
|
MathType |
Data.getType()
|
static MathType |
MathType.stringToType(String s)
create a MathType from its string representation; essentially the inverse of the prettyString method |
MathType |
TupleType.unary(int op,
Vector names)
|
MathType |
TextType.unary(int op,
Vector names)
|
MathType |
SetType.unary(int op,
Vector names)
|
MathType |
RealType.unary(int op,
Vector names)
|
MathType |
RealTupleType.unary(int op,
Vector names)
|
abstract MathType |
MathType.unary(int op,
Vector names)
|
MathType |
FunctionType.unary(int op,
Vector names)
|
| Methods in visad with parameters of type MathType | |
|---|---|
Data |
TupleIface.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
Tuple.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
RemoteDataImpl.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
Pointwise binary operation between this (AdaptedData) and data. |
Data |
RealTuple.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
Real.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
FlatField.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
Return new Field with value 'this op data'. |
Data |
FieldImpl.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
return new Field with value 'this op data'; test for various relations between types of this and data |
Data |
DataImpl.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
Pointwise binary operation between this and data. |
Data |
Data.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
Pointwise binary operation between this and data. |
MathType |
TupleType.binary(MathType type,
int op,
Vector names)
|
MathType |
TextType.binary(MathType type,
int op,
Vector names)
|
MathType |
SetType.binary(MathType type,
int op,
Vector names)
|
MathType |
RealType.binary(MathType type,
int op,
Vector names)
|
MathType |
RealTupleType.binary(MathType type,
int op,
Vector names)
Performs an arithmetic operation with another MathType. |
abstract MathType |
MathType.binary(MathType type,
int op,
Vector names)
|
MathType |
FunctionType.binary(MathType type,
int op,
Vector names)
|
Data |
RemoteDataImpl.changeMathType(MathType new_type)
call unary() to clone this except with a new MathType |
Data |
DataImpl.changeMathType(MathType new_type)
call unary() to clone this except with a new MathType |
Data |
Data.changeMathType(MathType new_type)
call unary() to clone this except with a new MathType |
Object |
UnionSet.cloneButType(MathType type)
Clone this UnionSet, but give it a new MathType; this is safe, since constructor checks consistency of DomainCoordinateSystem and SetUnits with type. |
Object |
SingletonSet.cloneButType(MathType type)
Clone this SingletonSet, but change the MathType |
Object |
SetIface.cloneButType(MathType type)
Clones this set -- changing the MathType. |
abstract Object |
Set.cloneButType(MathType type)
copy this Set, but give it a new MathType; this is safe, since constructor checks consistency of DomainCoordinateSystem and SetUnits with Type |
Object |
ProductSet.cloneButType(MathType type)
|
Object |
List1DSet.cloneButType(MathType type)
|
Object |
List1DDoubleSet.cloneButType(MathType type)
|
Object |
LinearNDSet.cloneButType(MathType type)
Return a clone of this object with a new MathType. |
Object |
LinearLatLonSet.cloneButType(MathType type)
|
Object |
Linear3DSet.cloneButType(MathType type)
Return a clone of this object with a new MathType. |
Object |
Linear2DSet.cloneButType(MathType type)
Return a clone of this object with a new MathType. |
Object |
Linear1DSet.cloneButType(MathType type)
Return a clone of this object with a new MathType. |
Object |
IrregularSet.cloneButType(MathType type)
|
Object |
Irregular3DSet.cloneButType(MathType type)
|
Object |
Irregular2DSet.cloneButType(MathType type)
|
Object |
Irregular1DSet.cloneButType(MathType type)
|
Object |
IntegerNDSet.cloneButType(MathType type)
|
Object |
Integer3DSet.cloneButType(MathType type)
|
Object |
Integer2DSet.cloneButType(MathType type)
|
Object |
Integer1DSet.cloneButType(MathType type)
|
Object |
GriddedSet.cloneButType(MathType type)
|
Object |
Gridded3DSet.cloneButType(MathType type)
|
Object |
Gridded3DDoubleSet.cloneButType(MathType type)
|
Object |
Gridded2DSet.cloneButType(MathType type)
|
Object |
Gridded2DDoubleSet.cloneButType(MathType type)
|
Object |
Gridded1DSet.cloneButType(MathType type)
|
Object |
Gridded1DDoubleSet.cloneButType(MathType type)
|
Object |
FloatSet.cloneButType(MathType type)
|
Object |
DoubleSet.cloneButType(MathType type)
Clones this instance with a different MathType. |
protected FlatField |
FlatField.cloneDouble(MathType f_type,
Unit[] units,
ErrorEstimate[] errors)
|
protected FlatField |
FlatField.cloneDouble(MathType f_type,
Unit[] units,
ErrorEstimate[] errors,
double[][] newValues)
|
protected FlatField |
FlatField.cloneFloat(MathType f_type,
Unit[] units,
ErrorEstimate[] errors)
|
protected FlatField |
FlatField.cloneFloat(MathType f_type,
Unit[] units,
ErrorEstimate[] errors,
float[][] newValues)
|
static Gridded1DDoubleSet |
Gridded1DDoubleSet.create(MathType type,
double[] samples,
CoordinateSystem coordSys,
Unit unit,
ErrorEstimate error)
Returns an instance of this class. |
static LinearSet |
LinearNDSet.create(MathType type,
double[] firsts,
double[] lasts,
int[] lengths)
General Factory method for creating the proper linear set (Linear1DSet, Linear2DSet, etc.). |
static LinearSet |
LinearNDSet.create(MathType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
static GriddedSet |
GriddedSet.create(MathType type,
float[][] samples,
int[] lengths)
Abreviated Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.). |
static GriddedSet |
GriddedSet.create(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.). |
static GriddedSet |
GriddedSet.create(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.). |
static GriddedSet |
GriddedSet.create(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.). |
static Gridded1DSet |
Gridded1DSet.create(MathType type,
float[] samples,
CoordinateSystem coordSys,
Unit unit,
ErrorEstimate error)
Returns an instance of this class. |
static GriddedSet |
IntegerNDSet.create(MathType type,
int[] lengths)
Abreviated factory method for creating the proper integer set (Integer1DSet, Integer2DSet, etc.). |
static GriddedSet |
IntegerNDSet.create(MathType type,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
General factory method for creating the proper integer set (Integer1DSet, Integer2DSet, etc.). |
Data |
RemoteFunctionImpl.derivative(MathType[] derivType_s,
int error_mode)
|
abstract Data |
FunctionImpl.derivative(MathType[] derivType_s,
int error_mode)
|
Data |
Function.derivative(MathType[] derivType_s,
int error_mode)
return the tuple of derivatives of this Function with respect to all RealType components of its domain RealTuple; set result MathTypes of tuple components to derivType_s; propogate errors according to error_mode |
Data |
FlatField.derivative(MathType[] derivType_s,
int error_mode)
|
Data |
FieldImpl.derivative(MathType[] derivType_s,
int error_mode)
|
Data |
RemoteFunctionImpl.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
abstract Data |
FunctionImpl.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
Data |
Function.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
return the tuple of derivatives of this Function with respect to the RealTypes in d_partial_s; the RealTypes in d_partial_s may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; set result MathTypes of tuple components to derivType_s; propogate errors according to error_mode |
Data |
FlatField.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
Data |
FieldImpl.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
Function |
RemoteFunctionImpl.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
abstract Function |
FunctionImpl.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
Function |
Function.derivative(RealType d_partial,
MathType derivType,
int error_mode)
return the derivative of this Function with respect to d_partial; set result MathType to derivType; d_partial may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; propogate errors according to error_mode |
Function |
FlatField.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
Function |
FieldImpl.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
boolean |
TupleType.equalsExceptName(MathType type)
|
boolean |
TextType.equalsExceptName(MathType type)
|
boolean |
SetType.equalsExceptName(MathType type)
|
boolean |
RealType.equalsExceptName(MathType type)
any two RealType-s are equal except Name |
boolean |
RealTupleType.equalsExceptName(MathType type)
|
abstract boolean |
MathType.equalsExceptName(MathType type)
this is useful for determining compatibility of Data objects for binary mathematical operations; any RealTypes are equal; any TextTypes are equal; TupleTypes are equal if their components are equal; FunctionTypes are equal if their domains and ranges are equal |
boolean |
FunctionType.equalsExceptName(MathType type)
|
boolean |
TupleType.equalsExceptNameButUnits(MathType type)
|
boolean |
TextType.equalsExceptNameButUnits(MathType type)
|
boolean |
SetType.equalsExceptNameButUnits(MathType type)
|
boolean |
RealType.equalsExceptNameButUnits(MathType type)
Check to see if type has convertible units with this RealType. |
boolean |
RealTupleType.equalsExceptNameButUnits(MathType type)
|
abstract boolean |
MathType.equalsExceptNameButUnits(MathType type)
|
boolean |
FunctionType.equalsExceptNameButUnits(MathType type)
|
Field |
FieldImpl.extract(MathType type)
extract Field from this.component using the MathType of one of the range componenets |
static boolean |
MathType.findScalarType(MathType mt,
ScalarType st)
return true if st occurs in mt |
int |
TupleType.getIndex(MathType type)
return index of first component with type; if no such component, return -1 |
Data |
TupleIface.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
Tuple.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
Set.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
RemoteDataImpl.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
Pointwise unary operation applied to this (AdaptedData). |
Data |
RealTuple.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
Real.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
unary function on a Real; override some trig functions based on Unit; transcental functions destroy dimensionfull Unit |
Data |
FlatField.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
Return new FlatField with value 'this op'. |
Data |
FieldImpl.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
return new Field with value 'op this' |
Data |
DataImpl.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
Pointwise unary operation applied to this. |
Data |
Data.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
Pointwise unary operation applied to this. |
| Constructors in visad with parameters of type MathType | |
|---|---|
DataImpl(MathType type)
construct a DataImpl with given MathType |
|
DoubleSet(MathType type)
construct a DoubleSet with null CoordinateSystem and Units |
|
DoubleSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units)
construct a DoubleSet with null CoordinateSystem and Units |
|
FloatSet(MathType type)
construct a FloatSet object with null CoordinateSystem and Units |
|
FloatSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units)
the set of values representable by N floats; type must be a RealType, a RealTupleType or a SetType; coordinate_system and units must be compatible with defaults for type, or may be null; a FloatSet may not be used as a Field domain |
|
FunctionType(MathType domain,
MathType range)
domain must be a RealType or a RealTupleType; range may be any MathType |
|
Gridded1DDoubleSet(MathType type,
double[][] samples,
int lengthX)
a 1-D sequence with no regular interval with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded1DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Gridded1DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
a 1-D sorted sequence with no regular interval. samples array is organized double[1][number_of_samples] where lengthX = number_of_samples. samples must be sorted (either increasing or decreasing). coordinate_system and units must be compatible with defaults for type, or may be null. errors may be null |
|
Gridded1DDoubleSet(MathType type,
float[][] samples,
int lengthX)
a 1-D sequence with no regular interval with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded1DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Gridded1DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
a 1-D sorted sequence with no regular interval. samples array is organized float[1][number_of_samples] where lengthX = number_of_samples. samples must be sorted (either increasing or decreasing). coordinate_system and units must be compatible with defaults for type, or may be null. errors may be null |
|
Gridded1DSet(MathType type,
float[][] samples,
int lengthX)
Constructs a 1-D sorted sequence with no regular interval. |
|
Gridded1DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Constructs a 1-D sorted sequence with no regular interval. |
|
Gridded1DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
Constructs a 1-D sorted sequence with no regular interval. |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX)
a 2-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized double[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY)
a 2-D set whose topology is a lengthX x lengthY grid, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized double[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX)
a 2-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized float[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY)
a 2-D set whose topology is a lengthX x lengthY grid, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized float[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX)
a 2-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized float[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY)
a 2-D set whose topology is a lengthX x lengthY grid, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized float[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX)
a 3-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized double[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY)
a 3-D set with manifold dimension = 2, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized double[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
int lengthZ)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized double[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX)
a 3-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY)
a 3-D set with manifold dimension = 2, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX)
a 3-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY)
a 3-D set with manifold dimension = 2, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid, with null errors, CoordinateSystem and Units are defaults from type |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
GriddedSet(MathType type,
float[][] samples,
int[] lengths)
construct a GriddedSet with samples |
|
GriddedSet(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a GriddedSet with samples and non-default CoordinateSystem |
|
GriddedSet(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Integer1DSet(MathType type,
int length)
|
|
Integer1DSet(MathType type,
int length,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a 1-dimensional set with values {0, 1, ..., length-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Integer2DSet(MathType type,
Integer1DSet[] sets)
|
|
Integer2DSet(MathType type,
Integer1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Integer2DSet(MathType type,
int length1,
int length2)
|
|
Integer2DSet(MathType type,
int length1,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a 2-dimensional set with values {0, 1, ..., length1-1} x {0, 1, ..., length2-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Integer3DSet(MathType type,
Integer1DSet[] sets)
|
|
Integer3DSet(MathType type,
Integer1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Integer3DSet(MathType type,
int length1,
int length2,
int length3)
|
|
Integer3DSet(MathType type,
int length1,
int length2,
int length3,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a 3-dimensional set with values {0, 1, ..., length1-1} x {0, 1, ..., length2-1} x {0, 1, ..., length3-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
IntegerNDSet(MathType type,
int[] lengths)
|
|
IntegerNDSet(MathType type,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct an N-dimensional set with values in the cross product of {0, 1, ..., lengths[i]-1} for i=0, ..., lengths[lengths.length-1]; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
IntegerNDSet(MathType type,
Integer1DSet[] sets)
|
|
IntegerNDSet(MathType type,
Integer1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct an N-dimensional set with values in the cross product of {0, 1, ..., lengths[i]-1} for i=0, ..., lengths[lengths.length-1]; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular1DSet(MathType type,
float[][] samples)
a 1-D irregular set with null errors, CoordinateSystem and Units are defaults from type |
|
Irregular1DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 1-D irregular set; samples array is organized float[1][number_of_samples]; samples need not be sorted - the constructor sorts samples to define a 1-D "triangulation"; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular1DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Irregular2DSet(MathType type,
float[][] samples)
a 2-D irregular set with null errors, CoordinateSystem and Units are defaults from type; topology is computed by the constructor |
|
Irregular2DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
a 2-D irregular set; samples array is organized float[2][number_of_samples]; no geometric constraint on samples; if delan is non-null it defines the topology of samples (which must have manifold dimension 2), else the constructor computes a topology with manifold dimension 2; note that Gridded2DSet can be used for an irregular set with domain dimension 2 and manifold dimension 1; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular2DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan,
boolean copy)
|
|
Irregular2DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new)
shortcut constructor for constructing Irregular2DSet using sort from existing Irregular1DSet |
|
Irregular2DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
complete constructor for constructing Irregular2DSet using sort from existing Irregular1DSet |
|
Irregular2DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Irregular3DSet(MathType type,
float[][] samples)
a 3-D irregular set with null errors, CoordinateSystem and Units are defaults from type; topology is computed by the constructor |
|
Irregular3DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
a 3-D irregular set; samples array is organized float[3][number_of_samples]; no geometric constraint on samples; if delan is non-null it defines the topology of samples (which may have manifold dimension 2 or 3), else the constructor computes a topology with manifold dimension 3; note that Gridded3DSet can be used for an irregular set with domain dimension 3 and manifold dimension 1; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular3DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan,
boolean copy)
|
|
Irregular3DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new)
construct Irregular3DSet using sort from existing Irregular1DSet |
|
Irregular3DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct Irregular3DSet using sort from existing Irregular1DSet |
|
Irregular3DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
IrregularSet(MathType type,
float[][] samples)
construct an IrregularSet |
|
IrregularSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct an IrregularSet with non-default CoordinateSystem |
|
IrregularSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
construct an IrregularSet with non-default CoordinateSystem and non-default Delaunay |
|
IrregularSet(MathType type,
float[][] samples,
Delaunay delan)
construct an IrregularSet with non-default Delaunay |
|
IrregularSet(MathType type,
float[][] samples,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
construct an IrregularSet with ManifoldDimension ! |
|
IrregularSet(MathType type,
float[][] samples,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan,
boolean copy)
|
|
Linear1DSet(MathType type,
double first,
double last,
int length)
Construct a 1-D arithmetic progression with the specified type and null errors. |
|
Linear1DSet(MathType type,
double first,
double last,
int length,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 1-D arithmetic progression with the specified type, coord_sys,
units and errors. |
|
Linear1DSet(MathType type,
double first,
double last,
int length,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 1-D arithmetic progression with the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2)
Construct a 2-D cross product of arithmetic progressions with null errors and the specified type. |
|
Linear2DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
Linear1DSet[] sets)
Construct a 2-D cross product of sets with the
specified type. |
|
Linear2DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
double first3,
double last3,
int length3)
Construct a 3-D cross product of arithmetic progressions with null errors and the specified type. |
|
Linear3DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
double first3,
double last3,
int length3,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 3-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
double first3,
double last3,
int length3,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 3-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
Linear1DSet[] sets)
Construct a 3-D cross product of sets with the
specified type. |
|
Linear3DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 3-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 3-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
LinearLatLonSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with null errors, CoordinateSystem and Units are defaults from type |
|
LinearLatLonSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearLatLonSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearLatLonSet(MathType type,
Linear1DSet[] sets)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with null errors, CoordinateSystem and Units are defaults from type. |
|
LinearLatLonSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearLatLonSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearNDSet(MathType type,
double[] firsts,
double[] lasts,
int[] lengths)
Construct an N-dimensional set as the product of N arithmetic progressions (lengths[i] samples between firsts[i] and lasts[i]), with null errors, CoordinateSystem and Units are defaults from type |
|
LinearNDSet(MathType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct an N-dimensional set as the product of N arithmetic progressions (lengths[i] samples between firsts[i] and lasts[i]), coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null. |
|
LinearNDSet(MathType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct an N-dimensional set as the product of N arithmetic progressions (lengths[i] samples between firsts[i] and lasts[i]), coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null. |
|
LinearNDSet(MathType type,
Linear1DSet[] l)
Construct an N-dimensional set as the product of N Linear1DSets, with null errors, CoordinateSystem and Units are defaults from type. |
|
LinearNDSet(MathType type,
Linear1DSet[] l,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct an N-dimensional set as the product of N Linear1DSets; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
LinearNDSet(MathType type,
Linear1DSet[] l,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct an N-dimensional set as the product of N Linear1DSets; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
List1DDoubleSet(double[] d,
MathType type,
CoordinateSystem coord_sys,
Unit[] units)
Constructs with a non-default CoordinateSystem. |
|
List1DSet(float[] d,
MathType type,
CoordinateSystem coord_sys,
Unit[] units)
Constructs with a non-default CoordinateSystem. |
|
ProductSet(MathType type,
SampledSet[] sets)
create the product of the sets array, with null errors, CoordinateSystem and Units are defaults from type |
|
ProductSet(MathType type,
SampledSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
create the product of the sets array; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
SampledSet(MathType type)
|
|
SampledSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
SampledSet(MathType type,
int manifold_dimension)
|
|
SampledSet(MathType type,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Set(MathType type)
construct a Set object |
|
Set(MathType type,
CoordinateSystem coord_sys)
Constructs a Set object with a non-default CoordinateSystem. |
|
Set(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Constructs a Set object with a non-default CoordinateSystem, non-default Unit-s, and non-default errors. |
|
SetType(MathType type)
type must be a RealType or a RealTupleType |
|
ShadowFunctionOrSetType(MathType t,
DataDisplayLink link,
ShadowType parent,
ShadowRealTupleType domain,
ShadowType range)
this constructor is a bit of a kludge to get around single inheritance problems |
|
ShadowFunctionType(MathType t,
DataDisplayLink link,
ShadowType parent,
ShadowRealTupleType domain,
ShadowType range)
|
|
ShadowRealTupleType(MathType t,
DataDisplayLink link,
ShadowType parent,
ShadowType[] tcs,
ShadowType adapter)
|
|
ShadowRealType(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowScalarType(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowSetType(MathType t,
DataDisplayLink link,
ShadowType parent,
ShadowRealTupleType domain)
|
|
ShadowTextType(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowTupleType(MathType t,
DataDisplayLink link,
ShadowType parent,
ShadowType[] tcs)
|
|
ShadowType(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
SimpleSet(MathType type)
|
|
SimpleSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
SimpleSet(MathType type,
int manifold_dimension)
|
|
SimpleSet(MathType type,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
TupleType(MathType[] types)
array of component types |
|
UnionSet(MathType type,
SampledSet[] sets)
Construct a UnionSet with an array of SampledSets with null errors. |
|
UnionSet(MathType type,
SampledSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
| Uses of MathType in visad.bom |
|---|
| Methods in visad.bom that return MathType | |
|---|---|
MathType |
TCData.getType()
|
| Methods in visad.bom with parameters of type MathType | |
|---|---|
static boolean |
ImageRendererJ3D.isImageType(MathType type)
determine whether the given MathType is usable with ImageRendererJ3D |
static boolean |
TextureFillRendererJ3D.isRendererUsable(MathType type,
ScalarMap[] maps)
determine whether the given MathType and collection of ScalarMaps meets the criteria to use TextureFillRendererJ3D. |
static boolean |
ImageRendererJ3D.isRendererUsable(MathType type,
ScalarMap[] maps)
determine whether the given MathType and collection of ScalarMaps meets the criteria to use ImageRendererJ3D. |
static boolean |
TextureFillRendererJ3D.isSetType(MathType type)
determine whether the given MathType is usable with TextureFillRendererJ3D |
static void |
ImageRendererJ3D.verifyImageRendererUsable(MathType type,
ScalarMap[] maps)
Deprecated. Use isRendererUsable(MathType, ScalarMap[]) instead. |
| Uses of MathType in visad.cluster |
|---|
| Methods in visad.cluster that return MathType | |
|---|---|
MathType |
UserDummyDataImpl.getType()
|
MathType |
RemoteNodeTupleImpl.getType()
|
MathType |
RemoteNodePartitionedFieldImpl.getType()
|
MathType |
RemoteNodeFieldImpl.getType()
|
MathType |
RemoteClientTupleImpl.getType()
|
MathType |
RemoteClientPartitionedFieldImpl.getType()
|
MathType |
RemoteClientFieldImpl.getType()
|
| Methods in visad.cluster with parameters of type MathType | |
|---|---|
Data |
UserDummyDataImpl.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
RemoteClientDataImpl.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
RemoteNodePartitionedFieldImpl.derivative(MathType[] derivType_s,
int error_mode)
|
Data |
RemoteNodeFieldImpl.derivative(MathType[] derivType_s,
int error_mode)
|
Data |
RemoteClientPartitionedFieldImpl.derivative(MathType[] derivType_s,
int error_mode)
|
Data |
RemoteClientFieldImpl.derivative(MathType[] derivType_s,
int error_mode)
|
Data |
RemoteNodePartitionedFieldImpl.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
Data |
RemoteNodeFieldImpl.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
Data |
RemoteClientPartitionedFieldImpl.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
Data |
RemoteClientFieldImpl.derivative(RealTuple location,
RealType[] d_partial_s,
MathType[] derivType_s,
int error_mode)
|
Function |
RemoteNodePartitionedFieldImpl.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
Function |
RemoteNodeFieldImpl.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
Function |
RemoteClientPartitionedFieldImpl.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
Function |
RemoteClientFieldImpl.derivative(RealType d_partial,
MathType derivType,
int error_mode)
|
Data |
UserDummyDataImpl.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
RemoteClientDataImpl.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
| Constructors in visad.cluster with parameters of type MathType | |
|---|---|
ShadowNodeFunctionTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowNodeRealTupleTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowNodeRealTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowNodeSetTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowNodeTupleTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
| Uses of MathType in visad.data |
|---|
| Fields in visad.data declared as MathType | |
|---|---|
protected MathType |
Form.mathType
The MathType of an existing data object. |
| Methods in visad.data that return MathType | |
|---|---|
MathType |
Form.getMathType()
Get the MathType. |
| Methods in visad.data with parameters of type MathType | |
|---|---|
Data |
FileFlatField.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
AreaImageCacheAdapter.binary(Data data,
int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
FileFlatField.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
Data |
AreaImageCacheAdapter.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
|
| Uses of MathType in visad.data.dods |
|---|
| Methods in visad.data.dods that return MathType | |
|---|---|
MathType |
VectorAdapter.getMathType()
Returns the VisAD math-type of this instance. |
abstract MathType |
VariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
UInt32VariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
UInt16VariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
StructureVariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
StringVariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
SequenceVariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
ListVariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
Int32VariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
Int16VariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
GridVariableMapAdapter.getMathType()
|
MathType |
GridVariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
Float64VariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
Float32VariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
ByteVariableAdapter.getMathType()
|
MathType |
BooleanVariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
MathType |
ArrayVariableAdapter.getMathType()
Returns the VisAD MathType of this instance. |
protected static MathType |
Adapter.mathType(MathType[] mathTypes)
Returns the VisAD MathType corresponding to an array of
MathTypes. |
protected static MathType |
VariableAdapter.mathType(VariableAdapter[] adapters)
Returns the VisAD MathType corresponding to an array of adapters
of DODS variables. |
| Methods in visad.data.dods with parameters of type MathType | |
|---|---|
protected static boolean |
Adapter.isFlat(MathType mathType)
Indicates if a given VisAD MathType is "flat" (i.e. comprises a
Real, a RealTuple, or a Tuple of Reals
and RealTuples. |
protected static MathType |
Adapter.mathType(MathType[] mathTypes)
Returns the VisAD MathType corresponding to an array of
MathTypes. |
| Uses of MathType in visad.data.gis |
|---|
| Methods in visad.data.gis with parameters of type MathType | |
|---|---|
FieldImpl |
ArcAsciiGridAdapter.getData(MathType mathType)
Get the ASCIIGRID as a VisAD data object with the specified domain and range. |
| Constructors in visad.data.gis with parameters of type MathType | |
|---|---|
ArcAsciiGridForm(MathType dataType)
Construct a Form for reading in Arc/Info ASCIIGRID files |
|
DemFamily(String name,
MathType dataFormat)
Construct a family of the supported map datatype Forms |
|
| Uses of MathType in visad.data.hdf5 |
|---|
| Methods in visad.data.hdf5 that return MathType | |
|---|---|
MathType |
HDF5GroupAdapted.getMathType()
|
MathType |
HDF5DatasetAdapted.getMathType()
|
MathType |
HDF5DataAdaptable.getMathType()
|
MathType |
HDF5Form.getMathType(HDF5FileAdapted file)
|
| Uses of MathType in visad.data.hdfeos |
|---|
| Methods in visad.data.hdfeos that return MathType | |
|---|---|
MathType |
HdfeosTuple.getType()
|
MathType |
HdfeosFlatField.getType()
|
MathType |
HdfeosField.getType()
|
| Methods in visad.data.hdfeos with parameters of type MathType | |
|---|---|
Set |
GctpMap.getVisADSet(MathType map)
|
| Uses of MathType in visad.data.in |
|---|
| Methods in visad.data.in with parameters of type MathType | |
|---|---|
static MathTypeCondition |
MathTypeCondition.mathTypeCondition(MathType mathType)
Returns an instance of this class. |
| Constructors in visad.data.in with parameters of type MathType | |
|---|---|
MathTypeCondition(MathType mathType)
Constructs from a VisAD math-type. |
|
| Uses of MathType in visad.data.netcdf |
|---|
| Subclasses of MathType in visad.data.netcdf | |
|---|---|
class |
Quantity
The following class represents a quantity -- usually a physical one such as energy, viscosity, or velocity (although an artificial one such as "money" should be possible). |
| Uses of MathType in visad.data.netcdf.in |
|---|
| Methods in visad.data.netcdf.in that return MathType | |
|---|---|
protected MathType |
DefaultView.getDomainType(ucar.netcdf.Dimension[] dims)
Returns the VisAD MathType corresponding to an array of netCDF
dimensions. |
MathType |
VirtualTuple.getType()
Gets the VisAD MathType of this virtual tuple. |
MathType |
VirtualScalar.getType()
Gets the MathType of this scalar. |
MathType |
VirtualField.getType()
Gets the MathType of this virtual Field. |
abstract MathType |
VirtualData.getType()
Gets the VisAD MathType of this virtual, data object. |
| Uses of MathType in visad.data.visad.object |
|---|
| Methods in visad.data.visad.object that return MathType | |
|---|---|
static MathType |
BinaryMathType.read(BinaryReader reader)
|
static MathType[] |
BinaryMathType.readList(BinaryReader reader,
int dim)
|
| Methods in visad.data.visad.object with parameters of type MathType | |
|---|---|
static int |
BinaryMathType.write(BinaryWriter writer,
MathType mt,
Object token)
|
| Uses of MathType in visad.java2d |
|---|
| Methods in visad.java2d that return MathType | |
|---|---|
MathType |
ShadowTypeJ2D.getType()
|
| Constructors in visad.java2d with parameters of type MathType | |
|---|---|
ShadowFunctionOrSetTypeJ2D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowFunctionTypeJ2D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowRealTupleTypeJ2D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowRealTypeJ2D(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowScalarTypeJ2D(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowSetTypeJ2D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowTextTypeJ2D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowTupleTypeJ2D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowTypeJ2D(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
| Uses of MathType in visad.java3d |
|---|
| Methods in visad.java3d that return MathType | |
|---|---|
MathType |
ShadowTypeJ3D.getType()
Get the MathType of the Data |
| Constructors in visad.java3d with parameters of type MathType | |
|---|---|
ShadowAnimationFunctionTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowFunctionOrSetTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowFunctionTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowRealTupleTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowRealTypeJ3D(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowScalarTypeJ3D(MathType type,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowSetTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowTextTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowTupleTypeJ3D(MathType t,
DataDisplayLink link,
ShadowType parent)
|
|
ShadowTypeJ3D(MathType type,
DataDisplayLink link,
ShadowType parent)
Create a new ShadowTypeJ3D |
|
| Uses of MathType in visad.jmet |
|---|
| Methods in visad.jmet with parameters of type MathType | |
|---|---|
static void |
DumpType.dumpMathType(MathType t)
Decomposes a VisAD MathType and lists out information about its components |
static void |
DumpType.dumpMathType(MathType t,
OutputStream uos)
Decomposes a VisAD MathType and lists out information about its components |
| Uses of MathType in visad.meteorology |
|---|
| Methods in visad.meteorology with parameters of type MathType | |
|---|---|
Data |
SingleBandedImageImpl.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
return new SingleBandedImageImpl with value 'op this' |
Data |
SatelliteImage.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
return new SatelliteImage with value 'op this' |
Data |
NavigatedImage.unary(int op,
MathType new_type,
int sampling_mode,
int error_mode)
return new NavigatedImage with value 'op this' |
| Uses of MathType in visad.python |
|---|
| Methods in visad.python that return MathType | |
|---|---|
static MathType |
JPythonMethods.getRangeType(Data data)
Get the range Type for the field |
static MathType |
JPythonMethods.getRangeType(FunctionType type)
get the range Type for the FunctionType |
static MathType |
JPythonMethods.getType(Data data)
Get the MathType of the named VisAD data object |
static MathType |
JPythonMethods.makeType(String s)
Creates a VisAD MathType from the given string |
static MathType |
JPythonMethods.rangeType(Data data)
get the range Type for the field |
| Methods in visad.python with parameters of type MathType | |
|---|---|
static Field |
JPythonMethods.extract(Field data,
MathType t)
Extracts a component of the Field |
static Linear1DSet |
JPythonMethods.makeDomain(MathType type,
double first,
double last,
int length)
Create a Linear1DSet for domain samples |
static Linear2DSet |
JPythonMethods.makeDomain(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2)
Create a Linear2DSet for domain samples |
static Linear3DSet |
JPythonMethods.makeDomain(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
double first3,
double last3,
int length3)
Create a Linear3DSet for domain samples |
static Integer1DSet |
JPythonMethods.makeDomain(MathType type,
int length)
Make an Integer1DSet of given length and MathType |
static Integer2DSet |
JPythonMethods.makeDomain(MathType type,
int lengthX,
int lengthY)
Make an Integer2DSet of given lengths |
static UnionSet |
JPythonMethods.makePairedLines(MathType mt,
double[][] points)
Construct a UnionSet of the given MathType for the pairs of points given |
| Uses of MathType in visad.util |
|---|
| Methods in visad.util that return MathType | |
|---|---|
static MathType |
DataUtility.getRangeType(Function function)
Gets the MathType of the range of a Function. |
static MathType |
DataUtility.simplify(MathType type)
Simplifies a MathType. |
| Methods in visad.util with parameters of type MathType | |
|---|---|
static Field |
DataUtility.ensureRange(Field field,
MathType newRangeType)
Ensures that the range of a Field is a given type. |
static RealTupleType |
DataUtility.ensureRealTupleType(MathType type)
Ensures that a MathType is a RealTupleType. |
static TupleType |
DataUtility.ensureTupleType(MathType type)
Ensures that a MathType is a TupleType. |
static int |
DataUtility.getComponentIndex(Function function,
MathType componentType)
Gets the index of a component in the range of a Function. |
static int |
DataUtility.getComponentIndex(Set set,
MathType componentType)
Gets the index of a component in a Set. |
static int |
DataUtility.getComponentIndex(TupleType tupleType,
MathType componentType)
Gets the index of a component in a TupleType. |
static ScalarMap[] |
DataUtility.guessMaps(MathType[] types,
boolean allow3d)
Attempts to guess a good set of mappings for a display containing Data objects of the given types. |
static MathType |
DataUtility.simplify(MathType type)
Simplifies a MathType. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||