## visad
Class FieldImpl

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

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

Direct Known Subclasses:
  FileField, FlatField, ImageSequenceImpl

public class FieldImpl
extends FunctionImpl
implements Field

FieldImpl is the VisAD class for finite samplings of functions from R^n to a range type, where n>0. The DomainSet, DomainUnits and DomainCoordinateSystem variables of FieldImpl are immutable.

A FieldImpl domain type may be either a RealType (for a function with domain = R) or a RealTupleType (for a function with domain = R^n for n > 0).

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
`(package private) CoordinateSystem` `DomainCoordinateSystem` this is DomainSet.DomainCoordinateSystem
`(package private) Set` `DomainSet` the sampling of the function domain R^n
`(package private) Unit[]` `DomainUnits` this is DomainSet.SetUnits
`(package private) int` `Length` the number of samples

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
`` `FieldImpl(FunctionType type)` construct a FieldImpl from type; use default Set of FunctionType domain; initial values are missing
`` `FieldImpl(FunctionType type, Set set)` Constructs from the type of function and a set of domain points.
`protected` `FieldImpl(FunctionType type, Set set, boolean createRangeArray)` Trusted constructor for subclasses that don't need to have the Range array instantiated (i.e., FlatField).

Method Summary
`Data` `__getitem__(int index)` A wrapper around `getSample` for JPython.
`int` `__len__()` A wrapper around `getLength` for JPython.
`void` `__setitem__(int index, Data data)` A wrapper around `setSample` for JPython.
`void` `__setitem__(int index, double data)` A wrapper around `setSample` for JPython.
`Data` `adjustSamplingError(Data error, int error_mode)` return a Field 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'; test for various relations between types of this and data
`Object` `clone()` Clones this instance.

`static Field`

`combine(Field[] fields)`
Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields; if the range of fields[i] is a Tuple without a RangeCoordinateSystem, then each Tuple component of a range sample of fields[i] becomes a Tuple component of a range sample of the result - otherwise a range sample of fields[i] becomes a Tuple component of a range sample of the result; this assumes all elements of the fields array have the same domain dimension; use default sampling_mode (Data.NEAREST_NEIGHBOR) and default error_mode (Data.NO_ERRORS)

`static Field` `combine(Field[] fields, boolean flatten)` Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields.

`static Field`

`combine(Field[] fields, int sampling_mode, int error_mode)`
resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields; if the range of fields[i] is a Tuple without a RangeCoordinateSystem, then each Tuple component of a range sample of fields[i] becomes a Tuple component of a range sample of the result - otherwise a range sample of fields[i] becomes a Tuple component of a range sample of the result; this assumes all elements of the fields array have the same domain dimension

`static Field` `combine(Field[] fields, int sampling_mode, int error_mode, boolean flatten)` Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields.
`static Field` `combine(Field[] fields, int sampling_mode, int error_mode, boolean flatten, boolean copy)` Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields.
`DataShadow` `computeRanges(ShadowType type, DataShadow shadow)` Recursive version of computeRanges(), called down through Data object tree.
`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
`Enumeration` `domainEnumeration()` Here's how to use this: for (Enumeration e = field.domainEnumeration() ; e.hasMoreElements(); ) { RealTuple domain_sample = (RealTuple) e.nextElement(); Data range = field.evaluate(domain_sample); }
`Field` `domainFactor(RealType factor)` Factors this instance into a (nested) field-of-fields.
`Field` `domainFactor(RealType factor, boolean copy)` Factors this instance into a (nested) field-of-fields.
`Field` `domainMultiply()` Combine domains of two outermost nested Fields into a single domain and Field.
`Field` `domainMultiply(CoordinateSystem resultCS)` Combine domains of two outermost nested Fields into a single domain and Field.
`Field` `domainMultiply(int collapse_depth)` Combine domains of `collapse_depth` if possible.
`Field` `domainMultiply(int collapse_depth, CoordinateSystem resultCS)` Combine domains of `collapse_depth` if possible.
`boolean` `equals(Object obj)`
`Field` `extract(int component)` extract field from this[].component
`Field` `extract(MathType type)` extract Field from this.component using the MathType of one of the range componenets
`Field` `extract(String name)` extract Field from this.component using the name of one of the range componenets
`Unit[]` `getDefaultRangeUnits()` get default range Unit-s for 'Flat' components
`CoordinateSystem` `getDomainCoordinateSystem()` Get the CoordinateSystem associated with the domain RealTuple
`Set` `getDomainSet()` Returns the domain-set of this instance.
`Unit[]` `getDomainUnits()` Returns the units of the values in the domain set.
`float[][]` `getFloats()` invokes getFloats(true)
`float[][]` `getFloats(boolean copy)` get range values for 'Flat' components in their default range Units (as defined by the range of this FieldImpl's FunctionType); the return array is dimensioned float[number_of_range_components][number_of_range_samples]; copy is ignored for FieldImpl
`int` `getLength()` get number of samples
`CoordinateSystem[]` `getRangeCoordinateSystem()` Get range CoordinateSystem for 'RealTuple' range; second index enumerates samples.
`CoordinateSystem[]` `getRangeCoordinateSystem(int component)` get range CoordinateSystem for 'RealTuple' components; second index enumerates samples
`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 enumerates samples since Units may differ between samples
`Data` `getSample(int index)` Get the range value at the index-th sample.
`Data` `getSample(int index, boolean metadataOnly)` Get the metadata for the range value at the index-th sample.
`String[][]` `getStringValues()` get range values for Text components; the return array is dimensioned double[number_of_range_components][number_of_range_samples]
`double[][]` `getValues()` invokes getValues(true)
`double[][]` `getValues(boolean copy)` get range values for 'Flat' components in their default range Units (as defined by the range of this FieldImpl's FunctionType); the return array is dimensioned double[number_of_range_components][number_of_range_samples]; copy is ignored for FieldImpl
`boolean` `isFlatField()` return true if this a FlatField or a RemoteField adapting a FlatField
`boolean` `isMissing()` test whether Field value is missing
`String` `longString(String pre)`
`Field` `resample(Set set, int sampling_mode, int error_mode)` Resample range values of this Field to domain samples in set either byt nearest neighbor or multi-linear interpolation.
`void` `setSample(int index, Data range)` Set the range value at the index-th sample; makes a local copy
`void` `setSample(int index, Data range, boolean copy)` Set the range value at the index-th sample
`void` `setSample(int index, Data range, boolean copy, boolean checkRangeType)` Set the range value at the index-th sample
`void` `setSample(RealTuple domain, Data range)` set the range value at the sample nearest to domain
`void` `setSample(RealTuple domain, Data range, boolean copy)` set the range value at the sample nearest to domain
`void` `setSamples(Data[] range, boolean copy)` Set the range samples of the function; the order of range samples must be the same as the order of domain indices in the DomainSet; copy range objects if copy is true;
`void` `setSamples(Data[] range, boolean copy, boolean checkAllRangeTypes)` Set the range samples of the function; the order of range samples must be the same as the order of domain indices in the DomainSet; copy range objects if copy is true; should use same MathType object in each Data object in range array
`void` `setSamples(double[][] range)` set range array as range values of this FieldImpl; this must have a Flat range; 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)` set range array as range values of this FieldImpl; this must have a Flat range; 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
`Data` `unary(int op, MathType new_type, int sampling_mode, int error_mode)` return new Field with value 'op this'

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, main, 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, toString, 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.Function
`evaluate, evaluate, evaluate, evaluate, getDomainDimension, 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

### DomainSet

    Set DomainSet

  the sampling of the function domain R^n

### DomainCoordinateSystem

    CoordinateSystem DomainCoordinateSystem

  this is DomainSet.DomainCoordinateSystem

### DomainUnits

    Unit[] DomainUnits

  this is DomainSet.SetUnits

### Length

    int Length

  the number of samples

Constructor Detail

### FieldImpl

    public FieldImpl(FunctionType type)
              throws VisADException

  construct a FieldImpl from type; use default Set of FunctionType domain; initial values are missing

### FieldImpl

    public FieldImpl(FunctionType type,
                     Set set)
              throws VisADException

  Constructs from the type of function and a set of domain points.

Parameters:
  `type` - The type of function.
  `set` - The set of domain points. Defines the units and any coordinate system transformation for the domain of the funciton. May be `null`, in which case the default domain set (`FunctionType.getDomain()`) is used. May not be `FloatSet` or `DoubleSet`. If non-`null`, then must be compatible with the domain of the FunctionType.
Throws:
  `CoordinateSystemException` - if the `CoordinateSystem` of the domain set is `null` but the `CoordinateSystem` of the domain of the FunctionType} is not; or if both `CoordinateSystem`s are non-`null` and do not have the same reference `RealTupleType`.
  `VisADException` - if a VisAD failure occurs.

### FieldImpl

    protected FieldImpl(FunctionType type,
                        Set set,
                        boolean createRangeArray)
                 throws VisADException

  Trusted constructor for subclasses that don't need to have the Range array instantiated (i.e., FlatField).

Parameters:
  `type` - The type of function.
  `set` - The set of domain points. Defines the units and any coordinate system transformation for the domain of the funciton. May be `null`, in which case the default domain set (`FunctionType.getDomain()`) is used. May not be `FloatSet` or `DoubleSet`. If non-`null`, then must be compatible with the domain of the FunctionType.
  `createRangeArray` - If true then the Range array is allocated.
Throws:
  `CoordinateSystemException` - if the `CoordinateSystem` of the domain set is `null` but the `CoordinateSystem` of the domain of the FunctionType} is not; or if both `CoordinateSystem`s are non-`null` and do not have the same reference `RealTupleType`.
  `VisADException` - if a VisAD failure occurs.

Method Detail

### setSamples

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

  Set the range samples of the function; the order of range samples must be the same as the order of domain indices in the DomainSet; copy range objects if copy is true;

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

### setSamples

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

  Set the range samples of the function; the order of range samples must be the same as the order of domain indices in the DomainSet; copy range objects if copy is true; should use same MathType object in each Data object in range array

  Parameters:
    `range` - The range values
    `copy` - should the range values be copied
    `checkAllRangeTypes` - If true then ensure that the MathType of each element in the range matches the type of this field. If false then only check the first range element. This is the "trust the calling method" flag. If you pass in false and there are elements in the range whose type does not match the type of this field then this may result in hard-to-track-down bugs.
  Throws:
    `VisADException`
    `RemoteException`

### getDomainSet

    public Set getDomainSet()

  Returns the domain-set of this instance. The actual set is returned: it is not a copy or a clone.

  Note that it is possible to simultaneously modify the domain-set of both this instance and of a 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.

  Specified by:
    `getDomainSet` in interface `Field`
  Returns:
    The actual domain-set of this instance.

### getLength

    public int getLength()

  get number of samples

  Specified by:
    `getLength` in interface `Field`

### getDomainUnits

    public Unit[] getDomainUnits()

  Returns the units of the values in the domain set. The units may differ from the default units of the underlying MathType of the domain, but will be convertible with them.

  Specified by:
    `getDomainUnits` in interface `Function`
  Overrides:
    `getDomainUnits` in class `FunctionImpl`
  Returns:
    The units of the values in the domain set.

### getDomainCoordinateSystem

    public CoordinateSystem getDomainCoordinateSystem()

  Description copied from interface: `Function`
  Get the CoordinateSystem associated with the domain RealTuple

  Specified by:
    `getDomainCoordinateSystem` in interface `Function`
  Overrides:
    `getDomainCoordinateSystem` in class `FunctionImpl`
  Returns:
    CoordinateSystem of the domain

### getStringValues

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

  get range values for Text components; the return array is dimensioned double[number_of_range_components][number_of_range_samples]

  Specified by:
    `getStringValues` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### getFloats

    public float[][] getFloats()
                        throws VisADException,
                               RemoteException

  Description copied from interface: `Field`
  invokes getFloats(true)

  Specified by:
    `getFloats` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### getFloats

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

  get range values for 'Flat' components in their default range Units (as defined by the range of this FieldImpl's FunctionType); the return array is dimensioned float[number_of_range_components][number_of_range_samples]; copy is ignored for FieldImpl

  Specified by:
    `getFloats` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### getValues

    public double[][] getValues()
                         throws VisADException,
                                RemoteException

  Description copied from interface: `Field`
  invokes getValues(true)

  Specified by:
    `getValues` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### getValues

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

  get range values for 'Flat' components in their default range Units (as defined by the range of this FieldImpl's FunctionType); the return array is dimensioned double[number_of_range_components][number_of_range_samples]; copy is ignored for FieldImpl

  Specified by:
    `getValues` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

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

  set range array as range values of this FieldImpl; this must have a Flat range; 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`
  Throws:
    `VisADException`
    `RemoteException`

### setSamples

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

  set range array as range values of this FieldImpl; this must have a Flat range; 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`
  Throws:
    `VisADException`
    `RemoteException`

### getRangeUnits

    public Unit[][] getRangeUnits()
                           throws VisADException,
                                  RemoteException

  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 enumerates samples since Units may differ between samples

  Specified by:
    `getRangeUnits` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### getRangeCoordinateSystem

    public CoordinateSystem[] getRangeCoordinateSystem()
                                                throws VisADException,
                                                       RemoteException

  Get range CoordinateSystem for 'RealTuple' range; second index enumerates samples.

  Specified by:
    `getRangeCoordinateSystem` in interface `Field`
  Returns:
    range CoordinateSystem assuming range type is a RealTupleType (throws a TypeException if its not); this may differ from default CoordinateSystem of range RealTupleType, but must be convertable; the index enumerates samples since Units may differ between samples
  Throws:
    `VisADException`
    `RemoteException`

### getRangeCoordinateSystem

    public CoordinateSystem[] getRangeCoordinateSystem(int component)
                                                throws VisADException,
                                                       RemoteException

  get range CoordinateSystem for 'RealTuple' components; second index enumerates samples

  Specified by:
    `getRangeCoordinateSystem` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### getDefaultRangeUnits

    public Unit[] getDefaultRangeUnits()

  get default range Unit-s for 'Flat' components

  Specified by:
    `getDefaultRangeUnits` in interface `Field`

### getSample

    public Data getSample(int index)
                   throws VisADException,
                          RemoteException

  Get the range value at the index-th sample. The actual range value is returned -- not a copy.

  This implementation uses `getSample(int, boolean)`.

  Specified by:
    `getSample` in interface `Field`
  Parameters:
    `index` - index of requested range sample
  Returns:
  Throws:
    `VisADException`
    `RemoteException`

### getSample

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

  Get the metadata for the range value at the index-th sample. If the range value is also requested, then the actual range value is returned -- not a copy.

  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`
    `RemoteException`

### setSample

    public void setSample(RealTuple domain,
                          Data range,
                          boolean copy)
                   throws VisADException,
                          RemoteException

  set the range value at the sample nearest to domain

  Specified by:
    `setSample` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### setSample

    public void setSample(RealTuple domain,
                          Data range)
                   throws VisADException,
                          RemoteException

  Description copied from interface: `Field`
  set the range value at the sample nearest to domain

  Specified by:
    `setSample` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### setSample

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

  Set the range value at the index-th sample; makes a local copy

  Specified by:
    `setSample` in interface `Field`
  Parameters:
    `index` - index in domain
    `range` - sample at that index
  Throws:
    `VisADException`
    `RemoteException`

### 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`
  Parameters:
    `index` - index in domain
    `range` - sample at that index
    `copy` - true to make a copy
  Throws:
    `VisADException`
    `RemoteException`

### setSample

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

  Set the range value at the index-th sample

  Parameters:
    `index` - index in domain
    `range` - sample at that index
    `copy` - true to make a copy
    `checkRangeType` - setting to false will not check to make sure that the sample MathType is the same as this FieldImpl's range. This saves on time at the expense of accuracy. Use this only if you like shooting yourself in the foot.
  Throws:
    `VisADException`
    `RemoteException`

### isMissing

    public boolean isMissing()

  test whether Field value is missing

  Specified by:
    `isMissing` in interface `Data`
  Returns:
    flag indicating whether this Data has a missing value

### 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

  Specified by:
    `binary` in interface `Data`
  Overrides:
    `binary` in class `DataImpl`
  Parameters:
    `data` - other Data operand for binary operation
    `op` - may be Data.ADD, Data.SUBTRACT, etc; these include all binary operations defined for Java primitive data types
    `new_type` - MathType of the result
    `sampling_mode` - may be Data.NEAREST_NEIGHBOR or Data.WEIGHTED_AVERAGE
    `error_mode` - may be Data.INDEPENDENT, Data.DEPENDENT or Data.NO_ERRORS;
  Returns:
    result, with MathType = new_type
  Throws:
    `RemoteException` - an RMI error occurred
    `VisADException` - a VisAD error occurred

### unary

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

  return new Field with value 'op this'

  Specified by:
    `unary` in interface `Data`
  Overrides:
    `unary` in class `DataImpl`
  Parameters:
    `op` - may be Data.ABS, Data.ACOS, etc; these include all unary operations defined for Java primitive data types
    `new_type` - MathType of the result
    `sampling_mode` - may be Data.NEAREST_NEIGHBOR or Data.WEIGHTED_AVERAGE
    `error_mode` - may be Data.INDEPENDENT, Data.DEPENDENT or Data.NO_ERRORS;
  Returns:
    result, with MathType = new_type
  Throws:
    `VisADException` - a VisAD error occurred
    `RemoteException` - an RMI error occurred

### combine

    public static Field combine(Field[] fields)
                         throws VisADException,
                                RemoteException

  Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields; if the range of fields[i] is a Tuple without a RangeCoordinateSystem, then each Tuple component of a range sample of fields[i] becomes a Tuple component of a range sample of the result - otherwise a range sample of fields[i] becomes a Tuple component of a range sample of the result; this assumes all elements of the fields array have the same domain dimension; use default sampling_mode (Data.NEAREST_NEIGHBOR) and default error_mode (Data.NO_ERRORS)

  Parameters:
    `fields` - fields to combine
  Returns:
    combined fields
  Throws:
    `VisADException`
    `RemoteException`

### combine

    public static Field combine(Field[] fields,
                                boolean flatten)
                         throws VisADException,
                                RemoteException

  Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields. If `flatten` is true and if the range of fields[i] is a Tuple without a RangeCoordinateSystem, then each Tuple component of a range sample of fields[i] becomes a Tuple component of a range sample of the result - otherwise a range sample of fields[i] becomes a Tuple component of a range sample of the result; this assumes all elements of the fields array have the same domain dimension; use default sampling_mode (Data.NEAREST_NEIGHBOR) and default error_mode (Data.NO_ERRORS)

  Parameters:
    `fields` - fields to combine
    `flatten` - true to flatten range tuples with no CoordinateSystem
  Returns:
    combined fields
  Throws:
    `VisADException`
    `RemoteException`

### combine

    public static Field combine(Field[] fields,
                                int sampling_mode,
                                int error_mode)
                         throws VisADException,
                                RemoteException

  resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields; if the range of fields[i] is a Tuple without a RangeCoordinateSystem, then each Tuple component of a range sample of fields[i] becomes a Tuple component of a range sample of the result - otherwise a range sample of fields[i] becomes a Tuple component of a range sample of the result; this assumes all elements of the fields array have the same domain dimension

  Throws:
    `VisADException`
    `RemoteException`

### combine

    public static Field combine(Field[] fields,
                                int sampling_mode,
                                int error_mode,
                                boolean flatten)
                         throws VisADException,
                                RemoteException

  Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields. If `flatten` is true and if the range of fields[i] is a Tuple without a RangeCoordinateSystem, then each Tuple component of a range sample of fields[i] becomes a Tuple component of a range sample of the result - otherwise a range sample of fields[i] becomes a Tuple component of a range sample of the result; this assumes all elements of the fields array have the same domain dimension.

  Parameters:
    `fields` - fields to combine
    `sampling_mode` - sampling mode to use (e.g., Data.NEAREST_NEIGHBOR)
    `error_mode` - error mode to use (e.g., Data.NO_ERRORS)
    `flatten` - true to flatten range tuples with no CoordinateSystem
  Returns:
    combined fields
  Throws:
    `VisADException`
    `RemoteException`

### combine

    public static Field combine(Field[] fields,
                                int sampling_mode,
                                int error_mode,
                                boolean flatten,
                                boolean copy)
                         throws VisADException,
                                RemoteException

  Resample all elements of the fields array to the domain set of fields[0], then return a Field whose range samples are Tuples merging the corresponding range samples from each element of fields. If `flatten` is true and if the range of fields[i] is a Tuple without a RangeCoordinateSystem, then each Tuple component of a range sample of fields[i] becomes a Tuple component of a range sample of the result - otherwise a range sample of fields[i] becomes a Tuple component of a range sample of the result; this assumes all elements of the fields array have the same domain dimension.

  Parameters:
    `fields` - fields to combine
    `sampling_mode` - sampling mode to use (e.g., Data.NEAREST_NEIGHBOR)
    `error_mode` - error mode to use (e.g., Data.NO_ERRORS)
    `flatten` - true to flatten range tuples with no CoordinateSystem
    `copy` - true to copy the values from the original fields
  Returns:
    combined fields
  Throws:
    `VisADException`
    `RemoteException`

### extract

    public Field extract(MathType type)
                  throws VisADException,
                         RemoteException

  extract Field from this.component using the MathType of one of the range componenets

  Throws:
    `VisADException`
    `RemoteException`

### extract

    public Field extract(String name)
                  throws VisADException,
                         RemoteException

  extract Field from this.component using the name of one of the range componenets

  Throws:
    `VisADException`
    `RemoteException`

### extract

    public Field extract(int component)
                  throws VisADException,
                         RemoteException

  extract field from this[].component

  Specified by:
    `extract` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`

### domainFactor

    public Field domainFactor(RealType factor)
                       throws DomainException,
                              VisADException,
                              RemoteException

  Factors this instance into a (nested) field-of-fields. The type of the domain of the outer field will be the type specified. The type of the domains of the inner fields will be the remainder of the original domain after the outer domain is factored out. Range data is not copied for FieldImpls, but will be for FlatFields.

  Specified by:
    `domainFactor` in interface `Field`
  Parameters:
    `factor` - The type of the domain for the outer field.
  Returns:
    The field-of-fields realization of this instance.
  Throws:
    `DomainException` - The domain of this instance cannot be factored as requested.
    `VisADException` - VisAD failure.
    `RemoteException` - Java RMI failure.
  See Also:
    `for copy information`

### domainFactor

    public Field domainFactor(RealType factor,
                              boolean copy)
                       throws DomainException,
                              VisADException,
                              RemoteException

  Factors this instance into a (nested) field-of-fields. The type of the domain of the outer field will be the type specified. The type of the domains of the inner fields will be the remainder of the original domain after the outer domain is factored out. Range data is copied if

  Parameters:
    `factor` - The type of the domain for the outer field.
    `copy` - true to make copies of the data objects
  Returns:
    The field-of-fields realization of this instance.
  Throws:
    `DomainException` - The domain of this instance cannot be factored as requested.
    `VisADException` - VisAD failure.
    `RemoteException` - Java RMI failure.

### domainMultiply

    public Field domainMultiply()
                         throws VisADException,
                                RemoteException

  Combine domains of two outermost nested Fields into a single domain and Field. If the domains each have `CoordinateSystem`-s the new domain will have a `CartesianProductCoordinateSystem` of Set-s CoordinateSystems

  Specified by:
    `domainMultiply` in interface `Field`
  Throws:
    `VisADException` - unable to collapse domains
    `RemoteException` - unable to collapse domains of remote data

### domainMultiply

    public Field domainMultiply(CoordinateSystem resultCS)
                         throws VisADException,
                                RemoteException

  Combine domains of two outermost nested Fields into a single domain and Field. The supplied `resultCS` would be used for the new domain

  Parameters:
    `resultCS` - CoordinateSystem to use for the new domain set
  Throws:
    `VisADException` - unable to collapse domains
    `RemoteException` - unable to collapse domains of remote data

### domainMultiply

    public Field domainMultiply(int collapse_depth)
                         throws VisADException,
                                RemoteException

  Combine domains of `collapse_depth` if possible.

  Specified by:
    `domainMultiply` in interface `Field`
  Parameters:
    `collapse_depth` - depth to collapse to
  Throws:
    `VisADException` - unable to collapse domains
    `RemoteException` - unable to collapse domains of remote data

### domainMultiply

    public Field domainMultiply(int collapse_depth,
                                CoordinateSystem resultCS)
                         throws VisADException,
                                RemoteException

  Combine domains of `collapse_depth` if possible. Use `resultCS` as the CoordinateSystem for the new domain.

  Parameters:
    `collapse_depth` - depth to collapse to
    `resultCS` - CoordinateSystem to use for the new domain set
  Throws:
    `VisADException` - unable to collapse domains
    `RemoteException` - unable to collapse domains of remote data

### 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`
  Specified by:
    `derivative` in class `FunctionImpl`
  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`
  Specified by:
    `derivative` in class `FunctionImpl`
  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`
  Specified by:
    `derivative` in class `FunctionImpl`
  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`
  Specified by:
    `derivative` in class `FunctionImpl`
  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`
  Specified by:
    `derivative` in class `FunctionImpl`
  Throws:
    `VisADException`
    `RemoteException`

### resample

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

  Resample range values of this Field to domain samples in set either byt nearest neighbor or multi-linear interpolation. NOTE: this code is very similar to resample in FlatField.java

  Specified by:
    `resample` in interface `Function`
  Specified by:
    `resample` in class `FunctionImpl`
  Parameters:
    `set` - finite sampling values for the function.
    `sampling_mode` - type of interpolation to perform (e.g., Data.WEIGHTED_AVERAGE, Data.NEAREST_NEIGHBOR)
    `error_mode` - type of error estimation to perform (e.g., Data.INDEPENDENT, Data.DEPENDENT, Data.NO_ERRORS)
  Returns:
    Data object corresponding to the function value at that domain, using the sampling_mode and error_modes specified. NOTE: may return this (i.e., not a copy).
  Throws:
    `VisADException` - unable to resample function
    `RemoteException` - Java RMI exception

### computeRanges

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

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

  Specified by:
    `computeRanges` in interface `Data`
  Parameters:
    `type` - ShadowType generated for MathType of this
    `shadow` - DataShadow instance whose contained double[][] array and animation sampling Set are modified according to RealType values in this, and used as return value
  Returns:
    DataShadow instance containing double[][] array of RealType ranges, and an animation sampling Set
  Throws:
    `RemoteException` - an RMI error occurred
    `VisADException` - a VisAD error occurred

### adjustSamplingError

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

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

  Specified by:
    `adjustSamplingError` in interface `Data`
  Overrides:
    `adjustSamplingError` in class `DataImpl`
  Parameters:
    `error` -
    `error_mode` - may be Data.INDEPENDENT, Data.DEPENDENT or Data.NO_ERRORS;
  Returns:
    clone of this, except with ErrorEstimates set according to values in error
  Throws:
    `RemoteException` - an RMI error occurred
    `VisADException` - a VisAD error occurred

### 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`

### __len__

    public int __len__()
                throws VisADException,
                       RemoteException

  A wrapper around `getLength` for JPython.

  Throws:
    `VisADException`
    `RemoteException`

### __getitem__

    public Data __getitem__(int index)
                     throws VisADException,
                            RemoteException

  A wrapper around `getSample` for JPython.

  Throws:
    `VisADException`
    `RemoteException`

### __setitem__

    public void __setitem__(int index,
                            Data data)
                     throws VisADException,
                            RemoteException

  A wrapper around `setSample` for JPython.

  Throws:
    `VisADException`
    `RemoteException`

### __setitem__

    public void __setitem__(int index,
                            double data)
                     throws VisADException,
                            RemoteException

  A wrapper around `setSample` for JPython.

  Throws:
    `VisADException`
    `RemoteException`

### clone

    public Object clone()
                 throws CloneNotSupportedException

  Clones this instance. The `MathType`, domain Set), and {@link CoordinateSystem} are shallow copied. Each range value, however, has its `clone()` method invoked.

  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 `DataImpl`
  Returns:
    A clone of this instance.
  Throws:
    `CloneNotSupportedException` - if cloning isn't supported by a range-value.

### longString

    public String longString(String pre)
                      throws VisADException,
                             RemoteException

  Specified by:
    `longString` in interface `Data`
  Overrides:
    `longString` in class `DataImpl`
  Parameters:
    `pre` - String added to start of each line
  Returns:
    a longer String than returned by toString(), indented by pre (a string of blanks)
  Throws:
    `VisADException`
    `RemoteException`

### equals

    public boolean equals(Object obj)

### domainEnumeration

    public Enumeration domainEnumeration()
                                  throws VisADException,
                                         RemoteException

         Here's how to use this:

         for (Enumeration e = field.domainEnumeration() ; e.hasMoreElements(); ) {
           RealTuple domain_sample = (RealTuple) e.nextElement();
           Data range = field.evaluate(domain_sample);
         }

  Specified by:
    `domainEnumeration` in interface `Field`
  Throws:
    `VisADException`
    `RemoteException`