|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use ErrorEstimate | |
|---|---|
| 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. |
| Uses of ErrorEstimate in visad |
|---|
| Methods in visad that return ErrorEstimate | |
|---|---|
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. |
| Methods in visad with parameters of type ErrorEstimate | |
|---|---|
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)
|
| Constructors in visad with parameters of type ErrorEstimate | |
|---|---|
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)
|
|
| Uses of ErrorEstimate in visad.data |
|---|
| Methods in visad.data with parameters of type ErrorEstimate | |
|---|---|
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 |
| Uses of ErrorEstimate in visad.data.visad |
|---|
| Methods in visad.data.visad with parameters of type ErrorEstimate | |
|---|---|
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)
|
| Uses of ErrorEstimate in visad.data.visad.object |
|---|
| Methods in visad.data.visad.object that return ErrorEstimate | |
|---|---|
static ErrorEstimate |
BinaryErrorEstimate.read(BinaryReader reader)
|
static ErrorEstimate[] |
BinaryErrorEstimate.readList(BinaryReader reader)
|
| Methods in visad.data.visad.object with parameters of type ErrorEstimate | |
|---|---|
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)
|
| Uses of ErrorEstimate in visad.meteorology |
|---|
| Methods in visad.meteorology with parameters of type ErrorEstimate | |
|---|---|
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. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||