Amesos2_Superlu_FunctionMap.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//           Amesos2: Templated Direct Sparse Solver Package
//                  Copyright 2011 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
//
// @HEADER

#ifndef AMESOS2_SUPERLU_FUNCTIONMAP_HPP
#define AMESOS2_SUPERLU_FUNCTIONMAP_HPP

#ifdef HAVE_TEUCHOS_COMPLEX
#include <complex>
#endif

#include "Amesos2_FunctionMap.hpp"
#include "Amesos2_Superlu_TypeMap.hpp"


/* External definitions of the Superlu functions
 *
 * Note that we do include the "slu_*defs.h" files provided for each
 * data-type.  This produces linker warnings, but keeps us from
 * including SuperLU code in our own code (even if only extern
 * declarations, which would eliminate linker warnings).  This is
 * because there are several declarations (as of SuperLU 4.1) across
 * these headers which conflict with each other in C linkage.  All of
 * the conflicting functions, on the other hand, we do not care about.
 */
namespace SLU {

  extern "C" {
    typedef int int_t;
#include "supermatrix.h"
#include "slu_util.h"

    namespace S {               // single-precision real definitions
#include "slu_sdefs.h"
    }

    namespace D {               // double-precision real definitions
#include "slu_ddefs.h"
    }

#ifdef HAVE_TEUCHOS_COMPLEX
    namespace C {              // single-precision complex definitions
#include "slu_cdefs.h"
    }

    namespace Z {              // double-precision complex definitions
#include "slu_zdefs.h"
    }
#endif  // HAVE_TEUCHOS_COMPLEX

  } // end extern "C"

} // end namespace SLU


namespace Amesos2 {

  /* ==================== Specializations ====================
   *
   * \cond Superlu_function_specializations
   */

  template <>
  struct FunctionMap<Superlu,float>
  {
    typedef TypeMap<Superlu,float> type_map;

    static void gssvx(SLU::superlu_options_t* options, SLU::SuperMatrix* A,
          int* perm_c, int* perm_r, int* etree, char* equed, float* R, float* C,
          SLU::SuperMatrix* L, SLU::SuperMatrix* U, void* work, int lwork,
          SLU::SuperMatrix* B, SLU::SuperMatrix* X, float* recip_pivot_growth,
          float* rcond, float* ferr, float* berr, SLU::mem_usage_t* mem_usage,
          SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::S::sgssvx(options, A, perm_c, perm_r, etree, equed, R, C, L, U, work,
         lwork, B, X, recip_pivot_growth, rcond, ferr, berr, mem_usage, stat, info);
    }

    static void gstrf(SLU::superlu_options_t* options, SLU::SuperMatrix* AC,
          int relax, int panel_size, int* etree, void* work,
          int lwork, int* perm_c, int* perm_r, SLU::SuperMatrix* L,
          SLU::SuperMatrix* U, SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::S::sgstrf(options, AC, relax, panel_size, etree,
         work, lwork, perm_c, perm_r, L, U, stat, info);
    }

    static void create_CompCol_Matrix(SLU::SuperMatrix* A, int m, int n, 
              int nnz, type_map::type* nzval, int* rowind, int* colptr, 
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::S::sCreate_CompCol_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);
    }

    static void create_CompRow_Matrix(SLU::SuperMatrix* A, int m, int n, 
              int nnz, type_map::type* nzval, int* rowind, int* colptr,
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::S::sCreate_CompRow_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);
    }


    static void create_Dense_Matrix(SLU::SuperMatrix* X, int m, int n,
            type_map::type* x, int ldx, SLU::Stype_t stype,
            SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::S::sCreate_Dense_Matrix(X, m, n, x, ldx, stype, dtype, mtype);
    }

    static void gsequ(SLU::SuperMatrix* A, float* R, float* C,
          float* rowcnd, float* colcnd, float* amax, int* info)
    {
      SLU::S::sgsequ(A, R, C, rowcnd, colcnd, amax, info);
    }

    static void laqgs(SLU::SuperMatrix* A, float* R, float* C,
          float rowcnd, float colcnd, float amax, char* equed)
    {
      SLU::S::slaqgs(A, R, C, rowcnd, colcnd, amax, equed);
    }
  };


  template <>
  struct FunctionMap<Superlu,double>
  {
    typedef TypeMap<Superlu,double> type_map;

    static void gssvx(SLU::superlu_options_t* options, SLU::SuperMatrix* A,
          int* perm_c, int* perm_r, int* etree, char* equed, double* R, double* C,
          SLU::SuperMatrix* L, SLU::SuperMatrix* U, void* work, int lwork,
          SLU::SuperMatrix* B, SLU::SuperMatrix* X, double* recip_pivot_growth,
          double* rcond, double* ferr, double* berr, SLU::mem_usage_t* mem_usage,
          SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::D::dgssvx(options, A, perm_c, perm_r, etree, equed, R, C, L, U, work,
         lwork, B, X, recip_pivot_growth, rcond, ferr, berr, mem_usage, stat, info);
    }

    static void gstrf(SLU::superlu_options_t* options, SLU::SuperMatrix* AC,
          int relax, int panel_size, int* etree, void* work, int lwork, int* perm_c,
          int* perm_r, SLU::SuperMatrix* L, SLU::SuperMatrix* U,
          SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::D::dgstrf(options, AC, relax, panel_size, etree,
         work, lwork, perm_c, perm_r, L, U, stat, info);
    }

    static void create_CompCol_Matrix(SLU::SuperMatrix* A, int m, int n, 
              int nnz, type_map::type* nzval, int* rowind, int* colptr, 
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::D::dCreate_CompCol_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);
    }

    static void create_CompRow_Matrix(SLU::SuperMatrix* A, int m, int n, 
              int nnz, type_map::type* nzval, int* rowind, int* colptr, 
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::D::dCreate_CompRow_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);
    }

    static void create_Dense_Matrix(SLU::SuperMatrix* X, int m, 
            int n, type_map::type* x, int ldx, SLU::Stype_t stype, 
            SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::D::dCreate_Dense_Matrix(X, m, n, x, ldx, stype, dtype, mtype);
    }

    static void gsequ(SLU::SuperMatrix* A, double* R, double* C,
          double* rowcnd, double* colcnd, double* amax, int* info)
    {
      SLU::D::dgsequ(A, R, C, rowcnd, colcnd, amax, info);
    }

    static void laqgs(SLU::SuperMatrix* A, double* R, double* C,
          double rowcnd, double colcnd, double amax, char* equed)
    {
      SLU::D::dlaqgs(A, R, C, rowcnd, colcnd, amax, equed);
    }

  };


#ifdef HAVE_TEUCHOS_COMPLEX

  /* The specializations for Teuchos::as<> for SLU::complex and
   * SLU::doublecomplex are provided in Amesos2_Superlu_Type.hpp
   */
  template <>
  struct FunctionMap<Superlu,SLU::C::complex>
  {
    static void gssvx(SLU::superlu_options_t* options, SLU::SuperMatrix* A,
          int* perm_c, int* perm_r, int* etree, char* equed, float* R, float* C,
          SLU::SuperMatrix* L, SLU::SuperMatrix* U, void* work, int lwork,
          SLU::SuperMatrix* B, SLU::SuperMatrix* X, float* recip_pivot_growth,
          float* rcond, float* ferr, float* berr, SLU::mem_usage_t* mem_usage,
          SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::C::cgssvx(options, A, perm_c, perm_r, etree, equed, R, C, L, U, work,
         lwork, B, X, recip_pivot_growth, rcond, ferr, berr, mem_usage, stat, info);
    }

    static void gstrf(SLU::superlu_options_t* options, SLU::SuperMatrix* AC,
          int relax, int panel_size, int* etree, void* work, int lwork, int* perm_c,
          int* perm_r, SLU::SuperMatrix* L, SLU::SuperMatrix* U,
          SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::C::cgstrf(options, AC, relax, panel_size, etree,
         work, lwork, perm_c, perm_r, L, U, stat, info);
    }

    static void create_CompCol_Matrix(SLU::SuperMatrix* A, int m, int n, int nnz,
              SLU::C::complex* nzval, int* rowind, int* colptr,
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::C::cCreate_CompCol_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);
    }

    static void create_CompRow_Matrix(SLU::SuperMatrix* A, int m, int n, int nnz,
              SLU::C::complex* nzval, int* rowind, int* colptr,
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::C::cCreate_CompRow_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);
    }

    static void create_Dense_Matrix(SLU::SuperMatrix* X, int m, int n,
            SLU::C::complex* x, int ldx, SLU::Stype_t stype,
            SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::C::cCreate_Dense_Matrix(X, m, n, x, ldx, stype, dtype, mtype);
    }

    static void gsequ(SLU::SuperMatrix* A, float* R, float* C,
          float* rowcnd, float* colcnd, float* amax, int* info)
    {
      SLU::C::cgsequ(A, R, C, rowcnd, colcnd, amax, info);
    }

    static void laqgs(SLU::SuperMatrix* A, float* R, float* C,
          float rowcnd, float colcnd, float amax, char* equed)
    {
      SLU::C::claqgs(A, R, C, rowcnd, colcnd, amax, equed);
    }
  };


  template <>
  struct FunctionMap<Superlu,SLU::Z::doublecomplex>
  {
    static void gssvx(SLU::superlu_options_t* options, SLU::SuperMatrix* A,
          int* perm_c, int* perm_r, int* etree, char* equed, double* R, double* C,
          SLU::SuperMatrix* L, SLU::SuperMatrix* U, void* work, int lwork,
          SLU::SuperMatrix* B, SLU::SuperMatrix* X, double* recip_pivot_growth,
          double* rcond, double* ferr, double* berr, SLU::mem_usage_t* mem_usage,
          SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::Z::zgssvx(options, A, perm_c, perm_r, etree, equed, R, C, L, U, work,
         lwork, B, X, recip_pivot_growth, rcond, ferr, berr, mem_usage, stat, info);
    }

    static void gstrf(SLU::superlu_options_t* options, SLU::SuperMatrix* AC,
          int relax, int panel_size, int* etree, void* work, int lwork, int* perm_c,
          int* perm_r, SLU::SuperMatrix* L, SLU::SuperMatrix* U,
          SLU::SuperLUStat_t* stat, int* info)
    {
      SLU::Z::zgstrf(options, AC, relax, panel_size, etree,
         work, lwork, perm_c, perm_r, L, U, stat, info);
    }

    static void create_CompCol_Matrix(SLU::SuperMatrix* A, int m, int n, int nnz,
              SLU::Z::doublecomplex* nzval, int* rowind, int* colptr,
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::Z::zCreate_CompCol_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);

      TEUCHOS_TEST_FOR_EXCEPTION( A == NULL,
        std::runtime_error,
        "Supermatrix A not initialized properly!");
    }


    static void create_CompRow_Matrix(SLU::SuperMatrix* A, int m, int n, int nnz,
              SLU::Z::doublecomplex* nzval, int* rowind, int* colptr,
              SLU::Stype_t stype, SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::Z::zCreate_CompRow_Matrix(A, m, n, nnz, nzval, rowind, colptr,
             stype, dtype, mtype);

      TEUCHOS_TEST_FOR_EXCEPTION( A == NULL,
        std::runtime_error,
        "Supermatrix A not initialized properly!");
    }

    static void create_Dense_Matrix(SLU::SuperMatrix* X, int m, int n,
            SLU::Z::doublecomplex* x, int ldx, SLU::Stype_t stype,
            SLU::Dtype_t dtype, SLU::Mtype_t mtype)
    {
      SLU::Z::zCreate_Dense_Matrix(X, m, n, x, ldx, stype, dtype, mtype);
    }

    static void gsequ(SLU::SuperMatrix* A, double* R, double* C,
          double* rowcnd, double* colcnd, double* amax, int* info)
    {
      SLU::Z::zgsequ(A, R, C, rowcnd, colcnd, amax, info);
    }

    static void laqgs(SLU::SuperMatrix* A, double* R, double* C,
          double rowcnd, double colcnd, double amax, char* equed)
    {
      SLU::Z::zlaqgs(A, R, C, rowcnd, colcnd, amax, equed);
    }
  };
#endif  // HAVE_TEUCHOS_COMPLEX

  /* \endcond Superlu_function_specializations */


} // end namespace Amesos2

#endif  // AMESOS2_SUPERLU_FUNCTIONMAP_HPP