| 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.data |
Provides for importing data to and exporting data from VisAD.
|
| visad.data.visad |
Provides for importing and exporting serialized Java object files
into and out of VisAD.
|
| visad.data.visad.object | |
| visad.meteorology |
Provides classes that are useful in the field of meteorology.
|
| Modifier and Type | Method and Description |
|---|---|
static ErrorEstimate[] |
ErrorEstimate.copyErrorsArray(ErrorEstimate[] errors)
copy a ErrorEstimate[] array; this is a helper for Set,
FlatField, etc
|
ErrorEstimate |
RealIface.getError()
Returns the uncertainty in the numeric value of this instance.
|
ErrorEstimate |
Real.getError() |
ErrorEstimate[] |
RealTupleIface.getErrors()
Returns the uncertainties of the components.
|
ErrorEstimate[] |
RealTuple.getErrors()
get ErrorEstimates of Real components
|
ErrorEstimate[] |
RemoteFlatFieldImpl.getRangeErrors()
return array of ErrorEstimates associated with each
RealType component of range; each ErrorEstimate is a
mean error for all samples of a range RealType
component
|
ErrorEstimate[] |
FlatFieldIface.getRangeErrors()
return array of ErrorEstimates associated with each
RealType component of range; each ErrorEstimate is a
mean error for all samples of a range RealType
component
|
ErrorEstimate[] |
FlatField.getRangeErrors()
return array of ErrorEstimates associated with each
RealType component of range; each ErrorEstimate is a
mean error for all samples of a range RealType
component
|
ErrorEstimate[] |
SetIface.getSetErrors()
Returns the error estimates of the samples in the set.
|
ErrorEstimate[] |
Set.getSetErrors()
Returns the error estimates of the values in the set.
|
| Modifier and Type | Method and Description |
|---|---|
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 ErrorEstimate[] |
ErrorEstimate.copyErrorsArray(ErrorEstimate[] errors)
copy a ErrorEstimate[] array; this is a helper for Set,
FlatField, etc
|
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,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors) |
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,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
General factory method for creating the proper integer set
(Integer1DSet, Integer2DSet, etc.).
|
protected static void |
FlatField.makeRational(double[][] values,
Unit[] units,
ErrorEstimate[] errors)
Ensure that numeric values and units are in rational form, i.e. one in
which ratios of data values make sense (e.g.
|
protected static void |
FlatField.makeRational(float[][] values,
Unit[] units,
ErrorEstimate[] errors) |
void |
RemoteFlatFieldImpl.setRangeErrors(ErrorEstimate[] errors)
set ErrorEstimates associated with each RealType
component of range
|
void |
FlatFieldIface.setRangeErrors(ErrorEstimate[] errors)
set ErrorEstimates associated with each RealType
component of range
|
void |
FlatField.setRangeErrors(ErrorEstimate[] errors)
Sets the ErrorEstimates associated with each RealType component of the
range.
|
void |
RemoteFlatFieldImpl.setSamples(double[][] range,
ErrorEstimate[] errors,
boolean copy)
set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet
|
void |
ImageFlatField.setSamples(double[][] range,
ErrorEstimate[] errors,
boolean copy) |
void |
FlatFieldIface.setSamples(double[][] range,
ErrorEstimate[] errors,
boolean copy)
set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet
|
void |
FlatField.setSamples(double[][] range,
ErrorEstimate[] errors,
boolean copy)
set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet
|
void |
RemoteFlatFieldImpl.setSamples(float[][] range,
ErrorEstimate[] errors,
boolean copy)
set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet
|
void |
ImageFlatField.setSamples(float[][] range,
ErrorEstimate[] errors,
boolean copy) |
void |
FlatFieldIface.setSamples(float[][] range,
ErrorEstimate[] errors,
boolean copy)
set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet
|
void |
FlatField.setSamples(float[][] range,
ErrorEstimate[] errors,
boolean copy)
set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet
|
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two
RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two
RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value,
boolean copy)
Transforms double-valued coordinates between two
RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value,
boolean copy)
Transforms double-valued coordinates between two
RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two
RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two
RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value,
boolean copy)
Transforms float-valued coordinates between two
RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value,
boolean copy)
Transforms float-valued coordinates between two
RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two
RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two
RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two
RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two
RealTupleTypes. |
static double[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
double[] value)
Transform double values and (optionally) error estimates.
|
static double[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
double[] value)
Transform double values and (optionally) error estimates.
|
static double[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
double[] value,
boolean copy)
Transform double values and (optionally) error estimates.
|
static double[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
double[] value,
boolean copy)
Transform double values and (optionally) error estimates.
|
static float[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
float[] value)
Transform float values and (optionally) error estimates.
|
static float[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
float[] value)
Transform float values and (optionally) error estimates.
|
static float[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
float[] value,
boolean copy)
Transform float values and (optionally) error estimates.
|
static float[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
float[] value,
boolean copy)
Transform float values and (optionally) error estimates.
|
RealTuple |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
double[][] inloc,
double[][] outloc,
RealTuple tuple)
transform a single vector in a RealTuple, based on a coordinate
transform of the field domain.
|
abstract double[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
abstract double[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
abstract double[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
double[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
double[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
double[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
double[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
double[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
double[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
float[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value) |
float[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value) |
float[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value) |
float[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
float[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
float[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
float[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
float[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
float[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a
coordinate transform of the field domain.
|
RealTuple |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
float[][] inloc,
float[][] outloc,
RealTuple tuple) |
| Constructor and Description |
|---|
ErrorEstimate(double[] value,
Unit u,
int op,
ErrorEstimate a,
ErrorEstimate b,
int error_mode)
construct Error for an array of values that is the result of a binary
operator; a and b are the ErrorEstimate-s for the operands
|
ErrorEstimate(double[] value,
Unit u,
int op,
ErrorEstimate a,
int error_mode)
construct Error for an array of values that is the result of a unary
operator; a is the ErrorEstimate for the operand
|
ErrorEstimate(double value,
Unit u,
int op,
ErrorEstimate a,
ErrorEstimate b,
int error_mode)
construct an ErrorEstimate for a value that is the result of a
binary operator; a and b are the ErrorEstimate-s for the operands
|
ErrorEstimate(double value,
Unit u,
int op,
ErrorEstimate a,
int error_mode)
construct an ErrorEstimate for a value that is the result of a
unary operator; a is the ErrorEstimate for the operand
|
ErrorEstimate(ErrorEstimate field_error,
ErrorEstimate sample_error,
double val,
int inc)
construct an ErrorEstimate from a Field ErrorEstimate, a sample
ErrorEstimate, the sample value, and an increment for NumberNotMissing;
used by FlatField.setSample
|
ErrorEstimate(float[] value,
Unit u,
int op,
ErrorEstimate a,
ErrorEstimate b,
int error_mode)
construct Error for an array of values that is the result of a binary
operator; a and b are the ErrorEstimate-s for the operands
|
ErrorEstimate(float[] value,
Unit u,
int op,
ErrorEstimate a,
int error_mode)
construct Error for an array of values that is the result of a unary
operator; a is the ErrorEstimate for the operand
|
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors) |
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,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors) |
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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
|
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
|
Real(RealType type,
double value,
Unit u,
ErrorEstimate error)
Constructs a Real object.
|
Real(RealType type,
double value,
Unit u,
ErrorEstimate error,
boolean checkUnit)
trusted constructor for other constructors
|
SampledSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors) |
SampledSet(MathType type,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors) |
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.
|
SimpleSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors) |
SimpleSet(MathType type,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors) |
SingletonSet(RealTuple d,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a SingletonSet with the single sample given by a RealTuple,
and a non-default CoordinateSystem, Units and ErrorEstimates.
|
SingletonSet(RealTupleType type,
double[] values,
CoordinateSystem coordSys,
Unit[] units,
ErrorEstimate[] errors)
Constructs from a type, numeric values, units, coordinate system, and
error estimates.
|
UnionSet(MathType type,
SampledSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy) |
| Modifier and Type | Method and Description |
|---|---|
void |
EmptyDataProcessor.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token) |
void |
DataProcessor.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token) |
abstract void |
BaseDataProcessor.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token) |
void |
EmptyDataProcessor.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token) |
void |
DataProcessor.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token) |
abstract void |
BaseDataProcessor.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token) |
void |
EmptyDataProcessor.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token) |
void |
DataProcessor.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token) |
abstract void |
BaseDataProcessor.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token) |
void |
EmptyDataProcessor.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token) |
void |
DataProcessor.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token) |
abstract void |
BaseDataProcessor.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token) |
void |
EmptyDataProcessor.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token) |
void |
DataProcessor.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token) |
abstract void |
BaseDataProcessor.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token) |
void |
EmptyDataProcessor.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token) |
void |
DataProcessor.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token) |
abstract void |
BaseDataProcessor.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token) |
void |
EmptyDataProcessor.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token) |
void |
DataProcessor.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token) |
abstract void |
BaseDataProcessor.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token) |
void |
EmptyDataProcessor.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token) |
void |
DataProcessor.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token) |
abstract void |
BaseDataProcessor.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token) |
void |
EmptyDataProcessor.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token) |
void |
DataProcessor.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token) |
abstract void |
BaseDataProcessor.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token) |
void |
EmptyDataProcessor.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token) |
void |
DataProcessor.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token) |
abstract void |
BaseDataProcessor.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token) |
void |
EmptyDataProcessor.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token) |
void |
DataProcessor.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token) |
abstract void |
BaseDataProcessor.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token) |
void |
EmptyDataProcessor.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token) |
void |
DataProcessor.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token) |
abstract void |
BaseDataProcessor.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token) |
void |
EmptyDataProcessor.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token) |
void |
DataProcessor.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token) |
abstract void |
BaseDataProcessor.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token) |
void |
EmptyDataProcessor.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token) |
void |
DataProcessor.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token) |
abstract void |
BaseDataProcessor.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token) |
void |
EmptyDataProcessor.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token) |
void |
DataProcessor.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token) |
abstract void |
BaseDataProcessor.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token) |
void |
EmptyDataProcessor.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token) |
void |
DataProcessor.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token) |
abstract void |
BaseDataProcessor.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token) |
void |
EmptyDataProcessor.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token) |
void |
DataProcessor.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token) |
abstract void |
BaseDataProcessor.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token) |
void |
EmptyDataProcessor.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token) |
void |
DataProcessor.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token) |
abstract void |
BaseDataProcessor.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token) |
void |
EmptyDataProcessor.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token) |
void |
DataProcessor.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token) |
abstract void |
BaseDataProcessor.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token) |
void |
EmptyDataProcessor.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token) |
void |
DataProcessor.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token) |
abstract void |
BaseDataProcessor.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token) |
void |
EmptyDataProcessor.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token) |
void |
DataProcessor.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token) |
abstract void |
BaseDataProcessor.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token) |
void |
EmptyDataProcessor.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token) |
void |
DataProcessor.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token) |
abstract void |
BaseDataProcessor.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token) |
void |
EmptyDataProcessor.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token) |
void |
DataProcessor.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token) |
abstract void |
BaseDataProcessor.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token) |
void |
EmptyDataProcessor.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token) |
void |
DataProcessor.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token) |
abstract void |
BaseDataProcessor.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token) |
void |
EmptyDataProcessor.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token) |
void |
DataProcessor.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token) |
abstract void |
BaseDataProcessor.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token) |
void |
AreaImageCacheAdapter.setSamples(double[][] range,
ErrorEstimate[] errors,
boolean copy) |
void |
CachedFlatField.setSamples(float[][] values,
ErrorEstimate[] errors,
boolean copy)
Set the sample
|
| Modifier and Type | Method and Description |
|---|---|
void |
BinaryWriter.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token) |
void |
BinarySizer.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token) |
void |
BinaryWriter.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token) |
void |
BinarySizer.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token) |
void |
BinaryWriter.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token) |
void |
BinarySizer.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token) |
void |
BinaryWriter.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token) |
void |
BinarySizer.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token) |
void |
BinaryWriter.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token) |
void |
BinarySizer.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token) |
void |
BinaryWriter.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token) |
void |
BinarySizer.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token) |
void |
BinaryWriter.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token) |
void |
BinarySizer.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token) |
void |
BinaryWriter.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token) |
void |
BinarySizer.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token) |
void |
BinaryWriter.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token) |
void |
BinarySizer.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token) |
void |
BinaryWriter.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token) |
void |
BinarySizer.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token) |
void |
BinaryWriter.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token) |
void |
BinarySizer.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token) |
void |
BinaryWriter.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token) |
void |
BinarySizer.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token) |
void |
BinaryWriter.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token) |
void |
BinarySizer.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token) |
void |
BinaryWriter.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token) |
void |
BinarySizer.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token) |
void |
BinaryWriter.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token) |
void |
BinarySizer.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token) |
void |
BinaryWriter.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token) |
void |
BinarySizer.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token) |
void |
BinaryWriter.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token) |
void |
BinarySizer.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token) |
void |
BinaryWriter.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token) |
void |
BinarySizer.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token) |
void |
BinaryWriter.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token) |
void |
BinarySizer.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token) |
void |
BinaryWriter.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token) |
void |
BinarySizer.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token) |
void |
BinaryWriter.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token) |
void |
BinarySizer.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token) |
void |
BinaryWriter.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token) |
void |
BinarySizer.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token) |
void |
BinaryWriter.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token) |
void |
BinarySizer.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token) |
void |
BinaryWriter.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token) |
void |
BinarySizer.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token) |
void |
BinaryWriter.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token) |
void |
BinarySizer.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token) |
| Modifier and Type | Method and Description |
|---|---|
static ErrorEstimate |
BinaryErrorEstimate.read(BinaryReader reader) |
static ErrorEstimate[] |
BinaryErrorEstimate.readList(BinaryReader reader) |
| Modifier and Type | Method and Description |
|---|---|
static int |
BinaryLinearSet.computeBytes(boolean matchedTypes,
double[] firsts,
double[] lasts,
int[] lengths,
Linear1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors) |
static int |
BinaryIntegerSet.computeBytes(boolean matchedTypes,
int[] lengths,
Integer1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors) |
static int |
BinaryGriddedDoubleSet.computeBytes(double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors) |
static int |
BinaryErrorEstimate.computeBytes(ErrorEstimate[] array) |
static int |
BinaryIrregularSet.computeBytes(float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay) |
static int |
BinaryGriddedSet.computeBytes(float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors) |
static int |
BinarySingletonSet.computeBytes(RealTupleType sampleType,
Real[] sampleReals,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors) |
static int |
BinaryProductSet.computeBytes(SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors) |
static int |
BinaryReal.computeBytes(Unit u,
ErrorEstimate err) |
static int[] |
BinaryErrorEstimate.lookupList(BinaryObjectCache cache,
ErrorEstimate[] errors) |
static int |
BinaryErrorEstimate.write(BinaryWriter writer,
ErrorEstimate error,
Object token) |
static void |
BinarySingletonSet.write(BinaryWriter writer,
RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token) |
static void |
BinaryReal.write(BinaryWriter writer,
RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token) |
static void |
BinaryGriddedDoubleSet.write(BinaryWriter writer,
SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token) |
static void |
BinaryLinearSet.write(BinaryWriter writer,
SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
Linear1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token) |
static void |
BinaryIrregularSet.write(BinaryWriter writer,
SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Class canonicalClass,
byte dataType,
Object token) |
static void |
BinaryGriddedSet.write(BinaryWriter writer,
SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token) |
static void |
BinaryIntegerSet.write(BinaryWriter writer,
SetType type,
int[] lengths,
Integer1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token) |
static void |
BinaryProductSet.write(BinaryWriter writer,
SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token) |
static void |
BinarySingletonSet.writeDependentData(BinaryWriter writer,
RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token) |
static void |
BinaryReal.writeDependentData(BinaryWriter writer,
RealType type,
Unit unit,
ErrorEstimate error,
Real real,
Object token) |
static void |
BinaryGriddedSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token) |
static void |
BinaryGriddedDoubleSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token) |
static void |
BinaryIrregularSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IrregularSet set,
Class canonicalClass,
Object token) |
static void |
BinaryIntegerSet.writeDependentData(BinaryWriter writer,
SetType type,
Integer1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token) |
static void |
BinaryLinearSet.writeDependentData(BinaryWriter writer,
SetType type,
Linear1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token) |
static void |
BinaryProductSet.writeDependentData(BinaryWriter writer,
SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token) |
static int[] |
BinaryErrorEstimate.writeList(BinaryWriter writer,
ErrorEstimate[] errors,
Object token) |
| Modifier and Type | Method and Description |
|---|---|
void |
SingleBandedImageImpl.setSamples(double[][] range,
ErrorEstimate[] errors,
boolean copy)
Set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet.
|
void |
SingleBandedImageImpl.setSamples(float[][] range,
ErrorEstimate[] errors,
boolean copy)
Set the range values of the function including ErrorEstimate-s;
the order of range values must be the same as the order of
domain indices in the DomainSet.
|