DenseMat.hpp

Go to the documentation of this file.

 
#ifndef __DENSEMAT_HEADER__
#define __DENSEMAT_HEADER__
 
// Standard header files
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
 
using namespace std;
 
extern "C" {
 
 
void dscal_(const int* n, const double* alpha, double* x, const int* incx);
 
double ddot_(const int* n, double* a, const int* inca, double* b, const int* incb);
 
int dcopy_(
    const int* n, const double* src, const int* incx, double* dst, const int* incy);
 
int daxpy_(const int*    n,
           const double* alpha,
           const double* x,
           const int*    incx,
           double*       y,
           const int*    incy);
 
double dnrm2_(const int* n, double* x, const int* incx);
 
double dasum_(const int* n, double* x, const int* incx);
 
int idamax_(const int* n, double* x, const int* incx);
 
int dgemm_(const char*   transa,
           const char*   transb,
           const int*    m,
           const int*    n,
           const int*    k,
           const double* alpha,
           const double* A,
           const int*    lda,
           const double* B,
           const int*    ldb,
           const double* beta,
           double*       C,
           const int*    ldc);
 
 
int dgesv_(const int* n,
           const int* nrhs,
           double*    A,
           const int* lda,
           int*       ipiv,
           double*    b,
           const int* ldb,
           int*       info);
 
int dsysv_(const char* uplo,
           const int*  n,
           const int*  nrhs,
           double*     A,
           const int*  lda,
           int*        ipiv,
           double*     b,
           const int*  ldb,
           double*     work,
           const int*  lwork,
           int*        info);
 
int ssyevd_(char*      jobz,
            char*      uplo,
            const int* n,
            float*     A,
            const int* lda,
            float*     w,
            float*     work,
            const int* lwork,
            int*       iwork,
            const int* liwork,
            int*       info);
}
 
void CalEigenSY(const int& N, float* A, float* w, float* work, const int& lwork);
 
// void MinEigenS(const int& N, float* a, float* w);
 
void Dcopy(const int& N, double* dst, const double* src);
 
double Ddot(int n, double* a, double* b);
 
double Dnorm1(const int& N, double* x);
 
double Dnorm2(const int& N, double* x);
 
void Dscalar(const int& n, const double& alpha, double* x);
 
void Daxpy(const int& n, const double& alpha, const double* x, double* y);
 
void DaABpbC(const int&    m,
             const int&    n,
             const int&    k,
             const double& alpha,
             const double* A,
             const double* B,
             const double& beta,
             double*       C);
 
// test
void myDABpC(const int&    m,
             const int&    n,
             const int&    k,
             const double* A,
             const double* B,
             double*       C);
void myDABpCp(const int&    m,
              const int&    n,
              const int&    k,
              const double* A,
              const double* B,
              double*       C,
              const int*    flag,
              const int     N);
void myDABpCp1(const int&    m,
               const int&    n,
               const int&    k,
               const double* A,
               const double* B,
               double*       C,
               const int*    flag,
               const int     N);
void myDABpCp2(const int&    m,
               const int&    n,
               const int&    k,
               const double* A,
               const double* B,
               double*       C,
               const int*    flag,
               const int     N);
 
void DaAxpby(const int&    m,
             const int&    n,
             const double& a,
             const double* A,
             const double* x,
             const double& b,
             double*       y);
 
void LUSolve(const int& nrhs, const int& N, double* A, double* b, int* pivot);
 
int SYSSolve(const int&  nrhs,
             const char* uplo,
             const int&  N,
             double*     A,
             double*     b,
             int*        pivot,
             double*     work,
             const int&  lwork);
 
template <typename T>
void PrintDX(const int& N, const T* x)
{
    for (int i = 0; i < N; i++) {
        cout << i << "   " << setprecision(16) << x[i] << endl;
    }
    cout << endl;
}
 
template <typename T>
bool CheckNan(const int& N, const T* x)
{
    for (int i = 0; i < N; i++) {
        if (!isfinite(x[i])) {
            return false;
        }
    }
    return true;
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*  Brief Change History of This File                                         */
/*----------------------------------------------------------------------------*/
/*  Author              Date             Actions                              */
/*----------------------------------------------------------------------------*/
/*  Shizhe Li           Oct/24/2021      Create file                          */
/*  Chensong Zhang      Jan/16/2022      Update Doxygen                       */
/*----------------------------------------------------------------------------*/