#pragma once

#ifndef TLIN_SUPERLU_WRAP

#define TLIN_SUPERLU_WRAP

#include "tcommon.h"

#undef DVAPI

#undef DVVAR

#ifdef TNZEXT_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

#include "tlin_matrix.h"

#include "tlin_sparsemat.h"

/*

  EXPLANATION:

  The tlin_superlu_wrap files implement wrappers to the SuperLU library.

  They are used to provide utility interfaces to SuperLU from tlin, and

  overcome name collisions (in particular, SuperLU is pure C - no

  namespaces, and redefines DOUBLES and such already defined

  from <windows.h>...)</windows.h>

*/

//================================================================================

namespace tlin {

//*****************************************************************************

//    Forward declarations

//*****************************************************************************

/*

  The following structs are heirs of the actual SuperLU counterparts - this is

  necessary due to the "typedef struct {..} _Name" syntax that prevents forward

  declaration of "_Name" (different base types).

  No member is added to the original type - so they are accessible exactly the

  same way.

*/

struct SuperMatrix;

struct superlu_options_t;

struct SuperFactors {

  SuperMatrix *L;

  SuperMatrix *U;

  int *perm_c;

  int *perm_r;

};

//*****************************************************************************

//    SuperLU-specific routines

//*****************************************************************************

void DVAPI allocS(SuperMatrix *&A, int rows, int cols,

                  int nnz);  //!< Allocates A in NC (sparse) format

void DVAPI allocD(SuperMatrix *&A, int rows,

                  int cols);  //!< Allocates A in DN (dense) format

//! Allocates A with externally supplied initializer values

void DVAPI allocS(SuperMatrix *&A, int rows, int cols, int nnz, int *colptr,

                  int *rowind, double *values);

void DVAPI allocD(SuperMatrix *&A, int rows, int cols, int lda, double *values);

void DVAPI freeS(SuperMatrix *A);   //!< Frees A allocated with allocS

void DVAPI freeD(SuperMatrix *A);   //!< Frees A allocated with allocD

void DVAPI freeF(SuperFactors *F);  //!< Frees F returned by factorize

//! Initializes a local SuperMatrix (ie created on stack).

void DVAPI createS(SuperMatrix &A, int rows, int cols, int nnz);

void DVAPI createD(SuperMatrix &A, int rows, int cols);

//! Initializes a local SuperMatrix with externally supplied data.

void DVAPI createS(SuperMatrix &A, int rows, int cols, int nnz, int *colptr,

                   int *rowind, double *values);

void DVAPI createD(SuperMatrix &A, int rows, int cols, int lda, double *values);

//! Destroys A. To be used when A is local (ie with create). Can be told to

//! spare data deallocation.

void DVAPI destroyS(SuperMatrix &A, bool destroyData = true);

void DVAPI destroyD(SuperMatrix &A, bool destroyData = true);

void DVAPI readDN(SuperMatrix *A, int &lda,

                  double *&values);  //!< Reads values ptr from A

void DVAPI readNC(SuperMatrix *A, int &nnz, int *&colptr, int *&rowind,

                  double *&values);  //!< Reads array ptrs from A

//! Copies m's content to A. A could be either 0 or an already initialized

//! SuperMatrix.

void DVAPI traduceS(tlin::sparse_matrix<double> &m, SuperMatrix *&A);</double>

void DVAPI traduceD(const tlin::matrix<double> &m, SuperMatrix *&A);</double>

void DVAPI traduceD(const tlin::sparse_matrix<double> &m, SuperMatrix *&A);</double>

/*!

  Returns A's factorization F, or 0 if the factorization failed (due to A's

  singularity,

  or memory shortage - see SuperLU docs for details).

*/

void DVAPI factorize(SuperMatrix *A, SuperFactors *&F,

                     superlu_options_t *opt = 0);

void DVAPI solve(SuperFactors *F, SuperMatrix *BX, superlu_options_t *opt = 0);

void DVAPI solve(SuperFactors *F, SuperMatrix *B, SuperMatrix *&X,

                 superlu_options_t *opt = 0);

void DVAPI solve(SuperMatrix *A, SuperMatrix *BX, superlu_options_t *opt = 0);

void DVAPI solve(SuperMatrix *A, SuperMatrix *B, SuperMatrix *&X,

                 superlu_options_t *opt = 0);

void DVAPI solve(SuperFactors *F, double *bx, superlu_options_t *opt = 0);

void DVAPI solve(SuperFactors *F, double *b, double *&x,

                 superlu_options_t *opt = 0);

void DVAPI solve(SuperMatrix *A, double *bx, superlu_options_t *opt = 0);

void DVAPI solve(SuperMatrix *A, double *b, double *&x,

                 superlu_options_t *opt = 0);

//*****************************************************************************

//    BLAS-related routines

//*****************************************************************************

void DVAPI multiplyS(const SuperMatrix *A, const double *v, double *&Av);

void DVAPI multiplyD(const SuperMatrix *A, const double *v, double *&Av);

}  // namespace tlin

#endif  // TLIN_SUPERLU_WRAP