Module ojalgo

Package org.ojalgo.matrix.store

Class RawStore

java.lang.Object

org.ojalgo.matrix.store.RawStore

All Implemented Interfaces:

Consumer<Access2D<?>>, Group, Group.Additive<MatrixStore<Double>>, NormedVectorSpace<MatrixStore<Double>,Double>, Operation, Operation.Addition<MatrixStore<Double>>, Operation.Multiplication<MatrixStore<Double>>, Operation.Subtraction<MatrixStore<Double>>, ScalarOperation, ScalarOperation.Addition<MatrixStore<Double>,Double>, ScalarOperation.Division<MatrixStore<Double>,Double>, ScalarOperation.Multiplication<MatrixStore<Double>,Double>, ScalarOperation.Subtraction<MatrixStore<Double>,Double>, VectorSpace<MatrixStore<Double>,Double>, Matrix2D<Double,MatrixStore<Double>>, ElementsSupplier<Double>, MatrixStore<Double>, PhysicalStore<Double>, TransformableRegion<Double>, Access1D<Double>, Access1D.Aggregatable<Double>, Access1D.Collectable<Double,Mutate1D>, Access1D.Sliceable<Double>, Access1D.Visitable<Double>, Access2D<Double>, Access2D.Aggregatable<Double>, Access2D.Collectable<Double,TransformableRegion<Double>>, Access2D.Sliceable<Double>, Access2D.Visitable<Double>, Factory2D.Builder<RawStore>, Mutate1D, Mutate1D.Fillable<Double>, Mutate1D.Modifiable<Double>, Mutate2D, Mutate2D.Exchangeable, Mutate2D.Fillable<Double>, Mutate2D.Modifiable<Double>, Mutate2D.ModifiableReceiver<Double>, Mutate2D.Receiver<Double>, Operate2D<Double,ElementsSupplier<Double>>, Structure1D, Structure2D, Structure2D.Logical<Access2D<Double>,MatrixStore<Double>>, Structure2D.ReducibleTo1D<ElementsSupplier<Double>>

public final class RawStore
extends Object
implements PhysicalStore<Double>, Factory2D.Builder<RawStore>

Uses double[][] internally.

Nested Class Summary

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

Access2D.Aggregatable<N extends Comparable<N>>, Access2D.Collectable<N extends Comparable<N>,R extends Mutate2D>, Access2D.ColumnView<N extends Comparable<N>>, Access2D.ElementView<N extends Comparable<N>>, Access2D.RowView<N extends Comparable<N>>, Access2D.SelectionView<N extends Comparable<N>>, Access2D.Sliceable<N extends Comparable<N>>, Access2D.Visitable<N extends 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 Comparable<N>>, Mutate1D.Mixable<N extends Comparable<N>>, Mutate1D.Modifiable<N extends Comparable<N>>, Mutate1D.ModifiableReceiver<N extends Comparable<N>>, Mutate1D.Receiver<N extends Comparable<N>>, Mutate1D.Sortable

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

Mutate2D.Exchangeable, Mutate2D.Fillable<N extends Comparable<N>>, Mutate2D.Mixable<N extends Comparable<N>>, Mutate2D.Modifiable<N extends Comparable<N>>, Mutate2D.ModifiableReceiver<N extends Comparable<N>>, Mutate2D.Receiver<N extends 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 Comparable<N>,I extends PhysicalStore<N> & Factory2D.Builder<I>>

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

ScalarOperation.Addition<T,N extends Comparable<N>>, ScalarOperation.Division<T,N extends Comparable<N>>, ScalarOperation.Multiplication<T,N extends Comparable<N>>, ScalarOperation.Subtraction<T,N extends 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 Comparable<N>>

Field Summary

Fields

Modifier and Type	Field	Description
final double[][]	data
static final PrimitiveFactory<RawStore>	FACTORY
private final int	myNumberOfColumns

Constructor Summary

Constructors

Constructor	Description
RawStore(double[][] elements, int numberOfColumns)
RawStore(int m, int n)	Construct an m-by-n matrix of zeros.

Method Summary

Modifier and Type	Method	Description
void	accept(Access2D<?> supplied)
void	add(long row, long col, double addend)
void	add(long row, long col, Comparable<?> addend)
Double	aggregateAll(Aggregator aggregator)
List<Double>	asList()	An (immutable) List delegating to this Access1D.
RawStore	build()
(package private) static Rotation.Primitive	cast(Rotation<Double> aTransf)
MatrixStore<Double>	conjugate()	Returns the conjugate transpose of this matrix.
private static RawStore	convert(Access1D<?> elements, int structure)
RawStore	copy()	Make a deep copy of a matrix
long	count()	count() == countRows() * countColumns()
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	doubleValue(int row, int col)	Extracts one element of this matrix as a double.
boolean	equals(Object obj)
void	exchangeColumns(long colA, long colB)
void	exchangeRows(long rowA, long rowB)
private static double[][]	extract(Access1D<?> elements, int nbRows)
void	fillAll(Double value)
void	fillAll(NullaryFunction<?> supplier)
void	fillByMultiplying(Access1D<Double> left, Access1D<Double> right)
void	fillColumn(long row, long col, Double value)
void	fillColumn(long row, long col, NullaryFunction<?> supplier)
void	fillCompatible(Access2D<Double> left, BinaryFunction<Double> operator, Access2D<Double> right)	'this' needs to be of a size compatible with the 'left' and 'right' matrices.
void	fillDiagonal(long row, long col, Double value)
void	fillDiagonal(long row, long col, NullaryFunction<?> supplier)
void	fillMatching(Access1D<?> source)	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	fillRange(long first, long limit, Double value)
void	fillRange(long first, long limit, NullaryFunction<?> supplier)
void	fillRow(long row, long col, Double value)
void	fillRow(long row, long col, NullaryFunction<?> supplier)
MatrixStore<Double>	get()
Double	get(int row, int col)
int	getColDim()
int	getRowDim()
int	hashCode()
long	indexOfLargest()
boolean	isSmall(long row, long col, double comparedTo)
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(BinaryFunction<Double> function, Access1D<Double> right)
void	modifyMatching(Access1D<Double> left, BinaryFunction<Double> function)
void	modifyOne(long row, long col, UnaryFunction<Double> modifier)
void	modifyRange(long first, long limit, UnaryFunction<Double> modifier)
void	modifyRow(long row, long col, UnaryFunction<Double> modifier)
RawStore	multiply(MatrixStore<Double> right)
Double	multiplyBoth(Access1D<Double> leftAndRight)	Assumes [leftAndRight] is a vector and will calulate [leftAndRight]H[this][leftAndRight]
PhysicalStore.Factory<Double,RawStore>	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	reset()	Reset this mutable structure to some standard (all zeros) initial state.
void	set(int row, int col, double value)
void	set(long row, long col, Comparable<?> value)
Access1D<Double>	sliceRow(long row)
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)
void	supplyTo(Mutate1D receiver)
PrimitiveScalar	toScalar(int row, int col)	Extracts one element of this matrix as a Scalar.
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	visitAll(VoidFunction<Double> visitor)
void	visitColumn(long row, long col, VoidFunction<Double> visitor)
void	visitDiagonal(long row, long col, VoidFunction<Double> visitor)
void	visitRange(long first, long limit, VoidFunction<Double> visitor)
void	visitRow(long row, long col, VoidFunction<Double> visitor)
static RawStore	wrap(double... data)	Will create a single row matrix with the supplied array as the inner array.
static RawStore	wrap(double[][] data)

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, dot, select, supplyTo, toList, toRawCopy1D

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

collect

Methods inherited from interface org.ojalgo.structure.Access2D

asCollectable2D, asKeyed2D, byteValue, byteValue, byteValue, byteValue, columns, doubleValue, doubleValue, doubleValue, elements, floatValue, floatValue, floatValue, floatValue, get, intValue, intValue, intValue, intValue, longValue, longValue, longValue, longValue, nonzeros, rows, shortValue, shortValue, shortValue, shortValue, toRawCopy2D

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

aggregateColumn, aggregateDiagonal, aggregateRow, reduceColumns, reduceRows

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

collect

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

sliceColumn, sliceDiagonal

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

visitColumn, visitDiagonal, visitOne, visitRow

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, aggregateColumn, aggregateDiagonal, aggregateRange, aggregateRow, below, below, below, bidiagonal, column, column, columns, columns, diagonal, diagonally, divide, divide, equals, get, hermitian, hessenberg, isHermitian, isNormal, 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, sliceColumn, sliceDiagonal, sliceRange, sliceRow, subtract, subtract, subtract, superimpose, superimpose, symmetric, transpose, triangular, tridiagonal, visitOne

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

fillCompatible, fillMatching

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

fillColumn, fillColumn, fillColumn, fillColumn, fillDiagonal, fillDiagonal, fillDiagonal, fillDiagonal, fillRow, fillRow, fillRow, fillRow

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, modifyColumn, modifyDiagonal, modifyMatchingInColumns, modifyMatchingInColumns, modifyMatchingInRows, modifyMatchingInRows, modifyOne, modifyRow

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

modifyCompatible, modifyCompatible

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

isAcceptable

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, modifyAny

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

firstInColumn, firstInRow, getMaxDim, getMinDim, isEmpty, isFat, isScalar, isSquare, isTall, isVector, limitOfColumn, limitOfRow, size

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

synchronised

Field Details

FACTORY

public static final PrimitiveFactory<RawStore> FACTORY

data

public final double[][] data

myNumberOfColumns

private final int myNumberOfColumns

Constructor Details

RawStore

RawStore(double[][] elements,
 int numberOfColumns)

RawStore

RawStore(int m,
 int n)

Construct an m-by-n matrix of zeros.

Parameters:

m - Number of rows.

n - Number of colums.

Method Details

wrap

public static RawStore wrap(double... data)

Will create a single row matrix with the supplied array as the inner array. You access it using data[0].

wrap

public static RawStore wrap(double[][] data)

convert

private static RawStore convert(Access1D<?> elements,
 int structure)

extract

private static double[][] extract(Access1D<?> elements,
 int nbRows)

cast

static Rotation.Primitive cast(Rotation<Double> aTransf)

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,
 Comparable<?> addend)

Specified by:

add in interface Mutate2D.Modifiable<Double>

add

public void add(long row,
 long col,
 double addend)

Specified by:

add in interface Mutate2D.Modifiable<Double>

aggregateAll

public Double aggregateAll(Aggregator aggregator)

Specified by:

aggregateAll in interface Access1D.Aggregatable<Double>

Specified by:

aggregateAll in interface MatrixStore<Double>

asList

public List<Double> asList()

Description copied from interface: Access1D

An (immutable) List delegating to this Access1D.

Specified by:

asList in interface Access1D<Double>

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.

See Also:

• Access1D.toList()

build

public RawStore build()

Specified by:

build in interface Factory2D.Builder<RawStore>

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 MatrixStore<Double>

Specified by:

conjugate in interface Structure2D.Logical<Access2D<Double>,MatrixStore<Double>>

Specified by:

conjugate in interface VectorSpace<MatrixStore<Double>,Double>

See Also:

• VectorSpace.conjugate()

copy

public RawStore copy()

Make a deep copy of a matrix

Specified by:

copy in interface MatrixStore<Double>

Returns:

A new PhysicalStore copy.

count

public long count()

Description copied from interface: Structure2D

count() == countRows() * countColumns()

Specified by:

count in interface Structure1D

Specified by:

count in interface Structure2D

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

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<Double>

Specified by:

doubleValue in interface MatrixStore<Double>

Parameters:

row - A row index.

col - A column index.

Returns:

One matrix element

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

exchangeColumns

public void exchangeColumns(long colA,
 long colB)

Specified by:

exchangeColumns in interface Mutate2D.Exchangeable

Specified by:

exchangeColumns in interface TransformableRegion<Double>

exchangeRows

public void exchangeRows(long rowA,
 long rowB)

Specified by:

exchangeRows in interface Mutate2D.Exchangeable

Specified by:

exchangeRows in interface TransformableRegion<Double>

fillAll

public void fillAll(Double value)

Specified by:

fillAll in interface Mutate1D.Fillable<Double>

fillAll

public void fillAll(NullaryFunction<?> supplier)

Specified by:

fillAll in interface Mutate1D.Fillable<Double>

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,
 Double value)

Specified by:

fillColumn in interface Mutate2D.Fillable<Double>

fillColumn

public void fillColumn(long row,
 long col,
 NullaryFunction<?> supplier)

Specified by:

fillColumn in interface Mutate2D.Fillable<Double>

fillCompatible

public void fillCompatible(Access2D<Double> left,
 BinaryFunction<Double> operator,
 Access2D<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<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<?> supplier)

Specified by:

fillDiagonal in interface Mutate2D.Fillable<Double>

fillMatching

public void fillMatching(Access1D<?> source)

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>

fillMatching

public void fillMatching(Access1D<Double> left,
 BinaryFunction<Double> function,
 Access1D<Double> right)

Specified by:

fillMatching in interface Mutate1D.Fillable<Double>

fillRange

public void fillRange(long first,
 long limit,
 Double value)

Specified by:

fillRange in interface Mutate1D.Fillable<Double>

fillRange

public void fillRange(long first,
 long limit,
 NullaryFunction<?> supplier)

Specified by:

fillRange in interface Mutate1D.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<?> supplier)

Specified by:

fillRow in interface Mutate2D.Fillable<Double>

get

public MatrixStore<Double> get()

Specified by:

get in interface MatrixStore<Double>

get

public Double get(int row,
 int col)

Specified by:

get in interface MatrixStore<Double>

getColDim

public int getColDim()

Specified by:

getColDim in interface Structure2D

Returns:

The number of columns

getRowDim

public int getRowDim()

Specified by:

getRowDim in interface Structure2D

Returns:

The number of rows

hashCode

public int hashCode()

Overrides:

hashCode in class Object

indexOfLargest

public long indexOfLargest()

Specified by:

indexOfLargest in interface Access1D.Aggregatable<Double>

Specified by:

indexOfLargest in interface MatrixStore<Double>

isSmall

public boolean isSmall(long row,
 long col,
 double comparedTo)

Specified by:

isSmall in interface MatrixStore<Double>

modifyAll

public void modifyAll(UnaryFunction<Double> modifier)

Specified by:

modifyAll in interface Mutate1D.Modifiable<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>

modifyMatching

public void modifyMatching(BinaryFunction<Double> function,
 Access1D<Double> right)

Specified by:

modifyMatching in interface Mutate1D.Modifiable<Double>

modifyOne

public void modifyOne(long row,
 long col,
 UnaryFunction<Double> modifier)

Specified by:

modifyOne in interface Mutate2D.Modifiable<Double>

modifyRange

public void modifyRange(long first,
 long limit,
 UnaryFunction<Double> modifier)

Specified by:

modifyRange in interface Mutate1D.Modifiable<Double>

modifyRow

public void modifyRow(long row,
 long col,
 UnaryFunction<Double> modifier)

Specified by:

modifyRow in interface Mutate2D.Modifiable<Double>

multiply

public RawStore multiply(MatrixStore<Double> right)

Specified by:

multiply in interface MatrixStore<Double>

Specified by:

multiply in interface Operation.Multiplication<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)

physical

public PhysicalStore.Factory<Double,RawStore> physical()

Specified by:

physical in interface MatrixStore<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

reset

public void reset()

Description copied from interface: Mutate1D

Reset this mutable structure to some standard (all zeros) initial state. It must still be usuable after this call, and the structure/size/shape must not change.

Specified by:

reset in interface Mutate1D

set

public void set(int row,
 int col,
 double value)

Specified by:

set in interface Mutate2D

set

public void set(long row,
 long col,
 Comparable<?> value)

Specified by:

set in interface Mutate2D

sliceRow

public Access1D<Double> sliceRow(long row)

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>

See Also:

• SubstituteBackwards.invoke(double[], int, int, int, Access2D, boolean, boolean, boolean)

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>

See Also:

• SubstituteForwards.invoke(double[], int, int, int, Access2D, boolean, boolean, boolean)

supplyTo

public void supplyTo(Mutate1D receiver)

Specified by:

supplyTo in interface Access1D.Collectable<Double,Mutate1D>

Specified by:

supplyTo in interface MatrixStore<Double>

supplyTo

public void supplyTo(TransformableRegion<Double> receiver)

Specified by:

supplyTo in interface Access2D.Collectable<Double,TransformableRegion<Double>>

Specified by:

supplyTo in interface MatrixStore<Double>

Specified by:

supplyTo in interface PhysicalStore<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<Double,MatrixStore<Double>>

Specified by:

toScalar in interface MatrixStore<Double>

Parameters:

row - A row index.

col - A column index.

Returns:

One matrix element as a Scalar.

toString

public String toString()

Overrides:

toString in class Object

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)

visitAll

public void visitAll(VoidFunction<Double> visitor)

Specified by:

visitAll in interface Access1D.Visitable<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>

visitRange

public void visitRange(long first,
 long limit,
 VoidFunction<Double> visitor)

Specified by:

visitRange in interface Access1D.Visitable<Double>

visitRow

public void visitRow(long row,
 long col,
 VoidFunction<Double> visitor)

Specified by:

visitRow in interface Access2D.Visitable<Double>