DoubleMatrixND (JOM (Java Optimization Modeler) 0.3.2 API)

java.lang.Object
- com.jom.DoubleMatrixND

```
public class DoubleMatrixND
extends Object
```
This class implements the functionality to handle an array of doubles of an arbitrary number of dimensions. Internally, data is stored in a 1D vector of the type DoubleMatrix1D, in the COLT library. The n-dim array can be dense or sparse, with NO DIFFERENCE AT ALL in the interface with the user. Internally, the data is stored in a sparse or dense 1D vector in each case, but all the operations have the same effect. The methods to manipulate and operate with the array follow a similar philosophy as the ones COLT library provides for handling 1D, 2D and 3D arrays. See http://sourceforge.net/projects/parallelcolt/ for more details

Author:

Pablo Pavon Mariño

See Also:

http://www.net2plan.com/jom

Constructor Summary

Constructors
Constructor and Description
`DoubleMatrixND(Collection<? extends Number> values, String rowOrColumn)` Creates a row or column (1xN, or Nx1) array, dense, with the given values
`DoubleMatrixND(double value)` Creates a 1x1 dense array with the given value.
`DoubleMatrixND(double[][] values)` Creates a 2D dense array, with the same size as value, and initializes with the data in values
`DoubleMatrixND(double[][][] values)` Creates a 3D dense array, with the same size as value, and initializes with the data in values
`DoubleMatrixND(double[][][][] values)` Creates a 4D dense array, with the same size as value, and initializes with the data in values
`DoubleMatrixND(double[][][][] values, String type)` Creates a 4D array of the appropriated type, with the same size as value, and initializes with the data in values
`DoubleMatrixND(double[][][] values, String type)` Creates a 3D array of the appropriated type, with the same size as value, and initializes with the data in values
`DoubleMatrixND(double[][] values, String type)` Creates a 2D array of the appropriated type, with the same size as value, and initializes with the data in values
`DoubleMatrixND(double[] values, String rowOrColumn)` Creates a row or column (1xN, or Nx1) array, dense, with the given values
`DoubleMatrixND(DoubleMatrix2D values)` Creates a 2D array of the same type (sparse, dense) as values, and also with the same size and data
`DoubleMatrixND(DoubleMatrix3D values)` Creates a 3D array of the same type (sparse, dense) as values, and also with the same size and data
`DoubleMatrixND(int[] size)` Creates a dense empty array of the given size, initialized to zeros
`DoubleMatrixND(int[] size, double value)` Creates a dense array of the given size, initialized to value
`DoubleMatrixND(int[] size, double[] values)` Creates a dense array of the given size, using values as initializing data. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index.
`DoubleMatrixND(int[] size, double[] values, String type)` Creates an array of the given size and type, using values as initializing data. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index .
`DoubleMatrixND(int[] size, DoubleMatrix1D values)` Creates an array of the given size and the same type as values, using values as initializing data. values must have as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index.
`DoubleMatrixND(int[] size, double value, String type)` Creates an array of the given size and type.
`DoubleMatrixND(int[] size, int[] values)` Creates a dense array of the given size, using values as initializing data, previously casted to double. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index.
`DoubleMatrixND(int[] size, int[] values, String type)` Creates an array of the given size and type, using values as initializing data, previously casted to double. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index.
`DoubleMatrixND(int[] size, String type)` Creates an empty array of the given size and type, initialized to zeros

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`aggregate(DoubleDoubleFunction aggr, DoubleFunction f)` Applies a function to each cell and aggregates the results.
`double`	`aggregate(DoubleDoubleFunction aggr, DoubleFunction f, IntArrayList indexList)` Applies a function to all cells with the given indexes and aggregates the results
`double`	`aggregate(DoubleMatrixND other, DoubleDoubleFunction aggr, DoubleDoubleFunction f)` Applies a function to each corresponding cell of two matrices and aggregates the results.
`DoubleMatrixND`	`ascending(double first, double step)` Fills the current array with ascending numbers (in the order of the linear indexes)
`DoubleMatrixND`	`assign(double value)` Sets all cells to the state specified by value
`DoubleMatrixND`	`assign(double[] values)` Sets all cells to the state specified by values. values is required to have as many cells as this.
`DoubleMatrixND`	`assign(DoubleFunction f)` Assigns the result of a function to each cell. x[i] = function(x[i]).
`DoubleMatrixND`	`assign(DoubleMatrixND other)` Replaces all cell values of the receiver with the values of another matrix.
`DoubleMatrixND`	`assign(DoubleMatrixND y, DoubleDoubleFunction function)` Assigns the result of a function to each cell; x[i] = function(x[i],y[i]).
`DoubleMatrixND`	`assign(DoubleMatrixND y, DoubleDoubleFunction function, IntArrayList indexList)` Assigns the result of a function to all cells with a given indexes function - a function object taking as first argument the current cell's value of this, and as second argument the current cell's value of y
`DoubleMatrixND`	`assign(DoubleProcedure cond, double value)` Assigns a value to all cells that satisfy a condition.
`DoubleMatrixND`	`assign(DoubleProcedure cond, DoubleFunction f)` Assigns the result of a function to all cells that satisfy a condition.
`int`	`cardinality()` Returns the number of cells having non-zero values; ignores tolerance
`DoubleMatrixND`	`copy()` Constructs and returns a deep copy of the receiver.
`DoubleMatrixND`	`descending(double first, double step)` Fills the current array with descending numbers (in the order of the linear indexes)
`DoubleMatrix1D`	`elements()` Returns the elements of this matrix
`boolean`	`equals(double value)` Returns whether all cells are equal to the given value
`boolean`	`equals(DoubleMatrixND other)` Compares this object against the specified object.
`double`	`get(int index)` Returns the matrix cell value at the given index.
`double`	`get(int[] subindexes)` Returns the matrix cell value at the given subindexes
`double[]`	`getMaxLocation()` Return maximum value of this matrix together with its location.
`double[]`	`getMinLocation()` Return minimum value of this matrix together with its location.
`void`	`getNegativeValues(IntArrayList indexList, DoubleArrayList valueList)` Fills the indexes and values of cells having negative values into the specified lists.
`void`	`getNonZeros(IntArrayList indexList, DoubleArrayList valueList)` Fills the indexes and values of cells having non zero values into the specified lists.
`int`	`getNumberOfNonZeros()` Returns the number of non zero elements
`int`	`getNumDim()` Gets the number of dimensions of the array
`int`	`getNumElements()` Gets the number of cells in the array (e.g for an array of size 2x3x5 the number of cells is 30)
`void`	`getPositiveValues(IntArrayList indexList, DoubleArrayList valueList)` Fills the indexes and values of cells having positive values into the specified lists.
`double`	`getQuick(int index)` Returns the matrix cell value at coordinate index.
`IntMatrix1D`	`getSize()` Gets the size of the array
`int`	`getSize(int dim)` Gets the size of the array in the given dimension
`static IntMatrix2D`	`ind2sub(int[] indexes, int[] size)` For arrays of the given size, converts the positions of the cells given as a linear index in indexes, into their associated coordinates in the arrays.
`static IntMatrix1D`	`ind2sub(int index, int[] size)` For arrays of the given size, converts the position of a cell given as a linear index, into its associated coordinates in the arrays.
`boolean`	`isView()` Returns whether the receiver is a view or not.
`void`	`normalize()` Normalizes this matrix, i.e. makes the sum of all elements equal to 1.0 If the matrix contains negative elements then all the values are shifted to ensure non-negativity.
`DoubleMatrixND`	`reshape(int[] newSize)` Changes the shape of this array.
`void`	`set(int[] subindexes, double value)` Sets the matrix cell at coordinate given by the subindexes to the specified value.
`void`	`set(int index, double value)` Sets the matrix cell at coordinate given by the subindexes to the specified value.
`void`	`setQuick(int[] subindexes, double value)` Sets the matrix cell at coordinate given by the subindexes to the specified value.
`void`	`setQuick(int index, double value)` Sets the matrix cell at coordinate index to the specified value.
`static int`	`sub2ind(IntMatrix1D coord, int[] size)` For arrays of the given size, converts the position of the cell given as a their coordinates, into its associated linear index.
`static IntMatrix1D`	`sub2ind(IntMatrix2D coord, int[] size)` For arrays of the given size, converts the positions of the cells given as a their coordinates, into their associated linear index.
`double[]`	`to1DArray()` Constructs and returns a 1-dimensional array containing the array values.
`double[][]`	`to2DArray()` Constructs and returns a 2-dimensional array containing the array values.
`double[][][]`	`to3DArray()` Constructs and returns a 3-dimensional array containing the array values.
`double[][][][]`	`to4DArray()` Constructs and returns a 4-dimensional array containing the array values.
`double[][][][][]`	`to5DArray()` Constructs and returns a 5-dimensional array containing the array values.
`double[][][][][][]`	`to6DArray()` Constructs and returns a 5-dimensional array containing the array values.
`Object`	`toArray()` Constructs and returns an n-dimensional double array containing the array values.
`List<Double>`	`toList()` Returns a List (ArrayList) with the values copied
`String`	`toString()`
`double`	`toValue()` If the array has only one cell, returns its value.
`DoubleMatrix1D`	`view1D()` If the array is 2D, returns a DoubleMatrix2D object copying the data in the array
`DoubleMatrix2D`	`view2D()` If the array is 2D, returns a DoubleMatrix2D object copying the data in the array
`DoubleMatrix3D`	`view3D(String type)` If the array is 3D, returns a DoubleMatrix3D object copying the data in the array
`DoubleMatrixND`	`viewPart(IntMatrix1D initialSubindex, IntMatrix1D width)` Returns Constructs and returns a new sub-range view.
`DoubleMatrixND`	`viewSelection(IntMatrix1D[] subindexesPerDim)` Returns Constructs and returns a new sub-range view.
`DoubleMatrixND`	`viewSelectionByIndexes(int[] newSize, IntMatrix1D indexes)` Returns Constructs and returns a new sub-range view.
`double`	`zSum()` Returns the sum of all cells in the array

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

- Constructor Detail
  - DoubleMatrixND
```
public DoubleMatrixND(double value)
```
    Creates a 1x1 dense array with the given value.
    
    Parameters:
    
    value - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(double[][] values)
```
    Creates a 2D dense array, with the same size as value, and initializes with the data in values
    
    Parameters:
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(double[] values,
                      String rowOrColumn)
```
    Creates a row or column (1xN, or Nx1) array, dense, with the given values
    
    Parameters:
    
    values - the values
    
    rowOrColumn - "row" for a row vector, "column" or other string for a column vector
  - DoubleMatrixND
```
public DoubleMatrixND(Collection<? extends Number> values,
                      String rowOrColumn)
```
    Creates a row or column (1xN, or Nx1) array, dense, with the given values
    
    Parameters:
    
    values - the values
    
    rowOrColumn - "row" for a row vector, "column" or other string for a column vector
  - DoubleMatrixND
```
public DoubleMatrixND(double[][] values,
                      String type)
```
    Creates a 2D array of the appropriated type, with the same size as value, and initializes with the data in values
    
    Parameters:
    
    values - The initializing data
    
    type - "sparse" or "dense" for creating sparse or dense arrays respectively
  - DoubleMatrixND
```
public DoubleMatrixND(double[][][] values)
```
    Creates a 3D dense array, with the same size as value, and initializes with the data in values
    
    Parameters:
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(double[][][] values,
                      String type)
```
    Creates a 3D array of the appropriated type, with the same size as value, and initializes with the data in values
    
    Parameters:
    
    values - The initializing data
    
    type - "sparse" or "dense" for creating spavaluesrse or dense arrays respectively
  - DoubleMatrixND
```
public DoubleMatrixND(double[][][][] values)
```
    Creates a 4D dense array, with the same size as value, and initializes with the data in values
    
    Parameters:
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(double[][][][] values,
                      String type)
```
    Creates a 4D array of the appropriated type, with the same size as value, and initializes with the data in values
    
    Parameters:
    
    values - The initializing data
    
    type - "sparse" or "dense" for creating sparse or dense arrays respectively
  - DoubleMatrixND
```
public DoubleMatrixND(DoubleMatrix2D values)
```
    Creates a 2D array of the same type (sparse, dense) as values, and also with the same size and data
    
    Parameters:
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(DoubleMatrix3D values)
```
    Creates a 3D array of the same type (sparse, dense) as values, and also with the same size and data
    
    Parameters:
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size)
```
    Creates a dense empty array of the given size, initialized to zeros
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      double value)
```
    Creates a dense array of the given size, initialized to value
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    value - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      double value,
                      String type)
```
    Creates an array of the given size and type. All the elements of the array equal to value
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    value - The initializing data
    
    type - "sparse" or "dense" for creating sparse or dense arrays respectively
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      double[] values)
```
    Creates a dense array of the given size, using values as initializing data. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index. See the JOM help to see how linear indexes correspond to positions in the array.
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      double[] values,
                      String type)
```
    Creates an array of the given size and type, using values as initializing data. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index . See the JOM help to see how linear indexes correspond to positions in the array.
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    values - The initializing data
    
    type - "sparse" or "dense" for creating sparse or dense arrays respectively
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      DoubleMatrix1D values)
```
    Creates an array of the given size and the same type as values, using values as initializing data. values must have as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index. See the JOM help to see how linear indexes correspond to positions in the array.
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      int[] values)
```
    Creates a dense array of the given size, using values as initializing data, previously casted to double. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index. See the JOM help to see how linear indexes correspond to positions in the array.
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    values - The initializing data
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      int[] values,
                      String type)
```
    Creates an array of the given size and type, using values as initializing data, previously casted to double. values must be a vector of as many elements as the number of cells in the array (product of the numbers in size parameter). i-th index in values vector is put in the array position of i-th linear index. See the JOM help to see how linear indexes correspond to positions in the array.
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    values - The initializing data
    
    type - "sparse" or "dense" for creating sparse or dense arrays respectively
  - DoubleMatrixND
```
public DoubleMatrixND(int[] size,
                      String type)
```
    Creates an empty array of the given size and type, initialized to zeros
    
    Parameters:
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    type - "sparse" or "dense" for creating sparse or dense arrays respectively. "random" for creating a matrix with random numbers between 0 and 1 sampled from a uniform distribution
- Method Detail
  - ind2sub
```
public static IntMatrix1D ind2sub(int index,
                                  int[] size)
```
    For arrays of the given size, converts the position of a cell given as a linear index, into its associated coordinates in the arrays.
    
    Parameters:
    
    index - Linear index of the cell position
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    Returns:
    
    The coordinates of the cell in the array
  - ind2sub
```
public static IntMatrix2D ind2sub(int[] indexes,
                                  int[] size)
```
    For arrays of the given size, converts the positions of the cells given as a linear index in indexes, into their associated coordinates in the arrays.
    
    Parameters:
    
    indexes - Linear indexes of the cells to convert
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    Returns:
    
    A 2D array, as many columns as dimensions in the array. i.th row of the array contains the coordinates of the i-th linear index to convert
  - sub2ind
```
public static int sub2ind(IntMatrix1D coord,
                          int[] size)
```
    For arrays of the given size, converts the position of the cell given as a their coordinates, into its associated linear index.
    
    Parameters:
    
    coord - Coordinates of the cell position
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    Returns:
    
    The linear index associated to the cell position
  - sub2ind
```
public static IntMatrix1D sub2ind(IntMatrix2D coord,
                                  int[] size)
```
    For arrays of the given size, converts the positions of the cells given as a their coordinates, into their associated linear index.
    
    Parameters:
    
    coord - Coordinates of the cell position. Each row is a coordinate
    
    size - Array size. The i-th element in size indicates the size of the array in the corresponding dimension.
    
    Returns:
    
    The set of linear indexes associated to the cell positions. i-th element corresponds to i-th row in coord
  - aggregate
```
public double aggregate(DoubleDoubleFunction aggr,
                        DoubleFunction f)
```
    Applies a function to each cell and aggregates the results. Applies a function to each cell and aggregates the results. Returns a value v such that v==a(size()) where a(i) == aggr( a(i-1), f(get(row,column)) ) and terminators are a(1) == f(get(0,0)), a(0)==Double.NaN.
    
    Parameters:
    
    aggr - an aggregation function taking as first argument the current aggregation and as second argument the transformed current cell value.
    
    f - a function transforming the current cell value.
    
    Returns:
    
    the aggregated measure
  - aggregate
```
public double aggregate(DoubleDoubleFunction aggr,
                        DoubleFunction f,
                        IntArrayList indexList)
```
    Applies a function to all cells with the given indexes and aggregates the results
    
    Parameters:
    
    aggr - an aggregation function taking as first argument the current aggregation and as second argument the transformed current cell value.
    
    f - a function transforming the current cell value
    
    indexList - indexes of the cells
    
    Returns:
    
    the aggregated measure
  - aggregate
```
public double aggregate(DoubleMatrixND other,
                        DoubleDoubleFunction aggr,
                        DoubleDoubleFunction f)
```
    Applies a function to each corresponding cell of two matrices and aggregates the results. Returns a value v such that v==a(size()) where a (i) == aggr( a(i-1), f(get(row,column),other.get(row,column)) ) and terminators are a(1) == f(get(0,0),other.get(0,0)), a(0)==Double.NaN.
    
    Parameters:
    
    other - the second array to make the aggregation
    
    aggr - an aggregation function taking as first argument the current aggregation and as second argument the transformed current cell values
    
    f - a function transforming the current cell values
    
    Returns:
    
    the aggregated measure
  - ascending
```
public DoubleMatrixND ascending(double first,
                                double step)
```
    Fills the current array with ascending numbers (in the order of the linear indexes)
    
    Parameters:
    
    first - First number, assigned to index 0 of the array
    
    step - step between the values in two consecutive cells
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(double value)
```
    Sets all cells to the state specified by value
    
    Parameters:
    
    value - the value to be filled into the cells
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(double[] values)
```
    Sets all cells to the state specified by values. values is required to have as many cells as this. The values are copied. So subsequent changes in values are not reflected in the matrix, and vice-versa.
    
    Parameters:
    
    values - the values to be filled into the cells.
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(DoubleFunction f)
```
    Assigns the result of a function to each cell. x[i] = function(x[i]).
    
    Parameters:
    
    f - a function object taking as argument the current cell's value.
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(DoubleMatrixND other)
```
    Replaces all cell values of the receiver with the values of another matrix. Both matrices must have the same size. If both matrices share the same cells (as is the case if they are views derived from the same matrix) and intersect in an ambiguous way, then replaces as if using an intermediate auxiliary deep copy of other.
    
    Parameters:
    
    other - the source matrix to copy from (may be identical to the receiver).
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(DoubleMatrixND y,
                             DoubleDoubleFunction function)
```
    Assigns the result of a function to each cell; x[i] = function(x[i],y[i]).
    
    Parameters:
    
    y - the secondary array to operate on.
    
    function - a function object taking as first argument the current cell's value of this, and as second argument the current cell's value of y,
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(DoubleMatrixND y,
                             DoubleDoubleFunction function,
                             IntArrayList indexList)
```
    Assigns the result of a function to all cells with a given indexes function - a function object taking as first argument the current cell's value of this, and as second argument the current cell's value of y
    
    Parameters:
    
    y - the secondary array to operate on
    
    function - a function object taking as first argument the current cell's value of this, and as second argument the current cell's value of y,
    
    indexList - the list of indexes
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(DoubleProcedure cond,
                             double value)
```
    Assigns a value to all cells that satisfy a condition.
    
    Parameters:
    
    cond - a condition
    
    value - a value
    
    Returns:
    
    this
  - assign
```
public DoubleMatrixND assign(DoubleProcedure cond,
                             DoubleFunction f)
```
    Assigns the result of a function to all cells that satisfy a condition.
    
    Parameters:
    
    cond - a condition
    
    f - a function object
    
    Returns:
    
    this
  - cardinality
```
public int cardinality()
```
    Returns the number of cells having non-zero values; ignores tolerance
    
    Returns:
    
    cardinality
  - copy
```
public DoubleMatrixND copy()
```
    Constructs and returns a deep copy of the receiver. Note that the returned matrix is an independent deep copy. The returned matrix is not backed by this matrix, so changes in the returned matrix are not reflected in this matrix, and vice-versa.
    
    Returns:
    
    a deep copy of the receiver
  - descending
```
public DoubleMatrixND descending(double first,
                                 double step)
```
    Fills the current array with descending numbers (in the order of the linear indexes)
    
    Parameters:
    
    first - First number, assigned to index 0 of the array
    
    step - step between the values in two consecutive cells
    
    Returns:
    
    this
  - elements
```
public DoubleMatrix1D elements()
```
    Returns the elements of this matrix
    
    Returns:
    
    the elements
  - equals
```
public boolean equals(double value)
```
    Returns whether all cells are equal to the given value
    
    Parameters:
    
    value - the value to test against.
    
    Returns:
    
    true if all cells are equal to the given value, false otherwise
  - equals
```
public boolean equals(DoubleMatrixND other)
```
    Compares this object against the specified object. The result is true if and only if the argument is not null and is at least a DoubleMatrixND object that has the same size as the receiver and has exactly the same values at the same coordinates
    
    Parameters:
    
    other - the object to compare with
    
    Returns:
    
    true if the objects are the same; false otherwise
  - get
```
public double get(int index)
```
    Returns the matrix cell value at the given index.
    
    Parameters:
    
    index - the index of the cell
    
    Returns:
    
    the value of the specified cell
  - get
```
public double get(int[] subindexes)
```
    Returns the matrix cell value at the given subindexes
    
    Parameters:
    
    subindexes - the coordinates of the cell
    
    Returns:
    
    the value of the specified cell
  - getMaxLocation
```
public double[] getMaxLocation()
```
    Return maximum value of this matrix together with its location. If the array has no elements, an empty array is returned
    
    Returns:
    
    {maximum_value, cell index (cast to double)}
  - getMinLocation
```
public double[] getMinLocation()
```
    Return minimum value of this matrix together with its location. If the array has no elements, an empty array is returned
    
    Returns:
    
    {minimum_value, cell index (cast to double)}
  - getNegativeValues
```
public void getNegativeValues(IntArrayList indexList,
                              DoubleArrayList valueList)
```
    Fills the indexes and values of cells having negative values into the specified lists. Fills into the lists, starting at index 0. After this call returns the specified lists all have a new size, the number of non-zero values.
    
    Parameters:
    
    indexList - the list to be filled with the indexes, can have any size
    
    valueList - the list to be filled with values, can have any size
  - getNonZeros
```
public void getNonZeros(IntArrayList indexList,
                        DoubleArrayList valueList)
```
    Fills the indexes and values of cells having non zero values into the specified lists. Fills into the lists, starting at index 0. After this call returns the specified lists all have a new size, the number of non-zero values. In general, fill order is unspecified.
    
    Parameters:
    
    indexList - the list to be filled with the indexes, can have any size
    
    valueList - the list to be filled with values, can have any size
  - getNumberOfNonZeros
```
public int getNumberOfNonZeros()
```
    Returns the number of non zero elements
    
    Returns:
    
    the number of nonzero elements
  - getNumDim
```
public int getNumDim()
```
    Gets the number of dimensions of the array
    
    Returns:
    
    the number of dimensions
  - getNumElements
```
public int getNumElements()
```
    Gets the number of cells in the array (e.g for an array of size 2x3x5 the number of cells is 30)
    
    Returns:
    
    the number of cells
  - getPositiveValues
```
public void getPositiveValues(IntArrayList indexList,
                              DoubleArrayList valueList)
```
    Fills the indexes and values of cells having positive values into the specified lists. Fills into the lists, starting at index 0. After this call returns the specified lists all have a new size, the number of non-zero values.
    
    Parameters:
    
    indexList - the list to be filled with the indexes, can have any size
    
    valueList - the list to be filled with values, can have any size
  - getQuick
```
public double getQuick(int index)
```
    Returns the matrix cell value at coordinate index. Provided with invalid parameters this method may return invalid objects without throwing any exception. You should only use this method when you are absolutely sure that the coordinate is within bounds. Precondition (unchecked): \(index < 0 \parallel index \ge size()\).
    
    Parameters:
    
    index - the index of the cell
    
    Returns:
    
    the value of the specified cell
  - getSize
```
public IntMatrix1D getSize()
```
    Gets the size of the array
    
    Returns:
    
    a copy of the vector with the array size. The i-th element in size indicates the size of the array in the corresponding dimension.
  - getSize
```
public int getSize(int dim)
```
    Gets the size of the array in the given dimension
    
    Parameters:
    
    dim - Dimension from which the size will be taken.
    
    Returns:
    
    the size
  - isView
```
public boolean isView()
```
    Returns whether the receiver is a view or not. Being a view means that the data in the array is backed by the data in other array, so changes in one side are automatically reflected in the other
    
    Returns:
    
    true if the receiver is a view, false otherwise
  - normalize
```
public void normalize()
```
    Normalizes this matrix, i.e. makes the sum of all elements equal to 1.0 If the matrix contains negative elements then all the values are shifted to ensure non-negativity.
  - reshape
```
public DoubleMatrixND reshape(int[] newSize)
```
    Changes the shape of this array. The number of elements is the same, the elements are not copied.
    
    Parameters:
    
    newSize - new size of the array. The array must have the same number of cells
    
    Returns:
    
    new array matrix
  - set
```
public void set(int index,
                double value)
```
    Sets the matrix cell at coordinate given by the subindexes to the specified value.
    
    Parameters:
    
    index - the index of the cell.
    
    value - the value to be filled into the specified cell.
  - set
```
public void set(int[] subindexes,
                double value)
```
    Sets the matrix cell at coordinate given by the subindexes to the specified value.
    
    Parameters:
    
    subindexes - the cell coordinates
    
    value - the value to be filled into the specified cell.
  - setQuick
```
public void setQuick(int index,
                     double value)
```
    Sets the matrix cell at coordinate index to the specified value. Provided with invalid parameters this method may access illegal indexes without throwing any exception. You should only use this method when you are absolutely sure that the coordinate is within bounds.
    
    Parameters:
    
    index - the index of the cell.
    
    value - the value to be filled into the specified cell
  - setQuick
```
public void setQuick(int[] subindexes,
                     double value)
```
    Sets the matrix cell at coordinate given by the subindexes to the specified value. Provided with invalid parameters this method may access illegal indexes without throwing any exception. You should only use this method when you are absolutely sure that the coordinate is within bounds.
    
    Parameters:
    
    subindexes - the coordinates of the cell.
    
    value - the value to be filled into the specified cell
  - to1DArray
```
public double[] to1DArray()
```
    Constructs and returns a 1-dimensional array containing the array values. The values are copied.
    
    Returns:
    
    an array filled with the values of the cells
  - to2DArray
```
public double[][] to2DArray()
```
    Constructs and returns a 2-dimensional array containing the array values. The values are copied.
    
    Returns:
    
    an array filled with the values of the cells
  - to3DArray
```
public double[][][] to3DArray()
```
    Constructs and returns a 3-dimensional array containing the array values. The values are copied.
    
    Returns:
    
    an array filled with the values of the cells
  - to4DArray
```
public double[][][][] to4DArray()
```
    Constructs and returns a 4-dimensional array containing the array values. The values are copied.
    
    Returns:
    
    an array filled with the values of the cells
  - to5DArray
```
public double[][][][][] to5DArray()
```
    Constructs and returns a 5-dimensional array containing the array values. The values are copied.
    
    Returns:
    
    an array filled with the values of the cells
  - to6DArray
```
public double[][][][][][] to6DArray()
```
    Constructs and returns a 5-dimensional array containing the array values. The values are copied.
    
    Returns:
    
    an array filled with the values of the cells
  - toArray
```
public Object toArray()
```
    Constructs and returns an n-dimensional double array containing the array values. The values are copied. If the array has 2 dimensions returns a double [][] object If the array has 3 dimensions returns a double [][][] object If the array has 4 dimensions returns a double [][][][] object If the array has 5 dimensions returns a double [][][][][] object If the array has 6 dimensions returns a double [][][][][][] object For arrays of more dimensions, an exception is raised
    
    Returns:
    
    an array filled with the values of the cells
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toValue
```
public double toValue()
```
    If the array has only one cell, returns its value. Otherwise raises an exception
    
    Returns:
    
    The value
  - toList
```
public List<Double> toList()
```
    Returns a List (ArrayList) with the values copied
    
    Returns:
    
    see above
  - view2D
```
public DoubleMatrix2D view2D()
```
    If the array is 2D, returns a DoubleMatrix2D object copying the data in the array
    
    Returns:
    
    The DoubleMatrix2D object
  - view1D
```
public DoubleMatrix1D view1D()
```
    If the array is 2D, returns a DoubleMatrix2D object copying the data in the array
    
    Returns:
    
    The DoubleMatrix2D object
  - view3D
```
public DoubleMatrix3D view3D(String type)
```
    If the array is 3D, returns a DoubleMatrix3D object copying the data in the array
    
    Parameters:
    
    type - Type of the matrix.
    
    Returns:
    
    The DoubleMatrix3D object
  - viewPart
```
public DoubleMatrixND viewPart(IntMatrix1D initialSubindex,
                               IntMatrix1D width)
```
    Returns Constructs and returns a new sub-range view. The view contains the cells from coordinates initialSubindex to initialSubindex+width-1, all inclusive. It is equivalent to viewSelection where in the i-th dimension, the ranges are (in JOM notation) (initialSubindex(i)) : (initialSubindex(i)+width(i)-1). In JOM notation Note that the view is really just a range restriction: The returned matrix is backed by this matrix, so changes in the returned matrix are reflected in this matrix, and vice-versa
    
    Parameters:
    
    initialSubindex - The coordinates of the cell that will is the upper-left corner of the subrange. This cell will have index 0 in the new view.
    
    width - For each dimension, its size in the new view.
    
    Returns:
    
    the new view
  - viewSelection
```
public DoubleMatrixND viewSelection(IntMatrix1D[] subindexesPerDim)
```
    Returns Constructs and returns a new sub-range view. The operation is equal to how subarrays are extracted in JOM. See JOM documentation for more info. Note that the view is really just a range restriction: The returned matrix is backed by this matrix, so changes in the returned matrix are reflected in this matrix, and vice-versa
    
    Parameters:
    
    subindexesPerDim - One IntMatrix1D object for each dimension, containing the indexes in the subrange.
    
    Returns:
    
    the new view
  - viewSelectionByIndexes
```
public DoubleMatrixND viewSelectionByIndexes(int[] newSize,
                                             IntMatrix1D indexes)
```
    Returns Constructs and returns a new sub-range view. The elements in the new view are the ones given in the array of indexes. Note that the view is really just a range restriction: The returned matrix is backed by this matrix, so changes in the returned matrix are reflected in this matrix, and vice-versa
    
    Parameters:
    
    newSize - The new size of the array. The associated number of cells in the new array must be equal to the number of indexes in indexes
    
    indexes - An array with the inedexes to include in the view (in the same order as they appear here)
    
    Returns:
    
    the new view
  - zSum
```
public double zSum()
```
    Returns the sum of all cells in the array
    
    Returns:
    
    the sum

Class DoubleMatrixND

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

DoubleMatrixND

Method Detail

ind2sub

ind2sub

sub2ind

sub2ind

aggregate

aggregate

aggregate

ascending

assign

assign

assign

assign

assign

assign

assign

assign

cardinality

copy

descending

elements

equals

equals

get

get

getMaxLocation

getMinLocation

getNegativeValues

getNonZeros

getNumberOfNonZeros

getNumDim

getNumElements

getPositiveValues

getQuick

getSize

getSize

isView

normalize

reshape

set

set

setQuick

setQuick

to1DArray

to2DArray

to3DArray

to4DArray

to5DArray

to6DArray

toArray

toString

toValue

toList

view2D

view1D