AMatrix (vectorz 0.17.0 API)

java.lang.Object
- mikera.transformz.ATransform
- - mikera.transformz.AAffineTransform
  - - mikera.transformz.ALinearTransform
    - - mikera.matrixx.AMatrix

All Implemented Interfaces:

Cloneable, Iterable<AVector>, INDArray, IMatrix, ITransform

Direct Known Subclasses:

ADiagonalMatrix, ArrayMatrix, AVectorMatrix, ColumnMatrix, Matrix22, Matrix33, PermutationMatrix, PermutedMatrix, RowMatrix, SubsetMatrix, TransposedMatrix, ZeroMatrix
```
public abstract class AMatrix
extends ALinearTransform
implements IMatrix, Iterable<AVector>
```
General abstract 2D matrix class. Implements generic version of most key matrix operations.

Author:

Mike

Constructor Summary

Constructors
Constructor and Description

AMatrix()

Constructors
Constructor and Description
`AMatrix()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abs()` Replaces all elements of this array with their absolute values, according to Math.abs(double)
`void`	`add(AMatrix m)` Adds another matrix to this matrix.
`void`	`add(AVector v)`
`void`	`add(double d)`
`void`	`add(INDArray a)`
`void`	`addAt(int i, int j, double d)`
`void`	`addMultiple(AMatrix m, double factor)`
`void`	`addRowMultiple(int src, int dst, double factor)` Adds a multiple of a source row to a destination row This is an elementary row operation
`void`	`applyOp(IOp op)` Applies a unary operator to all elements of the array (in-place)
`void`	`applyOp(Op op)` Applies a unary operator to all elements of the array (in-place)
`List<Double>`	`asElementList()`
`AVector`	`asVector()` Returns the matrix values as a single reference Vector in the form [row0 row1 row2....]
`INDArray`	`broadcast(int... targetShape)`
`double`	`calculateElement(int i, AVector v)` Calculates a single element of the output.
`void`	`clamp(double min, double max)`
`AMatrix`	`clone()` Clones the transform, performing a deep copy where needed
`AVector`	`cloneRow(int row)`
`abstract int`	`columnCount()` Returns the number of columns in the matrix
`AMatrix`	`compose(AMatrix a)` Composes this matrix with another matrix (matrix multiplication) Returns a new matrix that represents the compose transformation.
`ATransform`	`compose(ATransform a)` Composes this transformation with another transformation, returning a new combined transformation
`void`	`composeWith(AMatrix a)`
`void`	`composeWith(ATransform a)` Composes this transformation with a given transformation, mutating the transformation to represent the combined transform
`AMatrix`	`copyOfMatrix()` Returns a deep copy of the transformation matrix for this affine transform
`AVector`	`copyOfTranslationVector()` Returns a deep copy of the translation vector for this affine transform
`void`	`copyTo(double[] arr)` Copies all the elements of this INDArray to the specified double array
`double`	`determinant()` Calculates the determinant of the matrix.
`int`	`dimensionality()` Returns the dimensionality of the array (number of dimensions in the array shape) e.g.
`long`	`elementCount()` Returns the total number of elements in this array.
`Iterator<Double>`	`elementIterator()`
`void`	`elementMul(AMatrix m)` Multiplies this matrix in-place by another in an entrywise manner (Hadamard product).
`double`	`elementSquaredSum()` Returns the squared sum of all elements in the matrix
`double`	`elementSum()` Returns the sum of all elements in the matrix
`boolean`	`epsilonEquals(AMatrix a)` Returns true if this matrix is approximately equal to a second matrix, up to a default tolerance level
`boolean`	`epsilonEquals(INDArray a)`
`boolean`	`epsilonEquals(INDArray a, double epsilon)`
`boolean`	`equals(AAffineTransform a)`
`boolean`	`equals(AMatrix a)`
`boolean`	`equals(INDArray v)` Returns true if the two arrays are exactly equal in value and shape
`boolean`	`equals(Object o)`
`abstract AMatrix`	`exactClone()` Returns an exact deep clone of an array (i.e.
`void`	`exp()`
`void`	`fill(double value)` Fills the array with asingle double value
`double`	`get()` Returns the double value of a scalar array
`double`	`get(int... indexes)` Returns the double value at the specified index position in an array
`double`	`get(int row)` Returns the double value at the specified position in a 1D vector
`abstract double`	`get(int row, int column)` Returns a specified element in the matrix
`AVector`	`getColumn(int column)` Returns a column of the matrix as a vector view
`void`	`getElements(double[] dest, int offset)` Gets all elements of the array, copying them into a double array
`AVector`	`getLeadingDiagonal()` Returns a new vector that contains the leading diagonal values of the matrix
`long[]`	`getLongShape()` Returns the shape of the array as an array of longs.
`AMatrix`	`getMatrixComponent()`
`AVector`	`getRow(int row)` Returns a row of the matrix as a vector view
`int[]`	`getShape()` Returns the shape of the array as an array of ints.
`int`	`getShape(int dim)` Returns the dimension size for a specific dimension in the array's shape
`List<AVector>`	`getSlices()` Returns a list of all major slices of this array.
`List<INDArray>`	`getSliceViews()` Returns a list of slices as mutable INDArray views.
`AMatrix`	`getTranspose()` Returns a transposed version of this matrix.
`AMatrix`	`getTransposeView()` Returns a transposed view of the array.
`int`	`hashCode()`
`boolean`	`hasOrthonormalColumns()`
`boolean`	`hassOrthonormalRows()`
`AMatrix`	`innerProduct(AMatrix a)`
`AMatrix`	`innerProduct(AScalar s)`
`AVector`	`innerProduct(AVector v)`
`INDArray`	`innerProduct(INDArray a)` Calculates the inner product of this array with another array.
`Matrix`	`innerProduct(Matrix a)`
`int`	`inputDimensions()` Returns the number of dimensions required for input vectors
`AMatrix`	`inverse()` Return the inverse of this transformation if possible
`boolean`	`isDiagonal()` Returns true iff a matrix is a square diagonal matrix
`boolean`	`isElementConstrained()` Returns true if the IND has additional constraints on element values
`boolean`	`isFullyMutable()` Returns true if the INDArray is fully mutable in all positions i.e.
`boolean`	`isHermitian()` Returns true if a matrix is Hermitian This is equivalent to isSymmetric(), since all Vectorz matrices have real values.
`boolean`	`isIdentity()` Returns true if this transform is known to be the identity function, i.e.
`boolean`	`isInvertible()` Returns true if this transform is invertible
`boolean`	`isLowerTriangular()` Returns true if a matrix is lower triangular
`boolean`	`isMutable()` Returns true if the INDArray is mutable (at least partially)
`boolean`	`isOrthogonal()`
`void`	`isPositiveDefinite()` Returns true if a matrix is positive definite
`boolean`	`isRectangularDiagonal()`
`boolean`	`isSquare()` Returns true if the transform is square (same number of input and output dimensions)
`boolean`	`isSymmetric()` Returns true if a matrix is symmetric
`boolean`	`isUpperTriangular()` Returns true if a matrix is upper triangular
`boolean`	`isView()` Return true if this is a view
`boolean`	`isZeroMatrix()` Returns true if the matrix is the zero matrix (all components zero)
`Iterator<AVector>`	`iterator()` Returns an iterator over rows in this Matrix
`void`	`log()` Computes the natural logarithm (in-place) for all array elements
`void`	`mul(AMatrix a)` "Multiplies" this matrix by another, composing the transformation
`void`	`multiply(double factor)` Multiplies all elements of the array by a given double value
`void`	`multiply(INDArray a)` Multiplies all elements by the equivalent elements in a second array
`void`	`multiplyRow(int i, double factor)` Multiplies a row by a constant factor This is an elementary row operation
`void`	`negate()` Negates all elements in the array
`long`	`nonZeroCount()` Returns the number of non-zero elements in the array.
`INDArray`	`outerProduct(INDArray a)` Calculates the outer product of this array with another array.
`int`	`outputDimensions()` Returns the number of dimensions required for output vectors
`void`	`pow(double exponent)` Raises all elements of the array to a specified power
`void`	`reciprocal()` Replaces all elements in the array with their reciprocal
`INDArray`	`reshape(int... dimensions)`
`abstract int`	`rowCount()` Returns the number of rows in the matrix
`void`	`scale(double factor)` Scales a matrix by a constant scalar factor.
`void`	`scaleAdd(double factor, double constant)` Scales all elements of the array by a given double value and adds a constant vale
`void`	`set(AMatrix a)`
`void`	`set(double value)` Sets all elements of an array to a specific double value
`void`	`set(INDArray a)`
`void`	`set(int[] indexes, double value)`
`void`	`set(int row, double value)`
`abstract void`	`set(int row, int column, double value)` Sets a specified element in the matrix
`void`	`set(Object o)`
`void`	`setColumn(int i, AVector col)`
`void`	`setElements(double[] values)` Sets all elements in an array using the given double values
`void`	`setElements(double[] values, int offset, int length)` Sets all elements in an array using the given double values
`void`	`setRow(int i, AVector row)`
`void`	`signum()` Calculates the signum of all elements of the array
`AVector`	`slice(int rowNumber)`
`INDArray`	`slice(int dimension, int index)`
`int`	`sliceCount()` returns the number of major slices in this array.
`void`	`sqrt()` Computes the square root of all elements in the array
`void`	`square()` Squares all elements of the array
`void`	`sub(AMatrix m)` Subtracts another matrix from this one
`void`	`sub(AVector v)`
`void`	`sub(double d)`
`void`	`sub(INDArray a)`
`void`	`swapColumns(int i, int j)` Swaps two columns of the matrix in place
`void`	`swapRows(int i, int j)` Swaps two rows of the matrix in place This is an elementary row operation
`AAffineTransform`	`toAffineTransform()`
`void`	`toDoubleBuffer(DoubleBuffer dest)` Copies the elements of this INDArray to the specified double buffer
`Matrix`	`toMatrix()` Converts the matrix to a the standard mutable Matrix type in row major order.
`AMatrix`	`toMutableMatrix()` Creates a fully mutable deep copy of this matrix
`String`	`toString()`
`Vector`	`toVector()` Converts the matrix to a single flattened vector in row major order.
`double`	`trace()`
`void`	`transform(AVector source, AVector dest)` Transforms the source vector, storing the result in the given destination vector
`void`	`transformInPlace(ArrayVector v)`
`void`	`transformInPlace(AVector v)` Transforms a vector destructively.
`void`	`transposeInPlace()`
`void`	`validate()` Validates the internal data structure of the INDArray.

Methods inherited from class mikera.transformz.ALinearTransform
getTranslationComponent, isLinear

Methods inherited from class mikera.transformz.AAffineTransform
compose, transformNormal

Methods inherited from class mikera.transformz.ATransform
takeComponents, takeComponents, takeComponents, transform

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

- Constructor Detail
  - AMatrix
```
public AMatrix()
```
- Method Detail
  - rowCount
```
public abstract int rowCount()
```
    Returns the number of rows in the matrix
    
    Specified by:
    
    rowCount in interface IMatrix
  - columnCount
```
public abstract int columnCount()
```
    Returns the number of columns in the matrix
    
    Specified by:
    
    columnCount in interface IMatrix
  - get
```
public abstract double get(int row,
         int column)
```
    Returns a specified element in the matrix
    
    Specified by:
    
    get in interface INDArray
    
    Specified by:
    
    get in interface IMatrix
    
    Returns:
  - set
```
public abstract void set(int row,
       int column,
       double value)
```
    Sets a specified element in the matrix
    
    Specified by:
    
    set in interface INDArray
    
    Specified by:
    
    set in interface IMatrix
  - get
```
public final double get(int row)
```
    Description copied from interface: INDArray
    
    Returns the double value at the specified position in a 1D vector
    
    Specified by:
    
    get in interface INDArray
    
    Returns:
  - get
```
public final double get()
```
    Description copied from interface: INDArray
    
    Returns the double value of a scalar array
    
    Specified by:
    
    get in interface INDArray
    
    Returns:
  - set
```
public void set(int row,
       double value)
```
    Specified by:
    
    set in interface INDArray
  - set
```
public void set(double value)
```
    Description copied from interface: INDArray
    
    Sets all elements of an array to a specific double value
    
    Specified by:
    
    set in interface INDArray
  - fill
```
public void fill(double value)
```
    Description copied from interface: INDArray
    
    Fills the array with asingle double value
    
    Specified by:
    
    fill in interface INDArray
  - clamp
```
public void clamp(double min,
         double max)
```
    Specified by:
    
    clamp in interface INDArray
  - pow
```
public void pow(double exponent)
```
    Description copied from interface: INDArray
    
    Raises all elements of the array to a specified power
    
    Specified by:
    
    pow in interface INDArray
  - square
```
public void square()
```
    Description copied from interface: INDArray
    
    Squares all elements of the array
    
    Specified by:
    
    square in interface INDArray
  - set
```
public void set(int[] indexes,
       double value)
```
    Specified by:
    
    set in interface INDArray
  - dimensionality
```
public int dimensionality()
```
    Description copied from interface: INDArray
    
    Returns the dimensionality of the array (number of dimensions in the array shape) e.g. 0 for a scalar, 1 for a vector, 2 for a matrix etc.
    
    Specified by:
    
    dimensionality in interface INDArray
    
    Returns:
  - elementCount
```
public long elementCount()
```
    Description copied from interface: INDArray
    
    Returns the total number of elements in this array. Equivalent to the product all dimension sizes.
    
    Specified by:
    
    elementCount in interface INDArray
    
    Returns:
  - slice
```
public AVector slice(int rowNumber)
```
    Specified by:
    
    slice in interface INDArray
  - slice
```
public INDArray slice(int dimension,
             int index)
```
    Specified by:
    
    slice in interface INDArray
  - sliceCount
```
public int sliceCount()
```
    Description copied from interface: INDArray
    
    returns the number of major slices in this array.
    
    Specified by:
    
    sliceCount in interface INDArray
    
    Returns:
  - getSlices
```
public List<AVector> getSlices()
```
    Description copied from interface: INDArray
    
    Returns a list of all major slices of this array.
    
    Specified by:
    
    getSlices in interface INDArray
    
    Returns:
  - getSliceViews
```
public List<INDArray> getSliceViews()
```
    Description copied from interface: INDArray
    
    Returns a list of slices as mutable INDArray views. Note: will return a list of AScalar values when this array is a 1D vector
    
    Specified by:
    
    getSliceViews in interface INDArray
    
    Returns:
  - getShape
```
public int[] getShape()
```
    Description copied from interface: INDArray
    
    Returns the shape of the array as an array of ints.
    
    Specified by:
    
    getShape in interface INDArray
    
    Returns:
  - getShape
```
public int getShape(int dim)
```
    Description copied from interface: INDArray
    
    Returns the dimension size for a specific dimension in the array's shape
    
    Specified by:
    
    getShape in interface INDArray
    
    Returns:
  - getLongShape
```
public long[] getLongShape()
```
    Description copied from interface: INDArray
    
    Returns the shape of the array as an array of longs.
    
    Specified by:
    
    getLongShape in interface INDArray
    
    Returns:
  - get
```
public double get(int... indexes)
```
    Description copied from interface: INDArray
    
    Returns the double value at the specified index position in an array
    
    Specified by:
    
    get in interface INDArray
    
    Returns:
  - getLeadingDiagonal
```
public AVector getLeadingDiagonal()
```
    Returns a new vector that contains the leading diagonal values of the matrix
    
    Returns:
  - calculateElement
```
public double calculateElement(int i,
                      AVector v)
```
    Description copied from class: ATransform
    
    Calculates a single element of the output. Not necessarily faster than calculating full output, but can be in some circumstances.
    
    Overrides:
    
    calculateElement in class AAffineTransform
  - toAffineTransform
```
public AAffineTransform toAffineTransform()
```
    Overrides:
    
    toAffineTransform in class AAffineTransform
  - getMatrixComponent
```
public AMatrix getMatrixComponent()
```
    Specified by:
    
    getMatrixComponent in class AAffineTransform
  - isIdentity
```
public boolean isIdentity()
```
    Description copied from class: ATransform
    
    Returns true if this transform is known to be the identity function, i.e. it maps all vectors to themselves
    
    Overrides:
    
    isIdentity in class AAffineTransform
  - isSquare
```
public boolean isSquare()
```
    Description copied from class: ATransform
    
    Returns true if the transform is square (same number of input and output dimensions)
    
    Overrides:
    
    isSquare in class ATransform
    
    Returns:
  - isOrthogonal
```
public boolean isOrthogonal()
```
  - hasOrthonormalColumns
```
public boolean hasOrthonormalColumns()
```
  - hassOrthonormalRows
```
public boolean hassOrthonormalRows()
```
  - inputDimensions
```
public int inputDimensions()
```
    Description copied from class: ATransform
    
    Returns the number of dimensions required for input vectors
    
    Specified by:
    
    inputDimensions in interface ITransform
    
    Specified by:
    
    inputDimensions in class ATransform
    
    Returns:
  - outputDimensions
```
public int outputDimensions()
```
    Description copied from class: ATransform
    
    Returns the number of dimensions required for output vectors
    
    Specified by:
    
    outputDimensions in interface ITransform
    
    Specified by:
    
    outputDimensions in class ATransform
    
    Returns:
  - reshape
```
public INDArray reshape(int... dimensions)
```
    Specified by:
    
    reshape in interface INDArray
  - transform
```
public void transform(AVector source,
             AVector dest)
```
    Description copied from class: ATransform
    
    Transforms the source vector, storing the result in the given destination vector
    
    Specified by:
    
    transform in interface ITransform
    
    Overrides:
    
    transform in class AAffineTransform
  - transformInPlace
```
public void transformInPlace(AVector v)
```
    Description copied from class: ATransform
    
    Transforms a vector destructively. Intended for fast non-allocating transforms
    
    Overrides:
    
    transformInPlace in class AAffineTransform
  - transformInPlace
```
public void transformInPlace(ArrayVector v)
```
  - getRow
```
public AVector getRow(int row)
```
    Returns a row of the matrix as a vector view
  - getColumn
```
public AVector getColumn(int column)
```
    Returns a column of the matrix as a vector view
  - cloneRow
```
public AVector cloneRow(int row)
```
  - set
```
public void set(AMatrix a)
```
  - set
```
public void set(INDArray a)
```
    Specified by:
    
    set in interface INDArray
  - set
```
public void set(Object o)
```
    Specified by:
    
    set in interface INDArray
  - setElements
```
public void setElements(double[] values,
               int offset,
               int length)
```
    Description copied from interface: INDArray
    
    Sets all elements in an array using the given double values
    
    Specified by:
    
    setElements in interface INDArray
  - getElements
```
public void getElements(double[] dest,
               int offset)
```
    Description copied from interface: INDArray
    
    Gets all elements of the array, copying them into a double array
    
    Specified by:
    
    getElements in interface INDArray
  - copyTo
```
public void copyTo(double[] arr)
```
    Description copied from interface: INDArray
    
    Copies all the elements of this INDArray to the specified double array
    
    Specified by:
    
    copyTo in interface INDArray
  - setElements
```
public void setElements(double[] values)
```
    Description copied from interface: INDArray
    
    Sets all elements in an array using the given double values
    
    Specified by:
    
    setElements in interface INDArray
  - isFullyMutable
```
public boolean isFullyMutable()
```
    Description copied from interface: INDArray
    
    Returns true if the INDArray is fully mutable in all positions i.e. every position can store any valid double value
    
    Specified by:
    
    isFullyMutable in interface INDArray
    
    Returns:
  - isMutable
```
public boolean isMutable()
```
    Description copied from interface: INDArray
    
    Returns true if the INDArray is mutable (at least partially)
    
    Specified by:
    
    isMutable in interface INDArray
    
    Returns:
  - isElementConstrained
```
public boolean isElementConstrained()
```
    Description copied from interface: INDArray
    
    Returns true if the IND has additional constraints on element values
    
    Specified by:
    
    isElementConstrained in interface INDArray
  - clone
```
public AMatrix clone()
```
    Description copied from class: ATransform
    
    Clones the transform, performing a deep copy where needed
    
    Specified by:
    
    clone in interface INDArray
    
    Overrides:
    
    clone in class ATransform
    
    Returns:
  - determinant
```
public double determinant()
```
    Calculates the determinant of the matrix.
  - toMutableMatrix
```
public AMatrix toMutableMatrix()
```
    Creates a fully mutable deep copy of this matrix
    
    Returns:
    A new matrix
  - transposeInPlace
```
public void transposeInPlace()
```
  - getTranspose
```
public AMatrix getTranspose()
```
    Returns a transposed version of this matrix. May or may not be a view.
    
    Specified by:
    
    getTranspose in interface INDArray
    
    Returns:
  - getTransposeView
```
public AMatrix getTransposeView()
```
    Description copied from interface: INDArray
    
    Returns a transposed view of the array. May throw UnsupportedOperationException if the array does not support this capability
    
    Specified by:
    
    getTransposeView in interface INDArray
    
    Returns:
  - add
```
public void add(AMatrix m)
```
    Adds another matrix to this matrix. Matrices must be the same size.
    
    Parameters:
    m -
  - add
```
public void add(AVector v)
```
  - sub
```
public void sub(AVector v)
```
  - sub
```
public void sub(double d)
```
    Specified by:
    
    sub in interface INDArray
  - scale
```
public final void scale(double factor)
```
    Scales a matrix by a constant scalar factor.
    
    Specified by:
    
    scale in interface INDArray
    
    Parameters:
    m -
  - scaleAdd
```
public final void scaleAdd(double factor,
            double constant)
```
    Description copied from interface: INDArray
    
    Scales all elements of the array by a given double value and adds a constant vale
    
    Specified by:
    
    scaleAdd in interface INDArray
  - multiply
```
public void multiply(double factor)
```
    Description copied from interface: INDArray
    
    Multiplies all elements of the array by a given double value
    
    Specified by:
    
    multiply in interface INDArray
  - elementSum
```
public double elementSum()
```
    Returns the sum of all elements in the matrix
    
    Specified by:
    
    elementSum in interface INDArray
    
    Parameters:
    m -
    
    Returns:
  - elementSquaredSum
```
public double elementSquaredSum()
```
    Returns the squared sum of all elements in the matrix
    
    Specified by:
    
    elementSquaredSum in interface INDArray
    
    Parameters:
    m -
    
    Returns:
  - elementIterator
```
public Iterator<Double> elementIterator()
```
  - nonZeroCount
```
public long nonZeroCount()
```
    Description copied from interface: INDArray
    
    Returns the number of non-zero elements in the array.
    
    Specified by:
    
    nonZeroCount in interface INDArray
    
    Returns:
  - sub
```
public void sub(AMatrix m)
```
    Subtracts another matrix from this one
    
    Parameters:
    m -
  - negate
```
public void negate()
```
    Description copied from interface: INDArray
    
    Negates all elements in the array
    
    Specified by:
    
    negate in interface INDArray
  - reciprocal
```
public void reciprocal()
```
    Description copied from interface: INDArray
    
    Replaces all elements in the array with their reciprocal
    
    Specified by:
    
    reciprocal in interface INDArray
  - abs
```
public void abs()
```
    Description copied from interface: INDArray
    
    Replaces all elements of this array with their absolute values, according to Math.abs(double)
    
    Specified by:
    
    abs in interface INDArray
  - sqrt
```
public void sqrt()
```
    Description copied from interface: INDArray
    
    Computes the square root of all elements in the array
    
    Specified by:
    
    sqrt in interface INDArray
  - log
```
public void log()
```
    Description copied from interface: INDArray
    
    Computes the natural logarithm (in-place) for all array elements
    
    Specified by:
    
    log in interface INDArray
  - exp
```
public void exp()
```
    Specified by:
    
    exp in interface INDArray
  - signum
```
public void signum()
```
    Description copied from interface: INDArray
    
    Calculates the signum of all elements of the array
    
    Specified by:
    
    signum in interface INDArray
  - elementMul
```
public void elementMul(AMatrix m)
```
    Multiplies this matrix in-place by another in an entrywise manner (Hadamard product).
    
    Parameters:
    m -
  - mul
```
public void mul(AMatrix a)
```
    "Multiplies" this matrix by another, composing the transformation
    
    Parameters:
    a -
  - multiplyRow
```
public void multiplyRow(int i,
               double factor)
```
    Multiplies a row by a constant factor This is an elementary row operation
  - addRowMultiple
```
public void addRowMultiple(int src,
                  int dst,
                  double factor)
```
    Adds a multiple of a source row to a destination row This is an elementary row operation
  - swapRows
```
public void swapRows(int i,
            int j)
```
    Swaps two rows of the matrix in place This is an elementary row operation
  - swapColumns
```
public void swapColumns(int i,
               int j)
```
    Swaps two columns of the matrix in place
  - composeWith
```
public void composeWith(ATransform a)
```
    Description copied from class: ATransform
    
    Composes this transformation with a given transformation, mutating the transformation to represent the combined transform
    
    Overrides:
    
    composeWith in class ATransform
  - composeWith
```
public void composeWith(AMatrix a)
```
  - isView
```
public boolean isView()
```
    Description copied from interface: INDArray
    
    Return true if this is a view
    
    Specified by:
    
    isView in interface INDArray
    
    Returns:
  - copyOfMatrix
```
public AMatrix copyOfMatrix()
```
    Description copied from class: AAffineTransform
    
    Returns a deep copy of the transformation matrix for this affine transform
    
    Overrides:
    
    copyOfMatrix in class AAffineTransform
  - copyOfTranslationVector
```
public AVector copyOfTranslationVector()
```
    Description copied from class: AAffineTransform
    
    Returns a deep copy of the translation vector for this affine transform
    
    Overrides:
    
    copyOfTranslationVector in class AAffineTransform
  - addMultiple
```
public void addMultiple(AMatrix m,
               double factor)
```
  - iterator
```
public Iterator<AVector> iterator()
```
    Returns an iterator over rows in this Matrix
    
    Specified by:
    
    iterator in interface Iterable<AVector>
  - epsilonEquals
```
public boolean epsilonEquals(INDArray a)
```
    Specified by:
    
    epsilonEquals in interface INDArray
  - epsilonEquals
```
public boolean epsilonEquals(INDArray a,
                    double epsilon)
```
    Specified by:
    
    epsilonEquals in interface INDArray
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class AAffineTransform
  - equals
```
public boolean equals(AMatrix a)
```
  - equals
```
public boolean equals(INDArray v)
```
    Description copied from interface: INDArray
    
    Returns true if the two arrays are exactly equal in value and shape
    
    Specified by:
    
    equals in interface INDArray
    
    Returns:
  - epsilonEquals
```
public boolean epsilonEquals(AMatrix a)
```
    Returns true if this matrix is approximately equal to a second matrix, up to a default tolerance level
  - equals
```
public boolean equals(AAffineTransform a)
```
    Overrides:
    
    equals in class AAffineTransform
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class AAffineTransform
  - asVector
```
public AVector asVector()
```
    Returns the matrix values as a single reference Vector in the form [row0 row1 row2....]
    
    Specified by:
    
    asVector in interface INDArray
    
    Returns:
  - asElementList
```
public List<Double> asElementList()
```
    Specified by:
    
    asElementList in interface INDArray
  - compose
```
public ATransform compose(ATransform a)
```
    Description copied from class: ATransform
    
    Composes this transformation with another transformation, returning a new combined transformation
    
    Overrides:
    
    compose in class AAffineTransform
  - compose
```
public final AMatrix compose(AMatrix a)
```
    Composes this matrix with another matrix (matrix multiplication) Returns a new matrix that represents the compose transformation.
    
    Parameters:
    a -
    
    Returns:
  - innerProduct
```
public AMatrix innerProduct(AMatrix a)
```
  - innerProduct
```
public Matrix innerProduct(Matrix a)
```
  - innerProduct
```
public AVector innerProduct(AVector v)
```
  - innerProduct
```
public AMatrix innerProduct(AScalar s)
```
  - innerProduct
```
public INDArray innerProduct(INDArray a)
```
    Description copied from interface: INDArray
    
    Calculates the inner product of this array with another array.
    
    Specified by:
    
    innerProduct in interface INDArray
    
    Returns:
  - outerProduct
```
public INDArray outerProduct(INDArray a)
```
    Description copied from interface: INDArray
    
    Calculates the outer product of this array with another array.
    
    Specified by:
    
    outerProduct in interface INDArray
    
    Returns:
  - inverse
```
public AMatrix inverse()
```
    Description copied from class: ATransform
    
    Return the inverse of this transformation if possible
    
    Overrides:
    
    inverse in class AAffineTransform
    
    Returns:
  - trace
```
public double trace()
```
  - isInvertible
```
public boolean isInvertible()
```
    Description copied from class: ATransform
    
    Returns true if this transform is invertible
    
    Overrides:
    
    isInvertible in class AAffineTransform
  - toVector
```
public Vector toVector()
```
    Converts the matrix to a single flattened vector in row major order.
    
    Specified by:
    
    toVector in interface INDArray
    
    Returns:
  - toMatrix
```
public Matrix toMatrix()
```
    Converts the matrix to a the standard mutable Matrix type in row major order.
  - toDoubleBuffer
```
public void toDoubleBuffer(DoubleBuffer dest)
```
    Description copied from interface: INDArray
    
    Copies the elements of this INDArray to the specified double buffer
    
    Specified by:
    
    toDoubleBuffer in interface INDArray
  - applyOp
```
public void applyOp(Op op)
```
    Description copied from interface: INDArray
    
    Applies a unary operator to all elements of the array (in-place)
    
    Specified by:
    
    applyOp in interface INDArray
  - applyOp
```
public void applyOp(IOp op)
```
    Description copied from interface: INDArray
    
    Applies a unary operator to all elements of the array (in-place)
    
    Specified by:
    
    applyOp in interface INDArray
  - add
```
public void add(INDArray a)
```
    Specified by:
    
    add in interface INDArray
  - multiply
```
public void multiply(INDArray a)
```
    Description copied from interface: INDArray
    
    Multiplies all elements by the equivalent elements in a second array
    
    Specified by:
    
    multiply in interface INDArray
  - sub
```
public void sub(INDArray a)
```
    Specified by:
    
    sub in interface INDArray
  - add
```
public void add(double d)
```
    Specified by:
    
    add in interface INDArray
  - addAt
```
public void addAt(int i,
         int j,
         double d)
```
  - broadcast
```
public INDArray broadcast(int... targetShape)
```
    Specified by:
    
    broadcast in interface INDArray
  - isZeroMatrix
```
public boolean isZeroMatrix()
```
    Returns true if the matrix is the zero matrix (all components zero)
  - isPositiveDefinite
```
public void isPositiveDefinite()
```
    Returns true if a matrix is positive definite
  - isDiagonal
```
public boolean isDiagonal()
```
    Returns true iff a matrix is a square diagonal matrix
  - isRectangularDiagonal
```
public boolean isRectangularDiagonal()
```
  - isSymmetric
```
public boolean isSymmetric()
```
    Returns true if a matrix is symmetric
  - isHermitian
```
public final boolean isHermitian()
```
    Returns true if a matrix is Hermitian This is equivalent to isSymmetric(), since all Vectorz matrices have real values.
  - isUpperTriangular
```
public boolean isUpperTriangular()
```
    Returns true if a matrix is upper triangular
  - isLowerTriangular
```
public boolean isLowerTriangular()
```
    Returns true if a matrix is lower triangular
  - setRow
```
public void setRow(int i,
          AVector row)
```
  - setColumn
```
public void setColumn(int i,
             AVector col)
```
  - exactClone
```
public abstract AMatrix exactClone()
```
    Description copied from interface: INDArray
    
    Returns an exact deep clone of an array (i.e. of the same class as the original).
    
    Specified by:
    
    exactClone in interface INDArray
    
    Returns:
  - validate
```
public void validate()
```
    Description copied from interface: INDArray
    
    Validates the internal data structure of the INDArray. Throws an exception on failure. Failure indicates a serious bug and/or data corruption.
    
    Specified by:
    
    validate in interface INDArray

Class AMatrix

Constructor Summary

Method Summary

Methods inherited from class mikera.transformz.ALinearTransform

Methods inherited from class mikera.transformz.AAffineTransform

Methods inherited from class mikera.transformz.ATransform

Methods inherited from class java.lang.Object

Constructor Detail

AMatrix

Method Detail

rowCount

columnCount

get

set

get

get

set

set

fill

clamp

pow

square

set

dimensionality

elementCount

slice

slice

sliceCount

getSlices

getSliceViews

getShape

getShape

getLongShape

get

getLeadingDiagonal

calculateElement

toAffineTransform

getMatrixComponent

isIdentity

isSquare

isOrthogonal

hasOrthonormalColumns

hassOrthonormalRows

inputDimensions

outputDimensions

reshape

transform

transformInPlace

transformInPlace

getRow

getColumn

cloneRow

set

set

set

setElements

getElements

copyTo

setElements

isFullyMutable

isMutable

isElementConstrained

clone

determinant

toMutableMatrix

transposeInPlace

getTranspose

getTransposeView

add

add

sub

sub

scale

scaleAdd

multiply

elementSum

elementSquaredSum

elementIterator

nonZeroCount

sub