Array (CDM core library 4.6.0 API)

java.lang.Object
- ucar.ma2.Array

Direct Known Subclasses:

ArrayBoolean, ArrayByte, ArrayChar, ArrayDouble, ArrayFloat, ArrayInt, ArrayLong, ArrayObject, ArrayRagged, ArrayScalar, ArrayShort, ArrayString, ArrayStructure
```
public abstract class Array
extends Object
```
Superclass for implementations of multidimensional arrays. An Array has a classType which gives the Class of its elements, and a shape which describes the number of elements in each index. The rank is the number of indices. A scalar Array has rank = 0. An Array may have arbitrary rank. The Array size is the total number of elements, which must be less than 2^31 (about 2x10^9).
Actual data storage is done with Java 1D arrays and stride index calculations. This makes our Arrays rectangular, i.e. no "ragged arrays" where different elements can have different lengths as in Java multidimensional arrays, which are arrays of arrays.
Each primitive Java type (boolean, byte, char, short, int, long, float, double) has a corresponding concrete implementation, e.g. ArrayBoolean, ArrayDouble. Reference types are all implemented using the ArrayObject class, with the exceptions of the reference types that correspond to the primitive types, eg Double.class is mapped to double.class.
For efficiency, each Array type implementation has concrete subclasses for ranks 0-7, eg ArrayDouble.D0 is a double array of rank 0, ArrayDouble.D1 is a double array of rank 1, etc. These type and rank specific classes are convenient to work with when you know the type and rank of the Array. Ranks greater than 7 are handled by the type-specific superclass e.g. ArrayDouble. The Array class itself is used for fully general handling of any type and rank array. Use the Array.factory() methods to create Arrays in a general way.
The stride index calculations allow logical views to be efficiently implemented, eg subset, transpose, slice, etc. These views use the same data storage as the original Array they are derived from. The index stride calculations are equally efficient for any composition of logical views.
The type, shape and backing storage of an Array are immutable. The data itself is read or written using an Index or an IndexIterator, which stores any needed state information for efficient traversal. This makes use of Arrays thread-safe (as long as you dont share the Index or IndexIterator) except for the possibility of non-atomic read/write on long/doubles. If this is the case, you should probably synchronize your calls. Presumably 64-bit CPUs will make those operations atomic also.

Author:

caron

See Also:
Index, IndexIterator

Field Summary

Fields
Modifier and Type Field and Description

protected Index indexCalc

protected int rank

protected boolean unsigned

Fields
Modifier and Type	Field and Description
`protected Index`	`indexCalc`
`protected int`	`rank`
`protected boolean`	`unsigned`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Array(Index index)

protected Array(int[] shape)

Constructors
Modifier	Constructor and Description
`protected`	`Array(Index index)`
`protected`	`Array(int[] shape)`

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`arraycopy(Array arraySrc, int srcPos, Array arrayDst, int dstPos, int len)` Cover for System.arraycopy().
`Array`	`copy()` Create a copy of this Array, copying the data so that physical order is the same as logical order
`protected abstract void`	`copyFrom1DJavaArray(IndexIterator iter, Object javaArray)`
`Object`	`copyTo1DJavaArray()` Copy this array to a 1D Java primitive array of type getElementType(), with the physical order of the result the same as logical order.
`protected abstract void`	`copyTo1DJavaArray(IndexIterator iter, Object javaArray)`
`Object`	`copyToNDJavaArray()` Copy this array to a n-Dimensional Java primitive array of type getElementType() and rank getRank().
`protected abstract Array`	`createView(Index index)` create new Array with given Index and the same backing store
`static Array`	`factory(Class classType, int[] shape)` Generate new Array with given type and shape and zeroed storage.
`static Array`	`factory(Class classType, int[] shape, Object storage)` Generate new Array with given type, shape, storage.
`static Array`	`factory(DataType dataType, int[] shape)` Generate new Array with given type and shape and zeroed storage.
`static Array`	`factory(DataType dtype, int[] shape, ByteBuffer bb)` Create an Array from a ByteBuffer
`static Array`	`factory(DataType dataType, int[] shape, Object storage)` /** Generate new Array with given type, shape, storage.
`static Array`	`factory(Object javaArray)` Generate a new Array from a java array of any rank and type.
`static Array`	`factoryConstant(Class classType, int[] shape, Object storage)` Generate new Array with given type and shape and an Index that always return 0.
`Array`	`flip(int dim)` Create a new Array using same backing store as this Array, by flipping the index so that it runs from shape[index]-1 to 0.
`Object`	`get1DJavaArray(Class wantType)` This gets the equivalent java array of the wanted type, in correct order.
`abstract boolean`	`getBoolean(Index ima)` Get the array element at the current element of ima, as a boolean.
`abstract boolean`	`getBoolean(int elem)`
`abstract byte`	`getByte(Index ima)` Get the array element at the current element of ima, as a byte.
`abstract byte`	`getByte(int elem)`
`abstract char`	`getChar(Index ima)` Get the array element at the current element of ima, as a char.
`abstract char`	`getChar(int elem)`
`ByteBuffer`	`getDataAsByteBuffer()` This gets the data as a ByteBuffer, in correct order.
`DataType`	`getDataType()` Return the computed datatype for this array
`abstract double`	`getDouble(Index ima)` Get the array element at the current element of ima, as a double.
`abstract double`	`getDouble(int elem)`
`abstract Class`	`getElementType()` Get the element class type of this Array
`abstract float`	`getFloat(Index ima)` Get the array element at the current element of ima, as a float.
`abstract float`	`getFloat(int elem)`
`Index`	`getIndex()` Get an Index object used for indexed access of this Array.
`IndexIterator`	`getIndexIterator()` Get an index iterator for traversing the array in canonical order.
`IndexIterator`	`getIndexIteratorFast()` Deprecated. use getIndexIterator
`Index`	`getIndexPrivate()` Get an Index object used for indexed access of this Array.
`abstract int`	`getInt(Index ima)` Get the array element at the current element of ima, as a int.
`abstract int`	`getInt(int elem)`
`abstract long`	`getLong(Index ima)` Get the array element at the current element of ima, as a long.
`abstract long`	`getLong(int elem)`
`abstract Object`	`getObject(Index ima)` Get the array element at index as an Object.
`abstract Object`	`getObject(int elem)`
`IndexIterator`	`getRangeIterator(List<Range> ranges)` Get an index iterator for traversing a section of the array in canonical order.
`int`	`getRank()` Get the number of dimensions of the array.
`int[]`	`getShape()` Get the shape: length of array in each dimension.
`abstract short`	`getShort(Index ima)` Get the array element at the current element of ima, as a short.
`abstract short`	`getShort(int elem)`
`long`	`getSize()` Get the total number of elements in the array.
`long`	`getSizeBytes()` Get the total number of bytes in the array.
`abstract Object`	`getStorage()` Get underlying primitive array storage.
`boolean`	`hasNext()` Check if more elements in the local iterator.
`boolean`	`isConstant()` If this is a constant array
`boolean`	`isUnsigned()` Find whether the underlying data should be interpreted as unsigned.
`static Array`	`makeArray(DataType dtype, boolean isUnsigned, List<String> stringValues)` Make an 1D array from a list of strings.
`static Array`	`makeArray(DataType dtype, int npts, double start, double incr)` Make a 1D array from a start and inccr.
`static Array`	`makeArray(DataType dtype, List<String> stringValues)` Make an 1D array from a list of strings.
`static Array`	`makeArray(DataType dtype, String[] stringValues)` Make an 1D array from an array of strings.
`static Array`	`makeArrayRankPlusOne(Array org)` Add extra dimension with len = 1.
`Object`	`next()` Return the next object in the local iterator.
`boolean`	`nextBoolean()` Return the next boolean in the local iterator.
`byte`	`nextByte()` Return the next byte in the local iterator.
`char`	`nextChar()` Return the next char in the local iterator.
`double`	`nextDouble()` Return the next double in the local iterator.
`float`	`nextFloat()` Return the next float in the local iterator.
`int`	`nextInt()` Return the next int in the local iterator.
`long`	`nextLong()` Return the next long in the local iterator.
`short`	`nextShort()` Return the next short in the local iterator.
`Array`	`permute(int[] dims)` Create a new Array using same backing store as this Array, by permuting the indices.
`Array`	`reduce()` Create a new Array using same backing store as this Array, by eliminating any dimensions with length one.
`Array`	`reduce(int dim)` Create a new Array using same backing store as this Array, by eliminating the specified dimension.
`void`	`resetLocalIterator()` Reset the local iterator.
`Array`	`reshape(int[] shape)` Create a new Array by copying this Array to a new one with given shape
`Array`	`reshapeNoCopy(int[] shape)` Reshape this array without copying data
`Array`	`section(int[] origin, int[] shape)` Create a new Array as a subsection of this Array, with rank reduction.
`Array`	`section(int[] origin, int[] shape, int[] stride)` Create a new Array as a subsection of this Array, with rank reduction.
`Array`	`section(List<Range> ranges)` Create a new Array as a subsection of this Array, with rank reduction.
`Array`	`sectionNoReduce(int[] origin, int[] shape, int[] stride)` Create a new Array as a subsection of this Array, without rank reduction.
`Array`	`sectionNoReduce(List<Range> ranges)` Create a new Array as a subsection of this Array, without rank reduction.
`abstract void`	`setBoolean(Index ima, boolean value)` Set the array element at the current element of ima.
`abstract void`	`setBoolean(int elem, boolean value)`
`abstract void`	`setByte(Index ima, byte value)` Set the array element at the current element of ima.
`abstract void`	`setByte(int elem, byte value)`
`abstract void`	`setChar(Index ima, char value)` Set the array element at the current element of ima.
`abstract void`	`setChar(int elem, char value)`
`abstract void`	`setDouble(Index ima, double value)` Set the array element at the current element of ima.
`abstract void`	`setDouble(int elem, double val)`
`abstract void`	`setFloat(Index ima, float value)` Set the array element at the current element of ima.
`abstract void`	`setFloat(int elem, float val)`
`abstract void`	`setInt(Index ima, int value)` Set the array element at the current element of ima.
`abstract void`	`setInt(int elem, int value)`
`abstract void`	`setLong(Index ima, long value)` Set the array element at the current element of ima.
`abstract void`	`setLong(int elem, long value)`
`abstract void`	`setObject(Index ima, Object value)` Set the array element at index to the specified value.
`abstract void`	`setObject(int elem, Object value)`
`abstract void`	`setShort(Index ima, short value)` Set the array element at the current element of ima.
`abstract void`	`setShort(int elem, short value)`
`void`	`setUnsigned(boolean unsigned)` Set whether the data should be interpreted as unsigned.
`String`	`shapeToString()` Create a string representation of the shape of this Array.
`Array`	`slice(int dim, int value)` Create a new Array using same backing store as this Array, by fixing the specified dimension at the specified index value.
`String`	`toString()`
`Array`	`transpose(int dim1, int dim2)` Create a new Array using same backing store as this Array, by transposing two of the indices.

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

- Field Detail
  - indexCalc
```
protected final Index indexCalc
```
  - rank
```
protected final int rank
```
  - unsigned
```
protected boolean unsigned
```
- Constructor Detail
  - Array
```
protected Array(int[] shape)
```
  - Array
```
protected Array(Index index)
```
- Method Detail
  - factory
```
public static Array factory(DataType dataType,
            int[] shape)
```
    Generate new Array with given type and shape and zeroed storage.
    
    Parameters:
    dataType - instance of DataType.
    shape - shape of the array.
    
    Returns:
    new Array or Array.D if 0 <= rank <= 7.
  - factory
```
public static Array factory(Class classType,
            int[] shape)
```
    Generate new Array with given type and shape and zeroed storage.
    
    Parameters:
    classType - element Class type, eg double.class.
    shape - shape of the array.
    
    Returns:
    new Array or Array.D if 0 <= rank <= 7.
  - factory
```
public static Array factory(DataType dataType,
            int[] shape,
            Object storage)
```
    /** Generate new Array with given type, shape, storage.
    
    Parameters:
    dataType - DataType, eg DataType.DOUBLE.
    shape - shape of the array.
    storage - primitive array of correct type
    
    Returns:
    new Array or Array.D if 0 <= rank <= 7.
  - factory
```
public static Array factory(Class classType,
            int[] shape,
            Object storage)
```
    Generate new Array with given type, shape, storage. This should be package private, but is exposed for efficiency. Normally use factory( Class classType, int [] shape) instead. storage must be 1D array of type classType. storage.length must equal product of shapes storage data needs to be in canonical order
    
    Parameters:
    classType - element class type, eg double.class. Corresponding Object types like Double.class are mapped to double.class. Any reference types use ArrayObject.
    shape - array shape
    storage - 1D java array of type classType, except object types like Double.class are mapped to their corresponding primitive type, eg double.class.
    
    Returns:
    Array of given type, shape and storage
    
    Throws:
    
    IllegalArgumentException - storage.length != product of shapes
    
    ClassCastException - wrong storage type
  - factoryConstant
```
public static Array factoryConstant(Class classType,
                    int[] shape,
                    Object storage)
```
    Generate new Array with given type and shape and an Index that always return 0.
    
    Parameters:
    classType - element Class type, eg double.class.
    shape - shape of the array.
    storage - primitive array of correct type of length 1
    
    Returns:
    new Array or Array.D if 0 <= rank <= 7.
  - factory
```
public static Array factory(Object javaArray)
```
    Generate a new Array from a java array of any rank and type. This makes a COPY of the data values of javaArray. LOOK: not sure this works for reference types.
    
    Parameters:
    javaArray - scalar Object or a java array of any rank and type
    
    Returns:
    Array of the appropriate rank and type, with the data copied from javaArray.
  - arraycopy
```
public static void arraycopy(Array arraySrc,
             int srcPos,
             Array arrayDst,
             int dstPos,
             int len)
```
    Cover for System.arraycopy(). Works with the underlying data arrays. ArraySrc and ArrayDst must be the same primitive type. Exposed for efficiency; use at your own risk.
    
    Parameters:
    arraySrc - copy from here : if not in canonical order, an extra copy will be done
    srcPos - starting at
    arrayDst - copy to here : must be in canonical order
    dstPos - starting at
    len - number of elements to copy
  - makeArray
```
public static Array makeArray(DataType dtype,
              int npts,
              double start,
              double incr)
```
    Make a 1D array from a start and inccr.
    
    Parameters:
    dtype - data type of result. must be convertible to double.
    npts - number of points
    start - starting values
    incr - increment
    
    Returns:
    1D array
  - makeArray
```
public static Array makeArray(DataType dtype,
              boolean isUnsigned,
              List<String> stringValues)
                       throws NumberFormatException
```
    Make an 1D array from a list of strings.
    
    Parameters:
    dtype - data type of the array.
    isUnsigned - may be unsigned (byte, short, int, long)
    stringValues - list of strings.
    
    Returns:
    resulting 1D array.
    
    Throws:
    
    NumberFormatException - if string values not parseable to specified data type
  - makeArray
```
public static Array makeArray(DataType dtype,
              List<String> stringValues)
                       throws NumberFormatException
```
    Make an 1D array from a list of strings.
    
    Parameters:
    dtype - data type of the array. Assumed unsigned
    stringValues - list of strings.
    
    Returns:
    resulting 1D array.
    
    Throws:
    
    NumberFormatException - if string values not parseable to specified data type
  - makeArray
```
public static Array makeArray(DataType dtype,
              String[] stringValues)
                       throws NumberFormatException
```
    Make an 1D array from an array of strings.
    
    Parameters:
    dtype - data type of the array. Assumed unsigned
    stringValues - list of strings.
    
    Returns:
    resulting 1D array.
    
    Throws:
    
    NumberFormatException - if string values not parseable to specified data type
  - makeArrayRankPlusOne
```
public static Array makeArrayRankPlusOne(Array org)
```
    Add extra dimension with len = 1.
    
    Parameters:
    org - original array
    
    Returns:
    rank1 array of rank + 1
  - getDataType
```
public DataType getDataType()
```
    Return the computed datatype for this array
    
    Returns:
    the data type
  - getIndex
```
public Index getIndex()
```
    Get an Index object used for indexed access of this Array.
    
    Returns:
    an Index for this Array
    See Also:
    Index
  - getIndexPrivate
```
public Index getIndexPrivate()
```
    Get an Index object used for indexed access of this Array.
    
    Returns:
    an Index for this Array
  - getIndexIterator
```
public IndexIterator getIndexIterator()
```
    Get an index iterator for traversing the array in canonical order.
    
    Returns:
    an IndexIterator for this Array
    See Also:
    IndexIterator
  - getRank
```
public int getRank()
```
    Get the number of dimensions of the array.
    
    Returns:
    number of dimensions of the array
  - getShape
```
public int[] getShape()
```
    Get the shape: length of array in each dimension.
    
    Returns:
    array whose length is the rank of this Array and whose elements represent the length of each of its indices.
  - getSize
```
public long getSize()
```
    Get the total number of elements in the array.
    
    Returns:
    total number of elements in the array
  - getSizeBytes
```
public long getSizeBytes()
```
    Get the total number of bytes in the array.
    
    Returns:
    total number of bytes in the array
  - getRangeIterator
```
public IndexIterator getRangeIterator(List<Range> ranges)
                               throws InvalidRangeException
```
    Get an index iterator for traversing a section of the array in canonical order. This is equivalent to Array.section(ranges).getIterator();
    
    Parameters:
    ranges - list of Ranges that specify the array subset. Must be same rank as original Array. A particular Range: 1) may be a subset, or 2) may be null, meaning use entire Range.
    
    Returns:
    an IndexIterator over the named range.
    
    Throws:
    
    InvalidRangeException - if ranges is invalid
  - getIndexIteratorFast
```
public IndexIterator getIndexIteratorFast()
```
    Deprecated. use getIndexIterator
    
    Get an index iterator for traversing the array in arbitrary order. Use this if you dont care what order the elements are returned, eg if you are summing an Array. To get an iteration in order, use getIndexIterator(), which returns a fast iterator if possible.
    
    Returns:
    an IndexIterator for traversing the array in arbitrary order.
  - getElementType
```
public abstract Class getElementType()
```
    Get the element class type of this Array
    
    Returns:
    the class of the element
  - getStorage
```
public abstract Object getStorage()
```
    Get underlying primitive array storage. Exposed for efficiency, use at your own risk.
    
    Returns:
    underlying primitive array storage
  - copyFrom1DJavaArray
```
protected abstract void copyFrom1DJavaArray(IndexIterator iter,
                       Object javaArray)
```
  - copyTo1DJavaArray
```
protected abstract void copyTo1DJavaArray(IndexIterator iter,
                     Object javaArray)
```
  - createView
```
protected abstract Array createView(Index index)
```
    create new Array with given Index and the same backing store
    
    Parameters:
    index - use this Index
    
    Returns:
    a view of the Array using the given Index
  - section
```
public Array section(List<Range> ranges)
              throws InvalidRangeException
```
    Create a new Array as a subsection of this Array, with rank reduction. No data is moved, so the new Array references the same backing store as the original.
    
    Parameters:
    ranges - list of Ranges that specify the array subset. Must be same rank as original Array. A particular Range: 1) may be a subset, or 2) may be null, meaning use entire Range. If Range[dim].length == 1, then the rank of the resulting Array is reduced at that dimension.
    
    Returns:
    the new Array
    
    Throws:
    
    InvalidRangeException - if ranges is invalid
  - section
```
public Array section(int[] origin,
            int[] shape)
              throws InvalidRangeException
```
    Create a new Array as a subsection of this Array, with rank reduction. No data is moved, so the new Array references the same backing store as the original.
    
    Parameters:
    origin - int array specifying the starting index. Must be same rank as original Array.
    shape - int array specifying the extents in each dimension. This becomes the shape of the returned Array. Must be same rank as original Array. If shape[dim] == 1, then the rank of the resulting Array is reduced at that dimension.
    
    Returns:
    the new Array
    
    Throws:
    
    InvalidRangeException - if ranges is invalid
  - section
```
public Array section(int[] origin,
            int[] shape,
            int[] stride)
              throws InvalidRangeException
```
    Create a new Array as a subsection of this Array, with rank reduction. No data is moved, so the new Array references the same backing store as the original.
    
    Parameters:
    origin - int array specifying the starting index. Must be same rank as original Array.
    shape - int array specifying the extents in each dimension. This becomes the shape of the returned Array. Must be same rank as original Array. If shape[dim] == 1, then the rank of the resulting Array is reduced at that dimension.
    stride - int array specifying the strides in each dimension. If null, assume all ones.
    
    Returns:
    the new Array
    
    Throws:
    
    InvalidRangeException - if ranges is invalid
  - sectionNoReduce
```
public Array sectionNoReduce(List<Range> ranges)
                      throws InvalidRangeException
```
    Create a new Array as a subsection of this Array, without rank reduction. No data is moved, so the new Array references the same backing store as the original. Vlen is transferred over unchanged.
    
    Parameters:
    ranges - list of Ranges that specify the array subset. Must be same rank as original Array. A particular Range: 1) may be a subset, or 2) may be null, meaning use entire Range.
    
    Returns:
    the new Array
    
    Throws:
    
    InvalidRangeException - if ranges is invalid
  - sectionNoReduce
```
public Array sectionNoReduce(int[] origin,
                    int[] shape,
                    int[] stride)
                      throws InvalidRangeException
```
    Create a new Array as a subsection of this Array, without rank reduction. No data is moved, so the new Array references the same backing store as the original.
    
    Parameters:
    origin - int array specifying the starting index. Must be same rank as original Array.
    shape - int array specifying the extents in each dimension. This becomes the shape of the returned Array. Must be same rank as original Array.
    stride - int array specifying the strides in each dimension. If null, assume all ones.
    
    Returns:
    the new Array
    
    Throws:
    
    InvalidRangeException - if ranges is invalid
  - slice
```
public Array slice(int dim,
          int value)
```
    Create a new Array using same backing store as this Array, by fixing the specified dimension at the specified index value. This reduces rank by 1.
    
    Parameters:
    dim - which dimension to fix
    value - at what index value
    
    Returns:
    a new Array
  - copy
```
public Array copy()
```
    Create a copy of this Array, copying the data so that physical order is the same as logical order
    
    Returns:
    the new Array
  - get1DJavaArray
```
public Object get1DJavaArray(Class wantType)
```
    This gets the equivalent java array of the wanted type, in correct order. It avoids copying if possible.
    
    Parameters:
    wantType - returned object will be an array of this type. This must be convertible to it.
    
    Returns:
    java array of type want
  - getDataAsByteBuffer
```
public ByteBuffer getDataAsByteBuffer()
```
    This gets the data as a ByteBuffer, in correct order. It avoids copying if possible. Only for numeric types (byte, short, int, long, double, float)
    
    Returns:
    equivilent data in a ByteBuffer
  - factory
```
public static Array factory(DataType dtype,
            int[] shape,
            ByteBuffer bb)
```
    Create an Array from a ByteBuffer
    
    Parameters:
    dtype - type of data
    shape - shape of data; if null, then use int[]{bb.limit()}
    bb - data is in here
    
    Returns:
    equivilent Array
  - copyTo1DJavaArray
```
public Object copyTo1DJavaArray()
```
    Copy this array to a 1D Java primitive array of type getElementType(), with the physical order of the result the same as logical order.
    
    Returns:
    a Java 1D array of type getElementType().
  - copyToNDJavaArray
```
public Object copyToNDJavaArray()
```
    Copy this array to a n-Dimensional Java primitive array of type getElementType() and rank getRank(). Makes a copy of the data.
    
    Returns:
    a Java ND array of type getElementType().
  - flip
```
public Array flip(int dim)
```
    Create a new Array using same backing store as this Array, by flipping the index so that it runs from shape[index]-1 to 0.
    
    Parameters:
    dim - dimension to flip
    
    Returns:
    the new Array
  - transpose
```
public Array transpose(int dim1,
              int dim2)
```
    Create a new Array using same backing store as this Array, by transposing two of the indices.
    
    Parameters:
    dim1 - transpose these two indices
    dim2 - transpose these two indices
    
    Returns:
    the new Array
  - permute
```
public Array permute(int[] dims)
```
    Create a new Array using same backing store as this Array, by permuting the indices.
    
    Parameters:
    dims - the old index dims[k] becomes the new kth index.
    
    Returns:
    the new Array
    
    Throws:
    
    IllegalArgumentException: - wrong rank or dim[k] not valid
  - reshape
```
public Array reshape(int[] shape)
```
    Create a new Array by copying this Array to a new one with given shape
    
    Parameters:
    shape - the new shape
    
    Returns:
    the new Array
    
    Throws:
    
    IllegalArgumentException - new shape is not conformable
  - reshapeNoCopy
```
public Array reshapeNoCopy(int[] shape)
```
    Reshape this array without copying data
    
    Parameters:
    shape - the new shape
    
    Returns:
    the new Array, using same backing object
    
    Throws:
    
    IllegalArgumentException - new shape is not conformable
  - reduce
```
public Array reduce()
```
    Create a new Array using same backing store as this Array, by eliminating any dimensions with length one.
    
    Returns:
    the new Array, or the same array if no reduction was done
  - reduce
```
public Array reduce(int dim)
```
    Create a new Array using same backing store as this Array, by eliminating the specified dimension.
    
    Parameters:
    dim - dimension to eliminate: must be of length one, else IllegalArgumentException
    
    Returns:
    the new Array
  - isUnsigned
```
public boolean isUnsigned()
```
    Find whether the underlying data should be interpreted as unsigned. Only affects byte, short, and int. When true, conversions to wider types are handled correctly.
    
    Returns:
    true if the data is unsigned integer type.
  - isConstant
```
public boolean isConstant()
```
    If this is a constant array
    
    Returns:
    If this is a constant array
  - setUnsigned
```
public void setUnsigned(boolean unsigned)
```
    Set whether the data should be interpreted as unsigned. Only valid for byte, short, int, and long. When true, conversions to wider types are handled correctly.
    
    Parameters:
    unsigned - true if unsigned
  - getDouble
```
public abstract double getDouble(Index ima)
```
    Get the array element at the current element of ima, as a double.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to double if necessary.
  - setDouble
```
public abstract void setDouble(Index ima,
             double value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
  - getFloat
```
public abstract float getFloat(Index ima)
```
    Get the array element at the current element of ima, as a float.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to float if necessary.
  - setFloat
```
public abstract void setFloat(Index ima,
            float value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
  - getLong
```
public abstract long getLong(Index ima)
```
    Get the array element at the current element of ima, as a long.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to long if necessary.
  - setLong
```
public abstract void setLong(Index ima,
           long value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
  - getInt
```
public abstract int getInt(Index ima)
```
    Get the array element at the current element of ima, as a int.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to int if necessary.
  - setInt
```
public abstract void setInt(Index ima,
          int value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
  - getShort
```
public abstract short getShort(Index ima)
```
    Get the array element at the current element of ima, as a short.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to short if necessary.
  - setShort
```
public abstract void setShort(Index ima,
            short value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
  - getByte
```
public abstract byte getByte(Index ima)
```
    Get the array element at the current element of ima, as a byte.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to float if necessary.
  - setByte
```
public abstract void setByte(Index ima,
           byte value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
  - getChar
```
public abstract char getChar(Index ima)
```
    Get the array element at the current element of ima, as a char.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to char if necessary.
  - setChar
```
public abstract void setChar(Index ima,
           char value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
  - getBoolean
```
public abstract boolean getBoolean(Index ima)
```
    Get the array element at the current element of ima, as a boolean.
    
    Parameters:
    ima - Index with current element set
    
    Returns:
    value at index cast to boolean if necessary.
    
    Throws:
    
    ForbiddenConversionException - if underlying array not boolean
  - setBoolean
```
public abstract void setBoolean(Index ima,
              boolean value)
```
    Set the array element at the current element of ima.
    
    Parameters:
    ima - Index with current element set
    value - the new value; cast to underlying data type if necessary.
    
    Throws:
    
    ForbiddenConversionException - if underlying array not boolean
  - getObject
```
public abstract Object getObject(Index ima)
```
    Get the array element at index as an Object. The returned value is wrapped in an object, eg Double for double
    
    Parameters:
    ima - element Index
    
    Returns:
    Object value at index
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if index incorrect rank or out of bounds
  - setObject
```
public abstract void setObject(Index ima,
             Object value)
```
    Set the array element at index to the specified value. the value must be passed wrapped in the appropriate Object (eg Double for double)
    
    Parameters:
    ima - Index with current element set
    value - the new value.
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if index incorrect rank or out of bounds
    
    ClassCastException - if Object is incorrect type
  - getDouble
```
public abstract double getDouble(int elem)
```
  - setDouble
```
public abstract void setDouble(int elem,
             double val)
```
  - getFloat
```
public abstract float getFloat(int elem)
```
  - setFloat
```
public abstract void setFloat(int elem,
            float val)
```
  - getLong
```
public abstract long getLong(int elem)
```
  - setLong
```
public abstract void setLong(int elem,
           long value)
```
  - getInt
```
public abstract int getInt(int elem)
```
  - setInt
```
public abstract void setInt(int elem,
          int value)
```
  - getShort
```
public abstract short getShort(int elem)
```
  - setShort
```
public abstract void setShort(int elem,
            short value)
```
  - getByte
```
public abstract byte getByte(int elem)
```
  - setByte
```
public abstract void setByte(int elem,
           byte value)
```
  - getChar
```
public abstract char getChar(int elem)
```
  - setChar
```
public abstract void setChar(int elem,
           char value)
```
  - getBoolean
```
public abstract boolean getBoolean(int elem)
```
  - setBoolean
```
public abstract void setBoolean(int elem,
              boolean value)
```
  - getObject
```
public abstract Object getObject(int elem)
```
  - setObject
```
public abstract void setObject(int elem,
             Object value)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - shapeToString
```
public String shapeToString()
```
    Create a string representation of the shape of this Array.
    
    Returns:
    string representation of the shape
  - hasNext
```
public boolean hasNext()
```
    Check if more elements in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety. You cannot call any of the array.nextXXX() methods without calling hasNext() first. If you are not sure of the state of the iterator, you must reset it before use. Example:
```
 arr.resetLocalIterator();
 while (arr.hasNext()) {
 double val = mdata.nextDouble();
 ..
 }
 <.pre>
```
    Returns:
    true if there are more elements in the iteration
  - next
```
public Object next()
```
    Return the next object in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as an Object, same as IndexIterator.getObjectNext().
  - nextDouble
```
public double nextDouble()
```
    Return the next double in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a double, same as IndexIterator.getDoubleNext().
  - nextFloat
```
public float nextFloat()
```
    Return the next float in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a float, same as IndexIterator.getFloatNext().
  - nextByte
```
public byte nextByte()
```
    Return the next byte in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a byte, same as IndexIterator.getByteNext().
  - nextShort
```
public short nextShort()
```
    Return the next short in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a short, same as IndexIterator.getShortNext().
  - nextInt
```
public int nextInt()
```
    Return the next int in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a int, same as IndexIterator.getIntNext().
  - nextLong
```
public long nextLong()
```
    Return the next long in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a long, same as IndexIterator.getLongNext().
  - nextChar
```
public char nextChar()
```
    Return the next char in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a char, same as IndexIterator.getCharNext().
  - nextBoolean
```
public boolean nextBoolean()
```
    Return the next boolean in the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.
    
    Returns:
    next element as a boolean, same as IndexIterator.getBooleanNext().
  - resetLocalIterator
```
public void resetLocalIterator()
```
    Reset the local iterator. Uses the local iterator, which is not thread-safe. Use getIndexIterator if you need thread-safety.

Class Array

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

indexCalc

rank

unsigned

Constructor Detail

Array

Array

Method Detail

factory

factory

factory

factory

factoryConstant

factory

arraycopy

makeArray

makeArray

makeArray

makeArray

makeArrayRankPlusOne

getDataType

getIndex

getIndexPrivate

getIndexIterator

getRank

getShape

getSize

getSizeBytes

getRangeIterator

getIndexIteratorFast

getElementType

getStorage

copyFrom1DJavaArray

copyTo1DJavaArray

createView

section

section

section

sectionNoReduce

sectionNoReduce

slice

copy

get1DJavaArray

getDataAsByteBuffer

factory

copyTo1DJavaArray

copyToNDJavaArray

flip

transpose

permute

reshape

reshapeNoCopy

reduce

reduce

isUnsigned

isConstant

setUnsigned

getDouble

setDouble

getFloat

setFloat

getLong

setLong

getInt

setInt

getShort

setShort

getByte

setByte

getChar

setChar

getBoolean

setBoolean

getObject

setObject