// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_UMFPACKSUPPORT_H
#define EIGEN_UMFPACKSUPPORT_H

// for compatibility with super old version of umfpack,
// not sure this is really needed, but this is harmless.
#ifndef SuiteSparse_long
#ifdef UF_long
#define SuiteSparse_long UF_long
#else
#error neither SuiteSparse_long nor UF_long are defined
#endif
#endif

// IWYU pragma: private
#include "./InternalHeaderCheck.h"

namespace Eigen {

/* TODO extract L, extract U, compute det, etc... */

// generic double/complex<double> wrapper functions:

// Defaults
inline void umfpack_defaults(double control[UMFPACK_CONTROL], double, int) { umfpack_di_defaults(control); }

inline void umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, int) {
  umfpack_zi_defaults(control);
}

inline void umfpack_defaults(double control[UMFPACK_CONTROL], double, SuiteSparse_long) {
  umfpack_dl_defaults(control);
}

inline void umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long) {
  umfpack_zl_defaults(control);
}

// Report info
inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, int) {
  umfpack_di_report_info(control, info);
}

inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>, int) {
  umfpack_zi_report_info(control, info);
}

inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, SuiteSparse_long) {
  umfpack_dl_report_info(control, info);
}

inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>,
                                SuiteSparse_long) {
  umfpack_zl_report_info(control, info);
}

// Report status
inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, int) {
  umfpack_di_report_status(control, status);
}

inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, int) {
  umfpack_zi_report_status(control, status);
}

inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, SuiteSparse_long) {
  umfpack_dl_report_status(control, status);
}

inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, SuiteSparse_long) {
  umfpack_zl_report_status(control, status);
}

// report control
inline void umfpack_report_control(double control[UMFPACK_CONTROL], double, int) { umfpack_di_report_control(control); }

inline void umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, int) {
  umfpack_zi_report_control(control);
}

inline void umfpack_report_control(double control[UMFPACK_CONTROL], double, SuiteSparse_long) {
  umfpack_dl_report_control(control);
}

inline void umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long) {
  umfpack_zl_report_control(control);
}

// Free numeric
inline void umfpack_free_numeric(void **Numeric, double, int) {
  umfpack_di_free_numeric(Numeric);
  *Numeric = 0;
}

inline void umfpack_free_numeric(void **Numeric, std::complex<double>, int) {
  umfpack_zi_free_numeric(Numeric);
  *Numeric = 0;
}

inline void umfpack_free_numeric(void **Numeric, double, SuiteSparse_long) {
  umfpack_dl_free_numeric(Numeric);
  *Numeric = 0;
}

inline void umfpack_free_numeric(void **Numeric, std::complex<double>, SuiteSparse_long) {
  umfpack_zl_free_numeric(Numeric);
  *Numeric = 0;
}

// Free symbolic
inline void umfpack_free_symbolic(void **Symbolic, double, int) {
  umfpack_di_free_symbolic(Symbolic);
  *Symbolic = 0;
}

inline void umfpack_free_symbolic(void **Symbolic, std::complex<double>, int) {
  umfpack_zi_free_symbolic(Symbolic);
  *Symbolic = 0;
}

inline void umfpack_free_symbolic(void **Symbolic, double, SuiteSparse_long) {
  umfpack_dl_free_symbolic(Symbolic);
  *Symbolic = 0;
}

inline void umfpack_free_symbolic(void **Symbolic, std::complex<double>, SuiteSparse_long) {
  umfpack_zl_free_symbolic(Symbolic);
  *Symbolic = 0;
}

// Symbolic
inline int umfpack_symbolic(int n_row, int n_col, const int Ap[], const int Ai[], const double Ax[], void **Symbolic,
                            const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info);
}

inline int umfpack_symbolic(int n_row, int n_col, const int Ap[], const int Ai[], const std::complex<double> Ax[],
                            void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_zi_symbolic(n_row, n_col, Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Control, Info);
}
inline SuiteSparse_long umfpack_symbolic(SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[],
                                         const SuiteSparse_long Ai[], const double Ax[], void **Symbolic,
                                         const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info);
}

inline SuiteSparse_long umfpack_symbolic(SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[],
                                         const SuiteSparse_long Ai[], const std::complex<double> Ax[], void **Symbolic,
                                         const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_zl_symbolic(n_row, n_col, Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Control, Info);
}

// Numeric
inline int umfpack_numeric(const int Ap[], const int Ai[], const double Ax[], void *Symbolic, void **Numeric,
                           const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info);
}

inline int umfpack_numeric(const int Ap[], const int Ai[], const std::complex<double> Ax[], void *Symbolic,
                           void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_zi_numeric(Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Numeric, Control, Info);
}
inline SuiteSparse_long umfpack_numeric(const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[],
                                        void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL],
                                        double Info[UMFPACK_INFO]) {
  return umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info);
}

inline SuiteSparse_long umfpack_numeric(const SuiteSparse_long Ap[], const SuiteSparse_long Ai[],
                                        const std::complex<double> Ax[], void *Symbolic, void **Numeric,
                                        const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_zl_numeric(Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Numeric, Control, Info);
}

// solve
inline int umfpack_solve(int sys, const int Ap[], const int Ai[], const double Ax[], double X[], const double B[],
                         void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info);
}

inline int umfpack_solve(int sys, const int Ap[], const int Ai[], const std::complex<double> Ax[],
                         std::complex<double> X[], const std::complex<double> B[], void *Numeric,
                         const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_zi_solve(sys, Ap, Ai, &numext::real_ref(Ax[0]), 0, &numext::real_ref(X[0]), 0, &numext::real_ref(B[0]),
                          0, Numeric, Control, Info);
}

inline SuiteSparse_long umfpack_solve(int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[],
                                      const double Ax[], double X[], const double B[], void *Numeric,
                                      const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info);
}

inline SuiteSparse_long umfpack_solve(int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[],
                                      const std::complex<double> Ax[], std::complex<double> X[],
                                      const std::complex<double> B[], void *Numeric,
                                      const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO]) {
  return umfpack_zl_solve(sys, Ap, Ai, &numext::real_ref(Ax[0]), 0, &numext::real_ref(X[0]), 0, &numext::real_ref(B[0]),
                          0, Numeric, Control, Info);
}

// Get Lunz
inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double) {
  return umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric,
                            std::complex<double>) {
  return umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

inline SuiteSparse_long umfpack_get_lunz(SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row,
                                         SuiteSparse_long *n_col, SuiteSparse_long *nz_udiag, void *Numeric, double) {
  return umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

inline SuiteSparse_long umfpack_get_lunz(SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row,
                                         SuiteSparse_long *n_col, SuiteSparse_long *nz_udiag, void *Numeric,
                                         std::complex<double>) {
  return umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

// Get Numeric
inline int umfpack_get_numeric(int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[], int P[], int Q[],
                               double Dx[], int *do_recip, double Rs[], void *Numeric) {
  return umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric);
}

inline int umfpack_get_numeric(int Lp[], int Lj[], std::complex<double> Lx[], int Up[], int Ui[],
                               std::complex<double> Ux[], int P[], int Q[], std::complex<double> Dx[], int *do_recip,
                               double Rs[], void *Numeric) {
  double &lx0_real = numext::real_ref(Lx[0]);
  double &ux0_real = numext::real_ref(Ux[0]);
  double &dx0_real = numext::real_ref(Dx[0]);
  return umfpack_zi_get_numeric(Lp, Lj, Lx ? &lx0_real : 0, 0, Up, Ui, Ux ? &ux0_real : 0, 0, P, Q, Dx ? &dx0_real : 0,
                                0, do_recip, Rs, Numeric);
}
inline SuiteSparse_long umfpack_get_numeric(SuiteSparse_long Lp[], SuiteSparse_long Lj[], double Lx[],
                                            SuiteSparse_long Up[], SuiteSparse_long Ui[], double Ux[],
                                            SuiteSparse_long P[], SuiteSparse_long Q[], double Dx[],
                                            SuiteSparse_long *do_recip, double Rs[], void *Numeric) {
  return umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric);
}

inline SuiteSparse_long umfpack_get_numeric(SuiteSparse_long Lp[], SuiteSparse_long Lj[], std::complex<double> Lx[],
                                            SuiteSparse_long Up[], SuiteSparse_long Ui[], std::complex<double> Ux[],
                                            SuiteSparse_long P[], SuiteSparse_long Q[], std::complex<double> Dx[],
                                            SuiteSparse_long *do_recip, double Rs[], void *Numeric) {
  double &lx0_real = numext::real_ref(Lx[0]);
  double &ux0_real = numext::real_ref(Ux[0]);
  double &dx0_real = numext::real_ref(Dx[0]);
  return umfpack_zl_get_numeric(Lp, Lj, Lx ? &lx0_real : 0, 0, Up, Ui, Ux ? &ux0_real : 0, 0, P, Q, Dx ? &dx0_real : 0,
                                0, do_recip, Rs, Numeric);
}

// Get Determinant
inline int umfpack_get_determinant(double *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], int) {
  return umfpack_di_get_determinant(Mx, Ex, NumericHandle, User_Info);
}

inline int umfpack_get_determinant(std::complex<double> *Mx, double *Ex, void *NumericHandle,
                                   double User_Info[UMFPACK_INFO], int) {
  double &mx_real = numext::real_ref(*Mx);
  return umfpack_zi_get_determinant(&mx_real, 0, Ex, NumericHandle, User_Info);
}

inline SuiteSparse_long umfpack_get_determinant(double *Mx, double *Ex, void *NumericHandle,
                                                double User_Info[UMFPACK_INFO], SuiteSparse_long) {
  return umfpack_dl_get_determinant(Mx, Ex, NumericHandle, User_Info);
}

inline SuiteSparse_long umfpack_get_determinant(std::complex<double> *Mx, double *Ex, void *NumericHandle,
                                                double User_Info[UMFPACK_INFO], SuiteSparse_long) {
  double &mx_real = numext::real_ref(*Mx);
  return umfpack_zl_get_determinant(&mx_real, 0, Ex, NumericHandle, User_Info);
}

/** \ingroup UmfPackSupport_Module
 * \brief A sparse LU factorization and solver based on UmfPack
 *
 * This class allows to solve for A.X = B sparse linear problems via a LU factorization
 * using the UmfPack library. The sparse matrix A must be squared and full rank.
 * The vectors or matrices X and B can be either dense or sparse.
 *
 * \warning The input matrix A should be in a \b compressed and \b column-major form.
 * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
 * \tparam MatrixType_ the type of the sparse matrix A, it must be a SparseMatrix<>
 *
 * \implsparsesolverconcept
 *
 * \sa \ref TutorialSparseSolverConcept, class SparseLU
 */
template <typename MatrixType_>
class UmfPackLU : public SparseSolverBase<UmfPackLU<MatrixType_> > {
 protected:
  typedef SparseSolverBase<UmfPackLU<MatrixType_> > Base;
  using Base::m_isInitialized;

 public:
  using Base::_solve_impl;
  typedef MatrixType_ MatrixType;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  typedef typename MatrixType::StorageIndex StorageIndex;
  typedef Matrix<Scalar, Dynamic, 1> Vector;
  typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
  typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
  typedef SparseMatrix<Scalar> LUMatrixType;
  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> UmfpackMatrixType;
  typedef Ref<const UmfpackMatrixType, StandardCompressedFormat> UmfpackMatrixRef;
  enum { ColsAtCompileTime = MatrixType::ColsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime };

 public:
  typedef Array<double, UMFPACK_CONTROL, 1> UmfpackControl;
  typedef Array<double, UMFPACK_INFO, 1> UmfpackInfo;

  UmfPackLU() : m_dummy(0, 0), mp_matrix(m_dummy) { init(); }

  template <typename InputMatrixType>
  explicit UmfPackLU(const InputMatrixType &matrix) : mp_matrix(matrix) {
    init();
    compute(matrix);
  }

  ~UmfPackLU() {
    if (m_symbolic) umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
  }

  inline Index rows() const { return mp_matrix.rows(); }
  inline Index cols() const { return mp_matrix.cols(); }

  /** \brief Reports whether previous computation was successful.
   *
   * \returns \c Success if computation was successful,
   *          \c NumericalIssue if the matrix.appears to be negative.
   */
  ComputationInfo info() const {
    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
    return m_info;
  }

  inline const LUMatrixType &matrixL() const {
    if (m_extractedDataAreDirty) extractData();
    return m_l;
  }

  inline const LUMatrixType &matrixU() const {
    if (m_extractedDataAreDirty) extractData();
    return m_u;
  }

  inline const IntColVectorType &permutationP() const {
    if (m_extractedDataAreDirty) extractData();
    return m_p;
  }

  inline const IntRowVectorType &permutationQ() const {
    if (m_extractedDataAreDirty) extractData();
    return m_q;
  }

  /** Computes the sparse Cholesky decomposition of \a matrix
   *  Note that the matrix should be column-major, and in compressed format for best performance.
   *  \sa SparseMatrix::makeCompressed().
   */
  template <typename InputMatrixType>
  void compute(const InputMatrixType &matrix) {
    if (m_symbolic) umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
    grab(matrix.derived());
    analyzePattern_impl();
    factorize_impl();
  }

  /** Performs a symbolic decomposition on the sparcity of \a matrix.
   *
   * This function is particularly useful when solving for several problems having the same structure.
   *
   * \sa factorize(), compute()
   */
  template <typename InputMatrixType>
  void analyzePattern(const InputMatrixType &matrix) {
    if (m_symbolic) umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());

    grab(matrix.derived());

    analyzePattern_impl();
  }

  /** Provides the return status code returned by UmfPack during the numeric
   * factorization.
   *
   * \sa factorize(), compute()
   */
  inline int umfpackFactorizeReturncode() const {
    eigen_assert(m_numeric && "UmfPackLU: you must first call factorize()");
    return m_fact_errorCode;
  }

  /** Provides access to the control settings array used by UmfPack.
   *
   * If this array contains NaN's, the default values are used.
   *
   * See UMFPACK documentation for details.
   */
  inline const UmfpackControl &umfpackControl() const { return m_control; }

  /** Provides access to the control settings array used by UmfPack.
   *
   * If this array contains NaN's, the default values are used.
   *
   * See UMFPACK documentation for details.
   */
  inline UmfpackControl &umfpackControl() { return m_control; }

  /** Performs a numeric decomposition of \a matrix
   *
   * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
   *
   * \sa analyzePattern(), compute()
   */
  template <typename InputMatrixType>
  void factorize(const InputMatrixType &matrix) {
    eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());

    grab(matrix.derived());

    factorize_impl();
  }

  /** Prints the current UmfPack control settings.
   *
   * \sa umfpackControl()
   */
  void printUmfpackControl() { umfpack_report_control(m_control.data(), Scalar(), StorageIndex()); }

  /** Prints statistics collected by UmfPack.
   *
   * \sa analyzePattern(), compute()
   */
  void printUmfpackInfo() {
    eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
    umfpack_report_info(m_control.data(), m_umfpackInfo.data(), Scalar(), StorageIndex());
  }

  /** Prints the status of the previous factorization operation performed by UmfPack (symbolic or numerical
   * factorization).
   *
   * \sa analyzePattern(), compute()
   */
  void printUmfpackStatus() {
    eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
    umfpack_report_status(m_control.data(), m_fact_errorCode, Scalar(), StorageIndex());
  }

  /** \internal */
  template <typename BDerived, typename XDerived>
  bool _solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const;

  Scalar determinant() const;

  void extractData() const;

 protected:
  void init() {
    m_info = InvalidInput;
    m_isInitialized = false;
    m_numeric = 0;
    m_symbolic = 0;
    m_extractedDataAreDirty = true;

    umfpack_defaults(m_control.data(), Scalar(), StorageIndex());
  }

  void analyzePattern_impl() {
    m_fact_errorCode = umfpack_symbolic(internal::convert_index<StorageIndex>(mp_matrix.rows()),
                                        internal::convert_index<StorageIndex>(mp_matrix.cols()),
                                        mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
                                        &m_symbolic, m_control.data(), m_umfpackInfo.data());

    m_isInitialized = true;
    m_info = m_fact_errorCode ? InvalidInput : Success;
    m_analysisIsOk = true;
    m_factorizationIsOk = false;
    m_extractedDataAreDirty = true;
  }

  void factorize_impl() {
    m_fact_errorCode = umfpack_numeric(mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
                                       m_symbolic, &m_numeric, m_control.data(), m_umfpackInfo.data());

    m_info = m_fact_errorCode == UMFPACK_OK ? Success : NumericalIssue;
    m_factorizationIsOk = true;
    m_extractedDataAreDirty = true;
  }

  template <typename MatrixDerived>
  void grab(const EigenBase<MatrixDerived> &A) {
    internal::destroy_at(&mp_matrix);
    internal::construct_at(&mp_matrix, A.derived());
  }

  void grab(const UmfpackMatrixRef &A) {
    if (&(A.derived()) != &mp_matrix) {
      internal::destroy_at(&mp_matrix);
      internal::construct_at(&mp_matrix, A);
    }
  }

  // cached data to reduce reallocation, etc.
  mutable LUMatrixType m_l;
  StorageIndex m_fact_errorCode;
  UmfpackControl m_control;
  mutable UmfpackInfo m_umfpackInfo;

  mutable LUMatrixType m_u;
  mutable IntColVectorType m_p;
  mutable IntRowVectorType m_q;

  UmfpackMatrixType m_dummy;
  UmfpackMatrixRef mp_matrix;

  void *m_numeric;
  void *m_symbolic;

  mutable ComputationInfo m_info;
  int m_factorizationIsOk;
  int m_analysisIsOk;
  mutable bool m_extractedDataAreDirty;

 private:
  UmfPackLU(const UmfPackLU &) {}
};

template <typename MatrixType>
void UmfPackLU<MatrixType>::extractData() const {
  if (m_extractedDataAreDirty) {
    // get size of the data
    StorageIndex lnz, unz, rows, cols, nz_udiag;
    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());

    // allocate data
    m_l.resize(rows, (std::min)(rows, cols));
    m_l.resizeNonZeros(lnz);

    m_u.resize((std::min)(rows, cols), cols);
    m_u.resizeNonZeros(unz);

    m_p.resize(rows);
    m_q.resize(cols);

    // extract
    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(), m_u.outerIndexPtr(),
                        m_u.innerIndexPtr(), m_u.valuePtr(), m_p.data(), m_q.data(), 0, 0, 0, m_numeric);

    m_extractedDataAreDirty = false;
  }
}

template <typename MatrixType>
typename UmfPackLU<MatrixType>::Scalar UmfPackLU<MatrixType>::determinant() const {
  Scalar det;
  umfpack_get_determinant(&det, 0, m_numeric, 0, StorageIndex());
  return det;
}

template <typename MatrixType>
template <typename BDerived, typename XDerived>
bool UmfPackLU<MatrixType>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const {
  Index rhsCols = b.cols();
  eigen_assert((BDerived::Flags & RowMajorBit) == 0 && "UmfPackLU backend does not support non col-major rhs yet");
  eigen_assert((XDerived::Flags & RowMajorBit) == 0 && "UmfPackLU backend does not support non col-major result yet");
  eigen_assert(b.derived().data() != x.derived().data() && " Umfpack does not support inplace solve");

  Scalar *x_ptr = 0;
  Matrix<Scalar, Dynamic, 1> x_tmp;
  if (x.innerStride() != 1) {
    x_tmp.resize(x.rows());
    x_ptr = x_tmp.data();
  }
  for (int j = 0; j < rhsCols; ++j) {
    if (x.innerStride() == 1) x_ptr = &x.col(j).coeffRef(0);
    StorageIndex errorCode =
        umfpack_solve(UMFPACK_A, mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(), x_ptr,
                      &b.const_cast_derived().col(j).coeffRef(0), m_numeric, m_control.data(), m_umfpackInfo.data());
    if (x.innerStride() != 1) x.col(j) = x_tmp;
    if (errorCode != 0) return false;
  }

  return true;
}

}  // end namespace Eigen

#endif  // EIGEN_UMFPACKSUPPORT_H