|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use Unit | |
|---|---|
| visad | The core VisAD package, providing support for VisAD's Data & MathType hierarchy, as well as for VisAD Displays and remote collaboration. |
| visad.bom | |
| visad.cluster | |
| visad.data | Provides for importing data to and exporting data from VisAD. |
| visad.data.gis | |
| visad.data.hdfeos | Provides for importing an HDF-EOS dataset into VisAD. |
| visad.data.netcdf | Provides for importing a netCDF dataset into VisAD and for exporting a VisAD data object to a netCDF dataset. |
| visad.data.netcdf.in | Provides for importing a netCDF dataset into VisAD. |
| visad.data.netcdf.units | |
| visad.data.units | |
| visad.data.visad | Provides for importing and exporting serialized Java object files into and out of VisAD. |
| visad.data.visad.object | |
| visad.georef | Provides classes for geo-referencing. |
| visad.java2d | Provides support for two-dimensional VisAD Displays using Java2D. |
| visad.java3d | Provides support for two- and three-dimensional VisAD Displays using Java3D. |
| visad.jmet | |
| visad.math | |
| visad.matrix | |
| visad.python | |
| visad.sounder | |
| visad.util | Provides a collection of useful utilities, many of them GUI widgets, to aid in VisAD application design. |
| Uses of Unit in visad |
|---|
| Subclasses of Unit in visad | |
|---|---|
class |
BaseUnit
A class that represents the base units of a system of units. |
class |
DerivedUnit
A class that represents a unit consisting of zero or more base units. |
class |
LogarithmicUnit
A class that represents a scaled unit with an offset. |
class |
OffsetUnit
A class that represents a scaled unit with an offset. |
class |
PromiscuousUnit
PromiscuousUnit is the VisAD class for units that are convertable with any other Unit. |
class |
ScaledUnit
A class that represents a certain amount of a derived unit. |
| Fields in visad declared as Unit | |
|---|---|
static Unit |
CommonUnit.degree
CommonUnit for plane angle, not temperature |
static Unit |
CommonUnit.dimensionless
CommonUnit for all BaseUnits with exponent = zero |
static Unit |
CommonUnit.meter
CommonUnit for length |
static Unit |
CommonUnit.meterPerSecond
CommonUnit for speed |
static Unit |
CommonUnit.promiscuous
promiscuous is compatible with any Unit; useful for constants; not the same as null Unit, which is only compatible with other null Units; not the same as dimensionless, which is not compatible with other Units for addition and subtraction |
static Unit |
CommonUnit.radian
CommonUnit for plane angle |
protected Unit[] |
FlatField.RangeUnits
|
static Unit |
CommonUnit.second
CommonUnit for time |
static Unit |
CommonUnit.secondsSinceTheEpoch
CommonUnit for seconds since the Epoch (i.e. 1970-01-01 00:00:00Z) |
| Methods in visad that return Unit | |
|---|---|
Unit |
Unit.clone(String identifier)
Clones this unit, changing the identifier. |
static Unit[] |
Unit.copyUnitsArray(Unit[] units)
Copys an array of units. |
Unit |
PromiscuousUnit.divide(PromiscuousUnit that)
|
abstract Unit |
Unit.divide(Unit that)
Divide this unit by another unit. |
Unit |
ScaledUnit.divide(Unit that)
Divides this unit by another unit. |
Unit |
PromiscuousUnit.divide(Unit that)
|
Unit |
OffsetUnit.divide(Unit that)
Divide an offset unit by another unit. |
Unit |
LogarithmicUnit.divide(Unit that)
Divide this unit by another unit. |
Unit |
DerivedUnit.divide(Unit that)
Divide a derived unit by another unit. |
Unit |
BaseUnit.divide(Unit that)
Divide this unit by another unit. |
protected abstract Unit |
Unit.divideInto(Unit that)
Divide this unit into another unit. |
protected Unit |
ScaledUnit.divideInto(Unit that)
Divides this unit into another unit. |
protected Unit |
PromiscuousUnit.divideInto(Unit that)
|
protected Unit |
OffsetUnit.divideInto(Unit that)
Divide an offset unit into another unit. |
protected Unit |
LogarithmicUnit.divideInto(Unit that)
Divide this unit into another unit. |
protected Unit |
DerivedUnit.divideInto(Unit that)
Divide a derived unit into another unit. |
protected Unit |
BaseUnit.divideInto(Unit that)
Divide this unit into another unit. |
Unit |
Unit.getAbsoluteUnit()
Gets the absolute unit of this unit. |
Unit |
OffsetUnit.getAbsoluteUnit()
Gets the absolute unit of this unit. |
Unit |
LogarithmicUnit.getAbsoluteUnit()
Gets the absolute unit of this unit. |
Unit[] |
CoordinateSystem.getCoordinateSystemUnits()
Return the Units for this CoordinateSystem. |
Unit[] |
RemoteFieldImpl.getDefaultRangeUnits()
|
Unit[] |
FlatField.getDefaultRangeUnits()
Get default range Unit-s for 'Flat' components. |
Unit[] |
FieldImpl.getDefaultRangeUnits()
get default range Unit-s for 'Flat' components |
Unit[] |
Field.getDefaultRangeUnits()
get default range Unit-s for 'Flat' components |
Unit |
RealType.getDefaultUnit()
get default Unit |
Unit[] |
RealTupleType.getDefaultUnits()
get default Units of RealType components; copy DefaultUnits array to ensure that it cannot be altered |
Unit[] |
RemoteFunctionImpl.getDomainUnits()
|
Unit[] |
RemoteFieldImpl.getDomainUnits()
|
Unit[] |
FunctionImpl.getDomainUnits()
Get the default Units of the Real components of the domain. |
Unit[] |
Function.getDomainUnits()
Get the default Units of the Real components of the domain. |
Unit[] |
FieldImpl.getDomainUnits()
Returns the units of the values in the domain set. |
Unit[] |
DataRenderer.getEarthUnits()
|
Unit |
ScalarMap.getOverrideUnit()
Return the override unit. |
Unit[][] |
RemoteFieldImpl.getRangeUnits()
|
Unit[][] |
FlatField.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) |
Unit[][] |
FieldImpl.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 |
Unit[][] |
Field.getRangeUnits()
get range Unit-s for 'Flat' components; second index may enumerate samples, if they differ |
Unit[] |
CoordinateSystem.getReferenceUnits()
Return the Units for this CoordinateSystem's reference RealTupleType. |
Unit[] |
SetIface.getSetUnits()
Returns the units of the samples in the set. |
Unit[] |
Set.getSetUnits()
Returns the units of the values in the set. |
Unit[] |
RealTupleIface.getTupleUnits()
Returns the units of the components. |
Unit[] |
RealTuple.getTupleUnits()
get Units of Real components |
Unit[] |
DoubleTuple.getTupleUnits()
Get Units of Real components |
Unit |
ScaledUnit.getUnit()
Get the underlying unit |
Unit |
RealIface.getUnit()
Returns the unit of this instance. |
Unit |
Real.getUnit()
|
Unit |
ErrorEstimate.getUnit()
Get the Unit for this error distribution. |
abstract Unit |
Unit.log(double base)
Returns the logarithmic unit that has this unit as its reference level. |
Unit |
ScaledUnit.log(double base)
|
Unit |
PromiscuousUnit.log(double base)
|
Unit |
OffsetUnit.log(double base)
|
Unit |
LogarithmicUnit.log(double base)
|
Unit |
DerivedUnit.log(double base)
|
Unit |
BaseUnit.log(double base)
|
Unit |
DerivedUnit.multiply(DerivedUnit that)
Multiply a derived unit by a derived unit. |
abstract Unit |
Unit.multiply(Unit that)
Multiply this unit by another unit. |
Unit |
ScaledUnit.multiply(Unit that)
Multiplies this unit by another unit. |
Unit |
PromiscuousUnit.multiply(Unit that)
|
Unit |
OffsetUnit.multiply(Unit that)
Multiply an offset unit by another unit. |
Unit |
LogarithmicUnit.multiply(Unit that)
Multiply this unit by another unit. |
Unit |
DerivedUnit.multiply(Unit that)
Multiply a derived unit by another unit. |
Unit |
BaseUnit.multiply(Unit that)
Multiply this unit by another unit. |
abstract Unit |
Unit.pow(double power)
Raise a unit to a power. |
Unit |
ScaledUnit.pow(double power)
Raises this unit to a power. |
Unit |
PromiscuousUnit.pow(double power)
|
Unit |
OffsetUnit.pow(double power)
Raises an offset unit to a power. |
Unit |
LogarithmicUnit.pow(double power)
Raises this unit to a power. |
Unit |
DerivedUnit.pow(double power)
Raise a derived unit to a power. |
Unit |
BaseUnit.pow(double power)
Raise a unit to a power. |
abstract Unit |
Unit.pow(int power)
Raise this unit to a power. |
Unit |
ScaledUnit.pow(int power)
Raises this unit to a power. |
Unit |
PromiscuousUnit.pow(int power)
|
Unit |
OffsetUnit.pow(int power)
Raises an offset unit to a power. |
Unit |
LogarithmicUnit.pow(int power)
Raises this unit to a power. |
Unit |
DerivedUnit.pow(int power)
Raise a derived unit to a power. |
Unit |
BaseUnit.pow(int power)
Raise a base unit to a power. |
protected abstract Unit |
Unit.protectedClone(String identifier)
Clones this unit, changing the identifier. |
protected Unit |
ScaledUnit.protectedClone(String identifier)
Clones this unit, changing the identifier. |
protected Unit |
PromiscuousUnit.protectedClone(String identifier)
Clones this unit, changing the identifier. |
protected Unit |
OffsetUnit.protectedClone(String identifier)
Clones this unit, changing the identifier. |
protected Unit |
LogarithmicUnit.protectedClone(String identifier)
Clones this unit, changing the identifier. |
protected Unit |
DerivedUnit.protectedClone(String identifier)
Clones this unit, changing the identifier. |
protected Unit |
BaseUnit.protectedClone(String identifier)
Clones this unit, changing the identifier. |
abstract Unit |
Unit.root(int root)
Returns the N-th root of this unit. |
Unit |
ScaledUnit.root(int root)
Returns the N-th root of this unit. |
Unit |
PromiscuousUnit.root(int root)
|
Unit |
OffsetUnit.root(int root)
Returns the N-th root of this unit. |
Unit |
LogarithmicUnit.root(int root)
Returns the N-th root of this unit. |
Unit |
DerivedUnit.root(int root)
Returns the N-th root of this unit. |
Unit |
BaseUnit.root(int root)
Returns the N-th root of this unit. |
abstract Unit |
Unit.scale(double amount)
Scale this unit by an amount. |
Unit |
ScaledUnit.scale(double amount)
|
Unit |
PromiscuousUnit.scale(double amount)
|
Unit |
OffsetUnit.scale(double amount)
|
Unit |
LogarithmicUnit.scale(double scale)
|
Unit |
DerivedUnit.scale(double amount)
Scale this unit by an amount. |
Unit |
BaseUnit.scale(double amount)
|
abstract Unit |
Unit.shift(double offset)
Shift this unit by an amount. |
Unit |
ScaledUnit.shift(double offset)
|
Unit |
PromiscuousUnit.shift(double offset)
|
Unit |
OffsetUnit.shift(double offset)
|
Unit |
LogarithmicUnit.shift(double offset)
|
Unit |
DerivedUnit.shift(double offset)
Shift this unit by an amount. |
Unit |
BaseUnit.shift(double offset)
|
Unit |
Unit.sqrt()
Returns the square-root of this unit. |
| Methods in visad with parameters of type Unit | |
|---|---|
static boolean |
Unit.canConvert(Unit unita,
Unit unitb)
Indicates if values in two units are convertible. |
static boolean |
Unit.canConvertArray(Unit[] unita,
Unit[] unitb)
Indicates whether or not two unit arrays are convertible. |
static boolean |
Unit.canConvertArray(Unit[] unita,
Unit[] unitb)
Indicates whether or not two unit arrays are convertible. |
Real |
RealIface.cloneButUnit(Unit u)
Returns a clone of this instance but with a new Unit. |
Real |
Real.cloneButUnit(Unit u)
clone this, but with a new Unit |
protected FlatField |
FlatField.cloneDouble(MathType f_type,
Unit[] units,
ErrorEstimate[] errors)
|
protected FlatField |
FlatField.cloneDouble(MathType f_type,
Unit[] units,
ErrorEstimate[] errors,
double[][] newValues)
|
protected FlatField |
FlatField.cloneFloat(MathType f_type,
Unit[] units,
ErrorEstimate[] errors)
|
protected FlatField |
FlatField.cloneFloat(MathType f_type,
Unit[] units,
ErrorEstimate[] errors,
float[][] newValues)
|
static double[][] |
Unit.convertTuple(double[][] value,
Unit[] units_in,
Unit[] units_out)
Converts a tuple of double value arrays; returning a new tuple. |
static double[][] |
Unit.convertTuple(double[][] value,
Unit[] units_in,
Unit[] units_out)
Converts a tuple of double value arrays; returning a new tuple. |
static double[][] |
Unit.convertTuple(double[][] value,
Unit[] units_in,
Unit[] units_out,
boolean copy)
Converts a tuple of double value arrays, optionally returning a new tuple depending on the value of copy. |
static double[][] |
Unit.convertTuple(double[][] value,
Unit[] units_in,
Unit[] units_out,
boolean copy)
Converts a tuple of double value arrays, optionally returning a new tuple depending on the value of copy. |
static float[][] |
Unit.convertTuple(float[][] value,
Unit[] units_in,
Unit[] units_out)
Converts a tuple of float value arrays; returning a new tuple. |
static float[][] |
Unit.convertTuple(float[][] value,
Unit[] units_in,
Unit[] units_out)
Converts a tuple of float value arrays; returning a new tuple. |
static float[][] |
Unit.convertTuple(float[][] value,
Unit[] units_in,
Unit[] units_out,
boolean copy)
Converts a tuple of float value arrays, optionally returning a new tuple depending on the value of copy. |
static float[][] |
Unit.convertTuple(float[][] value,
Unit[] units_in,
Unit[] units_out,
boolean copy)
Converts a tuple of float value arrays, optionally returning a new tuple depending on the value of copy. |
static Unit[] |
Unit.copyUnitsArray(Unit[] units)
Copys an array of units. |
static ScaledUnit |
ScaledUnit.create(double amount,
Unit unit)
Factory method for creating a scaled unit. |
static Gridded1DDoubleSet |
Gridded1DDoubleSet.create(MathType type,
double[] samples,
CoordinateSystem coordSys,
Unit unit,
ErrorEstimate error)
Returns an instance of this class. |
static LinearSet |
LinearNDSet.create(MathType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
static GriddedSet |
GriddedSet.create(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.). |
static GriddedSet |
GriddedSet.create(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.). |
static GriddedSet |
GriddedSet.create(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.). |
static Gridded1DSet |
Gridded1DSet.create(MathType type,
float[] samples,
CoordinateSystem coordSys,
Unit unit,
ErrorEstimate error)
Returns an instance of this class. |
static GriddedSet |
IntegerNDSet.create(MathType type,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
General factory method for creating the proper integer set (Integer1DSet, Integer2DSet, etc.). |
abstract Unit |
Unit.divide(Unit that)
Divide this unit by another unit. |
Unit |
ScaledUnit.divide(Unit that)
Divides this unit by another unit. |
Unit |
PromiscuousUnit.divide(Unit that)
|
Unit |
OffsetUnit.divide(Unit that)
Divide an offset unit by another unit. |
Unit |
LogarithmicUnit.divide(Unit that)
Divide this unit by another unit. |
Unit |
DerivedUnit.divide(Unit that)
Divide a derived unit by another unit. |
Unit |
BaseUnit.divide(Unit that)
Divide this unit by another unit. |
protected abstract Unit |
Unit.divideInto(Unit that)
Divide this unit into another unit. |
protected Unit |
ScaledUnit.divideInto(Unit that)
Divides this unit into another unit. |
protected Unit |
PromiscuousUnit.divideInto(Unit that)
|
protected Unit |
OffsetUnit.divideInto(Unit that)
Divide an offset unit into another unit. |
protected Unit |
LogarithmicUnit.divideInto(Unit that)
Divide this unit into another unit. |
protected Unit |
DerivedUnit.divideInto(Unit that)
Divide a derived unit into another unit. |
protected Unit |
BaseUnit.divideInto(Unit that)
Divide this unit into another unit. |
abstract boolean |
Unit.equals(Unit unit)
Indicates whether or not this instance is equal to a unit. |
boolean |
ScaledUnit.equals(Unit unit)
Indicates if this instance is equal to a unit. |
boolean |
PromiscuousUnit.equals(Unit unit)
|
boolean |
OffsetUnit.equals(Unit unit)
Indicates if this instance equals a unit. |
boolean |
LogarithmicUnit.equals(Unit unit)
Indicates if this instance equals a unit. |
boolean |
DerivedUnit.equals(Unit unit)
Indicates if this instance equals a unit. |
boolean |
BaseUnit.equals(Unit unit)
Indicates whether or not this instance equals a unit. |
double[][] |
CoordinateSystem.fromReference(double[][] value,
Unit[] units)
Convert values in Units specified to this CoordinateSystem's Units. |
float[][] |
CoordinateSystem.fromReference(float[][] value,
Unit[] units)
Convert values in Units specified to this CoordinateSystem's Units. |
static RealType |
RealType.getRealType(String name,
Unit u)
Returns a RealType corresponding to a name and unit. |
static RealType |
RealType.getRealType(String name,
Unit u,
int attrMask)
Returns a RealType corresponding to a name, unit, and attribute mask. |
static RealType |
RealType.getRealType(String name,
Unit u,
Set set)
Returns a RealType corresponding to a name, unit, and representational set. |
static RealType |
RealType.getRealType(String name,
Unit u,
Set set,
int attrMask)
Returns a RealType corresponding to a name, unit, representational set, and attribute mask. |
double |
RealIface.getValue(Unit unit_out)
Returns the numeric value in a particular unit. |
double |
Real.getValue(Unit unit_out)
Get the value for this Real converted to unit_out. |
abstract boolean |
Unit.isConvertible(Unit unit)
Indicate whether this unit is convertible with another unit. |
boolean |
ScaledUnit.isConvertible(Unit unit)
Indicate whether this unit is convertible with another unit. |
boolean |
PromiscuousUnit.isConvertible(Unit unit)
Indicate whether this unit is convertible with another unit. |
boolean |
OffsetUnit.isConvertible(Unit unit)
Indicate whether this unit is convertible with another unit. |
boolean |
LogarithmicUnit.isConvertible(Unit unit)
Indicate whether this unit is convertible with another unit. |
boolean |
DerivedUnit.isConvertible(Unit unit)
Indicate whether this unit is convertible with another unit. |
boolean |
BaseUnit.isConvertible(Unit unit)
Indicate whether this unit is convertible with another unit. |
boolean |
ShadowType.makeContour(int valueArrayLength,
int[] valueToScalar,
float[][] display_values,
int[] inherited_values,
Vector MapVector,
int[] valueToMap,
int domain_length,
boolean[][] range_select,
int spatialManifoldDimension,
Set spatial_set,
byte[][] color_values,
boolean indexed,
Object group,
GraphicsModeControl mode,
boolean[] swap,
float constant_alpha,
float[] constant_color,
ShadowType shadow_api,
ShadowRealTupleType Domain,
ShadowRealType[] DomainReferenceComponents,
Set domain_set,
Unit[] domain_units,
CoordinateSystem dataCoordinateSystem)
|
VisADGeometryArray |
Gridded3DSet.makeIsoSurfaceMissingSpatial(float isolevel,
float[] fieldValues,
byte[][] color_values,
boolean indexed,
ShadowRealTupleType Domain,
ShadowRealTupleType domain_reference,
Unit[] domain_units,
CoordinateSystem dataCoordinateSystem,
CoordinateSystem coord_sys,
ShadowRealType[] DomainReferenceComponents,
DisplayTupleType spatial_tuple,
float[][] spatial_offset_values)
|
protected static void |
FlatField.makeRational(double[][] values,
Unit[] units,
ErrorEstimate[] errors)
Ensure that numeric values and units are in rational form, i.e. one in which ratios of data values make sense (e.g. |
protected static void |
FlatField.makeRational(float[][] values,
Unit[] units,
ErrorEstimate[] errors)
|
abstract Unit |
Unit.multiply(Unit that)
Multiply this unit by another unit. |
Unit |
ScaledUnit.multiply(Unit that)
Multiplies this unit by another unit. |
Unit |
PromiscuousUnit.multiply(Unit that)
|
Unit |
OffsetUnit.multiply(Unit that)
Multiply an offset unit by another unit. |
Unit |
LogarithmicUnit.multiply(Unit that)
Multiply this unit by another unit. |
Unit |
DerivedUnit.multiply(Unit that)
Multiply a derived unit by another unit. |
Unit |
BaseUnit.multiply(Unit that)
Multiply this unit by another unit. |
void |
DataRenderer.setEarthSpatialData(ShadowRealTupleType s_d_i,
ShadowRealTupleType s_d_o,
RealTupleType d_o,
Unit[] d_u_o,
RealTupleType d_i,
CoordinateSystem[] d_c_i,
Unit[] d_u_i)
save information about relation between earth and display spatial coordinates, IF the arguments do define the relation |
void |
DataRenderer.setEarthSpatialData(ShadowRealTupleType s_d_i,
ShadowRealTupleType s_d_o,
RealTupleType d_o,
Unit[] d_u_o,
RealTupleType d_i,
CoordinateSystem[] d_c_i,
Unit[] d_u_i)
save information about relation between earth and display spatial coordinates, IF the arguments do define the relation |
void |
ScalarMap.setOverrideUnit(Unit unit)
Set display Unit to override default Unit of Scalar; MUST be called before any data are displayed |
double[][] |
CoordinateSystem.toReference(double[][] value,
Unit[] units)
Convert values in Units specified to Reference coordinates. |
float[][] |
CoordinateSystem.toReference(float[][] value,
Unit[] units)
Convert values in Units specified to Reference coordinates. |
abstract double[] |
Unit.toThat(double[] values,
Unit that)
Convert values from this unit to another unit. |
double[] |
ScaledUnit.toThat(double[] values,
Unit that)
Convert values from this unit to another unit. |
double[] |
PromiscuousUnit.toThat(double[] values,
Unit that)
|
double[] |
OffsetUnit.toThat(double[] values,
Unit that)
Convert values from this unit to another unit. |
double[] |
LogarithmicUnit.toThat(double[] values,
Unit that)
Convert values from this unit to another unit. |
double[] |
DerivedUnit.toThat(double[] values,
Unit that)
Convert values from this unit to another unit. |
double[] |
BaseUnit.toThat(double[] values,
Unit that)
Convert values from this unit to another unit. |
double[] |
Unit.toThat(double[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
double[] |
ScaledUnit.toThat(double[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
double[] |
OffsetUnit.toThat(double[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
double[] |
LogarithmicUnit.toThat(double[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
double[] |
DerivedUnit.toThat(double[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
double[] |
BaseUnit.toThat(double[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
double |
Unit.toThat(double value,
Unit that)
Convert a value from this unit to another unit. |
abstract float[] |
Unit.toThat(float[] values,
Unit that)
Convert values from this unit to another unit. |
float[] |
ScaledUnit.toThat(float[] values,
Unit that)
Convert values from this unit to another unit. |
float[] |
PromiscuousUnit.toThat(float[] values,
Unit that)
|
float[] |
OffsetUnit.toThat(float[] values,
Unit that)
Convert values from this unit to another unit. |
float[] |
LogarithmicUnit.toThat(float[] values,
Unit that)
Convert values from this unit to another unit. |
float[] |
DerivedUnit.toThat(float[] values,
Unit that)
Convert values from this unit to another unit. |
float[] |
BaseUnit.toThat(float[] values,
Unit that)
Convert values from this unit to another unit. |
float[] |
Unit.toThat(float[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
float[] |
ScaledUnit.toThat(float[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
float[] |
OffsetUnit.toThat(float[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
float[] |
LogarithmicUnit.toThat(float[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
float[] |
DerivedUnit.toThat(float[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
float[] |
BaseUnit.toThat(float[] values,
Unit that,
boolean copy)
Convert values from this unit to another unit. |
abstract double[] |
Unit.toThis(double[] values,
Unit that)
Convert values to this unit from another unit. |
double[] |
ScaledUnit.toThis(double[] values,
Unit that)
Convert values to this unit from another unit. |
double[] |
PromiscuousUnit.toThis(double[] values,
Unit that)
|
double[] |
OffsetUnit.toThis(double[] values,
Unit that)
Convert values to this unit from another unit. |
double[] |
LogarithmicUnit.toThis(double[] values,
Unit that)
Convert values to this unit from another unit. |
double[] |
DerivedUnit.toThis(double[] values,
Unit that)
Convert values to this unit from another unit. |
double[] |
BaseUnit.toThis(double[] values,
Unit that)
Convert values to this unit from another unit. |
double[] |
Unit.toThis(double[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
double[] |
ScaledUnit.toThis(double[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
double[] |
OffsetUnit.toThis(double[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
double[] |
LogarithmicUnit.toThis(double[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
double[] |
DerivedUnit.toThis(double[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
double[] |
BaseUnit.toThis(double[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
double |
Unit.toThis(double value,
Unit that)
Convert a value to this unit from another unit. |
abstract float[] |
Unit.toThis(float[] values,
Unit that)
Convert values to this unit from another unit. |
float[] |
ScaledUnit.toThis(float[] values,
Unit that)
Convert values to this unit from another unit. |
float[] |
PromiscuousUnit.toThis(float[] values,
Unit that)
|
float[] |
OffsetUnit.toThis(float[] values,
Unit that)
Convert values to this unit from another unit. |
float[] |
LogarithmicUnit.toThis(float[] values,
Unit that)
Convert values to this unit from another unit. |
float[] |
DerivedUnit.toThis(float[] values,
Unit that)
Convert values to this unit from another unit. |
float[] |
BaseUnit.toThis(float[] values,
Unit that)
Convert values to this unit from another unit. |
float[] |
Unit.toThis(float[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
float[] |
ScaledUnit.toThis(float[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
float[] |
OffsetUnit.toThis(float[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
float[] |
LogarithmicUnit.toThis(float[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
float[] |
DerivedUnit.toThis(float[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
float[] |
BaseUnit.toThis(float[] values,
Unit that,
boolean copy)
Convert values to this unit from another unit. |
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value,
boolean copy)
Transforms double-valued coordinates between two RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value,
boolean copy)
Transforms double-valued coordinates between two RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value,
boolean copy)
Transforms float-valued coordinates between two RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinates(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value,
boolean copy)
Transforms float-valued coordinates between two RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two RealTupleTypes. |
static double[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
double[][] value)
Transforms double-valued coordinates between two RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two RealTupleTypes. |
static float[][] |
CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
ErrorEstimate[] errors_in,
float[][] value)
Transforms float-valued coordinates between two RealTupleTypes. |
static double[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
double[] value)
Transform double values and (optionally) error estimates. |
static double[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
double[] value,
boolean copy)
Transform double values and (optionally) error estimates. |
static float[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
float[] value)
Transform float values and (optionally) error estimates. |
static float[] |
Unit.transformUnits(Unit unit_out,
ErrorEstimate[] errors_out,
Unit unit_in,
ErrorEstimate error_in,
float[] value,
boolean copy)
Transform float values and (optionally) error estimates. |
RealTuple |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
double[][] inloc,
double[][] outloc,
RealTuple tuple)
transform a single vector in a RealTuple, based on a coordinate transform of the field domain. |
RealTuple |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
double[][] inloc,
double[][] outloc,
RealTuple tuple)
transform a single vector in a RealTuple, based on a coordinate transform of the field domain. |
abstract double[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
abstract double[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
double[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
double[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
double[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
double[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
double[][] inloc,
double[][] outloc,
double[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
float[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
|
float[][] |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
|
float[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
float[][] |
GridVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
float[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
float[][] |
EarthVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
ErrorEstimate[] errors_in,
ErrorEstimate[] errors_out,
float[][] inloc,
float[][] outloc,
float[][] value)
transform an array of vector values from a field, based on a coordinate transform of the field domain. |
RealTuple |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
float[][] inloc,
float[][] outloc,
RealTuple tuple)
|
RealTuple |
RealVectorType.transformVectors(RealTupleType out,
CoordinateSystem coord_out,
Unit[] units_out,
ErrorEstimate[] loc_errors_out,
RealTupleType in,
CoordinateSystem coord_in,
Unit[] units_in,
CoordinateSystem coord_vector,
float[][] inloc,
float[][] outloc,
RealTuple tuple)
|
| Constructors in visad with parameters of type Unit | |
|---|---|
CoordinateSystem(RealTupleType reference,
Unit[] units)
Constructs from the type of the reference coordinate system and units for values in this coordinate system. |
|
DateTime(double timeValue,
Unit timeUnits)
Construct a DateTime object from a tim value and a Unit |
|
DisplayRealType(String name,
boolean single,
double low,
double hi,
double def,
Unit unit)
construct a DisplayRealType |
|
DisplayRealType(String name,
boolean single,
double def,
Unit unit)
construct a DisplayRealType whose values are not scaled |
|
DoubleSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units)
construct a DoubleSet with null CoordinateSystem and Units |
|
DoubleStringTuple(TupleType type,
Data[] prototypes,
double[] doubles,
String[] strings,
Unit[] units)
|
|
DoubleStringTuple(TupleType type,
double[] doubles,
String[] strings,
Unit[] units)
Construct a DoubleStringTuple |
|
DoubleTuple(RealTupleType type,
Data[] prototypes,
double[] doubles,
Unit[] units)
|
|
DoubleTuple(RealTupleType type,
double[] doubles,
Unit[] units)
Construct a new DoubleTuple |
|
ErrorEstimate(double[] value,
double error,
Unit u)
construct an ErrorEstimate for an array of values with an error |
|
ErrorEstimate(double[] value,
Unit u,
int op,
ErrorEstimate a,
ErrorEstimate b,
int error_mode)
construct Error for an array of values that is the result of a binary operator; a and b are the ErrorEstimate-s for the operands |
|
ErrorEstimate(double[] value,
Unit u,
int op,
ErrorEstimate a,
int error_mode)
construct Error for an array of values that is the result of a unary operator; a is the ErrorEstimate for the operand |
|
ErrorEstimate(double error,
double mean,
long number,
Unit u)
construct an error distribution of number values with given mean and error (variance), in Unit unit Note that the mean and error
parameters are reversed in this method |
|
ErrorEstimate(double mean,
double error,
Unit u)
construct an error distribution of 1 value with given mean and error (variance), in Unit unit |
|
ErrorEstimate(double value,
Unit u,
int op,
ErrorEstimate a,
ErrorEstimate b,
int error_mode)
construct an ErrorEstimate for a value that is the result of a binary operator; a and b are the ErrorEstimate-s for the operands |
|
ErrorEstimate(double value,
Unit u,
int op,
ErrorEstimate a,
int error_mode)
construct an ErrorEstimate for a value that is the result of a unary operator; a is the ErrorEstimate for the operand |
|
ErrorEstimate(float[] value,
double error,
Unit u)
construct an ErrorEstimate for an array of values with an error |
|
ErrorEstimate(float[] value,
Unit u,
int op,
ErrorEstimate a,
ErrorEstimate b,
int error_mode)
construct Error for an array of values that is the result of a binary operator; a and b are the ErrorEstimate-s for the operands |
|
ErrorEstimate(float[] value,
Unit u,
int op,
ErrorEstimate a,
int error_mode)
construct Error for an array of values that is the result of a unary operator; a is the ErrorEstimate for the operand |
|
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. |
|
FloatSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units)
the set of values representable by N floats; type must be a RealType, a RealTupleType or a SetType; coordinate_system and units must be compatible with defaults for type, or may be null; a FloatSet may not be used as a Field domain |
|
Gridded1DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Gridded1DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
a 1-D sorted sequence with no regular interval. samples array is organized double[1][number_of_samples] where lengthX = number_of_samples. samples must be sorted (either increasing or decreasing). coordinate_system and units must be compatible with defaults for type, or may be null. errors may be null |
|
Gridded1DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Gridded1DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
a 1-D sorted sequence with no regular interval. samples array is organized float[1][number_of_samples] where lengthX = number_of_samples. samples must be sorted (either increasing or decreasing). coordinate_system and units must be compatible with defaults for type, or may be null. errors may be null |
|
Gridded1DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Constructs a 1-D sorted sequence with no regular interval. |
|
Gridded1DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
Constructs a 1-D sorted sequence with no regular interval. |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized double[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized double[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized float[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized float[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized float[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized float[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded2DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized double[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized double[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized double[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
double[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DDoubleSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Gridded3DSet(MathType type,
float[][] samples,
int lengthX,
int lengthY,
int lengthZ,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy,
boolean test)
|
|
GriddedSet(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a GriddedSet with samples and non-default CoordinateSystem |
|
GriddedSet(MathType type,
float[][] samples,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
IdentityCoordinateSystem(RealTupleType type,
Unit[] units)
Construct a new IdentityCoordinateSystem for
values of the type specified. |
|
ImageFlatField(FunctionType type,
Set domain_set,
CoordinateSystem[] range_coord_syses,
Set[] range_sets,
Unit[] units)
|
|
ImageFlatField(FunctionType type,
Set domain_set,
CoordinateSystem range_coord_sys,
CoordinateSystem[] range_coord_syses,
Set[] range_sets,
Unit[] units)
|
|
ImageFlatField(FunctionType type,
Set domain_set,
CoordinateSystem range_coord_sys,
Set[] range_sets,
Unit[] units)
|
|
Integer1DSet(MathType type,
int length,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a 1-dimensional set with values {0, 1, ..., length-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Integer2DSet(MathType type,
Integer1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Integer2DSet(MathType type,
int length1,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a 2-dimensional set with values {0, 1, ..., length1-1} x {0, 1, ..., length2-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Integer3DSet(MathType type,
Integer1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
Integer3DSet(MathType type,
int length1,
int length2,
int length3,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct a 3-dimensional set with values {0, 1, ..., length1-1} x {0, 1, ..., length2-1} x {0, 1, ..., length3-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
IntegerNDSet(MathType type,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct an N-dimensional set with values in the cross product of {0, 1, ..., lengths[i]-1} for i=0, ..., lengths[lengths.length-1]; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
IntegerNDSet(MathType type,
Integer1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct an N-dimensional set with values in the cross product of {0, 1, ..., lengths[i]-1} for i=0, ..., lengths[lengths.length-1]; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular1DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
a 1-D irregular set; samples array is organized float[1][number_of_samples]; samples need not be sorted - the constructor sorts samples to define a 1-D "triangulation"; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular1DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Irregular2DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
a 2-D irregular set; samples array is organized float[2][number_of_samples]; no geometric constraint on samples; if delan is non-null it defines the topology of samples (which must have manifold dimension 2), else the constructor computes a topology with manifold dimension 2; note that Gridded2DSet can be used for an irregular set with domain dimension 2 and manifold dimension 1; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular2DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan,
boolean copy)
|
|
Irregular2DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
complete constructor for constructing Irregular2DSet using sort from existing Irregular1DSet |
|
Irregular2DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
Irregular3DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
a 3-D irregular set; samples array is organized float[3][number_of_samples]; no geometric constraint on samples; if delan is non-null it defines the topology of samples (which may have manifold dimension 2 or 3), else the constructor computes a topology with manifold dimension 3; note that Gridded3DSet can be used for an irregular set with domain dimension 3 and manifold dimension 1; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
Irregular3DSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan,
boolean copy)
|
|
Irregular3DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct Irregular3DSet using sort from existing Irregular1DSet |
|
Irregular3DSet(MathType type,
float[][] samples,
int[] new2old,
int[] old2new,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
IrregularSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
construct an IrregularSet with non-default CoordinateSystem |
|
IrregularSet(MathType type,
float[][] samples,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
construct an IrregularSet with non-default CoordinateSystem and non-default Delaunay |
|
IrregularSet(MathType type,
float[][] samples,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan)
construct an IrregularSet with ManifoldDimension ! |
|
IrregularSet(MathType type,
float[][] samples,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delan,
boolean copy)
|
|
Linear1DSet(MathType type,
double first,
double last,
int length,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 1-D arithmetic progression with the specified type, coord_sys,
units and errors. |
|
Linear1DSet(MathType type,
double first,
double last,
int length,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 1-D arithmetic progression with the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
Linear2DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
double first3,
double last3,
int length3,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 3-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
double first3,
double last3,
int length3,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 3-D cross product of arithmetic progressions with the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 3-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
Linear3DSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 3-D cross product of sets, with
the specified type, coord_sys,
units and errors. |
|
LinearLatLonSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearLatLonSet(MathType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearLatLonSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearLatLonSet(MathType type,
Linear1DSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and
units. |
|
LinearNDSet(MathType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct an N-dimensional set as the product of N arithmetic progressions (lengths[i] samples between firsts[i] and lasts[i]), coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null. |
|
LinearNDSet(MathType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct an N-dimensional set as the product of N arithmetic progressions (lengths[i] samples between firsts[i] and lasts[i]), coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null. |
|
LinearNDSet(MathType type,
Linear1DSet[] l,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct an N-dimensional set as the product of N Linear1DSets; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
LinearNDSet(MathType type,
Linear1DSet[] l,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean cache)
Construct an N-dimensional set as the product of N Linear1DSets; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
List1DDoubleSet(double[] d,
MathType type,
CoordinateSystem coord_sys,
Unit[] units)
Constructs with a non-default CoordinateSystem. |
|
List1DSet(float[] d,
MathType type,
CoordinateSystem coord_sys,
Unit[] units)
Constructs with a non-default CoordinateSystem. |
|
OffsetUnit(double offset,
Unit unit)
Construct an offset unit from another unit. |
|
OffsetUnit(double offset,
Unit unit,
String identifier)
Construct an offset unit from another unit and an identifier. |
|
ProductSet(MathType type,
SampledSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
create the product of the sets array; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null |
|
QuantityDimension(Unit unit)
Constructs from an existing Unit. |
|
Real(RealType type,
double value,
Unit u)
Constructs a Real object. |
|
Real(RealType type,
double value,
Unit u,
double error)
Constructs a Real object. |
|
Real(RealType type,
double value,
Unit u,
ErrorEstimate error)
Constructs a Real object. |
|
Real(RealType type,
double value,
Unit u,
ErrorEstimate error,
boolean checkUnit)
trusted constructor for other constructors |
|
RealTuple(RealTupleType type,
Real[] reals,
CoordinateSystem coord_sys,
Unit[] units,
boolean checkUnits)
Construct a RealTuple according to an array of Real objects; coordinate_system may be null; otherwise coordinate_system.getReference() must equal type.getCoordinateSystem.getReference() |
|
RealType(String name,
Unit u)
Deprecated. Use RealType.getRealType(String, Unit) |
|
RealType(String name,
Unit u,
boolean b)
trusted constructor for initializers |
|
RealType(String name,
Unit u,
int attrMask,
boolean b)
trusted constructor for initializers |
|
RealType(String name,
Unit u,
Set set)
Deprecated. Use RealType.getRealType(String, Unit, Set) |
|
RealType(String name,
Unit u,
Set set,
int attrMask)
Deprecated. Use RealType.getRealType(String, Unit, Set, int) |
|
RealType(String name,
Unit u,
Set s,
int attrMask,
boolean b)
trusted constructor for initializers |
|
SampledSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
SampledSet(MathType type,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
ScaledUnit(double amount,
Unit unit)
Constructs a scaled unit from another unit. |
|
ScaledUnit(double amount,
Unit unit,
String identifier)
Constructs a scaled unit from another unit and an identifier. |
|
Set(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Constructs a Set object with a non-default CoordinateSystem, non-default Unit-s, and non-default errors. |
|
SimpleSet(MathType type,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
SimpleSet(MathType type,
int manifold_dimension,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
|
|
SingletonSet(RealTuple d,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors)
Construct a SingletonSet with the single sample given by a RealTuple, and a non-default CoordinateSystem, Units and ErrorEstimates. |
|
SingletonSet(RealTupleType type,
double[] values,
CoordinateSystem coordSys,
Unit[] units,
ErrorEstimate[] errors)
Constructs from a type, numeric values, units, coordinate system, and error estimates. |
|
UnionSet(MathType type,
SampledSet[] sets,
CoordinateSystem coord_sys,
Unit[] units,
ErrorEstimate[] errors,
boolean copy)
|
|
| Uses of Unit in visad.bom |
|---|
| Methods in visad.bom with parameters of type Unit | |
|---|---|
void |
ShadowImageFunctionTypeJ3D.buildCurvedTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
byte[][] color_bytes,
DisplayImpl display,
int curved_size,
ShadowRealTupleType Domain,
CoordinateSystem dataCoordinateSystem,
DataRenderer renderer,
ShadowFunctionOrSetType adaptedShadowType,
int[] start,
int lenX,
int lenY,
float[][] samples,
int bigX,
int bigY)
|
void |
ShadowImageFunctionTypeJ3D.buildCurvedTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
byte[][] color_bytes,
DisplayImpl display,
int curved_size,
ShadowRealTupleType Domain,
CoordinateSystem dataCoordinateSystem,
DataRenderer renderer,
ShadowFunctionOrSetType adaptedShadowType,
int[] start,
int lenX,
int lenY,
float[][] samples,
int bigX,
int bigY)
|
void |
ShadowImageByRefFunctionTypeJ3D.buildCurvedTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
DisplayImpl display,
int curved_size,
ShadowRealTupleType Domain,
CoordinateSystem dataCoordinateSystem,
DataRenderer renderer,
ShadowFunctionOrSetType adaptedShadowType,
int[] start,
int lenX,
int lenY,
int bigX,
int bigY,
VisADImageTile tile)
|
void |
ShadowImageByRefFunctionTypeJ3D.buildCurvedTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
DisplayImpl display,
int curved_size,
ShadowRealTupleType Domain,
CoordinateSystem dataCoordinateSystem,
DataRenderer renderer,
ShadowFunctionOrSetType adaptedShadowType,
int[] start,
int lenX,
int lenY,
int bigX,
int bigY,
VisADImageTile tile)
|
void |
ShadowImageFunctionTypeJ3D.buildLinearTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
byte[][] color_bytes,
DisplayImpl display)
|
void |
ShadowImageFunctionTypeJ3D.buildLinearTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
byte[][] color_bytes,
DisplayImpl display)
|
void |
ShadowImageByRefFunctionTypeJ3D.buildLinearTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
DisplayImpl display,
VisADImageTile tile)
|
void |
ShadowImageByRefFunctionTypeJ3D.buildLinearTexture(Object group,
Set domain_set,
Unit[] dataUnits,
Unit[] domain_units,
float[] default_values,
ShadowRealType[] DomainComponents,
int valueArrayLength,
int[] inherited_values,
int[] valueToScalar,
GraphicsModeControl mode,
float constant_alpha,
float[] value_array,
float[] constant_color,
DisplayImpl display,
VisADImageTile tile)
|
| Constructors in visad.bom with parameters of type Unit | |
|---|---|
WindPolarCoordinateSystem(RealTupleType reference,
Unit[] units)
constructor to set units |
|
| Uses of Unit in visad.cluster |
|---|
| Methods in visad.cluster that return Unit | |
|---|---|
Unit[] |
RemoteNodePartitionedFieldImpl.getDefaultRangeUnits()
|
Unit[] |
RemoteNodeFieldImpl.getDefaultRangeUnits()
|
Unit[] |
RemoteClientPartitionedFieldImpl.getDefaultRangeUnits()
|
Unit[] |
RemoteClientFieldImpl.getDefaultRangeUnits()
|
Unit[] |
RemoteNodePartitionedFieldImpl.getDomainUnits()
|
Unit[] |
RemoteNodeFieldImpl.getDomainUnits()
|
Unit[] |
RemoteClientPartitionedFieldImpl.getDomainUnits()
|
Unit[] |
RemoteClientFieldImpl.getDomainUnits()
|
Unit[][] |
RemoteNodePartitionedFieldImpl.getRangeUnits()
|
Unit[][] |
RemoteNodeFieldImpl.getRangeUnits()
|
Unit[][] |
RemoteClientPartitionedFieldImpl.getRangeUnits()
|
Unit[][] |
RemoteClientFieldImpl.getRangeUnits()
|
| Uses of Unit in visad.data |
|---|
| Methods in visad.data that return Unit | |
|---|---|
Unit[] |
FileFlatField.getDefaultRangeUnits()
|
Unit[] |
AreaImageCacheAdapter.getDefaultRangeUnits()
|
Unit[] |
FileFlatField.getDomainUnits()
|
Unit[] |
AreaImageCacheAdapter.getDomainUnits()
|
Unit[][] |
FileFlatField.getRangeUnits()
|
Unit[][] |
AreaImageCacheAdapter.getRangeUnits()
|
| Methods in visad.data with parameters of type Unit | |
|---|---|
CachedFlatField |
CachedFlatField.cloneMe(boolean copy,
FunctionType type,
Set domainSet,
CoordinateSystem rangeCoordSys,
CoordinateSystem[] rangeCoordSysArray,
Set[] rangeSets,
Unit[] units)
Clone this object |
void |
EmptyDataProcessor.processDoubleSet(SetType type,
CoordinateSystem cs,
Unit[] units,
DoubleSet set,
Object token)
|
void |
DataProcessor.processDoubleSet(SetType type,
CoordinateSystem cs,
Unit[] units,
DoubleSet set,
Object token)
|
abstract void |
BaseDataProcessor.processDoubleSet(SetType type,
CoordinateSystem cs,
Unit[] units,
DoubleSet set,
Object token)
|
void |
EmptyDataProcessor.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
void |
DataProcessor.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
abstract void |
BaseDataProcessor.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
void |
EmptyDataProcessor.processFloatSet(SetType type,
CoordinateSystem cs,
Unit[] units,
FloatSet set,
Object token)
|
void |
DataProcessor.processFloatSet(SetType type,
CoordinateSystem cs,
Unit[] units,
FloatSet set,
Object token)
|
abstract void |
BaseDataProcessor.processFloatSet(SetType type,
CoordinateSystem cs,
Unit[] units,
FloatSet set,
Object token)
|
void |
EmptyDataProcessor.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token)
|
void |
DataProcessor.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token)
|
abstract void |
BaseDataProcessor.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token)
|
void |
EmptyDataProcessor.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token)
|
void |
DataProcessor.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token)
|
void |
EmptyDataProcessor.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token)
|
void |
DataProcessor.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token)
|
abstract void |
BaseDataProcessor.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token)
|
void |
EmptyDataProcessor.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token)
|
void |
DataProcessor.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token)
|
void |
EmptyDataProcessor.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token)
|
void |
DataProcessor.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token)
|
abstract void |
BaseDataProcessor.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token)
|
void |
EmptyDataProcessor.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token)
|
void |
DataProcessor.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token)
|
void |
EmptyDataProcessor.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token)
|
void |
DataProcessor.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token)
|
abstract void |
BaseDataProcessor.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token)
|
void |
EmptyDataProcessor.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token)
|
void |
DataProcessor.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token)
|
void |
EmptyDataProcessor.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token)
|
void |
DataProcessor.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token)
|
void |
EmptyDataProcessor.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token)
|
void |
DataProcessor.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token)
|
void |
EmptyDataProcessor.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token)
|
void |
DataProcessor.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token)
|
abstract void |
BaseDataProcessor.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token)
|
void |
EmptyDataProcessor.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token)
|
void |
DataProcessor.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token)
|
void |
EmptyDataProcessor.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token)
|
void |
DataProcessor.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token)
|
void |
EmptyDataProcessor.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token)
|
void |
DataProcessor.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token)
|
void |
EmptyDataProcessor.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token)
|
void |
DataProcessor.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token)
|
abstract void |
BaseDataProcessor.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token)
|
void |
EmptyDataProcessor.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token)
|
void |
DataProcessor.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token)
|
void |
EmptyDataProcessor.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token)
|
void |
DataProcessor.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token)
|
void |
EmptyDataProcessor.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token)
|
void |
DataProcessor.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token)
|
void |
EmptyDataProcessor.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token)
|
void |
DataProcessor.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token)
|
abstract void |
BaseDataProcessor.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token)
|
void |
EmptyDataProcessor.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token)
|
void |
DataProcessor.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token)
|
abstract void |
BaseDataProcessor.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token)
|
void |
EmptyDataProcessor.processList1DSet(SetType type,
float[] list,
CoordinateSystem cs,
Unit[] units,
List1DSet set,
Object token)
|
void |
DataProcessor.processList1DSet(SetType type,
float[] list,
CoordinateSystem cs,
Unit[] units,
List1DSet set,
Object token)
|
abstract void |
BaseDataProcessor.processList1DSet(SetType type,
float[] list,
CoordinateSystem cs,
Unit[] units,
List1DSet set,
Object token)
|
void |
EmptyDataProcessor.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token)
|
void |
DataProcessor.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token)
|
abstract void |
BaseDataProcessor.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token)
|
void |
EmptyDataProcessor.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token)
|
void |
DataProcessor.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token)
|
abstract void |
BaseDataProcessor.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token)
|
void |
EmptyDataProcessor.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token)
|
void |
DataProcessor.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token)
|
abstract void |
BaseDataProcessor.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token)
|
void |
EmptyDataProcessor.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token)
|
void |
DataProcessor.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token)
|
abstract void |
BaseDataProcessor.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token)
|
void |
EmptyDataProcessor.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token)
|
void |
DataProcessor.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token)
|
abstract void |
BaseDataProcessor.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token)
|
| Constructors in visad.data with parameters of type Unit | |
|---|---|
CachedFlatField(CachedFlatField that,
boolean copy,
FunctionType type,
Set domainSet,
CoordinateSystem rangeCoordSys,
CoordinateSystem[] rangeCoordSysArray,
Set[] rangeSets,
Unit[] units)
Copy constructor |
|
CachedFlatField(FunctionType type,
Set domainSet,
CoordinateSystem rangeCoordSys,
CoordinateSystem[] rangeCoordSyses,
Set[] rangeSets,
Unit[] units,
float[][] floats)
Create a new CachedFlatField |
|
CachedFlatField(FunctionType type,
Set domainSet,
CoordinateSystem rangeCoordSys,
Set[] rangeSets,
Unit[] units,
float[][] floats)
Create a new CachedFlatField |
|
| Uses of Unit in visad.data.gis |
|---|
| Methods in visad.data.gis that return Unit | |
|---|---|
Unit |
ArcAsciiGridAdapter.getDataUnit()
Get the data units |
| Methods in visad.data.gis with parameters of type Unit | |
|---|---|
void |
ArcAsciiGridAdapter.setDataUnit(Unit newUnit)
Set the data units |
| Constructors in visad.data.gis with parameters of type Unit | |
|---|---|
ArcAsciiGridAdapter(String filename,
RealTupleType spatialType,
RealType dataType,
Unit dataUnit)
Create an ArcAsciiGridAdapter for the particular file and use the supplied RealType for the data values, and units if different from default from RealType. |
|
ArcAsciiGridAdapter(String filename,
RealType dataType,
Unit dataUnit)
Create an ArcAsciiGridAdapter for the particular file and use the supplied RealType for the data values, and units if different from default from RealType. |
|
ArcAsciiGridAdapter(String filename,
Unit dataUnit)
Create an ArcAsciiGridAdapter for the particular file and use units specified for the data. |
|
| Uses of Unit in visad.data.hdfeos |
|---|
| Methods in visad.data.hdfeos that return Unit | |
|---|---|
Unit[] |
GctpMap.getUnits()
|
| Uses of Unit in visad.data.netcdf |
|---|
| Fields in visad.data.netcdf declared as Unit | |
|---|---|
protected Unit |
QuantityDBImpl.UnitKey.unit
The default unit of the quantity. |
| Methods in visad.data.netcdf with parameters of type Unit | |
|---|---|
Quantity[] |
QuantityDBImpl.get(Unit unit)
Returns all quantities in the database whose default unit is convertible with a given unit. |
abstract Quantity[] |
QuantityDB.get(Unit unit)
Returns all quantities in the database whose default unit is convertible with a given unit. |
| Constructors in visad.data.netcdf with parameters of type Unit | |
|---|---|
QuantityDBImpl.UnitKey(Unit unit,
String name)
Constructs from the unit of a quantity and its name. |
|
| Uses of Unit in visad.data.netcdf.in |
|---|
| Methods in visad.data.netcdf.in that return Unit | |
|---|---|
Unit |
VirtualScalar.getUnit()
Gets the unit of the value. |
Unit |
VirtualReal.getUnit()
Gets the unit of the value. |
protected Unit |
View.getUnitFromAttribute(ucar.netcdf.Variable var)
Returns the unit of a netCDF variable according to the variable's unit attribute. |
| Methods in visad.data.netcdf.in with parameters of type Unit | |
|---|---|
Quantity[] |
NetcdfQuantityDB.get(Unit unit)
Returns all quantities in the database whose default unit is convertible with a given unit. |
protected boolean |
View.isTime(Unit unit)
Indicates if a unit is a unit of time. |
| Constructors in visad.data.netcdf.in with parameters of type Unit | |
|---|---|
VirtualReal(RealType type,
ucar.netcdf.Variable var,
SimpleSet rangeSet,
Unit unit,
visad.data.netcdf.in.Vetter vetter)
Constructs from a scalar type, a 1-D netCDF variable, a range set, a unit, and a value vetter. |
|
VirtualScalar(ScalarType type,
ucar.netcdf.Variable var,
SimpleSet rangeSet,
Unit unit,
visad.data.netcdf.in.Vetter vetter)
Constructs from a scalar type, a 1-D netCDF variable, a range set, a unit, and a value vetter. |
|
| Uses of Unit in visad.data.netcdf.units |
|---|
| Methods in visad.data.netcdf.units that return Unit | |
|---|---|
Unit |
DefaultUnitsDB.get(String name)
Deprecated. Use visad.data.units.DefaultUnitsDB.get(name) instead |
static Unit |
Parser.parse(String spec)
Deprecated. Use visad.data.units.Parser.parse(spec) instead |
| Methods in visad.data.netcdf.units with parameters of type Unit | |
|---|---|
void |
DefaultUnitsDB.putName(String name,
Unit u)
Deprecated. Use visad.data.units.DefaultUnitsDB.putName(name, u) instead |
void |
DefaultUnitsDB.putSymbol(String name,
Unit u)
Deprecated. Use visad.data.units.DefaultUnitsDB.putSymbol(name, u) instead |
| Uses of Unit in visad.data.units |
|---|
| Fields in visad.data.units declared as Unit | |
|---|---|
protected static Unit |
UnitParser.SECOND
The canonical time unit. |
| Methods in visad.data.units that return Unit | |
|---|---|
Unit |
UnitParser.basicExpr()
|
Unit |
UnitTable.get(String name)
Get a unit. |
Unit |
UnitsDB.get(String name)
Get a unit. |
Unit |
DefaultUnitsDB.get(String name)
Get a unit. |
protected Unit |
UnitTable.getByName(String name)
Get a unit by name. |
protected Unit |
UnitTable.getBySymbol(String symbol)
Get a unit by symbol. |
Unit |
UnitParser.logExpr()
|
Unit |
UnitParser.parse(String spec)
Parses a string unit specification. |
static Unit |
Parser.parse(String spec)
Parse a string unit-specification. |
Unit |
UnitParser.powerExpr()
|
Unit |
UnitParser.productExpr()
|
Unit |
UnitParser.shiftExpr()
|
Unit |
UnitParser.unitIdentifier()
|
Unit |
UnitParser.unitSpec()
|
| Methods in visad.data.units with parameters of type Unit | |
|---|---|
protected void |
DefaultUnitsDB.pn(String name,
Unit unit)
Adds a name, the plural form of the name, and a new unit to the database. |
protected void |
DefaultUnitsDB.ps(String symbol,
Unit unit)
Adds a symbol and a new unit to the database. |
void |
UnitTable.putName(String name,
Unit unit)
Adds a name and a unit to the name table. |
void |
UnitsDB.putName(String name,
Unit unit)
Adds a name and a unit to the name table. |
void |
UnitTable.putSymbol(String symbol,
Unit unit)
Adds a symbol and a unit to the symbol table. |
void |
UnitsDB.putSymbol(String symbol,
Unit unit)
Adds a symbol and a unit to the symbol table. |
protected void |
DefaultUnitsDB.px(String name,
Unit unit)
Adds a name that has no plural form and a new unit to the database. |
| Uses of Unit in visad.data.visad |
|---|
| Methods in visad.data.visad with parameters of type Unit | |
|---|---|
void |
BinaryWriter.processDoubleSet(SetType type,
CoordinateSystem cs,
Unit[] units,
DoubleSet set,
Object token)
|
void |
BinarySizer.processDoubleSet(SetType type,
CoordinateSystem cs,
Unit[] units,
DoubleSet set,
Object token)
|
void |
BinaryWriter.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
void |
BinarySizer.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
void |
BinaryWriter.processFloatSet(SetType type,
CoordinateSystem cs,
Unit[] units,
FloatSet set,
Object token)
|
void |
BinarySizer.processFloatSet(SetType type,
CoordinateSystem cs,
Unit[] units,
FloatSet set,
Object token)
|
void |
BinaryWriter.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token)
|
void |
BinarySizer.processGridded1DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DDoubleSet set,
Object token)
|
void |
BinaryWriter.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token)
|
void |
BinarySizer.processGridded1DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded1DSet set,
Object token)
|
void |
BinaryWriter.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token)
|
void |
BinarySizer.processGridded2DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DDoubleSet set,
Object token)
|
void |
BinaryWriter.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token)
|
void |
BinarySizer.processGridded2DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded2DSet set,
Object token)
|
void |
BinaryWriter.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token)
|
void |
BinarySizer.processGridded3DDoubleSet(SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DDoubleSet set,
Object token)
|
void |
BinaryWriter.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token)
|
void |
BinarySizer.processGridded3DSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Gridded3DSet set,
Object token)
|
void |
BinaryWriter.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token)
|
void |
BinarySizer.processGriddedSet(SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Object token)
|
void |
BinaryWriter.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token)
|
void |
BinarySizer.processInteger1DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer1DSet set,
Object token)
|
void |
BinaryWriter.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token)
|
void |
BinarySizer.processInteger2DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer2DSet set,
Object token)
|
void |
BinaryWriter.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token)
|
void |
BinarySizer.processInteger3DSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Integer3DSet set,
Object token)
|
void |
BinaryWriter.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token)
|
void |
BinarySizer.processIntegerNDSet(SetType type,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IntegerNDSet set,
Object token)
|
void |
BinaryWriter.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token)
|
void |
BinarySizer.processIrregular1DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Irregular1DSet set,
Object token)
|
void |
BinaryWriter.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token)
|
void |
BinarySizer.processIrregular2DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular2DSet set,
Object token)
|
void |
BinaryWriter.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token)
|
void |
BinarySizer.processIrregular3DSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
Irregular3DSet set,
Object token)
|
void |
BinaryWriter.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token)
|
void |
BinarySizer.processIrregularSet(SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Object token)
|
void |
BinaryWriter.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token)
|
void |
BinarySizer.processLinear1DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear1DSet set,
Object token)
|
void |
BinaryWriter.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token)
|
void |
BinarySizer.processLinear2DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear2DSet set,
Object token)
|
void |
BinaryWriter.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token)
|
void |
BinarySizer.processLinear3DSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Linear3DSet set,
Object token)
|
void |
BinaryWriter.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token)
|
void |
BinarySizer.processLinearLatLonSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearLatLonSet set,
Object token)
|
void |
BinaryWriter.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token)
|
void |
BinarySizer.processLinearNDSet(SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
LinearNDSet set,
Object token)
|
void |
BinaryWriter.processList1DSet(SetType type,
float[] list,
CoordinateSystem cs,
Unit[] units,
List1DSet set,
Object token)
|
void |
BinarySizer.processList1DSet(SetType type,
float[] list,
CoordinateSystem cs,
Unit[] units,
List1DSet set,
Object token)
|
void |
BinaryWriter.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token)
|
void |
BinarySizer.processProductSet(SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token)
|
void |
BinaryWriter.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token)
|
void |
BinarySizer.processReal(RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token)
|
void |
BinaryWriter.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token)
|
void |
BinarySizer.processSampledSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SampledSet set,
Object token)
|
void |
BinaryWriter.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token)
|
void |
BinarySizer.processSimpleSet(SetType st,
int manifold_dimension,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SimpleSet set,
Object token)
|
void |
BinaryWriter.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token)
|
void |
BinarySizer.processSingletonSet(RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token)
|
| Uses of Unit in visad.data.visad.object |
|---|
| Methods in visad.data.visad.object that return Unit | |
|---|---|
static Unit |
BinaryUnit.read(BinaryReader reader)
|
static Unit[] |
BinaryUnit.readList(BinaryReader reader)
|
| Methods in visad.data.visad.object with parameters of type Unit | |
|---|---|
static int |
BinaryLinearSet.computeBytes(boolean matchedTypes,
double[] firsts,
double[] lasts,
int[] lengths,
Linear1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors)
|
static int |
BinaryIntegerSet.computeBytes(boolean matchedTypes,
int[] lengths,
Integer1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors)
|
static int |
BinarySimpleSet.computeBytes(CoordinateSystem cs,
Unit[] units)
|
static int |
BinaryGriddedDoubleSet.computeBytes(double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors)
|
static int |
BinaryIrregularSet.computeBytes(float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay)
|
static int |
BinaryGriddedSet.computeBytes(float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors)
|
static int |
BinaryList1DSet.computeBytes(float[] list,
CoordinateSystem cs,
Unit[] units)
|
static int |
BinarySingletonSet.computeBytes(RealTupleType sampleType,
Real[] sampleReals,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors)
|
static int |
BinaryProductSet.computeBytes(SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors)
|
static int |
BinaryFlatField.computeBytes(Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld)
|
static int |
BinaryUnit.computeBytes(Unit u)
|
static int |
BinaryUnit.computeBytes(Unit[] array)
|
static int |
BinaryReal.computeBytes(Unit u,
ErrorEstimate err)
|
static int[] |
BinaryUnit.lookupList(BinaryObjectCache cache,
Unit[] units)
|
static void |
BinaryFlatField.write(BinaryWriter writer,
FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
static void |
BinarySingletonSet.write(BinaryWriter writer,
RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token)
|
static void |
BinaryReal.write(BinaryWriter writer,
RealType type,
double value,
Unit unit,
ErrorEstimate error,
Real real,
Object token)
|
static void |
BinarySimpleSet.write(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
SimpleSet set,
Class canonicalClass,
byte dataType,
Object token)
|
static void |
BinaryGriddedDoubleSet.write(BinaryWriter writer,
SetType type,
double[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token)
|
static void |
BinaryLinearSet.write(BinaryWriter writer,
SetType type,
double[] firsts,
double[] lasts,
int[] lengths,
Linear1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token)
|
static void |
BinaryIrregularSet.write(BinaryWriter writer,
SetType type,
float[][] samples,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
Delaunay delaunay,
IrregularSet set,
Class canonicalClass,
byte dataType,
Object token)
|
static void |
BinaryGriddedSet.write(BinaryWriter writer,
SetType type,
float[][] samples,
int[] lengths,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token)
|
static void |
BinaryList1DSet.write(BinaryWriter writer,
SetType type,
float[] list,
CoordinateSystem cs,
Unit[] units,
List1DSet set,
Object token)
|
static void |
BinaryIntegerSet.write(BinaryWriter writer,
SetType type,
int[] lengths,
Integer1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
byte dataType,
Object token)
|
static void |
BinaryProductSet.write(BinaryWriter writer,
SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token)
|
static int |
BinaryUnit.write(BinaryWriter writer,
Unit u,
Object token)
|
static void |
BinaryFlatField.writeDependentData(BinaryWriter writer,
FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
static void |
BinarySingletonSet.writeDependentData(BinaryWriter writer,
RealTuple sample,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
SingletonSet set,
Object token)
|
static void |
BinaryReal.writeDependentData(BinaryWriter writer,
RealType type,
Unit unit,
ErrorEstimate error,
Real real,
Object token)
|
static void |
BinaryGriddedSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token)
|
static void |
BinaryGriddedDoubleSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token)
|
static void |
BinaryIrregularSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
IrregularSet set,
Class canonicalClass,
Object token)
|
static void |
BinaryList1DSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
List1DSet set,
Object token)
|
static void |
BinarySimpleSet.writeDependentData(BinaryWriter writer,
SetType type,
CoordinateSystem cs,
Unit[] units,
SimpleSet set,
Class canonicalClass,
Object token)
|
static void |
BinaryIntegerSet.writeDependentData(BinaryWriter writer,
SetType type,
Integer1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token)
|
static void |
BinaryLinearSet.writeDependentData(BinaryWriter writer,
SetType type,
Linear1DSet[] comps,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
GriddedSet set,
Class canonicalClass,
Object token)
|
static void |
BinaryProductSet.writeDependentData(BinaryWriter writer,
SetType type,
SampledSet[] sets,
CoordinateSystem cs,
Unit[] units,
ErrorEstimate[] errors,
ProductSet set,
Object token)
|
static int[] |
BinaryUnit.writeList(BinaryWriter writer,
Unit[] units,
Object token)
|
| Uses of Unit in visad.georef |
|---|
| Fields in visad.georef declared as Unit | |
|---|---|
static Unit[] |
LatLonTuple.DEFAULT_UNITS
|
static Unit[] |
EarthLocationTuple.DEFAULT_UNITS
|
| Constructors in visad.georef with parameters of type Unit | |
|---|---|
EarthLocationTuple(Real lat,
Real lon,
Real alt,
Unit[] units,
boolean checkUnits)
Construct an EarthLocationTuple from Reals of lat, lon, alt |
|
LatLonTuple(Real lat,
Real lon,
Unit[] units,
boolean checkUnits)
Construct a LatLonTuple from Reals representing the latitude and longitude. |
|
MapProjection(RealTupleType reference,
Unit[] units)
Constructs from the type of the reference coordinate system and units for values in this coordinate system. |
|
NavigatedCoordinateSystem(RealTupleType reference,
Unit[] units)
Constructs from the type of the reference coordinate system and units for values in this coordinate system. |
|
| Uses of Unit in visad.java2d |
|---|
| Methods in visad.java2d with parameters of type Unit | |
|---|---|
boolean |
ShadowTypeJ2D.makeContour(int valueArrayLength,
int[] valueToScalar,
float[][] display_values,
int[] inherited_values,
Vector MapVector,
int[] valueToMap,
int domain_length,
boolean[][] range_select,
int spatialManifoldDimension,
Set spatial_set,
byte[][] color_values,
boolean indexed,
Object group,
GraphicsModeControl mode,
boolean[] swap,
float constant_alpha,
float[] constant_color,
ShadowType shadow_api,
ShadowRealTupleType Domain,
ShadowRealType[] DomainReferenceComponents,
Set domain_set,
Unit[] domain_units,
CoordinateSystem dataCoordinateSystem)
|
| Uses of Unit in visad.java3d |
|---|
| Methods in visad.java3d with parameters of type Unit | |
|---|---|
boolean |
ShadowTypeJ3D.makeContour(int valueArrayLength,
int[] valueToScalar,
float[][] display_values,
int[] inherited_values,
Vector MapVector,
int[] valueToMap,
int domain_length,
boolean[][] range_select,
int spatialManifoldDimension,
Set spatial_set,
byte[][] color_values,
boolean indexed,
Object group,
GraphicsModeControl mode,
boolean[] swap,
float constant_alpha,
float[] constant_color,
ShadowType shadow_api,
ShadowRealTupleType Domain,
ShadowRealType[] DomainReferenceComponents,
Set domain_set,
Unit[] domain_units,
CoordinateSystem dataCoordinateSystem)
|
| Uses of Unit in visad.jmet |
|---|
| Fields in visad.jmet declared as Unit | |
|---|---|
protected Unit |
MetGridDirectory.levelUnit
|
protected Unit |
MetGridDirectory.paramUnit
|
| Methods in visad.jmet that return Unit | |
|---|---|
Unit |
MetGridDirectory.getLevelUnit()
|
Unit |
MetGridDirectory.getParamUnit()
|
| Uses of Unit in visad.math |
|---|
| Methods in visad.math with parameters of type Unit | |
|---|---|
static FlatField |
FFT.fourierTransform(Field field,
boolean forward,
FunctionType ftype,
GriddedSet domain_set,
CoordinateSystem range_coord_sys,
Set[] range_sets,
Unit[] units)
return Fourier Transform of field, use FFT if domain dimension(s) are powers of 2 |
| Uses of Unit in visad.matrix |
|---|
| Constructors in visad.matrix with parameters of type Unit | |
|---|---|
JamaMatrix(Object matrix,
CoordinateSystem range_coord_sys,
CoordinateSystem[] range_coord_syses,
Set[] range_sets,
Unit[] units)
Construct a new JamaMatrix from the specified JAMA Matrix, coordinate systems, range sets and units. |
|
JamaMatrix(Object matrix,
FunctionType type,
Gridded2DSet domain_set,
CoordinateSystem range_coord_sys,
CoordinateSystem[] range_coord_syses,
Set[] range_sets,
Unit[] units)
Construct a new JamaMatrix from the specified JAMA Matrix, MathType, domain set, coordinate systems, range sets and units. |
|
| Uses of Unit in visad.python |
|---|
| Methods in visad.python that return Unit | |
|---|---|
static Unit |
JPythonMethods.makeUnit(String name)
get a VisAD Unit from the name given |
| Methods in visad.python with parameters of type Unit | |
|---|---|
static RealType |
JPythonMethods.getRealType(String name,
Unit unit)
Make or get the RealType corresponding to the name; if none exists, make one and return it. |
static RealType |
JPythonMethods.makeRealType(String name,
Unit unit)
Make or get the RealType corresponding to the name; if none exists, make one and return it. |
| Uses of Unit in visad.sounder |
|---|
| Constructors in visad.sounder with parameters of type Unit | |
|---|---|
Spectrum(float[] wavelength_domain,
Unit domain_unit,
float[] radiance_range,
Unit range_unit)
|
|
| Uses of Unit in visad.util |
|---|
| Methods in visad.util that return Unit | |
|---|---|
static Unit[] |
DataUtility.getRangeUnits(FlatField field)
Gets the units of the (flat) components of the range of a FlatField. |
| Methods in visad.util with parameters of type Unit | |
|---|---|
static RealType |
DataUtility.getUniqueRealType(String name,
Unit unit)
Make a RealType with a unique name for the given unit |
static RealType |
DataUtility.getUniqueRealType(String name,
Unit unit,
Set set,
int attrMask)
Make a RealType with a unique name for the given unit |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||