java.lang.Object
- org.ojalgo.array.BasicArray<N>
- - org.ojalgo.array.DenseArray<N>
  - - org.ojalgo.array.PlainArray<java.lang.Double>
    - - org.ojalgo.array.PrimitiveArray
      - org.ojalgo.array.ArrayR032
        
        org.ojalgo.matrix.store.R032Store

All Implemented Interfaces:

java.util.function.Consumer<Access2D<?>>, java.util.RandomAccess, Group, Group.Additive<MatrixStore<java.lang.Double>>, NormedVectorSpace<MatrixStore<java.lang.Double>,java.lang.Double>, Operation, Operation.Addition<MatrixStore<java.lang.Double>>, Operation.Multiplication<MatrixStore<java.lang.Double>>, Operation.Subtraction<MatrixStore<java.lang.Double>>, ScalarOperation, ScalarOperation.Addition<MatrixStore<java.lang.Double>,java.lang.Double>, ScalarOperation.Division<MatrixStore<java.lang.Double>,java.lang.Double>, ScalarOperation.Multiplication<MatrixStore<java.lang.Double>,java.lang.Double>, ScalarOperation.Subtraction<MatrixStore<java.lang.Double>,java.lang.Double>, VectorSpace<MatrixStore<java.lang.Double>,java.lang.Double>, Matrix2D<java.lang.Double,MatrixStore<java.lang.Double>>, ElementsSupplier<java.lang.Double>, MatrixStore<java.lang.Double>, PhysicalStore<java.lang.Double>, TransformableRegion<java.lang.Double>, Access1D<java.lang.Double>, Access1D.Aggregatable<java.lang.Double>, Access1D.Collectable<java.lang.Double,Mutate1D>, Access1D.Sliceable<java.lang.Double>, Access1D.Visitable<java.lang.Double>, Access2D<java.lang.Double>, Access2D.Aggregatable<java.lang.Double>, Access2D.Collectable<java.lang.Double,TransformableRegion<java.lang.Double>>, Access2D.Sliceable<java.lang.Double>, Access2D.Visitable<java.lang.Double>, Factory1D.Builder<DenseArray<java.lang.Double>>, Factory2D.Builder<R032Store>, Mutate1D, Mutate1D.Fillable<java.lang.Double>, Mutate1D.Modifiable<java.lang.Double>, Mutate1D.Sortable, Mutate2D, Mutate2D.Exchangeable, Mutate2D.Fillable<java.lang.Double>, Mutate2D.Modifiable<java.lang.Double>, Mutate2D.ModifiableReceiver<java.lang.Double>, Mutate2D.Receiver<java.lang.Double>, Operate2D<java.lang.Double,ElementsSupplier<java.lang.Double>>, Structure1D, Structure2D, Structure2D.Logical<Access2D<java.lang.Double>,MatrixStore<java.lang.Double>>, Structure2D.ReducibleTo1D<ElementsSupplier<java.lang.Double>>
```
public final class R032Store
extends ArrayR032
implements PhysicalStore<java.lang.Double>, Factory2D.Builder<R032Store>
```
A float implementation of PhysicalStore.

Nested Class Summary
- Nested classes/interfaces inherited from class org.ojalgo.array.PrimitiveArray
  PrimitiveArray.Factory
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Access1D
  Access1D.Aggregatable<N extends java.lang.Comparable<N>>, Access1D.Collectable<N extends java.lang.Comparable<N>,R extends Mutate1D>, Access1D.ElementView<N extends java.lang.Comparable<N>>, Access1D.SelectionView<N extends java.lang.Comparable<N>>, Access1D.Sliceable<N extends java.lang.Comparable<N>>, Access1D.Visitable<N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D
  Access2D.Aggregatable<N extends java.lang.Comparable<N>>, Access2D.Collectable<N extends java.lang.Comparable<N>,R extends Mutate2D>, Access2D.ColumnView<N extends java.lang.Comparable<N>>, Access2D.ElementView<N extends java.lang.Comparable<N>>, Access2D.RowView<N extends java.lang.Comparable<N>>, Access2D.SelectionView<N extends java.lang.Comparable<N>>, Access2D.Sliceable<N extends java.lang.Comparable<N>>, Access2D.Visitable<N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group
  Group.Additive<T>, Group.Multiplicative<T>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Mutate1D
  Mutate1D.Fillable<N extends java.lang.Comparable<N>>, Mutate1D.Mixable<N extends java.lang.Comparable<N>>, Mutate1D.Modifiable<N extends java.lang.Comparable<N>>, Mutate1D.ModifiableReceiver<N extends java.lang.Comparable<N>>, Mutate1D.Receiver<N extends java.lang.Comparable<N>>, Mutate1D.Sortable
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Mutate2D
  Mutate2D.Exchangeable, Mutate2D.Fillable<N extends java.lang.Comparable<N>>, Mutate2D.Mixable<N extends java.lang.Comparable<N>>, Mutate2D.Modifiable<N extends java.lang.Comparable<N>>, Mutate2D.ModifiableReceiver<N extends java.lang.Comparable<N>>, Mutate2D.Receiver<N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation
  Operation.Addition<T>, Operation.Division<T>, Operation.Multiplication<T>, Operation.Subtraction<T>
- Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.PhysicalStore
  PhysicalStore.Factory<N extends java.lang.Comparable<N>,I extends PhysicalStore<N> & Factory2D.Builder<I>>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation
  ScalarOperation.Addition<T,N extends java.lang.Comparable<N>>, ScalarOperation.Division<T,N extends java.lang.Comparable<N>>, ScalarOperation.Multiplication<T,N extends java.lang.Comparable<N>>, ScalarOperation.Subtraction<T,N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D
  Structure1D.BasicMapper<T>, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.Logical<S extends Structure1D,B extends Structure1D.Logical<S,B>>, Structure1D.LongIndex, Structure1D.LoopCallback
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D
  Structure2D.IntRowColumn, Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,B>>, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.Reshapable, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>
- Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.TransformableRegion
  TransformableRegion.FillByMultiplying<N extends java.lang.Comparable<N>>

Field Summary

Fields
Modifier and Type	Field	Description
`static PrimitiveFactory<R032Store>`	`FACTORY`
`private MultiplyBoth.Primitive`	`multiplyBoth`
`private MultiplyLeft.Primitive32`	`multiplyLeft`
`private MultiplyNeither.Primitive32`	`multiplyNeither`
`private MultiplyRight.Primitive32`	`multiplyRight`
`private int`	`myColDim`
`private int`	`myRowDim`
`private Array2D<java.lang.Double>`	`myUtility`
`private float[]`	`myWorkerColumn`

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

Fields inherited from class org.ojalgo.array.PlainArray
MAX_SIZE

Constructor Summary

Constructors
Constructor Description

R032Store(int numbRows, int numbCols, float[] dataArray)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`accept(Access2D<?> supplied)`
`void`	`add(long row, long col, double addend)`
`void`	`add(long row, long col, java.lang.Comparable<?> addend)`
`java.lang.Double`	`aggregateColumn(long row, long col, Aggregator aggregator)`
`java.lang.Double`	`aggregateColumn(long col, Aggregator aggregator)`
`java.lang.Double`	`aggregateDiagonal(long row, long col, Aggregator aggregator)`
`java.lang.Double`	`aggregateDiagonal(Aggregator aggregator)`
`java.lang.Double`	`aggregateRange(long first, long limit, Aggregator aggregator)`
`java.lang.Double`	`aggregateRow(long row, long col, Aggregator aggregator)`
`java.lang.Double`	`aggregateRow(long row, Aggregator aggregator)`
`<NN extends java.lang.Comparable<NN>,R extends Mutate2D.Receiver<NN>> Access2D.Collectable<NN,R>`	`asCollectable2D()`
`Array1D<java.lang.Double>`	`asList()`	An (immutable) `List` delegating to this `Access1D`.
`R032Store`	`build()`
`byte`	`byteValue(long row, long col)`
`(package private) static Householder.Primitive32`	`cast(Householder<java.lang.Double> transformation)`
`(package private) static Rotation.Primitive`	`cast(Rotation<java.lang.Double> transformation)`
`(package private) static R032Store`	`cast(Access1D<?> matrix)`
`Access2D.ColumnView<java.lang.Double>`	`columns()`
`MatrixStore<java.lang.Double>`	`conjugate()`	Returns the conjugate transpose of this matrix.
`long`	`countColumns()`	Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
`long`	`countRows()`	Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
`double`	`dot(Access1D<?> vector)`	Will calculate and return the dot product of this 1D-structure and another input 1D-vector.
`double`	`doubleValue(int row, int col)`	Extracts one element of this matrix as a double.
`ElementView2D<java.lang.Double,?>`	`elements()`	Returns an Iterable of ElementView1D.
`boolean`	`equals(java.lang.Object obj)`
`void`	`exchangeColumns(long colA, long colB)`
`void`	`exchangeRows(long rowA, long rowB)`
`void`	`fillByMultiplying(Access1D<java.lang.Double> left, Access1D<java.lang.Double> right)`
`void`	`fillColumn(long row, long col, java.lang.Double value)`
`void`	`fillColumn(long row, long col, NullaryFunction<?> supplier)`
`void`	`fillColumn(long row, long col, Access1D<java.lang.Double> values)`
`void`	`fillColumn(long col, java.lang.Double value)`
`void`	`fillColumn(long col, NullaryFunction<?> supplier)`
`void`	`fillColumn(long col, Access1D<java.lang.Double> values)`
`void`	`fillCompatible(Access2D<java.lang.Double> left, BinaryFunction<java.lang.Double> operator, Access2D<java.lang.Double> right)`	'this' needs to be of a size compatible with the 'left' and 'right' matrices.
`void`	`fillDiagonal(long row, long col, java.lang.Double value)`
`void`	`fillDiagonal(long row, long col, NullaryFunction<?> supplier)`
`void`	`fillDiagonal(long row, long col, Access1D<java.lang.Double> values)`
`void`	`fillDiagonal(java.lang.Double value)`
`void`	`fillDiagonal(NullaryFunction<?> supplier)`
`void`	`fillDiagonal(Access1D<java.lang.Double> values)`
`void`	`fillMatching(UnaryFunction<java.lang.Double> function, Access1D<java.lang.Double> arguments)`
`void`	`fillMatching(Access1D<java.lang.Double> left, BinaryFunction<java.lang.Double> function, Access1D<java.lang.Double> right)`
`void`	`fillRow(long row, long col, java.lang.Double value)`
`void`	`fillRow(long row, long col, NullaryFunction<?> supplier)`
`void`	`fillRow(long row, long col, Access1D<java.lang.Double> values)`
`void`	`fillRow(long row, java.lang.Double value)`
`void`	`fillRow(long row, NullaryFunction<?> supplier)`
`void`	`fillRow(long row, Access1D<java.lang.Double> values)`
`float`	`floatValue(long row, long col)`
`java.lang.Double`	`get(int row, int col)`
`int`	`getColDim()`
`int`	`getMaxDim()`
`int`	`getMinDim()`
`int`	`getRowDim()`
`private float[]`	`getWorkerColumn()`
`int`	`hashCode()`
`int`	`intValue(long row, long col)`
`boolean`	`isAcceptable(Structure2D supplier)`
`boolean`	`isEmpty()`	2D data structures are either square, tall, fat or empty.
`boolean`	`isFat()`	2D data structures are either square, tall, fat or empty.
`boolean`	`isScalar()`
`boolean`	`isSquare()`	2D data structures are either square, tall, fat or empty.
`boolean`	`isTall()`	2D data structures are either square, tall, fat or empty.
`boolean`	`isVector()`
`long`	`longValue(long row, long col)`
`void`	`modifyAll(UnaryFunction<java.lang.Double> modifier)`
`void`	`modifyAny(Transformation2D<java.lang.Double> modifier)`
`void`	`modifyColumn(long row, long col, UnaryFunction<java.lang.Double> modifier)`
`void`	`modifyColumn(long col, UnaryFunction<java.lang.Double> modifier)`
`void`	`modifyDiagonal(long row, long col, UnaryFunction<java.lang.Double> modifier)`
`void`	`modifyDiagonal(UnaryFunction<java.lang.Double> modifier)`
`void`	`modifyMatching(BinaryFunction<java.lang.Double> function, Access1D<java.lang.Double> right)`
`void`	`modifyMatching(Access1D<java.lang.Double> left, BinaryFunction<java.lang.Double> function)`
`void`	`modifyMatchingInColumns(BinaryFunction<java.lang.Double> function, Access1D<java.lang.Double> right)`	Same as `Mutate2D.Modifiable.modifyMatchingInColumns(Access1D, BinaryFunction)` but with the arguments to the modifier function swapped.
`void`	`modifyMatchingInColumns(Access1D<java.lang.Double> left, BinaryFunction<java.lang.Double> function)`	"Matching In Columns" refers to that the supplied, left, data structure will be treated as a column, matching the columns of this structure.
`void`	`modifyMatchingInRows(BinaryFunction<java.lang.Double> function, Access1D<java.lang.Double> right)`	Same as `Mutate2D.Modifiable.modifyMatchingInRows(Access1D, BinaryFunction)` but with the arguments to the modifier function swapped.
`void`	`modifyMatchingInRows(Access1D<java.lang.Double> left, BinaryFunction<java.lang.Double> function)`	Same as `Mutate2D.Modifiable.modifyMatchingInColumns(Access1D, BinaryFunction)` but now the supplied left data structure is treated as a row.
`void`	`modifyOne(long row, long col, UnaryFunction<java.lang.Double> modifier)`
`void`	`modifyRow(long row, long col, UnaryFunction<java.lang.Double> modifier)`
`void`	`modifyRow(long row, UnaryFunction<java.lang.Double> modifier)`
`MatrixStore<java.lang.Double>`	`multiply(MatrixStore<java.lang.Double> right)`
`java.lang.Double`	`multiplyBoth(Access1D<java.lang.Double> leftAndRight)`	Assumes [leftAndRight] is a vector and will calulate [leftAndRight]^H[this][leftAndRight]
`PhysicalStore.Factory<java.lang.Double,?>`	`physical()`
`void`	`reduceColumns(Aggregator aggregator, Mutate1D receiver)`
`void`	`reduceRows(Aggregator aggregator, Mutate1D receiver)`
`TransformableRegion<java.lang.Double>`	`regionByColumns(int... columns)`
`TransformableRegion<java.lang.Double>`	`regionByLimits(int rowLimit, int columnLimit)`
`TransformableRegion<java.lang.Double>`	`regionByOffsets(int rowOffset, int columnOffset)`
`TransformableRegion<java.lang.Double>`	`regionByRows(int... rows)`
`TransformableRegion<java.lang.Double>`	`regionByTransposing()`
`Access2D.RowView<java.lang.Double>`	`rows()`
`void`	`set(int row, int col, double value)`
`void`	`set(long row, long col, java.lang.Comparable<?> value)`
`short`	`shortValue(long row, long col)`
`Array1D<java.lang.Double>`	`sliceColumn(long col)`
`Array1D<java.lang.Double>`	`sliceColumn(long row, long col)`
`Access1D<java.lang.Double>`	`sliceDiagonal()`
`Array1D<java.lang.Double>`	`sliceDiagonal(long row, long col)`
`Array1D<java.lang.Double>`	`sliceRow(long row)`
`Array1D<java.lang.Double>`	`sliceRow(long row, long col)`
`void`	`substituteBackwards(Access2D<java.lang.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<java.lang.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
`double[]`	`toRawCopy1D()`
`double[][]`	`toRawCopy2D()`
`PrimitiveScalar`	`toScalar(int row, int col)`	Extracts one element of this matrix as a Scalar.
`java.lang.String`	`toString()`
`void`	`transformLeft(Householder<java.lang.Double> transformation, int firstColumn)`
`void`	`transformLeft(Rotation<java.lang.Double> transformation)`	As in `MatrixStore.premultiply(Access1D)` where the left/parameter matrix is a plane rotation.
`void`	`transformRight(Householder<java.lang.Double> transformation, int firstRow)`
`void`	`transformRight(Rotation<java.lang.Double> transformation)`	As in `MatrixStore.multiply(MatrixStore)` where the right/parameter matrix is a plane rotation.
`void`	`visitColumn(long row, long col, VoidFunction<java.lang.Double> visitor)`
`void`	`visitColumn(long col, VoidFunction<java.lang.Double> visitor)`
`void`	`visitDiagonal(long row, long col, VoidFunction<java.lang.Double> visitor)`
`void`	`visitDiagonal(VoidFunction<java.lang.Double> visitor)`
`void`	`visitOne(long row, long col, VoidFunction<java.lang.Double> visitor)`
`void`	`visitRow(long row, long col, VoidFunction<java.lang.Double> visitor)`
`void`	`visitRow(long row, VoidFunction<java.lang.Double> visitor)`
`static R032Store`	`wrap(float... data)`
`static R032Store`	`wrap(float[] data, int structure)`

Methods inherited from class org.ojalgo.array.ArrayR032
add, add, add, axpy, byteValue, copyOfData, doubleValue, exchange, fill, fill, fillMatching, fillOne, fillOne, fillOne, floatValue, get, indexOfLargest, intValue, isAbsolute, isSmall, make, modify, modify, modify, modifyOne, reset, searchAscending, set, set, set, set, shortValue, sortAscending, sortDescending, supplyTo, visit, visitOne

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

Methods inherited from class org.ojalgo.array.PlainArray
add, add, add, add, add, add, add, add, add, add, add, byteValue, count, doubleValue, exchange, fill, fill, fillAll, fillAll, fillRange, fillRange, floatValue, get, indexOfLargest, intValue, longValue, longValue, modify, modify, modify, modifyOne, set, set, set, set, set, set, set, set, set, set, shortValue, size, visit, visitOne

Methods inherited from class org.ojalgo.array.BasicArray
getMathType, indexOfLargest, isPrimitive, 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.structure.Access1D
asCollectable1D, asKeyed1D, axpy, select, supplyTo, toList

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

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

Methods inherited from interface org.ojalgo.structure.Access2D
asKeyed2D, byteValue, byteValue, byteValue, doubleValue, doubleValue, doubleValue, floatValue, floatValue, floatValue, get, intValue, intValue, intValue, longValue, longValue, longValue, nonzeros, shortValue, shortValue, shortValue

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

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

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

Methods inherited from interface org.ojalgo.matrix.store.ElementsSupplier
onAny, onColumns, onColumns, onMatching, onMatching, onRows, onRows

Methods inherited from interface org.ojalgo.matrix.Matrix2D
equals

Methods inherited from interface org.ojalgo.matrix.store.MatrixStore
above, above, above, add, add, add, aggregateAll, below, below, below, bidiagonal, column, column, columns, columns, copy, diagonal, diagonally, divide, divide, equals, get, get, hermitian, hessenberg, indexOfLargest, isHermitian, isNormal, isSmall, isSmall, left, left, left, limits, logical, multiply, multiply, multiply, negate, norm, offsets, onAll, operate, power, premultiply, reduceColumns, reduceRows, repeat, right, right, right, row, row, rows, rows, select, select, signum, sliceRange, subtract, subtract, subtract, superimpose, superimpose, supplyTo, symmetric, transpose, triangular, tridiagonal

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

Methods inherited from interface org.ojalgo.structure.Mutate1D.Fillable
fillAll, fillAll, fillCompatible, fillMatching, fillRange, fillRange

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

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

Methods inherited from interface org.ojalgo.structure.Mutate2D.Modifiable
add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, modifyOne

Methods inherited from interface org.ojalgo.structure.Mutate2D.ModifiableReceiver
modifyCompatible, modifyCompatible

Methods inherited from interface org.ojalgo.structure.Operate2D
onAll, onAll, onAll, onAll, onAll, onCompatible, onCompatible

Methods inherited from interface org.ojalgo.matrix.store.PhysicalStore
indexOfLargestInColumn, indexOfLargestInRow, indexOfLargestOnDiagonal, supplyTo

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Addition
add

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Division
divide

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Multiplication
multiply

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Subtraction
subtract

Methods inherited from interface org.ojalgo.structure.Structure2D
count, firstInColumn, firstInRow, limitOfColumn, limitOfRow, size

Methods inherited from interface org.ojalgo.matrix.store.TransformableRegion
synchronised

- Field Detail
  - FACTORY
```
public static final PrimitiveFactory<R032Store> FACTORY
```
  - multiplyBoth
```
private final MultiplyBoth.Primitive multiplyBoth
```
  - multiplyLeft
```
private final MultiplyLeft.Primitive32 multiplyLeft
```
  - multiplyNeither
```
private final MultiplyNeither.Primitive32 multiplyNeither
```
  - multiplyRight
```
private final MultiplyRight.Primitive32 multiplyRight
```
  - myColDim
```
private final int myColDim
```
  - myRowDim
```
private final int myRowDim
```
  - myUtility
```
private final Array2D<java.lang.Double> myUtility
```
  - myWorkerColumn
```
private transient float[] myWorkerColumn
```
- Constructor Detail
  - R032Store
```
R032Store(int numbRows,
          int numbCols,
          float[] dataArray)
```
- Method Detail
  - wrap
```
public static R032Store wrap(float... data)
```
  - wrap
```
public static R032Store wrap(float[] data,
                             int structure)
```
  - cast
```
static R032Store cast(Access1D<?> matrix)
```
  - cast
```
static Householder.Primitive32 cast(Householder<java.lang.Double> transformation)
```
  - cast
```
static Rotation.Primitive cast(Rotation<java.lang.Double> transformation)
```
  - accept
```
public void accept(Access2D<?> supplied)
```
    Specified by:
    
    accept in interface java.util.function.Consumer<Access2D<?>>
    
    Specified by:
    
    accept in interface Mutate2D.Receiver<java.lang.Double>
  - add
```
public void add(long row,
                long col,
                java.lang.Comparable<?> addend)
```
    Specified by:
    
    add in interface Mutate2D.Modifiable<java.lang.Double>
  - add
```
public void add(long row,
                long col,
                double addend)
```
    Specified by:
    
    add in interface Mutate2D.Modifiable<java.lang.Double>
  - aggregateColumn
```
public java.lang.Double aggregateColumn(long col,
                                        Aggregator aggregator)
```
    Specified by:
    
    aggregateColumn in interface Access2D.Aggregatable<java.lang.Double>
  - aggregateColumn
```
public java.lang.Double aggregateColumn(long row,
                                        long col,
                                        Aggregator aggregator)
```
    Specified by:
    
    aggregateColumn in interface Access2D.Aggregatable<java.lang.Double>
    
    Specified by:
    
    aggregateColumn in interface MatrixStore<java.lang.Double>
  - aggregateDiagonal
```
public java.lang.Double aggregateDiagonal(Aggregator aggregator)
```
    Specified by:
    
    aggregateDiagonal in interface Access2D.Aggregatable<java.lang.Double>
  - aggregateDiagonal
```
public java.lang.Double aggregateDiagonal(long row,
                                          long col,
                                          Aggregator aggregator)
```
    Specified by:
    
    aggregateDiagonal in interface Access2D.Aggregatable<java.lang.Double>
    
    Specified by:
    
    aggregateDiagonal in interface MatrixStore<java.lang.Double>
  - aggregateRange
```
public java.lang.Double aggregateRange(long first,
                                       long limit,
                                       Aggregator aggregator)
```
    Specified by:
    
    aggregateRange in interface Access1D.Aggregatable<java.lang.Double>
    
    Specified by:
    
    aggregateRange in interface MatrixStore<java.lang.Double>
    
    Overrides:
    
    aggregateRange in class BasicArray<java.lang.Double>
  - aggregateRow
```
public java.lang.Double aggregateRow(long row,
                                     Aggregator aggregator)
```
    Specified by:
    
    aggregateRow in interface Access2D.Aggregatable<java.lang.Double>
  - aggregateRow
```
public java.lang.Double aggregateRow(long row,
                                     long col,
                                     Aggregator aggregator)
```
    Specified by:
    
    aggregateRow in interface Access2D.Aggregatable<java.lang.Double>
    
    Specified by:
    
    aggregateRow in interface MatrixStore<java.lang.Double>
  - asCollectable2D
```
public <NN extends java.lang.Comparable<NN>,R extends Mutate2D.Receiver<NN>> Access2D.Collectable<NN,R> asCollectable2D()
```
    Specified by:
    
    asCollectable2D in interface Access2D<java.lang.Double>
  - asList
```
public Array1D<java.lang.Double> asList()
```
    Description copied from interface: Access1D
    
    An (immutable) List delegating to this Access1D.
    
    Specified by:
    
    asList in interface Access1D<java.lang.Double>
    
    Specified by:
    
    asList in interface PhysicalStore<java.lang.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.
    
    See Also:
    
    Access1D.toList()
  - build
```
public R032Store build()
```
    Specified by:
    
    build in interface Factory1D.Builder<DenseArray<java.lang.Double>>
    
    Specified by:
    
    build in interface Factory2D.Builder<R032Store>
    
    Overrides:
    
    build in class DenseArray<java.lang.Double>
  - byteValue
```
public byte byteValue(long row,
                      long col)
```
    Specified by:
    
    byteValue in interface Access2D<java.lang.Double>
  - columns
```
public Access2D.ColumnView<java.lang.Double> columns()
```
    Specified by:
    
    columns in interface Access2D<java.lang.Double>
  - conjugate
```
public MatrixStore<java.lang.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 MatrixStore<java.lang.Double>
    
    Specified by:
    
    conjugate in interface Structure2D.Logical<Access2D<java.lang.Double>,MatrixStore<java.lang.Double>>
    
    Specified by:
    
    conjugate in interface VectorSpace<MatrixStore<java.lang.Double>,java.lang.Double>
    
    See Also:
    
    VectorSpace.conjugate()
  - countColumns
```
public long countColumns()
```
    Description copied from interface: Structure2D
    
    Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
    
    Specified by:
    
    countColumns in interface Structure2D
    
    Returns:
    
    The number of columns
  - countRows
```
public long countRows()
```
    Description copied from interface: Structure2D
    
    Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
    
    Specified by:
    
    countRows in interface Structure2D
    
    Returns:
    
    The number of rows
  - dot
```
public double dot(Access1D<?> vector)
```
    Description copied from interface: Access1D
    
    Will calculate and return the dot product of this 1D-structure and another input 1D-vector.
    
    Specified by:
    
    dot in interface Access1D<java.lang.Double>
    
    Overrides:
    
    dot in class ArrayR032
    
    Parameters:
    
    vector - Another 1D-structure
    
    Returns:
    
    The dot product
  - doubleValue
```
public double doubleValue(int row,
                          int col)
```
    Description copied from interface: Access2D
    
    Extracts one element of this matrix as a double.
    
    Specified by:
    
    doubleValue in interface Access2D<java.lang.Double>
    
    Specified by:
    
    doubleValue in interface MatrixStore<java.lang.Double>
    
    Parameters:
    
    row - A row index.
    
    col - A column index.
    
    Returns:
    
    One matrix element
  - elements
```
public ElementView2D<java.lang.Double,?> elements()
```
    Description copied from interface: Access1D
    
    Returns an Iterable of ElementView1D. It allows to iterate over the instance's element "positions" without actually extracting the elements (unless you explicitly do so).
    
    Specified by:
    
    elements in interface Access1D<java.lang.Double>
    
    Specified by:
    
    elements in interface Access2D<java.lang.Double>
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class ArrayR032
  - exchangeColumns
```
public void exchangeColumns(long colA,
                            long colB)
```
    Specified by:
    
    exchangeColumns in interface Mutate2D.Exchangeable
    
    Specified by:
    
    exchangeColumns in interface TransformableRegion<java.lang.Double>
  - exchangeRows
```
public void exchangeRows(long rowA,
                         long rowB)
```
    Specified by:
    
    exchangeRows in interface Mutate2D.Exchangeable
    
    Specified by:
    
    exchangeRows in interface TransformableRegion<java.lang.Double>
  - fillByMultiplying
```
public void fillByMultiplying(Access1D<java.lang.Double> left,
                              Access1D<java.lang.Double> right)
```
    Specified by:
    
    fillByMultiplying in interface TransformableRegion<java.lang.Double>
  - fillColumn
```
public void fillColumn(long col,
                       Access1D<java.lang.Double> values)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<java.lang.Double>
  - fillColumn
```
public void fillColumn(long col,
                       java.lang.Double value)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<java.lang.Double>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       Access1D<java.lang.Double> values)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<java.lang.Double>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       java.lang.Double value)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<java.lang.Double>
  - fillColumn
```
public void fillColumn(long row,
                       long col,
                       NullaryFunction<?> supplier)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<java.lang.Double>
  - fillColumn
```
public void fillColumn(long col,
                       NullaryFunction<?> supplier)
```
    Specified by:
    
    fillColumn in interface Mutate2D.Fillable<java.lang.Double>
  - fillCompatible
```
public void fillCompatible(Access2D<java.lang.Double> left,
                           BinaryFunction<java.lang.Double> operator,
                           Access2D<java.lang.Double> right)
```
    Description copied from interface: Mutate2D.Fillable
    
    'this' needs to be of a size compatible with the 'left' and 'right' matrices. No checks are performed. The term "compatible" refers to MATLAB's rules for "array broadcasting". The result will be the same as if the 'left' and 'right' matrices where expanded (repeated) so that all three where of the same size, and then the operation was performed. The actual implementation may be more efficient than that.
    
    Specified by:
    
    fillCompatible in interface Mutate2D.Fillable<java.lang.Double>
  - fillDiagonal
```
public void fillDiagonal(Access1D<java.lang.Double> values)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<java.lang.Double>
  - fillDiagonal
```
public void fillDiagonal(java.lang.Double value)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<java.lang.Double>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long col,
                         Access1D<java.lang.Double> values)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<java.lang.Double>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long col,
                         java.lang.Double value)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<java.lang.Double>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long col,
                         NullaryFunction<?> supplier)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<java.lang.Double>
  - fillDiagonal
```
public void fillDiagonal(NullaryFunction<?> supplier)
```
    Specified by:
    
    fillDiagonal in interface Mutate2D.Fillable<java.lang.Double>
  - fillMatching
```
public void fillMatching(Access1D<java.lang.Double> left,
                         BinaryFunction<java.lang.Double> function,
                         Access1D<java.lang.Double> right)
```
    Specified by:
    
    fillMatching in interface Mutate1D.Fillable<java.lang.Double>
    
    Overrides:
    
    fillMatching in class ArrayR032
  - fillMatching
```
public void fillMatching(UnaryFunction<java.lang.Double> function,
                         Access1D<java.lang.Double> arguments)
```
    Specified by:
    
    fillMatching in interface Mutate1D.Fillable<java.lang.Double>
    
    Overrides:
    
    fillMatching in class ArrayR032
  - fillRow
```
public void fillRow(long row,
                    Access1D<java.lang.Double> values)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<java.lang.Double>
  - fillRow
```
public void fillRow(long row,
                    java.lang.Double value)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<java.lang.Double>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    Access1D<java.lang.Double> values)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<java.lang.Double>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    java.lang.Double value)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<java.lang.Double>
  - fillRow
```
public void fillRow(long row,
                    long col,
                    NullaryFunction<?> supplier)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<java.lang.Double>
  - fillRow
```
public void fillRow(long row,
                    NullaryFunction<?> supplier)
```
    Specified by:
    
    fillRow in interface Mutate2D.Fillable<java.lang.Double>
  - floatValue
```
public float floatValue(long row,
                        long col)
```
    Specified by:
    
    floatValue in interface Access2D<java.lang.Double>
  - get
```
public java.lang.Double get(int row,
                            int col)
```
    Specified by:
    
    get in interface MatrixStore<java.lang.Double>
  - getColDim
```
public int getColDim()
```
    Specified by:
    
    getColDim in interface Structure2D
    
    Returns:
    
    The number of columns
  - getMaxDim
```
public int getMaxDim()
```
    Specified by:
    
    getMaxDim in interface Structure2D
  - getMinDim
```
public int getMinDim()
```
    Specified by:
    
    getMinDim in interface Structure2D
  - getRowDim
```
public int getRowDim()
```
    Specified by:
    
    getRowDim in interface Structure2D
    
    Returns:
    
    The number of rows
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class ArrayR032
  - intValue
```
public int intValue(long row,
                    long col)
```
    Specified by:
    
    intValue in interface Access2D<java.lang.Double>
  - isAcceptable
```
public boolean isAcceptable(Structure2D supplier)
```
    Specified by:
    
    isAcceptable in interface Mutate2D.Receiver<java.lang.Double>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: Structure2D
    
    2D data structures are either square, tall, fat or empty.
    m <= 0 or n <= 0
    Historically some ojAlgo data structures did allow to create "empty" instances. Currently this is not encouraged, but still possible in some instances.
    
    Specified by:
    
    isEmpty in interface Structure2D
    
    Returns:
    
    true if matrix is empty
  - isFat
```
public boolean isFat()
```
    Description copied from interface: Structure2D
    
    2D data structures are either square, tall, fat or empty.
    1 <= m < n
    
    Specified by:
    
    isFat in interface Structure2D
    
    Returns:
    
    true if matrix is fat
  - isScalar
```
public boolean isScalar()
```
    Specified by:
    
    isScalar in interface Structure2D
    
    Returns:
    
    true if both the row and column dimensions are equal to 1.
  - isSquare
```
public boolean isSquare()
```
    Description copied from interface: Structure2D
    
    2D data structures are either square, tall, fat or empty.
    m = n <> 0
    
    Specified by:
    
    isSquare in interface Structure2D
    
    Returns:
    
    true if matrix is square
  - isTall
```
public boolean isTall()
```
    Description copied from interface: Structure2D
    
    2D data structures are either square, tall, fat or empty.
    m < n >= 1
    
    Specified by:
    
    isTall in interface Structure2D
    
    Returns:
    
    true if matrix is tall
  - isVector
```
public boolean isVector()
```
    Specified by:
    
    isVector in interface Structure2D
    
    Returns:
    
    true if either the row or column dimensions are equal to 1.
  - longValue
```
public long longValue(long row,
                      long col)
```
    Specified by:
    
    longValue in interface Access2D<java.lang.Double>
  - modifyAll
```
public void modifyAll(UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyAll in interface Mutate1D.Modifiable<java.lang.Double>
    
    Overrides:
    
    modifyAll in class BasicArray<java.lang.Double>
  - modifyAny
```
public void modifyAny(Transformation2D<java.lang.Double> modifier)
```
    Specified by:
    
    modifyAny in interface Mutate2D.ModifiableReceiver<java.lang.Double>
    
    Specified by:
    
    modifyAny in interface PhysicalStore<java.lang.Double>
    
    Specified by:
    
    modifyAny in interface TransformableRegion<java.lang.Double>
  - modifyColumn
```
public void modifyColumn(long row,
                         long col,
                         UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyColumn in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyColumn
```
public void modifyColumn(long col,
                         UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyColumn in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyDiagonal
```
public void modifyDiagonal(long row,
                           long col,
                           UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyDiagonal in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyDiagonal
```
public void modifyDiagonal(UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyDiagonal in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyMatching
```
public void modifyMatching(Access1D<java.lang.Double> left,
                           BinaryFunction<java.lang.Double> function)
```
    Specified by:
    
    modifyMatching in interface Mutate1D.Modifiable<java.lang.Double>
    
    Overrides:
    
    modifyMatching in class BasicArray<java.lang.Double>
  - modifyMatching
```
public void modifyMatching(BinaryFunction<java.lang.Double> function,
                           Access1D<java.lang.Double> right)
```
    Specified by:
    
    modifyMatching in interface Mutate1D.Modifiable<java.lang.Double>
    
    Overrides:
    
    modifyMatching in class BasicArray<java.lang.Double>
  - modifyMatchingInColumns
```
public void modifyMatchingInColumns(Access1D<java.lang.Double> left,
                                    BinaryFunction<java.lang.Double> function)
```
    Description copied from interface: Mutate2D.Modifiable
    
    "Matching In Columns" refers to that the supplied, left, data structure will be treated as a column, matching the columns of this structure. Matching columns have the same number of rows.
    This method will modify all elements of this structure by applying the modifier function to each of them. The left/first argument to the modifier function is taken from the supplied data structure, and the row-index determines which element.
    
    Specified by:
    
    modifyMatchingInColumns in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyMatchingInColumns
```
public void modifyMatchingInColumns(BinaryFunction<java.lang.Double> function,
                                    Access1D<java.lang.Double> right)
```
    Description copied from interface: Mutate2D.Modifiable
    
    Same as Mutate2D.Modifiable.modifyMatchingInColumns(Access1D, BinaryFunction) but with the arguments to the modifier function swapped.
    
    Specified by:
    
    modifyMatchingInColumns in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyMatchingInRows
```
public void modifyMatchingInRows(Access1D<java.lang.Double> left,
                                 BinaryFunction<java.lang.Double> function)
```
    Description copied from interface: Mutate2D.Modifiable
    
    Same as Mutate2D.Modifiable.modifyMatchingInColumns(Access1D, BinaryFunction) but now the supplied left data structure is treated as a row. (Matching rows have the same number of columns.)
    
    Specified by:
    
    modifyMatchingInRows in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyMatchingInRows
```
public void modifyMatchingInRows(BinaryFunction<java.lang.Double> function,
                                 Access1D<java.lang.Double> right)
```
    Description copied from interface: Mutate2D.Modifiable
    
    Same as Mutate2D.Modifiable.modifyMatchingInRows(Access1D, BinaryFunction) but with the arguments to the modifier function swapped.
    
    Specified by:
    
    modifyMatchingInRows in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyOne
```
public void modifyOne(long row,
                      long col,
                      UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyOne in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyRow
```
public void modifyRow(long row,
                      long col,
                      UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyRow in interface Mutate2D.Modifiable<java.lang.Double>
  - modifyRow
```
public void modifyRow(long row,
                      UnaryFunction<java.lang.Double> modifier)
```
    Specified by:
    
    modifyRow in interface Mutate2D.Modifiable<java.lang.Double>
  - multiply
```
public MatrixStore<java.lang.Double> multiply(MatrixStore<java.lang.Double> right)
```
    Specified by:
    
    multiply in interface MatrixStore<java.lang.Double>
    
    Specified by:
    
    multiply in interface Operation.Multiplication<MatrixStore<java.lang.Double>>
    
    Parameters:
    
    right - The multiplicand
    
    Returns:
    
    this * multiplicand.
  - multiplyBoth
```
public java.lang.Double multiplyBoth(Access1D<java.lang.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<java.lang.Double>
    
    Parameters:
    
    leftAndRight - The argument vector
    
    Returns:
    
    A scalar (extracted from the resulting 1 x 1 matrix)
  - physical
```
public PhysicalStore.Factory<java.lang.Double,?> physical()
```
    Specified by:
    
    physical in interface MatrixStore<java.lang.Double>
  - reduceColumns
```
public void reduceColumns(Aggregator aggregator,
                          Mutate1D receiver)
```
    Specified by:
    
    reduceColumns in interface Access2D.Aggregatable<java.lang.Double>
  - reduceRows
```
public void reduceRows(Aggregator aggregator,
                       Mutate1D receiver)
```
    Specified by:
    
    reduceRows in interface Access2D.Aggregatable<java.lang.Double>
  - regionByColumns
```
public TransformableRegion<java.lang.Double> regionByColumns(int... columns)
```
    Specified by:
    
    regionByColumns in interface TransformableRegion<java.lang.Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByLimits
```
public TransformableRegion<java.lang.Double> regionByLimits(int rowLimit,
                                                            int columnLimit)
```
    Specified by:
    
    regionByLimits in interface TransformableRegion<java.lang.Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByOffsets
```
public TransformableRegion<java.lang.Double> regionByOffsets(int rowOffset,
                                                             int columnOffset)
```
    Specified by:
    
    regionByOffsets in interface TransformableRegion<java.lang.Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByRows
```
public TransformableRegion<java.lang.Double> regionByRows(int... rows)
```
    Specified by:
    
    regionByRows in interface TransformableRegion<java.lang.Double>
    
    Returns:
    
    A consumer (sub)region
  - regionByTransposing
```
public TransformableRegion<java.lang.Double> regionByTransposing()
```
    Specified by:
    
    regionByTransposing in interface TransformableRegion<java.lang.Double>
    
    Returns:
    
    A transposed consumer region
  - rows
```
public Access2D.RowView<java.lang.Double> rows()
```
    Specified by:
    
    rows in interface Access2D<java.lang.Double>
  - set
```
public void set(int row,
                int col,
                double value)
```
    Specified by:
    
    set in interface Mutate2D
  - set
```
public void set(long row,
                long col,
                java.lang.Comparable<?> value)
```
    Specified by:
    
    set in interface Mutate2D
  - shortValue
```
public short shortValue(long row,
                        long col)
```
    Specified by:
    
    shortValue in interface Access2D<java.lang.Double>
  - sliceColumn
```
public Array1D<java.lang.Double> sliceColumn(long col)
```
    Specified by:
    
    sliceColumn in interface Access2D.Sliceable<java.lang.Double>
  - sliceColumn
```
public Array1D<java.lang.Double> sliceColumn(long row,
                                             long col)
```
    Specified by:
    
    sliceColumn in interface Access2D.Sliceable<java.lang.Double>
    
    Specified by:
    
    sliceColumn in interface MatrixStore<java.lang.Double>
  - sliceDiagonal
```
public Access1D<java.lang.Double> sliceDiagonal()
```
    Specified by:
    
    sliceDiagonal in interface Access2D.Sliceable<java.lang.Double>
  - sliceDiagonal
```
public Array1D<java.lang.Double> sliceDiagonal(long row,
                                               long col)
```
    Specified by:
    
    sliceDiagonal in interface Access2D.Sliceable<java.lang.Double>
    
    Specified by:
    
    sliceDiagonal in interface MatrixStore<java.lang.Double>
  - sliceRow
```
public Array1D<java.lang.Double> sliceRow(long row)
```
    Specified by:
    
    sliceRow in interface Access2D.Sliceable<java.lang.Double>
  - sliceRow
```
public Array1D<java.lang.Double> sliceRow(long row,
                                          long col)
```
    Specified by:
    
    sliceRow in interface Access2D.Sliceable<java.lang.Double>
    
    Specified by:
    
    sliceRow in interface MatrixStore<java.lang.Double>
  - substituteBackwards
```
public void substituteBackwards(Access2D<java.lang.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<java.lang.Double>
    
    See Also:
    
    SubstituteBackwards.invoke(double[], int, int, int, Access2D, boolean, boolean, boolean)
  - substituteForwards
```
public void substituteForwards(Access2D<java.lang.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<java.lang.Double>
    
    See Also:
    
    SubstituteForwards.invoke(double[], int, int, int, Access2D, boolean, boolean, boolean)
  - toRawCopy1D
```
public double[] toRawCopy1D()
```
    Specified by:
    
    toRawCopy1D in interface Access1D<java.lang.Double>
  - toRawCopy2D
```
public double[][] toRawCopy2D()
```
    Specified by:
    
    toRawCopy2D in interface Access2D<java.lang.Double>
  - toScalar
```
public PrimitiveScalar toScalar(int row,
                                int col)
```
    Description copied from interface: Matrix2D
    
    Extracts one element of this matrix as a Scalar.
    
    Specified by:
    
    toScalar in interface Matrix2D<java.lang.Double,MatrixStore<java.lang.Double>>
    
    Specified by:
    
    toScalar in interface MatrixStore<java.lang.Double>
    
    Parameters:
    
    row - A row index.
    
    col - A column index.
    
    Returns:
    
    One matrix element as a Scalar.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class BasicArray<java.lang.Double>
  - transformLeft
```
public void transformLeft(Householder<java.lang.Double> transformation,
                          int firstColumn)
```
    Specified by:
    
    transformLeft in interface PhysicalStore<java.lang.Double>
  - transformLeft
```
public void transformLeft(Rotation<java.lang.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<java.lang.Double>
    
    See Also:
    
    PhysicalStore.transformRight(Rotation)
  - transformRight
```
public void transformRight(Householder<java.lang.Double> transformation,
                           int firstRow)
```
    Specified by:
    
    transformRight in interface PhysicalStore<java.lang.Double>
  - transformRight
```
public void transformRight(Rotation<java.lang.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<java.lang.Double>
    
    See Also:
    
    PhysicalStore.transformLeft(Rotation)
  - visitColumn
```
public void visitColumn(long row,
                        long col,
                        VoidFunction<java.lang.Double> visitor)
```
    Specified by:
    
    visitColumn in interface Access2D.Visitable<java.lang.Double>
  - visitColumn
```
public void visitColumn(long col,
                        VoidFunction<java.lang.Double> visitor)
```
    Specified by:
    
    visitColumn in interface Access2D.Visitable<java.lang.Double>
  - visitDiagonal
```
public void visitDiagonal(long row,
                          long col,
                          VoidFunction<java.lang.Double> visitor)
```
    Specified by:
    
    visitDiagonal in interface Access2D.Visitable<java.lang.Double>
  - visitDiagonal
```
public void visitDiagonal(VoidFunction<java.lang.Double> visitor)
```
    Specified by:
    
    visitDiagonal in interface Access2D.Visitable<java.lang.Double>
  - visitOne
```
public void visitOne(long row,
                     long col,
                     VoidFunction<java.lang.Double> visitor)
```
    Specified by:
    
    visitOne in interface Access2D.Visitable<java.lang.Double>
    
    Specified by:
    
    visitOne in interface MatrixStore<java.lang.Double>
  - visitRow
```
public void visitRow(long row,
                     long col,
                     VoidFunction<java.lang.Double> visitor)
```
    Specified by:
    
    visitRow in interface Access2D.Visitable<java.lang.Double>
  - visitRow
```
public void visitRow(long row,
                     VoidFunction<java.lang.Double> visitor)
```
    Specified by:
    
    visitRow in interface Access2D.Visitable<java.lang.Double>
  - getWorkerColumn
```
private float[] getWorkerColumn()
```

Class R032Store

Nested Class Summary

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

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

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

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

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

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

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

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

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

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

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

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

Field Summary

Fields inherited from class org.ojalgo.array.ArrayR032

Fields inherited from class org.ojalgo.array.PlainArray

Constructor Summary

Method Summary

Methods inherited from class org.ojalgo.array.ArrayR032

Methods inherited from class org.ojalgo.array.PrimitiveArray

Methods inherited from class org.ojalgo.array.PlainArray

Methods inherited from class org.ojalgo.array.BasicArray

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.structure.Access1D

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

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

Methods inherited from interface org.ojalgo.structure.Access2D

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

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

Methods inherited from interface java.util.function.Consumer

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

Methods inherited from interface org.ojalgo.matrix.Matrix2D

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

Methods inherited from interface org.ojalgo.structure.Mutate1D

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

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

Methods inherited from interface org.ojalgo.structure.Mutate2D

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

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

Methods inherited from interface org.ojalgo.structure.Operate2D

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

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Addition

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Division

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Multiplication

Methods inherited from interface org.ojalgo.algebra.ScalarOperation.Subtraction

Methods inherited from interface org.ojalgo.structure.Structure2D

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

Field Detail

FACTORY

multiplyBoth

multiplyLeft

multiplyNeither

multiplyRight

myColDim

myRowDim

myUtility

myWorkerColumn

Constructor Detail

R032Store

Method Detail

wrap

wrap

cast

cast

cast

accept

add

add

aggregateColumn

aggregateColumn

aggregateDiagonal

aggregateDiagonal

aggregateRange

aggregateRow

aggregateRow

asCollectable2D

asList

build

byteValue