GenericDenseStore (ojAlgo 45.1.1 API)

java.lang.Object
- org.ojalgo.array.BasicArray<N>
- - org.ojalgo.array.DenseArray<N>
  - - org.ojalgo.array.ReferenceTypeArray<N>
    - - org.ojalgo.array.ScalarArray<N>
      - org.ojalgo.matrix.store.GenericDenseStore<N>

All Implemented Interfaces:

Serializable, Iterable<N>, Consumer<Access2D<?>>, Supplier<MatrixStore<N>>, RandomAccess, Access1D<N>, Access1D.Aggregatable<N>, Access1D.Elements, Access1D.IndexOf, Access1D.Sliceable<N>, Access1D.Visitable<N>, Access2D<N>, Access2D.Aggregatable<N>, Access2D.Collectable<N,ElementsConsumer<N>>, Access2D.Elements, Access2D.IndexOf, Access2D.Sliceable<N>, Access2D.Visitable<N>, Mutate1D, Mutate1D.BiModifiable<N>, Mutate1D.Fillable<N>, Mutate1D.Modifiable<N>, Mutate1D.Sortable, Mutate2D, Mutate2D.BiModifiable<N>, Mutate2D.Exchangeable, Mutate2D.Fillable<N>, Mutate2D.Modifiable<N>, Mutate2D.Receiver<N>, Stream2D<N,MatrixStore<N>,ElementsConsumer<N>,ElementsSupplier<N>>, Structure1D, Structure2D, Structure2D.ReducibleTo1D<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>, VectorSpace<MatrixStore<N>,N>, DecompositionStore<N>, ExchangeColumns, NegateColumn, RotateRight, ElementsConsumer<N>, ElementsSupplier<N>, MatrixStore<N>, PhysicalStore<N>, TransformationMatrix.Transformable<N>
```
public final class GenericDenseStore<N extends Number & Scalar<N>>
extends ScalarArray<N>
implements PhysicalStore<N>, DecompositionStore<N>
```
A N implementation of PhysicalStore.

Author:

apete

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`GenericDenseStore.GenericMultiplyBoth<N extends Number & Scalar<N>>`
`static interface`	`GenericDenseStore.GenericMultiplyLeft<N extends Number & Scalar<N>>`
`static interface`	`GenericDenseStore.GenericMultiplyNeither<N extends Number & Scalar<N>>`
`static interface`	`GenericDenseStore.GenericMultiplyRight<N extends Number & Scalar<N>>`

Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.MatrixStore
MatrixStore.LogicalBuilder<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.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>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.ElementsConsumer
ElementsConsumer.ColumnsRegion<N extends Number>, ElementsConsumer.ConsumerRegion<N extends Number>, ElementsConsumer.FillByMultiplying<N extends Number>, ElementsConsumer.LimitRegion<N extends Number>, ElementsConsumer.OffsetRegion<N extends Number>, ElementsConsumer.RowsRegion<N extends Number>, ElementsConsumer.TransposedRegion<N extends Number>

Nested classes/interfaces inherited from interface org.ojalgo.access.Mutate2D
Mutate2D.BiModifiable<N extends Number>, Mutate2D.Exchangeable, Mutate2D.Fillable<N extends Number>, Mutate2D.Mixable<N extends Number>, Mutate2D.Modifiable<N extends Number>, Mutate2D.Receiver<N extends Number>

Nested classes/interfaces inherited from interface org.ojalgo.access.Mutate1D
Mutate1D.Sortable

Nested classes/interfaces inherited from interface org.ojalgo.access.Structure2D
Structure2D.IntRowColumn, 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.access.Structure1D
Structure1D.BasicMapper<T>, Structure1D.IndexCallback, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.LongIndex, Structure1D.LoopCallback

Field Summary

Fields
Modifier and Type	Field and Description
`static PhysicalStore.Factory<ComplexNumber,GenericDenseStore<ComplexNumber>>`	`COMPLEX`
`static PhysicalStore.Factory<Quaternion,GenericDenseStore<Quaternion>>`	`QUATERNION`
`static PhysicalStore.Factory<RationalNumber,GenericDenseStore<RationalNumber>>`	`RATIONAL`

Fields inherited from class org.ojalgo.array.ReferenceTypeArray
data

Fields inherited from class org.ojalgo.array.DenseArray
MAX_ARRAY_SIZE

Fields inherited from interface org.ojalgo.matrix.store.MatrixStore
BIG, PRIMITIVE

Fields inherited from interface org.ojalgo.matrix.decomposition.function.RotateRight
NULL

Fields inherited from interface org.ojalgo.matrix.decomposition.function.ExchangeColumns
NULL

Fields inherited from interface org.ojalgo.matrix.decomposition.function.NegateColumn
NULL

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`accept(Access2D<?> supplied)`
`void`	`add(long index, double addend)`
`void`	`add(long row, long col, double addend)`
`void`	`add(long row, long col, Number addend)`
`void`	`add(long index, Number addend)`
`N`	`aggregateAll(Aggregator aggregator)`
`void`	`applyCholesky(int iterationPoint, BasicArray<N> multipliers)` Cholesky transformations
`void`	`applyLDL(int iterationPoint, BasicArray<N> multipliers)` LDL transformations
`void`	`applyLU(int iterationPoint, BasicArray<N> multipliers)` LU transformations
`Array1D<N>`	`asList()`
`Array1D<ComplexNumber>`	`computeInPlaceSchur(PhysicalStore<N> transformationCollector, boolean eigenvalue)`
`MatrixStore<N>`	`conjugate()` Returns the conjugate transpose of this matrix.
`GenericDenseStore<N>`	`copy()` Each call must produce a new instance.
`long`	`count()`
`long`	`countColumns()`
`long`	`countRows()`
`void`	`divideAndCopyColumn(int row, int column, BasicArray<N> destination)`
`double`	`doubleValue(long index)`
`double`	`doubleValue(long row, long col)` Extracts one element of this matrix as a double.
`boolean`	`equals(Object anObj)`
`protected void`	`exchange(long firstA, long firstB, long step, long count)`
`void`	`exchangeColumns(long colA, long colB)`
`void`	`exchangeHermitian(int indexA, int indexB)`
`void`	`exchangeRows(long rowA, long rowB)`
`protected void`	`fill(long first, long limit, long step, N value)`
`protected void`	`fill(long first, long limit, long step, NullaryFunction<N> supplier)`
`void`	`fillAll(N number)`
`void`	`fillAll(NullaryFunction<N> supplier)`
`void`	`fillByMultiplying(Access1D<N> left, Access1D<N> right)`
`void`	`fillColumn(long row, long col, Access1D<N> values)`
`void`	`fillColumn(long row, long col, N value)`
`void`	`fillColumn(long row, long col, NullaryFunction<N> supplier)`
`void`	`fillDiagonal(long row, long col, N value)`
`void`	`fillDiagonal(long row, long col, NullaryFunction<N> supplier)`
`void`	`fillMatching(Access1D<?> values)` Will fill the elements of [this] with the corresponding input values, and in the process (if necessary) convert the elements to the correct type:
`void`	`fillMatching(Access1D<N> left, BinaryFunction<N> function, Access1D<N> right)`
`void`	`fillMatching(UnaryFunction<N> function, Access1D<N> arguments)`
`void`	`fillOne(long index, Access1D<?> values, long valueIndex)`
`void`	`fillOne(long row, long col, Access1D<?> values, long valueIndex)`
`void`	`fillOne(long row, long col, N value)`
`void`	`fillOne(long row, long col, NullaryFunction<N> supplier)`
`void`	`fillOne(long index, N value)`
`void`	`fillOne(long index, NullaryFunction<N> supplier)`
`void`	`fillRange(long first, long limit, N number)`
`void`	`fillRange(long first, long limit, NullaryFunction<N> supplier)`
`void`	`fillRow(long row, long col, Access1D<N> values)`
`void`	`fillRow(long row, long col, N value)`
`void`	`fillRow(long row, long col, NullaryFunction<N> supplier)`
`boolean`	`generateApplyAndCopyHouseholderColumn(int row, int column, Householder<N> destination)`
`boolean`	`generateApplyAndCopyHouseholderRow(int row, int column, Householder<N> destination)`
`MatrixStore<N>`	`get()`
`N`	`get(long index)`
`N`	`get(long row, long col)`
`int`	`hashCode()`
`protected long`	`indexOfLargest(long first, long limit, long step)`
`long`	`indexOfLargestInColumn(long row, long col)`
`long`	`indexOfLargestInRow(long row, long col)`
`long`	`indexOfLargestOnDiagonal(long first)`
`boolean`	`isAbsolute(long index)`
`boolean`	`isAbsolute(long row, long col)`
`boolean`	`isColumnSmall(long row, long col, double comparedTo)`
`boolean`	`isRowSmall(long row, long col, double comparedTo)`
`boolean`	`isSmall(long index, double comparedTo)`
`boolean`	`isSmall(long row, long col, double comparedTo)`
`protected boolean`	`isSmall(long first, long limit, long step, double comparedTo)`
`protected void`	`modify(long first, long limit, long step, Access1D<N> left, BinaryFunction<N> function)`
`protected void`	`modify(long first, long limit, long step, BinaryFunction<N> function, Access1D<N> right)`
`protected void`	`modify(long first, long limit, long step, UnaryFunction<N> function)`
`void`	`modifyAll(UnaryFunction<N> aFunc)`
`void`	`modifyColumn(long row, long col, UnaryFunction<N> modifier)`
`void`	`modifyDiagonal(long row, long col, UnaryFunction<N> modifier)`
`void`	`modifyMatching(Access1D<N> left, BinaryFunction<N> function)`
`void`	`modifyMatching(BinaryFunction<N> function, Access1D<N> right)`
`void`	`modifyOne(long row, long col, UnaryFunction<N> modifier)`
`void`	`modifyOne(long index, UnaryFunction<N> modifier)`
`void`	`modifyRow(long row, long col, UnaryFunction<N> modifier)`
`MatrixStore<N>`	`multiply(MatrixStore<N> right)`
`N`	`multiplyBoth(Access1D<N> leftAndRight)` Assumes [leftAndRight] is a vector and will calulate [leftAndRight]^H[this][leftAndRight]
`void`	`negateColumn(int column)`
`PhysicalStore.Factory<N,GenericDenseStore<N>>`	`physical()`
`ElementsConsumer<N>`	`regionByColumns(int... columns)`
`ElementsConsumer<N>`	`regionByLimits(int rowLimit, int columnLimit)`
`ElementsConsumer<N>`	`regionByOffsets(int rowOffset, int columnOffset)`
`ElementsConsumer<N>`	`regionByRows(int... rows)`
`ElementsConsumer<N>`	`regionByTransposing()`
`void`	`rotateRight(int low, int high, double cos, double sin)`
`void`	`set(long index, double value)`
`void`	`set(long row, long col, double value)`
`void`	`set(long row, long col, Number value)`
`void`	`set(long index, Number number)`
`void`	`setToIdentity(int col)`
`Array1D<N>`	`sliceColumn(long row, long col)`
`Array1D<N>`	`sliceDiagonal(long row, long col)`
`Array1D<N>`	`sliceRange(long first, long limit)`
`Array1D<N>`	`sliceRow(long row, long col)`
`void`	`substituteBackwards(Access2D<N> body, boolean unitDiagonal, boolean conjugated, boolean hermitian)` Will solve the equation system [A][X]=[B] where: [body][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution). [A] is upper/right triangular
`void`	`substituteForwards(Access2D<N> body, boolean unitDiagonal, boolean conjugated, boolean identity)` Will solve the equation system [A][X]=[B] where: [body][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution). [A] is lower/left triangular
`void`	`supplyTo(ElementsConsumer<N> receiver)`
`Scalar<N>`	`toScalar(long row, long column)`
`String`	`toString()`
`void`	`transformLeft(Householder<N> transformation, int firstColumn)`
`void`	`transformLeft(Rotation<N> transformation)` As in `MatrixStore.premultiply(Access1D)` where the left/parameter matrix is a plane rotation.
`void`	`transformRight(Householder<N> transformation, int firstRow)`
`void`	`transformRight(Rotation<N> transformation)` As in `MatrixStore.multiply(MatrixStore)` where the right/parameter matrix is a plane rotation.
`void`	`transformSymmetric(Householder<N> transformation)`
`MatrixStore<N>`	`transpose()`
`void`	`tred2(BasicArray<N> mainDiagonal, BasicArray<N> offDiagonal, boolean yesvecs)`
`protected void`	`visit(long first, long limit, long step, VoidFunction<N> visitor)`
`void`	`visitColumn(long row, long col, VoidFunction<N> visitor)`
`void`	`visitDiagonal(long row, long col, VoidFunction<N> visitor)`
`void`	`visitOne(long index, VoidFunction<N> visitor)`
`void`	`visitRow(long row, long col, VoidFunction<N> visitor)`

Methods inherited from class org.ojalgo.array.ScalarArray
add, add, axpy, indexOfLargest, isAbsolute, isSmall, sortAscending, sortDescending

Methods inherited from class org.ojalgo.array.ReferenceTypeArray
copyOfData, doubleValue, exchange, exchange, fill, fill, fill, fill, fill, fill, fill, fillOne, fillOne, fillOne, get, invoke, invoke, invoke, invoke, invoke, invoke, modify, modify, modify, modify, modify, modify, modifyOne, reset, searchAscending, set, set, size, spliterator, visit, visitOne

Methods inherited from class org.ojalgo.array.BasicArray
factory, indexOfLargest, indexOfLargestInRange, makeDecreasingRange, makeDecreasingRange, makeIncreasingRange, makeIncreasingRange, modifyRange, visitAll, visitRange, wrapInArray1D, wrapInArray2D, wrapInArrayAnyD

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

Methods inherited from interface org.ojalgo.matrix.decomposition.DecompositionStore
exchangeColumns, sliceColumn, sliceRow

Methods inherited from interface org.ojalgo.matrix.store.MatrixStore
add, aggregateColumn, aggregateDiagonal, aggregateRange, aggregateRow, equals, firstInColumn, firstInRow, isSmall, limitOfColumn, limitOfRow, logical, multiply, multiply, multiply, negate, norm, premultiply, reduceColumns, reduceRows, signum, subtract, visitOne

Methods inherited from interface org.ojalgo.matrix.store.ElementsSupplier
operateOnAll, operateOnMatching, operateOnMatching

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

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

Methods inherited from interface org.ojalgo.access.Access2D
asCollectable2D, asPrimitive2D, columns, equals, newPrimitiveColumnCollectable, newPrimitiveRowCollectable, rows, toRawCopy2D, toString, wrap, wrap, wrapAccess2D, wrapAccess2D

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

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

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

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

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

Methods inherited from interface org.ojalgo.access.Access2D.IndexOf
indexOfLargestInColumn, indexOfLargestInRow, indexOfLargestOnDiagonal

Methods inherited from interface org.ojalgo.access.Access1D.IndexOf
indexOfLargest, indexOfLargestInRange

Methods inherited from interface org.ojalgo.matrix.transformation.TransformationMatrix.Transformable
transform

Methods inherited from interface org.ojalgo.access.Mutate2D.Receiver
isAcceptable

Methods inherited from interface org.ojalgo.access.Mutate2D
add, add, set, set

Methods inherited from interface org.ojalgo.access.Mutate1D
reset

Methods inherited from interface org.ojalgo.access.Mutate2D.Fillable
fillColumn, fillColumn, fillColumn, fillDiagonal, fillDiagonal, fillDiagonal, fillDiagonal, fillOne, fillOne, fillOne, fillRow, fillRow, fillRow

Methods inherited from interface org.ojalgo.access.Structure2D
column, column, column, column, column, count, 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.access.Mutate1D.Fillable
fillAll, fillAll, fillRange, fillRange

Methods inherited from interface org.ojalgo.access.Structure1D
loopAll, loopMatching, loopRange, mapper

Methods inherited from interface java.util.function.Consumer
andThen

Methods inherited from interface org.ojalgo.access.Mutate2D.Modifiable
modifyColumn, modifyDiagonal, modifyOne, modifyRow

Methods inherited from interface org.ojalgo.access.Mutate1D.Modifiable
modifyRange

- Field Detail
  - COMPLEX
```
public static final PhysicalStore.Factory<ComplexNumber,GenericDenseStore<ComplexNumber>> COMPLEX
```
  - QUATERNION
```
public static final PhysicalStore.Factory<Quaternion,GenericDenseStore<Quaternion>> QUATERNION
```
  - RATIONAL
```
public static final PhysicalStore.Factory<RationalNumber,GenericDenseStore<RationalNumber>> RATIONAL
```
- Method Detail
  - accept
```
public void accept(Access2D<?> supplied)
```
    Specified by:
    
    accept in interface Consumer<Access2D<?>>
    
    Specified by:
    
    accept in interface Mutate2D.Receiver<N extends Number & Scalar<N>>
  - add
```
public void add(long row,
                long col,
                double addend)
```
    Specified by:
    
    add in interface Mutate2D
  - add
```
public void add(long row,
                long col,
                Number addend)
```
    Specified by:
    
    add in interface Mutate2D
  - aggregateAll
```
public N aggregateAll(Aggregator aggregator)
```
    Specified by:
    
    aggregateAll in interface Access1D.Aggregatable<N extends Number & Scalar<N>>
    
    Specified by:
    
    aggregateAll in interface MatrixStore<N extends Number & Scalar<N>>
  - applyCholesky
```
public void applyCholesky(int iterationPoint,
                          BasicArray<N> multipliers)
```
    Description copied from interface: DecompositionStore
    
    Cholesky transformations
    
    Specified by:
    
    applyCholesky in interface DecompositionStore<N extends Number & Scalar<N>>
  - applyLDL
```
public void applyLDL(int iterationPoint,
                     BasicArray<N> multipliers)
```
    Description copied from interface: DecompositionStore
    
    LDL transformations
    
    Specified by:
    
    applyLDL in interface DecompositionStore<N extends Number & Scalar<N>>
  - applyLU
```
public void applyLU(int iterationPoint,
                    BasicArray<N> multipliers)
```
    Description copied from interface: DecompositionStore
    
    LU transformations
    
    Specified by:
    
    applyLU in interface DecompositionStore<N extends Number & Scalar<N>>
  - asList
```
public Array1D<N> asList()
```
    Specified by:
    
    asList in interface PhysicalStore<N extends Number & Scalar<N>>
    
    Returns:
    
    The elements of the physical store as a fixed size (1 dimensional) list. The elements may be accessed either row or colomn major.
  - computeInPlaceSchur
```
public Array1D<ComplexNumber> computeInPlaceSchur(PhysicalStore<N> transformationCollector,
                                                  boolean eigenvalue)
```
    Specified by:
    
    computeInPlaceSchur in interface DecompositionStore<N extends Number & Scalar<N>>
  - conjugate
```
public MatrixStore<N> conjugate()
```
    Description copied from interface: MatrixStore
    
    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 & Scalar<N>>,N extends Number & Scalar<N>>
    
    Specified by:
    
    conjugate in interface MatrixStore<N extends Number & Scalar<N>>
    
    See Also:
    
    VectorSpace.conjugate()
  - copy
```
public GenericDenseStore<N> copy()
```
    Description copied from interface: MatrixStore
    
    Each call must produce a new instance.
    
    Specified by:
    
    copy in interface MatrixStore<N extends Number & Scalar<N>>
    
    Returns:
    
    A new PhysicalStore copy.
  - countColumns
```
public long countColumns()
```
    Specified by:
    
    countColumns in interface Structure2D
    
    Returns:
    
    The number of columns
  - countRows
```
public long countRows()
```
    Specified by:
    
    countRows in interface Structure2D
    
    Returns:
    
    The number of rows
  - divideAndCopyColumn
```
public void divideAndCopyColumn(int row,
                                int column,
                                BasicArray<N> destination)
```
    Specified by:
    
    divideAndCopyColumn in interface DecompositionStore<N extends Number & Scalar<N>>
  - doubleValue
```
public 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 & Scalar<N>>
    
    Specified by:
    
    doubleValue in interface MatrixStore<N extends Number & Scalar<N>>
    
    Parameters:
    
    row - A row index.
    
    col - A column index.
    
    Returns:
    
    One matrix element
  - equals
```
public boolean equals(Object anObj)
```
    Overrides:
    
    equals in class ReferenceTypeArray<N extends Number & Scalar<N>>
  - exchangeColumns
```
public void exchangeColumns(long colA,
                            long colB)
```
    Specified by:
    
    exchangeColumns in interface Mutate2D.Exchangeable
  - exchangeHermitian
```
public void exchangeHermitian(int indexA,
                              int indexB)
```
    Specified by:
    
    exchangeHermitian in interface DecompositionStore<N extends Number & Scalar<N>>
  - exchangeRows
```
public void exchangeRows(long rowA,
                         long rowB)
```
    Specified by:
    
    exchangeRows in interface Mutate2D.Exchangeable
  - fillByMultiplying
```
public void fillByMultiplying(Access1D<N> left,
                              Access1D<N> right)
```
    Specified by:
    
    fillByMultiplying in interface ElementsConsumer<N extends Number & Scalar<N>>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       Access1D<N> values)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       N value)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       NullaryFunction<N> supplier)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long col,
                         N value)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long col,
                         NullaryFunction<N> supplier)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillMatching
```
public void fillMatching(Access1D<?> values)
```
    Description copied from interface: Mutate1D.Fillable
    
    Will fill the elements of [this] with the corresponding input values, and in the process (if necessary) convert the elements to the correct type:
    this(i) = values(i)
    
    Specified by:
    
    fillMatching in interface Mutate1D.Fillable<N extends Number & Scalar<N>>
    
    Overrides:
    
    fillMatching in class ReferenceTypeArray<N extends Number & Scalar<N>>
  - fillMatching
```
public void fillMatching(Access1D<N> left,
                         BinaryFunction<N> function,
                         Access1D<N> right)
```
    Specified by:
    
    fillMatching in interface Mutate1D.Fillable<N extends Number & Scalar<N>>
    
    Overrides:
    
    fillMatching in class ReferenceTypeArray<N extends Number & Scalar<N>>
  - fillMatching
```
public void fillMatching(UnaryFunction<N> function,
                         Access1D<N> arguments)
```
    Specified by:
    
    fillMatching in interface Mutate1D.Fillable<N extends Number & Scalar<N>>
    
    Overrides:
    
    fillMatching in class ReferenceTypeArray<N extends Number & Scalar<N>>
  - fillOne
```
public void fillOne(long row,
                    long col,
                    Access1D<?> values,
                    long valueIndex)
```
    Specified by:
    
    fillOne in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillOne
```
public void fillOne(long row,
                    long col,
                    N value)
```
    Specified by:
    
    fillOne in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillOne
```
public void fillOne(long row,
                    long col,
                    NullaryFunction<N> supplier)
```
    Specified by:
    
    fillOne in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    Access1D<N> values)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    N value)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    NullaryFunction<N> supplier)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<N extends Number & Scalar<N>>
  - generateApplyAndCopyHouseholderColumn
```
public boolean generateApplyAndCopyHouseholderColumn(int row,
                                                     int column,
                                                     Householder<N> destination)
```
    Specified by:
    
    generateApplyAndCopyHouseholderColumn in interface DecompositionStore<N extends Number & Scalar<N>>
  - generateApplyAndCopyHouseholderRow
```
public boolean generateApplyAndCopyHouseholderRow(int row,
                                                  int column,
                                                  Householder<N> destination)
```
    Specified by:
    
    generateApplyAndCopyHouseholderRow in interface DecompositionStore<N extends Number & Scalar<N>>
  - get
```
public final MatrixStore<N> get()
```
    Specified by:
    
    get in interface Supplier<MatrixStore<N extends Number & Scalar<N>>>
    
    Specified by:
    
    get in interface ElementsSupplier<N extends Number & Scalar<N>>
    
    Specified by:
    
    get in interface MatrixStore<N extends Number & Scalar<N>>
  - get
```
public N get(long row,
             long col)
```
    Specified by:
    
    get in interface Access2D<N extends Number & Scalar<N>>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class ReferenceTypeArray<N extends Number & Scalar<N>>
  - indexOfLargestInColumn
```
public long indexOfLargestInColumn(long row,
                                   long col)
```
    Specified by:
    
    indexOfLargestInColumn in interface Access2D.IndexOf
    
    Parameters:
    
    row - First row to investigate
    
    col - The column
    
    Returns:
    
    The row-index of the largest absolute value in a column, starting at the specified row.
  - indexOfLargestInRow
```
public long indexOfLargestInRow(long row,
                                long col)
```
    Specified by:
    
    indexOfLargestInRow in interface Access2D.IndexOf
    
    Parameters:
    
    row - The row
    
    col - The first column to investigate
    
    Returns:
    
    The column-index of the largest absolute value in a row, starting at the specified column.
  - indexOfLargestOnDiagonal
```
public long indexOfLargestOnDiagonal(long first)
```
    Specified by:
    
    indexOfLargestOnDiagonal in interface Access2D.IndexOf
    
    Parameters:
    
    first - The first row/column to investigate
    
    Returns:
    
    The row/column-index of the largest absolute value on the main diagonal, starting at the specified row/column.
  - isAbsolute
```
public boolean isAbsolute(long row,
                          long col)
```
    Specified by:
    
    isAbsolute in interface Access2D.Elements
    
    Specified by:
    
    isAbsolute in interface MatrixStore<N extends Number & Scalar<N>>
    
    See Also:
    
    Scalar.isAbsolute()
  - isColumnSmall
```
public boolean isColumnSmall(long row,
                             long col,
                             double comparedTo)
```
    Specified by:
    
    isColumnSmall in interface Access2D.Elements
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - isRowSmall
```
public boolean isRowSmall(long row,
                          long col,
                          double comparedTo)
```
    Specified by:
    
    isRowSmall in interface Access2D.Elements
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - isSmall
```
public boolean isSmall(long row,
                       long col,
                       double comparedTo)
```
    Specified by:
    
    isSmall in interface Access2D.Elements
    
    Specified by:
    
    isSmall in interface MatrixStore<N extends Number & Scalar<N>>
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - modifyAll
```
public void modifyAll(UnaryFunction<N> aFunc)
```
    Specified by:
    
    modifyAll in interface Mutate1D.Modifiable<N extends Number & Scalar<N>>
    
    Overrides:
    
    modifyAll in class BasicArray<N extends Number & Scalar<N>>
  - modifyColumn
```
public void modifyColumn(long row,
                         long col,
                         UnaryFunction<N> modifier)
```
    Specified by:
    
    modifyColumn in interface Mutate2D.Modifiable<N extends Number & Scalar<N>>
  - modifyDiagonal
```
public void modifyDiagonal(long row,
                           long col,
                           UnaryFunction<N> modifier)
```
    Specified by:
    
    modifyDiagonal in interface Mutate2D.Modifiable<N extends Number & Scalar<N>>
  - modifyMatching
```
public void modifyMatching(Access1D<N> left,
                           BinaryFunction<N> function)
```
    Specified by:
    
    modifyMatching in interface Mutate1D.BiModifiable<N extends Number & Scalar<N>>
  - modifyMatching
```
public void modifyMatching(BinaryFunction<N> function,
                           Access1D<N> right)
```
    Specified by:
    
    modifyMatching in interface Mutate1D.BiModifiable<N extends Number & Scalar<N>>
  - modifyOne
```
public void modifyOne(long row,
                      long col,
                      UnaryFunction<N> modifier)
```
    Specified by:
    
    modifyOne in interface Mutate2D.Modifiable<N extends Number & Scalar<N>>
  - modifyRow
```
public void modifyRow(long row,
                      long col,
                      UnaryFunction<N> modifier)
```
    Specified by:
    
    modifyRow in interface Mutate2D.Modifiable<N extends Number & Scalar<N>>
  - multiply
```
public MatrixStore<N> multiply(MatrixStore<N> right)
```
    Specified by:
    
    multiply in interface Operation.Multiplication<MatrixStore<N extends Number & Scalar<N>>>
    
    Specified by:
    
    multiply in interface MatrixStore<N extends Number & Scalar<N>>
    
    Parameters:
    
    right - The multiplicand
    
    Returns:
    
    this * multiplicand.
  - multiplyBoth
```
public N multiplyBoth(Access1D<N> leftAndRight)
```
    Description copied from interface: MatrixStore
    
    Assumes [leftAndRight] is a vector and will calulate [leftAndRight]^H[this][leftAndRight]
    
    Specified by:
    
    multiplyBoth in interface MatrixStore<N extends Number & Scalar<N>>
    
    Parameters:
    
    leftAndRight - The argument vector
    
    Returns:
    
    A scalar (extracted from the resulting 1 x 1 matrix)
  - negateColumn
```
public void negateColumn(int column)
```
    Specified by:
    
    negateColumn in interface NegateColumn
  - physical
```
public PhysicalStore.Factory<N,GenericDenseStore<N>> physical()
```
    Specified by:
    
    physical in interface ElementsSupplier<N extends Number & Scalar<N>>
  - regionByColumns
```
public final ElementsConsumer<N> regionByColumns(int... columns)
```
    Specified by:
    
    regionByColumns in interface ElementsConsumer<N extends Number & Scalar<N>>
    
    Returns:
    
    A consumer (sub)region
  - regionByLimits
```
public final ElementsConsumer<N> regionByLimits(int rowLimit,
                                                int columnLimit)
```
    Specified by:
    
    regionByLimits in interface ElementsConsumer<N extends Number & Scalar<N>>
    
    Returns:
    
    A consumer (sub)region
  - regionByOffsets
```
public final ElementsConsumer<N> regionByOffsets(int rowOffset,
                                                 int columnOffset)
```
    Specified by:
    
    regionByOffsets in interface ElementsConsumer<N extends Number & Scalar<N>>
    
    Returns:
    
    A consumer (sub)region
  - regionByRows
```
public final ElementsConsumer<N> regionByRows(int... rows)
```
    Specified by:
    
    regionByRows in interface ElementsConsumer<N extends Number & Scalar<N>>
    
    Returns:
    
    A consumer (sub)region
  - regionByTransposing
```
public final ElementsConsumer<N> regionByTransposing()
```
    Specified by:
    
    regionByTransposing in interface ElementsConsumer<N extends Number & Scalar<N>>
    
    Returns:
    
    A transposed consumer region
  - rotateRight
```
public void rotateRight(int low,
                        int high,
                        double cos,
                        double sin)
```
    Specified by:
    
    rotateRight in interface RotateRight
  - set
```
public void set(long row,
                long col,
                double value)
```
    Specified by:
    
    set in interface Mutate2D
  - set
```
public void set(long row,
                long col,
                Number value)
```
    Specified by:
    
    set in interface Mutate2D
  - setToIdentity
```
public void setToIdentity(int col)
```
    Specified by:
    
    setToIdentity in interface DecompositionStore<N extends Number & Scalar<N>>
  - sliceColumn
```
public Array1D<N> sliceColumn(long row,
                              long col)
```
    Specified by:
    
    sliceColumn in interface Access2D.Sliceable<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceColumn in interface DecompositionStore<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceColumn in interface MatrixStore<N extends Number & Scalar<N>>
  - sliceDiagonal
```
public Array1D<N> sliceDiagonal(long row,
                                long col)
```
    Specified by:
    
    sliceDiagonal in interface Access2D.Sliceable<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceDiagonal in interface DecompositionStore<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceDiagonal in interface MatrixStore<N extends Number & Scalar<N>>
  - sliceRange
```
public Array1D<N> sliceRange(long first,
                             long limit)
```
    Specified by:
    
    sliceRange in interface Access1D.Sliceable<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceRange in interface DecompositionStore<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceRange in interface MatrixStore<N extends Number & Scalar<N>>
  - sliceRow
```
public Array1D<N> sliceRow(long row,
                           long col)
```
    Specified by:
    
    sliceRow in interface Access2D.Sliceable<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceRow in interface DecompositionStore<N extends Number & Scalar<N>>
    
    Specified by:
    
    sliceRow in interface MatrixStore<N extends Number & Scalar<N>>
  - substituteBackwards
```
public void substituteBackwards(Access2D<N> body,
                                boolean unitDiagonal,
                                boolean conjugated,
                                boolean hermitian)
```
    Description copied from interface: PhysicalStore
    Will solve the equation system [A][X]=[B] where:
    - [body][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution).
    - [A] is upper/right triangular
    Specified by:
    
    substituteBackwards in interface PhysicalStore<N extends Number & Scalar<N>>
    
    Parameters:
    
    body - The equation system body parameters [A]
    
    unitDiagonal - TODO
    
    conjugated - true if the upper/right part of body is actually stored in the lower/left part of the matrix, and the elements conjugated.
    
    hermitian - TODO
  - substituteForwards
```
public void substituteForwards(Access2D<N> body,
                               boolean unitDiagonal,
                               boolean conjugated,
                               boolean identity)
```
    Description copied from interface: PhysicalStore
    Will solve the equation system [A][X]=[B] where:
    - [body][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution).
    - [A] is lower/left triangular
    Specified by:
    
    substituteForwards in interface PhysicalStore<N extends Number & Scalar<N>>
    
    Parameters:
    
    body - The equation system body parameters [A]
    
    unitDiagonal - true if body has ones on the diagonal
    
    conjugated - TODO
  - supplyTo
```
public void supplyTo(ElementsConsumer<N> receiver)
```
    Specified by:
    
    supplyTo in interface Access2D.Collectable<N extends Number & Scalar<N>,ElementsConsumer<N extends Number & Scalar<N>>>
    
    Specified by:
    
    supplyTo in interface MatrixStore<N extends Number & Scalar<N>>
  - toScalar
```
public Scalar<N> toScalar(long row,
                          long column)
```
    Specified by:
    
    toScalar in interface MatrixStore<N extends Number & Scalar<N>>
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class BasicArray<N extends Number & Scalar<N>>
  - transformLeft
```
public void transformLeft(Householder<N> transformation,
                          int firstColumn)
```
    Specified by:
    
    transformLeft in interface PhysicalStore<N extends Number & Scalar<N>>
  - transformLeft
```
public void transformLeft(Rotation<N> transformation)
```
    Description copied from interface: PhysicalStore
    
    As in MatrixStore.premultiply(Access1D) where the left/parameter matrix is a plane rotation.
    
    Multiplying by a plane rotation from the left means that [this] gets two of its rows updated to new combinations of those two (current) rows.
    
    There are two ways to transpose/invert a rotation. Either you negate the angle or you interchange the two indeces that define the rotation plane.
    
    Specified by:
    
    transformLeft in interface PhysicalStore<N extends Number & Scalar<N>>
    
    See Also:
    
    PhysicalStore.transformRight(Rotation)
  - transformRight
```
public void transformRight(Householder<N> transformation,
                           int firstRow)
```
    Specified by:
    
    transformRight in interface PhysicalStore<N extends Number & Scalar<N>>
  - transformRight
```
public void transformRight(Rotation<N> transformation)
```
    Description copied from interface: PhysicalStore
    
    As in MatrixStore.multiply(MatrixStore) where the right/parameter matrix is a plane rotation.
    
    Multiplying by a plane rotation from the right means that [this] gets two of its columns updated to new combinations of those two (current) columns.
    
    There result is undefined if the two input indeces are the same (in which case the rotation plane is undefined).
    
    Specified by:
    
    transformRight in interface PhysicalStore<N extends Number & Scalar<N>>
    
    See Also:
    
    PhysicalStore.transformLeft(Rotation)
  - transformSymmetric
```
public void transformSymmetric(Householder<N> transformation)
```
    Specified by:
    
    transformSymmetric in interface DecompositionStore<N extends Number & Scalar<N>>
  - transpose
```
public MatrixStore<N> transpose()
```
    Specified by:
    
    transpose in interface Stream2D<N extends Number & Scalar<N>,MatrixStore<N extends Number & Scalar<N>>,ElementsConsumer<N extends Number & Scalar<N>>,ElementsSupplier<N extends Number & Scalar<N>>>
    
    Specified by:
    
    transpose in interface ElementsSupplier<N extends Number & Scalar<N>>
    
    Specified by:
    
    transpose in interface MatrixStore<N extends Number & Scalar<N>>
    
    Returns:
    
    A transposed matrix instance.
  - tred2
```
public void tred2(BasicArray<N> mainDiagonal,
                  BasicArray<N> offDiagonal,
                  boolean yesvecs)
```
    Specified by:
    
    tred2 in interface DecompositionStore<N extends Number & Scalar<N>>
  - visitColumn
```
public void visitColumn(long row,
                        long col,
                        VoidFunction<N> visitor)
```
    Specified by:
    
    visitColumn in interface Access2D.Visitable<N extends Number & Scalar<N>>
  - visitDiagonal
```
public void visitDiagonal(long row,
                          long col,
                          VoidFunction<N> visitor)
```
    Specified by:
    
    visitDiagonal in interface Access2D.Visitable<N extends Number & Scalar<N>>
  - visitRow
```
public void visitRow(long row,
                     long col,
                     VoidFunction<N> visitor)
```
    Specified by:
    
    visitRow in interface Access2D.Visitable<N extends Number & Scalar<N>>
  - add
```
public void add(long index,
                double addend)
```
    Specified by:
    
    add in interface Mutate1D
  - add
```
public void add(long index,
                Number addend)
```
    Specified by:
    
    add in interface Mutate1D
  - count
```
public final long count()
```
    Specified by:
    
    count in interface Structure1D
    
    Returns:
    
    The total number of elements in this structure.
  - doubleValue
```
public final double doubleValue(long index)
```
    Specified by:
    
    doubleValue in interface Access1D<N extends Number>
  - fillAll
```
public final void fillAll(N number)
```
    Specified by:
    
    fillAll in interface Mutate1D.Fillable<N extends Number>
  - fillAll
```
public final void fillAll(NullaryFunction<N> supplier)
```
    Specified by:
    
    fillAll in interface Mutate1D.Fillable<N extends Number>
  - fillOne
```
public final void fillOne(long index,
                          Access1D<?> values,
                          long valueIndex)
```
    Specified by:
    
    fillOne in interface Mutate1D.Fillable<N extends Number>
  - fillOne
```
public void fillOne(long index,
                    N value)
```
    Specified by:
    
    fillOne in interface Mutate1D.Fillable<N extends Number>
  - fillOne
```
public void fillOne(long index,
                    NullaryFunction<N> supplier)
```
    Specified by:
    
    fillOne in interface Mutate1D.Fillable<N extends Number>
  - fillRange
```
public final void fillRange(long first,
                            long limit,
                            N number)
```
    Specified by:
    
    fillRange in interface Mutate1D.Fillable<N extends Number>
  - fillRange
```
public final void fillRange(long first,
                            long limit,
                            NullaryFunction<N> supplier)
```
    Specified by:
    
    fillRange in interface Mutate1D.Fillable<N extends Number>
  - get
```
public final N get(long index)
```
    Specified by:
    
    get in interface Access1D<N extends Number>
  - isAbsolute
```
public final boolean isAbsolute(long index)
```
    Specified by:
    
    isAbsolute in interface Access1D.Elements
    
    See Also:
    
    Scalar.isAbsolute()
  - isSmall
```
public final boolean isSmall(long index,
                             double comparedTo)
```
    Specified by:
    
    isSmall in interface Access1D.Elements
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - modifyOne
```
public final void modifyOne(long index,
                            UnaryFunction<N> modifier)
```
    Specified by:
    
    modifyOne in interface Mutate1D.Modifiable<N extends Number>
  - set
```
public final void set(long index,
                      double value)
```
    Specified by:
    
    set in interface Mutate1D
  - set
```
public final void set(long index,
                      Number number)
```
    Specified by:
    
    set in interface Mutate1D
  - visitOne
```
public void visitOne(long index,
                     VoidFunction<N> visitor)
```
    Specified by:
    
    visitOne in interface Access1D.Visitable<N extends Number>
  - exchange
```
protected final void exchange(long firstA,
                              long firstB,
                              long step,
                              long count)
```
    Specified by:
    
    exchange in class BasicArray<N extends Number>
  - fill
```
protected final void fill(long first,
                          long limit,
                          long step,
                          N value)
```
    Specified by:
    
    fill in class BasicArray<N extends Number>
  - fill
```
protected final void fill(long first,
                          long limit,
                          long step,
                          NullaryFunction<N> supplier)
```
    Specified by:
    
    fill in class BasicArray<N extends Number>
  - indexOfLargest
```
protected final long indexOfLargest(long first,
                                    long limit,
                                    long step)
```
    Overrides:
    
    indexOfLargest in class BasicArray<N extends Number>
  - isSmall
```
protected final boolean isSmall(long first,
                                long limit,
                                long step,
                                double comparedTo)
```
    Specified by:
    
    isSmall in class BasicArray<N extends Number>
  - modify
```
protected final void modify(long first,
                            long limit,
                            long step,
                            Access1D<N> left,
                            BinaryFunction<N> function)
```
    Specified by:
    
    modify in class BasicArray<N extends Number>
  - modify
```
protected final void modify(long first,
                            long limit,
                            long step,
                            BinaryFunction<N> function,
                            Access1D<N> right)
```
    Specified by:
    
    modify in class BasicArray<N extends Number>
  - modify
```
protected final void modify(long first,
                            long limit,
                            long step,
                            UnaryFunction<N> function)
```
    Specified by:
    
    modify in class BasicArray<N extends Number>
  - visit
```
protected final void visit(long first,
                           long limit,
                           long step,
                           VoidFunction<N> visitor)
```
    Specified by:
    
    visit in class BasicArray<N extends Number>

Class GenericDenseStore<N extends Number & Scalar<N>>

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.MatrixStore

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

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

Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.ElementsConsumer

Nested classes/interfaces inherited from interface org.ojalgo.access.Mutate2D

Nested classes/interfaces inherited from interface org.ojalgo.access.Mutate1D

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

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

Field Summary

Fields inherited from class org.ojalgo.array.ReferenceTypeArray

Fields inherited from class org.ojalgo.array.DenseArray

Fields inherited from interface org.ojalgo.matrix.store.MatrixStore

Fields inherited from interface org.ojalgo.matrix.decomposition.function.RotateRight

Fields inherited from interface org.ojalgo.matrix.decomposition.function.ExchangeColumns

Fields inherited from interface org.ojalgo.matrix.decomposition.function.NegateColumn

Method Summary

Methods inherited from class org.ojalgo.array.ScalarArray

Methods inherited from class org.ojalgo.array.ReferenceTypeArray

Methods inherited from class org.ojalgo.array.BasicArray

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.matrix.decomposition.DecompositionStore

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

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

Methods inherited from interface org.ojalgo.access.Stream2D

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

Methods inherited from interface org.ojalgo.access.Access2D

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

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

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

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

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

Methods inherited from interface org.ojalgo.access.Access2D.IndexOf

Methods inherited from interface org.ojalgo.access.Access1D.IndexOf

Methods inherited from interface org.ojalgo.matrix.transformation.TransformationMatrix.Transformable

Methods inherited from interface org.ojalgo.access.Mutate2D.Receiver

Methods inherited from interface org.ojalgo.access.Mutate2D

Methods inherited from interface org.ojalgo.access.Mutate1D

Methods inherited from interface org.ojalgo.access.Mutate2D.Fillable

Methods inherited from interface org.ojalgo.access.Structure2D

Methods inherited from interface org.ojalgo.access.Mutate1D.Fillable

Methods inherited from interface org.ojalgo.access.Structure1D

Methods inherited from interface java.util.function.Consumer

Methods inherited from interface org.ojalgo.access.Mutate2D.Modifiable

Methods inherited from interface org.ojalgo.access.Mutate1D.Modifiable

Field Detail

COMPLEX

QUATERNION

RATIONAL

Method Detail

accept

add

add

aggregateAll

applyCholesky

applyLDL

applyLU

asList

computeInPlaceSchur

conjugate

copy

countColumns

countRows

divideAndCopyColumn

doubleValue

equals

exchangeColumns

exchangeHermitian

exchangeRows

fillByMultiplying

fillColumn

fillColumn

fillColumn

fillDiagonal

fillDiagonal

fillMatching

fillMatching

fillMatching

fillOne