LapackSupport.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dftefeLapackSupport_h
#define dftefeLapackSupport_h
 
namespace dftefe
{
  namespace linearAlgebra
  {
    namespace types
    {
      using LapackInt = int64_t;
    } // namespace types
 
    namespace LAPACKSupport
    {
      enum State
      {
        matrix,
        inverse_matrix,
        lu,
        cholesky,
        eigenvalues,
        svd,
        inverse_svd,
        unusable = 0x8000
      };
 
      inline const char *
      state_name(State s)
      {
        switch (s)
          {
            case matrix:
              return "matrix";
            case inverse_matrix:
              return "inverse matrix";
            case lu:
              return "lu decomposition";
            case cholesky:
              return "cholesky decomposition";
            case eigenvalues:
              return "eigenvalues";
            case svd:
              return "svd";
            case inverse_svd:
              return "inverse_svd";
            case unusable:
              return "unusable";
            default:
              return "unknown";
          }
      }
 
      enum Property
      {
        general = 0,
        hermitian = 1,
        upper_triangular = 2,
        lower_triangular = 4,
        diagonal = 6,
        hessenberg = 8
      };
 
      inline const char *
      property_name(const Property s)
      {
        switch (s)
          {
            case general:
              return "general";
            case hermitian:
              return "hermitian";
            case upper_triangular:
              return "upper triangular";
            case lower_triangular:
              return "lower triangular";
            case diagonal:
              return "diagonal";
            case hessenberg:
              return "Hessenberg";
          }
 
        DFTEFE_Assert(false);
        return "invalid";
      }
 
      static const char A = 'A';
      static const char N = 'N';
      static const char O = 'O';
      static const char T = 'T';
      static const char C = 'C';
      static const char U = 'U';
      static const char L = 'L';
      static const char V = 'V';
      static const types::LapackInt zero = 0;
      static const types::LapackInt one = 1;
 
    } // namespace LAPACKSupport
  }   // namespace linearAlgebra
} // namespace dftefe
#endif