| Package | Description |
|---|---|
| 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.
|
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
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.
|
| Constructor and Description |
|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
MathType |
TCData.getType() |
| Modifier and Type | Method and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
MathType |
UserDummyDataImpl.getType() |
MathType |
RemoteNodeTupleImpl.getType() |
MathType |
RemoteNodePartitionedFieldImpl.getType() |
MathType |
RemoteNodeFieldImpl.getType() |
MathType |
RemoteClientTupleImpl.getType() |
MathType |
RemoteClientPartitionedFieldImpl.getType() |
MathType |
RemoteClientFieldImpl.getType() |
| Modifier and Type | Method and Description |
|---|---|
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) |
| Constructor and Description |
|---|
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) |
| Modifier and Type | Field and Description |
|---|---|
protected MathType |
Form.mathType
The MathType of an existing data object.
|
| Modifier and Type | Method and Description |
|---|---|
MathType |
Form.getMathType()
Get the MathType.
|
| Modifier and Type | Method and Description |
|---|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
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. |
| Modifier and Type | Method and Description |
|---|---|
protected static boolean |
Adapter.isFlat(MathType mathType)
|
protected static MathType |
Adapter.mathType(MathType[] mathTypes)
Returns the VisAD
MathType corresponding to an array of
MathTypes. |
| Modifier and Type | Method and Description |
|---|---|
FieldImpl |
ArcAsciiGridAdapter.getData(MathType mathType)
Get the ASCIIGRID as a VisAD data object with the specified domain
and range.
|
| Constructor and Description |
|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
MathType |
HDF5GroupAdapted.getMathType() |
MathType |
HDF5DatasetAdapted.getMathType() |
MathType |
HDF5DataAdaptable.getMathType() |
MathType |
HDF5Form.getMathType(HDF5FileAdapted file) |
| Modifier and Type | Method and Description |
|---|---|
MathType |
HdfeosTuple.getType() |
MathType |
HdfeosFlatField.getType() |
MathType |
HdfeosField.getType() |
| Modifier and Type | Method and Description |
|---|---|
Set |
GctpMap.getVisADSet(MathType map) |
| Modifier and Type | Method and Description |
|---|---|
static MathTypeCondition |
MathTypeCondition.mathTypeCondition(MathType mathType)
Returns an instance of this class.
|
| Constructor and Description |
|---|
MathTypeCondition(MathType mathType)
Constructs from a VisAD math-type.
|
| Modifier and Type | Class and Description |
|---|---|
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).
|
| Modifier and Type | Method and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
static MathType |
BinaryMathType.read(BinaryReader reader) |
static MathType[] |
BinaryMathType.readList(BinaryReader reader,
int dim) |
| Modifier and Type | Method and Description |
|---|---|
static int |
BinaryMathType.write(BinaryWriter writer,
MathType mt,
Object token) |
| Modifier and Type | Method and Description |
|---|---|
MathType |
ShadowTypeJ2D.getType() |
| Constructor and Description |
|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
MathType |
ShadowTypeJ3D.getType()
Get the MathType of the Data
|
| Constructor and Description |
|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
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'
|
| Modifier and Type | Method and Description |
|---|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
static MathType |
DataUtility.getRangeType(Function function)
Gets the MathType of the range of a Function.
|
static MathType |
DataUtility.simplify(MathType type)
Simplifies a MathType.
|
| Modifier and Type | Method and Description |
|---|---|
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.
|