## visad
Class Gridded3DDoubleSet

    java.lang.Object
      visad.ThingImpl
          visad.DataImpl
              visad.Set
                  visad.SimpleSet
                      visad.SampledSet
                          visad.GriddedSet
                              visad.Gridded3DSet
                                  visad.Gridded3DDoubleSet

All Implemented Interfaces:
  Cloneable, Data, GriddedDoubleSet, GriddedSetIface, SampledSetIface, Serializable, SetIface, SimpleSetIface, Thing

public class Gridded3DDoubleSet
extends Gridded3DSet
implements GriddedDoubleSet

Gridded3DDoubleSet is a Gridded3DSet with double-precision samples.

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) double[]` `Hi`
`(package private) double` `HiX`
`(package private) double` `HiY`
`(package private) double` `HiZ`
`(package private) double[]` `Low`
`(package private) double` `LowX`
`(package private) double` `LowY`
`(package private) double` `LowZ`
`(package private) double[][]` `Samples`

Fields inherited from class visad.Gridded3DSet
`BIG_NEG, case_E9, EPS_0, FALSE, incXn, incYn, incZn, ITAB, LengthX, LengthY, LengthZ, MASK, MAX_FLAG_NUM, NTAB, pol_edges, SF_6B, SF_6D, SF_79, SF_97, SF_9E, SF_B6, SF_D6, SF_E9, sp_cases, STAB, TRUE, Xn, Xp, Yn, Yp, Zn, Zp`

Fields inherited from class visad.GriddedSet
`EPS, Lengths, Pos`

Fields inherited from class visad.SimpleSet
`ManifoldDimension`

Fields inherited from class visad.Set
`DomainCoordinateSystem, DomainDimension, hashCode, hashCodeSet, Length, SetErrors, SetUnits`

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
`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX)` a 3-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type

`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)`
a 3-D set with manifold dimension = 1; samples array is organized double[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)`
`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY)` a 3-D set with manifold dimension = 2, with null errors, CoordinateSystem and Units are defaults from type

`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)`
a 3-D set with manifold dimension = 2; samples array is organized double[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)`
`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, int lengthZ)` a 3-D set whose topology is a lengthX x lengthY x lengthZ grid, with null errors, CoordinateSystem and Units are defaults from type

`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)`
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized double[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)`
`Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy, boolean test)`
`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX)` a 3-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type

`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)`
a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)`
`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY)` a 3-D set with manifold dimension = 2, with null errors, CoordinateSystem and Units are defaults from type

`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)`
a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)`
`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ)` a 3-D set whose topology is a lengthX x lengthY x lengthZ grid, with null errors, CoordinateSystem and Units are defaults from type

`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)`
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

`Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)`

Method Summary
`Object` `clone()` Clones this instance.
`Object` `cloneButType(MathType type)` Clones this set -- changing the MathType.
`void` `cram_missing(boolean[] range_select)`
`double[][]` `doubleToGrid(double[][] value)` transform an array of values in R^DomainDimension to an array of non-integer grid coordinates
`int[]` `doubleToIndex(double[][] value)` convert an array of values in R^DomainDimension to an array of 1-D indices
`void` `doubleToInterp(double[][] value, int[][] indices, double[][] weights)` for each of an array of values in R^DomainDimension, compute an array of 1-D indices and an array of weights, to be used for interpolation; indices[i] and weights[i] are null if i-th value is outside grid (i.e., if no interpolation is possible)
`boolean` `equals(Object set)` test for equality
`double[][]` `getDoubles()` Returns an enumeration of the samples of the set in index order.
`double[][]` `getDoubles(boolean copy)` Returns an enumeration of the samples of the set in index order.
`float[][]` `getSamples()` Returns an enumeration of the samples of the set in index order.
`float[][]` `getSamples(boolean copy)` Returns an enumeration of the samples of the set in index order.
`double[][]` `gridToDouble(double[][] grid)` transform an array of non-integer grid coordinates to an array of values in R^DomainDimension
`float[][]` `gridToValue(float[][] grid)` transform an array of non-integer grid coordinates to an array of values in R^DomainDimension
`double[][]` `indexToDouble(int[] index)` convert an array of 1-D indices to an array of values in R^DomainDimension
`float[][]` `indexToValue(int[] index)` convert an array of 1-D indices to an array of values in R^DomainDimension
`(package private) void` `init_doubles(double[][] samples, boolean copy)`
`boolean` `isMissing()`
`float[][]` `valueToGrid(float[][] value)` transform an array of values in R^DomainDimension to an array of non-integer grid coordinates
`int[]` `valueToIndex(float[][] value)` convert an array of values in R^DomainDimension to an array of 1-D indices
`void` `valueToInterp(float[][] value, int[][] indices, float[][] weights)` for each of an array of values in R^DomainDimension, compute an array of 1-D indices and an array of weights, to be used for interpolation; indices[i] and weights[i] are null if i-th value is outside grid (i.e., if no interpolation is possible)

Methods inherited from class visad.Gridded3DSet
`flags, getNormals, getStartPoint, main, make_lengths, make_normals, make2DGeometry, makeIsoLines, makeIsoSurface, makeNormals, poly_triangle_stripe`

Methods inherited from class visad.GriddedSet
`create, create, create, create, getLength, getLengths, getNeighbors, getNeighbors, getWedge, hashCode, longString, makeSpatial`

Methods inherited from class visad.SampledSet
`computeRanges, computeRanges, cram_samples, getHi, getLow, getNeighbors, init_samples, init_samples, make1DGeometry, make3DGeometry, makePointGeometry, setGeometryArray, setGeometryArray`

Methods inherited from class visad.SimpleSet
`getManifoldDimension, setAnimationSampling`

Methods inherited from class visad.Set
`__getitem__, __len__, addEqualsCache, addNotEqualsCache, adjustType, copyDoubles, copyFloats, doubleToFloat, equalUnitAndCS, floatToDouble, getCoordinateSystem, getDimension, getDimension, getLength, getSetErrors, getSetUnits, longString, merge1DSets, testEqualsCache, testNotEqualsCache, unary, unitAndCSHashCode`

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, adjustSamplingError, asin, asin, asinDegrees, asinDegrees, atan, atan, atan2, atan2, atan2Degrees, atan2Degrees, atanDegrees, atanDegrees, binary, binary, ceil, ceil, changeMathType, computeRanges, computeRanges, computeReferenceRanges, cos, cos, cosDegrees, cosDegrees, dataClone, divide, divide, exp, exp, floor, floor, getType, invertOp, local, log, log, 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, notify, notifyAll, wait, wait, wait`

Methods inherited from interface visad.SampledSetIface
`getHi, getLow`

Methods inherited from interface visad.SetIface
`equalUnitAndCS, getCoordinateSystem, getDimension, getLength, getManifoldDimension, getNeighbors, getSetErrors, getSetUnits, make1DGeometry, make3DGeometry, makePointGeometry, merge1DSets`

Methods inherited from interface visad.Data

`abs, abs, acos, acos, acosDegrees, acosDegrees, add, add, adjustSamplingError, asin, asin, asinDegrees, asinDegrees, atan, atan, atan2, atan2, atan2Degrees, atan2Degrees, atanDegrees, atanDegrees, binary, binary, ceil, ceil, changeMathType, computeRanges, 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, unary`

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

Field Detail

### Low

    double[] Low

### Hi

    double[] Hi

### LowX

    double LowX

### HiX

    double HiX

### LowY

    double LowY

### HiY

    double HiY

### LowZ

    double LowZ

### HiZ

    double HiZ

### Samples

    double[][] Samples

Constructor Detail

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              int lengthY,
                              int lengthZ)
                       throws VisADException

  a 3-D set whose topology is a lengthX x lengthY x lengthZ grid, with null errors, CoordinateSystem and Units are defaults from type

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              int lengthY,
                              int lengthZ,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors)
                       throws VisADException

  a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              int lengthY,
                              int lengthZ,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors,
                              boolean copy)
                       throws VisADException

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              int lengthY)
                       throws VisADException

  a 3-D set with manifold dimension = 2, with null errors, CoordinateSystem and Units are defaults from type

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              int lengthY,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors)
                       throws VisADException

  a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              int lengthY,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors,
                              boolean copy)
                       throws VisADException

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX)
                       throws VisADException

  a 3-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors)
                       throws VisADException

  a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              float[][] samples,
                              int lengthX,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors,
                              boolean copy)
                       throws VisADException

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              int lengthY,
                              int lengthZ)
                       throws VisADException

  a 3-D set whose topology is a lengthX x lengthY x lengthZ grid, with null errors, CoordinateSystem and Units are defaults from type

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              int lengthY,
                              int lengthZ,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors)
                       throws VisADException

  a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized double[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              int lengthY,
                              int lengthZ,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors,
                              boolean copy)
                       throws VisADException

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              int lengthY,
                              int lengthZ,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors,
                              boolean copy,
                              boolean test)
                       throws VisADException

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              int lengthY)
                       throws VisADException

  a 3-D set with manifold dimension = 2, with null errors, CoordinateSystem and Units are defaults from type

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              int lengthY,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors)
                       throws VisADException

  a 3-D set with manifold dimension = 2; samples array is organized double[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              int lengthY,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors,
                              boolean copy)
                       throws VisADException

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX)
                       throws VisADException

  a 3-D set with manifold dimension = 1, with null errors, CoordinateSystem and Units are defaults from type

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors)
                       throws VisADException

  a 3-D set with manifold dimension = 1; samples array is organized double[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

### Gridded3DDoubleSet

    public Gridded3DDoubleSet(MathType type,
                              double[][] samples,
                              int lengthX,
                              CoordinateSystem coord_sys,
                              Unit[] units,
                              ErrorEstimate[] errors,
                              boolean copy)
                       throws VisADException

Method Detail

### getSamples

    public float[][] getSamples()
                         throws VisADException

  Description copied from interface: `SetIface`
  Returns an enumeration of the samples of the set in index order. This is the same as `getSamples(true)`.

  Specified by:
    `getSamples` in interface `SetIface`
  Overrides:
    `getSamples` in class `SampledSet`
  Returns:
    A copy of the sample array.
  Throws:
    `VisADException`
  See Also:
    `SampledSet.getSamples(boolean)`

### getSamples

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

  Description copied from interface: `SetIface`
  Returns an enumeration of the samples of the set in index order.

  Specified by:
    `getSamples` in interface `SetIface`
  Overrides:
    `getSamples` in class `SampledSet`
  Parameters:
    `copy` - Whether or not a copy of the sample array should be returned.
  Returns:
    The sample array is `copy` is `false; otherwise, a copy of the sample array.`
  Throws:
    `VisADException`

### indexToValue

    public float[][] indexToValue(int[] index)
                           throws VisADException

  convert an array of 1-D indices to an array of values in R^DomainDimension

  Specified by:
    `indexToValue` in interface `SetIface`
  Overrides:
    `indexToValue` in class `Gridded3DSet`
  Throws:
    `VisADException`

### valueToIndex

    public int[] valueToIndex(float[][] value)
                       throws VisADException

  convert an array of values in R^DomainDimension to an array of 1-D indices

  Specified by:
    `valueToIndex` in interface `SetIface`
  Overrides:
    `valueToIndex` in class `Gridded3DSet`
  Throws:
    `VisADException`

### gridToValue

    public float[][] gridToValue(float[][] grid)
                          throws VisADException

  transform an array of non-integer grid coordinates to an array of values in R^DomainDimension

  Specified by:
    `gridToValue` in interface `GriddedSetIface`
  Overrides:
    `gridToValue` in class `Gridded3DSet`
  Throws:
    `VisADException`

### valueToGrid

    public float[][] valueToGrid(float[][] value)
                          throws VisADException

  transform an array of values in R^DomainDimension to an array of non-integer grid coordinates

  Specified by:
    `valueToGrid` in interface `GriddedSetIface`
  Overrides:
    `valueToGrid` in class `Gridded3DSet`
  Throws:
    `VisADException`

### valueToInterp

    public void valueToInterp(float[][] value,
                              int[][] indices,
                              float[][] weights)
                       throws VisADException

  for each of an array of values in R^DomainDimension, compute an array of 1-D indices and an array of weights, to be used for interpolation; indices[i] and weights[i] are null if i-th value is outside grid (i.e., if no interpolation is possible)

  Specified by:
    `valueToInterp` in interface `SimpleSetIface`
  Overrides:
    `valueToInterp` in class `GriddedSet`
  Throws:
    `VisADException`

### getDoubles

    public double[][] getDoubles()
                          throws VisADException

  Description copied from interface: `SetIface`
  Returns an enumeration of the samples of the set in index order. This is the same as `getDoubles(true)`.

  Specified by:
    `getDoubles` in interface `SetIface`
  Overrides:
    `getDoubles` in class `Set`
  Throws:
    `VisADException`

### getDoubles

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

  Description copied from interface: `SetIface`
  Returns an enumeration of the samples of the set in index order.

  Specified by:
    `getDoubles` in interface `GriddedDoubleSet`
  Overrides:
    `getDoubles` in class `Set`
  Throws:
    `VisADException`

### indexToDouble

    public double[][] indexToDouble(int[] index)
                             throws VisADException

  convert an array of 1-D indices to an array of values in R^DomainDimension

  Specified by:
    `indexToDouble` in interface `GriddedDoubleSet`
  Overrides:
    `indexToDouble` in class `Set`
  Parameters:
    `index` - The indicies of the sample points.
  Returns:
    A corresponding array of sample-point values. RETURN_VALUE`[i][j]` is the `j`th component of sample-point `i`.
  Throws:
    `VisADException` - if a VisAD failure occurs.

### doubleToIndex

    public int[] doubleToIndex(double[][] value)
                        throws VisADException

  convert an array of values in R^DomainDimension to an array of 1-D indices

  Specified by:
    `doubleToIndex` in interface `GriddedDoubleSet`
  Overrides:
    `doubleToIndex` in class `Set`
  Throws:
    `VisADException`

### gridToDouble

    public double[][] gridToDouble(double[][] grid)
                            throws VisADException

  transform an array of non-integer grid coordinates to an array of values in R^DomainDimension

  Specified by:
    `gridToDouble` in interface `GriddedDoubleSet`
  Throws:
    `VisADException`

### doubleToGrid

    public double[][] doubleToGrid(double[][] value)
                            throws VisADException

  transform an array of values in R^DomainDimension to an array of non-integer grid coordinates

  Specified by:
    `doubleToGrid` in interface `GriddedDoubleSet`
  Throws:
    `VisADException`

### doubleToInterp

    public void doubleToInterp(double[][] value,
                               int[][] indices,
                               double[][] weights)
                        throws VisADException

  for each of an array of values in R^DomainDimension, compute an array of 1-D indices and an array of weights, to be used for interpolation; indices[i] and weights[i] are null if i-th value is outside grid (i.e., if no interpolation is possible)

  Specified by:
    `doubleToInterp` in interface `GriddedDoubleSet`
  Throws:
    `VisADException`

### init_doubles

    void init_doubles(double[][] samples,
                      boolean copy)
                throws VisADException

  Throws:
    `VisADException`

### cram_missing

    public void cram_missing(boolean[] range_select)

  Specified by:
    `cram_missing` in interface `SetIface`
  Overrides:
    `cram_missing` in class `SampledSet`

### isMissing

    public boolean isMissing()

  Specified by:
    `isMissing` in interface `Data`
  Overrides:
    `isMissing` in class `SampledSet`

### equals

    public boolean equals(Object set)

  Description copied from class: `Set`
  test for equality

  Specified by:
    `equals` in interface `SetIface`
  Overrides:
    `equals` in class `GriddedSet`

### clone

    public Object clone()

  Clones this instance.

  Overrides:
    `clone` in class `SampledSet`
  Returns:
    A clone of this instance.

### cloneButType

    public Object cloneButType(MathType type)
                        throws VisADException

  Description copied from interface: `SetIface`
  Clones this set -- changing the MathType.

  Specified by:
    `cloneButType` in interface `SetIface`
  Overrides:
    `cloneButType` in class `Gridded3DSet`
  Throws:
    `VisADException`