Package com.mvohm.quadmatrix

Class QuadrupleMatrix

java.lang.Object
com.mvohm.quadmatrix.Matrix
com.mvohm.quadmatrix.QuadrupleMatrix
public class QuadrupleMatrix extends Matrix
An implementation of the abstract class Matrix that uses an array of Quadruple values to store the internal data and arithmetic provided by Quadruple to perform calculations.
Author:
M.Vokhmentsev

  • Constructor Summary

    Constructors
    Constructor
    Description
    QuadrupleMatrix(double[][] source)
    Creates a new QuadrupleMatrix whose inner data are obtained by converting the values of the given source array into corresponding Quadruple values without precision loss, and the default value of the needToScale flag.
    QuadrupleMatrix(double[][] source, boolean needToScale)
    Creates a new QuadrupleMatrix whose inner data are obtained by converting the values of the given source array into corresponding Quadruple values without precision loss, and the specified value of the needToScale flag that is passed in as the needToScale argument.
    QuadrupleMatrix(Matrix source)
    Creates a new QuadrupleMatrix with a copy of the data of the given source matrix and the default value of the needToScale flag.
    QuadrupleMatrix(Matrix source, boolean needToScale)
    Creates a new QuadrupleMatrix with a copy of the data of the given source matrix and the value of the needToScale flag that is passed in as the needToScale argument.
    QuadrupleMatrix(Number[][] source)
    Creates a new QuadrupleMatrix with a copy of the data of the given source array and the default value of the needToScale flag.
    QuadrupleMatrix(Number[][] source, boolean needToScale)
    Creates a new QuadrupleMatrix with a copy of the data of the given source array and the specified value of the needToScale flag.

  • Method Summary

    Modifier and Type
    Method
    Description
    Matrix
    add(double[][] matrixB)
    Adds the given matrixB passed in as a two-dimentional array of doubles to this matrix and returns the sum.
    Matrix
    add(Matrix matrixB)
    Adds the given matrixB to this matrix and returns the sum.
    Matrix
    add(Number[][] matrixB)
    Adds the given matrixB passed in as a two-dimentional array of Number to this matrix and returns the sum.
    double
    cond()
    Computes the condition number of the matrix, ║A║•║A-1║, and returns its value as a double value.
    Number
    determinant()
    Computes the determinant of the matrix and returns its value as a Number value.
    BigDecimal
    determinantAsBigDecimal()
    Computes the determinant of the matrix and returns its value as a BigDecimal value.
    double
    determinantAsDouble()
    Computes the determinant of the matrix and returns its value as a double value.
    Quadruple
    determinantAsQuadruple()
    Computes the determinant of the matrix and returns its value as a Quadruple value.
    boolean
    equals(Object anotherOne)
    Indicates whether the other Matrix is equal to this one.
    BigDecimal[][]
    getBigDecimalData()
    Returns a two-dimentional array of BigDecimal instances containing the values of the corresponding matrix elements.
    BigDecimal[][]
    getBigDecimalMatrixSolution()
    Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of BigDecimals.
    BigDecimal[]
    getBigDecimalSolution()
    Returns the last of the previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of BigDecimals.
    Number[][]
    getData()
    Returns a two-dimentional array of Number containing the values of the corresponding matrix elements.
    static boolean
    getDefaultScaling()
    Returns the value of the static #scaleByDefault flag that is used to set corresponding instance flags when creating a new instances by constructors without needToScale parameter.
    double[][]
    getDoubleData()
    Returns a two-dimentional array of primitive double values containing the values of the corresponding matrix elements, perhaps rounded.
    double[][]
    getDoubleMatrixSolution()
    Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of primitive doubles.
    double[]
    getDoubleSolution()
    Returns a copy of the last previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of doubles.
    String
    getErrorCode()
    Returns a string designation of the error code if an error has occurred during the solving or inversion of the matrix.
    Matrix
    getMatrixSolution()
    Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a Matrix.
    Number[][]
    getNumberMatrixSolution()
    Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of Number.
    Quadruple[][]
    getQuadrupleData()
    Returns a two-dimentional array of Quadruple instances containing the values of the corresponding matrix elements, perhaps rounded.
    Quadruple[][]
    getQuadrupleMatrixSolution()
    Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of Quadruples.
    Quadruple[]
    getQuadrupleSolution()
    Returns the last of the previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of Quadruples.
    boolean
    getScaling()
    Returns the value of an internal flag that defines whether row scaling will be applied while solving a system by this instance of Matrix.
    Number[]
    getSolution()
    Returns a copy of the last previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of Numbers.
    int
    hashCode()
    Returns a hash code value for the Matrix.
    Matrix
    inverse()
    Creates and returns a new Matrix instance containing the inversion of this instance.
    Matrix
    inverseAccurately()
    Creates and returns a new Matrix instance containing the inversion of this instance.
    Matrix
    multiply(double scalar)
    Multiplies this instance of Matrix by a scalar factor scalar passed in as a double parameter, and creates and returns a new matrix containing the product.
    Number[]
    multiply(double[] vector)
    Multiplies this instance of Matrix by a vector passed in as an array of doubles, and returns an array of Number values containing the product.
    Matrix
    multiply(double[][] factor)
    Multiplies this instance of Matrix by the factor passed in as a two-dimentional double array, and creates and returns a new matrix containing the product.
    Matrix
    multiply(Matrix factor)
    Multiplies this instance of Matrix by the matrix passed in as the factor argument, creates and returns a new matrix containing the product.
    Matrix
    multiply(Number scalar)
    Multiplies this instance of Matrix by a scalar factor scalar passed in as a Number parameter, and creates and returns a new matrix containing the product.
    Number[]
    multiply(Number[] vector)
    Multiplies this instance of Matrix by a vector passed in as an array of Number values and returns an array of Number values containing the product.
    Matrix
    multiply(Number[][] factor)
    Multiplies this instance of Matrix by the factor passed in as a two-dimentional array of Numbers, and creates and returns a new matrix containing the product.
    Number
    norm()
    Computes the row-based norm of the matrix, ║A║∞, and returns its value as a Number value.
    BigDecimal
    normAsBigDecimal()
    Computes the row-based norm of the matrix, ║A║∞, and returns its value as a BigDecimal value.
    double
    normAsDouble()
    Computes the row-based norm of the matrix, ║A║∞, and returns its value as a double value.
    Quadruple
    normAsQuadruple()
    Computes the row-based norm of the matrix, ║A║∞, and returns its value as a Quadruple value.
    static void
    setDefaultScaling(boolean scaleByDefault)
    Sets the value of the static scaleByDefault flag that is used to set corresponding instance flags when creating a new instances by constructors without needToScale parameter.
    Number[]
    solve(double[] vector)
    Solves a system of linear equations of form Ax = b and returns the found solution.
    Matrix
    solve(double[][] matrixB)
    Solves a matrix equation of form AX = B and returns the found solution.
    Matrix
    solve(Matrix matrixB)
    Solves a matrix equation of form AX = B and returns the found solution.
    Number[]
    solve(Number[] vector)
    Solves a system of linear equations of form Ax = b and returns the found solution.
    Matrix
    solve(Number[][] matrixB)
    Solves a matrix equation of form AX = B and returns the found solution.
    Number[]
    solveAccurately(double[] vector)
    Solves a system of linear equations of form Ax = b with increased accuracy and returns the found solution.
    Matrix
    solveAccurately(double[][] matrixB)
    Solves a matrix equation of form AX = B and returns the found solution.
    Matrix
    solveAccurately(Matrix matrixB)
    Solves a matrix equation of form AX = B and returns the found solution.
    Number[]
    solveAccurately(Number[] vector)
    Solves a system of linear equations of form Ax = b with increased accuracy and returns the found solution.
    Matrix
    solveAccurately(Number[][] matrixB)
    Solves a matrix equation of form AX = B and returns the found solution.
    Number[]
    solveSPD(double[] vector)
    Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients and returns the found solution.
    Number[]
    solveSPD(Number[] vector)
    Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients and returns the found solution.
    Number[]
    solveSPDAccurately(double[] vector)
    Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients, using an iterative refinement algorithm to achieve higher solution accuracy, and returns the found solution.
    Number[]
    solveSPDAccurately(Number[] vector)
    Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients, using an iterative refinement algorithm to achieve higher solution accuracy, and returns the found solution.
    Matrix
    subtract(double[][] matrixB)
    Subtracts the given matrixB passed in as a two-dimentional array of doubles from this matrix and returns the difference.
    Matrix
    subtract(Matrix matrixB)
    Subtracts the given matrixB from this matrix and returns the difference.
    Matrix
    subtract(Number[][] matrixB)
    Subtracts the given matrixB passed in as a two-dimentional array of Number from this matrix and returns the difference.
    Matrix
    transpose()
    Creates and returns a new Matrix instance containing the transposition of this instance.
    Matrix
    unity()
    Creates and returns a new Matrix instance containing a unity matrix of the same size as the source matrix.

    Methods inherited from class com.mvohm.quadmatrix.Matrix

    getSize

    Methods inherited from class java.lang.Object

    getClass, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • QuadrupleMatrix

      public QuadrupleMatrix(Matrix source)
      Creates a new QuadrupleMatrix with a copy of the data of the given source matrix and the default value of the needToScale flag.
      Uses static scaleByDefault value to set the new matrix's needToScale flag designating necessity to scale matrix rows before solving equation systems and inverting.
      Parameters:
      source - a matrix whose data get copied into the new Matrix's internal storage.
      See Also:

    • QuadrupleMatrix

      public QuadrupleMatrix(Matrix source, boolean needToScale)
      Creates a new QuadrupleMatrix with a copy of the data of the given source matrix and the value of the needToScale flag that is passed in as the needToScale argument.
      Uses the given needToScale value to set the new matrix's needToScale flag designating necessity to scale matrix rows while solving equation systems and inverting. The value of this flag can be obtained via getScaling() instance method.
      Parameters:
      source - a matrix whose data get copied into the new Matrix's internal storage.
      needToScale - the value defining necessity to scale rows while solving equation systems and inverting.
      See Also:

    • QuadrupleMatrix

      public QuadrupleMatrix(double[][] source)
      Creates a new QuadrupleMatrix whose inner data are obtained by converting the values of the given source array into corresponding Quadruple values without precision loss, and the default value of the needToScale flag.
      Uses static scaleByDefault value to set the new matrix's needToScale flag designating necessity to scale matrix rows before solving equation systems and inverting.
      Throws IllegalArgumentException if the source argument is a non-square or empty array, or contains non-numeric values, Double.NaN, Double.NEGATIVE_INFINITY, or Double.POSITIVE_INFINITY.
      Parameters:
      source - a two-dimentional square array of doubles to be converted into the Quadruple values of the internal storage of this instance.
      See Also:

    • QuadrupleMatrix

      public QuadrupleMatrix(double[][] source, boolean needToScale)
      Creates a new QuadrupleMatrix whose inner data are obtained by converting the values of the given source array into corresponding Quadruple values without precision loss, and the specified value of the needToScale flag that is passed in as the needToScale argument.
      Uses the given needToScale value to set the new matrix's needToScale flag designating necessity to scale matrix rows before solving equation systems and inverting. The value of this flag can be obtained via getScaling() instance method.
      Throws IllegalArgumentException if the source argument is a non-square or empty array, or contains non-numeric values, Double.NaN, Double.NEGATIVE_INFINITY, or Double.POSITIVE_INFINITY.
      Parameters:
      source - a two-dimentional square array of doubles to be converted into the Quadruple values of the internal storage of this instance.
      needToScale - the value defining necessity to scale rows while solving equation systems and inverting.
      See Also:

    • QuadrupleMatrix

      public QuadrupleMatrix(Number[][] source)
      Creates a new QuadrupleMatrix with a copy of the data of the given source array and the default value of the needToScale flag.
      Translates the values of the specified source array to Quadruple values using Quadruple constructors depending on the actual element type of the source array.
      Uses static scaleByDefault value to set the new matrix's needToScale flag designating necessity to scale matrix rows before solving equation systems and inverting.

      Throws IllegalArgumentException if the source argument is a non-square or empty array, or contains non-numeric values, Double.NaN, Double.NEGATIVE_INFINITY or Double.POSITIVE_INFINITY), or null.
      Parameters:
      source - a two-dimentional square array of Number values to be copied into the internal storage of this instance.
      See Also:

    • QuadrupleMatrix

      public QuadrupleMatrix(Number[][] source, boolean needToScale)
      Creates a new QuadrupleMatrix with a copy of the data of the given source array and the specified value of the needToScale flag.
      Translates the values of the specified source array to Quadruple values using Quadruple constructors depending on the actual element type of the source array.
      Uses the given needToScale value to set the new matrix's needToScale flag designating necessity to scale matrix rows while solving equation systems and inverting. The value of this flag can be obtained via getScaling() instance method.
      Uses static scaleByDefault value to set the new matrix's needToScale flag designating necessity to scale matrix rows before solving equation systems and inverting.
      Throws IllegalArgumentException if the source argument is a non-square or empty array, or contains non-numeric values, Double.NaN, Double.NEGATIVE_INFINITY or Double.POSITIVE_INFINITY), or null.
      Parameters:
      source - a two-dimentional square array of Number values to be copied into the internal storage of this instance.
      needToScale - the value defining necessity to scale rows while solving equation systems and inverting.

  • Method Details

    • setDefaultScaling

      public static void setDefaultScaling(boolean scaleByDefault)
      Sets the value of the static scaleByDefault flag that is used to set corresponding instance flags when creating a new instances by constructors without needToScale parameter.
      This flag determines the need to scale the rows of the matrix before LU-decomposing it so that the values of their norms are close enough to each other. This may increase the accuracy of the solution and the inversion, especially for matrices with a significantly non-uniform distribution of element values, at the cost of a insignificant increase in computation time.
      Parameters:
      scaleByDefault - the value of needToScale flag to set for new matrices created with constructors without needToScale parameter.

    • getDefaultScaling

      public static boolean getDefaultScaling()
      Returns the value of the static #scaleByDefault flag that is used to set corresponding instance flags when creating a new instances by constructors without needToScale parameter.
      Returns:
      the value of the static #scaleByDefault flag
      See Also:

    • getScaling

      public boolean getScaling()
      Returns the value of an internal flag that defines whether row scaling will be applied while solving a system by this instance of Matrix.
      Scaling of the rows of the matrix may be used while solving systems of linear equations. When an internal flag controlling the scaling is set to true, the rows of the matrix along with the corresponding elements of the vector b or the matrix B are scaled so that the norms of the rows are all be 1.0. In most cases this improves the accuracy of the solution, especially for matrices including both very large and very small elements. The default value of the flag signifying the necessity of the scaling for a certain subclass may be set via a static method setScaling() of the subclass, and the necessity of the scaling for a newly-created instance of Matrix may be controlled via the corresponding parameter of a constructor.
      Specified by:
      getScaling in class Matrix
      Returns:
      the value of the flag that defines whether the scaling will be applied while solving a system by this instance of Matrix

    • getData

      public Number[][] getData()
      Returns a two-dimentional array of Number containing the values of the corresponding matrix elements.
      The exact type of the array elements depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      The returned array is a copy of the corresponding internal array and can be safely modified. There is no loss of precision when copying, so the returned values are exactly equal to the values of the corresponding elements of the internal storage.
      QuadrupleMatrix returns a copy of the internal matrix data as a two-dimentional array of Quadruple.
      Specified by:
      getData in class Matrix
      Returns:
      a two-dimentional array of Number containing the values of the corresponding matrix elements.

    • getDoubleData

      public double[][] getDoubleData()
      Returns a two-dimentional array of primitive double values containing the values of the corresponding matrix elements, perhaps rounded.
      If the type of the internal data of the particular class enables for higher precision than that provided by double, the values get rounded to the nearest possible double value.
      If the value of an internal data element exceeds the range of double values, it gets converted to Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY, depending on its sign.
      QuadrupleMatrix returns an array containing values of the internal matrix data rounded to nearest double values.
      Specified by:
      getDoubleData in class Matrix
      Returns:
      a two-dimentional array of primitive double values containing rounded values of the corresponding elements of the internal data array

    • getQuadrupleData

      public Quadruple[][] getQuadrupleData()
      Returns a two-dimentional array of Quadruple instances containing the values of the corresponding matrix elements, perhaps rounded.
      If the type of the internal data of the particular class enables for higher precision than that provided by Quadruple, the values get rounded to the nearest possible Quadruple value.
      If the value of an internal data element exceeds the range of Quadruple values, it gets converted to Quadruple.POSITIVE_INFINITY or Quadruple.NEGATIVE_INFINITY, depending on its sign.
      QuadrupleMatrix returns an array containing the exact values of the corresponding elements of the internal storage.
      Specified by:
      getQuadrupleData in class Matrix
      Returns:
      a two-dimentional array of Quadruple values containing the values of the corresponding matrix elements, perhaps rounded.

    • getBigDecimalData

      public BigDecimal[][] getBigDecimalData()
      Returns a two-dimentional array of BigDecimal instances containing the values of the corresponding matrix elements.
      If the type of the internal data of the particular class is double then the corresponding BigDecimal values are obtained using BigDecimal.valueOf(double) method. If the type of the internal data of the particular class is Quadruple then the corresponding BigDecimal values are obtained using Quadruple.bigDecimalValue() method. If an internal data element is not convertible to BigDecimal (i.e. it is NaN or Infinity), throws NumberFormatException.
      QuadrupleMatrix returns an array containing the values of the corresponding elements of the internal storage, translated to BigDecimal values using Quadruple.bigDecimalValue().
      Specified by:
      getBigDecimalData in class Matrix
      Returns:
      a two-dimentional array of BigDecimal values containing the values of the corresponding matrix elements translated to BigDecimal instances.

    • equals

      public boolean equals(Object anotherOne)
      Indicates whether the other Matrix is equal to this one.
      Matrices are considered to be equal if they belong to the same subtype, and their internal arrays containing the elements of the matrices are equal, and their needToScale flags are equal.
      Under those condition, the matrices yield equal results for all operations performed on them.
      Specified by:
      equals in class Matrix
      Returns:
      true, if the matrices are equal.

    • hashCode

      public int hashCode()
      Returns a hash code value for the Matrix.
      It is guaranteed, that for two matrices returning different hashcodes their Matrix.equals(Object) methods return false, and two matrices considered to be equal return equal hashcodes. For two different matrices, the probability of the equality of their hashcodes is reasonably low.
      Specified by:
      hashCode in class Matrix
      Returns:
      a hash code value for this object.
      See Also:

    • solve

      public Number[] solve(double[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using LU decomposition.
      The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the length of the vector does not match the size of the matrix, or the argument contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      Before solving the equation, the values of the vector argument get converted to Quadruple values, using Quadruple(double) constructor.
      Specified by:
      solve in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of doubles
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix,, or the system has no solution or has infinitely many solutions, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null
      See Also:

    • solve

      public Number[] solve(Number[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using LU decomposition. Before solving, the given vector gets translated to an array of values of the type that is used to store internal matrix data (double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the length of the vector does not match the size of the matrix, or vector contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message. Before solving the equation, the values of the vector argument get converted to exactly equal or nearest possible Quadruple values, depending on the particular type of the vector elements.
      Specified by:
      solve in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of Numbers
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix, or the system has no solution or has infinitely many solutions, or the argument contains invalid values (NaN, Infinity, or null).
      NullPointerException - if the argument is null
      See Also:

    • solveSPD

      public Number[] solveSPD(double[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using Cholesky decomposition. The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an asymmetric or non-positively-defined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the length of the vector does not match the size of the matrix, or the argument contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      Before solving the equation, the values of the vector argument get converted to Quadruple values, using Quadruple(double) constructor.
      Specified by:
      solveSPD in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of Numbers
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix, or the matrix is asymmetric or not positively-defined, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null
      See Also:

    • solveSPD

      public Number[] solveSPD(Number[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using Cholesky decomposition. Before solving, the given vector gets translated to an array of values of the type that is used to store internal matrix data (double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc). The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an asymmetric or non-positively-defined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the length of the vector does not match the size of the matrix, or vector contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message. Before solving the equation, the values of the vector argument get converted to exactly equal or nearest possible Quadruple values, depending on the particular type of the vector elements.
      Specified by:
      solveSPD in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of Numbers
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix, or the matrix is asymmetric or not positively-defined, or the argument contains invalid values (NaN, Infinity, or null)
      NullPointerException - if the argument is null
      See Also:

    • solveAccurately

      public Number[] solveAccurately(double[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b with increased accuracy and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using LU decomposition. Uses an iterative refinement to find a more accurate solution. The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the length of the vector does not match the size of the matrix, or vector contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      The execution time is about 50% longer than that of the simple solve(double[]). In a typical case, the result error is reduced, compared to the simple solve(), by a factor from several units to several tens or a few hundreds, depending on the properties of the specific matrix data.
      For matrices 150 x 150 with uniformly-distributed random values, average square root of MSE is reduced by approximately 40 times, from about 2.5e-37 down to 6.3e-39.
      Specified by:
      solveAccurately in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of doubles
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix, or the system has no solution or has infinitely many solutions, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null
      See Also:

    • solveAccurately

      public Number[] solveAccurately(Number[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b with increased accuracy and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using LU decomposition. Before solving, the given vector gets translated to an array of values of the type that is used to store internal matrix data (double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      Uses an iterative refinement to find a more accurate solution. The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the length of the vector does not match the size of the matrix, or vector contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message.
      Before solving the equation, the values of the vector argument get converted to exactly equal or nearest possible Quadruple values, depending on the particular type of the vector elements.
      The execution time is about 50% longer than that of the simple solve(Number[]). In a typical case, the result error is reduced, compared to the simple solve(), by a factor from several units to several tens or a few hundreds, depending on the properties of the specific matrix data.
      For matrices 150 x 150 with uniformly-distributed random values, average square root of MSE is reduced by approximately 40 times, from about 2.5e-37 down to 6.3e-39.
      Specified by:
      solveAccurately in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of Numbers
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix, or the system has no solution or has infinitely many solutions, or the argument contains invalid values (NaN, Infinity, or null)
      NullPointerException - if the argument is null
      See Also:

    • solveSPDAccurately

      public Number[] solveSPDAccurately(double[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients, using an iterative refinement algorithm to achieve higher solution accuracy, and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using Cholesky decomposition. Uses an iterative refinement to find a more accurate solution. The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an asymmetric or non-SPD matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the length of the vector does not match the size of the matrix, or vector contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      The execution time is about 75% longer than that of the simple solveSPD(double[]). In a typical case, the result error is reduced, compared to the simple solveSPD(), by a factor of several units, depending on the properties of the specific matrix data.
      For matrices 150 x 150, average square root of MSE is reduced by approximately 5 times, from about 3.5e-38 down to 7.0e-39.
      Specified by:
      solveSPDAccurately in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of doubles
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix, or the matrix is asymmetric or not positively-defined, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null
      See Also:

    • solveSPDAccurately

      public Number[] solveSPDAccurately(Number[] vector) throws IllegalArgumentException, NullPointerException
      Solves a system of linear equations of form Ax = b for a symmetric positively-defined matrix of coefficients, using an iterative refinement algorithm to achieve higher solution accuracy, and returns the found solution.
      Solves the system Ax = b, formed by the inner matrix data A and the vector b passed in as the vector argument, using Cholesky decomposition. Uses an iterative refinement to find a more accurate solution. The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an asymmetric or non-SPD matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode(). If the length of the vector does not match the size of the matrix, or vector contains non-numeric values (NaN or Infinity) or null throws IllegalArgumentException with a relevant message.
      Before solving the equation, the values of the vector argument get converted to exactly equal or nearest possible Quadruple values, depending on the particular type of the vector elements.
      The execution time is about 75% longer than that of the simple solveSPD(double[]). In a typical case, the result error is reduced, compared to the simple solveSPD(), by a factor of several units, depending on the properties of the specific matrix data.
      For matrices 150 x 150, average square root of MSE is reduced by approximately 5 times, from about 3.5e-38 down to 7.0e-39.
      Specified by:
      solveSPDAccurately in class Matrix
      Parameters:
      vector - the column vector b of the equation to be solved, Ax = b, as an array of doubles
      Returns:
      the found solution x to the equation Ax = b as an array of Number instances. The particular type of the elements of the array returned by QuadrupleMatrix is Quadruple.
      Throws:
      IllegalArgumentException - if the length of the vector does not match the size of the matrix, or the matrix is asymmetric or not positively-defined, or the argument contains invalid values (NaN, Infinity, or null)
      NullPointerException - if the argument is null
      See Also:

    • getSolution

      public Number[] getSolution()
      Returns a copy of the last previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of Numbers.
      The exact type of the elements of the returned array depends on the particular subclass of this instance (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      If no system was solved with this instance of the Matrix, returns null.
      Specified by:
      getSolution in class Matrix
      Returns:
      the last of the previously found vector solutions, x, to a system of of linear equations of form Ax = b, as an array of Quadruples, or null, if no system was solved with the matrix.

    • getDoubleSolution

      public double[] getDoubleSolution()
      Returns a copy of the last previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of doubles.
      If the particular subtype of the instance stores internal data with higher precision than that provided by double, the values of the elements of the returned vector get rounded to the nearest double values.
      If no system was solved with this instance of the Matrix, returns null.
      The elements of the array returned by QudrupleMatrix are corresponded values of the found solution, rounded to the closest double values
      Specified by:
      getDoubleSolution in class Matrix
      Returns:
      the last of the previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of primitive doubles. or null, if no system was solved with the matrix.

    • getQuadrupleSolution

      public Quadruple[] getQuadrupleSolution()
      Returns the last of the previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of Quadruples.
      If the particular subtype of the instance stores internal data with higher precision than that provided by Quadruple, the values of the elements of the returned vector get rounded to the nearest double values.
      If no system was solved with this instance of the Matrix, returns null.
      QudrupleMatrix returns the exact values that was found by the corresponding solution method.
      Specified by:
      getQuadrupleSolution in class Matrix
      Returns:
      the last of the previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of Quadruples, or null, if no system was solved with the matrix.

    • getBigDecimalSolution

      public BigDecimal[] getBigDecimalSolution()
      Returns the last of the previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of BigDecimals.
      If no system was solved with this instance of the Matrix, returns null.
      If the solution contains values that can't be translated to BigDeciaml (NaN or Infinity), throws NumberFormatException.
      QuadrupleMatrix translates Quadruple values of the internally stored solution to BigDecimal values, using Quadruple.bigDecimalValue() method.
      Specified by:
      getBigDecimalSolution in class Matrix
      Returns:
      the last of the previously found vector solutions, x, to a system of linear equations of form Ax = b, as an array of BigDecimals. or null, if no system was solved with the matrix.

    • getErrorCode

      public String getErrorCode()
      Returns a string designation of the error code if an error has occurred during the solving or inversion of the matrix.
      This method can return the following values:
      • "OK" -- The last solution or inversion was successful;
      • "ASYMMETRIC" -- There was an attempt to solve or inverse the matrix using Cholesky decomposition, but the matrix is asymmetric;
      • "NON_SPD" -- There was an attempt to solve or inverse the matrix using Cholesky decomposition, but the matrix is not positively-defined;
      • "NON_INVERTIBLE" -- There was an attempt to solve or inverse the matrix using LU decomposition, but the matrix is inconsistent or underdetermined
      If no operations requiring decompositions were performed with this instance yet, returns OK.
      Specified by:
      getErrorCode in class Matrix
      Returns:
      a string designation of the error code if an error has occurred during the solving or inversion of the matrix, or "OK" in case of success.
      See Also:
      • Matrix.ErrorCodes

    • solve

      public Matrix solve(Matrix matrixB) throws IllegalArgumentException, NullPointerException
      Solves a matrix equation of form AX = B and returns the found solution.
      Solves a matrix equation of form AX = B formed by the inner matrix data A and the matrix B passed in as the Matrix matrixB argument, using LU decomposition.
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode(). If the size of the matrixB does not match the size of this instance of the matrix, throws IllegalArgumentException with a relevant message.
      Specified by:
      solve in class Matrix
      Parameters:
      matrixB - the matrix B of the equation to be solved, AX = B
      Returns:
      the found solution X to the equation AX = B as a new instance of QuadrupleMatrix.
      Throws:
      IllegalArgumentException - if the size of the matrixB does not match the size of this instance or the system has no solution or has infinitely many solutions.
      NullPointerException - if the argument is null
      See Also:

    • solve

      public Matrix solve(double[][] matrixB) throws IllegalArgumentException, NullPointerException
      Solves a matrix equation of form AX = B and returns the found solution.
      Solves a matrix equation of form AX = B formed by the inner matrix data A and the matrix B passed in as the double[][] matrixB argument, using LU decomposition.
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or the argument contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      Specified by:
      solve in class Matrix
      Parameters:
      matrixB - the matrix B of the equation to be solved, AX = B, as a two-dimentional array of primitive doubles
      Returns:
      the found solution X to the equation AX = B as a new instance of QuadrupleMatrix.
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance, or the system has no solution or has infinitely many solutions, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null
      See Also:

    • solve

      public Matrix solve(Number[][] matrixB) throws IllegalArgumentException, NullPointerException
      Solves a matrix equation of form AX = B and returns the found solution.
      Solves a matrix equation of form AX = B formed by the inner matrix data A and the matrix B passed in as the Number[][] matrixB argument, using LU decomposition.
      Before solving, the given matrixB array gets translated to an array of values of the type that is used to store internal matrix data (double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or matrixB contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message.
      Specified by:
      solve in class Matrix
      Parameters:
      matrixB - the matrix B of the equation to be solved, AX = B, as a two-dimentional array of Number
      Returns:
      the found solution X to the equation AX = B as a new instance of QuadrupleMatrix.
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance, or the system has no solution or has infinitely many solutions, or the argument contains invalid values (NaN, Infinity, or null).
      NullPointerException - if the argument is null
      See Also:

    • solveAccurately

      public Matrix solveAccurately(Matrix matrixB) throws IllegalArgumentException, NullPointerException
      Solves a matrix equation of form AX = B and returns the found solution.
      Solves a matrix equation of form AX = B formed by the inner matrix data A and the matrix B passed in as the matrixB argument, using LU decomposition.
      Uses an iterative refinement to find a more accurate solution.
      In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the size of the matrixB does not match the size of this instance of the matrix, throws IllegalArgumentException with a relevant message.
      The execution time is about 30 times longer than that of the simple solve(Matrix). In a typical case, the result error is reduced, compared to the simple solve(), by a factor from several units to several tens, depending on specific values of the matrix elements. For matrices 200 x 200 with uniformly-distributed random values, average square root of MSE is reduced by approximately 40 times, from about 1.2e-36 down to about 3.0e-38.
      Specified by:
      solveAccurately in class Matrix
      Parameters:
      matrixB - the matrix B of the equation to be solved, AX = B
      Returns:
      the found solution X to the equation AX = B as a new instance of QuadrupleMatrix.
      Throws:
      IllegalArgumentException - if the size of the matrixB does not match the size of this instance or the system has no solution or has infinitely many solutions.
      NullPointerException - if the argument is null
      See Also:

    • solveAccurately

      public Matrix solveAccurately(double[][] matrixB) throws IllegalArgumentException, NullPointerException
      Solves a matrix equation of form AX = B and returns the found solution.
      Solves a matrix equation of form AX = B formed by the inner matrix data A and the matrix B passed in as the double[][] matrixB argument, using LU decomposition.
      Uses an iterative refinement to find a more accurate solution. In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or the argument contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      The execution time is about 30 times longer than that of the simple solve(Matrix). In a typical case, the result error is reduced, compared to the simple solve(), by a factor from several units to several tens, depending on specific values of the matrix elements. For matrices 200 x 200 with uniformly-distributed random values, average square root of MSE is reduced by approximately 40 times, from about 1.2e-36 down to about 3.0e-38.
      Specified by:
      solveAccurately in class Matrix
      Parameters:
      matrixB - the matrix B of the equation to be solved, AX = B, as a two-dimentional array of primitive doubles
      Returns:
      the found solution X to the equation AX = B as a new instance of QuadrupleMatrix.
      Throws:
      IllegalArgumentException - if the size of the matrixB does not match the size of this instance or the system has no solution or has infinitely many solutions, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null
      See Also:

    • solveAccurately

      public Matrix solveAccurately(Number[][] matrixB) throws IllegalArgumentException, NullPointerException
      Solves a matrix equation of form AX = B and returns the found solution.
      Solves a matrix equation of form AX = B formed by the inner matrix data A and the matrix B passed in as the Number[][] matrixB argument, using LU decomposition.
      Before solving, the given matrixB array gets translated to an array of values of the type that is used to store internal matrix data (double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      Uses an iterative refinement to find a more accurate solution. In case of an inconsistent or underdefined matrix throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or matrixB contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message.
      The execution time is about 30 times longer than that of the simple solve(Matrix). In a typical case, the result error is reduced, compared to the simple solve(), by a factor from several units to several tens, depending on specific values of the matrix elements. For matrices 200 x 200 with uniformly-distributed random values, average square root of MSE is reduced by approximately 40 times, from about 1.2e-36 down to about 3.0e-38.
      Specified by:
      solveAccurately in class Matrix
      Parameters:
      matrixB - the matrix B of the equation to be solved, AX = B, as a two-dimentional array of Number
      Returns:
      the found solution X to the equation AX = B as a new instance of QuadrupleMatrix.
      Throws:
      IllegalArgumentException - if the size of the matrixB does not match the size of this instance or the system has no solution or has infinitely many solutions, or the argument contains invalid values (NaN, Infinity, or null).
      NullPointerException - if the argument is null
      See Also:

    • getMatrixSolution

      public Matrix getMatrixSolution()
      Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a Matrix. If no matrix equation was solved with this instance of the Matrix, returns null.
      Specified by:
      getMatrixSolution in class Matrix
      Returns:
      the last of the previously found matrix solution X to a system of linear equations of form AX = B, as a QuadrupleMatrix, or null, if no matrix equation was solved with the matrix.

    • getNumberMatrixSolution

      public Number[][] getNumberMatrixSolution()
      Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of Number.
      The particular type of the elements of the returned vector depends on the particular subtype of Matrix (it is Double for DoubleMatrix, Quadruple for QuadrupleMatrix, etc).
      If no matrix equation was solved with this instance of the Matrix, returns null.
      QuadrupleMatrix#getNumberMatrixSolution() returns the exact values of the elements of the matrix solution found by the call to one of the QuadrupleMatrix#solve() or QuadrupleMatrix#solveAccurately() methods.
      Specified by:
      getNumberMatrixSolution in class Matrix
      Returns:
      the last of the previously found matrix solution X, to a system of linear equations of form AX = B, as a two-dimentional array of Quadruple, or null, if no matrix equation was solved with the matrix.

    • getDoubleMatrixSolution

      public double[][] getDoubleMatrixSolution()
      Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of primitive doubles.
      If no matrix equation was solved with this instance of the Matrix, returns null.
      The returned array contains the values of the elements of the matrix solution found by a call to one of the QuadrupleMatrix#solve() or QuadrupleMatrix#solveAccurately() methods, rounded to nearest double values.
      Specified by:
      getDoubleMatrixSolution in class Matrix
      Returns:
      the last of the previously found matrix solution X, to a system of linear equations of form AX = B, as two-dimentional array of doubles, or null, if no matrix equation was solved with the matrix.

    • getQuadrupleMatrixSolution

      public Quadruple[][] getQuadrupleMatrixSolution()
      Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of Quadruples.
      If no matrix equation was solved with this instance of the Matrix, returns null.
      The returned array contains the exact values of the elements of the matrix solution found by a call to one of the QuadrupleMatrix#solve() or QuadrupleMatrix#solveAccurately() methods.
      Specified by:
      getQuadrupleMatrixSolution in class Matrix
      Returns:
      the last of the previously found matrix solution X, to a system of linear equations of form AX = B, as two-dimentional array of Quadruples, or null, if no matrix equation was solved with the matrix.

    • getBigDecimalMatrixSolution

      public BigDecimal[][] getBigDecimalMatrixSolution()
      Returns the last of the previously found matrix solutions, X, to a matrix equation of form AX = B, as a two-dimentional array of BigDecimals.
      If no matrix equation was solved with this instance of the Matrix, returns null.
      The returned array contains the values of the elements of the matrix solution found by a call to one of the QuadrupleMatrix#solve() or QuadrupleMatrix#solveAccurately() methods, translated to BigDecimal values using Quadruple.bigDecimalValue() method. If the internal storage contains element that can't be translated to BigDecimal values (NaN or Infinity), throws NumberFormatException.
      Specified by:
      getBigDecimalMatrixSolution in class Matrix
      Returns:
      the last of the previously found matrix solution X, to a system of linear equations of form AX = B, as two-dimentional array of BigDecimal, or null, if no matrix equation was solved with the matrix.

    • inverse

      public Matrix inverse() throws IllegalArgumentException
      Creates and returns a new Matrix instance containing the inversion of this instance.
      Computes the inversion of the matrix by solving the equation AX = E, creates and returns a new Matrix containing the found inversion. The exact subtype of the returned matrix is the same as that of this instance. If the matrix is not invertible (i.e. inconsistent or underdefined), throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      The particular subtype of Matrix returned by QuadrupleMatrix#inverse() is QuadrupleMatrix.
      Specified by:
      inverse in class Matrix
      Returns:
      a new Matrix containing the inversion of the given matrix.
      Throws:
      IllegalArgumentException - if the matrix is not invertible (i.e. inconsistent or underdefined)

    • inverseAccurately

      public Matrix inverseAccurately() throws IllegalArgumentException
      Creates and returns a new Matrix instance containing the inversion of this instance.
      Computes the inversion of the matrix by solving the equation AX = E, creates and returns a new Matrix containing the found inversion. Uses an iterative refinement to achieve a more accurate solution to the equation. The exact subtype of the returned matrix is the same as that of this instance. If the matrix is not invertible (i.e. inconsistent or underdefined), throws IllegalArgumentException with a relevant message and sets internal variable errorCode, whose value can be obtained using method Matrix.getErrorCode().
      The execution time is about 30 times longer than that of the simple inverse(). In a typical case, the result error is reduced, compared to the simple inverse(), by a factor of several units, depending on specific values of the matrix elements. For matrices 200 x 200 with uniformly-distributed random values, average square root of MSE is reduced by approximately 5 times, from about 2.0e-37 down to about 4.0e-38
      Specified by:
      inverseAccurately in class Matrix
      Returns:
      a new QuadrupleMatrix containing the inversion of the given matrix.
      Throws:
      IllegalArgumentException - if the matrix is not invertible (i.e. inconsistent or underdefined)

    • transpose

      public Matrix transpose()
      Creates and returns a new Matrix instance containing the transposition of this instance.
      Computes the transposition of the matrix, creates and returns a new Matrix containing the found transposition.
      The exact subtype of the returned matrix is the same as that of this instance.
      Specified by:
      transpose in class Matrix
      Returns:
      a new QuadrupleMatrix containing the transposition of the given matrix.

    • unity

      public Matrix unity()
      Creates and returns a new Matrix instance containing a unity matrix of the same size as the source matrix.
      The exact subtype of the returned matrix is the same as that of this instance.
      Specified by:
      unity in class Matrix
      Returns:
      a new QuadrupleMatrix containing the unity matrix of the same size as this Matrix

    • multiply

      public Matrix multiply(Matrix factor) throws IllegalArgumentException, NullPointerException
      Multiplies this instance of Matrix by the matrix passed in as the factor argument, creates and returns a new matrix containing the product. The exact subtype of the returned matrix is the same as that of this instance. If the size of the factor does not match the size of the source matrix, throws IllegalArgumentException with a relevant message.
      Specified by:
      multiply in class Matrix
      Parameters:
      factor - a matrix to multiply this instance by
      Returns:
      a new QuadrupleMatrix representing the product
      Throws:
      IllegalArgumentException - if the size of the argument does not match the size of this instance
      NullPointerException - if the argument is null

    • multiply

      public Matrix multiply(double[][] factor) throws IllegalArgumentException, NullPointerException
      Multiplies this instance of Matrix by the factor passed in as a two-dimentional double array, and creates and returns a new matrix containing the product. The exact subtype of the returned matrix is the same as that of this instance.
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or matrixB contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      Specified by:
      multiply in class Matrix
      Parameters:
      factor - two-dimentional double array representing a matrix to multiply this instance by
      Returns:
      a new QuadrupleMatrix representing the product
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or matrixB contains non-numeric values (NaN or Infinity)
      NullPointerException - if the argument is null

    • multiply

      public Matrix multiply(Number[][] factor) throws IllegalArgumentException, NullPointerException
      Multiplies this instance of Matrix by the factor passed in as a two-dimentional array of Numbers, and creates and returns a new matrix containing the product. The exact subtype of the returned matrix is the same as that of this instance.
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or matrixB contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message.
      Specified by:
      multiply in class Matrix
      Parameters:
      factor - two-dimentional array of Number representing the matrix to multiply this instance by
      Returns:
      a new QuadrupleMatrix representing the product
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or matrixB contains non-numeric values (NaN or Infinity) or null
      NullPointerException - if the argument is null

    • multiply

      public Number[] multiply(double[] vector) throws IllegalArgumentException, NullPointerException
      Multiplies this instance of Matrix by a vector passed in as an array of doubles, and returns an array of Number values containing the product. The exact type of the elements of the returned array depends on the particular subtype of the Matrix.
      If the length of the vector does not match the size of the source matrix, or the argument contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      Specified by:
      multiply in class Matrix
      Parameters:
      vector - the vector to multiply the matrix by.
      Returns:
      an array of Quadruple values containing the product.
      Throws:
      IllegalArgumentException - if the length of the array does not match the size of the matrix, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null

    • multiply

      public Number[] multiply(Number[] vector) throws IllegalArgumentException, NullPointerException
      Multiplies this instance of Matrix by a vector passed in as an array of Number values and returns an array of Number values containing the product. The exact type of the elements of the returned array depends on the particular subtype of the Matrix.
      If the length of the vector does not match the size of the source matrix, or the argument contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message.
      Specified by:
      multiply in class Matrix
      Parameters:
      vector - the vector to multiply the matrix by.
      Returns:
      an array of Quadruple values containing the product.
      Throws:
      IllegalArgumentException - if the length of the array does not match the size of the matrix, or the argument contains non-numeric values (NaN or Infinity) or null
      NullPointerException - if the argument is null

    • multiply

      public Matrix multiply(double scalar) throws IllegalArgumentException
      Multiplies this instance of Matrix by a scalar factor scalar passed in as a double parameter, and creates and returns a new matrix containing the product. The exact subtype of the returned matrix is the same as that of this instance. If the argument is a non-numeric value (NaN or Infinity), throws IllegalArgumentException.
      Specified by:
      multiply in class Matrix
      Parameters:
      scalar - a double value to multiply this matrix by.
      Returns:
      a new QuadrupleMatrix containing the product of the source matrix and the given scalar.
      Throws:
      IllegalArgumentException - if the argument is NaN or Infinity.

    • multiply

      public Matrix multiply(Number scalar) throws IllegalArgumentException, NullPointerException
      Multiplies this instance of Matrix by a scalar factor scalar passed in as a Number parameter, and creates and returns a new matrix containing the product. The exact subtype of the returned matrix is the same as that of this instance.
      If the argument is a non-numeric value (NaN or Infinity) or null, throws IllegalArgumentException. Before the multiplication, the value of the argument is translated into the corresponding Quadruple by one of the Quadruple constructors, depending on the actual type of the argument.
      Specified by:
      multiply in class Matrix
      Parameters:
      scalar - a Number value to multiply this matrix by.
      Returns:
      a new QuadrupleMatrix containing the product of the source matrix and the given scalar.
      Throws:
      IllegalArgumentException - if the argument is NaN, Infinity or null.
      NullPointerException - if the argument is null

    • add

      public Matrix add(Matrix matrixB) throws IllegalArgumentException, NullPointerException
      Adds the given matrixB to this matrix and returns the sum.
      Computes the sum of this matrix and the Matrix passed in, and creates and returns a new Matrix containing the found sum. The exact subtype of the returned matrix is the same as that of this instance. If the size of the matrixB does not match the size of this instance of the matrix, throws IllegalArgumentException with a relevant message.
      Specified by:
      add in class Matrix
      Parameters:
      matrixB - the matrix to add to the source matrix.
      Returns:
      a new QuadrupleMatrix containing the sum of the two matrices.
      Throws:
      IllegalArgumentException - if the size of the matrixB does not match the size of this instance.
      NullPointerException - if the argument is null

    • add

      public Matrix add(double[][] matrixB) throws IllegalArgumentException, NullPointerException
      Adds the given matrixB passed in as a two-dimentional array of doubles to this matrix and returns the sum.
      Computes the sum of this matrix and the matrix passed in, and creates and returns a new Matrix containing the found sum. The exact subtype of the returned matrix is the same as that of this instance.
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or the argument contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      Specified by:
      add in class Matrix
      Parameters:
      matrixB - the matrix to add to the source matrix.
      Returns:
      a new QuadrupleMatrix containing the sum of the two matrices.
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null

    • add

      public Matrix add(Number[][] matrixB) throws IllegalArgumentException, NullPointerException
      Adds the given matrixB passed in as a two-dimentional array of Number to this matrix and returns the sum.
      Computes the sum of this matrix and the matrix passed in, and creates and returns a new Matrix containing the found sum. The exact subtype of the returned matrix is the same as that of this instance.
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or the argument contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message.
      Specified by:
      add in class Matrix
      Parameters:
      matrixB - the matrix to add to the source matrix.
      Returns:
      a new QuadrupleMatrix containing the sum of the two matrices.
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance, or the argument contains non-numeric values (NaN or Infinity), or null.
      NullPointerException - if the argument is null

    • subtract

      public Matrix subtract(Matrix matrixB) throws IllegalArgumentException, NullPointerException
      Subtracts the given matrixB from this matrix and returns the difference.
      Computes the difference of this matrix and the Matrix passed in, and creates and returns a new Matrix containing the found difference. The exact subtype of the returned matrix is the same as that of this instance. If the size of the matrixB does not match the size of this instance of the matrix, throws IllegalArgumentException with a relevant message.
      Specified by:
      subtract in class Matrix
      Parameters:
      matrixB - the matrix to subtract from the source matrix.
      Returns:
      a new QuadrupleMatrix containing the difference of the two matrices.
      Throws:
      IllegalArgumentException - if the size of the matrixB does not match the size of this instance.
      NullPointerException - if the argument is null

    • subtract

      public Matrix subtract(double[][] matrixB) throws IllegalArgumentException, NullPointerException
      Subtracts the given matrixB passed in as a two-dimentional array of doubles from this matrix and returns the difference.
      Computes the difference of this matrix and the matrix passed in, creates and returns a new Matrix containing the found difference. The exact subtype of the returned matrix is the same as that of this instance.
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or the argument contains non-numeric values (NaN or Infinity), throws IllegalArgumentException with a relevant message.
      Specified by:
      subtract in class Matrix
      Parameters:
      matrixB - the matrix to subtract from the source matrix.
      Returns:
      a new QuadrupleMatrix containing the difference of the two matrices.
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance, or the argument contains non-numeric values (NaN or Infinity).
      NullPointerException - if the argument is null

    • subtract

      public Matrix subtract(Number[][] matrixB) throws IllegalArgumentException, NullPointerException
      Subtracts the given matrixB passed in as a two-dimentional array of Number from this matrix and returns the difference.
      Computes the difference of this matrix and the matrix passed in, creates and returns a new Matrix containing the found difference. The exact subtype of the returned matrix is the same as that of this instance.
      If the passed-in array is non-square, or its size does not match the size of this instance of the matrix, or the argument contains non-numeric values (NaN or Infinity) or null, throws IllegalArgumentException with a relevant message.
      Specified by:
      subtract in class Matrix
      Parameters:
      matrixB - the matrix to subtract from the source matrix.
      Returns:
      a new QuadrupleMatrix containing the difference of the two matrices.
      Throws:
      IllegalArgumentException - if the passed-in array is non-square, or its size does not match the size of this instance, or the argument contains non-numeric values (NaN or Infinity) or null.
      NullPointerException - if the argument is null

    • determinant

      public Number determinant()
      Computes the determinant of the matrix and returns its value as a Number value.
      The particular type of the returned Number depends on the exact subtype of this instance of Matrix (it is double for DoubleMatrix, Quadruple for QuadrupleMatrix, and BigDecimal for BigDecimalMatrix).
      Specified by:
      determinant in class Matrix
      Returns:
      the value of the determinant of the given Matrix as an instance of class Quadruple

    • determinantAsDouble

      public double determinantAsDouble()
      Computes the determinant of the matrix and returns its value as a double value. QuadrupleMatrix#determinantAsDouble() returns the result of the corresponding computations rounded to the nearest double value.
      Specified by:
      determinantAsDouble in class Matrix
      Returns:
      the value of the determinant of the given Matrix

    • determinantAsQuadruple

      public Quadruple determinantAsQuadruple()
      Computes the determinant of the matrix and returns its value as a Quadruple value. The precision of the result depends on the particular subtype of the instance. QuadrupleMatrix#determinantAsQuadruple() returns a Quadruple value exactly equal to the internally calculated Quadruple value.
      Specified by:
      determinantAsQuadruple in class Matrix
      Returns:
      the value of the determinant of the given Matrix

    • determinantAsBigDecimal

      public BigDecimal determinantAsBigDecimal()
      Computes the determinant of the matrix and returns its value as a BigDecimal value. The precision of the result depends on the particular subtype of the instance. For QuadrupleMatrix, it is limited to the precision provided by calculations with Quadruples.
      Specified by:
      determinantAsBigDecimal in class Matrix
      Returns:
      the value of the determinant of the given Matrix

    • norm

      public Number norm()
      Computes the row-based norm of the matrix, ║A║∞, and returns its value as a Number value.
      The particular type of the returned Number depends on the exact subtype of this instance of Matrix (it is double for DoubleMatrix, Quadruple for QuadrupleMatrix, and BigDecimal for BigDecimalMatrix).
      Specified by:
      norm in class Matrix
      Returns:
      the value of the norm of the given Matrix as an instance of class Quadruple

    • normAsDouble

      public double normAsDouble()
      Computes the row-based norm of the matrix, ║A║∞, and returns its value as a double value. QuadrupleMatrix#normAsDouble() returns the result of the corresponding computations rounded to the nearest double value.
      Specified by:
      normAsDouble in class Matrix
      Returns:
      the value of the norm of the given Matrix

    • normAsQuadruple

      public Quadruple normAsQuadruple()
      Computes the row-based norm of the matrix, ║A║∞, and returns its value as a Quadruple value. The precision of the result depends on the particular subtype of the instance. QuadrupleMatrix#normAsQuadruple() returns a Quadruple value exactly equal to the internally calculated value.
      Specified by:
      normAsQuadruple in class Matrix
      Returns:
      the value of the norm of the given Matrix

    • normAsBigDecimal

      public BigDecimal normAsBigDecimal()
      Computes the row-based norm of the matrix, ║A║∞, and returns its value as a BigDecimal value. The precision of the result depends on the particular subtype of the instance. For QuadrupleMatrix, it is limited to the precision provided by calculations with Quadruples.
      Specified by:
      normAsBigDecimal in class Matrix
      Returns:
      the value of the norm of the given Matrix

    • cond

      public double cond()
      Computes the condition number of the matrix, ║A║•║A-1║, and returns its value as a double value.
      For non-invertible matrices returns Double.POSITIVE_INFINITY.
      Specified by:
      cond in class Matrix
      Returns:
      the value of the condition number of the given Matrix, or Double.POSITIVE_INFINITY for non-invertible matrices