dfullmatrix_functions.h

Go to the documentation of this file.

#ifndef DFULLMATRIX_FUNCTIONS
#define DFULLMATRIX_FUNCTIONS

#include "lapack_functions.h"

 void DoubleFullMatrixVectorProduct(const tLVectorIndex& lx,
                                    const tLVectorIncrement& incx,
                                    const double* x,
                                    const tBoolean& isTransposed,
                                    const tLVectorIndex& nRows,//number of viewed rows of A
                                    const tLVectorIndex& nCols,//number of viewed columns of A
                                    const tLVectorIndex& ldaA,//memory distance between A[i][j] and A[i][j+1] 
                                    const double* A,
                                    const lapack_real& alpha,
                                    const lapack_real& beta,
                                    const tLVectorIndex& ly,
                                    const tLVectorIncrement& incy,
                                    double* y);


void DoubleFullUpperMatrixVectorProduct( const tBoolean& isTransA,
                                         const tLVectorIndex& nRowsA,//number of viewed rows of A
                                         const tLVectorIndex& ldA,//memory distance between A[i][j] and A[i][j+1]
                                         const double* A,
                                         const tLVectorIndex& nX,
                                         const tLVectorIncrement& incX,
                                         double* x) ;

// DGEMM - perform one of the matrix-matrix operations  
// C:=alpha*op( A )*op( B ) + beta*C, where  op( X ) is one of
//
// op( X ) = X   or   op( X ) = X**T,
// alpha and beta are scalars, and A, B and C are matrices, with op( A )
// an m by k matrix,  op( B )  a  k by n matrix and  C an m by n matrix.

void DoubleFullMatrixMatrixProduct(const tLVectorIndex& nARows,
                                   const tLVectorIndex& nACols,
                                   const tLVectorIndex& ldA,
                                   const double* A,
                                   const tLVectorIndex& nBRows,
                                   const tLVectorIndex& nBCols,
                                   const tLVectorIndex& ldB,
                                   const double* B,
                                   const tBoolean& isTrA,
                                   const tBoolean& isTrB,
                                   const lapack_real& alpha,
                                   const lapack_real& beta,
                                   const tLVectorIndex& nCRows,
                                   const tLVectorIndex& nCCols,
                                   const tLVectorIndex& ldC,
                                   double *C);



//eigen decomposition
//=====================
 /* DGEEV computes for an N-by-N real nonsymmetric matrix A, the
     *  eigenvalues and, optionally, the left and/or right eigenvectors.
     *
     *  The right eigenvector v(j) of A satisfies
     *                   A * v(j) = lambda(j) * v(j)
     *  where lambda(j) is its eigenvalue.
     *  The left eigenvector u(j) of A satisfies
     *                u(j)**H * A = lambda(j) * u(j)**H
     *  where u(j)**H denotes the conjugate transpose of u(j).
     *
     *  The computed eigenvectors are normalized to have Euclidean norm
     *  equal to 1 and largest component real.
     */
int DoubleFullMatrixEigenValues(const tLVectorIndex& nRows,
                                const tLVectorIndex& nCols,
                                const tLVectorIndex& ld,
                                double* A,
                                const tLVectorIndex& nU,
                                double* U,
                                double* C);


//LU factorization
int DoubleFullMatrixLUFactorization(const tLVectorIndex& nRows,
                                    const tLVectorIndex& nCols,
                                    const tLVectorIndex& ld,
                                    double* A,
                                    lapack_int *LU_pivots);

//inversion of matrix
/*  DGETRI computes the inverse of a matrix using the LU factorization
 *  computed by DGETRF.
*
*  This method inverts U and then computes inv(A) by solving the system
*  inv(A)*L = inv(U) for inv(A).
*/

bool DoubleFullMatrixInverse(const tLVectorIndex& nRows,
                             const tLVectorIndex& nCols,
                             const tLVectorIndex& ld,
                             const lapack_int* ipiv,
                             double* A);
/*
 *  DGETRS solves a system of linear equations
 *     A * X = B  or  A**T * X = B
 *  with a general N-by-N matrix A using the LU factorization computed
 *  by DGETRF.
 */
//AX=B X->B
//
bool DoubleFullMatrixSolveMatrixEquation(const tLVectorIndex& nARows,
                                        const tLVectorIndex& nACols,
                                        const tLVectorIndex& nAMaxRows,
                                        const tLVectorIndex& nAMaxCols,
                                        const tLVectorIndex& ldA,
                                        const tBoolean& isTransA,
                                        const lapack_int *ipiv,
                                        const double* A,
                                        const tLVectorIndex& nBRows,
                                        const tLVectorIndex& nBCols,
                                        const tLVectorIndex& ldB,
                                        double *B);

//QR factorization
//===============

/* DTRSM solves one of the matrix equations
 *
 * op( A )*X = alpha*B, or X*op( A ) = alpha*B,
 *
 * where alpha is a scalar, X and B are m by n matrices, A is a unit, or
 * non-unit, upper or lower triangular matrix and op( A ) is one of
 *
 * op( A ) = A or op( A ) = A**T.
 *
 * The matrix X is overwritten on B.
 */

int DoubleFullMatrixQRFactorization(const tLVectorIndex& nRows,
                                    const tLVectorIndex& nCols,
                                    const tLVectorIndex& nMaxRows,
                                    const tLVectorIndex& nMaxCols,
                                    const tLVectorIndex& ld,
                                    double* A,
                                    const tBoolean& isOnlyQ);
/*
 *  DGEQP3 computes a QR factorization with column pivoting of a
 *  matrix A:  A*P = Q*R  using Level 3 BLAS.
 */
/*  DORGQR generates an M-by-N real matrix Q with orthonormal columns,
 *  which is defined as the first N columns of a product of K elementary
 *  reflectors of order M
 *
 *        Q  =  H(1) H(2) . . . H(k)
 *
 *  as returned by DGEQRF.*/

int DoubleFullMatrixPQRFactorization(const tLVectorIndex& nRows,
                                     const tLVectorIndex& nCols,
                                     const tLVectorIndex& nMaxRows,
                                     const tLVectorIndex& nMaxCols,
                                     const tLVectorIndex& ld,
                                     double* A,
                                     const tBoolean& isOnlyQ);


#endif