MatrixStore (ojAlgo 47.2.0 API)

All Superinterfaces:

Access1D<N>, Access1D.Aggregatable<N>, Access1D.Elements, Access1D.Sliceable<N>, Access1D.Visitable<N>, Access2D<N>, Access2D.Aggregatable<N>, Access2D.Collectable<N,TransformableRegion<N>>, Access2D.Elements, Access2D.Sliceable<N>, Access2D.Visitable<N>, ElementsSupplier<N>, Group, Group.Additive<MatrixStore<N>>, NormedVectorSpace<MatrixStore<N>,N>, Operation, Operation.Addition<MatrixStore<N>>, Operation.Multiplication<MatrixStore<N>>, ScalarOperation, ScalarOperation.Multiplication<MatrixStore<N>,N>, Stream2D<N,MatrixStore<N>,TransformableRegion<N>,ElementsSupplier<N>>, Structure1D, Structure2D, Structure2D.ReducibleTo1D<ElementsSupplier<N>>, Supplier<MatrixStore<N>>, VectorSpace<MatrixStore<N>,N>

All Known Subinterfaces:

DecompositionStore<N>, PhysicalStore<N>

All Known Implementing Classes:

GenericDenseStore, PrimitiveDenseStore, RawStore, SparseStore
```
public interface MatrixStore<N extends Number>
extends ElementsSupplier<N>, Access2D<N>, Access2D.Visitable<N>, Access2D.Aggregatable<N>, Access2D.Sliceable<N>, Access2D.Elements, Structure2D.ReducibleTo1D<ElementsSupplier<N>>, NormedVectorSpace<MatrixStore<N>,N>, Operation.Multiplication<MatrixStore<N>>
```
A MatrixStore is a two dimensional store of numbers/scalars.

A MatrixStore extends Access2D (as well as Access2D.Visitable and Access2D.Elements) and defines some futher funtionality - mainly matrix multiplication.

This interface does not define any methods that require implementations to alter the matrix. Either the methods return matrix elements, some meta data or produce new instances.

The methods conjugate(), copy() and transpose() return PhysicalStore instances. PhysicalStore extends MatrixStore. It defines additional methods, and is mutable.

Author:

apete

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`MatrixStore.Factory<N extends Number>`
`static class`	`MatrixStore.LogicalBuilder<N extends Number>` A builder that lets you logically construct matrices and/or encode element structure.

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D
Structure2D.IntRowColumn, Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,?>>, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.RowColumnCallback, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D
Structure1D.BasicMapper<T>, Structure1D.IndexCallback, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.LongIndex, Structure1D.LoopCallback

Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D
Access2D.Aggregatable<N extends Number>, Access2D.Collectable<N extends Number,R extends Mutate2D.Receiver<N>>, Access2D.Elements, Access2D.ElementView<N extends Number>, Access2D.IndexOf, Access2D.Sliceable<N extends Number>, Access2D.Visitable<N extends Number>

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group
Group.Additive<S>, Group.Multiplicative<S>

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation
Operation.Addition<T>, Operation.Division<T>, Operation.Multiplication<T>, Operation.Subtraction<T>

Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation
ScalarOperation.Addition<T,N extends Number>, ScalarOperation.Division<T,N extends Number>, ScalarOperation.Multiplication<T,N extends Number>, ScalarOperation.Subtraction<T,N extends Number>

Field Summary

Fields
Modifier and Type	Field and Description
`static MatrixStore.Factory<ComplexNumber>`	`COMPLEX`
`static MatrixStore.Factory<Double>`	`PRIMITIVE`
`static MatrixStore.Factory<Quaternion>`	`QUATERNION`
`static MatrixStore.Factory<RationalNumber>`	`RATIONAL`

Method Summary

All Methods Static Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default MatrixStore<N>`	`add(MatrixStore<N> addend)`
`default N`	`aggregateAll(Aggregator aggregator)`
`default N`	`aggregateColumn(long row, long col, Aggregator aggregator)`
`default N`	`aggregateDiagonal(long row, long col, Aggregator aggregator)`
`default N`	`aggregateRange(long first, long limit, Aggregator aggregator)`
`default N`	`aggregateRow(long row, long col, Aggregator aggregator)`
`default MatrixStore<N>`	`conjugate()` Returns the conjugate transpose of this matrix.
`default PhysicalStore<N>`	`copy()` Each call must produce a new instance.
`default double`	`doubleValue(long row, long col)` Extracts one element of this matrix as a double.
`default boolean`	`equals(MatrixStore<N> other, NumberContext context)`
`static int`	`firstInColumn(Access1D<?> matrix, int col, int defaultAndMinimum)`
`static long`	`firstInColumn(Access1D<?> matrix, long col, long defaultAndMinimum)`
`default int`	`firstInColumn(int col)` The default value is simply `0`, and if all elements are zeros then `this.countRows()`.
`static int`	`firstInRow(Access1D<?> matrix, int row, int defaultAndMinimum)`
`static long`	`firstInRow(Access1D<?> matrix, long row, long defaultAndMinimum)`
`default int`	`firstInRow(int row)` The default value is simply `0`, and if all elements are zeros then `this.countColumns()`.
`default MatrixStore<N>`	`get()`
`default boolean`	`isAbsolute(long row, long col)`
`default boolean`	`isHermitian()`
`default boolean`	`isNormal()`
`default boolean`	`isSmall(double comparedTo)`
`default boolean`	`isSmall(long row, long col, double comparedTo)`
`static int`	`limitOfColumn(Access1D<?> matrix, int col, int defaultAndMaximum)`
`static long`	`limitOfColumn(Access1D<?> matrix, long col, long defaultAndMaximum)`
`default int`	`limitOfColumn(int col)` The default value is simply `this.countRows()`, and if all elements are zeros then `0`.
`static int`	`limitOfRow(Access1D<?> matrix, int row, int defaultAndMaximum)`
`static long`	`limitOfRow(Access1D<?> matrix, long row, long defaultAndMaximum)`
`default int`	`limitOfRow(int row)` The default value is simply `this.countColumns()`, and if all elements are zeros then `0`.
`default MatrixStore.LogicalBuilder<N>`	`logical()`
`default void`	`multiply(Access1D<N> right, TransformableRegion<N> target)`
`default MatrixStore<N>`	`multiply(double scalar)`
`default MatrixStore<N>`	`multiply(MatrixStore<N> right)`
`default MatrixStore<N>`	`multiply(N scalar)`
`default N`	`multiplyBoth(Access1D<N> leftAndRight)` Assumes [leftAndRight] is a vector and will calulate [leftAndRight]^H[this][leftAndRight]
`default MatrixStore<N>`	`negate()` The additive inverse of this.
`default double`	`norm()` `this == this.signum().multiply(this.norm())`
`default MatrixStore<N>`	`operateOnAll(UnaryFunction<N> operator)`
`default ElementsSupplier<N>`	`premultiply(Access1D<N> left)` The `premultiply` method differs from `multiply` in 3 ways: The matrix positions are swapped - left/right. It does NOT return a MatrixStore but an ElementsSupplier instead. It accepts an Access1D as the argument left matrix.
`default ElementsSupplier<N>`	`reduceColumns(Aggregator aggregator)`
`default ElementsSupplier<N>`	`reduceRows(Aggregator aggregator)`
`default MatrixStore<N>`	`signum()` `this == this.signum().multiply(this.norm())`
`default Access1D<N>`	`sliceColumn(long row, long col)`
`default Access1D<N>`	`sliceDiagonal(long row, long col)`
`default Access1D<N>`	`sliceRange(long first, long limit)`
`default Access1D<N>`	`sliceRow(long row, long col)`
`default MatrixStore<N>`	`subtract(MatrixStore<N> subtrahend)`
`default void`	`supplyTo(TransformableRegion<N> receiver)`
`default Scalar<N>`	`toScalar(long row, long column)`
`default MatrixStore<N>`	`transpose()`
`default void`	`visitOne(long row, long col, VoidFunction<N> visitor)`

Methods inherited from interface org.ojalgo.matrix.store.ElementsSupplier
operateOnAny, operateOnColumns, operateOnMatching, operateOnMatching, operateOnRows, physical

Methods inherited from interface org.ojalgo.structure.Stream2D
operateOnAll, operateOnAll, operateOnAll, operateOnAll, operateOnAll

Methods inherited from interface org.ojalgo.structure.Access2D.Collectable
collect

Methods inherited from interface org.ojalgo.structure.Structure2D
column, column, column, column, column, count, count, countColumns, countRows, index, index, isEmpty, isFat, isScalar, isSquare, isTall, isVector, loopAll, loopColumn, loopColumn, loopDiagonal, loopMatching, loopRow, loopRow, mapperOf, row, row, row, row, row

Methods inherited from interface org.ojalgo.structure.Structure1D
index, loopAll, loopMatching, loopRange, mapper, size

Methods inherited from interface org.ojalgo.structure.Access2D
asCollectable2D, asPrimitive2D, byteValue, byteValue, columns, doubleValue, elements, equals, floatValue, floatValue, get, get, intValue, intValue, longValue, longValue, newPrimitiveColumnCollectable, newPrimitiveRowCollectable, rows, shortValue, shortValue, toRawCopy2D, toString, wrap, wrap

Methods inherited from interface org.ojalgo.structure.Access1D
asCollectable1D, asPrimitive1D, axpy, dot, equals, hashCode, nonzeros, supplyTo, toRawCopy1D, toString, wrap, wrap, wrap

Methods inherited from interface org.ojalgo.structure.Access2D.Visitable
visitColumn, visitColumn, visitDiagonal, visitDiagonal, visitOne, visitRow, visitRow

Methods inherited from interface org.ojalgo.structure.Access1D.Visitable
visitAll, visitRange

Methods inherited from interface org.ojalgo.structure.Access2D.Aggregatable
aggregateColumn, aggregateDiagonal, aggregateRow, reduceColumns, reduceRows

Methods inherited from interface org.ojalgo.structure.Access2D.Sliceable
sliceColumn, sliceDiagonal, sliceRow

Methods inherited from interface org.ojalgo.structure.Access2D.Elements
isAbsolute, isColumnSmall, isColumnSmall, isRowSmall, isRowSmall, isSmall

Methods inherited from interface org.ojalgo.structure.Access1D.Elements
isAllSmall

- Field Detail
  - COMPLEX
```
static final MatrixStore.Factory<ComplexNumber> COMPLEX
```
  - PRIMITIVE
```
static final MatrixStore.Factory<Double> PRIMITIVE
```
  - QUATERNION
```
static final MatrixStore.Factory<Quaternion> QUATERNION
```
  - RATIONAL
```
static final MatrixStore.Factory<RationalNumber> RATIONAL
```
- Method Detail
  - firstInColumn
```
static int firstInColumn(Access1D<?> matrix,
                         int col,
                         int defaultAndMinimum)
```
  - firstInColumn
```
static long firstInColumn(Access1D<?> matrix,
                          long col,
                          long defaultAndMinimum)
```
  - firstInRow
```
static int firstInRow(Access1D<?> matrix,
                      int row,
                      int defaultAndMinimum)
```
  - firstInRow
```
static long firstInRow(Access1D<?> matrix,
                       long row,
                       long defaultAndMinimum)
```
  - limitOfColumn
```
static int limitOfColumn(Access1D<?> matrix,
                         int col,
                         int defaultAndMaximum)
```
  - limitOfColumn
```
static long limitOfColumn(Access1D<?> matrix,
                          long col,
                          long defaultAndMaximum)
```
  - limitOfRow
```
static int limitOfRow(Access1D<?> matrix,
                      int row,
                      int defaultAndMaximum)
```
  - limitOfRow
```
static long limitOfRow(Access1D<?> matrix,
                       long row,
                       long defaultAndMaximum)
```
  - add
```
default MatrixStore<N> add(MatrixStore<N> addend)
```
    Specified by:
    
    add in interface Operation.Addition<MatrixStore<N extends Number>>
    
    Parameters:
    
    addend - What to add
    
    Returns:
    
    this + addend
  - aggregateAll
```
default N aggregateAll(Aggregator aggregator)
```
    Specified by:
    
    aggregateAll in interface Access1D.Aggregatable<N extends Number>
  - aggregateColumn
```
default N aggregateColumn(long row,
                          long col,
                          Aggregator aggregator)
```
    Specified by:
    
    aggregateColumn in interface Access2D.Aggregatable<N extends Number>
  - aggregateDiagonal
```
default N aggregateDiagonal(long row,
                            long col,
                            Aggregator aggregator)
```
    Specified by:
    
    aggregateDiagonal in interface Access2D.Aggregatable<N extends Number>
  - aggregateRange
```
default N aggregateRange(long first,
                         long limit,
                         Aggregator aggregator)
```
    Specified by:
    
    aggregateRange in interface Access1D.Aggregatable<N extends Number>
  - aggregateRow
```
default N aggregateRow(long row,
                       long col,
                       Aggregator aggregator)
```
    Specified by:
    
    aggregateRow in interface Access2D.Aggregatable<N extends Number>
  - conjugate
```
default MatrixStore<N> conjugate()
```
    Returns the conjugate transpose of this matrix. The conjugate transpose is also known as adjoint matrix, adjugate matrix, hermitian adjoint or hermitian transpose. (The conjugate matrix is the complex conjugate of each element. This NOT what is returned here!)
    
    Specified by:
    
    conjugate in interface VectorSpace<MatrixStore<N extends Number>,N extends Number>
    
    See Also:
    
    VectorSpace.conjugate()
  - copy
```
default PhysicalStore<N> copy()
```
    Each call must produce a new instance.
    
    Returns:
    
    A new PhysicalStore copy.
  - doubleValue
```
default double doubleValue(long row,
                           long col)
```
    Description copied from interface: Access2D
    
    Extracts one element of this matrix as a double.
    
    Specified by:
    
    doubleValue in interface Access2D<N extends Number>
    
    Parameters:
    
    row - A row index.
    
    col - A column index.
    
    Returns:
    
    One matrix element
  - equals
```
default boolean equals(MatrixStore<N> other,
                       NumberContext context)
```
  - firstInColumn
```
default int firstInColumn(int col)
```
    The default value is simply 0, and if all elements are zeros then this.countRows().
    
    Parameters:
    
    col - The column index
    
    Returns:
    
    The row index of the first non-zero element in the specified column
  - firstInRow
```
default int firstInRow(int row)
```
    The default value is simply 0, and if all elements are zeros then this.countColumns().
    
    Returns:
    
    The column index of the first non-zero element in the specified row
  - get
```
default MatrixStore<N> get()
```
    Specified by:
    
    get in interface ElementsSupplier<N extends Number>
    
    Specified by:
    
    get in interface Supplier<MatrixStore<N extends Number>>
  - isAbsolute
```
default boolean isAbsolute(long row,
                           long col)
```
    Specified by:
    
    isAbsolute in interface Access2D.Elements
    
    See Also:
    
    Scalar.isAbsolute()
  - isHermitian
```
default boolean isHermitian()
```
  - isNormal
```
default boolean isNormal()
```
  - isSmall
```
default boolean isSmall(double comparedTo)
```
    Specified by:
    
    isSmall in interface NormedVectorSpace<MatrixStore<N extends Number>,N extends Number>
    
    Parameters:
    
    comparedTo - What to compare with
    
    Returns:
    
    true if this is small compared to the magnitude of the input reference value.
  - isSmall
```
default boolean isSmall(long row,
                        long col,
                        double comparedTo)
```
    Specified by:
    
    isSmall in interface Access2D.Elements
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - limitOfColumn
```
default int limitOfColumn(int col)
```
    The default value is simply this.countRows(), and if all elements are zeros then 0.
    
    Returns:
    
    The row index of the first zero element, after all non-zeros, in the specified column (index of the last non-zero + 1)
  - limitOfRow
```
default int limitOfRow(int row)
```
    The default value is simply this.countColumns(), and if all elements are zeros then 0.
    
    Returns:
    
    The column index of the first zero element, after all non-zeros, in the specified row (index of the last non-zero + 1)
  - logical
```
default MatrixStore.LogicalBuilder<N> logical()
```
  - multiply
```
default void multiply(Access1D<N> right,
                      TransformableRegion<N> target)
```
  - multiply
```
default MatrixStore<N> multiply(double scalar)
```
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<MatrixStore<N extends Number>,N extends Number>
    
    Returns:
    
    this * scalarMultiplicand.
  - multiply
```
default MatrixStore<N> multiply(MatrixStore<N> right)
```
    Specified by:
    
    multiply in interface Operation.Multiplication<MatrixStore<N extends Number>>
    
    Parameters:
    
    right - The multiplicand
    
    Returns:
    
    this * multiplicand.
  - multiply
```
default MatrixStore<N> multiply(N scalar)
```
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<MatrixStore<N extends Number>,N extends Number>
    
    Returns:
    
    this * multiplicand.
  - multiplyBoth
```
default N multiplyBoth(Access1D<N> leftAndRight)
```
    Assumes [leftAndRight] is a vector and will calulate [leftAndRight]^H[this][leftAndRight]
    
    Parameters:
    
    leftAndRight - The argument vector
    
    Returns:
    
    A scalar (extracted from the resulting 1 x 1 matrix)
  - negate
```
default MatrixStore<N> negate()
```
    Description copied from interface: Group.Additive
    
    The additive inverse of this.
    
    Specified by:
    
    negate in interface Group.Additive<MatrixStore<N extends Number>>
    
    Returns:
    
    -this.
  - norm
```
default double norm()
```
    Description copied from interface: NormedVectorSpace
    
    this == this.signum().multiply(this.norm())
    
    Specified by:
    
    norm in interface NormedVectorSpace<MatrixStore<N extends Number>,N extends Number>
    
    Returns:
    
    The norm
  - operateOnAll
```
default MatrixStore<N> operateOnAll(UnaryFunction<N> operator)
```
    Specified by:
    
    operateOnAll in interface ElementsSupplier<N extends Number>
    
    Specified by:
    
    operateOnAll in interface Stream2D<N extends Number,MatrixStore<N extends Number>,TransformableRegion<N extends Number>,ElementsSupplier<N extends Number>>
  - premultiply
```
default ElementsSupplier<N> premultiply(Access1D<N> left)
```
    The premultiply method differs from multiply in 3 ways:
    1. The matrix positions are swapped - left/right.
    2. It does NOT return a MatrixStore but an ElementsSupplier instead.
    3. It accepts an Access1D as the argument left matrix.
    Parameters:
    
    left - The left matrix
    
    Returns:
    
    The matrix product
  - reduceColumns
```
default ElementsSupplier<N> reduceColumns(Aggregator aggregator)
```
    Specified by:
    
    reduceColumns in interface Structure2D.ReducibleTo1D<ElementsSupplier<N extends Number>>
  - reduceRows
```
default ElementsSupplier<N> reduceRows(Aggregator aggregator)
```
    Specified by:
    
    reduceRows in interface Structure2D.ReducibleTo1D<ElementsSupplier<N extends Number>>
  - signum
```
default MatrixStore<N> signum()
```
    Description copied from interface: NormedVectorSpace
    
    this == this.signum().multiply(this.norm())
    
    Specified by:
    
    signum in interface NormedVectorSpace<MatrixStore<N extends Number>,N extends Number>
    
    Returns:
    
    A unit "vector"
  - sliceColumn
```
default Access1D<N> sliceColumn(long row,
                                long col)
```
    Specified by:
    
    sliceColumn in interface Access2D.Sliceable<N extends Number>
  - sliceDiagonal
```
default Access1D<N> sliceDiagonal(long row,
                                  long col)
```
    Specified by:
    
    sliceDiagonal in interface Access2D.Sliceable<N extends Number>
  - sliceRange
```
default Access1D<N> sliceRange(long first,
                               long limit)
```
    Specified by:
    
    sliceRange in interface Access1D.Sliceable<N extends Number>
  - sliceRow
```
default Access1D<N> sliceRow(long row,
                             long col)
```
    Specified by:
    
    sliceRow in interface Access2D.Sliceable<N extends Number>
  - subtract
```
default MatrixStore<N> subtract(MatrixStore<N> subtrahend)
```
  - supplyTo
```
default void supplyTo(TransformableRegion<N> receiver)
```
    Specified by:
    
    supplyTo in interface Access2D.Collectable<N extends Number,TransformableRegion<N extends Number>>
  - toScalar
```
default Scalar<N> toScalar(long row,
                           long column)
```
  - transpose
```
default MatrixStore<N> transpose()
```
    Specified by:
    
    transpose in interface ElementsSupplier<N extends Number>
    
    Specified by:
    
    transpose in interface Stream2D<N extends Number,MatrixStore<N extends Number>,TransformableRegion<N extends Number>,ElementsSupplier<N extends Number>>
    
    Returns:
    
    A transposed matrix instance.
  - visitOne
```
default void visitOne(long row,
                      long col,
                      VoidFunction<N> visitor)
```
    Specified by:
    
    visitOne in interface Access2D.Visitable<N extends Number>

Interface MatrixStore<N extends Number>

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D

Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation

Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation

Field Summary

Method Summary

Methods inherited from interface org.ojalgo.matrix.store.ElementsSupplier

Methods inherited from interface org.ojalgo.structure.Stream2D

Methods inherited from interface org.ojalgo.structure.Access2D.Collectable

Methods inherited from interface org.ojalgo.structure.Structure2D

Methods inherited from interface org.ojalgo.structure.Structure1D

Methods inherited from interface org.ojalgo.structure.Access2D

Methods inherited from interface org.ojalgo.structure.Access1D

Methods inherited from interface org.ojalgo.structure.Access2D.Visitable

Methods inherited from interface org.ojalgo.structure.Access1D.Visitable

Methods inherited from interface org.ojalgo.structure.Access2D.Aggregatable

Methods inherited from interface org.ojalgo.structure.Access2D.Sliceable

Methods inherited from interface org.ojalgo.structure.Access2D.Elements

Methods inherited from interface org.ojalgo.structure.Access1D.Elements

Field Detail

COMPLEX

PRIMITIVE

QUATERNION

RATIONAL

Method Detail

firstInColumn

firstInColumn

firstInRow

firstInRow

limitOfColumn

limitOfColumn

limitOfRow

limitOfRow

add

aggregateAll

aggregateColumn

aggregateDiagonal

aggregateRange

aggregateRow

conjugate

copy

doubleValue

equals

firstInColumn

firstInRow

get

isAbsolute

isHermitian

isNormal

isSmall

isSmall

limitOfColumn

limitOfRow

logical

multiply

multiply

multiply

multiply

multiplyBoth

negate

norm

operateOnAll

premultiply

reduceColumns

reduceRows

signum

sliceColumn

sliceDiagonal

sliceRange

sliceRow

subtract

supplyTo

toScalar

transpose

visitOne