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

xtgeo/include/eigen3/Eigen/src/Core/SolveTriangular.h

@@ -1,235 +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>
-//
-// 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_SOLVETRIANGULAR_H
-#define EIGEN_SOLVETRIANGULAR_H
-
-namespace Eigen {
-
-namespace internal {
-
-// Forward declarations:
-// The following two routines are implemented in the products/TriangularSolver*.h files
-template<typename LhsScalar, typename RhsScalar, typename Index, int Side, int Mode, bool Conjugate, int StorageOrder>
-struct triangular_solve_vector;
-
-template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherStorageOrder, int OtherInnerStride>
-struct triangular_solve_matrix;
-
-// small helper struct extracting some traits on the underlying solver operation
-template<typename Lhs, typename Rhs, int Side>
-class trsolve_traits
-{
-  private:
-    enum {
-      RhsIsVectorAtCompileTime = (Side==OnTheLeft ? Rhs::ColsAtCompileTime : Rhs::RowsAtCompileTime)==1
-    };
-  public:
-    enum {
-      Unrolling   = (RhsIsVectorAtCompileTime && Rhs::SizeAtCompileTime != Dynamic && Rhs::SizeAtCompileTime <= 8)
-                  ? CompleteUnrolling : NoUnrolling,
-      RhsVectors  = RhsIsVectorAtCompileTime ? 1 : Dynamic
-    };
-};
-
-template<typename Lhs, typename Rhs,
-  int Side, // can be OnTheLeft/OnTheRight
-  int Mode, // can be Upper/Lower | UnitDiag
-  int Unrolling = trsolve_traits<Lhs,Rhs,Side>::Unrolling,
-  int RhsVectors = trsolve_traits<Lhs,Rhs,Side>::RhsVectors
-  >
-struct triangular_solver_selector;
-
-template<typename Lhs, typename Rhs, int Side, int Mode>
-struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,1>
-{
-  typedef typename Lhs::Scalar LhsScalar;
-  typedef typename Rhs::Scalar RhsScalar;
-  typedef blas_traits<Lhs> LhsProductTraits;
-  typedef typename LhsProductTraits::ExtractType ActualLhsType;
-  typedef Map<Matrix<RhsScalar,Dynamic,1>, Aligned> MappedRhs;
-  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
-  {
-    ActualLhsType actualLhs = LhsProductTraits::extract(lhs);
-
-    // FIXME find a way to allow an inner stride if packet_traits<Scalar>::size==1
-
-    bool useRhsDirectly = Rhs::InnerStrideAtCompileTime==1 || rhs.innerStride()==1;
-
-    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhs,rhs.size(),
-                                                  (useRhsDirectly ? rhs.data() : 0));
-
-    if(!useRhsDirectly)
-      MappedRhs(actualRhs,rhs.size()) = rhs;
-
-    triangular_solve_vector<LhsScalar, RhsScalar, Index, Side, Mode, LhsProductTraits::NeedToConjugate,
-                            (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor>
-      ::run(actualLhs.cols(), actualLhs.data(), actualLhs.outerStride(), actualRhs);
-
-    if(!useRhsDirectly)
-      rhs = MappedRhs(actualRhs, rhs.size());
-  }
-};
-
-// the rhs is a matrix
-template<typename Lhs, typename Rhs, int Side, int Mode>
-struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,Dynamic>
-{
-  typedef typename Rhs::Scalar Scalar;
-  typedef blas_traits<Lhs> LhsProductTraits;
-  typedef typename LhsProductTraits::DirectLinearAccessType ActualLhsType;
-
-  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
-  {
-    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
-
-    const Index size = lhs.rows();
-    const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
-
-    typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
-              Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;
-
-    BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);
-
-    triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
-                               (Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
-      ::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
-  }
-};
-
-/***************************************************************************
-* meta-unrolling implementation
-***************************************************************************/
-
-template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size,
-         bool Stop = LoopIndex==Size>
-struct triangular_solver_unroller;
-
-template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
-struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,false> {
-  enum {
-    IsLower = ((Mode&Lower)==Lower),
-    DiagIndex  = IsLower ? LoopIndex : Size - LoopIndex - 1,
-    StartIndex = IsLower ? 0         : DiagIndex+1
-  };
-  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
-  {
-    if (LoopIndex>0)
-      rhs.coeffRef(DiagIndex) -= lhs.row(DiagIndex).template segment<LoopIndex>(StartIndex).transpose()
-                                .cwiseProduct(rhs.template segment<LoopIndex>(StartIndex)).sum();
-
-    if(!(Mode & UnitDiag))
-      rhs.coeffRef(DiagIndex) /= lhs.coeff(DiagIndex,DiagIndex);
-
-    triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex+1,Size>::run(lhs,rhs);
-  }
-};
-
-template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
-struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,true> {
-  static EIGEN_DEVICE_FUNC void run(const Lhs&, Rhs&) {}
-};
-
-template<typename Lhs, typename Rhs, int Mode>
-struct triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,CompleteUnrolling,1> {
-  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
-  { triangular_solver_unroller<Lhs,Rhs,Mode,0,Rhs::SizeAtCompileTime>::run(lhs,rhs); }
-};
-
-template<typename Lhs, typename Rhs, int Mode>
-struct triangular_solver_selector<Lhs,Rhs,OnTheRight,Mode,CompleteUnrolling,1> {
-  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
-  {
-    Transpose<const Lhs> trLhs(lhs);
-    Transpose<Rhs> trRhs(rhs);
-
-    triangular_solver_unroller<Transpose<const Lhs>,Transpose<Rhs>,
-                              ((Mode&Upper)==Upper ? Lower : Upper) | (Mode&UnitDiag),
-                              0,Rhs::SizeAtCompileTime>::run(trLhs,trRhs);
-  }
-};
-
-} // end namespace internal
-
-/***************************************************************************
-* TriangularView methods
-***************************************************************************/
-
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-template<typename MatrixType, unsigned int Mode>
-template<int Side, typename OtherDerived>
-EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType,Mode,Dense>::solveInPlace(const MatrixBase<OtherDerived>& _other) const
-{
-  OtherDerived& other = _other.const_cast_derived();
-  eigen_assert( derived().cols() == derived().rows() && ((Side==OnTheLeft && derived().cols() == other.rows()) || (Side==OnTheRight && derived().cols() == other.cols())) );
-  eigen_assert((!(int(Mode) & int(ZeroDiag))) && bool(int(Mode) & (int(Upper) | int(Lower))));
-  // If solving for a 0x0 matrix, nothing to do, simply return.
-  if (derived().cols() == 0)
-    return;
-
-  enum { copy = (internal::traits<OtherDerived>::Flags & RowMajorBit)  && OtherDerived::IsVectorAtCompileTime && OtherDerived::SizeAtCompileTime!=1};
-  typedef typename internal::conditional<copy,
-    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
-  OtherCopy otherCopy(other);
-
-  internal::triangular_solver_selector<MatrixType, typename internal::remove_reference<OtherCopy>::type,
-    Side, Mode>::run(derived().nestedExpression(), otherCopy);
-
-  if (copy)
-    other = otherCopy;
-}
-
-template<typename Derived, unsigned int Mode>
-template<int Side, typename Other>
-const internal::triangular_solve_retval<Side,TriangularView<Derived,Mode>,Other>
-TriangularViewImpl<Derived,Mode,Dense>::solve(const MatrixBase<Other>& other) const
-{
-  return internal::triangular_solve_retval<Side,TriangularViewType,Other>(derived(), other.derived());
-}
-#endif
-
-namespace internal {
-
-
-template<int Side, typename TriangularType, typename Rhs>
-struct traits<triangular_solve_retval<Side, TriangularType, Rhs> >
-{
-  typedef typename internal::plain_matrix_type_column_major<Rhs>::type ReturnType;
-};
-
-template<int Side, typename TriangularType, typename Rhs> struct triangular_solve_retval
- : public ReturnByValue<triangular_solve_retval<Side, TriangularType, Rhs> >
-{
-  typedef typename remove_all<typename Rhs::Nested>::type RhsNestedCleaned;
-  typedef ReturnByValue<triangular_solve_retval> Base;
-
-  triangular_solve_retval(const TriangularType& tri, const Rhs& rhs)
-    : m_triangularMatrix(tri), m_rhs(rhs)
-  {}
-
-  inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_rhs.rows(); }
-  inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
-
-  template<typename Dest> inline void evalTo(Dest& dst) const
-  {
-    if(!is_same_dense(dst,m_rhs))
-      dst = m_rhs;
-    m_triangularMatrix.template solveInPlace<Side>(dst);
-  }
-
-  protected:
-    const TriangularType& m_triangularMatrix;
-    typename Rhs::Nested m_rhs;
-};
-
-} // namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_SOLVETRIANGULAR_H

xtgeo/include/eigen3/Eigen/src/Core/SolverBase.h

@@ -1,168 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 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_SOLVERBASE_H
-#define EIGEN_SOLVERBASE_H
-
-namespace Eigen {
-
-namespace internal {
-
-template<typename Derived>
-struct solve_assertion {
-    template<bool Transpose_, typename Rhs>
-    static void run(const Derived& solver, const Rhs& b) { solver.template _check_solve_assertion<Transpose_>(b); }
-};
-
-template<typename Derived>
-struct solve_assertion<Transpose<Derived> >
-{
-    typedef Transpose<Derived> type;
-
-    template<bool Transpose_, typename Rhs>
-    static void run(const type& transpose, const Rhs& b)
-    {
-        internal::solve_assertion<typename internal::remove_all<Derived>::type>::template run<true>(transpose.nestedExpression(), b);
-    }
-};
-
-template<typename Scalar, typename Derived>
-struct solve_assertion<CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived> > >
-{
-    typedef CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived> > type;
-
-    template<bool Transpose_, typename Rhs>
-    static void run(const type& adjoint, const Rhs& b)
-    {
-        internal::solve_assertion<typename internal::remove_all<Transpose<Derived> >::type>::template run<true>(adjoint.nestedExpression(), b);
-    }
-};
-} // end namespace internal
-
-/** \class SolverBase
-  * \brief A base class for matrix decomposition and solvers
-  *
-  * \tparam Derived the actual type of the decomposition/solver.
-  *
-  * Any matrix decomposition inheriting this base class provide the following API:
-  *
-  * \code
-  * MatrixType A, b, x;
-  * DecompositionType dec(A);
-  * x = dec.solve(b);             // solve A   * x = b
-  * x = dec.transpose().solve(b); // solve A^T * x = b
-  * x = dec.adjoint().solve(b);   // solve A'  * x = b
-  * \endcode
-  *
-  * \warning Currently, any other usage of transpose() and adjoint() are not supported and will produce compilation errors.
-  *
-  * \sa class PartialPivLU, class FullPivLU, class HouseholderQR, class ColPivHouseholderQR, class FullPivHouseholderQR, class CompleteOrthogonalDecomposition, class LLT, class LDLT, class SVDBase
-  */
-template<typename Derived>
-class SolverBase : public EigenBase<Derived>
-{
-  public:
-
-    typedef EigenBase<Derived> Base;
-    typedef typename internal::traits<Derived>::Scalar Scalar;
-    typedef Scalar CoeffReturnType;
-
-    template<typename Derived_>
-    friend struct internal::solve_assertion;
-
-    enum {
-      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
-      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
-      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
-                                                          internal::traits<Derived>::ColsAtCompileTime>::ret),
-      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
-      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
-      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
-                                                             internal::traits<Derived>::MaxColsAtCompileTime>::ret),
-      IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
-                           || internal::traits<Derived>::MaxColsAtCompileTime == 1,
-      NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0 : bool(IsVectorAtCompileTime) ? 1 : 2
-    };
-
-    /** Default constructor */
-    SolverBase()
-    {}
-
-    ~SolverBase()
-    {}
-
-    using Base::derived;
-
-    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
-      */
-    template<typename Rhs>
-    inline const Solve<Derived, Rhs>
-    solve(const MatrixBase<Rhs>& b) const
-    {
-      internal::solve_assertion<typename internal::remove_all<Derived>::type>::template run<false>(derived(), b);
-      return Solve<Derived, Rhs>(derived(), b.derived());
-    }
-
-    /** \internal the return type of transpose() */
-    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
-    /** \returns an expression of the transposed of the factored matrix.
-      *
-      * A typical usage is to solve for the transposed problem A^T x = b:
-      * \code x = dec.transpose().solve(b); \endcode
-      *
-      * \sa adjoint(), solve()
-      */
-    inline ConstTransposeReturnType transpose() const
-    {
-      return ConstTransposeReturnType(derived());
-    }
-
-    /** \internal the return type of adjoint() */
-    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
-                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
-                        ConstTransposeReturnType
-                     >::type AdjointReturnType;
-    /** \returns an expression of the adjoint of the factored matrix
-      *
-      * A typical usage is to solve for the adjoint problem A' x = b:
-      * \code x = dec.adjoint().solve(b); \endcode
-      *
-      * For real scalar types, this function is equivalent to transpose().
-      *
-      * \sa transpose(), solve()
-      */
-    inline AdjointReturnType adjoint() const
-    {
-      return AdjointReturnType(derived().transpose());
-    }
-
-  protected:
-
-    template<bool Transpose_, typename Rhs>
-    void _check_solve_assertion(const Rhs& b) const {
-        EIGEN_ONLY_USED_FOR_DEBUG(b);
-        eigen_assert(derived().m_isInitialized && "Solver is not initialized.");
-        eigen_assert((Transpose_?derived().cols():derived().rows())==b.rows() && "SolverBase::solve(): invalid number of rows of the right hand side matrix b");
-    }
-};
-
-namespace internal {
-
-template<typename Derived>
-struct generic_xpr_base<Derived, MatrixXpr, SolverStorage>
-{
-  typedef SolverBase<Derived> type;
-
-};
-
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_SOLVERBASE_H

xtgeo/include/eigen3/Eigen/src/Core/StableNorm.h

@@ -1,251 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 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_STABLENORM_H
-#define EIGEN_STABLENORM_H
-
-namespace Eigen { 
-
-namespace internal {
-
-template<typename ExpressionType, typename Scalar>
-inline void stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& scale, Scalar& invScale)
-{
-  Scalar maxCoeff = bl.cwiseAbs().maxCoeff();
-  
-  if(maxCoeff>scale)
-  {
-    ssq = ssq * numext::abs2(scale/maxCoeff);
-    Scalar tmp = Scalar(1)/maxCoeff;
-    if(tmp > NumTraits<Scalar>::highest())
-    {
-      invScale = NumTraits<Scalar>::highest();
-      scale = Scalar(1)/invScale;
-    }
-    else if(maxCoeff>NumTraits<Scalar>::highest()) // we got a INF
-    {
-      invScale = Scalar(1);
-      scale = maxCoeff;
-    }
-    else
-    {
-      scale = maxCoeff;
-      invScale = tmp;
-    }
-  }
-  else if(maxCoeff!=maxCoeff) // we got a NaN
-  {
-    scale = maxCoeff;
-  }
-  
-  // TODO if the maxCoeff is much much smaller than the current scale,
-  // then we can neglect this sub vector
-  if(scale>Scalar(0)) // if scale==0, then bl is 0 
-    ssq += (bl*invScale).squaredNorm();
-}
-
-template<typename VectorType, typename RealScalar>
-void stable_norm_impl_inner_step(const VectorType &vec, RealScalar& ssq, RealScalar& scale, RealScalar& invScale)
-{
-  typedef typename VectorType::Scalar Scalar;
-  const Index blockSize = 4096;
-  
-  typedef typename internal::nested_eval<VectorType,2>::type VectorTypeCopy;
-  typedef typename internal::remove_all<VectorTypeCopy>::type VectorTypeCopyClean;
-  const VectorTypeCopy copy(vec);
-  
-  enum {
-    CanAlign = (   (int(VectorTypeCopyClean::Flags)&DirectAccessBit)
-                || (int(internal::evaluator<VectorTypeCopyClean>::Alignment)>0) // FIXME Alignment)>0 might not be enough
-               ) && (blockSize*sizeof(Scalar)*2<EIGEN_STACK_ALLOCATION_LIMIT)
-                 && (EIGEN_MAX_STATIC_ALIGN_BYTES>0) // if we cannot allocate on the stack, then let's not bother about this optimization
-  };
-  typedef typename internal::conditional<CanAlign, Ref<const Matrix<Scalar,Dynamic,1,0,blockSize,1>, internal::evaluator<VectorTypeCopyClean>::Alignment>,
-                                                   typename VectorTypeCopyClean::ConstSegmentReturnType>::type SegmentWrapper;
-  Index n = vec.size();
-  
-  Index bi = internal::first_default_aligned(copy);
-  if (bi>0)
-    internal::stable_norm_kernel(copy.head(bi), ssq, scale, invScale);
-  for (; bi<n; bi+=blockSize)
-    internal::stable_norm_kernel(SegmentWrapper(copy.segment(bi,numext::mini(blockSize, n - bi))), ssq, scale, invScale);
-}
-
-template<typename VectorType>
-typename VectorType::RealScalar
-stable_norm_impl(const VectorType &vec, typename enable_if<VectorType::IsVectorAtCompileTime>::type* = 0 )
-{
-  using std::sqrt;
-  using std::abs;
-
-  Index n = vec.size();
-
-  if(n==1)
-    return abs(vec.coeff(0));
-
-  typedef typename VectorType::RealScalar RealScalar;
-  RealScalar scale(0);
-  RealScalar invScale(1);
-  RealScalar ssq(0); // sum of squares
-
-  stable_norm_impl_inner_step(vec, ssq, scale, invScale);
-  
-  return scale * sqrt(ssq);
-}
-
-template<typename MatrixType>
-typename MatrixType::RealScalar
-stable_norm_impl(const MatrixType &mat, typename enable_if<!MatrixType::IsVectorAtCompileTime>::type* = 0 )
-{
-  using std::sqrt;
-
-  typedef typename MatrixType::RealScalar RealScalar;
-  RealScalar scale(0);
-  RealScalar invScale(1);
-  RealScalar ssq(0); // sum of squares
-
-  for(Index j=0; j<mat.outerSize(); ++j)
-    stable_norm_impl_inner_step(mat.innerVector(j), ssq, scale, invScale);
-  return scale * sqrt(ssq);
-}
-
-template<typename Derived>
-inline typename NumTraits<typename traits<Derived>::Scalar>::Real
-blueNorm_impl(const EigenBase<Derived>& _vec)
-{
-  typedef typename Derived::RealScalar RealScalar;  
-  using std::pow;
-  using std::sqrt;
-  using std::abs;
-
-  // This program calculates the machine-dependent constants
-  // bl, b2, slm, s2m, relerr overfl
-  // from the "basic" machine-dependent numbers
-  // nbig, ibeta, it, iemin, iemax, rbig.
-  // The following define the basic machine-dependent constants.
-  // For portability, the PORT subprograms "ilmaeh" and "rlmach"
-  // are used. For any specific computer, each of the assignment
-  // statements can be replaced
-  static const int ibeta = std::numeric_limits<RealScalar>::radix;  // base for floating-point numbers
-  static const int it    = NumTraits<RealScalar>::digits();  // number of base-beta digits in mantissa
-  static const int iemin = NumTraits<RealScalar>::min_exponent();  // minimum exponent
-  static const int iemax = NumTraits<RealScalar>::max_exponent();  // maximum exponent
-  static const RealScalar rbig   = NumTraits<RealScalar>::highest();  // largest floating-point number
-  static const RealScalar b1     = RealScalar(pow(RealScalar(ibeta),RealScalar(-((1-iemin)/2))));  // lower boundary of midrange
-  static const RealScalar b2     = RealScalar(pow(RealScalar(ibeta),RealScalar((iemax + 1 - it)/2)));  // upper boundary of midrange
-  static const RealScalar s1m    = RealScalar(pow(RealScalar(ibeta),RealScalar((2-iemin)/2)));  // scaling factor for lower range
-  static const RealScalar s2m    = RealScalar(pow(RealScalar(ibeta),RealScalar(- ((iemax+it)/2))));  // scaling factor for upper range
-  static const RealScalar eps    = RealScalar(pow(double(ibeta), 1-it));
-  static const RealScalar relerr = sqrt(eps);  // tolerance for neglecting asml
-
-  const Derived& vec(_vec.derived());
-  Index n = vec.size();
-  RealScalar ab2 = b2 / RealScalar(n);
-  RealScalar asml = RealScalar(0);
-  RealScalar amed = RealScalar(0);
-  RealScalar abig = RealScalar(0);
-
-  for(Index j=0; j<vec.outerSize(); ++j)
-  {
-    for(typename Derived::InnerIterator iter(vec, j); iter; ++iter)
-    {
-      RealScalar ax = abs(iter.value());
-      if(ax > ab2)     abig += numext::abs2(ax*s2m);
-      else if(ax < b1) asml += numext::abs2(ax*s1m);
-      else             amed += numext::abs2(ax);
-    }
-  }
-  if(amed!=amed)
-    return amed;  // we got a NaN
-  if(abig > RealScalar(0))
-  {
-    abig = sqrt(abig);
-    if(abig > rbig) // overflow, or *this contains INF values
-      return abig;  // return INF
-    if(amed > RealScalar(0))
-    {
-      abig = abig/s2m;
-      amed = sqrt(amed);
-    }
-    else
-      return abig/s2m;
-  }
-  else if(asml > RealScalar(0))
-  {
-    if (amed > RealScalar(0))
-    {
-      abig = sqrt(amed);
-      amed = sqrt(asml) / s1m;
-    }
-    else
-      return sqrt(asml)/s1m;
-  }
-  else
-    return sqrt(amed);
-  asml = numext::mini(abig, amed);
-  abig = numext::maxi(abig, amed);
-  if(asml <= abig*relerr)
-    return abig;
-  else
-    return abig * sqrt(RealScalar(1) + numext::abs2(asml/abig));
-}
-
-} // end namespace internal
-
-/** \returns the \em l2 norm of \c *this avoiding underflow and overflow.
-  * This version use a blockwise two passes algorithm:
-  *  1 - find the absolute largest coefficient \c s
-  *  2 - compute \f$ s \Vert \frac{*this}{s} \Vert \f$ in a standard way
-  *
-  * For architecture/scalar types supporting vectorization, this version
-  * is faster than blueNorm(). Otherwise the blueNorm() is much faster.
-  *
-  * \sa norm(), blueNorm(), hypotNorm()
-  */
-template<typename Derived>
-inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
-MatrixBase<Derived>::stableNorm() const
-{
-  return internal::stable_norm_impl(derived());
-}
-
-/** \returns the \em l2 norm of \c *this using the Blue's algorithm.
-  * A Portable Fortran Program to Find the Euclidean Norm of a Vector,
-  * ACM TOMS, Vol 4, Issue 1, 1978.
-  *
-  * For architecture/scalar types without vectorization, this version
-  * is much faster than stableNorm(). Otherwise the stableNorm() is faster.
-  *
-  * \sa norm(), stableNorm(), hypotNorm()
-  */
-template<typename Derived>
-inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
-MatrixBase<Derived>::blueNorm() const
-{
-  return internal::blueNorm_impl(*this);
-}
-
-/** \returns the \em l2 norm of \c *this avoiding undeflow and overflow.
-  * This version use a concatenation of hypot() calls, and it is very slow.
-  *
-  * \sa norm(), stableNorm()
-  */
-template<typename Derived>
-inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
-MatrixBase<Derived>::hypotNorm() const
-{
-  if(size()==1)
-    return numext::abs(coeff(0,0));
-  else
-    return this->cwiseAbs().redux(internal::scalar_hypot_op<RealScalar>());
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_STABLENORM_H