org.ode4j.cpp.internal
Class ApiCppMathMatrix

java.lang.Object
  org.ode4j.cpp.internal.ApiCppMathMisc
      org.ode4j.cpp.internal.ApiCppMathRotation
          org.ode4j.cpp.internal.ApiCppMathMatrix

Direct Known Subclasses:

OdeCppMath

public abstract class ApiCppMathMatrix
extends ApiCppMathRotation

optimized and unoptimized vector and matrix functions.

Constructor Summary

ApiCppMathMatrix()

Method Summary

static double	dDot(double[] a, double[] b, int n)
static double	dDot(double[] a, int aPos, double[] b, int n)
static double	dDot(double[] a, int aPos, double[] b, int bPos, int n)
static double	dDot(DVector3C a, DVector3 b, int n) get the dot product of two n*1 vectors.
static boolean	dFactorCholesky(double[] A, int n) do an in-place cholesky decomposition on the lower triangle of the n*n symmetric matrix A (which is stored by rows).
static void	dFactorLDLT(double[] A, double[] d, int n, int nskip) factorize a matrix A into L*D*L', where L is lower triangular with ones on the diagonal, and D is diagonal.
static boolean	dInvertPDMatrix(double[] A, double[] Ainv, int n) compute the inverse of the n*n positive definite matrix A and put it in Ainv.
static boolean	dIsPositiveDefinite(double[] A, int n) check whether an n*n matrix A is positive definite, return 1/0 (yes/no).
static void	dLDLTAddTL(double[] L, double[] d, double[] a, int n, int nskip) given an L*D*L' factorization of an n*n matrix A, return the updated factorization L2*D2*L2' of A plus the following "top left" matrix: [ b a' ] <-- b is a[0] [ a 0 ] <-- a is a[1..n-1] - L has size n*n, its leading dimension is nskip.
static void	dLDLTRemove(double[] A, int[] p, double[] L, double[] d, int n1, int n2, int r, int nskip) given an L*D*L' factorization of a permuted matrix A, produce a new factorization for row and column `r' removed.
static void	dMultiply0(double[] A, double[] B, double[] C, int p, int q, int r) matrix multiplication.
static void	dMultiply1(double[] A, double[] B, double[] C, int p, int q, int r)
static void	dMultiply2(double[] A, double[] B, double[] C, int p, int q, int r)
static void	dRemoveRowCol(double[] A, int n, int nskip, int r) given an n*n matrix A (with leading dimension nskip), remove the r'th row and column by moving elements.
static void	dSetValue(double[] a, int n, double value)
static void	dSetZero(double[] a, int n) set a vector/matrix of size n to all zeros, or to a specific value.
static void	dSolveCholesky(double[] L, double[] b, int n) solve for x: L*L'*x = b, and put the result back into x.
static void	dSolveLDLT(double[] L, double[] d, double[] b, int n, int nskip) given `L', a n*n lower triangular matrix with ones on the diagonal, and `d', a n*1 vector of the reciprocal diagonal elements of an n*n matrix D, solve L*D*L'*x=b where x,b are n*1.

Methods inherited from class org.ode4j.cpp.internal.ApiCppMathRotation

dDQfromW, dQFromAxisAndAngle, dQfromR, dQMultiply0, dQMultiply1, dQMultiply2, dQMultiply3, dQSetIdentity, dQtoR, dRFrom2Axes, dRFromAxisAndAngle, dRFromEulerAngles, dRfromQ, dRFromZAxis, dRSetIdentity

Methods inherited from class org.ode4j.cpp.internal.ApiCppMathMisc

dClearUpperTriangle, dMakeRandomMatrix, dMakeRandomVector, dMaxDifference, dMaxDifferenceLowerTriangle, dRand, dRandGetSeed, dRandInt, dRandReal, dRandSetSeed, dTestRand

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ApiCppMathMatrix

public ApiCppMathMatrix()

Method Detail

dSetZero

public static void dSetZero(double[] a,
                            int n)

set a vector/matrix of size n to all zeros, or to a specific value.

dSetValue

public static void dSetValue(double[] a,
                             int n,
                             double value)

dDot

public static double dDot(DVector3C a,
                          DVector3 b,
                          int n)

get the dot product of two n*1 vectors. if n <= 0 then zero will be returned (in which case a and b need not be valid).

dDot

public static double dDot(double[] a,
                          double[] b,
                          int n)

dDot

public static double dDot(double[] a,
                          int aPos,
                          double[] b,
                          int n)

dDot

public static double dDot(double[] a,
                          int aPos,
                          double[] b,
                          int bPos,
                          int n)

dMultiply0

public static void dMultiply0(double[] A,
                              double[] B,
                              double[] C,
                              int p,
                              int q,
                              int r)

matrix multiplication. all matrices are stored in standard row format. the digit refers to the argument that is transposed: 0: A = B * C (sizes: A:p*r B:p*q C:q*r) 1: A = B' * C (sizes: A:p*r B:q*p C:q*r) 2: A = B * C' (sizes: A:p*r B:p*q C:r*q) case 1,2 are equivalent to saying that the operation is A=B*C but B or C are stored in standard column format.

dMultiply1

public static void dMultiply1(double[] A,
                              double[] B,
                              double[] C,
                              int p,
                              int q,
                              int r)

dMultiply2

public static void dMultiply2(double[] A,
                              double[] B,
                              double[] C,
                              int p,
                              int q,
                              int r)

dFactorCholesky

public static boolean dFactorCholesky(double[] A,
                                      int n)

do an in-place cholesky decomposition on the lower triangle of the n*n symmetric matrix A (which is stored by rows). the resulting lower triangle will be such that L*L'=A. return 1 on success and 0 on failure (on failure the matrix is not positive definite).

dSolveCholesky

public static void dSolveCholesky(double[] L,
                                  double[] b,
                                  int n)

solve for x: L*L'*x = b, and put the result back into x. L is size n*n, b is size n*1. only the lower triangle of L is considered.

dInvertPDMatrix

public static boolean dInvertPDMatrix(double[] A,
                                      double[] Ainv,
                                      int n)

compute the inverse of the n*n positive definite matrix A and put it in Ainv. this is not especially fast. this returns 1 on success (A was positive definite) or 0 on failure (not PD).

dIsPositiveDefinite

public static boolean dIsPositiveDefinite(double[] A,
                                          int n)

check whether an n*n matrix A is positive definite, return 1/0 (yes/no). positive definite means that x'*A*x > 0 for any x. this performs a cholesky decomposition of A. if the decomposition fails then the matrix is not positive definite. A is stored by rows. A is not altered.

dFactorLDLT

public static void dFactorLDLT(double[] A,
                               double[] d,
                               int n,
                               int nskip)

factorize a matrix A into L*D*L', where L is lower triangular with ones on the diagonal, and D is diagonal. A is an n*n matrix stored by rows, with a leading dimension of n rounded up to 4. L is written into the strict lower triangle of A (the ones are not written) and the reciprocal of the diagonal elements of D are written into d.

dSolveLDLT

public static void dSolveLDLT(double[] L,
                              double[] d,
                              double[] b,
                              int n,
                              int nskip)

given `L', a n*n lower triangular matrix with ones on the diagonal, and `d', a n*1 vector of the reciprocal diagonal elements of an n*n matrix D, solve L*D*L'*x=b where x,b are n*1. x overwrites b. the leading dimension of L is `nskip'.

dLDLTAddTL

public static void dLDLTAddTL(double[] L,
                              double[] d,
                              double[] a,
                              int n,
                              int nskip)

given an L*D*L' factorization of an n*n matrix A, return the updated factorization L2*D2*L2' of A plus the following "top left" matrix: [ b a' ] <-- b is a[0] [ a 0 ] <-- a is a[1..n-1] - L has size n*n, its leading dimension is nskip. L is lower triangular with ones on the diagonal. only the lower triangle of L is referenced. - d has size n. d contains the reciprocal diagonal elements of D. - a has size n. the result is written into L, except that the left column of L and d[0] are not actually modified. see ldltaddTL.m for further comments.

dLDLTRemove

public static void dLDLTRemove(double[] A,
                               int[] p,
                               double[] L,
                               double[] d,
                               int n1,
                               int n2,
                               int r,
                               int nskip)

given an L*D*L' factorization of a permuted matrix A, produce a new factorization for row and column `r' removed. - A has size n1*n1, its leading dimension in nskip. A is symmetric and positive definite. only the lower triangle of A is referenced. A itself may actually be an array of row pointers. - L has size n2*n2, its leading dimension in nskip. L is lower triangular with ones on the diagonal. only the lower triangle of L is referenced. - d has size n2. d contains the reciprocal diagonal elements of D. - p is a permutation vector. it contains n2 indexes into A. each index must be in the range 0..n1-1. - r is the row/column of L to remove. the new L will be written within the old L, i.e. will have the same leading dimension. the last row and column of L, and the last element of d, are undefined on exit. a fast O(n^2) algorithm is used. see ldltremove.m for further comments.

dRemoveRowCol

public static void dRemoveRowCol(double[] A,
                                 int n,
                                 int nskip,
                                 int r)

given an n*n matrix A (with leading dimension nskip), remove the r'th row and column by moving elements. the new matrix will have the same leading dimension. the last row and column of A are untouched on exit.