CD_LaPackUtils.H

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2021-2026 SINTEF Energy Research
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
 
#ifndef CD_LAPACKUTILS_H
#define CD_LAPACKUTILS_H
 
// Std includes
#include <vector>
 
// Our includes
#include <CD_NamespaceHeader.H>
 
extern "C" void
dgelss_(int*    a_M,
        int*    a_N,
        int*    a_nRHS,
        double* a_A,
        int*    a_LDA,
        double* a_B,
        int*    a_LDB,
        double* a_S,
        double* a_rcond,
        int*    a_RANK,
        double* a_WORK,
        int*    a_LWORK,
        int*    a_INFO);
 
extern "C" void
dgesdd_(char*   a_JOBZ,
        int*    a_M,
        int*    a_N,
        double* a_A,
        int*    a_LDA,
        double* a_S,
        double* a_U,
        int*    a_LDU,
        double* a_VT,
        int*    a_LDVT,
        double* a_WORK,
        int*    a_LWORK,
        int*    a_IWORK,
        int*    a_INFO);
 
extern "C" void
sgesdd_(char*  a_JOBZ,
        int*   a_M,
        int*   a_N,
        float* a_A,
        int*   a_LDA,
        float* a_S,
        float* a_U,
        int*   a_LDU,
        float* a_VT,
        int*   a_LDVT,
        float* a_WORK,
        int*   a_LWORK,
        int*   a_IWORK,
        int*   a_INFO);
 
extern "C" void
dgemm_(char*   a_TRANSA,
       char*   a_TRANSB,
       int*    a_M,
       int*    a_N,
       int*    a_K,
       double* a_ALPHA,
       double* a_A,
       int*    a_LDA,
       double* a_B,
       int*    a_LDB,
       double* a_BETA,
       double* a_C,
       int*    a_LDC);
 
extern "C" void
sgemm_(char*  a_TRANSA,
       char*  a_TRANSB,
       int*   a_M,
       int*   a_N,
       int*   a_K,
       float* a_ALPHA,
       float* a_A,
       int*   a_LDA,
       float* a_B,
       int*   a_LDB,
       float* a_BETA,
       float* a_C,
       int*   a_LDC);
 
extern "C" void
dgesv_(int* N, int* NRHS, double* A, int* LDA, int* IPIV, double* B, int* LDB, int* INFO);
 
namespace LaPackUtils {
 
  int
  linearIndex(const int irow, const int jcol, const int M, const int N);
 
  bool
  computeSVD(std::vector<double>&       a_linU,
             std::vector<double>&       a_linSigma,
             std::vector<double>&       a_linVtran,
             const std::vector<double>& a_linA,
             const int&                 a_M,
             const int&                 a_N);
 
  bool
  computeSVD(std::vector<float>&       a_linU,
             std::vector<float>&       a_linSigma,
             std::vector<float>&       a_linVtran,
             const std::vector<float>& a_linA,
             const int&                a_M,
             const int&                a_N);
 
  bool
  computePseudoInverse(std::vector<double>&       a_linAplus,
                       const std::vector<double>& a_linA,
                       const int&                 a_M,
                       const int&                 a_N);
 
  bool
  computePseudoInverse(std::vector<float>&       a_linAplus,
                       const std::vector<float>& a_linA,
                       const int&                a_M,
                       const int&                a_N);
 
  void
  linearizeMatrix(std::vector<double>&                    a_linA,
                  int&                                    a_M,
                  int&                                    a_N,
                  const std::vector<std::vector<double>>& a_A,
                  const char&                             a_format);
 
  void
  linearizeColumnMajorMatrix(std::vector<double>&                    a_linA,
                             int&                                    a_M,
                             int&                                    a_N,
                             const std::vector<std::vector<double>>& a_A);
 
  void
  linearizeRowMajorMatrix(std::vector<double>& a_linA, int& a_M, int& a_N, const std::vector<std::vector<double>>& a_A);
 
  void
  deLinearizeMatrix(std::vector<std::vector<double>>& a_A,
                    const int&                        a_M,
                    const int&                        a_N,
                    const std::vector<double>&        a_linA,
                    const char&                       a_format);
 
  void
  deLinearizeColumnMajorMatrix(std::vector<std::vector<double>>& a_A,
                               const int&                        a_M,
                               const int&                        a_N,
                               const std::vector<double>&        a_linA);
 
  void
  deLinearizeRowMajorMatrix(std::vector<std::vector<double>>& a_A,
                            const int&                        a_M,
                            const int&                        a_N,
                            const std::vector<double>&        a_linA);
} // namespace LaPackUtils
 
#include <CD_NamespaceFooter.H>
 
#endif