PrimitiveDenseStore (ojAlgo 47.2.0 API)

java.lang.Object
- org.ojalgo.array.BasicArray<N>
- - org.ojalgo.array.DenseArray<N>
  - - org.ojalgo.array.PrimitiveArray
    - - org.ojalgo.array.Primitive64Array
      - org.ojalgo.matrix.store.PrimitiveDenseStore

All Implemented Interfaces:

Consumer<Access2D<?>>, Supplier<MatrixStore<Double>>, RandomAccess, Group, Group.Additive<MatrixStore<Double>>, NormedVectorSpace<MatrixStore<Double>,Double>, Operation, Operation.Addition<MatrixStore<Double>>, Operation.Multiplication<MatrixStore<Double>>, ScalarOperation, ScalarOperation.Multiplication<MatrixStore<Double>,Double>, VectorSpace<MatrixStore<Double>,Double>, DecompositionStore<Double>, ExchangeColumns, NegateColumn, RotateRight, ElementsSupplier<Double>, MatrixStore<Double>, PhysicalStore<Double>, TransformableRegion<Double>, Access1D<Double>, Access1D.Aggregatable<Double>, Access1D.Elements, Access1D.IndexOf, Access1D.Sliceable<Double>, Access1D.Visitable<Double>, Access2D<Double>, Access2D.Aggregatable<Double>, Access2D.Collectable<Double,TransformableRegion<Double>>, Access2D.Elements, Access2D.IndexOf, Access2D.Sliceable<Double>, Access2D.Visitable<Double>, Mutate1D, Mutate1D.Fillable<Double>, Mutate1D.Modifiable<Double>, Mutate1D.Sortable, Mutate2D, Mutate2D.Exchangeable, Mutate2D.Fillable<Double>, Mutate2D.Modifiable<Double>, Mutate2D.ModifiableReceiver<Double>, Mutate2D.Receiver<Double>, Stream2D<Double,MatrixStore<Double>,TransformableRegion<Double>,ElementsSupplier<Double>>, Structure1D, Structure2D, Structure2D.ReducibleTo1D<ElementsSupplier<Double>>
```
public final class PrimitiveDenseStore
extends Primitive64Array
implements PhysicalStore<Double>, DecompositionStore<Double>
```
A Double (actually double) implementation of PhysicalStore.

Author:

apete

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`PrimitiveDenseStore.PrimitiveMultiplyBoth`
`static interface`	`PrimitiveDenseStore.PrimitiveMultiplyLeft`
`static interface`	`PrimitiveDenseStore.PrimitiveMultiplyNeither`
`static interface`	`PrimitiveDenseStore.PrimitiveMultiplyRight`

Nested classes/interfaces inherited from class org.ojalgo.array.DenseArray
DenseArray.Factory<N extends Number>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.PhysicalStore
PhysicalStore.Factory<N extends Number,I extends PhysicalStore<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.TransformableRegion
TransformableRegion.ColumnsRegion<N extends Number>, TransformableRegion.FillByMultiplying<N extends Number>, TransformableRegion.LimitRegion<N extends Number>, TransformableRegion.OffsetRegion<N extends Number>, TransformableRegion.ReceiverRegion<N extends Number>, TransformableRegion.RowsRegion<N extends Number>, TransformableRegion.TransposedRegion<N extends Number>

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

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

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>

Field Summary

Fields
Modifier and Type Field and Description

static PhysicalStore.Factory<Double,PrimitiveDenseStore> FACTORY
- Fields inherited from class org.ojalgo.array.Primitive64Array
  data
- Fields inherited from class org.ojalgo.array.DenseArray
  MAX_ARRAY_SIZE
- Fields inherited from interface org.ojalgo.matrix.store.MatrixStore
  COMPLEX, PRIMITIVE, QUATERNION, RATIONAL
- 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

Fields
Modifier and Type	Field and Description
`static PhysicalStore.Factory<Double,PrimitiveDenseStore>`	`FACTORY`

Method Summary

All Methods Static 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)`
`Double`	`aggregateAll(Aggregator aggregator)`
`void`	`applyCholesky(int iterationPoint, BasicArray<Double> multipliers)` Cholesky transformations
`void`	`applyLDL(int iterationPoint, BasicArray<Double> multipliers)` LDL transformations
`void`	`applyLU(int iterationPoint, BasicArray<Double> multipliers)` LU transformations
`Array1D<Double>`	`asList()`
`void`	`caxpy(double aSclrA, int aColX, int aColY, int aFirstRow)`
`Array1D<ComplexNumber>`	`computeInPlaceSchur(PhysicalStore<Double> transformationCollector, boolean eigenvalue)`
`MatrixStore<Double>`	`conjugate()` Returns the conjugate transpose of this matrix.
`PrimitiveDenseStore`	`copy()` Each call must produce a new instance.
`long`	`count()`
`long`	`countColumns()`
`long`	`countRows()`
`void`	`divideAndCopyColumn(int row, int column, BasicArray<Double> 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<Double> left, Access1D<Double> right)`
`void`	`fillColumn(long row, long col, Access1D<Double> values)`
`void`	`fillColumn(long row, long col, Double value)`
`void`	`fillColumn(long row, long col, NullaryFunction<Double> supplier)`
`void`	`fillDiagonal(long row, long col, Double value)`
`void`	`fillDiagonal(long row, long col, NullaryFunction<Double> 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<Double> left, BinaryFunction<Double> function, Access1D<Double> right)`
`void`	`fillMatching(UnaryFunction<Double> function, Access1D<Double> 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, Double value)`
`void`	`fillOne(long row, long col, NullaryFunction<Double> 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<Double> values)`
`void`	`fillRow(long row, long col, Double value)`
`void`	`fillRow(long row, long col, NullaryFunction<Double> supplier)`
`boolean`	`generateApplyAndCopyHouseholderColumn(int row, int column, Householder<Double> destination)`
`boolean`	`generateApplyAndCopyHouseholderRow(int row, int column, Householder<Double> destination)`
`MatrixStore<Double>`	`get()`
`N`	`get(long index)`
`Double`	`get(long row, long col)`
`static PrimitiveDenseStore`	`getComplexArgument(Access2D<ComplexNumber> arg)` Extracts the argument of the ComplexNumber elements to a new primitive double valued matrix.
`static PrimitiveDenseStore`	`getComplexImaginary(Access2D<ComplexNumber> arg)` Extracts the imaginary part of the ComplexNumber elements to a new primitive double valued matrix.
`static PrimitiveDenseStore`	`getComplexModulus(Access2D<ComplexNumber> arg)` Extracts the modulus of the ComplexNumber elements to a new primitive double valued matrix.
`static PrimitiveDenseStore`	`getComplexReal(Access2D<ComplexNumber> arg)` Extracts the real part of the ComplexNumber elements to a new primitive double valued matrix.
`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<Double> modifier)`
`void`	`modifyColumn(long row, long col, UnaryFunction<Double> modifier)`
`void`	`modifyDiagonal(long row, long col, UnaryFunction<Double> modifier)`
`void`	`modifyMatching(Access1D<Double> left, BinaryFunction<Double> function)`
`void`	`modifyMatching(BinaryFunction<Double> function, Access1D<Double> right)`
`void`	`modifyOne(long row, long col, UnaryFunction<Double> modifier)`
`void`	`modifyOne(long index, UnaryFunction<N> modifier)`
`void`	`modifyRow(long row, long col, UnaryFunction<Double> modifier)`
`MatrixStore<Double>`	`multiply(MatrixStore<Double> right)`
`Double`	`multiplyBoth(Access1D<Double> leftAndRight)` Assumes [leftAndRight] is a vector and will calulate [leftAndRight]^H[this][leftAndRight]
`void`	`negateColumn(int column)`
`PhysicalStore.Factory<Double,PrimitiveDenseStore>`	`physical()`
`TransformableRegion<Double>`	`regionByColumns(int... columns)`
`TransformableRegion<Double>`	`regionByLimits(int rowLimit, int columnLimit)`
`TransformableRegion<Double>`	`regionByOffsets(int rowOffset, int columnOffset)`
`TransformableRegion<Double>`	`regionByRows(int... rows)`
`TransformableRegion<Double>`	`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<Double>`	`sliceColumn(long row, long col)`
`Array1D<Double>`	`sliceDiagonal(long row, long col)`
`Array1D<Double>`	`sliceRange(long first, long limit)`
`Array1D<Double>`	`sliceRow(long row, long col)`
`void`	`substituteBackwards(Access2D<Double> 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<Double> 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(TransformableRegion<Double> receiver)`
`PrimitiveScalar`	`toScalar(long row, long column)`
`String`	`toString()`
`void`	`transformLeft(Householder<Double> transformation, int firstColumn)`
`void`	`transformLeft(Rotation<Double> transformation)` As in `MatrixStore.premultiply(Access1D)` where the left/parameter matrix is a plane rotation.
`void`	`transformRight(Householder<Double> transformation, int firstRow)`
`void`	`transformRight(Rotation<Double> transformation)` As in `MatrixStore.multiply(MatrixStore)` where the right/parameter matrix is a plane rotation.
`void`	`transformSymmetric(Householder<Double> transformation)`
`MatrixStore<Double>`	`transpose()`
`void`	`tred2(BasicArray<Double> mainDiagonal, BasicArray<Double> offDiagonal, boolean yesvecs)`
`protected void`	`visit(long first, long limit, long step, VoidFunction<N> visitor)`
`void`	`visitColumn(long row, long col, VoidFunction<Double> visitor)`
`void`	`visitDiagonal(long row, long col, VoidFunction<Double> visitor)`
`void`	`visitOne(long index, VoidFunction<N> visitor)`
`void`	`visitRow(long row, long col, VoidFunction<Double> visitor)`

Methods inherited from class org.ojalgo.array.Primitive64Array
add, add, axpy, copyOfData, dot, doubleValue, exchange, exchange, fill, fill, fill, fill, fill, fill, fill, fill, fillOne, fillOne, fillOne, get, indexOfLargest, invoke, invoke, invoke, invoke, invoke, invoke, isAbsolute, isSmall, make, modify, modify, modify, modify, modify, modify, modifyOne, searchAscending, set, set, size, sortAscending, sortDescending, spliterator, stream, visit, visitOne, wrap

Methods inherited from class org.ojalgo.array.PrimitiveArray
reset, wrap

Methods inherited from class org.ojalgo.array.BasicArray
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.PhysicalStore
modifyAny

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

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

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.Access2D.Visitable
visitColumn, visitDiagonal, visitOne, 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
sliceDiagonal

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

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

Methods inherited from interface org.ojalgo.structure.Mutate2D.Modifiable
modifyColumn, modifyDiagonal, modifyMatchingInColumns, modifyMatchingInColumns, modifyMatchingInRows, modifyMatchingInRows, modifyOne, modifyRow

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

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

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

Methods inherited from interface org.ojalgo.structure.Mutate1D
copyComplexArgument, copyComplexImaginary, copyComplexModulus, copyComplexModulusAndArgument, copyComplexReal, copyComplexRealAndImaginary, reset

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

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

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

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

Methods inherited from interface org.ojalgo.structure.Access2D
asCollectable2D, asPrimitive2D, byteValue, byteValue, columns, doubleValue, elements, equals, floatValue, floatValue, 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

- Field Detail
  - FACTORY
```
public static final PhysicalStore.Factory<Double,PrimitiveDenseStore> FACTORY
```
- Method Detail
  - getComplexArgument
```
public static PrimitiveDenseStore getComplexArgument(Access2D<ComplexNumber> arg)
```
    Extracts the argument of the ComplexNumber elements to a new primitive double valued matrix.
  - getComplexImaginary
```
public static PrimitiveDenseStore getComplexImaginary(Access2D<ComplexNumber> arg)
```
    Extracts the imaginary part of the ComplexNumber elements to a new primitive double valued matrix.
  - getComplexModulus
```
public static PrimitiveDenseStore getComplexModulus(Access2D<ComplexNumber> arg)
```
    Extracts the modulus of the ComplexNumber elements to a new primitive double valued matrix.
  - getComplexReal
```
public static PrimitiveDenseStore getComplexReal(Access2D<ComplexNumber> arg)
```
    Extracts the real part of the ComplexNumber elements to a new primitive double valued matrix.
  - accept
```
public void accept(Access2D<?> supplied)
```
    Specified by:
    
    accept in interface Consumer<Access2D<?>>
    
    Specified by:
    
    accept in interface Mutate2D.Receiver<Double>
  - 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 Double aggregateAll(Aggregator aggregator)
```
    Specified by:
    
    aggregateAll in interface MatrixStore<Double>
    
    Specified by:
    
    aggregateAll in interface Access1D.Aggregatable<Double>
  - applyCholesky
```
public void applyCholesky(int iterationPoint,
                          BasicArray<Double> multipliers)
```
    Description copied from interface: DecompositionStore
    
    Cholesky transformations
    
    Specified by:
    
    applyCholesky in interface DecompositionStore<Double>
  - applyLDL
```
public void applyLDL(int iterationPoint,
                     BasicArray<Double> multipliers)
```
    Description copied from interface: DecompositionStore
    
    LDL transformations
    
    Specified by:
    
    applyLDL in interface DecompositionStore<Double>
  - applyLU
```
public void applyLU(int iterationPoint,
                    BasicArray<Double> multipliers)
```
    Description copied from interface: DecompositionStore
    
    LU transformations
    
    Specified by:
    
    applyLU in interface DecompositionStore<Double>
  - asList
```
public Array1D<Double> asList()
```
    Specified by:
    
    asList in interface PhysicalStore<Double>
    
    Returns:
    
    The elements of the physical store as a fixed size (1 dimensional) list. The elements may be accessed either row or colomn major.
  - caxpy
```
public void caxpy(double aSclrA,
                  int aColX,
                  int aColY,
                  int aFirstRow)
```
  - computeInPlaceSchur
```
public Array1D<ComplexNumber> computeInPlaceSchur(PhysicalStore<Double> transformationCollector,
                                                  boolean eigenvalue)
```
    Specified by:
    
    computeInPlaceSchur in interface DecompositionStore<Double>
  - conjugate
```
public MatrixStore<Double> 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<Double>,Double>
    
    Specified by:
    
    conjugate in interface MatrixStore<Double>
    
    See Also:
    
    VectorSpace.conjugate()
  - copy
```
public PrimitiveDenseStore copy()
```
    Description copied from interface: MatrixStore
    
    Each call must produce a new instance.
    
    Specified by:
    
    copy in interface MatrixStore<Double>
    
    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<Double> destination)
```
    Specified by:
    
    divideAndCopyColumn in interface DecompositionStore<Double>
  - 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 MatrixStore<Double>
    
    Specified by:
    
    doubleValue in interface Access2D<Double>
    
    Parameters:
    
    row - A row index.
    
    col - A column index.
    
    Returns:
    
    One matrix element
  - equals
```
public boolean equals(Object anObj)
```
    Overrides:
    
    equals in class Primitive64Array
  - exchangeColumns
```
public void exchangeColumns(long colA,
                            long colB)
```
    Specified by:
    
    exchangeColumns in interface TransformableRegion<Double>
    
    Specified by:
    
    exchangeColumns in interface Mutate2D.Exchangeable
  - exchangeHermitian
```
public void exchangeHermitian(int indexA,
                              int indexB)
```
    Specified by:
    
    exchangeHermitian in interface DecompositionStore<Double>
  - exchangeRows
```
public void exchangeRows(long rowA,
                         long rowB)
```
    Specified by:
    
    exchangeRows in interface TransformableRegion<Double>
    
    Specified by:
    
    exchangeRows in interface Mutate2D.Exchangeable
  - fillByMultiplying
```
public void fillByMultiplying(Access1D<Double> left,
                              Access1D<Double> right)
```
    Specified by:
    
    fillByMultiplying in interface TransformableRegion<Double>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       Access1D<Double> values)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<Double>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       Double value)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<Double>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       NullaryFunction<Double> supplier)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<Double>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long col,
                         Double value)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<Double>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long col,
                         NullaryFunction<Double> supplier)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<Double>
  - 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<Double>
    
    Overrides:
    
    fillMatching in class Primitive64Array
  - fillMatching
```
public void fillMatching(Access1D<Double> left,
                         BinaryFunction<Double> function,
                         Access1D<Double> right)
```
    Specified by:
    
    fillMatching in interface Mutate1D.Fillable<Double>
    
    Overrides:
    
    fillMatching in class Primitive64Array
  - fillMatching
```
public void fillMatching(UnaryFunction<Double> function,
                         Access1D<Double> arguments)
```
    Specified by:
    
    fillMatching in interface Mutate1D.Fillable<Double>
    
    Overrides:
    
    fillMatching in class Primitive64Array
  - fillOne
```
public void fillOne(long row,
                    long col,
                    Access1D<?> values,
                    long valueIndex)
```
    Specified by:
    
    fillOne in interface Mutate2D.Fillable<Double>
  - fillOne
```
public void fillOne(long row,
                    long col,
                    Double value)
```
    Specified by:
    
    fillOne in interface Mutate2D.Fillable<Double>
  - fillOne
```
public void fillOne(long row,
                    long col,
                    NullaryFunction<Double> supplier)
```
    Specified by:
    
    fillOne in interface Mutate2D.Fillable<Double>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    Access1D<Double> values)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<Double>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    Double value)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<Double>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    NullaryFunction<Double> supplier)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<Double>
  - generateApplyAndCopyHouseholderColumn
```
public boolean generateApplyAndCopyHouseholderColumn(int row,
                                                     int column,
                                                     Householder<Double> destination)
```
    Specified by:
    
    generateApplyAndCopyHouseholderColumn in interface DecompositionStore<Double>
  - generateApplyAndCopyHouseholderRow
```
public boolean generateApplyAndCopyHouseholderRow(int row,
                                                  int column,
                                                  Householder<Double> destination)
```
    Specified by:
    
    generateApplyAndCopyHouseholderRow in interface DecompositionStore<Double>
  - get
```
public MatrixStore<Double> get()
```
    Specified by:
    
    get in interface Supplier<MatrixStore<Double>>
    
    Specified by:
    
    get in interface ElementsSupplier<Double>
    
    Specified by:
    
    get in interface MatrixStore<Double>
  - get
```
public Double get(long row,
                  long col)
```
    Specified by:
    
    get in interface Access2D<Double>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Primitive64Array
  - 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 MatrixStore<Double>
    
    Specified by:
    
    isAbsolute in interface Access2D.Elements
    
    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 MatrixStore<Double>
    
    Specified by:
    
    isSmall in interface Access2D.Elements
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - modifyAll
```
public void modifyAll(UnaryFunction<Double> modifier)
```
    Specified by:
    
    modifyAll in interface Mutate1D.Modifiable<Double>
    
    Overrides:
    
    modifyAll in class BasicArray<Double>
  - modifyColumn
```
public void modifyColumn(long row,
                         long col,
                         UnaryFunction<Double> modifier)
```
    Specified by:
    
    modifyColumn in interface Mutate2D.Modifiable<Double>
  - modifyDiagonal
```
public void modifyDiagonal(long row,
                           long col,
                           UnaryFunction<Double> modifier)
```
    Specified by:
    
    modifyDiagonal in interface Mutate2D.Modifiable<Double>
  - modifyMatching
```
public void modifyMatching(Access1D<Double> left,
                           BinaryFunction<Double> function)
```
    Specified by:
    
    modifyMatching in interface Mutate1D.Modifiable<Double>
    
    Overrides:
    
    modifyMatching in class BasicArray<Double>
  - modifyMatching
```
public void modifyMatching(BinaryFunction<Double> function,
                           Access1D<Double> right)
```
    Specified by:
    
    modifyMatching in interface Mutate1D.Modifiable<Double>
    
    Overrides:
    
    modifyMatching in class BasicArray<Double>
  - modifyOne
```
public void modifyOne(long row,
                      long col,
                      UnaryFunction<Double> modifier)
```
    Specified by:
    
    modifyOne in interface Mutate2D.Modifiable<Double>
  - modifyRow
```
public void modifyRow(long row,
                      long col,
                      UnaryFunction<Double> modifier)
```
    Specified by:
    
    modifyRow in interface Mutate2D.Modifiable<Double>
  - multiply
```
public MatrixStore<Double> multiply(MatrixStore<Double> right)
```
    Specified by:
    
    multiply in interface Operation.Multiplication<MatrixStore<Double>>
    
    Specified by:
    
    multiply in interface MatrixStore<Double>
    
    Parameters:
    
    right - The multiplicand
    
    Returns:
    
    this * multiplicand.
  - multiplyBoth
```
public Double multiplyBoth(Access1D<Double> leftAndRight)
```
    Description copied from interface: MatrixStore
    
    Assumes [leftAndRight] is a vector and will calulate [leftAndRight]^H[this][leftAndRight]
    
    Specified by:
    
    multiplyBoth in interface MatrixStore<Double>
    
    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<Double,PrimitiveDenseStore> physical()
```
    Specified by:
    
    physical in interface ElementsSupplier<Double>
  - regionByColumns
```
public TransformableRegion<Double> regionByColumns(int... columns)
```
    Specified by:
    
    regionByColumns in interface TransformableRegion<Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByLimits
```
public TransformableRegion<Double> regionByLimits(int rowLimit,
                                                  int columnLimit)
```
    Specified by:
    
    regionByLimits in interface TransformableRegion<Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByOffsets
```
public TransformableRegion<Double> regionByOffsets(int rowOffset,
                                                   int columnOffset)
```
    Specified by:
    
    regionByOffsets in interface TransformableRegion<Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByRows
```
public TransformableRegion<Double> regionByRows(int... rows)
```
    Specified by:
    
    regionByRows in interface TransformableRegion<Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByTransposing
```
public TransformableRegion<Double> regionByTransposing()
```
    Specified by:
    
    regionByTransposing in interface TransformableRegion<Double>
    
    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<Double>
  - sliceColumn
```
public Array1D<Double> sliceColumn(long row,
                                   long col)
```
    Specified by:
    
    sliceColumn in interface DecompositionStore<Double>
    
    Specified by:
    
    sliceColumn in interface MatrixStore<Double>
    
    Specified by:
    
    sliceColumn in interface Access2D.Sliceable<Double>
  - sliceDiagonal
```
public Array1D<Double> sliceDiagonal(long row,
                                     long col)
```
    Specified by:
    
    sliceDiagonal in interface DecompositionStore<Double>
    
    Specified by:
    
    sliceDiagonal in interface MatrixStore<Double>
    
    Specified by:
    
    sliceDiagonal in interface Access2D.Sliceable<Double>
  - sliceRange
```
public Array1D<Double> sliceRange(long first,
                                  long limit)
```
    Specified by:
    
    sliceRange in interface DecompositionStore<Double>
    
    Specified by:
    
    sliceRange in interface MatrixStore<Double>
    
    Specified by:
    
    sliceRange in interface Access1D.Sliceable<Double>
  - sliceRow
```
public Array1D<Double> sliceRow(long row,
                                long col)
```
    Specified by:
    
    sliceRow in interface DecompositionStore<Double>
    
    Specified by:
    
    sliceRow in interface MatrixStore<Double>
    
    Specified by:
    
    sliceRow in interface Access2D.Sliceable<Double>
  - substituteBackwards
```
public void substituteBackwards(Access2D<Double> 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<Double>
    
    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<Double> 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<Double>
    
    Parameters:
    
    body - The equation system body parameters [A]
    
    unitDiagonal - true if body has ones on the diagonal
    
    conjugated - TODO
  - supplyTo
```
public void supplyTo(TransformableRegion<Double> receiver)
```
    Specified by:
    
    supplyTo in interface MatrixStore<Double>
    
    Specified by:
    
    supplyTo in interface Access2D.Collectable<Double,TransformableRegion<Double>>
  - toScalar
```
public PrimitiveScalar toScalar(long row,
                                long column)
```
    Specified by:
    
    toScalar in interface MatrixStore<Double>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class BasicArray<Double>
  - transformLeft
```
public void transformLeft(Householder<Double> transformation,
                          int firstColumn)
```
    Specified by:
    
    transformLeft in interface PhysicalStore<Double>
  - transformLeft
```
public void transformLeft(Rotation<Double> 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<Double>
    
    See Also:
    
    PhysicalStore.transformRight(Rotation)
  - transformRight
```
public void transformRight(Householder<Double> transformation,
                           int firstRow)
```
    Specified by:
    
    transformRight in interface PhysicalStore<Double>
  - transformRight
```
public void transformRight(Rotation<Double> 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<Double>
    
    See Also:
    
    PhysicalStore.transformLeft(Rotation)
  - transformSymmetric
```
public void transformSymmetric(Householder<Double> transformation)
```
    Specified by:
    
    transformSymmetric in interface DecompositionStore<Double>
  - transpose
```
public MatrixStore<Double> transpose()
```
    Specified by:
    
    transpose in interface ElementsSupplier<Double>
    
    Specified by:
    
    transpose in interface MatrixStore<Double>
    
    Specified by:
    
    transpose in interface Stream2D<Double,MatrixStore<Double>,TransformableRegion<Double>,ElementsSupplier<Double>>
    
    Returns:
    
    A transposed matrix instance.
  - tred2
```
public void tred2(BasicArray<Double> mainDiagonal,
                  BasicArray<Double> offDiagonal,
                  boolean yesvecs)
```
    Specified by:
    
    tred2 in interface DecompositionStore<Double>
  - visitColumn
```
public void visitColumn(long row,
                        long col,
                        VoidFunction<Double> visitor)
```
    Specified by:
    
    visitColumn in interface Access2D.Visitable<Double>
  - visitDiagonal
```
public void visitDiagonal(long row,
                          long col,
                          VoidFunction<Double> visitor)
```
    Specified by:
    
    visitDiagonal in interface Access2D.Visitable<Double>
  - visitRow
```
public void visitRow(long row,
                     long col,
                     VoidFunction<Double> visitor)
```
    Specified by:
    
    visitRow in interface Access2D.Visitable<Double>
  - 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 PrimitiveDenseStore

Nested Class Summary

Nested classes/interfaces inherited from class org.ojalgo.array.DenseArray

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

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.TransformableRegion

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

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

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

Field Summary

Fields inherited from class org.ojalgo.array.Primitive64Array

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.Primitive64Array

Methods inherited from class org.ojalgo.array.PrimitiveArray

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.PhysicalStore

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

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.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.IndexOf

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

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

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

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

Methods inherited from interface org.ojalgo.structure.Mutate2D

Methods inherited from interface org.ojalgo.structure.Mutate1D

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

Methods inherited from interface org.ojalgo.structure.Structure2D

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

Methods inherited from interface org.ojalgo.structure.Structure1D

Methods inherited from interface java.util.function.Consumer

Methods inherited from interface org.ojalgo.structure.Access2D

Methods inherited from interface org.ojalgo.structure.Access1D

Field Detail

FACTORY

Method Detail

getComplexArgument

getComplexImaginary

getComplexModulus

getComplexReal

accept

add

add

aggregateAll

applyCholesky

applyLDL

applyLU

asList

caxpy

computeInPlaceSchur

conjugate

copy

countColumns

countRows

divideAndCopyColumn

doubleValue

equals

exchangeColumns

exchangeHermitian

exchangeRows

fillByMultiplying

fillColumn

fillColumn

fillColumn