org.ojalgo.matrix.store

Class RawStore

java.lang.Object

org.ojalgo.matrix.store.RawStore

All Implemented Interfaces:

Serializable, Iterable<Double>, Consumer<Access2D<?>>, Supplier<MatrixStore<Double>>, Access1D<Double>, Access1D.Aggregatable<Double>, Access1D.Elements, Access1D.IndexOf, Access1D.Sliceable<Double>, Access1D.Visitable<Double>, Access2D<Double>, Access2D.Aggregatable<Double>, Access2D.Collectable<Double,ElementsConsumer<Double>>, Access2D.Elements, Access2D.IndexOf, Access2D.Sliceable<Double>, Access2D.Visitable<Double>, Mutate1D, Mutate1D.BiModifiable<Double>, Mutate1D.Fillable<Double>, Mutate1D.Modifiable<Double>, Mutate2D, Mutate2D.BiModifiable<Double>, Mutate2D.Exchangeable, Mutate2D.Fillable<Double>, Mutate2D.Modifiable<Double>, Mutate2D.Receiver<Double>, Stream2D<Double,MatrixStore<Double>,ElementsConsumer<Double>,ElementsSupplier<Double>>, Structure1D, Structure2D, Structure2D.ReducibleTo1D<ElementsSupplier<Double>>, 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>, ElementsConsumer<Double>, ElementsSupplier<Double>, MatrixStore<Double>, PhysicalStore<Double>, TransformationMatrix.Transformable<Double>

public final class RawStore
extends Object
implements PhysicalStore<Double>, Serializable

Uses double[][] internally.

Author:

apete

See Also:

Serialized Form

Nested Class Summary

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.access.Access2D

Access2D.Aggregatable<N extends Number>, Access2D.Collectable<N extends Number,R extends Mutate2D.Receiver<N>>, Access2D.Elements, Access2D.ElementView<N extends Number>, Access2D.IndexOf, Access2D.Sliceable<N extends Number>, Access2D.Visitable<N extends Number>

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

Group.Additive<S>, Group.Multiplicative<S>

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

Operation.Addition<T>, Operation.Division<T>, Operation.Multiplication<T>, Operation.Subtraction<T>

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

ScalarOperation.Addition<T,N extends Number>, ScalarOperation.Division<T,N extends Number>, ScalarOperation.Multiplication<T,N extends Number>, ScalarOperation.Subtraction<T,N extends Number>

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

ElementsConsumer.ColumnsRegion<N extends Number>, ElementsConsumer.ConsumerRegion<N extends Number>, ElementsConsumer.FillByMultiplying<N extends Number>, ElementsConsumer.LimitRegion<N extends Number>, ElementsConsumer.OffsetRegion<N extends Number>, ElementsConsumer.RowsRegion<N extends Number>, ElementsConsumer.TransposedRegion<N extends Number>

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

Mutate2D.BiModifiable<N extends Number>, Mutate2D.Exchangeable, Mutate2D.Fillable<N extends Number>, Mutate2D.Mixable<N extends Number>, Mutate2D.Modifiable<N extends Number>, Mutate2D.Receiver<N extends Number>

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

Mutate1D.Sortable

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

Structure2D.IntRowColumn, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.RowColumnCallback, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>

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

Structure1D.BasicMapper<T>, Structure1D.IndexCallback, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.LongIndex, Structure1D.LoopCallback

Field Summary

Fields

Modifier and Type	Field and Description
double[][]	data
static PhysicalStore.Factory<Double,RawStore>	FACTORY

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

BIG, COMPLEX, PRIMITIVE

Constructor Summary

Constructors

Constructor and Description
RawStore(Access2D<?> template)
RawStore(double[][] A) Construct a matrix from a 2-D array.
RawStore(double[][] A, int m, int n) Construct a matrix quickly without checking arguments.
RawStore(double[] elements, int structure) Construct a matrix from a one-dimensional packed array
RawStore(int m, int n) Construct an m-by-n matrix of zeros.
RawStore(int m, int n, double s) Construct an m-by-n constant matrix.

Method Summary

Modifier and Type	Method and Description
void	accept(Access2D<?> supplied)
void	add(long row, long col, double addend)
void	add(long row, long col, Number addend)
Double	aggregateAll(Aggregator aggregator)
List<Double>	asList()
RawStore	conjugate() Returns the conjugate transpose of this matrix.
static RawStore	constructWithCopy(double[][] A) Construct a matrix from a copy of a 2-D array.
RawStore	copy() Make a deep copy of a matrix
double[][]	copyOfData() Copy the internal two-dimensional array.
long	count() count() == countRows() * countColumns()
long	countColumns()
long	countRows()
double	doubleValue(long row, long col) Extracts one element of this matrix as a double.
boolean	equals(Object other)
void	exchangeColumns(long colA, long colB)
void	exchangeRows(long rowA, long rowB)
void	fillAll(Double value)
void	fillAll(NullaryFunction<Double> supplier)
void	fillByMultiplying(Access1D<Double> leftMatrix, Access1D<Double> rightMatrix)
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<?> 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	fillMatching(Access1D<Double> left, BinaryFunction<Double> function, Double right) Deprecated. v39
void	fillMatching(Double left, BinaryFunction<Double> function, Access1D<Double> right) Deprecated. v39
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	fillRange(long first, long limit, Double value)
void	fillRange(long first, long limit, NullaryFunction<Double> supplier)
void	fillRow(long row, long col, Double value)
void	fillRow(long row, long col, NullaryFunction<Double> supplier)
MatrixStore<Double>	get()
Double	get(long row, long col)
RawStore	getMatrix(int[] r, int j0, int j1) Deprecated. v39
RawStore	getMatrix(int i0, int i1, int j0, int j1) Deprecated. v39
int	hashCode()
long	indexOfLargest()
long	indexOfLargestInColumn(long row, long col)
long	indexOfLargestInRange(long first, long limit)
long	indexOfLargestInRow(long row, long col)
long	indexOfLargestOnDiagonal(long first)
boolean	isAbsolute(long index)
boolean	isAbsolute(long row, long col)
boolean	isSmall(long index, double comparedTo)
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(Access1D<Double> left, BinaryFunction<Double> function)
void	modifyMatching(BinaryFunction<Double> function, Access1D<Double> right)
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()
static RawStore	random(int m, int n) Generate matrix with random elements
static RawStore	read(BufferedReader input) Read a matrix from a stream.
ElementsConsumer<Double>	regionByColumns(int... columns)
ElementsConsumer<Double>	regionByLimits(int rowLimit, int columnLimit)
ElementsConsumer<Double>	regionByOffsets(int rowOffset, int columnOffset)
ElementsConsumer<Double>	regionByRows(int... rows)
ElementsConsumer<Double>	regionByTransposing()
void	set(long row, long col, double value)
void	set(long row, long col, Number value)
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(ElementsConsumer<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.
RawStore	transpose() RawStore transpose.
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)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

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

add, aggregateColumn, aggregateDiagonal, aggregateRange, aggregateRow, equals, firstInColumn, firstInRow, isSmall, limitOfColumn, limitOfRow, logical, multiply, multiply, multiply, negate, norm, premultiply, reduceColumns, reduceRows, signum, sliceColumn, sliceDiagonal, sliceRange, sliceRow, subtract, visitOne

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

operateOnAll, operateOnMatching, operateOnMatching

Methods inherited from interface org.ojalgo.access.Stream2D

operateOnAll, operateOnAll, operateOnAll, operateOnAll, operateOnAll

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

collect

Methods inherited from interface org.ojalgo.access.Access2D

asCollectable2D, asPrimitive2D, columns, doubleValue, elements, equals, get, newPrimitiveColumnCollectable, newPrimitiveRowCollectable, rows, toRawCopy2D, toString, wrap, wrap, wrapAccess2D, wrapAccess2D

Methods inherited from interface org.ojalgo.access.Access1D

asCollectable1D, asPrimitive1D, axpy, dot, equals, hashCode, iterator, nonzeros, stream, supplyTo, toRawCopy1D, wrap, wrap, wrap, wrapAccess1D, wrapAccess1D, wrapAccess1D

Methods inherited from interface java.lang.Iterable

forEach, spliterator

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

isColumnSmall, isColumnSmall, isRowSmall, isRowSmall

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

isAllSmall

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

visitColumn, visitDiagonal, visitOne, visitRow

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

aggregateColumn, aggregateRow, reduceColumns, reduceRows

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

sliceColumn, sliceRow

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

indexOfLargestInColumn, indexOfLargestInRow, indexOfLargestOnDiagonal

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

transform

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

isAcceptable

Methods inherited from interface org.ojalgo.access.Mutate2D

add, add, set, set

Methods inherited from interface org.ojalgo.access.Mutate1D

reset

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

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

Methods inherited from interface org.ojalgo.access.Structure2D

column, column, column, column, column, index, index, isEmpty, isFat, isScalar, isSquare, isTall, isVector, loopAll, loopColumn, loopColumn, loopDiagonal, loopMatching, loopRow, loopRow, mapperOf, row, row, row, row, row

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

fillMatching

Methods inherited from interface org.ojalgo.access.Structure1D

loopAll, loopMatching, loopRange, mapper

Methods inherited from interface java.util.function.Consumer

andThen

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

modifyColumn, modifyDiagonal, modifyOne, modifyRow

Field Detail

FACTORY

public static PhysicalStore.Factory<Double,RawStore> FACTORY

data

public final double[][] data

Constructor Detail

RawStore

public RawStore(Access2D<?> template)

RawStore

public RawStore(double[] elements,
                int structure)

Construct a matrix from a one-dimensional packed array

Parameters:

elements - One-dimensional array of doubles, packed by columns (ala Fortran).

structure - Number of rows.

Throws:

IllegalArgumentException - Array length must be a multiple of m.

RawStore

public RawStore(double[][] A)

Construct a matrix from a 2-D array.

Parameters:

A - Two-dimensional array of doubles.

Throws:

IllegalArgumentException - All rows must have the same length

See Also:

constructWithCopy(double[][])

RawStore

public RawStore(double[][] A,
                int m,
                int n)

Construct a matrix quickly without checking arguments.

Parameters:

A - Two-dimensional array of doubles.

m - Number of rows.

n - Number of colums.

RawStore

public RawStore(int m,
                int n)

Construct an m-by-n matrix of zeros.

Parameters:

m - Number of rows.

n - Number of colums.

RawStore

public RawStore(int m,
                int n,
                double s)

Construct an m-by-n constant matrix.

Parameters:

m - Number of rows.

n - Number of colums.

s - Fill the matrix with this scalar value.

Method Detail

constructWithCopy

public static RawStore constructWithCopy(double[][] A)

Construct a matrix from a copy of a 2-D array.

Parameters:

A - Two-dimensional array of doubles.

Throws:

IllegalArgumentException - All rows must have the same length

random

public static RawStore random(int m,
                              int n)

Generate matrix with random elements

Parameters:

m - Number of rows.

n - Number of colums.

Returns:

An m-by-n matrix with uniformly distributed random elements.

read

public static RawStore read(BufferedReader input)
                     throws IOException

Read a matrix from a stream. The format is the same the print method, so printed matrices can be read back in (provided they were printed using US Locale). Elements are separated by whitespace, all the elements for each row appear on a single line, the last row is followed by a blank line.

Parameters:

input - the input stream.

Throws:

IOException

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 Access1D.Aggregatable<Double>

Specified by:

aggregateAll in interface MatrixStore<Double>

asList

public List<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.

conjugate

public RawStore 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 RawStore copy()

Make a deep copy of a matrix

Specified by:

copy in interface MatrixStore<Double>

Returns:

A new PhysicalStore copy.

copyOfData

public double[][] copyOfData()

Copy the internal two-dimensional array.

Returns:

Two-dimensional array copy of matrix elements.

count

public long count()

Description copied from interface: Structure2D

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

Specified by:

count in interface Structure1D

Specified by:

count in interface Structure2D

Returns:

The total number of elements in this structure.

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

doubleValue

public double doubleValue(long row,
                          long col)

Description copied from interface: Access2D

Extracts one element of this matrix as a double.

Specified by:

doubleValue in interface Access2D<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 other)

Overrides:

equals in class Object

exchangeColumns

public void exchangeColumns(long colA,
                            long colB)

Specified by:

exchangeColumns in interface Mutate2D.Exchangeable

exchangeRows

public void exchangeRows(long rowA,
                         long rowB)

Specified by:

exchangeRows in interface Mutate2D.Exchangeable

fillAll

public void fillAll(Double value)

Specified by:

fillAll in interface Mutate1D.Fillable<Double>

fillAll

public void fillAll(NullaryFunction<Double> supplier)

Specified by:

fillAll in interface Mutate1D.Fillable<Double>

fillByMultiplying

public void fillByMultiplying(Access1D<Double> leftMatrix,
                              Access1D<Double> rightMatrix)

Specified by:

fillByMultiplying in interface ElementsConsumer<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<?> 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>

fillMatching

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

Deprecated. v39

fillMatching

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

Deprecated. v39

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>

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

Specified by:

fillRow in interface Mutate2D.Fillable<Double>

get

public final 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>

getMatrix

@Deprecated
public RawStore getMatrix(int i0,
                                      int i1,
                                      int j0,
                                      int j1)

Deprecated. v39

Get a submatrix.

Parameters:

i0 - Initial row index

i1 - Final row index

j0 - Initial column index

j1 - Final column index

Returns:

A(i0:i1,j0:j1)

Throws:

ArrayIndexOutOfBoundsException - Submatrix indices

getMatrix

@Deprecated
public RawStore getMatrix(int[] r,
                                      int j0,
                                      int j1)

Deprecated. v39

Get a submatrix.

Parameters:

r - Array of row indices.

j0 - Initial column index

j1 - Final column index

Returns:

A(r(:),j0:j1)

Throws:

ArrayIndexOutOfBoundsException - Submatrix indices

hashCode

public int hashCode()

Overrides:

hashCode in class Object

indexOfLargest

public long indexOfLargest()

Specified by:

indexOfLargest in interface Access1D.IndexOf

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.

indexOfLargestInRange

public long indexOfLargestInRange(long first,
                                  long limit)

Specified by:

indexOfLargestInRange in interface Access1D.IndexOf

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 index)

Specified by:

isAbsolute in interface Access1D.Elements

Specified by:

isAbsolute in interface Access2D.Elements

See Also:

Scalar.isAbsolute()

isAbsolute

public boolean isAbsolute(long row,
                          long col)

Specified by:

isAbsolute in interface Access2D.Elements

Specified by:

isAbsolute in interface MatrixStore<Double>

See Also:

Scalar.isAbsolute()

isSmall

public boolean isSmall(long index,
                       double comparedTo)

Specified by:

isSmall in interface Access1D.Elements

Specified by:

isSmall in interface Access2D.Elements

See Also:

NormedVectorSpace.isSmall(double)

isSmall

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

Specified by:

isSmall in interface Access2D.Elements

Specified by:

isSmall in interface MatrixStore<Double>

See Also:

NormedVectorSpace.isSmall(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.BiModifiable<Double>

modifyMatching

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

Specified by:

modifyMatching in interface Mutate1D.BiModifiable<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 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)

physical

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

Specified by:

physical in interface ElementsSupplier<Double>

regionByColumns

public final ElementsConsumer<Double> regionByColumns(int... columns)

Specified by:

regionByColumns in interface ElementsConsumer<Double>

Returns:

A consumer (sub)region

regionByLimits

public final ElementsConsumer<Double> regionByLimits(int rowLimit,
                                                     int columnLimit)

Specified by:

regionByLimits in interface ElementsConsumer<Double>

Returns:

A consumer (sub)region

regionByOffsets

public final ElementsConsumer<Double> regionByOffsets(int rowOffset,
                                                      int columnOffset)

Specified by:

regionByOffsets in interface ElementsConsumer<Double>

Returns:

A consumer (sub)region

regionByRows

public final ElementsConsumer<Double> regionByRows(int... rows)

Specified by:

regionByRows in interface ElementsConsumer<Double>

Returns:

A consumer (sub)region

regionByTransposing

public final ElementsConsumer<Double> regionByTransposing()

Specified by:

regionByTransposing in interface ElementsConsumer<Double>

Returns:

A transposed consumer region

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

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(ElementsConsumer<Double> receiver)

Specified by:

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

Specified by:

supplyTo in interface MatrixStore<Double>

toScalar

public PrimitiveScalar toScalar(long row,
                                long column)

Specified by:

toScalar in interface MatrixStore<Double>

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)

transpose

public RawStore transpose()

RawStore transpose.

Specified by:

transpose in interface Stream2D<Double,MatrixStore<Double>,ElementsConsumer<Double>,ElementsSupplier<Double>>

Specified by:

transpose in interface ElementsSupplier<Double>

Specified by:

transpose in interface MatrixStore<Double>

Returns:

A'

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>