dpackedsymmatrix_functions.h

Go to the documentation of this file.

#ifndef DPACKEDSYMMATRIX_FUNCTIONS
#define DPACKEDSYMMATRIX_FUNCTIONS

#include "lapack_functions.h"

void DoublePackedSymmetricMatrixVectorProduct(const tLVectorIndex& nX,
                                              const tLVectorIncrement& incX,
                                              const double* x,
                                              const tLVectorIndex& nRows,//number of viewed rows of A
                                              const double* A,
                                              const lapack_real& alpha,
                                              const lapack_real& beta,
                                              const tLVectorIndex& nY,
                                              const tLVectorIncrement& incY,
                                              double* y);


/* \brief comute S+=alpha tX.tX
 * @param incX:increment of vector X
 * @param X: values of X
 * @param alpha: multiplicator factor
 * @param nSRows: number of rows of S
 * @param S: values of packed symmetric matrix
 */
void DoublePackedSymmetricMatrixRankSymmetricProduct(const tLVectorIncrement& incX,
                                                     const double *X,
                                                     const double& alpha,
                                                     const tLVectorIndex& nSRows,
                                                     double *S);

void DoublePackedSymmetricMatrixMatrixProduct(const tBoolean& isLeftSide,
                                              const tLVectorIndex& nRowsS,
                                              const double* S,
                                              const tLVectorIndex& nRowsB,
                                              const tLVectorIndex& nColsB,
                                              const tLVectorIncrement& incB,
                                              const tLVectorIndex& ldB,
                                              const tBoolean& isBSymmetric,
                                              const tBoolean& isBFull,
                                              const double* B,
                                              const lapack_real& alpha,
                                              const lapack_real& beta,
                                              const tLVectorIndex& nRowsC,
                                              const tLVectorIndex& nColsC,
                                              const tLVectorIncrement& incC,
                                              const tLVectorIndex& ldC,
                                              double *C) ;


void DoublePackedSymmetricMatrixKRankSymmetricProduct(const tLVectorIndex& nRowsA,
                                                      const tLVectorIndex& nColsA,
                                                      const tLVectorIncrement& incA,
                                                      const tLVectorIndex& ldA,
                                                      const tBoolean& isTransA,
                                                      const double *A,
                                                      const double& alpha,
                                                      const double& beta,
                                                      const tLVectorIndex& nD,
                                                      const tLVectorIncrement& incD,
                                                      const double* D,
                                                      const tLVectorIndex& nS,
                                                      double *S);

tBoolean DoublePackedSymmetricMatrixEigenValues(const tLVectorIndex& nRowsA,
                                                double* A,
                                                const tLVectorIndex& nU,
                                                double* U,
                                                const tLVectorIndex& ldW,
                                                double* W);

tBoolean DoublePackedSymmetricMatrixBoundedEigenValues(const tLVectorIndex& nRowsA,
                                                       double* A,
                                                       const tLVectorIndex& nU,//of size M=N  or M=iu-il+1
                                                       double* U,
                                                       const tLVectorIndex& minIndex,
                                                       const tLVectorIndex& maxIndex,
                                                       const double& minBound,
                                                       const double& maxBound,
                                                       const tLVectorIndex& ldW,//Z of size nRows  x M
                                                       double *W);

tBoolean DoublePackedSymmetricMatrixCholeskyFactorization(const tLVectorIndex& nRowsA,
                                                          double* A);

tBoolean DoublePackedSymmetricMatrixBunchKaufmanFactorization(const tLVectorIndex& nRows,
                                                              double *A,
                                                              lapack_int *ipiv);

tBoolean DoublePackedSymmetricMatrixInverse(const tLVectorIndex& nRows,
                                            const lapack_int* ipiv,
                                            double *A);
#endif