xtgeo 4.10.0__cp312-cp312-macosx_11_0_arm64.whl → 4.11.0__cp312-cp312-macosx_11_0_arm64.whl

xtgeo/include/eigen3/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h

@@ -1,226 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011-2014 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_BASIC_PRECONDITIONERS_H
-#define EIGEN_BASIC_PRECONDITIONERS_H
-
-namespace Eigen {
-
-/** \ingroup IterativeLinearSolvers_Module
-  * \brief A preconditioner based on the digonal entries
-  *
-  * This class allows to approximately solve for A.x = b problems assuming A is a diagonal matrix.
-  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
-    \code
-    A.diagonal().asDiagonal() . x = b
-    \endcode
-  *
-  * \tparam _Scalar the type of the scalar.
-  *
-  * \implsparsesolverconcept
-  *
-  * This preconditioner is suitable for both selfadjoint and general problems.
-  * The diagonal entries are pre-inverted and stored into a dense vector.
-  *
-  * \note A variant that has yet to be implemented would attempt to preserve the norm of each column.
-  *
-  * \sa class LeastSquareDiagonalPreconditioner, class ConjugateGradient
-  */
-template <typename _Scalar>
-class DiagonalPreconditioner
-{
-    typedef _Scalar Scalar;
-    typedef Matrix<Scalar,Dynamic,1> Vector;
-  public:
-    typedef typename Vector::StorageIndex StorageIndex;
-    enum {
-      ColsAtCompileTime = Dynamic,
-      MaxColsAtCompileTime = Dynamic
-    };
-
-    DiagonalPreconditioner() : m_isInitialized(false) {}
-
-    template<typename MatType>
-    explicit DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols())
-    {
-      compute(mat);
-    }
-
-    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
-    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
-
-    template<typename MatType>
-    DiagonalPreconditioner& analyzePattern(const MatType& )
-    {
-      return *this;
-    }
-
-    template<typename MatType>
-    DiagonalPreconditioner& factorize(const MatType& mat)
-    {
-      m_invdiag.resize(mat.cols());
-      for(int j=0; j<mat.outerSize(); ++j)
-      {
-        typename MatType::InnerIterator it(mat,j);
-        while(it && it.index()!=j) ++it;
-        if(it && it.index()==j && it.value()!=Scalar(0))
-          m_invdiag(j) = Scalar(1)/it.value();
-        else
-          m_invdiag(j) = Scalar(1);
-      }
-      m_isInitialized = true;
-      return *this;
-    }
-
-    template<typename MatType>
-    DiagonalPreconditioner& compute(const MatType& mat)
-    {
-      return factorize(mat);
-    }
-
-    /** \internal */
-    template<typename Rhs, typename Dest>
-    void _solve_impl(const Rhs& b, Dest& x) const
-    {
-      x = m_invdiag.array() * b.array() ;
-    }
-
-    template<typename Rhs> inline const Solve<DiagonalPreconditioner, Rhs>
-    solve(const MatrixBase<Rhs>& b) const
-    {
-      eigen_assert(m_isInitialized && "DiagonalPreconditioner is not initialized.");
-      eigen_assert(m_invdiag.size()==b.rows()
-                && "DiagonalPreconditioner::solve(): invalid number of rows of the right hand side matrix b");
-      return Solve<DiagonalPreconditioner, Rhs>(*this, b.derived());
-    }
-
-    ComputationInfo info() { return Success; }
-
-  protected:
-    Vector m_invdiag;
-    bool m_isInitialized;
-};
-
-/** \ingroup IterativeLinearSolvers_Module
-  * \brief Jacobi preconditioner for LeastSquaresConjugateGradient
-  *
-  * This class allows to approximately solve for A' A x  = A' b problems assuming A' A is a diagonal matrix.
-  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
-    \code
-    (A.adjoint() * A).diagonal().asDiagonal() * x = b
-    \endcode
-  *
-  * \tparam _Scalar the type of the scalar.
-  *
-  * \implsparsesolverconcept
-  *
-  * The diagonal entries are pre-inverted and stored into a dense vector.
-  *
-  * \sa class LeastSquaresConjugateGradient, class DiagonalPreconditioner
-  */
-template <typename _Scalar>
-class LeastSquareDiagonalPreconditioner : public DiagonalPreconditioner<_Scalar>
-{
-    typedef _Scalar Scalar;
-    typedef typename NumTraits<Scalar>::Real RealScalar;
-    typedef DiagonalPreconditioner<_Scalar> Base;
-    using Base::m_invdiag;
-  public:
-
-    LeastSquareDiagonalPreconditioner() : Base() {}
-
-    template<typename MatType>
-    explicit LeastSquareDiagonalPreconditioner(const MatType& mat) : Base()
-    {
-      compute(mat);
-    }
-
-    template<typename MatType>
-    LeastSquareDiagonalPreconditioner& analyzePattern(const MatType& )
-    {
-      return *this;
-    }
-
-    template<typename MatType>
-    LeastSquareDiagonalPreconditioner& factorize(const MatType& mat)
-    {
-      // Compute the inverse squared-norm of each column of mat
-      m_invdiag.resize(mat.cols());
-      if(MatType::IsRowMajor)
-      {
-        m_invdiag.setZero();
-        for(Index j=0; j<mat.outerSize(); ++j)
-        {
-          for(typename MatType::InnerIterator it(mat,j); it; ++it)
-            m_invdiag(it.index()) += numext::abs2(it.value());
-        }
-        for(Index j=0; j<mat.cols(); ++j)
-          if(numext::real(m_invdiag(j))>RealScalar(0))
-            m_invdiag(j) = RealScalar(1)/numext::real(m_invdiag(j));
-      }
-      else
-      {
-        for(Index j=0; j<mat.outerSize(); ++j)
-        {
-          RealScalar sum = mat.col(j).squaredNorm();
-          if(sum>RealScalar(0))
-            m_invdiag(j) = RealScalar(1)/sum;
-          else
-            m_invdiag(j) = RealScalar(1);
-        }
-      }
-      Base::m_isInitialized = true;
-      return *this;
-    }
-
-    template<typename MatType>
-    LeastSquareDiagonalPreconditioner& compute(const MatType& mat)
-    {
-      return factorize(mat);
-    }
-
-    ComputationInfo info() { return Success; }
-
-  protected:
-};
-
-/** \ingroup IterativeLinearSolvers_Module
-  * \brief A naive preconditioner which approximates any matrix as the identity matrix
-  *
-  * \implsparsesolverconcept
-  *
-  * \sa class DiagonalPreconditioner
-  */
-class IdentityPreconditioner
-{
-  public:
-
-    IdentityPreconditioner() {}
-
-    template<typename MatrixType>
-    explicit IdentityPreconditioner(const MatrixType& ) {}
-
-    template<typename MatrixType>
-    IdentityPreconditioner& analyzePattern(const MatrixType& ) { return *this; }
-
-    template<typename MatrixType>
-    IdentityPreconditioner& factorize(const MatrixType& ) { return *this; }
-
-    template<typename MatrixType>
-    IdentityPreconditioner& compute(const MatrixType& ) { return *this; }
-
-    template<typename Rhs>
-    inline const Rhs& solve(const Rhs& b) const { return b; }
-
-    ComputationInfo info() { return Success; }
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_BASIC_PRECONDITIONERS_H

xtgeo/include/eigen3/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h

@@ -1,212 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
-// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@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_BICGSTAB_H
-#define EIGEN_BICGSTAB_H
-
-namespace Eigen { 
-
-namespace internal {
-
-/** \internal Low-level bi conjugate gradient stabilized algorithm
-  * \param mat The matrix A
-  * \param rhs The right hand side vector b
-  * \param x On input and initial solution, on output the computed solution.
-  * \param precond A preconditioner being able to efficiently solve for an
-  *                approximation of Ax=b (regardless of b)
-  * \param iters On input the max number of iteration, on output the number of performed iterations.
-  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
-  * \return false in the case of numerical issue, for example a break down of BiCGSTAB. 
-  */
-template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-bool bicgstab(const MatrixType& mat, const Rhs& rhs, Dest& x,
-              const Preconditioner& precond, Index& iters,
-              typename Dest::RealScalar& tol_error)
-{
-  using std::sqrt;
-  using std::abs;
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar,Dynamic,1> VectorType;
-  RealScalar tol = tol_error;
-  Index maxIters = iters;
-
-  Index n = mat.cols();
-  VectorType r  = rhs - mat * x;
-  VectorType r0 = r;
-  
-  RealScalar r0_sqnorm = r0.squaredNorm();
-  RealScalar rhs_sqnorm = rhs.squaredNorm();
-  if(rhs_sqnorm == 0)
-  {
-    x.setZero();
-    return true;
-  }
-  Scalar rho    = 1;
-  Scalar alpha  = 1;
-  Scalar w      = 1;
-  
-  VectorType v = VectorType::Zero(n), p = VectorType::Zero(n);
-  VectorType y(n),  z(n);
-  VectorType kt(n), ks(n);
-
-  VectorType s(n), t(n);
-
-  RealScalar tol2 = tol*tol*rhs_sqnorm;
-  RealScalar eps2 = NumTraits<Scalar>::epsilon()*NumTraits<Scalar>::epsilon();
-  Index i = 0;
-  Index restarts = 0;
-
-  while ( r.squaredNorm() > tol2 && i<maxIters )
-  {
-    Scalar rho_old = rho;
-
-    rho = r0.dot(r);
-    if (abs(rho) < eps2*r0_sqnorm)
-    {
-      // The new residual vector became too orthogonal to the arbitrarily chosen direction r0
-      // Let's restart with a new r0:
-      r  = rhs - mat * x;
-      r0 = r;
-      rho = r0_sqnorm = r.squaredNorm();
-      if(restarts++ == 0)
-        i = 0;
-    }
-    Scalar beta = (rho/rho_old) * (alpha / w);
-    p = r + beta * (p - w * v);
-    
-    y = precond.solve(p);
-    
-    v.noalias() = mat * y;
-
-    alpha = rho / r0.dot(v);
-    s = r - alpha * v;
-
-    z = precond.solve(s);
-    t.noalias() = mat * z;
-
-    RealScalar tmp = t.squaredNorm();
-    if(tmp>RealScalar(0))
-      w = t.dot(s) / tmp;
-    else
-      w = Scalar(0);
-    x += alpha * y + w * z;
-    r = s - w * t;
-    ++i;
-  }
-  tol_error = sqrt(r.squaredNorm()/rhs_sqnorm);
-  iters = i;
-  return true; 
-}
-
-}
-
-template< typename _MatrixType,
-          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
-class BiCGSTAB;
-
-namespace internal {
-
-template< typename _MatrixType, typename _Preconditioner>
-struct traits<BiCGSTAB<_MatrixType,_Preconditioner> >
-{
-  typedef _MatrixType MatrixType;
-  typedef _Preconditioner Preconditioner;
-};
-
-}
-
-/** \ingroup IterativeLinearSolvers_Module
-  * \brief A bi conjugate gradient stabilized solver for sparse square problems
-  *
-  * This class allows to solve for A.x = b sparse linear problems using a bi conjugate gradient
-  * stabilized algorithm. The vectors x and b can be either dense or sparse.
-  *
-  * \tparam _MatrixType the type of the sparse matrix A, can be a dense or a sparse matrix.
-  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
-  *
-  * \implsparsesolverconcept
-  *
-  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
-  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
-  * and NumTraits<Scalar>::epsilon() for the tolerance.
-  * 
-  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
-  * 
-  * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format.
-  * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
-  * See \ref TopicMultiThreading for details.
-  * 
-  * This class can be used as the direct solver classes. Here is a typical usage example:
-  * \include BiCGSTAB_simple.cpp
-  * 
-  * By default the iterations start with x=0 as an initial guess of the solution.
-  * One can control the start using the solveWithGuess() method.
-  * 
-  * BiCGSTAB can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
-  *
-  * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
-  */
-template< typename _MatrixType, typename _Preconditioner>
-class BiCGSTAB : public IterativeSolverBase<BiCGSTAB<_MatrixType,_Preconditioner> >
-{
-  typedef IterativeSolverBase<BiCGSTAB> Base;
-  using Base::matrix;
-  using Base::m_error;
-  using Base::m_iterations;
-  using Base::m_info;
-  using Base::m_isInitialized;
-public:
-  typedef _MatrixType MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef _Preconditioner Preconditioner;
-
-public:
-
-  /** Default constructor. */
-  BiCGSTAB() : Base() {}
-
-  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
-    * 
-    * This constructor is a shortcut for the default constructor followed
-    * by a call to compute().
-    * 
-    * \warning this class stores a reference to the matrix A as well as some
-    * precomputed values that depend on it. Therefore, if \a A is changed
-    * this class becomes invalid. Call compute() to update it with the new
-    * matrix A, or modify a copy of A.
-    */
-  template<typename MatrixDerived>
-  explicit BiCGSTAB(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
-
-  ~BiCGSTAB() {}
-
-  /** \internal */
-  template<typename Rhs,typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
-  {    
-    m_iterations = Base::maxIterations();
-    m_error = Base::m_tolerance;
-    
-    bool ret = internal::bicgstab(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error);
-
-    m_info = (!ret) ? NumericalIssue
-           : m_error <= Base::m_tolerance ? Success
-           : NoConvergence;
-  }
-
-protected:
-
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_BICGSTAB_H

xtgeo/include/eigen3/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h

@@ -1,229 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011-2014 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_CONJUGATE_GRADIENT_H
-#define EIGEN_CONJUGATE_GRADIENT_H
-
-namespace Eigen { 
-
-namespace internal {
-
-/** \internal Low-level conjugate gradient algorithm
-  * \param mat The matrix A
-  * \param rhs The right hand side vector b
-  * \param x On input and initial solution, on output the computed solution.
-  * \param precond A preconditioner being able to efficiently solve for an
-  *                approximation of Ax=b (regardless of b)
-  * \param iters On input the max number of iteration, on output the number of performed iterations.
-  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
-  */
-template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-EIGEN_DONT_INLINE
-void conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
-                        const Preconditioner& precond, Index& iters,
-                        typename Dest::RealScalar& tol_error)
-{
-  using std::sqrt;
-  using std::abs;
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar,Dynamic,1> VectorType;
-  
-  RealScalar tol = tol_error;
-  Index maxIters = iters;
-  
-  Index n = mat.cols();
-
-  VectorType residual = rhs - mat * x; //initial residual
-
-  RealScalar rhsNorm2 = rhs.squaredNorm();
-  if(rhsNorm2 == 0) 
-  {
-    x.setZero();
-    iters = 0;
-    tol_error = 0;
-    return;
-  }
-  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
-  RealScalar threshold = numext::maxi(RealScalar(tol*tol*rhsNorm2),considerAsZero);
-  RealScalar residualNorm2 = residual.squaredNorm();
-  if (residualNorm2 < threshold)
-  {
-    iters = 0;
-    tol_error = sqrt(residualNorm2 / rhsNorm2);
-    return;
-  }
-
-  VectorType p(n);
-  p = precond.solve(residual);      // initial search direction
-
-  VectorType z(n), tmp(n);
-  RealScalar absNew = numext::real(residual.dot(p));  // the square of the absolute value of r scaled by invM
-  Index i = 0;
-  while(i < maxIters)
-  {
-    tmp.noalias() = mat * p;                    // the bottleneck of the algorithm
-
-    Scalar alpha = absNew / p.dot(tmp);         // the amount we travel on dir
-    x += alpha * p;                             // update solution
-    residual -= alpha * tmp;                    // update residual
-    
-    residualNorm2 = residual.squaredNorm();
-    if(residualNorm2 < threshold)
-      break;
-    
-    z = precond.solve(residual);                // approximately solve for "A z = residual"
-
-    RealScalar absOld = absNew;
-    absNew = numext::real(residual.dot(z));     // update the absolute value of r
-    RealScalar beta = absNew / absOld;          // calculate the Gram-Schmidt value used to create the new search direction
-    p = z + beta * p;                           // update search direction
-    i++;
-  }
-  tol_error = sqrt(residualNorm2 / rhsNorm2);
-  iters = i;
-}
-
-}
-
-template< typename _MatrixType, int _UpLo=Lower,
-          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
-class ConjugateGradient;
-
-namespace internal {
-
-template< typename _MatrixType, int _UpLo, typename _Preconditioner>
-struct traits<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
-{
-  typedef _MatrixType MatrixType;
-  typedef _Preconditioner Preconditioner;
-};
-
-}
-
-/** \ingroup IterativeLinearSolvers_Module
-  * \brief A conjugate gradient solver for sparse (or dense) self-adjoint problems
-  *
-  * This class allows to solve for A.x = b linear problems using an iterative conjugate gradient algorithm.
-  * The matrix A must be selfadjoint. The matrix A and the vectors x and b can be either dense or sparse.
-  *
-  * \tparam _MatrixType the type of the matrix A, can be a dense or a sparse matrix.
-  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower,
-  *               \c Upper, or \c Lower|Upper in which the full matrix entries will be considered.
-  *               Default is \c Lower, best performance is \c Lower|Upper.
-  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
-  *
-  * \implsparsesolverconcept
-  *
-  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
-  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
-  * and NumTraits<Scalar>::epsilon() for the tolerance.
-  * 
-  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
-  * 
-  * \b Performance: Even though the default value of \c _UpLo is \c Lower, significantly higher performance is
-  * achieved when using a complete matrix and \b Lower|Upper as the \a _UpLo template parameter. Moreover, in this
-  * case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
-  * See \ref TopicMultiThreading for details.
-  * 
-  * This class can be used as the direct solver classes. Here is a typical usage example:
-    \code
-    int n = 10000;
-    VectorXd x(n), b(n);
-    SparseMatrix<double> A(n,n);
-    // fill A and b
-    ConjugateGradient<SparseMatrix<double>, Lower|Upper> cg;
-    cg.compute(A);
-    x = cg.solve(b);
-    std::cout << "#iterations:     " << cg.iterations() << std::endl;
-    std::cout << "estimated error: " << cg.error()      << std::endl;
-    // update b, and solve again
-    x = cg.solve(b);
-    \endcode
-  * 
-  * By default the iterations start with x=0 as an initial guess of the solution.
-  * One can control the start using the solveWithGuess() method.
-  * 
-  * ConjugateGradient can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
-  *
-  * \sa class LeastSquaresConjugateGradient, class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
-  */
-template< typename _MatrixType, int _UpLo, typename _Preconditioner>
-class ConjugateGradient : public IterativeSolverBase<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
-{
-  typedef IterativeSolverBase<ConjugateGradient> Base;
-  using Base::matrix;
-  using Base::m_error;
-  using Base::m_iterations;
-  using Base::m_info;
-  using Base::m_isInitialized;
-public:
-  typedef _MatrixType MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef _Preconditioner Preconditioner;
-
-  enum {
-    UpLo = _UpLo
-  };
-
-public:
-
-  /** Default constructor. */
-  ConjugateGradient() : Base() {}
-
-  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
-    * 
-    * This constructor is a shortcut for the default constructor followed
-    * by a call to compute().
-    * 
-    * \warning this class stores a reference to the matrix A as well as some
-    * precomputed values that depend on it. Therefore, if \a A is changed
-    * this class becomes invalid. Call compute() to update it with the new
-    * matrix A, or modify a copy of A.
-    */
-  template<typename MatrixDerived>
-  explicit ConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
-
-  ~ConjugateGradient() {}
-
-  /** \internal */
-  template<typename Rhs,typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
-  {
-    typedef typename Base::MatrixWrapper MatrixWrapper;
-    typedef typename Base::ActualMatrixType ActualMatrixType;
-    enum {
-      TransposeInput  =   (!MatrixWrapper::MatrixFree)
-                      &&  (UpLo==(Lower|Upper))
-                      &&  (!MatrixType::IsRowMajor)
-                      &&  (!NumTraits<Scalar>::IsComplex)
-    };
-    typedef typename internal::conditional<TransposeInput,Transpose<const ActualMatrixType>, ActualMatrixType const&>::type RowMajorWrapper;
-    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
-    typedef typename internal::conditional<UpLo==(Lower|Upper),
-                                           RowMajorWrapper,
-                                           typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type
-                                          >::type SelfAdjointWrapper;
-
-    m_iterations = Base::maxIterations();
-    m_error = Base::m_tolerance;
-
-    RowMajorWrapper row_mat(matrix());
-    internal::conjugate_gradient(SelfAdjointWrapper(row_mat), b, x, Base::m_preconditioner, m_iterations, m_error);
-    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
-  }
-
-protected:
-
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_CONJUGATE_GRADIENT_H