Uses of Class
visad.ErrorEstimate

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.