GraphType

java.lang.Object
- triana.types.TrianaType
- - triana.types.GraphType

All Implemented Interfaces:

java.io.Serializable, Arithmetic, AsciiComm, SequenceInterface

Direct Known Subclasses:

Curve, MatrixType, MultipleChannel, VectorType
```
public abstract class GraphType
extends TrianaType
implements Arithmetic, AsciiComm
```
GraphType is the basis for all Triana numerical data types that can be displayed graphically.
GraphType defines Triana's most general numerical data structures along with methods for reading the data, modifying it, providing information to a graphing object, restricting the data to a sub-domain, and doing element-by- element arithmetic on the data (implementing the Arithmetic interface). The arithmetic methods include for example adding and multiplying by other GraphType data objects and by Const type objects. GraphType implements arithmetic for data arrays of arbitrary dimensionality holding arbitrary primitive arithmetic Java data types (double, int, float, etc.); the data may be real or complex (in which the real and imaginary parts are held in separate arrays). The arithmetic implementation relies heavily on the class methods of FlatArray, which also provides methods that graphical display objects can use for rescaling and translating graphs. GraphType distinguishes between data for dependent and independent variables, both of which may be complex. GraphType's data model is described below.
GraphType is an abstract class, so it cannot be used directly to store data. Rather, "raw data" classes should be derived from GraphType for specific values of dimensions of the data structures. Raw data types derived from GraphType include VectorType (1D array) and MatrixType (2D array), and Curve (1D curve in several dimensions). These permit one to use strong type checking in Units, while losing none of the functionality of GraphType. Therefore, although GraphType provides methods for modifying or replacing data, it does not provide methods for changing the basic dimensionality parameters that determine (i) the number of dimensions in the multi-dimensional arrays used to store data, and (ii) the number of dependent variable arrays.
GraphType also does not provide parameters (auxilliary data) that will be needed for some applications, nor should the "raw" types derived directly from GraphType include extra parameters. It is recommended that types needing new parameters be derived as subclasses of these raw types and that the methods used to manipulate parameters be implemented via Interfaces. Interfaces allow such types to be defined anywhere in the inheritance tree of GraphType, i.e. for any kinds of data structures that are needed. Interfaces already implemented include Signal, Spectral, and Histogramming.
GraphType's data model is designed to allow very general representations of functions and geometical objects. The data represent the values of a number dependentVariables of functions of another number independentVariables of independent variables. The independent variables span the domain of the problem, and they are represented by a set of one-dimensional arrays of doubles (or, to save storage, by Triplets, which are basically iteration counters -- see below).
The data arrays (dependent variables) must each have independentVariables dimensions, but their lengths in each of the dimensions can differ from one another. Thus, there is no requirement that they span the domain. The data arrays can store any kind of data. The data could be primitive data types (such as doubles) or other Java Ojbects, such as colors. The data elements could also be arrays, such as vectors; this would define a vector field over the independent variables. The data can be complex (two similar arrays for each variable), and the independent variables can also be complex.
To use this data model one should think of the independent variables as parameters describing the dependent variables. Thus, for an ordinary graph representing a function of one variable there would be one independent variable and one dependent variable. But to describe a curve that is not a single-valued function, such as a circle in the x-y plane, one would use two dependent variables (x and y) and a single independent variable (distance along the curve). The first would be an instance of VectorType, the second of Curve. A sphere in 3 dimensions would need 3 dependent variables (x, y, and z) depending on two independent variables (the spherical coordinates on the sphere, perhaps).
Often the independent variable in this data model is implicit; it could be just the index of the one-dimensional array of points describing the function of one variable. GraphType does not require that all the values of the independent variable be stored as doubles. Instead, it allows storage of a Triplet. The Triplet class contains three numbers: an integer length, a double starting value and a double step. These can be used to generate the independent variable by iteration. If the independent variable data are not uniformly spaced, however, then they must be stored in GraphType as a double[] array.
GraphType stores its data in the Hashtable called dataContainer that is defined in its super-class TrianaType. The keys used for the Hashtable are defined internally in GraphType, but they do not need to be known to the user. The data are accessed by methods that assign an index to each data set, as if they were stored in an ordered list. If imaginary parts do not exist for certain data then the associated elements are not stored. Parameters defined in this class include arrays of flags and lengths.
GraphType communicates with Units by implementing TrianaType, and with other programs (or computers) by implementing AsciiComm. Types derived from GraphType should call these inherited functions first before implementing their own specific data transfer. The key methods are CopyMe, outputToStream, and inputFromStream. These and the following methods will normally be over-ridden in classes derived from GraphType by methods of the same name that extend their functionality: testDataModel, copyData, copyParameters, and the methods demanded by the Arithmetic Interface -- isCompatible, equals, add, subtract, multiply, divide. Note that GraphType implements the methods of Arithmetic in such a way that they work on any data array that holds numerical data, regardless of its dimension or size. It does this by invoking the utilities of FlatArray. If a GraphType data object contains non-numerical data, such as images, these are ignored by the arithmetic operations.

See Also:
TrianaType, Arithmetic, Triplet, VectorType, MatrixType, Curve, Serialized Form

Field Summary
- Fields inherited from class triana.types.TrianaType
  NOT_CONNECTED, NOT_READY, OUT_OF_RANGE

Constructor Summary

Constructors
Constructor and Description
`GraphType()` Creates a new GraphType that is empty.
`GraphType(int iv, int dv)` Creates a new GraphType with specified dimensions and an empty dataContainer hashtable.

Method Summary

Methods
Modifier and Type	Method and Description
`Arithmetic`	`add(java.lang.Object obj)` Adds the argument TrianaType to the current object.
`void`	`addToTitle(java.lang.String str)` Appends the argument String str to the existing title String.
`void`	`convertDependentDataArraysToBytes()` Converts all of the arithmetic dependent data from their present format to byte arrays.
`void`	`convertDependentDataArraysToDoubles()` Converts all of the arithmetic dependent data from their present format to double arrays.
`void`	`convertDependentDataArraysToFloats()` Converts all of the arithmetic dependent data from their present format to float arrays.
`void`	`convertDependentDataArraysToInts()` Converts all of the arithmetic dependent data from their present format to int arrays.
`void`	`convertDependentDataArraysToLongs()` Converts all of the arithmetic dependent data from their present format to long arrays.
`void`	`convertDependentDataArraysToShorts()` Converts all of the arithmetic dependent data from their present format to short arrays.
`protected void`	`copyData(TrianaType source)` Copies data held in dataContainer from the argument object to the current object.
`java.util.Hashtable`	`copyLabels()` Returns a Hashtable copy of labels, by value, not by reference.
`abstract TrianaType`	`copyMe()` This is one of the most important methods of Triana data.
`protected void`	`copyParameters(TrianaType source)` Copies modifiable parameters from the argument object to the current object.
`Arithmetic`	`divide(java.lang.Object obj)` Divides the argument TrianaType into the current object.
`boolean`	`equals(java.lang.Object obj)` Tests if the argument Object is equal to the current object.
`java.lang.Class`	`getDataArrayClass(int dv)` Returns the Class of the data array (dependent variable) associated with the argument index dv.
`java.lang.Object`	`getDataArrayImag(int dv)` Returns the imaginary part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayImag(int dv, java.lang.Class outClass)` Returns the imag part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayImagAsBytes(int dv)` Returns the imag part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayImagAsDoubles(int dv)` Returns the imag part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayImagAsFloats(int dv)` Returns the imag part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayImagAsInts(int dv)` Returns the imag part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayImagAsLongs(int dv)` Returns the imag part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayImagAsShorts(int dv)` Returns the imag part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayReal(int dv)` Returns the real part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayReal(int dv, java.lang.Class outClass)` Returns the real part of the array for the dependent variable indexed by dv; if the elements of the array can be converted to the data type of the given Class (second argument) then they are; if the given Class is an array, then the method tries to convert to the type of the elements of that array.
`java.lang.Object`	`getDataArrayRealAsBytes(int dv)` Returns the real part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayRealAsDoubles(int dv)` Returns the real part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayRealAsFloats(int dv)` Returns the real part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayRealAsInts(int dv)` Returns the real part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayRealAsLongs(int dv)` Returns the real part of the array for the dependent variable indexed by dv.
`java.lang.Object`	`getDataArrayRealAsShorts(int dv)` Returns the real part of the array for the dependent variable indexed by dv.
`java.lang.String`	`getDataArrayTypeNames(int dv)` Returns the type name of the data array (dependent variable) associated with the argument index dv.
`java.lang.String`	`getDependentLabels(int dv)` Returns a String containing the label to be displayed along the axis associated with the dependent variable dv.
`int[]`	`getDependentVariableDimensions(int dv)` Returns an int[] containing the lengths of the dimensions of the dependent variable given by the argument dv.
`int`	`getDependentVariables()` Returns the number of dependent dimensions dependentVariables of the data set.
`int[]`	`getDimensionLengths()` Returns an integer array containing the number of points in each of the independent variable dimensions, numbered 0 to independentVariables - 1.
`int`	`getDimensionLengths(int dim)` Returns the number of domain points in the independent variable dimension given by argument dim.
`java.lang.Object`	`getGraphArrayImag(int dv)` Returns an array containing the imaginary part of the graphing values for the dependent variable indexed by dv.
`java.lang.Object`	`getGraphArrayImagLog10(int dv)` Returns an array containing the logarithms (base 10) of the imag part of the graphing values for the dependent variable indexed by dv.
`java.lang.Object`	`getGraphArrayReal(int dv)` Returns an array containing the real part of the graphing values for the dependent variable indexed by dv as an array of doubles.
`java.lang.Object`	`getGraphArrayRealLog10(int dv)` Returns an array containing the logarithms (base 10) of the real part of the graphing values for the dependent variable indexed by dv.
`double[]`	`getIndependentArrayImag(int dim)` Returns the imaginary part of the array for the independent variable indexed by dim.
`double[]`	`getIndependentArrayReal(int dim)` Returns the real part of the array for the independent variable indexed by dim.
`java.lang.String`	`getIndependentLabels(int dim)` Returns a String containing the label to be displayed along the axis associated with the independent variable dim.
`double[]`	`getIndependentScaleImag(int dim)` Returns an array containing the imaginary part of the graphing scale associated with the independent variable indexed by dim.
`double[]`	`getIndependentScaleImagLog10(int dim)` Returns an array containing the logarithms (base 10) of the imag part of the graphing scale values associated with the dependent variable indexed by dim.
`double[]`	`getIndependentScaleReal(int dim)` Returns an array containing the real part of the graphing scale associated with the independent variable indexed by dim.
`double[]`	`getIndependentScaleRealLog10(int dim)` Returns an array containing the logarithms (base 10) of the real part of the graphing scale values associated with the dependent variable indexed by dim.
`Triplet`	`getIndependentTriplet(int dim)` Returns the Triplet object which specifies how values of the independent variable indexed by dim are generated.
`int`	`getIndependentVariables()` Returns the number of independent dimensions independentVariables of the data set.
`java.util.Hashtable`	`getLabels()` Returns a Hashtable containing all the labels to be displayed along the axes of the independent and dependent variables.
`java.lang.String`	`getLabelsColumn()` Returns all the axis labels that have been defined, along with their keys.
`java.lang.String`	`getTitle()` Returns a String containing the title to be written on a displayed graph.
`void`	`inputFromStream(java.io.BufferedReader dis)` Used when Triana types want to be able to create a new data object from ASCII data it receives from a stream.
`boolean`	`isArithmeticArray(int dv)` Returns true if the dependent variable associated with the argument index dv is an array of primitive Java data types for numerical data: byte, short, int, long, float, or double.
`boolean`	`isArithmeticData(int dv)` Returns true if the dependent variable associated with the argument index dv is an array of primitive Java arithmetic data types at the level of independentVariables, i.e.
`boolean`	`isCompatible(java.lang.Object obj)` Tests the argument object to determine if it makes sense to perform arithmetic operations between it and the current object.
`boolean`	`isDependentComplex(int dv)` Returns true if the data associated with the dependent variable dv is complex, falseotherwise.
`boolean`	`isIndependentComplex(int dim)` Returns true if the data associated with the independent variable dim is complex, false otherwise.
`boolean`	`isPrimitiveArray(int dv)` Returns true if the dependent variable associated with the argument index dv is an array of primitive Java data types.
`boolean`	`isPrimitiveData(int dv)` Returns true if the dependent variable associated with the argument index dv is an array of primitive Java data types at the level of independentVariables.
`boolean`	`isTriplet(int dim)` Returns true if (i) isIndependentComplex returns false for the same argument and (ii) the independent variable numbered by the argument dim is generated from a Triplet (length, start, step).
`boolean`	`isUniform(int dim)` Tests to see if the independent variable in the given direction is uniformly sampled.
`double[]`	`maxDependentGraphingValuesImag()` Returns a double[] containing the maximum value of the imaginary part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData.
`double[]`	`maxDependentGraphingValuesReal()` Returns a double[] containing the maximum value of the real part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData.
`double[]`	`maxDependentVariablesImag()` Returns a double[] containing the maximum value of the imaginary part of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData.
`double[]`	`maxDependentVariablesReal()` Returns a double[] containing the maximum value of the real part of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData.
`double[]`	`maxIndependentScalesImag()` Returns a double[] containing the largest values of the elements of the imaginary parts of the graphing scales of all the independent variables.
`double[]`	`maxIndependentScalesReal()` Returns a double[] containing the largest values on the graphing scales of all the independent variables.
`double[]`	`maxIndependentVariablesImag()` Returns a double[] containing the largest values of the elements of the imaginary parts of all the independent variables.
`double[]`	`maxIndependentVariablesReal()` Returns a double[] containing the largest values of the elements of the real parts of all the independent variables.
`double[]`	`minDependentGraphingValuesImag()` Returns a double[] containing the minimum value of the imaginary part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData.
`double[]`	`minDependentGraphingValuesReal()` Returns a double[] containing the minimum value of the real part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData.
`double[]`	`minDependentVariablesImag()` Returns a double[] containing the minimum value of the imaginary part of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData.
`double[]`	`minDependentVariablesReal()` Returns a double[] containing the minimum value of the real parts of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData.
`double[]`	`minIndependentScalesImag()` Returns a double[] containing the largest values of the elements of the imaginary parts of the graphing scales of all the independent variables.
`double[]`	`minIndependentScalesReal()` Returns a double[] containing the largest values on the graphing scales of all the independent variables.
`double[]`	`minIndependentVariablesImag()` Returns a double[] containing the smallest values elements of the imaginary parts of all the independent variables.
`double[]`	`minIndependentVariablesReal()` Returns a double[] containing the smallest values of the elements of the real parts of all the independent variables.
`Arithmetic`	`multiply(java.lang.Object obj)` Multiplies the argument TrianaType into the current object.
`void`	`outputToStream(java.io.PrintWriter dos)` Used when Triana types want to be able to send ASCII data to other programs using strings.
`void`	`resetDependent(int dv)` Checks the dependent data in the given dimension for consistency and resets all the boolean flags etc.
`void`	`resetIndependent(int dim)` Checks the independent data in the given dimension for consistency and resets all the boolean flags etc.
`GraphType`	`restrictToSubdomain(int dim, double from, double to)` Returns a new GraphType object with data restricted to a subdomain of one of the independent variables.
`GraphType`	`restrictToSubdomain(int dim, int from, int to)` Returns a new GraphType object with data restricted to a subdomain of one of the independent variables.
`void`	`setDataArrayImag(java.lang.Object A, int dv)` Assigns the appropriately dimensioned argument array A to the storage location in this data object for the imaginary part of the data associated with independent variable dv.
`void`	`setDataArrayReal(java.lang.Object A, int dv)` Assigns the appropriately dimensioned argument array A to the storage location in this data object for the real part of the data associated with dependent variable dv.
`void`	`setDefaultAxisLabelling()` Added by I.
`void`	`setDependentLabels(int dv, java.lang.String lbl)` Sets the axis label for the dependent (data) variable dim to the argument String l.
`void`	`setDependentVariableDimensions(int[] size, int dv)` Sets an int[] into the ArrayList containing the lengths of the dimensions of the dependent variable given by the argument dv.
`void`	`setDimensionLengths(int[] dimLen)` Sets the integer array containing the number of domain points in each of the independent variable dimensions to the elements of the argument dimLen.
`void`	`setDimensionLengths(int length, int dim)` Sets the number of domain points in the independent variable dimension given by argument dim to the value given by the argument length.
`void`	`setDimensions(int iv, int dv)` Sets up the Graph Type to the specified dimensions and an empty dataContainer hashtable.
`void`	`setIndependentArrayImag(double[] A, int dim)` Assigns the argument array of doubles A to the storage location in this data object for the imaginary part of the data associated with independent variable dim.
`void`	`setIndependentArrayReal(double[] A, int dim)` Assigns the argument array of doubles A to the storage location in this data object for the real part of the data associated with independent variable dim.
`void`	`setIndependentLabels(int dim, java.lang.String lbl)` Sets the axis label for the independent variable dim to the argument String l.
`void`	`setIndependentTriplet(int len, double strt, double stp, int dim)` Sets the argument values into a new Triplet object and then sets this object to be the data object for uniformly spaced values of the independent variable given by dim: length is given by the argument len, starting value by the argument strt, and the step by the argument stp.
`void`	`setIndependentTriplet(Triplet tr, int dim)` Sets the Triplet object which specifies how values of the independent variable indexed by dim to the argument tr.
`void`	`setLabels(java.util.Hashtable newLab)` Sets the axis labels Hashtable, by reference.
`void`	`setTitle(java.lang.String t)` Sets the title String to the argument String t by reference.
`Arithmetic`	`subtract(java.lang.Object obj)` Subtracts the argument TrianaType from the current object.
`boolean`	`testDataModel()` Tests to make sure this object obeys the GraphType data model.

Methods inherited from class triana.types.TrianaType
containerSize, dataExists, deleteFromContainer, getDataContainer, getFromContainer, getSequenceNumber, insertIntoContainer, inspectDataContainer, setDataContainer, setSequenceNumber, updateObsoletePointers

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

- Constructor Detail
  - GraphType
```
public GraphType()
```
    Creates a new GraphType that is empty.
  - GraphType
```
public GraphType(int iv,
         int dv)
```
    Creates a new GraphType with specified dimensions and an empty dataContainer hashtable. The data containers are initialized with correct keys but null data. Data could be added later using the methods below. Derived classes can call this Constructor and then fill in the data.
    
    Parameters:
    iv - The number of independent variables (must be positive)
    dv - The number of dependent variables (must be positive)
- Method Detail
  - setDefaultAxisLabelling
```
public void setDefaultAxisLabelling()
```
    Added by I. Taylor, August 2001 : This function sets the default labeling scheme used for all GraphTypes. Default values are 'X' for the X-axis and 'Y' for the Y axis. The various subclasses can override this function with their specific axis-labelling conventions.
  - setDimensions
```
public void setDimensions(int iv,
                 int dv)
```
    Sets up the Graph Type to the specified dimensions and an empty dataContainer hashtable. The data containers are initialized with correct keys but null data. Data could be added later using the methods below. Derived classes can call this Constructor and then fill in the data.
    
    Parameters:
    iv - The number of independent variables (must be positive)
    dv - The number of dependent variables (must be positive)
  - testDataModel
```
public boolean testDataModel()
```
    Tests to make sure this object obeys the GraphType data model. This should be overridden in classes derived from GraphType to test for more restrictive assumptions. The overriding method should call this one first.
    This method returns true if the data sets exist, if the independent variables are determined either by Triplets or by one-dimensional arrays of doubles, if the dependent data arrays have independentVariables dimensions, and if the lengths of the dimensions of the dependent variable arrays is the same as the lengths of the independent variable data sets. Otherwise it returns false.
    
    Returns:
    boolean True if the current data satisfy the data model
    See Also:
    Triplet
  - resetIndependent
```
public void resetIndependent(int dim)
```
    Checks the independent data in the given dimension for consistency and resets all the boolean flags etc. This is called by methods that change data sets.
    
    Parameters:
    dim - The dimension being reset
  - resetDependent
```
public void resetDependent(int dv)
```
    Checks the dependent data in the given dimension for consistency and resets all the boolean flags etc. This is called by methods that change data sets. If the associated independent variables are Triplets before the call to this method, and if their size is not consistent with the length of the new data, then they are automatically reset to new Triplets running by default from index 0 with step 1. This is a fail-safe mechanism for programmers who forget to reset the Triplet.
    
    Parameters:
    dv - The index of the dependent data being reset
  - isIndependentComplex
```
public boolean isIndependentComplex(int dim)
```
    Returns true if the data associated with the independent variable dim is complex, false otherwise.
    If there is no data array (i.e. if the data are generated by a Triplet -- see the method isTriplet below) then this returns false.
    
    Parameters:
    dim - The number indicating the variable in question
    
    Returns:
    True if the data in this dimension are complex, false otherwise
    See Also:
    Triplet
  - isDependentComplex
```
public boolean isDependentComplex(int dv)
```
    Returns true if the data associated with the dependent variable dv is complex, falseotherwise.
    
    Parameters:
    dv - The number indicating the variable in question
    
    Returns:
    True if the data in this dimension are complex, false otherwise
  - isTriplet
```
public boolean isTriplet(int dim)
```
    Returns true if (i) isIndependentComplex returns false for the same argument and (ii) the independent variable numbered by the argument dim is generated from a Triplet (length, start, step). The Triplet itself can be found using the method getIndependentTriplet below.
    
    Parameters:
    dim - The independent variable dimension
    
    Returns:
    True if data in this dimension are represented by a Triplet
    See Also:
    Triplet
  - getDataArrayTypeNames
```
public java.lang.String getDataArrayTypeNames(int dv)
```
    Returns the type name of the data array (dependent variable) associated with the argument index dv. This is the name of the full array.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The component type name of the data in this dimension
  - getDataArrayClass
```
public java.lang.Class getDataArrayClass(int dv)
```
    Returns the Class of the data array (dependent variable) associated with the argument index dv. Returns null if the Class does not exist.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The Class of the data in this dimension
  - isPrimitiveArray
```
public boolean isPrimitiveArray(int dv)
```
    Returns true if the dependent variable associated with the argument index dv is an array of primitive Java data types. It returns false if the elements of the array at its lowest level are reference types.
    
    Parameters:
    dv - The index of the dependent variable being inspected
    
    Returns:
    True if the elements at the lowest level are primitive.
  - isPrimitiveData
```
public boolean isPrimitiveData(int dv)
```
    Returns true if the dependent variable associated with the argument index dv is an array of primitive Java data types at the level of independentVariables. This returns false if the components of the data array after the first independentVariables dimensions are reference types, even if they are arrays of primitives.
    This can be used to determine if the data are to be interpreted as arrays of arrays, such as vector fields.
    
    Parameters:
    dv - The index of the dependent variable being inspected
    
    Returns:
    True if the elements at the independentVariables level are primitive.
  - isArithmeticArray
```
public boolean isArithmeticArray(int dv)
```
    Returns true if the dependent variable associated with the argument index dv is an array of primitive Java data types for numerical data: byte, short, int, long, float, or double. It returns false if the elements of the array at its lowest level are boolean, char, or reference types.
  - isArithmeticData
```
public boolean isArithmeticData(int dv)
```
    Returns true if the dependent variable associated with the argument index dv is an array of primitive Java arithmetic data types at the level of independentVariables, i.e. not boolean or char. This returns false if the components of the data array after the first independentVariables dimensions are reference types or boolean or char, even if they are arrays of arithmetic primitives.
    This can be used to determine if the data are to be interpreted as arrays of arrays, such as vector fields.
    
    Parameters:
    dv - The index of the dependent variable being inspected
    
    Returns:
    True if the elements at the independentVariables level are arithmetic primitive types.
  - isUniform
```
public boolean isUniform(int dim)
```
    Tests to see if the independent variable in the given direction is uniformly sampled.
    
    Returns:
    boolean True if the given independent variable is sampled uniformly
  - getIndependentVariables
```
public int getIndependentVariables()
```
    Returns the number of independent dimensions independentVariables of the data set.
    
    Returns:
    int Number of independent variables
  - getDependentVariables
```
public int getDependentVariables()
```
    Returns the number of dependent dimensions dependentVariables of the data set.
    
    Returns:
    int Number of dependent variables
  - getDimensionLengths
```
public int getDimensionLengths(int dim)
```
    Returns the number of domain points in the independent variable dimension given by argument dim.
    
    Parameters:
    dim - The number indicating the variable in question
    
    Returns:
    The length of the independent variable dimension dim
  - getDimensionLengths
```
public int[] getDimensionLengths()
```
    Returns an integer array containing the number of points in each of the independent variable dimensions, numbered 0 to independentVariables - 1.
    
    Returns:
    int[] An array containing the lengths of the independent variable dimensions
  - getDependentVariableDimensions
```
public int[] getDependentVariableDimensions(int dv)
```
    Returns an int[] containing the lengths of the dimensions of the dependent variable given by the argument dv.
    
    Parameters:
    dv - The dependent variable under consideration
    
    Returns:
    The array of the lengths of the dimensions of the variable
  - getIndependentTriplet
```
public Triplet getIndependentTriplet(int dim)
```
    Returns the Triplet object which specifies how values of the independent variable indexed by dim are generated. If the independent variable values are held in an array, the array is converted to a Triplet if its values are uniformly spaced. If they are not uniform, then this method returns null.
    
    Parameters:
    dim - The spatial dimension
    
    Returns:
    The Triplet Object from which uniformly spaced one-dimensional data can be generated
    See Also:
    Triplet
  - getIndependentArrayReal
```
public double[] getIndependentArrayReal(int dim)
```
    Returns the real part of the array for the independent variable indexed by dim. If the data are real (isIndependentComplex returns false) then this returns the whole data. If method isTriplet returns true (so that the data array does not exist) then this returns a data array generated by the Triplet.
    
    Parameters:
    dim - The independent variable dimension
    
    Returns:
    The values of (real part of) the independent variable
    See Also:
    Triplet
  - getIndependentScaleReal
```
public double[] getIndependentScaleReal(int dim)
```
    Returns an array containing the real part of the graphing scale associated with the independent variable indexed by dim. By default this just returns getIndependentArrayReal, but it should be over-ridden in derived types if the scale to be displayed on a graph is not stored in the independent variable. This can happen if the "physical" values are not monotonic in the independent variable index, so they cannot be stored there.
    If the data are real (isIndependentComplex returns false) then this returns the whole scale.
    
    Parameters:
    dim - The independent variable dimension
    
    Returns:
    The values of (real part of) the graphing scale for this variable
  - getIndependentScaleRealLog10
```
public double[] getIndependentScaleRealLog10(int dim)
```
    Returns an array containing the logarithms (base 10) of the real part of the graphing scale values associated with the dependent variable indexed by dim. This is an aid to producing logarithmically scaled graphs.
    Users should check to see that data are positive before calling this method (use minIndependentScalesReal). The method uses the Java log function, which returns NaN on data values that are negative, and negative infinity on data values that are zero.
    If the data are real (isIndependentComplex returns false) then this returns the logarithm of the whole graphing data set.
    
    Parameters:
    dim - The dependent variable dimension
    
    Returns:
    The logarithms (base 10) of the values of (real part of) the graphing scale associated with the given dependent variable
  - getIndependentArrayImag
```
public double[] getIndependentArrayImag(int dim)
```
    Returns the imaginary part of the array for the independent variable indexed by dim. If the data are real (isIndependentComplex() returns false) then this returns null. If method isTriplet() returns true (so that the data array does not exist) then this returns null.
    
    Parameters:
    dim - The independent variable dimension
    
    Returns:
    The values of the imaginary part of the independent variable
    See Also:
    Triplet
  - getIndependentScaleImag
```
public double[] getIndependentScaleImag(int dim)
```
    Returns an array containing the imaginary part of the graphing scale associated with the independent variable indexed by dim. By default this just returns getIndependentArrayImag, but it should be over-ridden in derived types if the scale to be displayed on a graph is not stored in the independent variable. This can happen if the "physical" values are not monotonic in the independent variable index, so they cannot be stored there.
    If the data are real (isIndependentComplex returns false) then this returns null.
    
    Parameters:
    dim - The independent variable dimension
    
    Returns:
    The values of the imaginary part of the graphing scale for this variable
  - getIndependentScaleImagLog10
```
public double[] getIndependentScaleImagLog10(int dim)
```
    Returns an array containing the logarithms (base 10) of the imag part of the graphing scale values associated with the dependent variable indexed by dim. This is an aid to producing logarithmically scaled graphs.
    Users should check to see that data are positive before calling this method (use minIndependentScalesImag). The method uses the Java log function, which returns NaN on data values that are negative, and negative infinity on data values that are zero.
    If the data are purely real (isIndependentComplex returns false) then this returns null.
    
    Parameters:
    dim - The dependent variable dimension
    
    Returns:
    The logarithms (base 10) of the values of (imag part of) the graphing scale associated with the given dependent variable
  - getDataArrayReal
```
public java.lang.Object getDataArrayReal(int dv)
```
    Returns the real part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getDataArrayRealAsDoubles
```
public java.lang.Object getDataArrayRealAsDoubles(int dv)
```
    Returns the real part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to doubles then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getDataArrayRealAsFloats
```
public java.lang.Object getDataArrayRealAsFloats(int dv)
```
    Returns the real part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to floatss then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getDataArrayRealAsInts
```
public java.lang.Object getDataArrayRealAsInts(int dv)
```
    Returns the real part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to ints then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getDataArrayRealAsLongs
```
public java.lang.Object getDataArrayRealAsLongs(int dv)
```
    Returns the real part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to longs then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getDataArrayRealAsShorts
```
public java.lang.Object getDataArrayRealAsShorts(int dv)
```
    Returns the real part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to shorts then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getDataArrayRealAsBytes
```
public java.lang.Object getDataArrayRealAsBytes(int dv)
```
    Returns the real part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to bytess then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getDataArrayReal
```
public java.lang.Object getDataArrayReal(int dv,
                                java.lang.Class outClass)
```
    Returns the real part of the array for the dependent variable indexed by dv; if the elements of the array can be converted to the data type of the given Class (second argument) then they are; if the given Class is an array, then the method tries to convert to the type of the elements of that array. Otherwise the method returns null. If the data are real (isDependentComplex returns false) then this returns the whole data.
    Note that Java provides Class constants for primitives, denoted by Integer.Type, Double.Type, etc,. These values are also returned by applying the suffix .class to a primitive variable type name, e.g. int.class has the value Integer.Type. For any Object Q, including arrays, the class is given by the method Q.getClass(). Normally, the present method would be used to to get the data as an array of elements of the same type as the elements of object q by invoking getDataArrayReal( o, q.getClass() ).
    
    Parameters:
    dv - The dependent variable dimension
    outClass - The desired type of the output elements
    
    Returns:
    The values of (real part of) the dependent variable
  - getGraphArrayReal
```
public java.lang.Object getGraphArrayReal(int dv)
```
    Returns an array containing the real part of the graphing values for the dependent variable indexed by dv as an array of doubles. By default this simply returns getDataArrayReal, but it should be over-ridden in derived classes that arrange the data storage in a way that should not be graphed directly, for example if the value along the graphing scale of the independent variable is not monotonic in the index of the data set.
    If the data are real (isDependentComplex returns false) then this returns the whole graphing data set.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getGraphArrayRealLog10
```
public java.lang.Object getGraphArrayRealLog10(int dv)
```
    Returns an array containing the logarithms (base 10) of the real part of the graphing values for the dependent variable indexed by dv. This is an aid to producing logarithmically scaled graphs.
    Users should check to see that data are positive before calling this method (use minDependentGraphReal). The method uses the Java log function, which returns NaN on data values that are negative, and negative infinity on data values that are zero.
    If the data are real (isDependentComplex returns false) then this returns the logarithm of the whole graphing data set.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable as an array of doubles
  - getDataArrayImag
```
public java.lang.Object getDataArrayImag(int dv)
```
    Returns the imaginary part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex() returns false) then this returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of the imaginary part of the dependent variable
  - getDataArrayImagAsDoubles
```
public java.lang.Object getDataArrayImagAsDoubles(int dv)
```
    Returns the imag part of the array for the dependent variable indexed by dv. If the data are imag (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to doubles then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (imag part of) the dependent variable
  - getDataArrayImagAsFloats
```
public java.lang.Object getDataArrayImagAsFloats(int dv)
```
    Returns the imag part of the array for the dependent variable indexed by dv. If the data are imag (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to floatss then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (imag part of) the dependent variable
  - getDataArrayImagAsInts
```
public java.lang.Object getDataArrayImagAsInts(int dv)
```
    Returns the imag part of the array for the dependent variable indexed by dv. If the data are imag (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to ints then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (imag part of) the dependent variable
  - getDataArrayImagAsLongs
```
public java.lang.Object getDataArrayImagAsLongs(int dv)
```
    Returns the imag part of the array for the dependent variable indexed by dv. If the data are imag (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to longs then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (imag part of) the dependent variable
  - getDataArrayImagAsShorts
```
public java.lang.Object getDataArrayImagAsShorts(int dv)
```
    Returns the imag part of the array for the dependent variable indexed by dv. If the data are imag (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to shorts then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (imag part of) the dependent variable
  - getDataArrayImagAsBytes
```
public java.lang.Object getDataArrayImagAsBytes(int dv)
```
    Returns the imag part of the array for the dependent variable indexed by dv. If the data are imag (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to bytess then they are, otherwise the method returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (imag part of) the dependent variable
  - getDataArrayImag
```
public java.lang.Object getDataArrayImag(int dv,
                                java.lang.Class outClass)
```
    Returns the imag part of the array for the dependent variable indexed by dv. If the data are real (isDependentComplex returns false) then this returns the whole data. If the elements of the array can be converted to the data type of the given Class (second argument) then they are; if the given Class is an array, then the method tries to convert to the type of the elements of that array. Otherwise the method returns null.
    Note that Java provides Class constants for primitives, denoted by Integer.Type, Double.Type, etc,. These values are also returned by applying the suffix .class to a primitive variable type name, e.g. int.class has the value Integer.Type. For any Object Q, including arrays, the class is given by the method Q.getClass(). Normally, the present method would be used to to get the data as an array of elements of the same type as the elements of object q by invoking getDataArrayImag( o, q.getClass() ).
    
    Parameters:
    dv - The dependent variable dimension
    outClass - The desired type of the output elements
    
    Returns:
    The values of (imag part of) the dependent variable
  - convertDependentDataArraysToDoubles
```
public void convertDependentDataArraysToDoubles()
```
    Converts all of the arithmetic dependent data from their present format to double arrays.
  - convertDependentDataArraysToFloats
```
public void convertDependentDataArraysToFloats()
```
    Converts all of the arithmetic dependent data from their present format to float arrays.
  - convertDependentDataArraysToInts
```
public void convertDependentDataArraysToInts()
```
    Converts all of the arithmetic dependent data from their present format to int arrays.
  - convertDependentDataArraysToLongs
```
public void convertDependentDataArraysToLongs()
```
    Converts all of the arithmetic dependent data from their present format to long arrays.
  - convertDependentDataArraysToShorts
```
public void convertDependentDataArraysToShorts()
```
    Converts all of the arithmetic dependent data from their present format to short arrays.
  - convertDependentDataArraysToBytes
```
public void convertDependentDataArraysToBytes()
```
    Converts all of the arithmetic dependent data from their present format to byte arrays.
  - getGraphArrayImag
```
public java.lang.Object getGraphArrayImag(int dv)
```
    Returns an array containing the imaginary part of the graphing values for the dependent variable indexed by dv. By default this simply returns getDataArrayImag, but it should be over-ridden in derived classes that arrange the data storage in a way that should not be graphed directly, for example if the value along the graphing scale of the independent variable is not monotonic in the index of the data set.
    If the data are real (isDependentComplex returns false) then this returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (real part of) the dependent variable
  - getGraphArrayImagLog10
```
public java.lang.Object getGraphArrayImagLog10(int dv)
```
    Returns an array containing the logarithms (base 10) of the imag part of the graphing values for the dependent variable indexed by dv. This is an aid to producing logarithmically scaled graphs.
    Users should check to see that data are positive before calling this method (use minDependentGraphImag). The method uses the Java log function, which returns NaN on data values that are negative, and negative infinity on data values that are zero.
    If the data are real (isDependentComplex returns false) then this returns null.
    
    Parameters:
    dv - The dependent variable dimension
    
    Returns:
    The values of (imag part of) the dependent variable as an array of doubles
  - getTitle
```
public java.lang.String getTitle()
```
    Returns a String containing the title to be written on a displayed graph.
    
    Returns:
    String The title String for this data Object
  - getIndependentLabels
```
public java.lang.String getIndependentLabels(int dim)
```
    Returns a String containing the label to be displayed along the axis associated with the independent variable dim. If the label has not been defined, an empty String is returned.
    
    Parameters:
    dim - The spatial dimension
    
    Returns:
    The independent axis label for this dimension
  - getDependentLabels
```
public java.lang.String getDependentLabels(int dv)
```
    Returns a String containing the label to be displayed along the axis associated with the dependent variable dv. If the label has not been defined, an empty String is returned.
    
    Parameters:
    dv - The index of the dependent variable
    
    Returns:
    The dependent variable axis label for this dimension
  - getLabels
```
public java.util.Hashtable getLabels()
```
    Returns a Hashtable containing all the labels to be displayed along the axes of the independent and dependent variables.
    
    Returns:
    Hashtable The axis labels
  - getLabelsColumn
```
public java.lang.String getLabelsColumn()
```
    Returns all the axis labels that have been defined, along with their keys. This is in the form of a String consisting of key \n label \n key \n label \n ...: keys and labels alternating on separate lines. If no labels have been defined, then the method returns an empty String.
    
    Returns:
    String The axis labels and keys
  - copyLabels
```
public java.util.Hashtable copyLabels()
```
    Returns a Hashtable copy of labels, by value, not by reference.
    
    Returns:
    Hashtable The copy of the axis labels
  - setDimensionLengths
```
public void setDimensionLengths(int length,
                       int dim)
```
    Sets the number of domain points in the independent variable dimension given by argument dim to the value given by the argument length.
    
    Parameters:
    length - The number of values of this variable
    dim - The number indicating the independent variable in question
  - setDimensionLengths
```
public void setDimensionLengths(int[] dimLen)
```
    Sets the integer array containing the number of domain points in each of the independent variable dimensions to the elements of the argument dimLen. The user is responsible for checking that it has the right number of dimensions.
    
    Parameters:
    dimLen - An array containing the lengths of the independent variable dimensions
  - setDependentVariableDimensions
```
public void setDependentVariableDimensions(int[] size,
                                  int dv)
```
    Sets an int[] into the ArrayList containing the lengths of the dimensions of the dependent variable given by the argument dv.
    
    Parameters:
    size - The array of the lengths of the dimensions of the variable
    dv - The dependent variable under consideration
  - setIndependentTriplet
```
public void setIndependentTriplet(Triplet tr,
                         int dim)
```
    Sets the Triplet object which specifies how values of the independent variable indexed by dim to the argument tr. If there had been a data array for this data then it is removed from the Hashtable, along with its imaginary counterpart if it is complex. It sets the flag createTool by the method isTriplet to true and it removes any imaginary data associated with this direction, setting the flag createTool by the method isIndependentComplex flag to false.
    
    Parameters:
    tr - The Triplet to be used to repesent data for this dimension
    dim - The independent variable dimension
    See Also:
    Triplet
  - setIndependentTriplet
```
public void setIndependentTriplet(int len,
                         double strt,
                         double stp,
                         int dim)
```
    Sets the argument values into a new Triplet object and then sets this object to be the data object for uniformly spaced values of the independent variable given by dim: length is given by the argument len, starting value by the argument strt, and the step by the argument stp. The method sets the flag createTool by the method isTriplet to true and it removes any imaginary data associated with this direction, setting the flag createTool by the method isIndependentComplex to false.
    
    Parameters:
    len - The length of the data set to be represented by a Triplet
    strt - The starting value of the uniformly spaced data
    stp - The step between the uniformly spaced data values
    dim - The independent variable dimension
    See Also:
    Triplet
  - setIndependentArrayReal
```
public void setIndependentArrayReal(double[] A,
                           int dim)
```
    Assigns the argument array of doubles A to the storage location in this data object for the real part of the data associated with independent variable dim. This method sets the flag createTool by the method isTriplet for this dimension to false. If the array A is null, any existing data array will be deleted from the Hashtable.
    
    Parameters:
    A - The (real part of the) data to be stored in this independent variable
    dim - The spatial dimension
    See Also:
    Triplet
  - setIndependentArrayImag
```
public void setIndependentArrayImag(double[] A,
                           int dim)
```
    Assigns the argument array of doubles A to the storage location in this data object for the imaginary part of the data associated with independent variable dim. This method sets the flag createTool by the method isTriplet for this dimension to false and the flag createTool by isIndependentComplex to true. If the array A is null, the stored data array will be deleted, losing any existing data in this location.
    
    Parameters:
    A - The (real part of the) data to be stored in this independent variable
    dim - The spatial dimension
    See Also:
    Triplet
  - setDataArrayReal
```
public void setDataArrayReal(java.lang.Object A,
                    int dv)
```
    Assigns the appropriately dimensioned argument array A to the storage location in this data object for the real part of the data associated with dependent variable dv. The type specified for A is Object, and it can be an array of any dimensionality and component type. To create the array, the user should make sure it is consistent with the information supplied by methods like getDimensionLengths and getDataArrayTypeNames. If the Object A is null, the data array will be deleted, losing any existing data in this location. If it is not an array of some kind, then nothing is done.
    Warning to programmers: the independent variables associated with the array are not automatically reset when a new array is stored. This is because it is not possible to know whether the independent variable should be a uniformly spaced index starting at zero, or something more complicated. Therefore users should be sure that they call setIndependentTriplet or setIndependentArrayReal if the new dependent array has a different size from the previous one. However, to catch the most frequent case, the method resetDependent will reset the independent variable in one situation, where the previous dependent variable was a Triplet and the new dependent array has a size in that direction that is different from the length of the Triplet. Then the independent variable is reset to a Triplet of the correct length, starting at zero with step 1.
    
    Parameters:
    A - The (real part of the) data to be stored in this dependent variable
    dv - The dimension in the data space (dependent variable)
  - setDataArrayImag
```
public void setDataArrayImag(java.lang.Object A,
                    int dv)
```
    Assigns the appropriately dimensioned argument array A to the storage location in this data object for the imaginary part of the data associated with independent variable dv. The type specified for A is Object, and it can be an array of any dimensionality and component type. To create the array the user should make sure it is consistent with the information supplied by methods like dimensionLengths() and getDataArrayTypeNames(). If the Object A is null, the data array will be deleted, losing any existing data in this location. If it is not an array of some kind, then nothing is done.
    Warning to programmers: the independent variables associated with the array are not automatically reset when a new array is stored. This is because it is not possible to know whether the independent variable should be a uniformly spaced index starting at zero, or something more complicated. Therefore users should be sure that they call setIndependentTriplet or setIndependentArrayReal if the new dependent array has a different size from the previous one. However, to catch the most frequent case, the method resetDependent will reset the independent variable in one situation, where the previous dependent variable was a Triplet and the new dependent array has a size in that direction that is different from the length of the Triplet. Then the independent variable is reset to a Triplet of the correct length, starting at zero with step 1.
    
    Parameters:
    A - The imaginary part of the data to be stored in this dependent variable
    dv - The dimension of the data space (dependent variable)
  - setTitle
```
public void setTitle(java.lang.String t)
```
    Sets the title String to the argument String t by reference.
    
    Parameters:
    t - The new graph title
  - addToTitle
```
public void addToTitle(java.lang.String str)
```
    Appends the argument String str to the existing title String.
    
    Parameters:
    str - The String to be appended
  - setIndependentLabels
```
public void setIndependentLabels(int dim,
                        java.lang.String lbl)
```
    Sets the axis label for the independent variable dim to the argument String l.
    
    Parameters:
    dim - The independent variable index
    lbl - The new axis label for this variable
  - setDependentLabels
```
public void setDependentLabels(int dv,
                      java.lang.String lbl)
```
    Sets the axis label for the dependent (data) variable dim to the argument String l.
    
    Parameters:
    dv - The data variable index
    lbl - The new axis label for this variable
  - setLabels
```
public void setLabels(java.util.Hashtable newLab)
```
    Sets the axis labels Hashtable, by reference. Use method copyLabels to create a copy by value.
    
    Parameters:
    newLab - The new axis labels
  - copyMe
```
public abstract TrianaType copyMe()
```
    This is one of the most important methods of Triana data. types. It returns a copy of the type invoking it. This must be overridden for every derived data type derived. If not, the data cannot be copied to be given to other units. Copying must be done by value, not by reference.
    To override, the programmer should not invoke the super.copyMe method. Instead, create an object of the current type and call methods copyData and copyParameters. If these have been written correctly, then they will do the copying. The code should createTool, for type YourType:
```
 YourType y = null; try { y =
 (YourType)getClass().newInstance(); y.copyData( this ); y.copyParameters( this ); y.setLegend( this.getLegend()
 ); } catch (IllegalAccessException ee) { System.out.println("Illegal Access: " + ee.getMessage()); } catch
 (InstantiationException ee) { System.out.println("Couldn't be instantiated: " + ee.getMessage()); } return y;
 
```
    The copied object's data should be identical to the original. The method here modifies only one item: a String indicating that the object was created as a copy is added to the description StringVector.
    Specified by:
    
    copyMe in class TrianaType
    
    Returns:
    TrianaType Copy by value of the current Object except for an updated description
  - copyData
```
protected void copyData(TrianaType source)
```
    Copies data held in dataContainer from the argument object to the current object. The copying is by value, not by reference. The implementation in GraphType copies all data arrays that are arrays of primitive Java data types (doubles, ints, booleans, etc). The data representing the independent variable(s) are always of this type, so they are copied by this implementation. Any derived classes that use dependent variable arrays of primitives can rely on their being copied here.
    However, a derived type that defines a dependent variable array of reference types (eg colors, streams, hashtables, ...) MUST implement copy-by-value in its own over-riding method copyData. The over-riding method should first invoke
```
 super.copyData( source ) 
```
    and then proceed with remaining copies.
    This method is protected so that it cannot be called except by objects that inherit from this one. It is called by copyMe.
    Overrides:
    
    copyData in class TrianaType
    
    Parameters:
    source - Object that contains the data to be copied.
  - copyParameters
```
protected void copyParameters(TrianaType source)
```
    Copies modifiable parameters from the argument object to the current object. The copying is by value, not by reference. Parameters are defined as data not held in dataContainer. They are modifiable if they have set... methods. Parameters that cannot be modified, but which are set by constructors, should be placed correctly into the copied object when it is constructed. Other parameters that do not have set... methods are given values when data arrays are set, eg in the method reset.
    In GraphType, only the parameters title and labels need to be copied. The boolean arrays and the arrays dimensionLengths and dataArrayTypeNames are generated automatically by reset when data is copied by copyData. The dimensions and the StringVectors for dimension names are generated by the default Constructor of subclass types. (Recall that GraphType is abstract so only subclass types are instantiated.)
    This method must be overridden by any subclass that defines new parameters. The overriding method should invoke its super method first, as below. It should use the set... and get... methods for the parameters in question.
    This method is protected so that it cannot be called except by objects that inherit from this one. It is called by copyMe.
    
    Overrides:
    
    copyParameters in class TrianaType
    
    Parameters:
    source - Object that contains the data to be copied.
  - outputToStream
```
public void outputToStream(java.io.PrintWriter dos)
                    throws java.io.IOException
```
    Used when Triana types want to be able to send ASCII data to other programs using strings. This is used to implement socket and to run other executables, written in C or other languages. With ASCII you don't have to worry about ENDIAN'ness as the conversions are all done via text. This is obviously slower than binary communication because you have to format the input and output within the other program and because ASCII data representations are generally larger than binary ones.
    This method takes care of the output of data held in dataContainer in arrays of primitive Java data types (double, int, boolean, etc) and of parameters defined in GraphType. It must be overridden in every subclass that defines new parameters or dependent variable arrays holding reference types at their lowest level. The problem of representing such reference types as ASCII data is left to the programmer! The overriding method should first call
```
 super.outputToStream( dos ) 
```
    to get output from superior classes, and then new parameters and/or arrays of reference values defined for the current subclass must be output.
    Unlike copyData and copyParameters, this method explicitly outputs the boolean and other arrays that have no set... methods. Although this is not necessary for the arrays to be reconstructed, it is useful because it allows the output stream to be written to a text editor for inspecting all the contents of the object.
    Programmers must ensure that all parameters are written to output before the data arrays that they describe, so that the input method can correctly dimension and createTool the data.
    Specified by:
    
    outputToStream in interface AsciiComm
    
    Parameters:
    dos - The data output stream
    
    Throws:
    
    java.io.IOException
  - inputFromStream
```
public void inputFromStream(java.io.BufferedReader dis)
                     throws java.io.IOException
```
    Used when Triana types want to be able to create a new data object from ASCII data it receives from a stream. This is used to implement socket and to run other executables, written in C or in other languages. With ASCII you don't have to worry about ENDIAN'ness as the conversions are all done via text. This is obviously slower than binary communication since you have to format the input and output and the ASCII representation of most data is larger than the binary.
    This method must be overridden in every subclass that defines new data or parameters. The overriding method should first call
```
 super.inputFromStream(dis) 
```
    to get input from superior classes, and then new parameters defined for the current subclass must be input. Data arrays that contain only primitive Java data types will be correctly input by the methods implemented here in GraphType, but programmers who define dependent variable data arrays that contain reference types will have to take care of ASCII I/O for these types themselves in the over-riding method. The over-riding method must be written to createTool data that are in the format created by outputToStream.
    Specified by:
    
    inputFromStream in interface AsciiComm
    
    Parameters:
    dis - The data input stream
    
    Throws:
    
    java.io.IOException
  - maxIndependentVariablesReal
```
public double[] maxIndependentVariablesReal()
```
    Returns a double[] containing the largest values of the elements of the real parts of all the independent variables.
    
    Returns:
    double[] The maximum values of the real parts of the independent variables
  - maxIndependentVariablesImag
```
public double[] maxIndependentVariablesImag()
```
    Returns a double[] containing the largest values of the elements of the imaginary parts of all the independent variables. It returns NaN for any data for which the imaginary part does not exist.
    
    Returns:
    double[] The maximum values of the imaginary parts of the independent variables
  - maxIndependentScalesReal
```
public double[] maxIndependentScalesReal()
```
    Returns a double[] containing the largest values on the graphing scales of all the independent variables.
    
    Returns:
    double[] The maximum values of the real parts of the graphing scales
  - maxIndependentScalesImag
```
public double[] maxIndependentScalesImag()
```
    Returns a double[] containing the largest values of the elements of the imaginary parts of the graphing scales of all the independent variables. It returns NaN for any data for which the imaginary part does not exist.
    
    Returns:
    double[] The maximum values of the imaginary parts of the graphing scales
  - minIndependentVariablesReal
```
public double[] minIndependentVariablesReal()
```
    Returns a double[] containing the smallest values of the elements of the real parts of all the independent variables.
    
    Returns:
    double[] The minimum values of the independent variables
  - minIndependentVariablesImag
```
public double[] minIndependentVariablesImag()
```
    Returns a double[] containing the smallest values elements of the imaginary parts of all the independent variables. It returns NaN for any data for which the imaginary part does not exist.
    
    Returns:
    double[] The minimum values of the imaginary parts of the independent variables
  - minIndependentScalesReal
```
public double[] minIndependentScalesReal()
```
    Returns a double[] containing the largest values on the graphing scales of all the independent variables.
    
    Returns:
    double[] The minimum values of the real parts of the graphing scales
  - minIndependentScalesImag
```
public double[] minIndependentScalesImag()
```
    Returns a double[] containing the largest values of the elements of the imaginary parts of the graphing scales of all the independent variables. It returns NaN for any data for which the imaginary part does not exist.
    
    Returns:
    double[] The minimum values of the imaginary parts of the graphing scales
  - maxDependentVariablesReal
```
public double[] maxDependentVariablesReal()
```
    Returns a double[] containing the maximum value of the real part of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData. The maximum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, then NaN is returned for that array.
    
    Returns:
    double[] The maximum values of the real parts of the arithmetic data arrays
  - maxDependentVariablesImag
```
public double[] maxDependentVariablesImag()
```
    Returns a double[] containing the maximum value of the imaginary part of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData. The maximum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, or if the data have no imaginary part, then NaN is returned for that array.
    
    Returns:
    double[] The maximum values of the imaginary parts of the arithmetic data arrays
  - maxDependentGraphingValuesReal
```
public double[] maxDependentGraphingValuesReal()
```
    Returns a double[] containing the maximum value of the real part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData. The maximum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, then NaN is returned for that array.
    
    Returns:
    double[] The maximum values of the real parts of the graphing values of the arithmetic data arrays
  - maxDependentGraphingValuesImag
```
public double[] maxDependentGraphingValuesImag()
```
    Returns a double[] containing the maximum value of the imaginary part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData. The maximum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, or if the data have no imaginary part, then NaN is returned for that array.
    
    Returns:
    double[] The maximum values of the imaginary parts of the graphing values of the arithmetic data arrays
  - minDependentVariablesReal
```
public double[] minDependentVariablesReal()
```
    Returns a double[] containing the minimum value of the real parts of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData. The minimum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, then NaN is returned for that array.
    
    Returns:
    double[] The minimum values of the real parts of the arithmetic data arrays
  - minDependentVariablesImag
```
public double[] minDependentVariablesImag()
```
    Returns a double[] containing the minimum value of the imaginary part of each of the dependent variables that is an arithmetic data type, as determined by method isArithmeticData. The minimum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, or if the data have no imaginary part, then NaN is returned for that array.
    
    Returns:
    double[] The minimum values of the imaginary parts of the arithmetic data arrays
  - minDependentGraphingValuesReal
```
public double[] minDependentGraphingValuesReal()
```
    Returns a double[] containing the minimum value of the real part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData. The minimum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, then NaN is returned for that array.
    
    Returns:
    double[] The minimum values of the real parts of the graphing values of the arithmetic data arrays
  - minDependentGraphingValuesImag
```
public double[] minDependentGraphingValuesImag()
```
    Returns a double[] containing the minimum value of the imaginary part of the graphing values associated with each of the dependent variables that is an arithmetic data type, as determined by the method isArithmeticData. The minimum is found over all elements of the array. The numeric data are converted to doubles for output. If the data are not arithmetic, or if the data have no imaginary part, then NaN is returned for that array.
    
    Returns:
    double[] The minimum values of the imaginary parts of the graphing values of the arithmetic data arrays
  - restrictToSubdomain
```
public GraphType restrictToSubdomain(int dim,
                            int from,
                            int to)
```
    Returns a new GraphType object with data restricted to a subdomain of one of the independent variables. In this version of the method, the subdomain is defined by minimum and maximum index values of the given variable. The dependent variable data arrays are modified so that they contain only the data on that subdomain. Data are copied value to the new object using method copyMe, so they do not contain references to the old data.
    
    Parameters:
    dim - The index of the independent variable being restricted
    from - The starting value of the new domain
    to - The ending value of the new domain
  - restrictToSubdomain
```
public GraphType restrictToSubdomain(int dim,
                            double from,
                            double to)
```
    Returns a new GraphType object with data restricted to a subdomain of one of the independent variables. In this version the subdomain is defined by the given minimum and maximum values of the real parts of the given independent variable. In case these do not coincide with actual sampled values of the variable, the restriction is performed by finding the largest subdomain of the independent variable that is contained in the given domain. The dependent variable data arrays are modified so that they contain only the data on that subdomain. Data are copied by value to the new object using copyMe, so they do not contain references to the old data. If there is no value of the independent variable in the given subdomain, the method returns null.
    
    Parameters:
    dim - The index of the independent variable being restricted
    from - The starting value of the new domain
    to - The ending value of the new domain
  - isCompatible
```
public boolean isCompatible(java.lang.Object obj)
```
    Tests the argument object to determine if it makes sense to perform arithmetic operations between it and the current object.
    In GraphType, this method tests that the given Object is either another GraphType or a Const. If it is a GraphType Object, then the method tests that the number of independent dimensions and their sizes are the same. It does not inspect the dependent data or check the values of the independent variables. If the given Object is a Const, then it is automatically compatible.
    Classes derived from this should over-ride this method with further tests as appropriate. The over-riding method should normally have the first lines
```
 boolean test = super.isCompatible( obj ); 
```
    followed by other tests. If other types not subclassed from GraphType or Const should be allowed to be compatible then other tests must be implemented.
    Specified by:
    
    isCompatible in interface Arithmetic
    
    Parameters:
    obj - The data object to be compared with the current one
    
    Returns:
    True if the object can be combined with the current one
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Tests if the argument Object is equal to the current object.
    In GraphType, this method inspects the data arrays and independent variables. The number of dependent variables and the values of the other parameters must be equal. The independent data values must also be equal. The dependent data arrays are then inspected, and all arrays of Java primitive data types are required to have equal elements. Arrays of non-primitive data types must have the same type, but are not tested further for equality.
    This method must be over-ridden in derived types. In a derived type called xxx the method should begin
```
 if ( !( obj instanceof xxx ) ) return false; if
 ( !isCompatible( obj ) ) return false; 
```
    followed by tests that are specific to type xxx (testing its own parameters) and then (if all tests have been passed) the last line should be
```
 return super.equals( obj );
 
```
    This line invokes the other equals methods up the chain to GraphType. Each superior object tests its own parameters. If subclasses implement dependent data that are not arrays of primitives, then they should implement suitable tests of equality for these in this method.
    Specified by:
    
    equals in interface Arithmetic
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    obj - The data object to be compared with the current one
    
    Returns:
    True if the object equals the current one
  - add
```
public Arithmetic add(java.lang.Object obj)
               throws java.lang.ClassCastException
```
    Adds the argument TrianaType to the current object. Users should invoke method isCompatible to test whether this operation makes sense.
    In the GraphType method, addition is performed if the given Object is a Const or another GraphType. In each case only data of the current object that are of an arithmetic nature are added to. When the given object is a GraphType, the addition is done between corresponding data sets, i.e. sets that have the same index when they are stored and retrieved. (If the given TrianaType passes the isCompatible test, then these sets are guaranteed to exist.) When the given TrianaType is a Const, its value is added to each element of all arithmetic data sets.
    
    Specified by:
    
    add in interface Arithmetic
    
    Parameters:
    obj - The new data object to be added to the current one
    
    Returns:
    the result
    
    Throws:
    
    java.lang.ClassCastException - if addition with the specified object is not valid
  - subtract
```
public Arithmetic subtract(java.lang.Object obj)
                    throws java.lang.ClassCastException
```
    Subtracts the argument TrianaType from the current object. Users should invoke method isCompatible to test whether this operation makes sense.
    In the GraphType method, subtraction is performed if the given Object is a Const or another GraphType. In each case only data of the current object that are of an arithmetic nature are subtracted from. When the given object is a GraphType, the subtraction is done between corresponding data sets, i.e. sets that have the same index when they are stored and retrieved. (If the given TrianaType passes the isCompatible test, then these sets are guaranteed to exist.) When the given TrianaType is a Const, its value is subtracted from each element of all arithmetic data sets.
    
    Specified by:
    
    subtract in interface Arithmetic
    
    Parameters:
    obj - The new data object to be subtracted from the current one
    
    Returns:
    the result
    
    Throws:
    
    java.lang.ClassCastException - if subtraction with the specified object is not valid
  - multiply
```
public Arithmetic multiply(java.lang.Object obj)
                    throws java.lang.ClassCastException
```
    Multiplies the argument TrianaType into the current object. Users should invoke method isCompatible to test whether this operation makes sense.
    In the GraphType method, multiplication is performed if the given Object is a Const or another GraphType. In each case only data of the current object that are of an arithmetic nature are multiplied. When the given object is a GraphType, the multiplication is done between corresponding data sets, i.e. sets that have the same index when they are stored and retrieved. (If the given TrianaType passes the isCompatible test, then these sets are guaranteed to exist.) When the given TrianaType is a Const, its value is multiplied into each element of all arithmetic data sets.
    
    Specified by:
    
    multiply in interface Arithmetic
    
    Parameters:
    obj - The new data object to be multiplied into the current one
    
    Returns:
    the result
    
    Throws:
    
    java.lang.ClassCastException - if multiplication with the specified object is not valid
  - divide
```
public Arithmetic divide(java.lang.Object obj)
                  throws java.lang.ClassCastException
```
    Divides the argument TrianaType into the current object. Users should invoke method isCompatible to test whether this operation makes sense.
    In the GraphType method, division is performed if the given Object is a Const or another GraphType. In each case only data of the current object that are of an arithmetic nature are divided. When the given object is a GraphType, the division is done between corresponding data sets, i.e. sets that have the same index when they are stored and retrieved. (If the given TrianaType passes the isCompatible test, then these sets are guaranteed to exist.) When the given TrianaType is a Const, its value is divided into each element of all arithmetic data sets.
    
    Specified by:
    
    divide in interface Arithmetic
    
    Parameters:
    obj - The new data object to be divided into the current one
    
    Returns:
    the result
    
    Throws:
    
    java.lang.ClassCastException - if division with the specified object is not valid

Class GraphType

Field Summary

Fields inherited from class triana.types.TrianaType

Constructor Summary

Method Summary

Methods inherited from class triana.types.TrianaType

Methods inherited from class java.lang.Object

Constructor Detail

GraphType

GraphType

Method Detail

setDefaultAxisLabelling

setDimensions

testDataModel

resetIndependent

resetDependent

isIndependentComplex

isDependentComplex

isTriplet

getDataArrayTypeNames

getDataArrayClass

isPrimitiveArray

isPrimitiveData

isArithmeticArray

isArithmeticData

isUniform

getIndependentVariables

getDependentVariables

getDimensionLengths

getDimensionLengths

getDependentVariableDimensions

getIndependentTriplet

getIndependentArrayReal

getIndependentScaleReal

getIndependentScaleRealLog10

getIndependentArrayImag

getIndependentScaleImag

getIndependentScaleImagLog10

getDataArrayReal

getDataArrayRealAsDoubles

getDataArrayRealAsFloats

getDataArrayRealAsInts

getDataArrayRealAsLongs

getDataArrayRealAsShorts

getDataArrayRealAsBytes

getDataArrayReal

getGraphArrayReal

getGraphArrayRealLog10

getDataArrayImag

getDataArrayImagAsDoubles

getDataArrayImagAsFloats

getDataArrayImagAsInts

getDataArrayImagAsLongs

getDataArrayImagAsShorts

getDataArrayImagAsBytes

getDataArrayImag

convertDependentDataArraysToDoubles

convertDependentDataArraysToFloats

convertDependentDataArraysToInts

convertDependentDataArraysToLongs

convertDependentDataArraysToShorts

convertDependentDataArraysToBytes

getGraphArrayImag

getGraphArrayImagLog10

getTitle

getIndependentLabels

getDependentLabels

getLabels

getLabelsColumn

copyLabels

setDimensionLengths

setDimensionLengths

setDependentVariableDimensions

setIndependentTriplet

setIndependentTriplet

setIndependentArrayReal

setIndependentArrayImag

setDataArrayReal

setDataArrayImag

setTitle