BlasLapackLA.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_LINEARALGEBRA_INTERFACES_BLASLAPACKLA_HPP_
#define GEOSX_LINEARALGEBRA_INTERFACES_BLASLAPACKLA_HPP_

#include <complex>
#include "common/DataTypes.hpp"
#include "common/Logger.hpp"
#include "linearAlgebra/common.hpp"

namespace geosx
{

struct BlasLapackLA
{
  template< typename T >
  using Vec = arraySlice1d< T >;

  template< typename T >
  using MatRowMajor = arraySlice2d< T, MatrixLayout::ROW_MAJOR >;

  template< typename T >
  using MatColMajor = arraySlice2d< T, MatrixLayout::COL_MAJOR >;

  enum class RandomNumberDistribution : integer
  {
    UNIFORM_01 = 1,   
    UNIFORM_m1p1 = 2, 
    NORMAL_01 = 3     
  };

  static real64 vectorNorm1( Vec< real64 const > const & X );

  static real64 vectorNorm2( Vec< real64 const > const & X );

  static real64 vectorNormInf( Vec< real64 const > const & X );

  static real64 determinant( MatRowMajor< real64 const > const & A );

  static real64 determinant( MatColMajor< real64 const > const & A );

  static real64 matrixNormInf( MatRowMajor< real64 const > const & A );

  static real64 matrixNormInf( MatColMajor< real64 const > const & A );

  static real64 matrixNorm1( MatRowMajor< real64 const > const & A );

  static real64 matrixNorm1( MatColMajor< real64 const > const & A );

  static real64 matrixNormFrobenius( MatRowMajor< real64 const > const & A );

  static real64 matrixNormFrobenius( MatColMajor< real64 const > const & A );

  static void vectorVectorAdd( Vec< real64 const > const & X,
                               Vec< real64 > const & Y,
                               real64 const alpha = 1. );

  static void matrixMatrixAdd( MatRowMajor< real64 const > const & A,
                               MatRowMajor< real64 > const & B,
                               real64 const alpha = 1. );

  static void matrixMatrixAdd( MatColMajor< real64 const > const & A,
                               MatColMajor< real64 > const & B,
                               real64 const alpha = 1. );

  static void vectorScale( real64 const alpha,
                           Vec< real64 > const & X );

  static void matrixScale( real64 const alpha,
                           MatRowMajor< real64 > const & A );

  static void matrixScale( real64 const alpha,
                           MatColMajor< real64 > const & A );

  static real64 vectorDot( Vec< real64 const > const & X,
                           Vec< real64 const > const & Y );

  static void matrixVectorMultiply( MatRowMajor< real64 const > const & A,
                                    Vec< real64 const > const & X,
                                    Vec< real64 > const & Y,
                                    real64 const alpha = 1.0,
                                    real64 const beta = 0.0 );

  static void matrixTVectorMultiply( MatRowMajor< real64 const > const & A,
                                     Vec< real64 const > const & X,
                                     Vec< real64 > const & Y,
                                     real64 const alpha = 1.0,
                                     real64 const beta = 0.0 );

  static void matrixMatrixMultiply( MatRowMajor< real64 const > const & A,
                                    MatRowMajor< real64 const > const & B,
                                    MatRowMajor< real64 > const & C,
                                    real64 const alpha = 1.0,
                                    real64 const beta = 0.0 );

  static void matrixTMatrixMultiply( MatRowMajor< real64 const > const & A,
                                     MatRowMajor< real64 const > const & B,
                                     MatRowMajor< real64 > const & C,
                                     real64 const alpha = 1.0,
                                     real64 const beta = 0.0 );

  static void matrixMatrixTMultiply( MatRowMajor< real64 const > const & A,
                                     MatRowMajor< real64 const > const & B,
                                     MatRowMajor< real64 > const & C,
                                     real64 const alpha = 1.0,
                                     real64 const beta = 0.0 );

  static void matrixTMatrixTMultiply( MatRowMajor< real64 const > const & A,
                                      MatRowMajor< real64 const > const & B,
                                      MatRowMajor< real64 > const & C,
                                      real64 const alpha = 1.0,
                                      real64 const beta = 0.0 );

  static void matrixInverse( MatRowMajor< real64 const > const & A,
                             MatRowMajor< real64 > const & Ainv,
                             real64 & detA );

  static void matrixInverse( MatColMajor< real64 const > const & A,
                             MatColMajor< real64 > const & Ainv,
                             real64 & detA );

  static void matrixInverse( MatRowMajor< real64 const > const & A,
                             MatRowMajor< real64 > const & Ainv );

  static void matrixInverse( MatColMajor< real64 const > const & A,
                             MatColMajor< real64 > const & Ainv );

  static void vectorCopy( Vec< real64 const > const & X,
                          Vec< real64 > const & Y );

  static void matrixCopy( MatRowMajor< real64 const > const & A,
                          MatRowMajor< real64 > const & B );

  static void matrixCopy( MatColMajor< real64 const > const & A,
                          MatColMajor< real64 > const & B );

  static void setRandomNumberGeneratorSeed( arraySlice1d< int const > const & seed );

  static void getRandomNumberGeneratorSeed( arraySlice1d< int > const & seed );

  static void vectorRand( Vec< real64 > const & X,
                          RandomNumberDistribution const & idist = RandomNumberDistribution::UNIFORM_01 );

  static void matrixRand( MatRowMajor< real64 > const & A,
                          RandomNumberDistribution const & idist = RandomNumberDistribution::UNIFORM_01 );

  static void matrixRand( MatColMajor< real64 > const & A,
                          RandomNumberDistribution const & idist = RandomNumberDistribution::UNIFORM_01 );


  static void matrixSVD( MatRowMajor< real64 const > const & A,
                         MatRowMajor< real64 > const & U,
                         Vec< real64 > const & S,
                         MatRowMajor< real64 > const & VT );

  static void matrixSVD( MatColMajor< real64 const > const & A,
                         MatColMajor< real64 > const & U,
                         Vec< real64 > const & S,
                         MatColMajor< real64 > const & VT );

  static void matrixEigenvalues( MatRowMajor< real64 const > const & A,
                                 Vec< std::complex< real64 > > const & lambda );

  static void matrixEigenvalues( MatColMajor< real64 const > const & A,
                                 Vec< std::complex< real64 > > const & lambda );

};

}

#endif /*GEOSX_LINEARALGEBRA_BLASLAPACKLA_HPP_*/