RationalMatrix (ojAlgo 45.1.1 API)

java.lang.Object
- org.ojalgo.matrix.RationalMatrix

All Implemented Interfaces:

Serializable, Iterable<Number>, Access1D<Number>, Access1D.Aggregatable<Number>, Access1D.Elements, Access2D<Number>, Access2D.Aggregatable<Number>, Access2D.Elements, Structure1D, Structure2D, Structure2D.ReducibleTo1D<BasicMatrix>, Group, Group.Additive<BasicMatrix>, NormedVectorSpace<BasicMatrix,Number>, Operation, Operation.Addition<BasicMatrix>, Operation.Multiplication<BasicMatrix>, Operation.Subtraction<BasicMatrix>, ScalarOperation, ScalarOperation.Addition<BasicMatrix,Number>, ScalarOperation.Division<BasicMatrix,Number>, ScalarOperation.Multiplication<BasicMatrix,Number>, ScalarOperation.Subtraction<BasicMatrix,Number>, VectorSpace<BasicMatrix,Number>, BasicMatrix
```
public final class RationalMatrix
extends Object
```
RationalMatrix

Author:

apete

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface org.ojalgo.matrix.BasicMatrix
  BasicMatrix.Builder<I extends BasicMatrix>, BasicMatrix.Factory<I extends BasicMatrix>
- 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.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
- 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>

Field Summary

Fields
Modifier and Type Field and Description

static BasicMatrix.Factory<RationalMatrix> FACTORY

Fields
Modifier and Type	Field and Description
`static BasicMatrix.Factory<RationalMatrix>`	`FACTORY`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`I`	`add(BasicMatrix addend)`
`I`	`add(double scalarAddend)`
`I`	`add(int row, int col, Access2D<?> addend)`
`I`	`add(Number scalarAddend)`
`N`	`aggregateColumn(long row, long col, Aggregator aggregator)`
`N`	`aggregateDiagonal(long row, long col, Aggregator aggregator)`
`N`	`aggregateRange(long first, long limit, Aggregator aggregator)`
`N`	`aggregateRow(long row, long col, Aggregator aggregator)`
`I`	`conjugate()` This method will (most likely) be moved to some other interface in the future! Just have to figure out where it fits...
`BasicMatrix.Builder<I>`	`copy()`
`long`	`count()` count() == countRows() * countColumns()
`long`	`countColumns()`
`long`	`countRows()`
`I`	`divide(double scalarDivisor)`
`I`	`divide(Number scalarDivisor)`
`I`	`divideElements(Access2D<?> divisor)` Divides the elements of this with the elements of aMtrx.
`double`	`doubleValue(long index)`
`double`	`doubleValue(long i, long j)` Extracts one element of this matrix as a double.
`I`	`enforce(NumberContext context)` Will enforce this number context on the elements
`boolean`	`equals(Access2D<?> aMtrx, NumberContext aCntxt)`
`boolean`	`equals(Object obj)`
`void`	`flushCache()` BasicMatrix instances are intended to be immutable.
`N`	`get(long index)`
`N`	`get(long aRow, long aColumn)`
`I`	`getColumnsRange(int first, int limit)`
`Scalar<N>`	`getCondition()` Matrix condition (2-norm)
`Scalar<N>`	`getDeterminant()`
`List<ComplexNumber>`	`getEigenvalues()`
`Scalar<N>`	`getFrobeniusNorm()`
`Scalar<N>`	`getInfinityNorm()`
`Scalar<N>`	`getKyFanNorm(int k)`
`Scalar<N>`	`getOneNorm()`
`Scalar<N>`	`getOperatorNorm()` Deprecated. v40 Use `SingularValue`
`int`	`getRank()` The rank of a matrix is the (maximum) number of linearly independent rows or columns it contains.
`I`	`getRowsRange(int first, int limit)`
`List<Double>`	`getSingularValues()`
`Scalar<N>`	`getTrace()` The sum of the diagonal elements.
`Scalar<N>`	`getTraceNorm()`
`Scalar<N>`	`getVectorNorm(int degree)` Deprecated. v40 Use `Access1D.Aggregatable.aggregateAll(org.ojalgo.function.aggregator.Aggregator)`
`int`	`hashCode()`
`I`	`invert()` About inverting matrices:
`boolean`	`isAbsolute(long row, long col)`
`boolean`	`isFullRank()`
`boolean`	`isHermitian()`
`boolean`	`isSmall(double comparedTo)`
`boolean`	`isSmall(long row, long col, double comparedTo)`
`boolean`	`isSymmetric()`
`I`	`mergeColumns(Access2D<?> belowRows)` [belowRows] is appended below [this].
`I`	`mergeRows(Access2D<?> rightColumns)` [rightColumns] is appended to the right of [this].
`I`	`modify(UnaryFunction<? extends Number> modifier)`
`I`	`multiply(BasicMatrix multiplicand)`
`I`	`multiply(double scalarMultiplicand)`
`I`	`multiply(Number scalarMultiplicand)`
`I`	`multiplyElements(Access2D<?> multiplicand)` Multiplies the elements of this matrix with the elements of aMtrx.
`I`	`negate()` The additive inverse of this.
`double`	`norm()` 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.
`I`	`reduceColumns(Aggregator aggregator)`
`I`	`reduceRows(Aggregator aggregator)`
`I`	`selectColumns(int... someCols)`
`I`	`selectRows(int... someRows)`
`I`	`signum()` `this == this.signum().multiply(this.norm())`
`I`	`solve(Access2D<?> rhs)` This method solves a system of linear equations: [this][X]=[aRHS].
`I`	`subtract(BasicMatrix subtrahend)`
`BasicMatrix`	`subtract(double scalarSubtrahend)`
`I`	`subtract(Number scalarSubtrahend)`
`Scalar<N>`	`toScalar(long row, long col)` Extracts one element of this matrix as a Scalar.
`String`	`toString()`
`I`	`transpose()` Transposes this matrix.

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

Methods inherited from interface org.ojalgo.matrix.BasicMatrix
calculateFrobeniusNorm, calculateInfinityNorm, calculateOneNorm, toString

Methods inherited from interface org.ojalgo.access.Access2D
asCollectable2D, asPrimitive2D, columns, elements, equals, 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
isAbsolute, isColumnSmall, isColumnSmall, isRowSmall, isRowSmall, isSmall

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

Methods inherited from interface org.ojalgo.access.Access2D.Aggregatable
aggregateColumn, aggregateRow, reduceColumns, reduceRows

Methods inherited from interface org.ojalgo.access.Access1D.Aggregatable
aggregateAll

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.Structure1D
loopAll, loopMatching, loopRange, mapper

- Field Detail
  - FACTORY
```
public static final BasicMatrix.Factory<RationalMatrix> FACTORY
```
- Method Detail
  - add
```
public I add(BasicMatrix addend)
```
    Specified by:
    
    add in interface Operation.Addition<BasicMatrix>
    
    Parameters:
    
    addend - What to add
    
    Returns:
    
    this + addend
  - add
```
public I add(double scalarAddend)
```
    Specified by:
    
    add in interface ScalarOperation.Addition<BasicMatrix,Number>
    
    Returns:
    
    this + scalarAddend.
  - add
```
public I add(int row,
             int col,
             Access2D<?> addend)
```
    Specified by:
    
    add in interface BasicMatrix
    
    Parameters:
    
    row - The row index of where to superimpose the top left element of the addend
    
    col - The column index of where to superimpose the top left element of the addend
    
    addend - A matrix to superimpose
    
    Returns:
    
    A new matrix
  - add
```
public I add(Number scalarAddend)
```
    Specified by:
    
    add in interface ScalarOperation.Addition<BasicMatrix,Number>
    
    Returns:
    
    this + scalarAddend.
  - aggregateColumn
```
public N aggregateColumn(long row,
                         long col,
                         Aggregator aggregator)
```
    Specified by:
    
    aggregateColumn in interface Access2D.Aggregatable<Number>
  - aggregateDiagonal
```
public N aggregateDiagonal(long row,
                           long col,
                           Aggregator aggregator)
```
    Specified by:
    
    aggregateDiagonal in interface Access2D.Aggregatable<Number>
  - aggregateRange
```
public N aggregateRange(long first,
                        long limit,
                        Aggregator aggregator)
```
    Specified by:
    
    aggregateRange in interface Access1D.Aggregatable<Number>
  - aggregateRow
```
public N aggregateRow(long row,
                      long col,
                      Aggregator aggregator)
```
    Specified by:
    
    aggregateRow in interface Access2D.Aggregatable<Number>
  - conjugate
```
public I conjugate()
```
    Description copied from interface: VectorSpace
    
    This method will (most likely) be moved to some other interface in the future! Just have to figure out where it fits...
    
    The conjugate transpose of a matrix and/or the conjugate of a scalar/field like ComplexNumber or Quaternion.
    
    The conjugate transpose of a real matrix is simply its transpose.
    
    Specified by:
    
    conjugate in interface VectorSpace<BasicMatrix,Number>
  - copy
```
public BasicMatrix.Builder<I> copy()
```
    Specified by:
    
    copy in interface BasicMatrix
    
    Returns:
    
    A fully mutable matrix builder with the elements initially set to a copy of this matrix.
  - 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
  - divide
```
public I divide(double scalarDivisor)
```
    Specified by:
    
    divide in interface ScalarOperation.Division<BasicMatrix,Number>
    
    Returns:
    
    this / scalarDivisor.
  - divide
```
public I divide(Number scalarDivisor)
```
    Specified by:
    
    divide in interface ScalarOperation.Division<BasicMatrix,Number>
    
    Returns:
    
    this / scalarDivisor.
  - divideElements
```
public I divideElements(Access2D<?> divisor)
```
    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
    
    Parameters:
    
    divisor - 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 index)
```
    Specified by:
    
    doubleValue in interface Access1D<Number>
    
    Specified by:
    
    doubleValue in interface Access2D<Number>
  - doubleValue
```
public double doubleValue(long i,
                          long j)
```
    Description copied from interface: Access2D
    
    Extracts one element of this matrix as a double.
    
    Specified by:
    
    doubleValue in interface Access2D<Number>
    
    Parameters:
    
    i - A row index.
    
    j - A column index.
    
    Returns:
    
    One matrix element
  - enforce
```
public I enforce(NumberContext context)
```
    Description copied from interface: BasicMatrix
    
    Will enforce this number context on the elements
    
    Specified by:
    
    enforce in interface BasicMatrix
    
    Parameters:
    
    context - The context
    
    Returns:
    
    A new matrix with the elements enforced
  - equals
```
public boolean equals(Access2D<?> aMtrx,
                      NumberContext aCntxt)
```
    Specified by:
    
    equals in interface BasicMatrix
    
    Returns:
    
    true if the frobenius norm of the difference between [this] and [aStore] is zero within the limits of aCntxt.
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - 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
  - get
```
public N get(long index)
```
    Specified by:
    
    get in interface Access1D<Number>
    
    Specified by:
    
    get in interface Access2D<Number>
  - get
```
public N get(long aRow,
             long aColumn)
```
    Specified by:
    
    get in interface Access2D<Number>
  - getColumnsRange
```
public I getColumnsRange(int first,
                         int limit)
```
    Specified by:
    
    getColumnsRange in interface BasicMatrix
    
    Parameters:
    
    first - The first column to include.
    
    limit - The limit (exclusive) - the first column not to include.
    
    Returns:
    
    A new matrix with only the specified range of columns
  - getCondition
```
public Scalar<N> getCondition()
```
    Description copied from interface: BasicMatrix
    
    Matrix condition (2-norm)
    
    Specified by:
    
    getCondition in interface BasicMatrix
    
    Returns:
    
    ratio of largest to smallest singular value.
  - getDeterminant
```
public Scalar<N> getDeterminant()
```
    Specified by:
    
    getDeterminant in interface BasicMatrix
    
    Returns:
    
    The matrix' determinant.
  - getEigenvalues
```
public List<ComplexNumber> getEigenvalues()
```
    Specified by:
    
    getEigenvalues in interface BasicMatrix
  - getFrobeniusNorm
```
public Scalar<N> getFrobeniusNorm()
```
  - getInfinityNorm
```
public Scalar<N> getInfinityNorm()
```
  - getKyFanNorm
```
public Scalar<N> getKyFanNorm(int k)
```
  - getOneNorm
```
public Scalar<N> getOneNorm()
```
  - getOperatorNorm
```
@Deprecated
public Scalar<N> getOperatorNorm()
```
    Deprecated. v40 Use SingularValue
    
    2-norm, max singular value
  - 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
    
    Returns:
    
    The matrix' rank.
  - getRowsRange
```
public I getRowsRange(int first,
                      int limit)
```
    Specified by:
    
    getRowsRange in interface BasicMatrix
    
    Parameters:
    
    first - The first row to include.
    
    limit - 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
  - getTrace
```
public Scalar<N> getTrace()
```
    Description copied from interface: BasicMatrix
    
    The sum of the diagonal elements.
    
    Specified by:
    
    getTrace in interface BasicMatrix
    
    Returns:
    
    The matrix' trace.
  - getTraceNorm
```
public Scalar<N> getTraceNorm()
```
  - getVectorNorm
```
@Deprecated
public Scalar<N> getVectorNorm(int degree)
```
    Deprecated. v40 Use Access1D.Aggregatable.aggregateAll(org.ojalgo.function.aggregator.Aggregator)
    
    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.
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - invert
```
public I invert()
```
    Description copied from interface: BasicMatrix
    About inverting matrices:
    - "right inverse": [this][right inverse]=[I]. You may calculate it using BasicMatrix.solve(Access2D).
    - "left inverse": [left inverse][this]=[I]. You may calculate it using BasicMatrix.solve(Access2D) 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
    
    Returns:
    
    The "best possible" inverse....
  - isAbsolute
```
public boolean isAbsolute(long row,
                          long col)
```
    Specified by:
    
    isAbsolute in interface Access2D.Elements
    
    See Also:
    
    Scalar.isAbsolute()
  - isFullRank
```
public boolean isFullRank()
```
    Specified by:
    
    isFullRank in interface BasicMatrix
    
    Returns:
    
    true if BasicMatrix.getRank() == min(Structure2D.countRows(), Structure2D.countColumns())
  - isHermitian
```
public boolean isHermitian()
```
    Specified by:
    
    isHermitian in interface BasicMatrix
  - isSmall
```
public boolean isSmall(double comparedTo)
```
    Specified by:
    
    isSmall in interface NormedVectorSpace<BasicMatrix,Number>
    
    Parameters:
    
    comparedTo - What to compare with
    
    Returns:
    
    true if this is small compared to the magnitude of the input reference value.
  - isSmall
```
public boolean isSmall(long row,
                       long col,
                       double comparedTo)
```
    Specified by:
    
    isSmall in interface Access2D.Elements
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - isSymmetric
```
public boolean isSymmetric()
```
    Specified by:
    
    isSymmetric in interface BasicMatrix
  - mergeColumns
```
public I mergeColumns(Access2D<?> belowRows)
```
    Description copied from interface: BasicMatrix
    
    [belowRows] is appended below [this]. The two matrices must have the same number of columns.
    
    Specified by:
    
    mergeColumns in interface BasicMatrix
    
    Parameters:
    
    belowRows - The matrix to merge.
    
    Returns:
    
    A new matrix with more rows.
  - mergeRows
```
public I mergeRows(Access2D<?> rightColumns)
```
    Description copied from interface: BasicMatrix
    
    [rightColumns] is appended to the right of [this]. The two matrices must have the same number of rows.
    
    Specified by:
    
    mergeRows in interface BasicMatrix
    
    Parameters:
    
    rightColumns - The matrix to merge.
    
    Returns:
    
    A new matrix with more columns.
  - modify
```
public I modify(UnaryFunction<? extends Number> modifier)
```
    Specified by:
    
    modify in interface BasicMatrix
  - multiply
```
public I multiply(BasicMatrix multiplicand)
```
    Specified by:
    
    multiply in interface Operation.Multiplication<BasicMatrix>
    
    Parameters:
    
    multiplicand - The multiplicand
    
    Returns:
    
    this * multiplicand.
  - multiply
```
public I multiply(double scalarMultiplicand)
```
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<BasicMatrix,Number>
    
    Returns:
    
    this * scalarMultiplicand.
  - multiply
```
public I multiply(Number scalarMultiplicand)
```
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<BasicMatrix,Number>
    
    Returns:
    
    this * multiplicand.
  - multiplyElements
```
public I multiplyElements(Access2D<?> multiplicand)
```
    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
    
    Parameters:
    
    multiplicand - The elements to multiply by.
    
    Returns:
    
    A new matrix whos elements are the elements of this multiplied with the elements of aMtrx.
  - negate
```
public I negate()
```
    Description copied from interface: Group.Additive
    
    The additive inverse of this.
    
    Specified by:
    
    negate in interface Group.Additive<BasicMatrix>
    
    Returns:
    
    -this.
  - norm
```
public double norm()
```
    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. This definition fits the requirements of NormedVectorSpace.norm().
    
    Specified by:
    
    norm in interface NormedVectorSpace<BasicMatrix,Number>
    
    Returns:
    
    The matrix' Frobenius norm
  - reduceColumns
```
public I reduceColumns(Aggregator aggregator)
```
    Specified by:
    
    reduceColumns in interface Structure2D.ReducibleTo1D<BasicMatrix>
  - reduceRows
```
public I reduceRows(Aggregator aggregator)
```
    Specified by:
    
    reduceRows in interface Structure2D.ReducibleTo1D<BasicMatrix>
  - selectColumns
```
public I selectColumns(int... someCols)
```
    Specified by:
    
    selectColumns in interface BasicMatrix
    
    Parameters:
    
    someCols - An ordered array of column indeces.
    
    Returns:
    
    A matrix with a subset of, reordered, columns.
  - selectRows
```
public I selectRows(int... someRows)
```
    Specified by:
    
    selectRows in interface BasicMatrix
    
    Parameters:
    
    someRows - An ordered array of row indeces.
    
    Returns:
    
    A matrix with a subset of, reordered, rows.
  - signum
```
public I signum()
```
    Description copied from interface: NormedVectorSpace
    
    this == this.signum().multiply(this.norm())
    
    Specified by:
    
    signum in interface NormedVectorSpace<BasicMatrix,Number>
    
    Returns:
    
    A unit "vector"
  - solve
```
public I solve(Access2D<?> rhs)
```
    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
    
    Parameters:
    
    rhs - The right hand side of the equation.
    
    Returns:
    
    The solution, [X].
  - subtract
```
public I subtract(BasicMatrix subtrahend)
```
    Specified by:
    
    subtract in interface Operation.Subtraction<BasicMatrix>
    
    Parameters:
    
    subtrahend - The subtrahend
    
    Returns:
    
    this - subtrahend.
  - subtract
```
public BasicMatrix subtract(double scalarSubtrahend)
```
    Specified by:
    
    subtract in interface ScalarOperation.Subtraction<BasicMatrix,Number>
    
    Returns:
    
    this - scalarSubtrahend.
  - subtract
```
public I subtract(Number scalarSubtrahend)
```
    Specified by:
    
    subtract in interface ScalarOperation.Subtraction<BasicMatrix,Number>
    
    Returns:
    
    this - scalarSubtrahend.
  - toScalar
```
public Scalar<N> toScalar(long row,
                          long col)
```
    Description copied from interface: BasicMatrix
    
    Extracts one element of this matrix as a Scalar.
    
    Specified by:
    
    toScalar in interface BasicMatrix
    
    Parameters:
    
    row - A row index.
    
    col - A column index.
    
    Returns:
    
    One matrix element
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - transpose
```
public I transpose()
```
    Description copied from interface: BasicMatrix
    
    Transposes this matrix. For complex matrices conjugate() and transpose() are NOT EQUAL.
    
    Specified by:
    
    transpose in interface BasicMatrix
    
    Returns:
    
    A matrix that is the transpose of this matrix.
    
    See Also:
    
    VectorSpace.conjugate()

Class RationalMatrix

Nested Class Summary

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

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

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

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

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

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

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

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.matrix.BasicMatrix

Methods inherited from interface org.ojalgo.access.Access2D

Methods inherited from interface org.ojalgo.access.Access1D

Methods inherited from interface java.lang.Iterable

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

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

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

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

Methods inherited from interface org.ojalgo.access.Structure2D

Methods inherited from interface org.ojalgo.access.Structure1D

Field Detail

FACTORY

Method Detail

add

add

add

add

aggregateColumn

aggregateDiagonal

aggregateRange

aggregateRow

conjugate

copy

count

countColumns

countRows

divide

divide

divideElements

doubleValue

doubleValue

enforce

equals

equals

flushCache

get

get

getColumnsRange

getCondition

getDeterminant

getEigenvalues

getFrobeniusNorm

getInfinityNorm

getKyFanNorm

getOneNorm

getOperatorNorm

getRank

getRowsRange

getSingularValues

getTrace

getTraceNorm

getVectorNorm

hashCode

invert

isAbsolute

isFullRank

isHermitian

isSmall

isSmall

isSymmetric

mergeColumns

mergeRows

modify

multiply

multiply

multiply

multiplyElements

negate