AMatrix (vectorz 0.13.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, AVectorMatrix, ColumnMatrix, Matrix, Matrix22, Matrix33, PermutedMatrix, RowMatrix, SubsetMatrix, TransposedMatrix, ZeroMatrix
```
public abstract class AMatrix
extends ALinearTransform
implements IMatrix, Iterable<AVector>, INDArray
```
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`	`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)`
`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)
`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.
`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
`double`	`determinant()` Calculates the determinant of the matrix.
`int`	`dimensionality()`
`long`	`elementCount()`
`void`	`elementMul(AMatrix m)` Multiplies this matrix in-place by another in an entrywise manner (Hadamard product).
`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`	`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.
`double`	`get()`
`double`	`get(int... indexes)`
`double`	`get(int row)`
`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
`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.
`List<AVector>`	`getSlices()`
`AMatrix`	`getTranspose()` Returns a transposed version of this matrix.
`int`	`hashCode()`
`AMatrix`	`innerProduct(AMatrix a)`
`AMatrix`	`innerProduct(AScalar s)`
`AVector`	`innerProduct(AVector v)`
`INDArray`	`innerProduct(INDArray a)`
`int`	`inputDimensions()` Returns the number of dimensions required for input vectors
`AMatrix`	`inverse()` Return the inverse of this transformation if possible
`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`	`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`	`isMutable()` Returns true if the INDArray is mutable (at least partially)
`boolean`	`isSquare()` Returns true if the transform is square (same number of input and output dimensions)
`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`	`mul(AMatrix a)` "Multiplies" this matrix by another, composing the transformation
`void`	`multiply(double factor)`
`void`	`multiplyRow(int i, double factor)`
`INDArray`	`outerProduct(INDArray a)`
`int`	`outputDimensions()` Returns the number of dimensions required for output vectors
`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`	`set(AMatrix a)`
`void`	`set(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`	`setElements(double[] values)` Sets all elements in an array using the given double values
`void`	`setElements(double[] values, int offset, int length)`
`AVector`	`slice(int rowNumber)`
`int`	`sliceCount()`
`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
`AAffineTransform`	`toAffineTransform()`
`AMatrix`	`toMutableMatrix()` Creates a fully mutable deep copy of this matrix
`String`	`toString()`
`AVector`	`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(AVector v)` Transforms a vector destructively.
`void`	`transposeInPlace()`

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
  - 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 double get(int row)
```
    Specified by:
    
    get in interface INDArray
  - get
```
public double get()
```
    Specified by:
    
    get in interface INDArray
  - set
```
public void set(int row,
       double value)
```
    Specified by:
    
    set in interface INDArray
  - set
```
public void set(double value)
```
    Specified by:
    
    set in interface INDArray
  - set
```
public void set(int[] indexes,
       double value)
```
    Specified by:
    
    set in interface INDArray
  - dimensionality
```
public int dimensionality()
```
    Specified by:
    
    dimensionality in interface INDArray
  - elementCount
```
public long elementCount()
```
    Specified by:
    
    elementCount in interface INDArray
  - slice
```
public AVector slice(int rowNumber)
```
    Specified by:
    
    slice in interface INDArray
  - sliceCount
```
public int sliceCount()
```
    Specified by:
    
    sliceCount in interface INDArray
  - getSlices
```
public List<AVector> getSlices()
```
    Specified by:
    
    getSlices in interface INDArray
  - 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:
  - 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)
```
    Specified by:
    
    get in interface INDArray
  - 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:
  - 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
  - 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)
```
    Specified by:
    
    setElements 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.
    
    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)
```
  - scale
```
public final void scale(double factor)
```
    Scales a matrix by a constant scalar factor.
    
    Specified by:
    
    scale in interface INDArray
    
    Parameters:
    m -
  - multiply
```
public void multiply(double factor)
```
    Specified by:
    
    multiply in interface INDArray
  - elementSum
```
public double elementSum()
```
    Returns the sum of all elements in the matrix
    
    Parameters:
    m -
    
    Returns:
  - sub
```
public void sub(AMatrix m)
```
    Subtracts another matrix from this one
    
    Parameters:
    m -
  - 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)
```
  - addRowMultiple
```
public void addRowMultiple(int src,
                  int dst,
                  double factor)
```
  - 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>
  - 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:
  - 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 AVector innerProduct(AVector v)
```
  - innerProduct
```
public AMatrix innerProduct(AScalar s)
```
  - innerProduct
```
public INDArray innerProduct(INDArray a)
```
    Specified by:
    
    innerProduct in interface INDArray
  - outerProduct
```
public INDArray outerProduct(INDArray a)
```
    Specified by:
    
    outerProduct in interface INDArray
  - 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
  - swapRows
```
public void swapRows(int i,
            int j)
```
    Swaps two rows of the matrix in place
  - swapColumns
```
public void swapColumns(int i,
               int j)
```
    Swaps two columns of the matrix in place
  - toVector
```
public AVector toVector()
```
    Converts the matrix to a single flattened vector in row major order.
  - 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
  - sub
```
public void sub(INDArray a)
```
    Specified by:
    
    sub in interface INDArray
  - add
```
public void add(double d)
```
  - 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)
  - 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:

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

set

dimensionality

elementCount

slice

sliceCount

getSlices

getShape

getLongShape

get

getLeadingDiagonal

calculateElement

toAffineTransform

getMatrixComponent

isIdentity

isSquare

inputDimensions

outputDimensions

reshape

transform

transformInPlace

getRow

getColumn

cloneRow

set

set

set

setElements

setElements

isFullyMutable

isMutable

isElementConstrained

clone

determinant

toMutableMatrix

transposeInPlace

getTranspose

add

add

sub

sub

scale

multiply

elementSum

sub

elementMul

mul

multiplyRow

addRowMultiple

composeWith

composeWith

isView

copyOfMatrix

copyOfTranslationVector

addMultiple

iterator

equals

equals

equals

epsilonEquals

equals

toString

hashCode