casadi 3.6.4__cp39-none-macosx_11_0_arm64.whl → 3.6.6__cp39-none-macosx_11_0_arm64.whl

casadi/include/include/eigen3/unsupported/Eigen/src/IterativeSolvers/IDRS.h

@@ -1,436 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl>
-// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl>
-// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl>
-//
-// 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_IDRS_H
-#define EIGEN_IDRS_H
-
-namespace Eigen
-{
-
-	namespace internal
-	{
-		/**     \internal Low-level Induced Dimension Reduction algoritm
-		        \param A The matrix A
-		        \param b 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 iter On input the max number of iteration, on output the number of performed iterations.
-		        \param relres On input the tolerance error, on output an estimation of the relative error.
-		        \param S On input Number of the dimension of the shadow space.
-				\param smoothing switches residual smoothing on.
-				\param angle small omega lead to faster convergence at the expense of numerical stability
-				\param replacement switches on a residual replacement strategy to increase accuracy of residual at the expense of more Mat*vec products
-		        \return false in the case of numerical issue, for example a break down of IDRS.
-		*/
-		template<typename Vector, typename RealScalar>
-		typename Vector::Scalar omega(const Vector& t, const Vector& s, RealScalar angle)
-		{
-			using numext::abs;
-			typedef typename Vector::Scalar Scalar;
-			const RealScalar ns = s.norm();
-			const RealScalar nt = t.norm();
-			const Scalar ts = t.dot(s);
-			const RealScalar rho = abs(ts / (nt * ns));
-
-			if (rho < angle) {
-				if (ts == Scalar(0)) {
-					return Scalar(0);
-				}
-				// Original relation for om is given by
-				// om = om * angle / rho;
-				// To alleviate potential (near) division by zero this can be rewritten as
-				// om = angle * (ns / nt) * (ts / abs(ts)) = angle * (ns / nt) * sgn(ts)
-  				return angle * (ns / nt) * (ts / abs(ts));
-			}
-			return ts / (nt * nt);
-		}
-
-		template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-		bool idrs(const MatrixType& A, const Rhs& b, Dest& x, const Preconditioner& precond,
-			Index& iter,
-			typename Dest::RealScalar& relres, Index S, bool smoothing, typename Dest::RealScalar angle, bool replacement)
-		{
-			typedef typename Dest::RealScalar RealScalar;
-			typedef typename Dest::Scalar Scalar;
-			typedef Matrix<Scalar, Dynamic, 1> VectorType;
-			typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType;
-			const Index N = b.size();
-			S = S < x.rows() ? S : x.rows();
-			const RealScalar tol = relres;
-			const Index maxit = iter;
-
-			Index replacements = 0;
-			bool trueres = false;
-
-			FullPivLU<DenseMatrixType> lu_solver;
-
-			DenseMatrixType P;
-			{
-				HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S));
-			    P = (qr.householderQ() * DenseMatrixType::Identity(N, S));
-			}
-
-			const RealScalar normb = b.norm();
-
-			if (internal::isApprox(normb, RealScalar(0)))
-			{
-				//Solution is the zero vector
-				x.setZero();
-				iter = 0;
-				relres = 0;
-				return true;
-			}
-			 // from http://homepage.tudelft.nl/1w5b5/IDRS/manual.pdf
-			 // A peak in the residual is considered dangerously high if‖ri‖/‖b‖> C(tol/epsilon).
-			 // With epsilon the
-             // relative machine precision. The factor tol/epsilon corresponds to the size of a
-             // finite precision number that is so large that the absolute round-off error in
-             // this number, when propagated through the process, makes it impossible to
-             // achieve the required accuracy.The factor C accounts for the accumulation of
-             // round-off errors. This parameter has beenset to 10−3.
-			 // mp is epsilon/C
-			 // 10^3 * eps is very conservative, so normally no residual replacements will take place. 
-			 // It only happens if things go very wrong. Too many restarts may ruin the convergence.
-			const RealScalar mp = RealScalar(1e3) * NumTraits<Scalar>::epsilon();
-
-
-
-			//Compute initial residual
-			const RealScalar tolb = tol * normb; //Relative tolerance
-			VectorType r = b - A * x;
-
-			VectorType x_s, r_s;
-
-			if (smoothing)
-			{
-				x_s = x;
-				r_s = r;
-			}
-
-			RealScalar normr = r.norm();
-
-			if (normr <= tolb)
-			{
-				//Initial guess is a good enough solution
-				iter = 0;
-				relres = normr / normb;
-				return true;
-			}
-
-			DenseMatrixType G = DenseMatrixType::Zero(N, S);
-			DenseMatrixType U = DenseMatrixType::Zero(N, S);
-			DenseMatrixType M = DenseMatrixType::Identity(S, S);
-			VectorType t(N), v(N);
-			Scalar om = 1.;
-
-			//Main iteration loop, guild G-spaces:
-			iter = 0;
-
-			while (normr > tolb && iter < maxit)
-			{
-				//New right hand size for small system:
-				VectorType f = (r.adjoint() * P).adjoint();
-
-				for (Index k = 0; k < S; ++k)
-				{
-					//Solve small system and make v orthogonal to P:
-					//c = M(k:s,k:s)\f(k:s);
-					lu_solver.compute(M.block(k , k , S -k, S - k ));
-					VectorType c = lu_solver.solve(f.segment(k , S - k ));
-					//v = r - G(:,k:s)*c;
-					v = r - G.rightCols(S - k ) * c;
-					//Preconditioning
-					v = precond.solve(v);
-
-					//Compute new U(:,k) and G(:,k), G(:,k) is in space G_j
-					U.col(k) = U.rightCols(S - k ) * c + om * v;
-					G.col(k) = A * U.col(k );
-
-					//Bi-Orthogonalise the new basis vectors:
-					for (Index i = 0; i < k-1 ; ++i)
-					{
-						//alpha =  ( P(:,i)'*G(:,k) )/M(i,i);
-						Scalar alpha = P.col(i ).dot(G.col(k )) / M(i, i );
-						G.col(k ) = G.col(k ) - alpha * G.col(i );
-						U.col(k ) = U.col(k ) - alpha * U.col(i );
-					}
-
-					//New column of M = P'*G  (first k-1 entries are zero)
-					//M(k:s,k) = (G(:,k)'*P(:,k:s))';
-					M.block(k , k , S - k , 1) = (G.col(k ).adjoint() * P.rightCols(S - k )).adjoint();
-
-					if (internal::isApprox(M(k,k), Scalar(0)))
-					{
-						return false;
-					}
-
-					//Make r orthogonal to q_i, i = 0..k-1
-					Scalar beta = f(k ) / M(k , k );
-					r = r - beta * G.col(k );
-					x = x + beta * U.col(k );
-					normr = r.norm();
-
-					if (replacement && normr > tolb / mp)
-					{
-						trueres = true;
-					}
-
-					//Smoothing:
-					if (smoothing)
-					{
-						t = r_s - r;
-						//gamma is a Scalar, but the conversion is not allowed
-						Scalar gamma = t.dot(r_s) / t.norm();
-						r_s = r_s - gamma * t;
-						x_s = x_s - gamma * (x_s - x);
-						normr = r_s.norm();
-					}
-
-					if (normr < tolb || iter == maxit)
-					{
-						break;
-					}
-
-					//New f = P'*r (first k  components are zero)
-					if (k < S-1)
-					{
-						f.segment(k + 1, S - (k + 1) ) = f.segment(k + 1 , S - (k + 1)) - beta * M.block(k + 1 , k , S - (k + 1), 1);
-					}
-				}//end for
-
-				if (normr < tolb || iter == maxit)
-				{
-					break;
-				}
-
-				//Now we have sufficient vectors in G_j to compute residual in G_j+1
-				//Note: r is already perpendicular to P so v = r
-				//Preconditioning
-				v = r;
-				v = precond.solve(v);
-
-				//Matrix-vector multiplication:
-				t = A * v;
-
-				//Computation of a new omega
-				om = internal::omega(t, r, angle);
-
-				if (om == RealScalar(0.0))
-				{
-					return false;
-				}
-
-				r = r - om * t;
-				x = x + om * v;
-				normr = r.norm();
-
-				if (replacement && normr > tolb / mp)
-				{
-					trueres = true;
-				}
-
-				//Residual replacement?
-				if (trueres && normr < normb)
-				{
-					r = b - A * x;
-					trueres = false;
-					replacements++;
-				}
-
-				//Smoothing:
-				if (smoothing)
-				{
-					t = r_s - r;
-					Scalar gamma = t.dot(r_s) /t.norm();
-					r_s = r_s - gamma * t;
-					x_s = x_s - gamma * (x_s - x);
-					normr = r_s.norm();
-				}
-
-				iter++;
-
-			}//end while
-
-			if (smoothing)
-			{
-				x = x_s;
-			}
-			relres=normr/normb;
-			return true;
-		}
-
-	}  // namespace internal
-
-	template <typename _MatrixType, typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
-	class IDRS;
-
-	namespace internal
-	{
-
-		template <typename _MatrixType, typename _Preconditioner>
-		struct traits<Eigen::IDRS<_MatrixType, _Preconditioner> >
-		{
-			typedef _MatrixType MatrixType;
-			typedef _Preconditioner Preconditioner;
-		};
-
-	}  // namespace internal
-
-
-/** \ingroup IterativeLinearSolvers_Module
-  * \brief The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square problems.
-  *
-  * This class allows to solve for A.x = b sparse linear problems. The vectors x and b can be either dense or sparse.
-  * he Induced Dimension Reduction method, IDR(), is a robust and efficient short-recurrence Krylov subspace method for
-  * solving large nonsymmetric systems of linear equations.
-  *
-  * For indefinite systems IDR(S) outperforms both BiCGStab and BiCGStab(L). Additionally, IDR(S) can handle matrices
-  * with complex eigenvalues more efficiently than BiCGStab.
-  *
-  * Many problems that do not converge for BiCGSTAB converge for IDR(s) (for larger values of s). And if both methods 
-  * converge the convergence for IDR(s) is typically much faster for difficult systems (for example indefinite problems). 
-  *
-  * IDR(s) is a limited memory finite termination method. In exact arithmetic it converges in at most N+N/s iterations,
-  * with N the system size.  It uses a fixed number of 4+3s vector. In comparison, BiCGSTAB terminates in 2N iterations 
-  * and uses 7 vectors. GMRES terminates in at most N iterations, and uses I+3 vectors, with I the number of iterations. 
-  * Restarting GMRES limits the memory consumption, but destroys the finite termination property.
-  *
-  * \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.
-  *
-  * By default the iterations start with x=0 as an initial guess of the solution.
-  * One can control the start using the solveWithGuess() method.
-  *
-  * IDR(s) 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 IDRS : public IterativeSolverBase<IDRS<_MatrixType, _Preconditioner> >
-	{
-
-		public:
-			typedef _MatrixType MatrixType;
-			typedef typename MatrixType::Scalar Scalar;
-			typedef typename MatrixType::RealScalar RealScalar;
-			typedef _Preconditioner Preconditioner;
-
-		private:
-			typedef IterativeSolverBase<IDRS> Base;
-			using Base::m_error;
-			using Base::m_info;
-			using Base::m_isInitialized;
-			using Base::m_iterations;
-			using Base::matrix;
-			Index m_S;
-			bool m_smoothing;
-			RealScalar m_angle;
-			bool m_residual;
-
-		public:
-			/** Default constructor. */
-			IDRS(): m_S(4), m_smoothing(false), m_angle(RealScalar(0.7)), m_residual(false) {}
-
-			/**     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 IDRS(const EigenBase<MatrixDerived>& A) : Base(A.derived()), m_S(4), m_smoothing(false),
-															   m_angle(RealScalar(0.7)), m_residual(false) {}
-
-
-			/** \internal */
-			/**     Loops over the number of columns of b and does the following:
-			                1. sets the tolerence and maxIterations
-			                2. Calls the function that has the core solver routine
-			*/
-			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::idrs(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_S,m_smoothing,m_angle,m_residual);
-
-				m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
-			}
-
-			/** Sets the parameter S, indicating the dimension of the shadow space. Default is 4*/
-			void setS(Index S)
-			{
-				if (S < 1)
-				{
-					S = 4;
-				}
-
-				m_S = S;
-			}
-
-			/** Switches off and on smoothing.
-			Residual smoothing results in monotonically decreasing residual norms at
-			the expense of two extra vectors of storage and a few extra vector
-			operations. Although monotonic decrease of the residual norms is a
-			desirable property, the rate of convergence of the unsmoothed process and
-			the smoothed process is basically the same. Default is off */
-			void setSmoothing(bool smoothing)
-			{
-				m_smoothing=smoothing;
-			}
-
-			/** The angle must be a real scalar. In IDR(s), a value for the
-			iteration parameter omega must be chosen in every s+1th step. The most
-			natural choice is to select a value to minimize the norm of the next residual.
-			This corresponds to the parameter omega = 0. In practice, this may lead to
-			values of omega that are so small that the other iteration parameters
-			cannot be computed with sufficient accuracy. In such cases it is better to
-			increase the value of omega sufficiently such that a compromise is reached
-			between accurate computations and reduction of the residual norm. The
-			parameter angle =0.7 (”maintaining the convergence strategy”)
-			results in such a compromise. */
-			void setAngle(RealScalar angle)
-			{
-				m_angle=angle;
-			}
-
-			/** The parameter replace is a logical that determines whether a
-			residual replacement strategy is employed to increase the accuracy of the
-			solution. */
-			void setResidualUpdate(bool update)
-			{
-				m_residual=update;
-			}
-
-	};
-
-}  // namespace Eigen
-
-#endif /* EIGEN_IDRS_H */

casadi/include/include/eigen3/unsupported/Eigen/src/IterativeSolvers/IncompleteLU.h

@@ -1,90 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 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_INCOMPLETE_LU_H
-#define EIGEN_INCOMPLETE_LU_H
-
-namespace Eigen { 
-
-template <typename _Scalar>
-class IncompleteLU : public SparseSolverBase<IncompleteLU<_Scalar> >
-{
-  protected:
-    typedef SparseSolverBase<IncompleteLU<_Scalar> > Base;
-    using Base::m_isInitialized;
-    
-    typedef _Scalar Scalar;
-    typedef Matrix<Scalar,Dynamic,1> Vector;
-    typedef typename Vector::Index Index;
-    typedef SparseMatrix<Scalar,RowMajor> FactorType;
-
-  public:
-    typedef Matrix<Scalar,Dynamic,Dynamic> MatrixType;
-
-    IncompleteLU() {}
-
-    template<typename MatrixType>
-    IncompleteLU(const MatrixType& mat)
-    {
-      compute(mat);
-    }
-
-    Index rows() const { return m_lu.rows(); }
-    Index cols() const { return m_lu.cols(); }
-
-    template<typename MatrixType>
-    IncompleteLU& compute(const MatrixType& mat)
-    {
-      m_lu = mat;
-      int size = mat.cols();
-      Vector diag(size);
-      for(int i=0; i<size; ++i)
-      {
-        typename FactorType::InnerIterator k_it(m_lu,i);
-        for(; k_it && k_it.index()<i; ++k_it)
-        {
-          int k = k_it.index();
-          k_it.valueRef() /= diag(k);
-
-          typename FactorType::InnerIterator j_it(k_it);
-          typename FactorType::InnerIterator kj_it(m_lu, k);
-          while(kj_it && kj_it.index()<=k) ++kj_it;
-          for(++j_it; j_it; )
-          {
-            if(kj_it.index()==j_it.index())
-            {
-              j_it.valueRef() -= k_it.value() * kj_it.value();
-              ++j_it;
-              ++kj_it;
-            }
-            else if(kj_it.index()<j_it.index()) ++kj_it;
-            else                                ++j_it;
-          }
-        }
-        if(k_it && k_it.index()==i) diag(i) = k_it.value();
-        else                        diag(i) = 1;
-      }
-      m_isInitialized = true;
-      return *this;
-    }
-
-    template<typename Rhs, typename Dest>
-    void _solve_impl(const Rhs& b, Dest& x) const
-    {
-      x = m_lu.template triangularView<UnitLower>().solve(b);
-      x = m_lu.template triangularView<Upper>().solve(x);
-    }
-
-  protected:
-    FactorType m_lu;
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_INCOMPLETE_LU_H

casadi/include/include/eigen3/unsupported/Eigen/src/IterativeSolvers/IterationController.h

@@ -1,154 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
-
-/* NOTE The class IterationController has been adapted from the iteration
- *      class of the GMM++ and ITL libraries.
- */
-
-//=======================================================================
-// Copyright (C) 1997-2001
-// Authors: Andrew Lumsdaine <lums@osl.iu.edu> 
-//          Lie-Quan Lee     <llee@osl.iu.edu>
-//
-// This file is part of the Iterative Template Library
-//
-// You should have received a copy of the License Agreement for the
-// Iterative Template Library along with the software;  see the
-// file LICENSE.  
-//
-// Permission to modify the code and to distribute modified code is
-// granted, provided the text of this NOTICE is retained, a notice that
-// the code was modified is included with the above COPYRIGHT NOTICE and
-// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE
-// file is distributed with the modified code.
-//
-// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.
-// By way of example, but not limitation, Licensor MAKES NO
-// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY
-// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS
-// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS
-// OR OTHER RIGHTS.
-//=======================================================================
-
-//========================================================================
-//
-// Copyright (C) 2002-2007 Yves Renard
-//
-// This file is a part of GETFEM++
-//
-// Getfem++ is free software; you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as
-// published by the Free Software Foundation; version 2.1 of the License.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Lesser General Public License for more details.
-// You should have received a copy of the GNU Lesser General Public
-// License along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301,
-// USA.
-//
-//========================================================================
-
-#include "../../../../Eigen/src/Core/util/NonMPL2.h"
-
-#ifndef EIGEN_ITERATION_CONTROLLER_H
-#define EIGEN_ITERATION_CONTROLLER_H
-
-namespace Eigen { 
-
-/** \ingroup IterativeLinearSolvers_Module
-  * \class IterationController
-  *
-  * \brief Controls the iterations of the iterative solvers
-  *
-  * This class has been adapted from the iteration class of GMM++ and ITL libraries.
-  *
-  */
-class IterationController
-{
-  protected :
-    double m_rhsn;        ///< Right hand side norm
-    size_t m_maxiter;     ///< Max. number of iterations
-    int m_noise;          ///< if noise > 0 iterations are printed
-    double m_resmax;      ///< maximum residual
-    double m_resminreach, m_resadd;
-    size_t m_nit;         ///< iteration number
-    double m_res;         ///< last computed residual
-    bool m_written;
-    void (*m_callback)(const IterationController&);
-  public :
-
-    void init()
-    {
-      m_nit = 0; m_res = 0.0; m_written = false;
-      m_resminreach = 1E50; m_resadd = 0.0;
-      m_callback = 0;
-    }
-
-    IterationController(double r = 1.0E-8, int noi = 0, size_t mit = size_t(-1))
-      : m_rhsn(1.0), m_maxiter(mit), m_noise(noi), m_resmax(r) { init(); }
-
-    void operator ++(int) { m_nit++; m_written = false; m_resadd += m_res; }
-    void operator ++() { (*this)++; }
-
-    bool first() { return m_nit == 0; }
-
-    /* get/set the "noisyness" (verbosity) of the solvers */
-    int noiseLevel() const { return m_noise; }
-    void setNoiseLevel(int n) { m_noise = n; }
-    void reduceNoiseLevel() { if (m_noise > 0) m_noise--; }
-
-    double maxResidual() const { return m_resmax; }
-    void setMaxResidual(double r) { m_resmax = r; }
-
-    double residual() const { return m_res; }
-
-    /* change the user-definable callback, called after each iteration */
-    void setCallback(void (*t)(const IterationController&))
-    {
-      m_callback = t;
-    }
-
-    size_t iteration() const { return m_nit; }
-    void setIteration(size_t i) { m_nit = i; }
-
-    size_t maxIterarions() const { return m_maxiter; }
-    void setMaxIterations(size_t i) { m_maxiter = i; }
-
-    double rhsNorm() const { return m_rhsn; }
-    void setRhsNorm(double r) { m_rhsn = r; }
-
-    bool converged() const { return m_res <= m_rhsn * m_resmax; }
-    bool converged(double nr)
-    {
-      using std::abs;
-      m_res = abs(nr); 
-      m_resminreach = (std::min)(m_resminreach, m_res);
-      return converged();
-    }
-    template<typename VectorType> bool converged(const VectorType &v)
-    { return converged(v.squaredNorm()); }
-
-    bool finished(double nr)
-    {
-      if (m_callback) m_callback(*this);
-      if (m_noise > 0 && !m_written)
-      {
-        converged(nr);
-        m_written = true;
-      }
-      return (m_nit >= m_maxiter || converged(nr));
-    }
-    template <typename VectorType>
-    bool finished(const MatrixBase<VectorType> &v)
-    { return finished(double(v.squaredNorm())); }
-
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_ITERATION_CONTROLLER_H