org.ojalgo.matrix.store
Class PrimitiveDenseStore

java.lang.Object
  org.ojalgo.array.PrimitiveArray
      org.ojalgo.matrix.store.PrimitiveDenseStore

All Implemented Interfaces:

Serializable, Access1D<Double>, Access2D<Double>, DecompositionStore<Double>, MatrixStore<Double>, PhysicalStore<Double>

public final class PrimitiveDenseStore
extends PrimitiveArray
implements PhysicalStore<Double>, DecompositionStore<Double>

A Double (actually double) implementation of PhysicalStore.

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>

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

MatrixStore.Builder<N extends Number>

Field Summary

static boolean	DEBUG
static PhysicalStore.Factory<Double>	FACTORY
int	length

Constructor Summary

PrimitiveDenseStore(int aRowDim, int aColDim, double[] anArray)
Deprecated. Only temporarily made public - don't use it!

Method Summary

Double	aggregateAll(ChainableAggregator aVisitor)
Double	aggregateAll(CollectableAggregator aVisitor)
Array1D<N>	asArray1D() A utility facade that conveniently/consistently presents the BasicArray as a one-dimensional array.
Array2D<Double>	asArray2D()
Array2D<N>	asArray2D(int aRowDim, int aColDim) A utility facade that conveniently/consistently presents the BasicArray as a two-dimensional array.
ArrayAnyD<N>	asArrayAnyD(int[] aStructure) A utility facade that conveniently/consistently presents the BasicArray as a multi-dimensional array.
Array1D<Double>	asList()
MatrixStore.Builder<Double>	builder()
void	caxpy(Double aSclrA, int aColX, int aColY, int aFirstRow) column a * x plus y
void	computeInPlaceBidiagonal(boolean normalAspectRatio)
boolean	computeInPlaceCholesky(boolean checkForSPD)
void	computeInPlaceHessenberg(boolean upper)
LUDecomposition.Pivot	computeInPlaceLU(boolean assumeNoPivotingRequired)
void	computeInPlaceQR()
void	computeInPlaceTridiagonal()
PhysicalStore<Double>	computeInPlaceTridiagonal(boolean someCollectTransformations)
void	computeInPlaceTridiagonalOld()
PrimitiveDenseStore	conjugate() Each call must produce a new instance.
PrimitiveDenseStore	copy() Each call must produce a new instance.
double	doubleValue(int aRow, int aCol) Extracts one element of this matrix as a double.
boolean	equals(MatrixStore<Double> aStore, NumberContext aCntxt)
boolean	equals(Object anObj)
void	exchangeColumns(int aColA, int aColB)
void	exchangeRows(int aRowA, int aRowB)
void	fillAll(Double aNmbr)
void	fillByMultiplying(MatrixStore<Double> aLeftArg, MatrixStore<Double> aRightArg)
void	fillColumn(int aRow, int aCol, Double aNmbr)
void	fillDiagonal(int aRow, int aCol, Double aNmbr)
void	fillMatching(Access2D<Double> aSource2D)
void	fillMatching(Double aLeftArg, BinaryFunction<Double> aFunc, MatrixStore<Double> aRightArg) Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:
void	fillMatching(MatrixStore<Double> aLeftArg, BinaryFunction<Double> aFunc, Double aRightArg) Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:
void	fillMatching(MatrixStore<Double> aLeftArg, BinaryFunction<Double> aFunc, MatrixStore<Double> aRightArg) Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:
void	fillRow(int aRow, int aCol, Double aNmbr)
Householder<Double>	generateHouseholderColumn(int aRow, int aCol)
Householder<Double>	generateHouseholderRow(int aRow, int aCol)
Double	get(int aRow, int aCol)
int	getColDim() The size of this structure in the column-direction/dimension
PhysicalStore.Factory<Double>	getFactory()
int	getIndexOfLargestInColumn(int aRow, int aCol)
int	getIndexOfLargestInRow(int aRow, int aCol)
int	getMinDim()
int	getRowDim() The size of this structure in the row-direction/dimension
int	hashCode()
boolean	isAbsolute(int aRow, int aCol)
boolean	isReal(int aRow, int aCol)
boolean	isZero(int aRow, int aCol)
void	maxpy(Double aSclrA, MatrixStore<Double> aMtrxX) matrix a * x plus y
void	modifyAll(UnaryFunction<Double> aFunc)
void	modifyColumn(int aRow, int aCol, UnaryFunction<Double> aFunc)
void	modifyDiagonal(int aRow, int aCol, UnaryFunction<Double> aFunc)
void	modifyRow(int aRow, int aCol, UnaryFunction<Double> aFunc)
MatrixStore<Double>	multiplyLeft(MatrixStore<Double> aStore)
MatrixStore<Double>	multiplyRight(MatrixStore<Double> aStore)
void	raxpy(Double aSclrA, int aRowX, int aRowY, int aFirstCol) row a * x plus y
void	set(int aRow, int aCol, double aNmbr)
void	set(int aRow, int aCol, Double aNmbr)
int	size()
int	size()
void	substituteBackwards(Access2D<Double> aBody, boolean transposed) Will solve the equation system [A][X]=[B] where: [aBody][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> aBody, boolean onesOnDiagonal, Access2D<Double> aRHS, boolean zerosAboveDiagonal) Will solve the equation system [A][X]=[B] where: [aBody][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
PrimitiveScalar	toScalar(int aRow, int aCol)
String	toString()
void	transformLeft(Householder.Reference<Double> aTransf, int aFirstCol)
void	transformLeft(Householder<Double> aTransf, int aFirstCol)
void	transformLeft(Rotation<Double> aTransf) As in MatrixStore.multiplyLeft(MatrixStore) where the left/parameter matrix is a plane rotation.
void	transformRight(Householder.Reference<Double> aTransf, int aFirstRow)
void	transformRight(Householder<Double> aTransf, int aFirstRow)
void	transformRight(Rotation<Double> aTransf) As in MatrixStore.multiplyRight(MatrixStore) where the right/parameter matrix is a plane rotation.
PrimitiveDenseStore	transpose() Each call must produce a new instance.
void	visitAll(AggregatorFunction<Double> aVisitor)
void	visitColumn(int aRow, int aCol, AggregatorFunction<Double> aVisitor)
void	visitDiagonal(int aRow, int aCol, AggregatorFunction<Double> aVisitor)
void	visitRow(int aRow, int aCol, AggregatorFunction<Double> aVisitor)

Methods inherited from class org.ojalgo.array.PrimitiveArray

doubleValue, exchange, fill, fill, fill, fill, get, getIndexOfLargest, isAbsolute, isReal, isZero, modify, modify, modify, modify, modify, modify, searchAscending, set, set, sortAscending, toScalar, visit

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Field Detail

FACTORY

public static final PhysicalStore.Factory<Double> FACTORY

DEBUG

public static boolean DEBUG

length

public final int length

Constructor Detail

PrimitiveDenseStore

@Deprecated
public PrimitiveDenseStore(int aRowDim,
                                      int aColDim,
                                      double[] anArray)

Deprecated. Only temporarily made public - don't use it!

Method Detail

aggregateAll

public Double aggregateAll(ChainableAggregator aVisitor)

Specified by:

aggregateAll in interface MatrixStore<Double>

aggregateAll

public Double aggregateAll(CollectableAggregator aVisitor)

Specified by:

aggregateAll in interface MatrixStore<Double>

asArray2D

public Array2D<Double> asArray2D()

Specified by:

asArray2D in interface DecompositionStore<Double>

asList

public Array1D<Double> asList()

Specified by:

asList in interface PhysicalStore<Double>

Returns:

The elements of the physical store as a fixed size (1 dimensional) list. The elements may be accessed either row or colomn major.

builder

public final MatrixStore.Builder<Double> builder()

Specified by:

builder in interface MatrixStore<Double>

caxpy

public void caxpy(Double aSclrA,
                  int aColX,
                  int aColY,
                  int aFirstRow)

Description copied from interface: PhysicalStore

column a * x plus y

[this(*,aColY)] = aSclrA [this(*,aColX)] + [this(*,aColY)]

Specified by:

caxpy in interface PhysicalStore<Double>

computeInPlaceBidiagonal

public void computeInPlaceBidiagonal(boolean normalAspectRatio)

Specified by:

computeInPlaceBidiagonal in interface DecompositionStore<Double>

computeInPlaceCholesky

public boolean computeInPlaceCholesky(boolean checkForSPD)

Specified by:

computeInPlaceCholesky in interface DecompositionStore<Double>

computeInPlaceHessenberg

public void computeInPlaceHessenberg(boolean upper)

Specified by:

computeInPlaceHessenberg in interface DecompositionStore<Double>

computeInPlaceLU

public LUDecomposition.Pivot computeInPlaceLU(boolean assumeNoPivotingRequired)

Specified by:

computeInPlaceLU in interface DecompositionStore<Double>

computeInPlaceQR

public void computeInPlaceQR()

Specified by:

computeInPlaceQR in interface DecompositionStore<Double>

computeInPlaceTridiagonal

public void computeInPlaceTridiagonal()

Specified by:

computeInPlaceTridiagonal in interface DecompositionStore<Double>

computeInPlaceTridiagonal

public PhysicalStore<Double> computeInPlaceTridiagonal(boolean someCollectTransformations)

computeInPlaceTridiagonalOld

public void computeInPlaceTridiagonalOld()

conjugate

public PrimitiveDenseStore conjugate()

Description copied from interface: MatrixStore

Each call must produce a new instance.

Specified by:

conjugate in interface MatrixStore<Double>

Returns:

A new conjugated PhysicalStore copy.

copy

public PrimitiveDenseStore copy()

Description copied from interface: MatrixStore

Each call must produce a new instance.

Specified by:

copy in interface MatrixStore<Double>

Returns:

A new PhysicalStore copy.

doubleValue

public double doubleValue(int aRow,
                          int aCol)

Extracts one element of this matrix as a double.

Parameters:

aRow - A row index.

aCol - A column index.

Returns:

One matrix element

equals

public boolean equals(MatrixStore<Double> aStore,
                      NumberContext aCntxt)

Specified by:

equals in interface MatrixStore<Double>

equals

public boolean equals(Object anObj)

Overrides:

equals in class PrimitiveArray

exchangeColumns

public void exchangeColumns(int aColA,
                            int aColB)

Specified by:

exchangeColumns in interface PhysicalStore<Double>

exchangeRows

public void exchangeRows(int aRowA,
                         int aRowB)

Specified by:

exchangeRows in interface PhysicalStore<Double>

fillAll

public void fillAll(Double aNmbr)

Specified by:

fillAll in interface PhysicalStore<Double>

fillByMultiplying

public void fillByMultiplying(MatrixStore<Double> aLeftArg,
                              MatrixStore<Double> aRightArg)

Specified by:

fillByMultiplying in interface PhysicalStore<Double>

fillColumn

public void fillColumn(int aRow,
                       int aCol,
                       Double aNmbr)

Specified by:

fillColumn in interface PhysicalStore<Double>

fillDiagonal

public void fillDiagonal(int aRow,
                         int aCol,
                         Double aNmbr)

Specified by:

fillDiagonal in interface PhysicalStore<Double>

fillMatching

public void fillMatching(Access2D<Double> aSource2D)

Specified by:

fillMatching in interface PhysicalStore<Double>

fillMatching

public void fillMatching(Double aLeftArg,
                         BinaryFunction<Double> aFunc,
                         MatrixStore<Double> aRightArg)

Description copied from interface: PhysicalStore

Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:

this(i,j) = aFunc.invoke(aLeftArg,aRightArg(i,j))

Specified by:

fillMatching in interface PhysicalStore<Double>

fillMatching

public void fillMatching(MatrixStore<Double> aLeftArg,
                         BinaryFunction<Double> aFunc,
                         Double aRightArg)

Description copied from interface: PhysicalStore

Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:

this(i,j) = aFunc.invoke(aLeftArg(i,j),aRightArg))

Specified by:

fillMatching in interface PhysicalStore<Double>

fillMatching

public void fillMatching(MatrixStore<Double> aLeftArg,
                         BinaryFunction<Double> aFunc,
                         MatrixStore<Double> aRightArg)

Description copied from interface: PhysicalStore

Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:

this(i,j) = aFunc.invoke(aLeftArg(i,j),aRightArg(i,j))

Specified by:

fillMatching in interface PhysicalStore<Double>

fillRow

public void fillRow(int aRow,
                    int aCol,
                    Double aNmbr)

Specified by:

fillRow in interface PhysicalStore<Double>

generateHouseholderColumn

public Householder<Double> generateHouseholderColumn(int aRow,
                                                     int aCol)

Specified by:

generateHouseholderColumn in interface PhysicalStore<Double>

generateHouseholderRow

public Householder<Double> generateHouseholderRow(int aRow,
                                                  int aCol)

Specified by:

generateHouseholderRow in interface PhysicalStore<Double>

get

public Double get(int aRow,
                  int aCol)

getColDim

public int getColDim()

The size of this structure in the column-direction/dimension

Returns:

The number of columns

getFactory

public PhysicalStore.Factory<Double> getFactory()

Specified by:

getFactory in interface MatrixStore<Double>

getIndexOfLargestInColumn

public int getIndexOfLargestInColumn(int aRow,
                                     int aCol)

Specified by:

getIndexOfLargestInColumn in interface PhysicalStore<Double>

getIndexOfLargestInRow

public int getIndexOfLargestInRow(int aRow,
                                  int aCol)

Specified by:

getIndexOfLargestInRow in interface PhysicalStore<Double>

getMinDim

public int getMinDim()

Specified by:

getMinDim in interface MatrixStore<Double>

getRowDim

public int getRowDim()

The size of this structure in the row-direction/dimension

Returns:

The number of rows

hashCode

public int hashCode()

Overrides:

hashCode in class PrimitiveArray

isAbsolute

public boolean isAbsolute(int aRow,
                          int aCol)

Specified by:

isAbsolute in interface MatrixStore<Double>

See Also:

Scalar.isAbsolute()

isReal

public boolean isReal(int aRow,
                      int aCol)

Specified by:

isReal in interface MatrixStore<Double>

See Also:

Scalar.isReal()

isZero

public boolean isZero(int aRow,
                      int aCol)

Specified by:

isZero in interface MatrixStore<Double>

See Also:

Scalar.isZero()

maxpy

public void maxpy(Double aSclrA,
                  MatrixStore<Double> aMtrxX)

Description copied from interface: PhysicalStore

matrix a * x plus y

[this] = aSclrA [aMtrxX] + [this]

Specified by:

maxpy in interface PhysicalStore<Double>

modifyAll

public void modifyAll(UnaryFunction<Double> aFunc)

Specified by:

modifyAll in interface PhysicalStore<Double>

modifyColumn

public void modifyColumn(int aRow,
                         int aCol,
                         UnaryFunction<Double> aFunc)

Specified by:

modifyColumn in interface PhysicalStore<Double>

modifyDiagonal

public void modifyDiagonal(int aRow,
                           int aCol,
                           UnaryFunction<Double> aFunc)

Specified by:

modifyDiagonal in interface PhysicalStore<Double>

modifyRow

public void modifyRow(int aRow,
                      int aCol,
                      UnaryFunction<Double> aFunc)

Specified by:

modifyRow in interface PhysicalStore<Double>

multiplyLeft

public MatrixStore<Double> multiplyLeft(MatrixStore<Double> aStore)

Specified by:

multiplyLeft in interface MatrixStore<Double>

multiplyRight

public MatrixStore<Double> multiplyRight(MatrixStore<Double> aStore)

Specified by:

multiplyRight in interface MatrixStore<Double>

raxpy

public void raxpy(Double aSclrA,
                  int aRowX,
                  int aRowY,
                  int aFirstCol)

Description copied from interface: PhysicalStore

row a * x plus y

[this(aRowY,*)] = aSclrA [this(aRowX,*)] + [this(aRowY,*)]

Specified by:

raxpy in interface PhysicalStore<Double>

set

public void set(int aRow,
                int aCol,
                double aNmbr)

Specified by:

set in interface PhysicalStore<Double>

set

public void set(int aRow,
                int aCol,
                Double aNmbr)

Specified by:

set in interface PhysicalStore<Double>

substituteBackwards

public void substituteBackwards(Access2D<Double> aBody,
                                boolean transposed)

Description copied from interface: DecompositionStore

Will solve the equation system [A][X]=[B] where:

• [aBody][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 DecompositionStore<Double>

Parameters:

aBody - The equation system body parameters [A]

transposed - true if the upper/right part of aBody is actually stored in the lower/left part of the matrix.

substituteForwards

public void substituteForwards(Access2D<Double> aBody,
                               boolean onesOnDiagonal,
                               Access2D<Double> aRHS,
                               boolean zerosAboveDiagonal)

Description copied from interface: DecompositionStore

Will solve the equation system [A][X]=[B] where:

• [aBody][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 DecompositionStore<Double>

Parameters:

aBody - The equation system body parameters [A]

onesOnDiagonal - true if aBody as ones on the diagonal

toScalar

public PrimitiveScalar toScalar(int aRow,
                                int aCol)

Specified by:

toScalar in interface MatrixStore<Double>

transformLeft

public void transformLeft(Householder.Reference<Double> aTransf,
                          int aFirstCol)

Specified by:

transformLeft in interface DecompositionStore<Double>

transformLeft

public void transformLeft(Householder<Double> aTransf,
                          int aFirstCol)

Specified by:

transformLeft in interface PhysicalStore<Double>

transformLeft

public void transformLeft(Rotation<Double> aTransf)

Description copied from interface: PhysicalStore

As in MatrixStore.multiplyLeft(MatrixStore) 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.Reference<Double> aTransf,
                           int aFirstRow)

Specified by:

transformRight in interface DecompositionStore<Double>

transformRight

public void transformRight(Householder<Double> aTransf,
                           int aFirstRow)

Specified by:

transformRight in interface PhysicalStore<Double>

transformRight

public void transformRight(Rotation<Double> aTransf)

Description copied from interface: PhysicalStore

As in MatrixStore.multiplyRight(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 PrimitiveDenseStore transpose()

Description copied from interface: MatrixStore

Each call must produce a new instance.

Specified by:

transpose in interface MatrixStore<Double>

Returns:

A new transposed PhysicalStore copy.

visitAll

public void visitAll(AggregatorFunction<Double> aVisitor)

Specified by:

visitAll in interface MatrixStore<Double>

visitColumn

public void visitColumn(int aRow,
                        int aCol,
                        AggregatorFunction<Double> aVisitor)

Specified by:

visitColumn in interface MatrixStore<Double>

visitDiagonal

public void visitDiagonal(int aRow,
                          int aCol,
                          AggregatorFunction<Double> aVisitor)

Specified by:

visitDiagonal in interface MatrixStore<Double>

visitRow

public void visitRow(int aRow,
                     int aCol,
                     AggregatorFunction<Double> aVisitor)

Specified by:

visitRow in interface MatrixStore<Double>

size

public int size()

Returns:

The total number of elements contained in this structure

asArray1D

public final Array1D<N> asArray1D()

A utility facade that conveniently/consistently presents the BasicArray as a one-dimensional array. Note that you will modify the actual array by accessing it through this facade.

Disregards the array structure, and simply treats it as one-domensional.

asArray2D

public final Array2D<N> asArray2D(int aRowDim,
                                  int aColDim)

A utility facade that conveniently/consistently presents the BasicArray as a two-dimensional array. Note that you will modify the actual array by accessing it through this facade.

If "this" has more than two dimensions then only the first plane of the first cube of the first... is used/accessed. If this only has one dimension then everything is assumed to be in the first column of the first plane of the first cube...

asArrayAnyD

public final ArrayAnyD<N> asArrayAnyD(int[] aStructure)

A utility facade that conveniently/consistently presents the BasicArray as a multi-dimensional array. Note that you will modify the actual array by accessing it through this facade.

size

public final int size()

Returns:

The total number of elements contained in this structure

toString

public String toString()

Overrides:

toString in class Object