## visad
Class FlatField

    java.lang.Object
      visad.ThingImpl
          visad.DataImpl
              visad.FunctionImpl
                  visad.FieldImpl
                      visad.FlatField

All Implemented Interfaces:
  Cloneable, Data, Field, FlatFieldIface, Function, Serializable, Thing

Direct Known Subclasses:
  FileFlatField, ImageFlatField, JamaMatrix, SingleBandedImageImpl

public class FlatField
extends FieldImpl
implements FlatFieldIface

FlatField is the VisAD class for finite samplings of functions whose range type and range coordinate systems are simple enough to allow efficient representation. The DomainSet, DomainCoordinateSystem, RangeSet, RangeCoordinateSystem and RangeCoordinateSystems variables of FlatField are immutable.

A FlatField range type may be either a RealType (for a function with range = R), a RealTupleType (for a function with range = R^n for n > 0), or a TupleType of RealType-s and RealTupleType-s..

VisAD avoids invoking methods once per datum through the use of FlatField's. These are logically Field's of Tuple's of RealType's and RealTupleType's. Internally FlatField's are stored as arrays of numerical values, rather than the arrays of data objects stored in Field's. Many of the methods in the FlatField class and in other classes (e.g., CoordinateTransform, Set, Unit) process data in the form double[Dimension][Length] where Length is the number of samples in a Field and Dimension is the number of Tuple elements in the Field range values. Note that the order of the Length and Dimension indices are reversed as array indices. This allows efficient processing of long columns of Field value components. For example, if Latitude is one component of Field values, then any computation involving Latitude can be applied in a tight loop to all Latitude's in the Field.

FlatField's support range types more general than RealTuple's. To understand the motive, consider a set of observations that include Latitude, Longitude, Altitude, Pressure, Temperature, etc. We can organize these as a Field whose range values have the Tuple type:

         (Latitude, Longitude, Altitude, Pressure, Temperature, ...)

However, in order to declare that (Latitude, Longitude, Altitude) is a coordinate system with coordinate transform functions to other spatial coordinate systems, we need to organize:

         (Latitude, Longitude, Altitude)

as a RealTupleType. Hence the range type of the Field of observations must be:

         ((Latitude, Longitude, Altitude), Pressure, Temperature, ...)

which is not a RealTupleType (since one of its components is a RealTupleType). In order to process such data efficiently, FlatField's must support range types that are Tuple's of RealType's and RealTupleType's.

See Also:
  Serialized Form

Nested Class Summary

Nested classes inherited from class visad.DataImpl
`DataImpl.Syncher`

Nested classes inherited from class visad.ThingImpl
`ThingImpl.RemotePair`

Field Summary
`protected CoordinateSystem` `RangeCoordinateSystem`
`protected CoordinateSystem[]` `RangeCoordinateSystems`
`protected Unit[]` `RangeUnits`
`protected int` `TupleDimension`

Fields inherited from class visad.FieldImpl
`DomainCoordinateSystem, DomainSet, DomainUnits, Length`

Fields inherited from class visad.DataImpl
`Type`

Fields inherited from interface visad.Data

`ABS, ACOS, ACOS_DEGREES, ADD, ASIN, ASIN_DEGREES, ATAN, ATAN_DEGREES, ATAN2, ATAN2_DEGREES, CEIL, COS, COS_DEGREES, DEGREES_TO_RADIANS, DEPENDENT, DIVIDE, EXP, FLOOR, INDEPENDENT, INV_ATAN2, INV_ATAN2_DEGREES, INV_DIVIDE, INV_POW, INV_REMAINDER, INV_SUBTRACT, LOG, MAX, MIN, MULTIPLY, NEAREST_NEIGHBOR, NEGATE, NO_ERRORS, NOP, POW, RADIANS_TO_DEGREES, REMAINDER, RINT, ROUND, SIN, SIN_DEGREES, SQRT, SUBTRACT, TAN, TAN_DEGREES, WEIGHTED_AVERAGE`

Constructor Summary
`FlatField(FunctionType type)` Constructs a FlatField from a function type.
`FlatField(FunctionType type, Set domain_set)` Constructs a FlatField from a function type and a (non-default) domain Set.
`FlatField(FunctionType type, Set domain_set, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)` Constructs a FlatField from a function type, a sampling set of the domain, coordinate systems for the range components, sampling sets for the range components, and units for the range components.
`FlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)` Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, coordinate systems for the range components, sampling sets for the range components, and units for the range components.
`FlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, Set[] range_sets, Unit[] units)` Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, sampling sets for the range components, and units for the range components.

Method Summary
`Data` `adjustSamplingError(Data error, int error_mode)` return a FlatField that clones this, except its ErrorEstimate-s are adjusted for sampling errors in error
`Data` `binary(Data data, int op, MathType new_type, int sampling_mode, int error_mode)` Return new Field with value 'this op data'.
`void` `clearMissing()` Mark this FlatField as non-missing
`Object` `clone()` Clones this instance.
`protected FlatField` `cloneDouble(MathType f_type, Unit[] units, ErrorEstimate[] errors)`
`protected FlatField` `cloneDouble(MathType f_type, Unit[] units, ErrorEstimate[] errors, double[][] newValues)`
`protected FlatField` `cloneFloat(MathType f_type, Unit[] units, ErrorEstimate[] errors)`
`protected FlatField` `cloneFloat(MathType f_type, Unit[] units, ErrorEstimate[] errors, float[][] newValues)`
`DataShadow` `computeRanges(ShadowType type, DataShadow shadow)` Recursive version of computeRanges(), called down through Data object tree.
`Field` `convertToField()` convert this FlatField to a (non-Flat) FieldImpl
`Data` `derivative(int error_mode)` return the tuple of derivatives of this Function with respect to all RealType components of its domain RealTuple; propogate errors according to error_mode
`Data` `derivative(MathType[] derivType_s, int error_mode)` return the tuple of derivatives of this Function with respect to all RealType components of its domain RealTuple; set result MathTypes of tuple components to derivType_s; propogate errors according to error_mode

`Data`

`derivative(RealTuple location, RealType[] d_partial_s, MathType[] derivType_s, int error_mode)`
return the tuple of derivatives of this Function with respect to the RealTypes in d_partial_s; the RealTypes in d_partial_s may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; set result MathTypes of tuple components to derivType_s; propogate errors according to error_mode

`Function` `derivative(RealType d_partial, int error_mode)` return the derivative of this Function with respect to d_partial; d_partial may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; propogate errors according to error_mode
`Function` `derivative(RealType d_partial, MathType derivType, int error_mode)` return the derivative of this Function with respect to d_partial; set result MathType to derivType; d_partial may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; propogate errors according to error_mode
`boolean` `equals(Object obj)`
`Field` `extract(int component)` extract field from this[].component; this is OK, when we get around to it
`static void` `fillField(FlatField image, double step, double half)`
`Unit[]` `getDefaultRangeUnits()` Get default range Unit-s for 'Flat' components.
`float[][]` `getFloats()` Returns the range values in their default units as floats.
`float[][]` `getFloats(boolean copy)` Returns the range values in their default units as floats.
`CoordinateSystem[]` `getRangeCoordinateSystem()` Returns the range CoordinateSystem assuming that the range type is a RealTupleType (and throws a TypeException if its not).
`CoordinateSystem[]` `getRangeCoordinateSystem(int i)` Returns the CoordinateSystem of a component of the range.
`int` `getRangeDimension()` Gets the number of components in the "flat" range.
`ErrorEstimate[]` `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
`Set[]` `getRangeSets()` Returns the sampling set of each flat component.
`Unit[][]` `getRangeUnits()` return array of Units associated with each RealType component of range; these may differ from default Units of range RealTypes, but must be convertable; the second index has length = 1 (since all samples have the same Units)
`Data` `getSample(int index)` Get the range value at the index-th sample.
`Data` `getSample(int index, boolean metadataOnly)` A stub routine which simply invokes `getSample` to override `FieldImpl.getSample`
`String[][]` `getStringValues()` Get String values for Text components
`double[][]` `getValues()` Returns the range values in their default units as doubles.
`double[][]` `getValues(boolean copy)` Returns the range values in their default units as doubles.
`double[]` `getValues(int s_index)` Get values for 'Flat' components in default range Unit-s.
`byte[][]` `grabBytes()`
`boolean` `isFlatField()` return true if this a FlatField or a RemoteField adapting a FlatField
`boolean` `isMissing()` Test whether range values are missing
`String` `longString(String pre)`
`static void` `main(String[] args)` run 'java visad.FlatField' to test the FlatField class
`static FlatField` `makeField(FunctionType type, int length, boolean irregular)` construct a FlatField of given type; used for testing
`static FlatField` `makeField1(FunctionType type, double first1, double last1, int length1, double first2, double last2, int length2)` construct a FlatField with a 2-D domain and a 1-D range; used for testing
`static FlatField` `makeField2(FunctionType type, double first1, double last1, int length1, double first2, double last2, int length2)` construct a FlatField with a 2-D domain and a 2-D range; used for testing
`(package private) static FlatField` `makeRandomField2(FunctionType type, double first1, double last1, int length1, double first2, double last2, int length2)` construct a FlatField with a 2-D domain and a 2-D range and random values; used for testing
`protected static void` `makeRational(double[][] values, Unit[] units, ErrorEstimate[] errors)` Ensure that numeric values and units are in rational form, i.e.
`protected static void` `makeRational(float[][] values, Unit[] units, ErrorEstimate[] errors)`
`protected void` `pr(String message)`
`Field` `resample(Set set, int sampling_mode, int error_mode)` Resamples the range to domain samples of a given set.
`void` `setRangeErrors(ErrorEstimate[] errors)` Sets the ErrorEstimates associated with each RealType component of the range.
`void` `setSample(int index, Data range)` Set the range value at the index-th sample
`void` `setSample(int index, Data range, boolean copy)` Set the range value at the index-th sample
`void` `setSamples(Data[] range, boolean copy)` set the range values of the function; the order of range values must be the same as the order of domain indices in the DomainSet; copy argument included for consistency with Field, but ignored
`void` `setSamples(double[][] range)` set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet
`void` `setSamples(double[][] range, boolean copy)` set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true
`void` `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` `setSamples(float[][] range)` set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet
`void` `setSamples(float[][] range, boolean copy)` set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true
`void` `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` `setSamples(int[] indices, double[][] range)`
`void` `setSamples(int start, double[][] range)` update a subset of a FlatField's range samples, where start is the index of the first sample to update and range[0].length is the number of samples to update; the array is dimensioned double[number_of_range_components][number_of_range_samples]
`String` `toString()`
`Data` `unary(int op, MathType new_type, int sampling_mode, int error_mode)` Return new FlatField with value 'this op'.
`float[][]` `unpackFloats()` unpack an array of floats from field sample values according to the RangeSet-s; returns a copy
`protected float[][]` `unpackFloats(boolean copy)` unpack an array of floats from field sample values according to the RangeSet-s; returns a copy if copy == true
`protected float[]` `unpackFloats(int s_index)`
`protected double[]` `unpackOneRangeComp(int comp)`
`double[][]` `unpackValues()` unpack an array of doubles from field sample values according to the RangeSet-s; returns a copy
`protected double[][]` `unpackValues(boolean copy)` Unpacks an array of doubles from field sample values according to the RangeSet-s; returns a copy if copy == true.
`protected double[]` `unpackValues(int s_index)`
`(package private) String` `valuesString()`

Methods inherited from class visad.FieldImpl
`__getitem__, __len__, __setitem__, __setitem__, combine, combine, combine, combine, combine, domainEnumeration, domainFactor, domainFactor, domainMultiply, domainMultiply, domainMultiply, domainMultiply, extract, extract, getDomainCoordinateSystem, getDomainSet, getDomainUnits, getLength, setSample, setSample, setSample, setSamples`

Methods inherited from class visad.FunctionImpl
`__getitem__, __getitem__, evaluate, evaluate, evaluate, evaluate, getDomainDimension, resample`

Methods inherited from class visad.DataImpl

`__add__, __add__, __div__, __div__, __mod__, __mod__, __mul__, __mul__, __neg__, __pow__, __pow__, __radd__, __rdiv__, __rmod__, __rmul__, __rpow__, __rsub__, __sub__, __sub__, abs, abs, acos, acos, acosDegrees, acosDegrees, add, add, asin, asin, asinDegrees, asinDegrees, atan, atan, atan2, atan2, atan2Degrees, atan2Degrees, atanDegrees, atanDegrees, binary, ceil, ceil, changeMathType, computeRanges, computeRanges, computeReferenceRanges, cos, cos, cosDegrees, cosDegrees, dataClone, divide, divide, exp, exp, floor, floor, getType, invertOp, local, log, log, longString, max, max, min, min, multiply, multiply, negate, negate, notifyReferences, pow, pow, remainder, remainder, rint, rint, round, round, setParent, sin, sin, sinDegrees, sinDegrees, sqrt, sqrt, subtract, subtract, tan, tan, tanDegrees, tanDegrees, unary`

Methods inherited from class visad.ThingImpl
`adaptedAddReference, adaptedRemoveReference, addReference, removeReference`

Methods inherited from class java.lang.Object
`finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface visad.Field
`domainEnumeration, domainFactor, domainMultiply, domainMultiply, getDomainSet, getLength, setSample, setSample`

Methods inherited from interface visad.Function
`evaluate, evaluate, evaluate, evaluate, getDomainCoordinateSystem, getDomainDimension, getDomainUnits, resample`

Methods inherited from interface visad.Data

`abs, abs, acos, acos, acosDegrees, acosDegrees, add, add, asin, asin, asinDegrees, asinDegrees, atan, atan, atan2, atan2, atan2Degrees, atan2Degrees, atanDegrees, atanDegrees, binary, ceil, ceil, changeMathType, computeRanges, computeRanges, cos, cos, cosDegrees, cosDegrees, dataClone, divide, divide, exp, exp, floor, floor, getType, local, log, log, longString, max, max, min, min, multiply, multiply, negate, negate, pow, pow, remainder, remainder, rint, rint, round, round, sin, sin, sinDegrees, sinDegrees, sqrt, sqrt, subtract, subtract, tan, tan, tanDegrees, tanDegrees, unary`

Methods inherited from interface visad.Thing
`addReference, removeReference`

Field Detail

### TupleDimension

    protected int TupleDimension

### RangeCoordinateSystem

    protected CoordinateSystem RangeCoordinateSystem

### RangeCoordinateSystems

    protected CoordinateSystem[] RangeCoordinateSystems

### RangeUnits

    protected Unit[] RangeUnits

Constructor Detail

### FlatField

    public FlatField(FunctionType type)
              throws VisADException

  Constructs a FlatField from a function type. The domain Set is the default Set of the function domain.

Parameters:
  `type` - The type of the function.
Throws:
  `VisADException` - Couldn't create necessary VisAD object.

### FlatField

    public FlatField(FunctionType type,
                     Set domain_set)
              throws VisADException

  Constructs a FlatField from a function type and a (non-default) domain Set.

Parameters:
  `type` - The type of the function.
  `domain_set` - The sampling set of the domain. May be `null`, in which case the sampling set is the default Set of the function domain.
Throws:
  `VisADException` - Couldn't create necessary VisAD object.

### FlatField

    public FlatField(FunctionType type,
                     Set domain_set,
                     CoordinateSystem range_coord_sys,
                     Set[] range_sets,
                     Unit[] units)
              throws VisADException

  Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, sampling sets for the range components, and units for the range components.

Parameters:
  `type` - The type of the function.
  `domain_set` - The sampling set of the domain. May be `null`, in which case the sampling set is set to the default sampling set of the function domain (i.e. `type.getDomain().getDefaultSet()`).
  `range_coord_sys` - Optional coordinate system for the range. May be `null`. If non-`null` , then the range of the function shall be a RealTuple (i.e. `type.getRange() instanceof RealTuple` shall be true) and the reference coordinate system of the range coordinate system shall be the same as the reference coordiinate system of the function range (i.e. `range_coord_sys().getReference().equals( ((RealTuple)type.getRange()).getReference())` shall be true).
  `range_sets` - The sampling sets of the (flat) range components. May be `null`, in which case the default sampling sets of the range component RealType-s are used (i.e. `((RealType)type.getFlatRange().getComponent(i)) .getDefaultSet()` for all `i` in the flat range). If non-`null`, then the `i`th flat range component values are stored in bytes if `range_sets[i].getLength() < 256`, stored in shorts if `range_sets[i].getLength() < 65536`, etc.
  `units` - The units of the (flat) range components. May be `null`, in which case the default units of the flat range RealType-s are used.
Throws:
  `VisADException` - Couldn't create necessary VisAD object.

### FlatField

    public FlatField(FunctionType type,
                     Set domain_set,
                     CoordinateSystem[] range_coord_syses,
                     Set[] range_sets,
                     Unit[] units)
              throws VisADException

  Constructs a FlatField from a function type, a sampling set of the domain, coordinate systems for the range components, sampling sets for the range components, and units for the range components.

Parameters:
  `type` - The type of the function.
  `domain_set` - The sampling set of the domain. May be null, in which case the sampling set is set to the default sampling set of the function domain (i.e. `type.getDomain().getDefaultSet()`).
  `range_coord_syses` - Optional coordinate systems for the range components. May be `null`. If the `i`th component of the range is a RealTuple, then `range_coord_syses[i]` may be non-`null` and, if so, is the coordinate system for that component and shall have the same reference coordinate system as the corresponding component in the range of the function type.
  `range_sets` - The sampling sets of the (flat) range components. May be `null`, in which case the default sampling sets of the range component RealType-s are used (i.e. `((RealType)type.getFlatRange().getComponent(i)) .getDefaultSet()` for all `i` in the flat range). If non-`null`, then the `i`th flat range component values are stored in bytes if `range_sets[i].getLength() < 256`, stored in shorts if `range_sets[i].getLength() < 65536`, etc.
  `units` - The units of the (flat) range components. May be `null`, in which case the default units of the flat range RealType-s are used.
Throws:
  `VisADException` - Couldn't create necessary VisAD object.

### FlatField

    public FlatField(FunctionType type,
                     Set domain_set,
                     CoordinateSystem range_coord_sys,
                     CoordinateSystem[] range_coord_syses,
                     Set[] range_sets,
                     Unit[] units)
              throws VisADException

  Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, coordinate systems for the range components, sampling sets for the range components, and units for the range components. This is the most general constructor.

Parameters:
  `type` - The type of the function.
  `domain_set` - The sampling set of the domain. May be null, in which case the sampling set is set to the default sampling set of the function domain (i.e. `type.getDomain().getDefaultSet()`).
  `range_coord_sys` - Optional coordinate system for the range. May be `null`. If non-`null` , then the range of the function shall be a RealTuple (i.e. `type.getRange() instanceof RealTuple` shall be true) and the reference coordinate system of the range coordinate system shall be the same as the reference coordiinate system of the function range (i.e. `range_coord_sys().getReference().equals( ((RealTuple)type.getRange()).getReference())` shall be true).
  `range_coord_syses` - Optional coordinate systems for the range components. May be `null`. If the `i`th component of the range is a RealTuple, then `range_coord_syses[i]` may be non-`null` and, if so, is the coordinate system for that component and shall have the same reference coordinate system as the corresponding component in the range of the function type.
  `range_sets` - The sampling sets of the (flat) range components. May be `null`, in which case the default sampling sets of the range component RealType-s are used (i.e. `((RealType)type.getFlatRange().getComponent(i)) .getDefaultSet()` for all `i` in the flat range). If non-`null`, then the `i`th flat range component values are stored in bytes if `range_sets[i].getLength() < 256`, stored in shorts if `range_sets[i].getLength() < 65536`, etc.
  `units` - The units of the (flat) range components. May be `null`, in which case the default units of the flat range RealType-s are used.
Throws:
  `SetException` - if `range_sets` is non-`null` and either one of its elements is `null` or an element's dimension is not one.
  `VisADException` - Couldn't create necessary VisAD object.

Method Detail

### getRangeCoordinateSystem

    public CoordinateSystem[] getRangeCoordinateSystem()
                                                throws TypeException

  Returns the range CoordinateSystem assuming that the range type is a RealTupleType (and throws a TypeException if its not). This may differ from default CoordinateSystem of range RealTupleType, but must be convertable; the index has length = 1 (since all samples have the same Units).

  Specified by:
    `getRangeCoordinateSystem` in interface `Field`
  Overrides:
    `getRangeCoordinateSystem` in class `FieldImpl`
  Returns:
    The CoordinateSystem of the RealTuple range. Will not be `null` and will be of length 1.
  Throws:
    `TypeException` - The type of the range is neither RealType nor RealTupleType.

### getRangeSets

    public Set[] getRangeSets()

  Returns the sampling set of each flat component.

  Specified by:
    `getRangeSets` in interface `FlatFieldIface`
  Returns:
    The sampling set of each component in the flat range.

### getRangeCoordinateSystem

    public CoordinateSystem[] getRangeCoordinateSystem(int i)
                                                throws TypeException

  Returns the CoordinateSystem of a component of the range. The MathType of the range shall be a TupleType.

  Specified by:
    `getRangeCoordinateSystem` in interface `Field`
  Overrides:
    `getRangeCoordinateSystem` in class `FieldImpl`
  Parameters:
    `i` - The index of the component. The value shall be greater than or equal to zero and less that the number of components in the TupleType of the range.
  Returns:
    The CoordinateSystem of the `i`-th component. Won't be `null` and will be of length 1. The single element might be `null`.
  Throws:
    `TypeException` - The type of the range is either RealType or RealTupleType.

### getRangeUnits

    public Unit[][] getRangeUnits()

  return array of Units associated with each RealType component of range; these may differ from default Units of range RealTypes, but must be convertable; the second index has length = 1 (since all samples have the same Units)

  Specified by:
    `getRangeUnits` in interface `Field`
  Overrides:
    `getRangeUnits` in class `FieldImpl`

### getRangeErrors

    public ErrorEstimate[] 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

  Specified by:
    `getRangeErrors` in interface `FlatFieldIface`

### setRangeErrors

    public void setRangeErrors(ErrorEstimate[] errors)
                        throws FieldException

  Sets the ErrorEstimates associated with each RealType component of the range. `errors[i]` is the `ErrorEstimate` for the `i`-th `RealType` component.

  Specified by:
    `setRangeErrors` in interface `FlatFieldIface`
  Parameters:
    `errors` - The error estimates for the range values.
  Throws:
    `FieldException` - if `errors` is non-`null` and `errors.length != getRangeDimension()`.

### setSamples

    public void setSamples(Data[] range,
                           boolean copy)
                    throws VisADException,
                           RemoteException

  set the range values of the function; the order of range values must be the same as the order of domain indices in the DomainSet; copy argument included for consistency with Field, but ignored

  Specified by:
    `setSamples` in interface `Field`
  Overrides:
    `setSamples` in class `FieldImpl`
  Parameters:
    `range` - The range values
    `copy` - should the range values be copied
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(double[][] range)
                    throws VisADException,
                           RemoteException

  set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet

  Specified by:
    `setSamples` in interface `Field`
  Overrides:
    `setSamples` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(float[][] range)
                    throws VisADException,
                           RemoteException

  set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet

  Specified by:
    `setSamples` in interface `Field`
  Overrides:
    `setSamples` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(double[][] range,
                           boolean copy)
                    throws VisADException,
                           RemoteException

  set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true

  Specified by:
    `setSamples` in interface `FlatFieldIface`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(float[][] range,
                           boolean copy)
                    throws VisADException,
                           RemoteException

  set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true

  Specified by:
    `setSamples` in interface `FlatFieldIface`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(double[][] range,
                           ErrorEstimate[] errors,
                           boolean copy)
                    throws VisADException,
                           RemoteException

  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

  Specified by:
    `setSamples` in interface `FlatFieldIface`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(int start,
                           double[][] range)
                    throws VisADException,
                           RemoteException

  update a subset of a FlatField's range samples, where start is the index of the first sample to update and range[0].length is the number of samples to update; the array is dimensioned double[number_of_range_components][number_of_range_samples]

  Specified by:
    `setSamples` in interface `FlatFieldIface`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(int[] indices,
                           double[][] range)
                    throws VisADException,
                           RemoteException

  Throws:
    `VisADException`
    `RemoteException`

### setSamples

    public void setSamples(float[][] range,
                           ErrorEstimate[] errors,
                           boolean copy)
                    throws VisADException,
                           RemoteException

  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

  Specified by:
    `setSamples` in interface `FlatFieldIface`
  Throws:
    `VisADException`
    `RemoteException`

### pr

    protected void pr(String message)

### grabBytes

    public byte[][] grabBytes()

  Specified by:
    `grabBytes` in interface `FlatFieldIface`

### unpackValues

    public double[][] unpackValues()
                            throws VisADException

  unpack an array of doubles from field sample values according to the RangeSet-s; returns a copy

  Throws:
    `VisADException`

### unpackValues

    protected double[][] unpackValues(boolean copy)
                               throws SetException,
                                      VisADException

  Unpacks an array of doubles from field sample values according to the RangeSet-s; returns a copy if copy == true.

  Parameters:
    `copy` - Whether or not to return a copy.
  Throws:
    `SetException` - if an element of `#RangeMode` contains an unknown value.
    `VisADException` - if `Set.indexToValue(int)` on a range set fails.

### unpackFloats

    public float[][] unpackFloats()
                           throws VisADException

  unpack an array of floats from field sample values according to the RangeSet-s; returns a copy

  Throws:
    `VisADException`

### unpackFloats

    protected float[][] unpackFloats(boolean copy)
                              throws VisADException

  unpack an array of floats from field sample values according to the RangeSet-s; returns a copy if copy == true

  Throws:
    `VisADException`

### unpackOneRangeComp

    protected double[] unpackOneRangeComp(int comp)
                                   throws VisADException

  Throws:
    `VisADException`

### unpackValues

    protected double[] unpackValues(int s_index)
                             throws VisADException

  Throws:
    `VisADException`

### unpackFloats

    protected float[] unpackFloats(int s_index)
                            throws VisADException

  Throws:
    `VisADException`

### getFloats

    public float[][] getFloats()
                        throws VisADException

  Returns the range values in their default units as floats.

  Specified by:
    `getFloats` in interface `Field`
  Overrides:
    `getFloats` in class `FieldImpl`
  Returns:
    The range values in their default units as determined by the `MathType` of the range. Element `[i][j]` is the `j`th sample value of the `i`th component of the range.
  Throws:
    `VisADException` - if a VisAD object couldn't be created.

### getFloats

    public float[][] getFloats(boolean copy)
                        throws VisADException

  Returns the range values in their default units as floats.

  Specified by:
    `getFloats` in interface `Field`
  Overrides:
    `getFloats` in class `FieldImpl`
  Parameters:
    `copy` - Whether or not the returned array might be the actual range array. If `true`, then the returned array will not be the actual range array.
  Returns:
    The range values in their default units as determined by the `MathType` of the range. Element `[i][j]` is the `j`th sample value of the `i`th component of the range.
  Throws:
    `VisADException` - if a VisAD object couldn't be created.

### getValues

    public double[][] getValues()
                         throws VisADException

  Returns the range values in their default units as doubles.

  Specified by:
    `getValues` in interface `Field`
  Overrides:
    `getValues` in class `FieldImpl`
  Returns:
    The range values in their default units as determined by the `MathType` of the range. Element `[i][j]` is the `j`th sample value of the `i`th component of the range.
  Throws:
    `VisADException` - if a VisAD object couldn't be created.

### getValues

    public double[][] getValues(boolean copy)
                         throws VisADException

  Returns the range values in their default units as doubles.

  Specified by:
    `getValues` in interface `Field`
  Overrides:
    `getValues` in class `FieldImpl`
  Parameters:
    `copy` - Whether or not the returned array might be the actual range array. If `true`, then the returned array will not be the actual range array.
  Returns:
    The range values in their default units as determined by the `MathType` of the range. Element `[i][j]` is the `j`th sample value of the `i`th component of the range.
  Throws:
    `VisADException` - if a VisAD object couldn't be created.

### getStringValues

    public String[][] getStringValues()
                               throws VisADException,
                                      RemoteException

  Get String values for Text components

  Specified by:
    `getStringValues` in interface `Field`
  Overrides:
    `getStringValues` in class `FieldImpl`
  Returns:
    null (there are none for FlatFields)
  Throws:
    `VisADException` - but doesn't happen
    `RemoteException` - but doesn't happen

### getValues

    public double[] getValues(int s_index)
                       throws VisADException

  Get values for 'Flat' components in default range Unit-s.

  Specified by:
    `getValues` in interface `FlatFieldIface`
  Returns:
    The range values in their default units as determined by the `MathType` of the range. Element `[i]` is the value of the `i`th component of the flattened range.
  Throws:
    `VisADException` - if a VisAD object couldn't be created.

### getDefaultRangeUnits

    public Unit[] getDefaultRangeUnits()

  Get default range Unit-s for 'Flat' components.

  Specified by:
    `getDefaultRangeUnits` in interface `Field`
  Overrides:
    `getDefaultRangeUnits` in class `FieldImpl`
  Returns:
    array of the default Units for each of the RealTypes components in the flattened range.

### getSample

    public Data getSample(int index)
                   throws VisADException,
                          RemoteException

  Get the range value at the index-th sample. FlatField does not override evaluate, but the correctness of FlatField.evaluate depends on overriding getSample

  Specified by:
    `getSample` in interface `Field`
  Overrides:
    `getSample` in class `FieldImpl`
  Parameters:
    `index` - index of requested range sample
  Returns:
    Data object (Real, RealTuple, or Tuple) corresponding to the range at the index-th sample.
  Throws:
    `VisADException` - problem getting data
    `RemoteException` - problem getting data from remote object

### getSample

    public Data getSample(int index,
                          boolean metadataOnly)
                   throws VisADException,
                          RemoteException

  A stub routine which simply invokes `getSample` to override `FieldImpl.getSample`

  Overrides:
    `getSample` in class `FieldImpl`
  Parameters:
    `index` - index of requested range sample
    `metadataOnly` - `true` if only the metadata is needed, `false</ff> if both metadata and data are desired.`
  Throws:
    `VisADException` - if a VisAD object couldn't be created.
    `RemoteException` - if the Remote object couldn't be created.

### setSample

    public void setSample(int index,
                          Data range,
                          boolean copy)
                   throws VisADException,
                          RemoteException

  Set the range value at the index-th sample

  Specified by:
    `setSample` in interface `Field`
  Overrides:
    `setSample` in class `FieldImpl`
  Parameters:
    `index` - index to set
    `range` - range value to set
    `copy` - flag to copy values - meaningless for FlatField
  Throws:
    `VisADException` - if range's MathType is incompatible or some other error.
    `RemoteException` - if the Remote object couldn't be created.

### setSample

    public void setSample(int index,
                          Data range)
                   throws VisADException,
                          RemoteException

  Set the range value at the index-th sample

  Specified by:
    `setSample` in interface `Field`
  Overrides:
    `setSample` in class `FieldImpl`
  Parameters:
    `index` - index to set
    `range` - range value to set
  Throws:
    `VisADException` - if range's MathType is incompatible or some other error.
    `RemoteException` - if the Remote object couldn't be created.

### isMissing

    public boolean isMissing()

  Test whether range values are missing

  Specified by:
    `isMissing` in interface `Data`
  Overrides:
    `isMissing` in class `FieldImpl`
  Returns:
    true if the range values have not been set

### clearMissing

    public void clearMissing()

  Mark this FlatField as non-missing

  Specified by:
    `clearMissing` in interface `FlatFieldIface`

### binary

    public Data binary(Data data,
                       int op,
                       MathType new_type,
                       int sampling_mode,
                       int error_mode)
                throws VisADException,
                       RemoteException

  Return new Field with value 'this op data'. test for various relations between types of this and data; note return type may not be FlatField, in case data is a Field and this matches its range

  Specified by:
    `binary` in interface `Data`
  Overrides:
    `binary` in class `FieldImpl`
  Parameters:
    `data` - object to operate on
    `op` - operation to perform (e.g. ADD, SUB, MULT)
    `new_type` - MathType of new object
    `sampling_mode` - sampling mode to use (e.g., NEAREST_NEIGHBOR, WEIGHTED_AVERAGE)
    `error_mode` - error estimate mode (e.g., NO_ERROR, DEPENDENT, independent)
  Returns:
    new Field corresponding to the requested operation
  Throws:
    `VisADException` - couldn't create new VisAD object
    `RemoteException` - couldn't create new Remote object

### unary

    public Data unary(int op,
                      MathType new_type,
                      int sampling_mode,
                      int error_mode)
               throws VisADException

  Return new FlatField with value 'this op'.

  Specified by:
    `unary` in interface `Data`
  Overrides:
    `unary` in class `FieldImpl`
  Parameters:
    `op` - operation to perform (e.g., NOP, ABS, COS)
    `new_type` - MathType of new object
    `sampling_mode` - sampling mode to use (e.g., NEAREST_NEIGHBOR, WEIGHTED_AVERAGE)
    `error_mode` - error estimate mode (e.g., NO_ERROR, DEPENDENT, independent)
  Returns:
    new FlatField corresponding to the requested operation
  Throws:
    `VisADException` - couldn't create new VisAD object
    `RemoteException` - couldn't create new Remote object

### makeRational

    protected static void makeRational(double[][] values,
                                       Unit[] units,
                                       ErrorEstimate[] errors)
                                throws UnitException

  Ensure that numeric values and units are in rational form, i.e. one in which ratios of data values make sense (e.g. Temperature values in Kelvin rather than Celsius). Additionally, if an input unit is a non-unity dimensionless unit, then the associated values will be converted to the dimensionless unity unit (this conditions the values for operations like exp() and pow()). All conversions are done in-place.

  Parameters:
    `values` - The numeric values. On output, `values[i]` will have been replaced if necessary.
    `units` - The units for the values and error estimates. It's length shall be `values.length`. On output, `units[i]` will have been replaced with the absolute form of the input unit if necessary.
    `errors` - The error estimates. It's length shall be `values.length`. On output, `errors[i]` will have been replaced if necessary.
  Throws:
    `UnitException` - Unit conversion error.

### makeRational

    protected static void makeRational(float[][] values,
                                       Unit[] units,
                                       ErrorEstimate[] errors)
                                throws UnitException

  Throws:
    `UnitException`

### extract

    public Field extract(int component)
                  throws VisADException,
                         RemoteException

  extract field from this[].component; this is OK, when we get around to it

  Specified by:
    `extract` in interface `Field`
  Overrides:
    `extract` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### derivative

    public Data derivative(RealTuple location,
                           RealType[] d_partial_s,
                           MathType[] derivType_s,
                           int error_mode)
                    throws VisADException,
                           RemoteException

  Description copied from interface: `Function`
  return the tuple of derivatives of this Function with respect to the RealTypes in d_partial_s; the RealTypes in d_partial_s may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; set result MathTypes of tuple components to derivType_s; propogate errors according to error_mode

  Specified by:
    `derivative` in interface `Function`
  Overrides:
    `derivative` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### derivative

    public Data derivative(int error_mode)
                    throws VisADException,
                           RemoteException

  Description copied from interface: `Function`
  return the tuple of derivatives of this Function with respect to all RealType components of its domain RealTuple; propogate errors according to error_mode

  Specified by:
    `derivative` in interface `Function`
  Overrides:
    `derivative` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### derivative

    public Data derivative(MathType[] derivType_s,
                           int error_mode)
                    throws VisADException,
                           RemoteException

  Description copied from interface: `Function`
  return the tuple of derivatives of this Function with respect to all RealType components of its domain RealTuple; set result MathTypes of tuple components to derivType_s; propogate errors according to error_mode

  Specified by:
    `derivative` in interface `Function`
  Overrides:
    `derivative` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### derivative

    public Function derivative(RealType d_partial,
                               int error_mode)
                        throws VisADException,
                               RemoteException

  Description copied from interface: `Function`
  return the derivative of this Function with respect to d_partial; d_partial may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; propogate errors according to error_mode

  Specified by:
    `derivative` in interface `Function`
  Overrides:
    `derivative` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### derivative

    public Function derivative(RealType d_partial,
                               MathType derivType,
                               int error_mode)
                        throws VisADException,
                               RemoteException

  Description copied from interface: `Function`
  return the derivative of this Function with respect to d_partial; set result MathType to derivType; d_partial may occur in this Function's domain RealTupleType, or, if the domain has a CoordinateSystem, in its Reference RealTupleType; propogate errors according to error_mode

  Specified by:
    `derivative` in interface `Function`
  Overrides:
    `derivative` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### resample

    public Field resample(Set set,
                          int sampling_mode,
                          int error_mode)
                   throws VisADException,
                          RemoteException

  Resamples the range to domain samples of a given set. Resampling is either by nearest neighbor or mulit-linear interpolation. NOTE: This code is very similar to FieldImpl.resample(Set,int,int).

  Specified by:
    `resample` in interface `Function`
  Overrides:
    `resample` in class `FieldImpl`
  Parameters:
    `set` - The set of points at which to resample this field.
    `sampling_mode` - Resampling mode: Data.NEAREST_NEIGHBOR or Data.WEIGHTED_AVERAGE
    `error_mode` - Error estimation mode: Data.DEPENDENT, Data.INDEPENDENT, or Data.NO_ERRORS.
  Returns:
    Field of resampled data. RangeSet objects in result are set to DoubleSet. NOTE: May return this (i.e., not a copy).
  Throws:
    `RemoteException` - Java RMI exception
    `VisADException` - unable to resample function

### convertToField

    public Field convertToField()
                         throws VisADException,
                                RemoteException

  convert this FlatField to a (non-Flat) FieldImpl

  Specified by:
    `convertToField` in interface `FlatFieldIface`
  Throws:
    `VisADException`
    `RemoteException`

### computeRanges

    public DataShadow computeRanges(ShadowType type,
                                    DataShadow shadow)
                             throws VisADException

  Description copied from interface: `Data`
  Recursive version of computeRanges(), called down through Data object tree.

  Specified by:
    `computeRanges` in interface `Data`
  Overrides:
    `computeRanges` in class `FieldImpl`
  Throws:
    `VisADException`

### adjustSamplingError

    public Data adjustSamplingError(Data error,
                                    int error_mode)
                             throws VisADException,
                                    RemoteException

  return a FlatField that clones this, except its ErrorEstimate-s are adjusted for sampling errors in error

  Specified by:
    `adjustSamplingError` in interface `Data`
  Overrides:
    `adjustSamplingError` in class `FieldImpl`
  Throws:
    `VisADException`
    `RemoteException`

### isFlatField

    public boolean isFlatField()

  Description copied from interface: `Field`
  return true if this a FlatField or a RemoteField adapting a FlatField

  Specified by:
    `isFlatField` in interface `Field`
  Overrides:
    `isFlatField` in class `FieldImpl`

### cloneDouble

    protected FlatField cloneDouble(MathType f_type,
                                    Unit[] units,
                                    ErrorEstimate[] errors)
                             throws VisADException

  Throws:
    `VisADException`

### cloneDouble

    protected FlatField cloneDouble(MathType f_type,
                                    Unit[] units,
                                    ErrorEstimate[] errors,
                                    double[][] newValues)
                             throws VisADException

  Throws:
    `VisADException`

### cloneFloat

    protected FlatField cloneFloat(MathType f_type,
                                   Unit[] units,
                                   ErrorEstimate[] errors)
                            throws VisADException

  Throws:
    `VisADException`

### cloneFloat

    protected FlatField cloneFloat(MathType f_type,
                                   Unit[] units,
                                   ErrorEstimate[] errors,
                                   float[][] newValues)
                            throws VisADException

  Throws:
    `VisADException`

### clone

    public Object clone()

  Clones this instance. Immutable fields are shallow copied. Range values, however, are deep copied.

  Note that it is possible to simultaneously modify the domain-set of both this instance and the clone by modifying the values in the array returned by invoking `getSamples(false)` on the domain-set of either this instance or the clone. Don't do this unless you enjoy debugging.

  Overrides:
    `clone` in class `FieldImpl`
  Returns:
    A clone of this instance.
  Throws:
    `RuntimeException` - if a `VisADException` occurs.

### valuesString

    String valuesString()
                  throws VisADException

  Throws:
    `VisADException`

### toString

    public String toString()

  Overrides:
    `toString` in class `DataImpl`
  Returns:
    a String representation of this

### longString

    public String longString(String pre)
                      throws VisADException

  Specified by:
    `longString` in interface `Data`
  Overrides:
    `longString` in class `FieldImpl`
  Throws:
    `VisADException`

### getRangeDimension

    public int getRangeDimension()

  Gets the number of components in the "flat" range.

  Specified by:
    `getRangeDimension` in interface `FlatFieldIface`
  Returns:
    The number of components in the "flat" range.

### equals

    public boolean equals(Object obj)

  Overrides:
    `equals` in class `FieldImpl`

### makeField

    public static FlatField makeField(FunctionType type,
                                      int length,
                                      boolean irregular)
                               throws VisADException,
                                      RemoteException

  construct a FlatField of given type; used for testing

  Throws:
    `VisADException`
    `RemoteException`

### fillField

    public static void fillField(FlatField image,
                                 double step,
                                 double half)
                          throws VisADException,
                                 RemoteException

  Throws:
    `VisADException`
    `RemoteException`

### makeField1

    public static FlatField makeField1(FunctionType type,
                                       double first1,
                                       double last1,
                                       int length1,
                                       double first2,
                                       double last2,
                                       int length2)
                                throws VisADException,
                                       RemoteException

  construct a FlatField with a 2-D domain and a 1-D range; used for testing

  Throws:
    `VisADException`
    `RemoteException`

### makeField2

    public static FlatField makeField2(FunctionType type,
                                       double first1,
                                       double last1,
                                       int length1,
                                       double first2,
                                       double last2,
                                       int length2)
                                throws VisADException,
                                       RemoteException

  construct a FlatField with a 2-D domain and a 2-D range; used for testing

  Throws:
    `VisADException`
    `RemoteException`

### makeRandomField2

    static FlatField makeRandomField2(FunctionType type,
                                      double first1,
                                      double last1,
                                      int length1,
                                      double first2,
                                      double last2,
                                      int length2)
                               throws VisADException,
                                      RemoteException

  construct a FlatField with a 2-D domain and a 2-D range and random values; used for testing

  Throws:
    `VisADException`
    `RemoteException`

### main

    public static void main(String[] args)
                     throws VisADException,
                            RemoteException

  run 'java visad.FlatField' to test the FlatField class

  Throws:
    `VisADException`
    `RemoteException`