JamaMatrix

java.lang.Object
- org.ojalgo.matrix.jama.JamaMatrix

All Implemented Interfaces:

Serializable, Iterable<Double>, Access1D<Double>, Access1D.Elements, Access1D.Fillable<Double>, Access1D.Modifiable<Double>, Access1D.Visitable<Double>, Access2D<Double>, Access2D.Elements, Access2D.Fillable<Double>, Access2D.Modifiable<Double>, Access2D.Visitable<Double>, BasicMatrix<Double>, MatrixStore<Double>, PhysicalStore<Double>
```
public final class JamaMatrix
extends Object
implements BasicMatrix<Double>, PhysicalStore<Double>, Serializable
```
This class adapts JAMA's Matrix to ojAlgo's BasicMatrix and PhysicalStore interfaces.

Author:

apete

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface org.ojalgo.matrix.BasicMatrix
  BasicMatrix.Factory<I extends BasicMatrix<?>>
- 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.Builder<N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.access.Access2D
  Access2D.Elements, Access2D.Fillable<N extends Number>, Access2D.Iterable2D<N extends Number>, Access2D.Modifiable<N extends Number>, Access2D.Visitable<N extends Number>

Field Summary

Fields
Modifier and Type Field and Description

static JamaFactory FACTORY

Fields
Modifier and Type	Field and Description
`static JamaFactory`	`FACTORY`

Constructor Summary

Constructors
Constructor and Description

JamaMatrix(BasicMatrix aMtrx)

JamaMatrix(MatrixStore<Double> aStore)

Constructors
Constructor and Description
`JamaMatrix(BasicMatrix aMtrx)`
`JamaMatrix(MatrixStore<Double> aStore)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`JamaMatrix`	`add(Access2D<?> aMtrx)` Adds the elements of aMtrx to the elements of this matrix.
`JamaMatrix`	`add(int row, int column, Access2D<?> aMtrx)`
`JamaMatrix`	`add(int row, int column, Number aNmbr)` Do not use this method to populate large dense matrices! Only use it to change a few (a small number) of elements.
`MatrixStore<Double>`	`add(MatrixStore<Double> addend)`
`JamaMatrix`	`add(Number aNmbr)` Adds aNmbr to the elements of this.
`Double`	`aggregateAll(Aggregator aggregator)`
`List<Double>`	`asList()`
`MatrixStore.Builder<Double>`	`builder()`
`void`	`caxpy(Double aSclrA, int aColX, int aColY, int aFirstRow)` column a * x plus y
`JamaMatrix`	`conjugate()` For real matrices conjugate() and transpose() are identical.
`JamaMatrix`	`copy()` Each call must produce a new instance.
`Access2D.Builder<JamaMatrix>`	`copyToBuilder()`
`long`	`count()`
`long`	`countColumns()`
`long`	`countRows()`
`JamaMatrix`	`divide(Number aNmbr)` Divides the elements of this with aNmbr.
`JamaMatrix`	`divideElements(Access2D<?> aMtrx)` Divides the elements of this with the elements of aMtrx.
`double`	`doubleValue(long anInd)`
`double`	`doubleValue(long row, long column)` Extracts one element of this matrix as a double.
`JamaMatrix`	`enforce(NumberContext aContext)`
`boolean`	`equals(Access2D<?> aMtrx, NumberContext aCntxt)`
`boolean`	`equals(MatrixStore<Double> other, NumberContext context)`
`boolean`	`equals(Object anObject)`
`void`	`exchangeColumns(int aColA, int aColB)`
`void`	`exchangeRows(int aRowA, int aRowB)`
`PhysicalStore.Factory<Double,JamaMatrix>`	`factory()`
`void`	`fillAll(Double aNmbr)`
`void`	`fillByMultiplying(Access1D<Double> aLeftArg, Access1D<Double> aRightArg)`
`void`	`fillColumn(long row, long column, Double aNmbr)`
`void`	`fillConjugated(Access2D<? extends Number> source)`
`void`	`fillDiagonal(long row, long column, Double aNmbr)`
`void`	`fillMatching(Access1D<? extends Number> source)`
`void`	`fillMatching(Access1D<Double> leftArg, BinaryFunction<Double> function, Access1D<Double> rightArg)` Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:
`void`	`fillMatching(Access1D<Double> aLeftArg, BinaryFunction<Double> function, Double aRightArg)` Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:
`void`	`fillMatching(Double aLeftArg, BinaryFunction<Double> function, Access1D<Double> aRightArg)` Will replace the elements of [this] with the results of element wise invocation of the input binary funtion:
`void`	`fillRange(long first, long limit, Double value)`
`void`	`fillRow(long row, long column, Double aNmbr)`
`void`	`fillTransposed(Access2D<? extends Number> source)`
`void`	`flushCache()` BasicMatrix instances are intended to be immutable.
`Double`	`get(long index)`
`Double`	`get(long row, long column)`
`static Access2D.Builder<JamaMatrix>`	`getBuilder(int aLength)`
`static Access2D.Builder<JamaMatrix>`	`getBuilder(int aRowDim, int aColDim)`
`int`	`getColDim()`
`JamaMatrix`	`getColumnsRange(int aFirst, int aLimit)`
`PrimitiveScalar`	`getCondition()`
`PrimitiveScalar`	`getDeterminant()`
`List<ComplexNumber>`	`getEigenvalues()`
`PrimitiveScalar`	`getFrobeniusNorm()` The Frobenius norm is the square root of the sum of the squares of each element, or the square root of the sum of the square of the singular values.
`PrimitiveScalar`	`getInfinityNorm()`
`PrimitiveScalar`	`getKyFanNorm(int k)`
`int`	`getMaxDim()`
`int`	`getMinDim()`
`Scalar<Double>`	`getOneNorm()`
`PrimitiveScalar`	`getOperatorNorm()` 2-norm, max singular value
`int`	`getRank()` The rank of a matrix is the (maximum) number of linearly independent rows or columns it contains.
`int`	`getRowDim()`
`JamaMatrix`	`getRowsRange(int aFirst, int aLimit)`
`List<Double>`	`getSingularValues()`
`PrimitiveScalar`	`getTrace()` The sum of the diagonal elements.
`PrimitiveScalar`	`getTraceNorm()`
`PrimitiveScalar`	`getVectorNorm(int aDegree)` Treats [this] as if it is one dimensional (a vector) and calculates the vector norm.
`int`	`hashCode()`
`JamaMatrix`	`invert()` About inverting matrices:
`boolean`	`isAbsolute(long index)`
`boolean`	`isAbsolute(long row, long column)`
`boolean`	`isEmpty()` Matrices are either square, tall, fat or empty.
`boolean`	`isFat()` Matrices are either square, tall, fat or empty.
`boolean`	`isFullRank()`
`boolean`	`isHermitian()`
`boolean`	`isInfinite(long index)`
`boolean`	`isInfinite(long row, long column)`
`boolean`	`isLowerLeftShaded()` The entries below (left of) the first subdiagonal are zero - effectively an upper Hessenberg matrix.
`boolean`	`isNaN(long index)`
`boolean`	`isNaN(long row, long column)`
`boolean`	`isPositive(long index)`
`boolean`	`isPositive(long row, long column)`
`boolean`	`isReal(long index)`
`boolean`	`isReal(long row, long column)`
`boolean`	`isScalar()`
`boolean`	`isSquare()` Matrices are either square, tall, fat or empty.
`boolean`	`isSymmetric()`
`boolean`	`isTall()` Matrices are either square, tall, fat or empty.
`boolean`	`isUpperRightShaded()` The entries above (right of) the first superdiagonal are zero - effectively a lower Hessenberg matrix.
`boolean`	`isVector()`
`boolean`	`isZero(long index)`
`boolean`	`isZero(long row, long column)`
`Iterator<Double>`	`iterator()`
`void`	`maxpy(Double aSclrA, MatrixStore<Double> aMtrxX)` matrix a * x plus y
`JamaMatrix`	`mergeColumns(Access2D<?> aMtrx)` [aMtrx] is appended to the bottom of [this].
`JamaMatrix`	`mergeRows(Access2D<?> aMtrx)` [aMtrx] is appended to the right side of [this].
`JamaMatrix`	`modify(UnaryFunction<Double> function)`
`void`	`modifyAll(UnaryFunction<Double> function)`
`void`	`modifyColumn(long row, long column, UnaryFunction<Double> function)`
`void`	`modifyDiagonal(long row, long column, UnaryFunction<Double> function)`
`void`	`modifyOne(long row, long column, UnaryFunction<Double> function)`
`void`	`modifyRange(long first, long limit, UnaryFunction<Double> function)`
`void`	`modifyRow(long row, long column, UnaryFunction<Double> function)`
`JamaMatrix`	`multiply(Number aNmbr)` Multiplies the elements of this matrix with aNmbr.
`JamaMatrix`	`multiplyElements(Access2D<?> aMtrx)` Multiplies the elements of this matrix with the elements of aMtrx.
`JamaMatrix`	`multiplyLeft(Access1D<Double> leftMtrx)`
`JamaMatrix`	`multiplyLeft(Access2D<?> aMtrx)` Matrix multiplication: [aMtrx][this] The column dimension of the left matrix must equal the row dimension of the right matrix.
`JamaMatrix`	`multiplyRight(Access1D<Double> rightMtrx)`
`JamaMatrix`	`multiplyRight(Access2D<?> aMtrx)` Matrix multiplication: [this][aMtrx] The column dimension of the left matrix must equal the row dimension of the right matrix.
`PrimitiveScalar`	`multiplyVectors(Access2D<?> aVctr)` Assumes that both [this] and [aVctr] have row or column dimension, doesn't matter which, equal to 1.
`JamaMatrix`	`negate()`
`void`	`raxpy(Double aSclrA, int aRowX, int aRowY, int aFirstCol)` row a * x plus y
`JamaMatrix`	`round(NumberContext aCntxt)`
`JamaMatrix`	`scale(Double scalar)`
`JamaMatrix`	`selectColumns(int... someCols)`
`JamaMatrix`	`selectRows(int... someRows)`
`Double`	`set(int anInd, Number value)`
`void`	`set(long index, double value)`
`void`	`set(long row, long column, double aNmbr)`
`void`	`set(long row, long column, Number aNmbr)`
`void`	`set(long index, Number value)`
`int`	`size()`
`JamaMatrix`	`solve(Access2D<?> aRHS)` This method solves a system of linear equations: [this][X]=[aRHS].
`JamaMatrix`	`subtract(Access2D<?> aMtrx)` Subtracts the elements of aMtrx from the elements of this matrix.
`MatrixStore<Double>`	`subtract(MatrixStore<Double> subtrahend)`
`JamaMatrix`	`subtract(Number value)` Subtracts aNmbr from the elements of this matrix.
`BigDecimal`	`toBigDecimal(int row, int column)` Extracts one element of this matrix as a BigDecimal.
`PhysicalStore<BigDecimal>`	`toBigStore()` Must be a copy that is safe to modify.
`ComplexNumber`	`toComplexNumber(int row, int column)` Extracts one element of this matrix as a ComplexNumber.
`PhysicalStore<ComplexNumber>`	`toComplexStore()` Must be a copy that is safe to modify.
`List<BasicMatrix<Double>>`	`toListOfColumns()`
`List<Double>`	`toListOfElements()` It is also possible to call BasicMatrix.toBigStore(), BasicMatrix.toComplexStore() or BasicMatrix.toPrimitiveStore() and then PhysicalStore.asList().
`List<BasicMatrix<Double>>`	`toListOfRows()`
`JamaMatrix`	`toPrimitiveStore()` Must be a copy that is safe to modify.
`PrimitiveScalar`	`toScalar(long row, long column)` Extracts one element of this matrix as a Scalar.
`String`	`toString()`
`String`	`toString(int row, int column)`
`void`	`transformLeft(Householder<Double> transformation, int firstColumn)`
`void`	`transformLeft(Rotation<Double> transformation)` As in `MatrixStore#multiplyLeft(MatrixStore)` where the left/parameter matrix is a plane rotation.
`void`	`transformRight(Householder<Double> transformation, int firstRow)`
`void`	`transformRight(Rotation<Double> transformation)` As in `MatrixStore#multiplyRight(MatrixStore)` where the right/parameter matrix is a plane rotation.
`JamaMatrix`	`transpose()` Transposes this matrix.
`void`	`update(int[] someRows, int[] someColumns, JamaMatrix aMtrx)`
`void`	`update(int[] someRows, int aFirstCol, int aColCount, JamaMatrix aMtrx)`
`void`	`update(int aFirstRow, int aRowCount, int[] someColumns, JamaMatrix aMtrx)`
`void`	`update(int aFirstRow, int aRowCount, int aFirstCol, int aColCount, JamaMatrix aMtrx)`
`void`	`update(int row, int column, Number aNmbr)`
`void`	`visitAll(VoidFunction<Double> visitor)`
`void`	`visitColumn(long row, long column, VoidFunction<Double> visitor)`
`void`	`visitDiagonal(long row, long column, VoidFunction<Double> visitor)`
`void`	`visitRange(long first, long limit, VoidFunction<Double> visitor)`
`void`	`visitRow(long row, long column, VoidFunction<Double> visitor)`

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - FACTORY
```
public static final JamaFactory FACTORY
```
- Constructor Detail
  - JamaMatrix
```
public JamaMatrix(BasicMatrix aMtrx)
```
  - JamaMatrix
```
public JamaMatrix(MatrixStore<Double> aStore)
```
- Method Detail
  - getBuilder
```
public static Access2D.Builder<JamaMatrix> getBuilder(int aLength)
```
  - getBuilder
```
public static Access2D.Builder<JamaMatrix> getBuilder(int aRowDim,
                                                      int aColDim)
```
  - add
```
public JamaMatrix add(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    Adds the elements of aMtrx to the elements of this matrix. The matrices must have equal dimensions.
    
    Specified by:
    
    add in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - What to add.
    
    Returns:
    
    A new matrix whos elements are the sum of this' and aMtrx'.
  - add
```
public JamaMatrix add(int row,
                      int column,
                      Access2D<?> aMtrx)
```
    Specified by:
    
    add in interface BasicMatrix<Double>
    
    Parameters:
    
    row - The row index of where to superimpose the top left element of aMtrx
    
    column - The column index of where to superimpose the top left element of aMtrx
    
    aMtrx - A matrix to superimpose
    
    Returns:
    
    A new matrix
  - add
```
public JamaMatrix add(int row,
                      int column,
                      Number aNmbr)
```
    Description copied from interface: BasicMatrix
    
    Do not use this method to populate large dense matrices! Only use it to change a few (a small number) of elements.
    
    Specified by:
    
    add in interface BasicMatrix<Double>
  - add
```
public MatrixStore<Double> add(MatrixStore<Double> addend)
```
    Specified by:
    
    add in interface MatrixStore<Double>
  - add
```
public JamaMatrix add(Number aNmbr)
```
    Description copied from interface: BasicMatrix
    
    Adds aNmbr to the elements of this.
    
    Specified by:
    
    add in interface BasicMatrix<Double>
    
    Parameters:
    
    aNmbr - What to add
    
    Returns:
    
    A new matrix whos elements are the sum of this' elements and aNmbr.
  - aggregateAll
```
public Double aggregateAll(Aggregator aggregator)
```
    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.
  - 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>
  - conjugate
```
public JamaMatrix conjugate()
```
    Description copied from interface: BasicMatrix
    
    For real matrices conjugate() and transpose() are identical. For complex matrices they're not.
    
    Specified by:
    
    conjugate in interface BasicMatrix<Double>
    
    Specified by:
    
    conjugate in interface MatrixStore<Double>
    
    Returns:
    
    The conjugate transpose of this.
    
    See Also:
    
    BasicMatrix.transpose()
  - copy
```
public JamaMatrix 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.
  - copyToBuilder
```
public Access2D.Builder<JamaMatrix> copyToBuilder()
```
    Specified by:
    
    copyToBuilder in interface BasicMatrix<Double>
    
    Returns:
    
    A fully mutable matrix builder with the elements initially set to a copy of this matrix.
  - count
```
public long count()
```
    Returns:
    
    The total number of elements in this structure.
  - countColumns
```
public long countColumns()
```
    Returns:
    
    The number of columns
  - countRows
```
public long countRows()
```
    Returns:
    
    The number of rows
  - divide
```
public JamaMatrix divide(Number aNmbr)
```
    Description copied from interface: BasicMatrix
    
    Divides the elements of this with aNmbr.
    
    Specified by:
    
    divide in interface BasicMatrix<Double>
    
    Parameters:
    
    aNmbr - The denominator.
    
    Returns:
    
    A new matrix whos elements are the elements of this divided with aNmbr.
  - divideElements
```
public JamaMatrix divideElements(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    Divides the elements of this with the elements of aMtrx. The matrices must have equal dimensions.
    
    Specified by:
    
    divideElements in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - The denominator elements.
    
    Returns:
    
    A new matrix whos elements are the elements of this divided with the elements of aMtrx.
  - doubleValue
```
public double doubleValue(long anInd)
```
    Specified by:
    
    doubleValue in interface Access1D<Double>
  - doubleValue
```
public double doubleValue(long row,
                          long column)
```
    Description copied from interface: Access2D
    
    Extracts one element of this matrix as a double.
    
    Specified by:
    
    doubleValue in interface Access2D<Double>
    
    Parameters:
    
    row - A row index.
    
    column - A column index.
    
    Returns:
    
    One matrix element
  - enforce
```
public JamaMatrix enforce(NumberContext aContext)
```
    Specified by:
    
    enforce in interface BasicMatrix<Double>
  - equals
```
public final boolean equals(Access2D<?> aMtrx,
                            NumberContext aCntxt)
```
    Specified by:
    
    equals in interface BasicMatrix<Double>
    
    Returns:
    
    true if the frobenius norm of the difference between [this] and [aStore] is zero within the limits of aCntxt.
  - equals
```
public boolean equals(MatrixStore<Double> other,
                      NumberContext context)
```
    Specified by:
    
    equals in interface MatrixStore<Double>
  - equals
```
public final boolean equals(Object anObject)
```
    Overrides:
    
    equals in class Object
  - 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>
  - factory
```
public PhysicalStore.Factory<Double,JamaMatrix> factory()
```
    Specified by:
    
    factory in interface MatrixStore<Double>
  - fillAll
```
public void fillAll(Double aNmbr)
```
    Specified by:
    
    fillAll in interface Access1D.Fillable<Double>
  - fillByMultiplying
```
public void fillByMultiplying(Access1D<Double> aLeftArg,
                              Access1D<Double> aRightArg)
```
    Specified by:
    
    fillByMultiplying in interface PhysicalStore<Double>
  - fillColumn
```
public void fillColumn(long row,
                       long column,
                       Double aNmbr)
```
    Specified by:
    
    fillColumn in interface Access2D.Fillable<Double>
  - fillConjugated
```
public void fillConjugated(Access2D<? extends Number> source)
```
    Specified by:
    
    fillConjugated in interface PhysicalStore<Double>
  - fillDiagonal
```
public void fillDiagonal(long row,
                         long column,
                         Double aNmbr)
```
    Specified by:
    
    fillDiagonal in interface Access2D.Fillable<Double>
  - fillMatching
```
public void fillMatching(Access1D<? extends Number> source)
```
    Specified by:
    
    fillMatching in interface PhysicalStore<Double>
  - fillMatching
```
public void fillMatching(Access1D<Double> leftArg,
                         BinaryFunction<Double> function,
                         Access1D<Double> rightArg)
```
    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>
  - fillMatching
```
public void fillMatching(Access1D<Double> aLeftArg,
                         BinaryFunction<Double> function,
                         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(Double aLeftArg,
                         BinaryFunction<Double> function,
                         Access1D<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>
  - fillRange
```
public void fillRange(long first,
                      long limit,
                      Double value)
```
    Specified by:
    
    fillRange in interface Access1D.Fillable<Double>
  - fillRow
```
public void fillRow(long row,
                    long column,
                    Double aNmbr)
```
    Specified by:
    
    fillRow in interface Access2D.Fillable<Double>
  - fillTransposed
```
public void fillTransposed(Access2D<? extends Number> source)
```
    Specified by:
    
    fillTransposed in interface PhysicalStore<Double>
  - flushCache
```
public void flushCache()
```
    Description copied from interface: BasicMatrix
    
    BasicMatrix instances are intended to be immutable. If they are it is possible to cache (partial) calculation results. Calling this method should flush any cached calculation results.
    
    Specified by:
    
    flushCache in interface BasicMatrix<Double>
  - get
```
public Double get(long index)
```
    Specified by:
    
    get in interface Access1D<Double>
  - get
```
public Double get(long row,
                  long column)
```
    Specified by:
    
    get in interface Access2D<Double>
  - getColDim
```
public int getColDim()
```
  - getColumnsRange
```
public JamaMatrix getColumnsRange(int aFirst,
                                  int aLimit)
```
    Specified by:
    
    getColumnsRange in interface BasicMatrix<Double>
    
    Parameters:
    
    aFirst - The first column to include.
    
    aLimit - The limit (exclusive) - the first column not to include.
    
    Returns:
    
    A new matrix with only the specified range of columns
  - getCondition
```
public PrimitiveScalar getCondition()
```
    Specified by:
    
    getCondition in interface BasicMatrix<Double>
  - getDeterminant
```
public PrimitiveScalar getDeterminant()
```
    Specified by:
    
    getDeterminant in interface BasicMatrix<Double>
    
    Returns:
    
    The matrix' determinant.
  - getEigenvalues
```
public List<ComplexNumber> getEigenvalues()
```
    Specified by:
    
    getEigenvalues in interface BasicMatrix<Double>
  - getFrobeniusNorm
```
public PrimitiveScalar getFrobeniusNorm()
```
    Description copied from interface: BasicMatrix
    
    The Frobenius norm is the square root of the sum of the squares of each element, or the square root of the sum of the square of the singular values.
    
    Specified by:
    
    getFrobeniusNorm in interface BasicMatrix<Double>
    
    Returns:
    
    The matrix' Frobenius norm
    
    See Also:
    
    BasicMatrix.getFrobeniusNorm(), BasicMatrix.getInfinityNorm(), BasicMatrix.getKyFanNorm(int), BasicMatrix.getOneNorm(), BasicMatrix.getOperatorNorm(), BasicMatrix.getTraceNorm(), BasicMatrix.getVectorNorm(int)
  - getInfinityNorm
```
public PrimitiveScalar getInfinityNorm()
```
    Specified by:
    
    getInfinityNorm in interface BasicMatrix<Double>
    
    Returns:
    
    Max row sum
    
    See Also:
    
    BasicMatrix.getFrobeniusNorm(), BasicMatrix.getInfinityNorm(), BasicMatrix.getKyFanNorm(int), BasicMatrix.getOneNorm(), BasicMatrix.getOperatorNorm(), BasicMatrix.getTraceNorm(), BasicMatrix.getVectorNorm(int)
  - getKyFanNorm
```
public PrimitiveScalar getKyFanNorm(int k)
```
    Specified by:
    
    getKyFanNorm in interface BasicMatrix<Double>
    
    See Also:
    
    BasicMatrix.getFrobeniusNorm(), BasicMatrix.getInfinityNorm(), BasicMatrix.getKyFanNorm(int), BasicMatrix.getOneNorm(), BasicMatrix.getOperatorNorm(), BasicMatrix.getTraceNorm(), BasicMatrix.getVectorNorm(int)
  - getMaxDim
```
public int getMaxDim()
```
  - getMinDim
```
public int getMinDim()
```
  - getOneNorm
```
public Scalar<Double> getOneNorm()
```
    Specified by:
    
    getOneNorm in interface BasicMatrix<Double>
    
    Returns:
    
    Max col sum
    
    See Also:
    
    BasicMatrix.getFrobeniusNorm(), BasicMatrix.getInfinityNorm(), BasicMatrix.getKyFanNorm(int), BasicMatrix.getOneNorm(), BasicMatrix.getOperatorNorm(), BasicMatrix.getTraceNorm(), BasicMatrix.getVectorNorm(int)
  - getOperatorNorm
```
public PrimitiveScalar getOperatorNorm()
```
    Description copied from interface: BasicMatrix
    
    2-norm, max singular value
    
    Specified by:
    
    getOperatorNorm in interface BasicMatrix<Double>
    
    See Also:
    
    BasicMatrix.getFrobeniusNorm(), BasicMatrix.getInfinityNorm(), BasicMatrix.getKyFanNorm(int), BasicMatrix.getOneNorm(), BasicMatrix.getOperatorNorm(), BasicMatrix.getTraceNorm(), BasicMatrix.getVectorNorm(int)
  - getRank
```
public int getRank()
```
    Description copied from interface: BasicMatrix
    
    The rank of a matrix is the (maximum) number of linearly independent rows or columns it contains. It is also equal to the number of nonzero singular values of the matrix.
    
    Specified by:
    
    getRank in interface BasicMatrix<Double>
    
    Returns:
    
    The matrix' rank.
  - getRowDim
```
public int getRowDim()
```
  - getRowsRange
```
public JamaMatrix getRowsRange(int aFirst,
                               int aLimit)
```
    Specified by:
    
    getRowsRange in interface BasicMatrix<Double>
    
    Parameters:
    
    aFirst - The first row to include.
    
    aLimit - The limit (exclusive) - the first row not to include.
    
    Returns:
    
    A new matrix with only the specified range of rows
  - getSingularValues
```
public List<Double> getSingularValues()
```
    Specified by:
    
    getSingularValues in interface BasicMatrix<Double>
  - getTrace
```
public PrimitiveScalar getTrace()
```
    Description copied from interface: BasicMatrix
    
    The sum of the diagonal elements.
    
    Specified by:
    
    getTrace in interface BasicMatrix<Double>
    
    Returns:
    
    The matrix' trace.
  - getTraceNorm
```
public PrimitiveScalar getTraceNorm()
```
    Specified by:
    
    getTraceNorm in interface BasicMatrix<Double>
    
    See Also:
    
    BasicMatrix.getFrobeniusNorm(), BasicMatrix.getInfinityNorm(), BasicMatrix.getKyFanNorm(int), BasicMatrix.getOneNorm(), BasicMatrix.getOperatorNorm(), BasicMatrix.getTraceNorm(), BasicMatrix.getVectorNorm(int)
  - getVectorNorm
```
public PrimitiveScalar getVectorNorm(int aDegree)
```
    Description copied from interface: BasicMatrix
    
    Treats [this] as if it is one dimensional (a vector) and calculates the vector norm. The interface only requires that implementations can handle arguments 0, 1, 2 and Integer.MAX_VALUE.
    
    Specified by:
    
    getVectorNorm in interface BasicMatrix<Double>
    
    See Also:
    
    BasicMatrix.getFrobeniusNorm(), BasicMatrix.getInfinityNorm(), BasicMatrix.getKyFanNorm(int), BasicMatrix.getOneNorm(), BasicMatrix.getOperatorNorm(), BasicMatrix.getTraceNorm(), BasicMatrix.getVectorNorm(int)
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - invert
```
public JamaMatrix invert()
```
    Description copied from interface: BasicMatrix
    About inverting matrices:
    - "right inverse": [this][right inverse]=[I]. You may calculate it using #solve(BasicMatrix).
    - "left inverse": [left inverse][this]=[I]. You may calculate it using #solve(BasicMatrix) and transposing.
    - "generalised inverse": [this][generalised inverse][this]=[this]. Note that if [this] is singular or non-square, then [generalised inverse] is not unique.
    - "pseudoinverse": The generalised inverse (there are typically/possibly many) with the smallest frobenius norm is called the pseudoinverse. You may calculate it using the QR or SingularValue decompositions.
    - "inverse":
      If [left inverse]=[right inverse] then it is also [inverse].
      If [this] is square and has full rank then the [generalised inverse] is unique, with the [pseudoinverse] given, and equal to [inverse].
    Specified by:
    
    invert in interface BasicMatrix<Double>
    
    Returns:
    
    The "best possible" inverse....
  - isAbsolute
```
public boolean isAbsolute(long index)
```
    Specified by:
    
    isAbsolute in interface Access1D.Elements
    
    See Also:
    
    Scalar.isAbsolute()
  - isAbsolute
```
public boolean isAbsolute(long row,
                          long column)
```
    Specified by:
    
    isAbsolute in interface Access2D.Elements
    
    See Also:
    
    Scalar.isAbsolute()
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: BasicMatrix
    
    Matrices are either square, tall, fat or empty. m <= 0 or n <= 0
    
    Specified by:
    
    isEmpty in interface BasicMatrix<Double>
    
    Returns:
    
    true if matrix is empty
  - isFat
```
public boolean isFat()
```
    Description copied from interface: BasicMatrix
    
    Matrices are either square, tall, fat or empty. 1 <= m < n
    
    Specified by:
    
    isFat in interface BasicMatrix<Double>
    
    Returns:
    
    true if matrix is fat
  - isFullRank
```
public boolean isFullRank()
```
    Specified by:
    
    isFullRank in interface BasicMatrix<Double>
    
    Returns:
    
    true if BasicMatrix.getRank() == min(#getRowDim(),#getColDim())
  - isHermitian
```
public boolean isHermitian()
```
    Specified by:
    
    isHermitian in interface BasicMatrix<Double>
  - isInfinite
```
public boolean isInfinite(long index)
```
    Specified by:
    
    isInfinite in interface Access1D.Elements
    
    See Also:
    
    Scalar.isInfinite()
  - isInfinite
```
public boolean isInfinite(long row,
                          long column)
```
    Specified by:
    
    isInfinite in interface Access2D.Elements
    
    See Also:
    
    Scalar.isInfinite()
  - isLowerLeftShaded
```
public boolean isLowerLeftShaded()
```
    Description copied from interface: MatrixStore
    
    The entries below (left of) the first subdiagonal are zero - effectively an upper Hessenberg matrix.
    
    Specified by:
    
    isLowerLeftShaded in interface MatrixStore<Double>
    
    See Also:
    
    MatrixStore.isUpperRightShaded()
  - isNaN
```
public boolean isNaN(long index)
```
    Specified by:
    
    isNaN in interface Access1D.Elements
    
    See Also:
    
    Scalar.isNaN()
  - isNaN
```
public boolean isNaN(long row,
                     long column)
```
    Specified by:
    
    isNaN in interface Access2D.Elements
    
    See Also:
    
    Scalar.isNaN()
  - isPositive
```
public boolean isPositive(long index)
```
    Specified by:
    
    isPositive in interface Access1D.Elements
    
    See Also:
    
    Scalar.isPositive()
  - isPositive
```
public boolean isPositive(long row,
                          long column)
```
    Specified by:
    
    isPositive in interface Access2D.Elements
    
    See Also:
    
    Scalar.isPositive()
  - isReal
```
public boolean isReal(long index)
```
    Specified by:
    
    isReal in interface Access1D.Elements
    
    See Also:
    
    Scalar.isReal()
  - isReal
```
public boolean isReal(long row,
                      long column)
```
    Specified by:
    
    isReal in interface Access2D.Elements
    
    See Also:
    
    Scalar.isReal()
  - isScalar
```
public boolean isScalar()
```
    Specified by:
    
    isScalar in interface BasicMatrix<Double>
    
    Returns:
    
    true if this is a 1x1 matrix
  - isSquare
```
public boolean isSquare()
```
    Description copied from interface: BasicMatrix
    
    Matrices are either square, tall, fat or empty. m = n <> 0
    
    Specified by:
    
    isSquare in interface BasicMatrix<Double>
    
    Returns:
    
    true if matrix is square
  - isSymmetric
```
public boolean isSymmetric()
```
    Specified by:
    
    isSymmetric in interface BasicMatrix<Double>
  - isTall
```
public boolean isTall()
```
    Description copied from interface: BasicMatrix
    
    Matrices are either square, tall, fat or empty. m > n >= 1
    
    Specified by:
    
    isTall in interface BasicMatrix<Double>
    
    Returns:
    
    true if matrix is tall
  - isUpperRightShaded
```
public boolean isUpperRightShaded()
```
    Description copied from interface: MatrixStore
    
    The entries above (right of) the first superdiagonal are zero - effectively a lower Hessenberg matrix.
    
    Specified by:
    
    isUpperRightShaded in interface MatrixStore<Double>
    
    See Also:
    
    MatrixStore.isLowerLeftShaded()
  - isVector
```
public boolean isVector()
```
    Specified by:
    
    isVector in interface BasicMatrix<Double>
    
    Returns:
    
    true if the row or column dimensions are equal to 1.
  - isZero
```
public boolean isZero(long index)
```
    Specified by:
    
    isZero in interface Access1D.Elements
    
    See Also:
    
    Scalar.isZero()
  - isZero
```
public boolean isZero(long row,
                      long column)
```
    Specified by:
    
    isZero in interface Access2D.Elements
    
    See Also:
    
    Scalar.isZero()
  - iterator
```
public final Iterator<Double> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Double>
  - 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>
  - mergeColumns
```
public JamaMatrix mergeColumns(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    [aMtrx] is appended to the bottom of [this]. The two matrices must have the same number of columns.
    
    Specified by:
    
    mergeColumns in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - The matrix to merge.
    
    Returns:
    
    A new matrix with more rows.
  - mergeRows
```
public JamaMatrix mergeRows(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    [aMtrx] is appended to the right side of [this]. The two matrices must have the same number of rows.
    
    Specified by:
    
    mergeRows in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - The matrix to merge.
    
    Returns:
    
    A new matrix with more columns.
  - modify
```
public JamaMatrix modify(UnaryFunction<Double> function)
```
    Specified by:
    
    modify in interface BasicMatrix<Double>
  - modifyAll
```
public void modifyAll(UnaryFunction<Double> function)
```
    Specified by:
    
    modifyAll in interface Access1D.Modifiable<Double>
  - modifyColumn
```
public void modifyColumn(long row,
                         long column,
                         UnaryFunction<Double> function)
```
    Specified by:
    
    modifyColumn in interface Access2D.Modifiable<Double>
  - modifyDiagonal
```
public void modifyDiagonal(long row,
                           long column,
                           UnaryFunction<Double> function)
```
    Specified by:
    
    modifyDiagonal in interface Access2D.Modifiable<Double>
  - modifyOne
```
public void modifyOne(long row,
                      long column,
                      UnaryFunction<Double> function)
```
    Specified by:
    
    modifyOne in interface PhysicalStore<Double>
  - modifyRange
```
public void modifyRange(long first,
                        long limit,
                        UnaryFunction<Double> function)
```
    Specified by:
    
    modifyRange in interface Access1D.Modifiable<Double>
  - modifyRow
```
public void modifyRow(long row,
                      long column,
                      UnaryFunction<Double> function)
```
    Specified by:
    
    modifyRow in interface Access2D.Modifiable<Double>
  - multiply
```
public JamaMatrix multiply(Number aNmbr)
```
    Description copied from interface: BasicMatrix
    
    Multiplies the elements of this matrix with aNmbr.
    
    Specified by:
    
    multiply in interface BasicMatrix<Double>
    
    Parameters:
    
    aNmbr - What to multiply with.
    
    Returns:
    
    A new matrix whos elements are the elements of this multiplied with aNmbr.
  - multiplyElements
```
public JamaMatrix multiplyElements(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    Multiplies the elements of this matrix with the elements of aMtrx. The matrices must have equal dimensions.
    
    Specified by:
    
    multiplyElements in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - The elements to multiply by.
    
    Returns:
    
    A new matrix whos elements are the elements of this multiplied with the elements of aMtrx.
  - multiplyLeft
```
public JamaMatrix multiplyLeft(Access1D<Double> leftMtrx)
```
    Specified by:
    
    multiplyLeft in interface MatrixStore<Double>
  - multiplyLeft
```
public JamaMatrix multiplyLeft(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    Matrix multiplication: [aMtrx][this]
    The column dimension of the left matrix must equal the row dimension of the right matrix.
    
    Specified by:
    
    multiplyLeft in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - The left matrix.
    
    Returns:
    
    The product.
    
    See Also:
    
    org.ojalgo.matrix.BasicMatrix#multiplyRight(BasicMatrix)
  - multiplyRight
```
public JamaMatrix multiplyRight(Access1D<Double> rightMtrx)
```
    Specified by:
    
    multiplyRight in interface MatrixStore<Double>
  - multiplyRight
```
public JamaMatrix multiplyRight(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    Matrix multiplication: [this][aMtrx]
    The column dimension of the left matrix must equal the row dimension of the right matrix.
    
    Specified by:
    
    multiplyRight in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - The right matrix.
    
    Returns:
    
    The product.
    
    See Also:
    
    org.ojalgo.matrix.BasicMatrix#multiplyLeft(BasicMatrix)
  - multiplyVectors
```
public PrimitiveScalar multiplyVectors(Access2D<?> aVctr)
```
    Description copied from interface: BasicMatrix
    
    Assumes that both [this] and [aVctr] have row or column dimension, doesn't matter which, equal to 1. The two vectors must have the same number of elements.
    
    Specified by:
    
    multiplyVectors in interface BasicMatrix<Double>
  - negate
```
public JamaMatrix negate()
```
    Specified by:
    
    negate in interface BasicMatrix<Double>
    
    Specified by:
    
    negate in interface MatrixStore<Double>
    
    Returns:
    
    A new matrix with negated elements.
  - 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>
  - round
```
public JamaMatrix round(NumberContext aCntxt)
```
    Specified by:
    
    round in interface BasicMatrix<Double>
    
    Returns:
  - scale
```
public JamaMatrix scale(Double scalar)
```
    Specified by:
    
    scale in interface MatrixStore<Double>
  - selectColumns
```
public JamaMatrix selectColumns(int... someCols)
```
    Specified by:
    
    selectColumns in interface BasicMatrix<Double>
    
    Parameters:
    
    someCols - An ordered array of column indeces.
    
    Returns:
    
    A matrix with a subset of, reordered, columns.
  - selectRows
```
public JamaMatrix selectRows(int... someRows)
```
    Specified by:
    
    selectRows in interface BasicMatrix<Double>
    
    Parameters:
    
    someRows - An ordered array of row indeces.
    
    Returns:
    
    A matrix with a subset of, reordered, rows.
  - set
```
public Double set(int anInd,
                  Number value)
```
  - set
```
public void set(long index,
                double value)
```
    Specified by:
    
    set in interface Access1D.Fillable<Double>
  - set
```
public void set(long row,
                long column,
                double aNmbr)
```
    Specified by:
    
    set in interface Access2D.Fillable<Double>
  - set
```
public void set(long row,
                long column,
                Number aNmbr)
```
    Specified by:
    
    set in interface Access2D.Fillable<Double>
  - set
```
public void set(long index,
                Number value)
```
    Specified by:
    
    set in interface Access1D.Fillable<Double>
  - size
```
public int size()
```
  - solve
```
public JamaMatrix solve(Access2D<?> aRHS)
```
    Description copied from interface: BasicMatrix
    This method solves a system of linear equations: [this][X]=[aRHS]. A combination of columns in [this] should produce a column in [aRHS]. It is ok for [aRHS] to have more than 1 column.
    - If the problem is over-qualified an approximate solution is returned.
    - If the problem is under-qualified one possible solution is returned.
    Remember that: [X][this]=[aRHS] is equivalent to [this]^T[X]^T=[aRHS]^T
    Specified by:
    
    solve in interface BasicMatrix<Double>
    
    Parameters:
    
    aRHS - The right hand side of the equation.
    
    Returns:
    
    The solution, [X].
  - subtract
```
public JamaMatrix subtract(Access2D<?> aMtrx)
```
    Description copied from interface: BasicMatrix
    
    Subtracts the elements of aMtrx from the elements of this matrix. The matrices must have equal dimensions.
    
    Specified by:
    
    subtract in interface BasicMatrix<Double>
    
    Parameters:
    
    aMtrx - What to subtract.
    
    Returns:
    
    A new matrix whos elements are the difference of this' and aMtrx'.
  - subtract
```
public MatrixStore<Double> subtract(MatrixStore<Double> subtrahend)
```
    Specified by:
    
    subtract in interface MatrixStore<Double>
  - subtract
```
public JamaMatrix subtract(Number value)
```
    Description copied from interface: BasicMatrix
    
    Subtracts aNmbr from the elements of this matrix.
    
    Specified by:
    
    subtract in interface BasicMatrix<Double>
    
    Parameters:
    
    value - What to subtract.
    
    Returns:
    
    A new matrix whos elements are the differences between this' elements and aNmbr.
  - toBigDecimal
```
public BigDecimal toBigDecimal(int row,
                               int column)
```
    Description copied from interface: BasicMatrix
    
    Extracts one element of this matrix as a BigDecimal.
    
    Specified by:
    
    toBigDecimal in interface BasicMatrix<Double>
    
    Parameters:
    
    row - A row index.
    
    column - A column index.
    
    Returns:
    
    One matrix element
  - toBigStore
```
public PhysicalStore<BigDecimal> toBigStore()
```
    Description copied from interface: BasicMatrix
    
    Must be a copy that is safe to modify.
    
    Specified by:
    
    toBigStore in interface BasicMatrix<Double>
    
    See Also:
    
    BasicMatrix.toComplexStore(), BasicMatrix.toPrimitiveStore()
  - toComplexNumber
```
public ComplexNumber toComplexNumber(int row,
                                     int column)
```
    Description copied from interface: BasicMatrix
    
    Extracts one element of this matrix as a ComplexNumber.
    
    Specified by:
    
    toComplexNumber in interface BasicMatrix<Double>
    
    Parameters:
    
    row - A row index.
    
    column - A column index.
    
    Returns:
    
    One matrix element
  - toComplexStore
```
public PhysicalStore<ComplexNumber> toComplexStore()
```
    Description copied from interface: BasicMatrix
    
    Must be a copy that is safe to modify.
    
    Specified by:
    
    toComplexStore in interface BasicMatrix<Double>
    
    See Also:
    
    BasicMatrix.toBigStore(), BasicMatrix.toPrimitiveStore()
  - toListOfColumns
```
public List<BasicMatrix<Double>> toListOfColumns()
```
    Specified by:
    
    toListOfColumns in interface BasicMatrix<Double>
  - toListOfElements
```
public List<Double> toListOfElements()
```
    Description copied from interface: BasicMatrix
    
    It is also possible to call BasicMatrix.toBigStore(), BasicMatrix.toComplexStore() or BasicMatrix.toPrimitiveStore() and then PhysicalStore.asList().
    
    Specified by:
    
    toListOfElements in interface BasicMatrix<Double>
  - toListOfRows
```
public List<BasicMatrix<Double>> toListOfRows()
```
    Specified by:
    
    toListOfRows in interface BasicMatrix<Double>
  - toPrimitiveStore
```
public JamaMatrix toPrimitiveStore()
```
    Description copied from interface: BasicMatrix
    
    Must be a copy that is safe to modify.
    
    Specified by:
    
    toPrimitiveStore in interface BasicMatrix<Double>
    
    See Also:
    
    BasicMatrix.toBigStore(), BasicMatrix.toComplexStore()
  - toScalar
```
public PrimitiveScalar toScalar(long row,
                                long column)
```
    Description copied from interface: BasicMatrix
    
    Extracts one element of this matrix as a Scalar.
    
    Specified by:
    
    toScalar in interface BasicMatrix<Double>
    
    Specified by:
    
    toScalar in interface MatrixStore<Double>
    
    Parameters:
    
    row - A row index.
    
    column - A column index.
    
    Returns:
    
    One matrix element
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(int row,
                       int column)
```
    Specified by:
    
    toString in interface BasicMatrix<Double>
  - transformLeft
```
public void transformLeft(Householder<Double> transformation,
                          int firstColumn)
```
    Specified by:
    
    transformLeft in interface PhysicalStore<Double>
  - transformLeft
```
public void transformLeft(Rotation<Double> transformation)
```
    Description copied from interface: PhysicalStore
    
    As in MatrixStore#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<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#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 JamaMatrix transpose()
```
    Description copied from interface: BasicMatrix
    
    Transposes this matrix. For complex matrices conjugate() and transpose() are NOT EQUAL.
    
    Specified by:
    
    transpose in interface BasicMatrix<Double>
    
    Specified by:
    
    transpose in interface MatrixStore<Double>
    
    Returns:
    
    A matrix that is the transpose of this matrix.
    
    See Also:
    
    BasicMatrix.conjugate()
  - update
```
public final void update(int aFirstRow,
                         int aRowCount,
                         int aFirstCol,
                         int aColCount,
                         JamaMatrix aMtrx)
```
  - update
```
public final void update(int aFirstRow,
                         int aRowCount,
                         int[] someColumns,
                         JamaMatrix aMtrx)
```
  - update
```
public final void update(int row,
                         int column,
                         Number aNmbr)
```
  - update
```
public final void update(int[] someRows,
                         int aFirstCol,
                         int aColCount,
                         JamaMatrix aMtrx)
```
  - update
```
public final void update(int[] someRows,
                         int[] someColumns,
                         JamaMatrix aMtrx)
```
  - visitAll
```
public void visitAll(VoidFunction<Double> visitor)
```
    Specified by:
    
    visitAll in interface Access1D.Visitable<Double>
  - visitColumn
```
public void visitColumn(long row,
                        long column,
                        VoidFunction<Double> visitor)
```
    Specified by:
    
    visitColumn in interface Access2D.Visitable<Double>
  - visitDiagonal
```
public void visitDiagonal(long row,
                          long column,
                          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 column,
                     VoidFunction<Double> visitor)
```
    Specified by:
    
    visitRow in interface Access2D.Visitable<Double>

Class JamaMatrix

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.matrix.BasicMatrix

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

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

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

FACTORY

Constructor Detail

JamaMatrix

JamaMatrix

Method Detail

getBuilder

getBuilder

add

add

add

add

add

aggregateAll

asList

builder

caxpy

conjugate

copy

copyToBuilder

count

countColumns

countRows

divide

divideElements

doubleValue

doubleValue

enforce

equals

equals

equals

exchangeColumns

exchangeRows

factory

fillAll

fillByMultiplying

fillColumn

fillConjugated

fillDiagonal

fillMatching

fillMatching

fillMatching

fillMatching

fillRange

fillRow

fillTransposed

flushCache

get

get

getColDim

getColumnsRange

getCondition

getDeterminant

getEigenvalues

getFrobeniusNorm

getInfinityNorm

getKyFanNorm

getMaxDim

getMinDim

getOneNorm

getOperatorNorm

getRank

getRowDim

getRowsRange

getSingularValues

getTrace

getTraceNorm

getVectorNorm

hashCode