Attachment #301 for bug #314

This bugzilla service is closed. All entries have been migrated to https://gitlab.com/libeigen/eigen

View | Details | Raw Unified | Return to bug 314
Collapse All | Expand All





template<int UpLo> struct ldlt_inplace;

template<> struct ldlt_inplace<Lower>
{
  template<typename MatrixType, typename TranspositionType, typename Workspace>
  static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, int* sign=0)
  {
    using std::abs;
    typedef typename MatrixType::Scalar Scalar;
    typedef typename MatrixType::RealScalar RealScalar;
    typedef typename MatrixType::Index Index;
    eigen_assert(mat.rows()==mat.cols());
    const Index size = mat.rows();

    if (size <= 1)
    {





namespace internal {

template<typename Scalar, int UpLo> struct llt_inplace;

template<typename MatrixType, typename VectorType>
static typename MatrixType::Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
{
  using std::sqrt;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  typedef typename MatrixType::Index Index;
  typedef typename MatrixType::ColXpr ColXpr;
  typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
  typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
  typedef Matrix<Scalar,Dynamic,1> TempVectorType;
  typedef typename TempVectorType::SegmentReturnType TempVecSegment;

}

template<typename Scalar> struct llt_inplace<Scalar, Lower>
{
  typedef typename NumTraits<Scalar>::Real RealScalar;
  template<typename MatrixType>
  static typename MatrixType::Index unblocked(MatrixType& mat)
  {
    using std::sqrt;
    typedef typename MatrixType::Index Index;
    
    eigen_assert(mat.rows()==mat.cols());
    const Index size = mat.rows();
    for(Index k = 0; k < size; ++k)
    {
      Index rs = size-k-1; // remaining size





  * Example: \include MatrixBase_isDiagonal.cpp
  * Output: \verbinclude MatrixBase_isDiagonal.out
  *
  * \sa asDiagonal()
  */
template<typename Derived>
bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const
{
  using std::abs;
  if(cols() != rows()) return false;
  RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);
  for(Index j = 0; j < cols(); ++j)
  {
    RealScalar absOnDiagonal = abs(coeff(j,j));
    if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;
  }
  for(Index j = 0; j < cols(); ++j)
    for(Index i = 0; i < j; ++i)
    {
      if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;
      if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;
    }




  * In both cases, it consists in the square root of the sum of the square of all the matrix entries.
  * For vectors, this is also equals to the square root of the dot product of \c *this with itself.
  *
  * \sa dot(), squaredNorm()
  */
template<typename Derived>
inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm() const
{
  using std::sqrt;
  return sqrt(squaredNorm());
}

/** \returns an expression of the quotient of *this by its own norm.
  *
  * \only_for_vectors
  *
  * \sa norm(), normalize()
  */




/** \internal
  * \brief Template functor to compute the absolute value of a scalar
  *
  * \sa class CwiseUnaryOp, Cwise::abs
  */
template<typename Scalar> struct scalar_abs_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
  typedef typename NumTraits<Scalar>::Real result_type;
  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { using std::abs; return abs(a); }
  template<typename Packet>
  EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
  { return internal::pabs(a); }
};
template<typename Scalar>
struct functor_traits<scalar_abs_op<Scalar> >
{
  enum {

/** \internal
  *
  * \brief Template functor to compute the exponential of a scalar
  *
  * \sa class CwiseUnaryOp, Cwise::exp()
  */
template<typename Scalar> struct scalar_exp_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
  inline const Scalar operator() (const Scalar& a) const { using std::exp; return exp(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
};
template<typename Scalar>
struct functor_traits<scalar_exp_op<Scalar> >
{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasExp }; };

/** \internal
  *
  * \brief Template functor to compute the logarithm of a scalar
  *
  * \sa class CwiseUnaryOp, Cwise::log()
  */
template<typename Scalar> struct scalar_log_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
  inline const Scalar operator() (const Scalar& a) const { using std::log; return log(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
};
template<typename Scalar>
struct functor_traits<scalar_log_op<Scalar> >
{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; };

/** \internal

{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAdd }; };

/** \internal
  * \brief Template functor to compute the square root of a scalar
  * \sa class CwiseUnaryOp, Cwise::sqrt()
  */
template<typename Scalar> struct scalar_sqrt_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
  inline const Scalar operator() (const Scalar& a) const { using std::sqrt; return sqrt(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
};
template<typename Scalar>
struct functor_traits<scalar_sqrt_op<Scalar> >
{ enum {
    Cost = 5 * NumTraits<Scalar>::MulCost,
    PacketAccess = packet_traits<Scalar>::HasSqrt

};

/** \internal
  * \brief Template functor to compute the cosine of a scalar
  * \sa class CwiseUnaryOp, ArrayBase::cos()
  */
template<typename Scalar> struct scalar_cos_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
  inline Scalar operator() (const Scalar& a) const { using std::cos; return cos(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
};
template<typename Scalar>
struct functor_traits<scalar_cos_op<Scalar> >
{
  enum {
    Cost = 5 * NumTraits<Scalar>::MulCost,

};

/** \internal
  * \brief Template functor to compute the sine of a scalar
  * \sa class CwiseUnaryOp, ArrayBase::sin()
  */
template<typename Scalar> struct scalar_sin_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
  inline const Scalar operator() (const Scalar& a) const { using std::sin; return sin(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
};
template<typename Scalar>
struct functor_traits<scalar_sin_op<Scalar> >
{
  enum {
    Cost = 5 * NumTraits<Scalar>::MulCost,



/** \internal
  * \brief Template functor to compute the tan of a scalar
  * \sa class CwiseUnaryOp, ArrayBase::tan()
  */
template<typename Scalar> struct scalar_tan_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
  inline const Scalar operator() (const Scalar& a) const { using std::tan; return tan(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
};
template<typename Scalar>
struct functor_traits<scalar_tan_op<Scalar> >
{
  enum {
    Cost = 5 * NumTraits<Scalar>::MulCost,

};

/** \internal
  * \brief Template functor to compute the arc cosine of a scalar
  * \sa class CwiseUnaryOp, ArrayBase::acos()
  */
template<typename Scalar> struct scalar_acos_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
  inline const Scalar operator() (const Scalar& a) const { using std::acos; return acos(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
};
template<typename Scalar>
struct functor_traits<scalar_acos_op<Scalar> >
{
  enum {
    Cost = 5 * NumTraits<Scalar>::MulCost,

};

/** \internal
  * \brief Template functor to compute the arc sine of a scalar
  * \sa class CwiseUnaryOp, ArrayBase::asin()
  */
template<typename Scalar> struct scalar_asin_op {
  EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
  inline const Scalar operator() (const Scalar& a) const { using std::asin; return asin(a); }
  typedef typename packet_traits<Scalar>::type Packet;
  inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
};
template<typename Scalar>
struct functor_traits<scalar_asin_op<Scalar> >
{
  enum {
    Cost = 5 * NumTraits<Scalar>::MulCost,




// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2010-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// 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_GLOBAL_FUNCTIONS_H
#define EIGEN_GLOBAL_FUNCTIONS_H

#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR) \
  template<typename Derived> \
  inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
  NAME(const Eigen::ArrayBase<Derived>& x) { \
    return x.derived(); \
  }

#define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \
  \

  { \
    static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) \
    { \
      return x.derived(); \
    } \
  };


namespace Eigen
{
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(real,scalar_real_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(imag,scalar_imag_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sin,scalar_sin_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cos,scalar_cos_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asin,scalar_asin_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos,scalar_acos_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tan,scalar_tan_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(exp,scalar_exp_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log,scalar_log_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs,scalar_abs_op)
  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sqrt,scalar_sqrt_op)
  
  template<typename Derived>
  inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar>, const Derived>
  pow(const Eigen::ArrayBase<Derived>& x, const typename Derived::Scalar& exponent) {
    return x.derived().pow(exponent);
  }

  template<typename Derived>
  inline const Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const Derived, const Derived>
  pow(const Eigen::ArrayBase<Derived>& x, const Eigen::ArrayBase<Derived>& exponents) 
  {
    return Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const Derived, const Derived>(
      x.derived(),
      exponents.derived()
    );
  }
  

namespace Eigen
{
  /**
  * \brief Component-wise division of a scalar by array elements.
  **/
  template <typename Derived>
  inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived>
    operator/(typename Derived::Scalar s, const Eigen::ArrayBase<Derived>& a)
  {
    return Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived>(

      Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>(s)  
    );
  }

  namespace internal
  {
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sin,scalar_sin_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(cos,scalar_cos_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(asin,scalar_asin_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(acos,scalar_acos_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(tan,scalar_tan_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(exp,scalar_exp_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(log,scalar_log_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs,scalar_abs_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op)
    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sqrt,scalar_sqrt_op)
  }
}

// TODO: cleanly disable those functions that are not supported on Array (internal::real_ref, internal::random, internal::isApprox...)

#endif // EIGEN_GLOBAL_FUNCTIONS_H





template<typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)
{
  return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
}

/****************************************************************************
* Implementation of abs                                                  *
****************************************************************************/

template<typename Scalar>
struct abs_impl
{
  typedef typename NumTraits<Scalar>::Real RealScalar;
  static inline RealScalar run(const Scalar& x)
  {
    using std::abs;
    return abs(x);
  }
};

template<typename Scalar>
struct abs_retval
{
  typedef typename NumTraits<Scalar>::Real type;
};

template<typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(abs, Scalar) abs(const Scalar& x)
{
  return EIGEN_MATHFUNC_IMPL(abs, Scalar)::run(x);
}

/****************************************************************************
* Implementation of abs2                                                 *
****************************************************************************/

template<typename Scalar>
struct abs2_impl
{
  typedef typename NumTraits<Scalar>::Real RealScalar;
  static inline RealScalar run(const Scalar& x)


template<typename OldType, typename NewType>
inline NewType cast(const OldType& x)
{
  return cast_impl<OldType, NewType>::run(x);
}

/****************************************************************************
* Implementation of sqrt                                                 *
****************************************************************************/

template<typename Scalar, bool IsInteger>
struct sqrt_default_impl
{
  static inline Scalar run(const Scalar& x)
  {
    using std::sqrt;
    return sqrt(x);
  }
};

template<typename Scalar>
struct sqrt_default_impl<Scalar, true>
{
  static inline Scalar run(const Scalar&)
  {
#ifdef EIGEN2_SUPPORT
    eigen_assert(!NumTraits<Scalar>::IsInteger);
#else
    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
#endif
    return Scalar(0);
  }
};

template<typename Scalar>
struct sqrt_impl : sqrt_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {};

template<typename Scalar>
struct sqrt_retval
{
  typedef Scalar type;
};

template<typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(const Scalar& x)
{
  return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x);
}

/****************************************************************************
* Implementation of standard unary real functions (exp, log, sin, cos, ...  *
****************************************************************************/

// This macro instanciate all the necessary template mechanism which is common to all unary real functions.
#define EIGEN_MATHFUNC_STANDARD_REAL_UNARY(NAME) \
  template<typename Scalar, bool IsInteger> struct NAME##_default_impl {            \
    static inline Scalar run(const Scalar& x) { using std::NAME; return NAME(x); }  \
  };                                                                                \
  template<typename Scalar> struct NAME##_default_impl<Scalar, true> {              \
    static inline Scalar run(const Scalar&) {                                       \
      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)                                       \
      return Scalar(0);                                                             \
    }                                                                               \
  };                                                                                \
  template<typename Scalar> struct NAME##_impl                                      \
    : NAME##_default_impl<Scalar, NumTraits<Scalar>::IsInteger>                     \
  {};                                                                               \
  template<typename Scalar> struct NAME##_retval { typedef Scalar type; };          \
  template<typename Scalar>                                                         \
  inline EIGEN_MATHFUNC_RETVAL(NAME, Scalar) NAME(const Scalar& x) {                \
    return EIGEN_MATHFUNC_IMPL(NAME, Scalar)::run(x);                               \
  }

EIGEN_MATHFUNC_STANDARD_REAL_UNARY(exp)
EIGEN_MATHFUNC_STANDARD_REAL_UNARY(log)
EIGEN_MATHFUNC_STANDARD_REAL_UNARY(sin)
EIGEN_MATHFUNC_STANDARD_REAL_UNARY(cos)
EIGEN_MATHFUNC_STANDARD_REAL_UNARY(tan)
EIGEN_MATHFUNC_STANDARD_REAL_UNARY(asin)
EIGEN_MATHFUNC_STANDARD_REAL_UNARY(acos)

/****************************************************************************
* Implementation of atan2                                                *
****************************************************************************/

template<typename Scalar, bool IsInteger>
struct atan2_default_impl
{
  typedef Scalar retval;
  static inline Scalar run(const Scalar& x, const Scalar& y)
  {
    using std::atan2;
    return atan2(x, y);
  }
};

template<typename Scalar>
struct atan2_default_impl<Scalar, true>
{
  static inline Scalar run(const Scalar&, const Scalar&)
  {
    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
    return Scalar(0);
  }
};

template<typename Scalar>
struct atan2_impl : atan2_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {};

template<typename Scalar>
struct atan2_retval
{
  typedef Scalar type;
};

template<typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(atan2, Scalar) atan2(const Scalar& x, const Scalar& y)
{
  return EIGEN_MATHFUNC_IMPL(atan2, Scalar)::run(x, y);
}

/****************************************************************************
* Implementation of atanh2                                                *
****************************************************************************/

template<typename Scalar, bool IsInteger>
struct atanh2_default_impl
{
  typedef Scalar retval;
  typedef typename NumTraits<Scalar>::Real RealScalar;




  *
  * \sa norm(), blueNorm(), hypotNorm()
  */
template<typename Derived>
inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
MatrixBase<Derived>::stableNorm() const
{
  using std::min;
  using std::sqrt;
  const Index blockSize = 4096;
  RealScalar scale(0);
  RealScalar invScale(1);
  RealScalar ssq(0); // sum of square
  enum {
    Alignment = (int(Flags)&DirectAccessBit) || (int(Flags)&AlignedBit) ? 1 : 0
  };
  Index n = size();
  Index bi = internal::first_aligned(derived());
  if (bi>0)
    internal::stable_norm_kernel(this->head(bi), ssq, scale, invScale);
  for (; bi<n; bi+=blockSize)
    internal::stable_norm_kernel(this->segment(bi,(min)(blockSize, n - bi)).template forceAlignedAccessIf<Alignment>(), ssq, scale, invScale);
  return scale * sqrt(ssq);
}

/** \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.

  */
template<typename Derived>
inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
MatrixBase<Derived>::blueNorm() const
{
  using std::pow;
  using std::min;
  using std::max;
  using std::sqrt;
  using std::abs;
  static Index nmax = -1;
  static RealScalar b1, b2, s1m, s2m, overfl, rbig, relerr;
  if(nmax <= 0)
  {
    int nbig, ibeta, it, iemin, iemax, iexp;
    RealScalar abig, eps;
    // This program calculates the machine-dependent constants
    // bl, b2, slm, s2m, relerr overfl, nmax


    iexp  = (2-iemin)/2;
    s1m   = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));   // scaling factor for lower range
    iexp  = - ((iemax+it)/2);
    s2m   = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));   // scaling factor for upper range

    overfl  = rbig*s2m;             // overflow boundary for abig
    eps     = RealScalar(pow(double(ibeta), 1-it));
    relerr  = sqrt(eps);         // tolerance for neglecting asml
    abig    = RealScalar(1.0/eps - 1.0);
    if (RealScalar(nbig)>abig)  nmax = int(abig);  // largest safe n
    else                        nmax = nbig;
  }
  Index n = size();
  RealScalar ab2 = b2 / RealScalar(n);
  RealScalar asml = RealScalar(0);
  RealScalar amed = RealScalar(0);
  RealScalar abig = RealScalar(0);
  for(Index j=0; j<n; ++j)
  {
    RealScalar ax = abs(coeff(j));
    if(ax > ab2)     abig += internal::abs2(ax*s2m);
    else if(ax < b1) asml += internal::abs2(ax*s1m);
    else             amed += internal::abs2(ax);
  }
  if(abig > RealScalar(0))
  {
    abig = sqrt(abig);
    if(abig > overfl)
    {
      return rbig;
    }
    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 = (min)(abig, amed);
  abig = (max)(abig, amed);
  if(asml <= abig*relerr)
    return abig;
  else
    return abig * sqrt(RealScalar(1) + internal::abs2(asml/abig));
}

/** \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>




/** \returns true if *this is approximately equal to an upper triangular matrix,
  *          within the precision given by \a prec.
  *
  * \sa isLowerTriangular()
  */
template<typename Derived>
bool MatrixBase<Derived>::isUpperTriangular(const RealScalar& prec) const
{
  using std::abs;
  RealScalar maxAbsOnUpperPart = static_cast<RealScalar>(-1);
  for(Index j = 0; j < cols(); ++j)
  {
    Index maxi = (std::min)(j, rows()-1);
    for(Index i = 0; i <= maxi; ++i)
    {
      RealScalar absValue = abs(coeff(i,j));
      if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;
    }
  }
  RealScalar threshold = maxAbsOnUpperPart * prec;
  for(Index j = 0; j < cols(); ++j)
    for(Index i = j+1; i < rows(); ++i)
      if(abs(coeff(i, j)) > threshold) return false;
  return true;
}

/** \returns true if *this is approximately equal to a lower triangular matrix,
  *          within the precision given by \a prec.
  *
  * \sa isUpperTriangular()
  */
template<typename Derived>
bool MatrixBase<Derived>::isLowerTriangular(const RealScalar& prec) const
{
  using std::abs;
  RealScalar maxAbsOnLowerPart = static_cast<RealScalar>(-1);
  for(Index j = 0; j < cols(); ++j)
    for(Index i = j; i < rows(); ++i)
    {
      RealScalar absValue = abs(coeff(i,j));
      if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;
    }
  RealScalar threshold = maxAbsOnLowerPart * prec;
  for(Index j = 1; j < cols(); ++j)
  {
    Index maxi = (std::min)(j, rows()-1);
    for(Index i = 0; i < maxi; ++i)
      if(abs(coeff(i, j)) > threshold) return false;
  }
  return true;
}

} // end namespace Eigen

#endif // EIGEN_TRIANGULARMATRIX_H




#ifndef EIGEN2_MATH_FUNCTIONS_H
#define EIGEN2_MATH_FUNCTIONS_H

namespace Eigen { 

template<typename T> inline typename NumTraits<T>::Real ei_real(const T& x) { return internal::real(x); }
template<typename T> inline typename NumTraits<T>::Real ei_imag(const T& x) { return internal::imag(x); }
template<typename T> inline T ei_conj(const T& x) { return internal::conj(x); }
template<typename T> inline typename NumTraits<T>::Real ei_abs (const T& x) { using std::abs; return abs(x); }
template<typename T> inline typename NumTraits<T>::Real ei_abs2(const T& x) { return internal::abs2(x); }
template<typename T> inline T ei_sqrt(const T& x) { using std::sqrt; return sqrt(x); }
template<typename T> inline T ei_exp (const T& x) { using std::exp;  return exp(x); }
template<typename T> inline T ei_log (const T& x) { using std::log;  return log(x); }
template<typename T> inline T ei_sin (const T& x) { using std::sin;  return sin(x); }
template<typename T> inline T ei_cos (const T& x) { using std::cos;  return cos(x); }
template<typename T> inline T ei_atan2(const T& x,const T& y) { using std::atan2; return atan2(x,y); }
template<typename T> inline T ei_pow (const T& x,const T& y) { return internal::pow(x,y); }
template<typename T> inline T ei_random () { return internal::random<T>(); }
template<typename T> inline T ei_random (const T& x, const T& y) { return internal::random(x, y); }

template<typename T> inline T precision () { return NumTraits<T>::dummy_precision(); }
template<typename T> inline T machine_epsilon () { return NumTraits<T>::epsilon(); }






  return false;
}


/** Compute the shift in the current QR iteration. */
template<typename MatrixType>
typename ComplexSchur<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::computeShift(Index iu, Index iter)
{
  using std::abs;
  if (iter == 10 || iter == 20) 
  {
    // exceptional shift, taken from http://www.netlib.org/eispack/comqr.f
    return abs(internal::real(m_matT.coeff(iu,iu-1))) + abs(internal::real(m_matT.coeff(iu-1,iu-2)));
  }

  // compute the shift as one of the eigenvalues of t, the 2x2
  // diagonal block on the bottom of the active submatrix
  Matrix<ComplexScalar,2,2> t = m_matT.template block<2,2>(iu-1,iu-1);
  RealScalar normt = t.cwiseAbs().sum();
  t /= normt;     // the normalization by sf is to avoid under/overflow





  }
  return matV;
}

template<typename MatrixType>
EigenSolver<MatrixType>& 
EigenSolver<MatrixType>::compute(const MatrixType& matrix, bool computeEigenvectors)
{
  using std::sqrt;
  using std::abs;
  assert(matrix.cols() == matrix.rows());

  // Reduce to real Schur form.
  m_realSchur.compute(matrix, computeEigenvectors);

  if (m_realSchur.info() == Success)
  {
    m_matT = m_realSchur.matrixT();

      if (i == matrix.cols() - 1 || m_matT.coeff(i+1, i) == Scalar(0)) 
      {
        m_eivalues.coeffRef(i) = m_matT.coeff(i, i);
        ++i;
      }
      else
      {
        Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i+1, i+1));
        Scalar z = sqrt(abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));
        m_eivalues.coeffRef(i)   = ComplexScalar(m_matT.coeff(i+1, i+1) + p, z);
        m_eivalues.coeffRef(i+1) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, -z);
        i += 2;
      }
    }
    
    // Compute eigenvectors.
    if (computeEigenvectors)


  return *this;
}

// Complex scalar division.
template<typename Scalar>
std::complex<Scalar> cdiv(Scalar xr, Scalar xi, Scalar yr, Scalar yi)
{
  using std::abs;
  Scalar r,d;
  if (abs(yr) > abs(yi))
  {
      r = yi/yr;
      d = yr + r*yi;
      return std::complex<Scalar>((xr + r*xi)/d, (xi - r*xr)/d);
  }
  else
  {
      r = yr/yi;

      return std::complex<Scalar>((r*xr + xi)/d, (r*xi - xr)/d);
  }
}


template<typename MatrixType>
void EigenSolver<MatrixType>::doComputeEigenvectors()
{
  using std::abs;
  const Index size = m_eivec.cols();
  const Scalar eps = NumTraits<Scalar>::epsilon();

  // inefficient! this is already computed in RealSchur
  Scalar norm(0);
  for (Index j = 0; j < size; ++j)
  {
    norm += m_matT.row(j).segment((std::max)(j-1,Index(0)), size-(std::max)(j-1,Index(0))).cwiseAbs().sum();

          }
          else // Solve real equations
          {
            Scalar x = m_matT.coeff(i,i+1);
            Scalar y = m_matT.coeff(i+1,i);
            Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();
            Scalar t = (x * lastr - lastw * r) / denom;
            m_matT.coeffRef(i,n) = t;
            if (abs(x) > abs(lastw))
              m_matT.coeffRef(i+1,n) = (-r - w * t) / x;
            else
              m_matT.coeffRef(i+1,n) = (-lastr - y * t) / lastw;
          }

          // Overflow control
          Scalar t = abs(m_matT.coeff(i,n));
          if ((eps * t) * t > Scalar(1))
            m_matT.col(n).tail(size-i) /= t;
        }
      }
    }
    else if (q < Scalar(0) && n > 0) // Complex vector
    {
      Scalar lastra(0), lastsa(0), lastw(0);
      Index l = n-1;

      // Last vector component imaginary so matrix is triangular
      if (abs(m_matT.coeff(n,n-1)) > abs(m_matT.coeff(n-1,n)))
      {
        m_matT.coeffRef(n-1,n-1) = q / m_matT.coeff(n,n-1);
        m_matT.coeffRef(n-1,n) = -(m_matT.coeff(n,n) - p) / m_matT.coeff(n,n-1);
      }
      else
      {
        std::complex<Scalar> cc = cdiv<Scalar>(0.0,-m_matT.coeff(n-1,n),m_matT.coeff(n-1,n-1)-p,q);
        m_matT.coeffRef(n-1,n-1) = internal::real(cc);

          else
          {
            // Solve complex equations
            Scalar x = m_matT.coeff(i,i+1);
            Scalar y = m_matT.coeff(i+1,i);
            Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;
            Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;
            if ((vr == 0.0) && (vi == 0.0))
              vr = eps * norm * (abs(w) + abs(q) + abs(x) + abs(y) + abs(lastw));

            std::complex<Scalar> cc = cdiv(x*lastra-lastw*ra+q*sa,x*lastsa-lastw*sa-q*ra,vr,vi);
            m_matT.coeffRef(i,n-1) = internal::real(cc);
            m_matT.coeffRef(i,n) = internal::imag(cc);
            if (abs(x) > (abs(lastw) + abs(q)))
            {
              m_matT.coeffRef(i+1,n-1) = (-ra - w * m_matT.coeff(i,n-1) + q * m_matT.coeff(i,n)) / x;
              m_matT.coeffRef(i+1,n) = (-sa - w * m_matT.coeff(i,n) - q * m_matT.coeff(i,n-1)) / x;
            }
            else
            {
              cc = cdiv(-lastra-y*m_matT.coeff(i,n-1),-lastsa-y*m_matT.coeff(i,n),lastw,q);
              m_matT.coeffRef(i+1,n-1) = internal::real(cc);
              m_matT.coeffRef(i+1,n) = internal::imag(cc);
            }
          }

          // Overflow control
          using std::max;
          Scalar t = (max)(abs(m_matT.coeff(i,n-1)),abs(m_matT.coeff(i,n)));
          if ((eps * t) * t > Scalar(1))
            m_matT.block(i, n-1, size-i, 2) /= t;

        }
      }
      
      // We handled a pair of complex conjugate eigenvalues, so need to skip them both
      n--;




//  // TODO
//  return matV;
//}

template<typename MatrixType>
GeneralizedEigenSolver<MatrixType>&
GeneralizedEigenSolver<MatrixType>::compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors)
{
  using std::sqrt;
  using std::abs;
  eigen_assert(A.cols() == A.rows() && B.cols() == A.rows() && B.cols() == B.rows());

  // Reduce to generalized real Schur form:
  // A = Q S Z and B = Q T Z
  m_realQZ.compute(A, B, computeEigenvectors);

  if (m_realQZ.info() == Success)
  {

      {
        m_alphas.coeffRef(i) = m_matS.coeff(i, i);
        m_betas.coeffRef(i)  = m_realQZ.matrixT().coeff(i,i);
        ++i;
      }
      else
      {
        Scalar p = Scalar(0.5) * (m_matS.coeff(i, i) - m_matS.coeff(i+1, i+1));
        Scalar z = sqrt(abs(p * p + m_matS.coeff(i+1, i) * m_matS.coeff(i, i+1)));
        m_alphas.coeffRef(i)   = ComplexScalar(m_matS.coeff(i+1, i+1) + p, z);
        m_alphas.coeffRef(i+1) = ComplexScalar(m_matS.coeff(i+1, i+1) + p, -z);

        m_betas.coeffRef(i)   = m_realQZ.matrixT().coeff(i,i);
        m_betas.coeffRef(i+1) = m_realQZ.matrixT().coeff(i,i);
        i += 2;
      }
    }




  * Output: \verbinclude MatrixBase_operatorNorm.out
  *
  * \sa SelfAdjointView::eigenvalues(), SelfAdjointView::operatorNorm()
  */
template<typename Derived>
inline typename MatrixBase<Derived>::RealScalar
MatrixBase<Derived>::operatorNorm() const
{
  using std::sqrt;
  typename Derived::PlainObject m_eval(derived());
  // FIXME if it is really guaranteed that the eigenvalues are already sorted,
  // then we don't need to compute a maxCoeff() here, comparing the 1st and last ones is enough.
  return sqrt((m_eval*m_eval.adjoint())
                 .eval()
		 .template selfadjointView<Lower>()
		 .eigenvalues()
		 .maxCoeff()
		 );
}

/** \brief Computes the L2 operator norm




      }
    }


  /** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0) */
  template<typename MatrixType>
    inline typename MatrixType::Index RealQZ<MatrixType>::findSmallSubdiagEntry(Index iu)
    {
      using std::abs;
      Index res = iu;
      while (res > 0)
      {
        Scalar s = abs(m_S.coeff(res-1,res-1)) + abs(m_S.coeff(res,res));
        if (s == Scalar(0.0))
          s = m_normOfS;
        if (abs(m_S.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
          break;
        res--;
      }
      return res;
    }

  /** \internal Look for single small diagonal element T(res, res) for res between f and l, and return res (or f-1)  */
  template<typename MatrixType>
    inline typename MatrixType::Index RealQZ<MatrixType>::findSmallDiagEntry(Index f, Index l)
    {
      using std::abs;
      Index res = l;
      while (res >= f) {
        if (abs(m_T.coeff(res,res)) <= NumTraits<Scalar>::epsilon() * m_normOfT)
          break;
        res--;
      }
      return res;
    }

  /** \internal decouple 2x2 diagonal block in rows i, i+1 if eigenvalues are real */
  template<typename MatrixType>
    inline void RealQZ<MatrixType>::splitOffTwoRows(Index i)
    {
      using std::abs;
      using std::sqrt;
      const Index dim=m_S.cols();
      if (abs(m_S.coeff(i+1,i)==Scalar(0)))
        return;
      Index z = findSmallDiagEntry(i,i+1);
      if (z==i-1)
      {
        // block of (S T^{-1})
        Matrix2s STi = m_T.template block<2,2>(i,i).template triangularView<Upper>().
          template solve<OnTheRight>(m_S.template block<2,2>(i,i));
        Scalar p = Scalar(0.5)*(STi(0,0)-STi(1,1));
        Scalar q = p*p + STi(1,0)*STi(0,1);
        if (q>=0) {
          Scalar z = sqrt(q);
          // one QR-like iteration for ABi - lambda I
          // is enough - when we know exact eigenvalue in advance,
          // convergence is immediate
          JRs G;
          if (p>=0)
            G.makeGivens(p + z, STi(1,0));
          else
            G.makeGivens(p - z, STi(1,0));

      m_S.coeffRef(l,l-1)=Scalar(0.0);
      // update Z
      if (m_computeQZ)
        m_Z.applyOnTheLeft(l,l-1,G.adjoint());
    }

  /** \internal QR-like iterative step for block f..l */
  template<typename MatrixType>
    inline void RealQZ<MatrixType>::step(Index f, Index l, Index iter)
    {
      using std::abs;
      const Index dim = m_S.cols();

      // x, y, z
      Scalar x, y, z;
      if (iter==10)
      {
        // Wilkinson ad hoc shift
        const Scalar

          a21=m_S.coeff(f+1,f+0), a22=m_S.coeff(f+1,f+1), a32=m_S.coeff(f+2,f+1),
          b12=m_T.coeff(f+0,f+1),
          b11i=Scalar(1.0)/m_T.coeff(f+0,f+0),
          b22i=Scalar(1.0)/m_T.coeff(f+1,f+1),
          a87=m_S.coeff(l-1,l-2),
          a98=m_S.coeff(l-0,l-1),
          b77i=Scalar(1.0)/m_T.coeff(l-2,l-2),
          b88i=Scalar(1.0)/m_T.coeff(l-1,l-1);
        Scalar ss = abs(a87*b77i) + abs(a98*b88i),
               lpl = Scalar(1.5)*ss,
               ll = ss*ss;
        x = ll + a11*a11*b11i*b11i - lpl*a11*b11i + a12*a21*b11i*b22i
          - a11*a21*b12*b11i*b11i*b22i;
        y = a11*a21*b11i*b11i - lpl*a21*b11i + a21*a22*b11i*b22i 
          - a21*a21*b12*b11i*b11i*b22i;
        z = a21*a32*b11i*b22i;
      }




    norm += m_matT.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
  return norm;
}

/** \internal Look for single small sub-diagonal element and returns its index */
template<typename MatrixType>
inline typename MatrixType::Index RealSchur<MatrixType>::findSmallSubdiagEntry(Index iu, Scalar norm)
{
  using std::abs;
  Index res = iu;
  while (res > 0)
  {
    Scalar s = abs(m_matT.coeff(res-1,res-1)) + abs(m_matT.coeff(res,res));
    if (s == 0.0)
      s = norm;
    if (abs(m_matT.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
      break;
    res--;
  }
  return res;
}

/** \internal Update T given that rows iu-1 and iu decouple from the rest. */
template<typename MatrixType>
inline void RealSchur<MatrixType>::splitOffTwoRows(Index iu, bool computeU, Scalar exshift)
{
  using std::sqrt;
  using std::abs;
  const Index size = m_matT.cols();

  // The eigenvalues of the 2x2 matrix [a b; c d] are 
  // trace +/- sqrt(discr/4) where discr = tr^2 - 4*det, tr = a + d, det = ad - bc
  Scalar p = Scalar(0.5) * (m_matT.coeff(iu-1,iu-1) - m_matT.coeff(iu,iu));
  Scalar q = p * p + m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);   // q = tr^2 / 4 - det = discr/4
  m_matT.coeffRef(iu,iu) += exshift;
  m_matT.coeffRef(iu-1,iu-1) += exshift;

  if (q >= Scalar(0)) // Two real eigenvalues
  {
    Scalar z = sqrt(abs(q));
    JacobiRotation<Scalar> rot;
    if (p >= Scalar(0))
      rot.makeGivens(p + z, m_matT.coeff(iu, iu-1));
    else
      rot.makeGivens(p - z, m_matT.coeff(iu, iu-1));

    m_matT.rightCols(size-iu+1).applyOnTheLeft(iu-1, iu, rot.adjoint());
    m_matT.topRows(iu+1).applyOnTheRight(iu-1, iu, rot);

  if (iu > 1) 
    m_matT.coeffRef(iu-1, iu-2) = Scalar(0);
}

/** \internal Form shift in shiftInfo, and update exshift if an exceptional shift is performed. */
template<typename MatrixType>
inline void RealSchur<MatrixType>::computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo)
{
  using std::sqrt;
  using std::abs;
  shiftInfo.coeffRef(0) = m_matT.coeff(iu,iu);
  shiftInfo.coeffRef(1) = m_matT.coeff(iu-1,iu-1);
  shiftInfo.coeffRef(2) = m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);

  // Wilkinson's original ad hoc shift
  if (iter == 10)
  {
    exshift += shiftInfo.coeff(0);
    for (Index i = 0; i <= iu; ++i)
      m_matT.coeffRef(i,i) -= shiftInfo.coeff(0);
    Scalar s = abs(m_matT.coeff(iu,iu-1)) + abs(m_matT.coeff(iu-1,iu-2));
    shiftInfo.coeffRef(0) = Scalar(0.75) * s;
    shiftInfo.coeffRef(1) = Scalar(0.75) * s;
    shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s;
  }

  // MATLAB's new ad hoc shift
  if (iter == 30)
  {
    Scalar s = (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
    s = s * s + shiftInfo.coeff(2);
    if (s > Scalar(0))
    {
      s = sqrt(s);
      if (shiftInfo.coeff(1) < shiftInfo.coeff(0))
        s = -s;
      s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
      s = shiftInfo.coeff(0) - shiftInfo.coeff(2) / s;
      exshift += s;
      for (Index i = 0; i <= iu; ++i)
        m_matT.coeffRef(i,i) -= s;
      shiftInfo.setConstant(Scalar(0.964));
    }
  }
}

/** \internal Compute index im at which Francis QR step starts and the first Householder vector. */
template<typename MatrixType>
inline void RealSchur<MatrixType>::initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector)
{
  using std::abs;
  Vector3s& v = firstHouseholderVector; // alias to save typing

  for (im = iu-2; im >= il; --im)
  {
    const Scalar Tmm = m_matT.coeff(im,im);
    const Scalar r = shiftInfo.coeff(0) - Tmm;
    const Scalar s = shiftInfo.coeff(1) - Tmm;
    v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / m_matT.coeff(im+1,im) + m_matT.coeff(im,im+1);
    v.coeffRef(1) = m_matT.coeff(im+1,im+1) - Tmm - r - s;
    v.coeffRef(2) = m_matT.coeff(im+2,im+1);
    if (im == il) {
      break;
    }
    const Scalar lhs = m_matT.coeff(im,im-1) * (abs(v.coeff(1)) + abs(v.coeff(2)));
    const Scalar rhs = v.coeff(0) * (abs(m_matT.coeff(im-1,im-1)) + abs(Tmm) + abs(m_matT.coeff(im+1,im+1)));
    if (abs(lhs) < NumTraits<Scalar>::epsilon() * rhs)
    {
      break;
    }
  }
}

/** \internal Perform a Francis QR step involving rows il:iu and columns im:iu. */
template<typename MatrixType>




template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n);
}

template<typename MatrixType>
SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
::compute(const MatrixType& matrix, int options)
{
  using std::abs;
  eigen_assert(matrix.cols() == matrix.rows());
  eigen_assert((options&~(EigVecMask|GenEigMask))==0
          && (options&EigVecMask)!=EigVecMask
          && "invalid option parameter");
  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
  Index n = matrix.cols();
  m_eivalues.resize(n,1);


  
  Index end = n-1;
  Index start = 0;
  Index iter = 0; // total number of iterations

  while (end>0)
  {
    for (Index i = start; i<end; ++i)
      if (internal::isMuchSmallerThan(abs(m_subdiag[i]),(abs(diag[i])+abs(diag[i+1]))))
        m_subdiag[i] = 0;

    // find the largest unreduced block
    while (end>0 && m_subdiag[end-1]==0)
    {
      end--;
    }
    if (end<=0)

    const Scalar t0 = Scalar(0.5) * sqrt( abs2(m(0,0)-m(1,1)) + Scalar(4)*m(1,0)*m(1,0));
    const Scalar t1 = Scalar(0.5) * (m(0,0) + m(1,1));
    roots(0) = t1 - t0;
    roots(1) = t1 + t0;
  }
  
  static inline void run(SolverType& solver, const MatrixType& mat, int options)
  {
    using std::sqrt;
    eigen_assert(mat.cols() == 2 && mat.cols() == mat.rows());
    eigen_assert((options&~(EigVecMask|GenEigMask))==0
            && (options&EigVecMask)!=EigVecMask
            && "invalid option parameter");
    bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
    
    MatrixType& eivecs = solver.m_eivec;
    VectorType& eivals = solver.m_eivalues;

  internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>::run(*this,matrix,options);
  return *this;
}

namespace internal {
template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n)
{
  using std::abs;
  RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5);
  RealScalar e = subdiag[end-1];
  // Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still
  // underflow thus leading to inf/NaN values when using the following commented code:
//   RealScalar e2 = abs2(subdiag[end-1]);
//   RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));
  // This explain the following, somewhat more complicated, version:
  RealScalar mu = diag[end];




struct tridiagonalization_inplace_selector<MatrixType,3,false>
{
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;

  template<typename DiagonalType, typename SubDiagonalType>
  static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ)
  {
    using std::sqrt;
    diag[0] = mat(0,0);
    RealScalar v1norm2 = abs2(mat(2,0));
    if(v1norm2 == RealScalar(0))
    {
      diag[1] = mat(1,1);
      diag[2] = mat(2,2);
      subdiag[0] = mat(1,0);
      subdiag[1] = mat(2,1);




  inline Scalar squaredExteriorDistance(const AlignedBox& b) const;

  /** \returns the distance between the point \a p and the box \c *this,
    * and zero if \a p is inside the box.
    * \sa squaredExteriorDistance()
    */
  template<typename Derived>
  inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
  { using std::sqrt; return sqrt(NonInteger(squaredExteriorDistance(p))); }

  /** \returns the distance between the boxes \a b and \c *this,
    * and zero if the boxes intersect.
    * \sa squaredExteriorDistance()
    */
  inline NonInteger exteriorDistance(const AlignedBox& b) const
  { using std::sqrt; return sqrt(NonInteger(squaredExteriorDistance(b))); }

  /** \returns \c *this with scalar type casted to \a NewScalarType
    *
    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
    * then this function smartly returns a const reference to \c *this.
    */
  template<typename NewScalarType>
  inline typename internal::cast_return_type<AlignedBox,




  */
template<typename Scalar>
template<typename QuatDerived>
AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const QuaternionBase<QuatDerived>& q)
{
  using std::acos;
  using std::min;
  using std::max;
  using std::sqrt;
  Scalar n2 = q.vec().squaredNorm();
  if (n2 < NumTraits<Scalar>::dummy_precision()*NumTraits<Scalar>::dummy_precision())
  {
    m_angle = 0;
    m_axis << 1, 0, 0;
  }
  else
  {
    m_angle = Scalar(2)*acos((min)((max)(Scalar(-1),q.w()),Scalar(1)));
    m_axis = q.vec() / sqrt(n2);
  }
  return *this;
}

/** Set \c *this from a 3x3 rotation matrix \a mat.
  */
template<typename Scalar>
template<typename Derived>

}

/** Constructs and \returns an equivalent 3x3 rotation matrix.
  */
template<typename Scalar>
typename AngleAxis<Scalar>::Matrix3
AngleAxis<Scalar>::toRotationMatrix(void) const
{
  using std::sin;
  using std::cos;
  Matrix3 res;
  Vector3 sin_axis  = sin(m_angle) * m_axis;
  Scalar c = cos(m_angle);
  Vector3 cos1_axis = (Scalar(1)-c) * m_axis;

  Scalar tmp;
  tmp = cos1_axis.x() * m_axis.y();
  res.coeffRef(0,1) = tmp - sin_axis.z();
  res.coeffRef(1,0) = tmp + sin_axis.z();

  tmp = cos1_axis.x() * m_axis.z();




  *      * AngleAxisf(ea[1], Vector3f::UnitX())
  *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
  * This corresponds to the right-multiply conventions (with right hand side frames).
  */
template<typename Derived>
inline Matrix<typename MatrixBase<Derived>::Scalar,3,1>
MatrixBase<Derived>::eulerAngles(Index a0, Index a1, Index a2) const
{
  using std::atan2;
  /* Implemented from Graphics Gems IV */
  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3)

  Matrix<Scalar,3,1> res;
  typedef Matrix<typename Derived::Scalar,2,1> Vector2;
  const Scalar epsilon = NumTraits<Scalar>::dummy_precision();

  const Index odd = ((a0+1)%3 == a1) ? 0 : 1;
  const Index i = a0;
  const Index j = (a0 + 1 + odd)%3;
  const Index k = (a0 + 2 - odd)%3;

  if (a0==a2)
  {
    Scalar s = Vector2(coeff(j,i) , coeff(k,i)).norm();
    res[1] = atan2(s, coeff(i,i));
    if (s > epsilon)
    {
      res[0] = atan2(coeff(j,i), coeff(k,i));
      res[2] = atan2(coeff(i,j),-coeff(i,k));
    }
    else
    {
      res[0] = Scalar(0);
      res[2] = (coeff(i,i)>0?1:-1)*atan2(-coeff(k,j), coeff(j,j));
    }
  }
  else
  {
    Scalar c = Vector2(coeff(i,i) , coeff(i,j)).norm();
    res[1] = atan2(-coeff(i,k), c);
    if (c > epsilon)
    {
      res[0] = atan2(coeff(j,k), coeff(k,k));
      res[2] = atan2(coeff(i,j), coeff(i,i));
    }
    else
    {
      res[0] = Scalar(0);
      res[2] = (coeff(i,k)>0?1:-1)*atan2(-coeff(k,j), coeff(j,j));
    }
  }
  if (!odd)
    res = -res;
  return res;
}

} // end namespace Eigen




  /** \returns the signed distance between the plane \c *this and a point \a p.
    * \sa absDistance()
    */
  inline Scalar signedDistance(const VectorType& p) const { return normal().dot(p) + offset(); }

  /** \returns the absolute distance between the plane \c *this and a point \a p.
    * \sa signedDistance()
    */
  inline Scalar absDistance(const VectorType& p) const { using std::abs; return abs(signedDistance(p)); }

  /** \returns the projection of a point \a p onto the plane \c *this.
    */
  inline VectorType projection(const VectorType& p) const { return p - signedDistance(p) * normal(); }

  /** \returns a constant reference to the unit normal vector of the plane, which corresponds
    * to the linear part of the implicit equation.
    */

  /** \returns the intersection of *this with \a other.
    *
    * \warning The ambient space must be a plane, i.e. have dimension 2, so that \c *this and \a other are lines.
    *
    * \note If \a other is approximately parallel to *this, this method will return any point on *this.
    */
  VectorType intersection(const Hyperplane& other) const
  {
    using std::abs;
    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
    Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0);
    // since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests
    // whether the two lines are approximately parallel.
    if(internal::isMuchSmallerThan(det, Scalar(1)))
    {   // special case where the two lines are approximately parallel. Pick any point on the first line.
        if(abs(coeffs().coeff(1))>abs(coeffs().coeff(0)))
            return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0));
        else
            return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0));
    }
    else
    {   // general case
        Scalar invdet = Scalar(1) / det;
        return VectorType(invdet*(coeffs().coeff(1)*other.coeffs().coeff(2)-other.coeffs().coeff(1)*coeffs().coeff(2)),




  RealScalar squaredDistance(const VectorType& p) const
  {
    VectorType diff = p - origin();
    return (diff - direction().dot(diff) * direction()).squaredNorm();
  }
  /** \returns the distance of a point \a p to its projection onto the line \c *this.
    * \sa squaredDistance()
    */
  RealScalar distance(const VectorType& p) const { using std::sqrt; return sqrt(squaredDistance(p)); }

  /** \returns the projection of a point \a p onto the line \c *this. */
  VectorType projection(const VectorType& p) const
  { return origin() + direction().dot(p-origin()) * direction(); }

  VectorType pointAt(const Scalar& t) const;
  
  template <int OtherOptions>




  return derived();
}

/** Set \c *this from an angle-axis \a aa and returns a reference to \c *this
  */
template<class Derived>
EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const AngleAxisType& aa)
{
  using std::cos;
  using std::sin;
  Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings
  this->w() = cos(ha);
  this->vec() = sin(ha) * aa.axis();
  return derived();
}

/** Set \c *this from the expression \a xpr:
  *   - if \a xpr is a 4x1 vector, then \a xpr is assumed to be a quaternion
  *   - if \a xpr is a 3x3 matrix, then \a xpr is assumed to be rotation matrix
  *     and \a xpr is converted to a quaternion
  */

  * Note that the two input vectors do \b not have to be normalized, and
  * do not need to have the same norm.
  */
template<class Derived>
template<typename Derived1, typename Derived2>
inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
{
  using std::max;
  using std::sqrt;
  Vector3 v0 = a.normalized();
  Vector3 v1 = b.normalized();
  Scalar c = v1.dot(v0);

  // if dot == -1, vectors are nearly opposites
  // => accuraletly compute the rotation axis by computing the
  //    intersection of the two planes. This is done by solving:
  //       x^T v0 = 0

  if (c < Scalar(-1)+NumTraits<Scalar>::dummy_precision())
  {
    c = max<Scalar>(c,-1);
    Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
    JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
    Vector3 axis = svd.matrixV().col(2);

    Scalar w2 = (Scalar(1)+c)*Scalar(0.5);
    this->w() = sqrt(w2);
    this->vec() = axis * sqrt(Scalar(1) - w2);
    return derived();
  }
  Vector3 axis = v0.cross(v1);
  Scalar s = sqrt((Scalar(1)+c)*Scalar(2));
  Scalar invs = Scalar(1)/s;
  this->vec() = axis * invs;
  this->w() = s * Scalar(0.5);

  return derived();
}



  * \sa dot()
  */
template <class Derived>
template <class OtherDerived>
inline typename internal::traits<Derived>::Scalar
QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& other) const
{
  using std::acos;
  using std::abs;
  double d = abs(this->dot(other));
  if (d>=1.0)
    return Scalar(0);
  return static_cast<Scalar>(2 * acos(d));
}

/** \returns the spherical linear interpolation between the two quaternions
  * \c *this and \a other at the parameter \a t
  */
template <class Derived>
template <class OtherDerived>
Quaternion<typename internal::traits<Derived>::Scalar>
QuaternionBase<Derived>::slerp(Scalar t, const QuaternionBase<OtherDerived>& other) const
{
  using std::acos;
  using std::sin;
  using std::abs;
  static const Scalar one = Scalar(1) - NumTraits<Scalar>::epsilon();
  Scalar d = this->dot(other);
  Scalar absD = abs(d);

  Scalar scale0;
  Scalar scale1;

  if(absD>=one)
  {
    scale0 = Scalar(1) - t;
    scale1 = t;
  }
  else
  {
    // theta is the angle between the 2 quaternions
    Scalar theta = acos(absD);
    Scalar sinTheta = sin(theta);

    scale0 = sin( ( Scalar(1) - t ) * theta) / sinTheta;
    scale1 = sin( ( t * theta) ) / sinTheta;
  }
  if(d<0) scale1 = -scale1;

  return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
}

namespace internal {

// set from a rotation matrix
template<typename Other>
struct quaternionbase_assign_impl<Other,3,3>
{
  typedef typename Other::Scalar Scalar;
  typedef DenseIndex Index;
  template<class Derived> static inline void run(QuaternionBase<Derived>& q, const Other& mat)
  {
    using std::sqrt;
    // This algorithm comes from  "Quaternion Calculus and Fast Animation",
    // Ken Shoemake, 1987 SIGGRAPH course notes
    Scalar t = mat.trace();
    if (t > Scalar(0))
    {
      t = sqrt(t + Scalar(1.0));
      q.w() = Scalar(0.5)*t;
      t = Scalar(0.5)/t;




/** Set \c *this from a 2x2 rotation matrix \a mat.
  * In other words, this function extract the rotation angle
  * from the rotation matrix.
  */
template<typename Scalar>
template<typename Derived>
Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
{
  using std::atan2;
  EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
  m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
  return *this;
}

/** Constructs and \returns an equivalent 2x2 rotation matrix.
  */
template<typename Scalar>
typename Rotation2D<Scalar>::Matrix2
Rotation2D<Scalar>::toRotationMatrix(void) const
{
  using std::sin;
  using std::cos;
  Scalar sinA = sin(m_angle);
  Scalar cosA = cos(m_angle);
  return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
}

} // end namespace Eigen

#endif // EIGEN_ROTATION2D_H




  */
template<typename Derived>
template<typename EssentialPart>
void MatrixBase<Derived>::makeHouseholder(
  EssentialPart& essential,
  Scalar& tau,
  RealScalar& beta) const
{
  using std::sqrt;
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)
  VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size()-1);
  
  RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm();
  Scalar c0 = coeff(0);

  if(tailSqNorm == RealScalar(0) && internal::imag(c0)==RealScalar(0))
  {
    tau = RealScalar(0);
    beta = internal::real(c0);
    essential.setZero();
  }
  else
  {
    beta = sqrt(internal::abs2(c0) + tailSqNorm);
    if (internal::real(c0)>=RealScalar(0))
      beta = -beta;
    essential = tail / (c0 - beta);
    tau = internal::conj((beta - c0) / beta);
  }
}

/** Apply the elementary reflector H given by




/** Makes \c *this as a Jacobi rotation \a J such that applying \a J on both the right and left sides of the selfadjoint 2x2 matrix
  * \f$ B = \left ( \begin{array}{cc} x & y \\ \overline y & z \end{array} \right )\f$ yields a diagonal matrix \f$ A = J^* B J \f$
  *
  * \sa MatrixBase::makeJacobi(const MatrixBase<Derived>&, Index, Index), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
  */
template<typename Scalar>
bool JacobiRotation<Scalar>::makeJacobi(RealScalar x, Scalar y, RealScalar z)
{
  using std::sqrt;
  using std::abs;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  if(y == Scalar(0))
  {
    m_c = Scalar(1);
    m_s = Scalar(0);
    return false;
  }
  else
  {
    RealScalar tau = (x-z)/(RealScalar(2)*abs(y));
    RealScalar w = sqrt(internal::abs2(tau) + RealScalar(1));
    RealScalar t;
    if(tau>RealScalar(0))
    {
      t = RealScalar(1) / (tau + w);
    }
    else
    {
      t = RealScalar(1) / (tau - w);
    }
    RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
    RealScalar n = RealScalar(1) / sqrt(internal::abs2(t)+RealScalar(1));
    m_s = - sign_t * (internal::conj(y) / abs(y)) * abs(t) * n;
    m_c = n;
    return true;
  }
}

/** Makes \c *this as a Jacobi rotation \c J such that applying \a J on both the right and left sides of the 2x2 selfadjoint matrix
  * \f$ B = \left ( \begin{array}{cc} \text{this}_{pp} & \text{this}_{pq} \\ (\text{this}_{pq})^* & \text{this}_{qq} \end{array} \right )\f$ yields
  * a diagonal matrix \f$ A = J^* B J \f$

  makeGivens(p, q, z, typename internal::conditional<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>::type());
}


// specialization for complexes
template<typename Scalar>
void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type)
{
  using std::sqrt;
  using std::abs;
  if(q==Scalar(0))
  {
    m_c = internal::real(p)<0 ? Scalar(-1) : Scalar(1);
    m_s = 0;
    if(r) *r = m_c * p;
  }
  else if(p==Scalar(0))
  {
    m_c = 0;
    m_s = -q/abs(q);
    if(r) *r = abs(q);
  }
  else
  {
    RealScalar p1 = internal::norm1(p);
    RealScalar q1 = internal::norm1(q);
    if(p1>=q1)
    {
      Scalar ps = p / p1;
      RealScalar p2 = internal::abs2(ps);
      Scalar qs = q / p1;
      RealScalar q2 = internal::abs2(qs);

      RealScalar u = sqrt(RealScalar(1) + q2/p2);
      if(internal::real(p)<RealScalar(0))
        u = -u;

      m_c = Scalar(1)/u;
      m_s = -qs*internal::conj(ps)*(m_c/p2);
      if(r) *r = p * u;
    }
    else
    {
      Scalar ps = p / q1;
      RealScalar p2 = internal::abs2(ps);
      Scalar qs = q / q1;
      RealScalar q2 = internal::abs2(qs);

      RealScalar u = q1 * sqrt(p2 + q2);
      if(internal::real(p)<RealScalar(0))
        u = -u;

      p1 = abs(p);
      ps = p/p1;
      m_c = p1/u;
      m_s = -internal::conj(ps) * (q/u);
      if(r) *r = ps * u;
    }
  }
}

// specialization for reals
template<typename Scalar>
void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)
{
  using std::sqrt;
  using std::abs;
  if(q==Scalar(0))
  {
    m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
    m_s = Scalar(0);
    if(r) *r = abs(p);
  }
  else if(p==Scalar(0))
  {
    m_c = Scalar(0);
    m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
    if(r) *r = abs(q);
  }
  else if(abs(p) > abs(q))
  {
    Scalar t = q/p;
    Scalar u = sqrt(Scalar(1) + internal::abs2(t));
    if(p<Scalar(0))
      u = -u;
    m_c = Scalar(1)/u;
    m_s = -t * m_c;
    if(r) *r = p * u;
  }
  else
  {
    Scalar t = p/q;
    Scalar u = sqrt(Scalar(1) + internal::abs2(t));
    if(q<Scalar(0))
      u = -u;
    m_s = -Scalar(1)/u;
    m_c = -t * m_s;
    if(r) *r = q * u;
  }

}




    /** \returns the rank of the matrix of which *this is the LU decomposition.
      *
      * \note This method has to determine which pivots should be considered nonzero.
      *       For that, it uses the threshold value that you can control by calling
      *       setThreshold(const RealScalar&).
      */
    inline Index rank() const
    {
      using std::abs;
      eigen_assert(m_isInitialized && "LU is not initialized.");
      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
      Index result = 0;
      for(Index i = 0; i < m_nonzero_pivots; ++i)
        result += (abs(m_lu.coeff(i,i)) > premultiplied_threshold);
      return result;
    }

    /** \returns the dimension of the kernel of the matrix of which *this is the LU decomposition.
      *
      * \note This method has to determine which pivots should be considered nonzero.
      *       For that, it uses the threshold value that you can control by calling
      *       setThreshold(const RealScalar&).


  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
            MatrixType::MaxColsAtCompileTime,
            MatrixType::MaxRowsAtCompileTime)
  };

  template<typename Dest> void evalTo(Dest& dst) const
  {
    using std::abs;
    const Index cols = dec().matrixLU().cols(), dimker = cols - rank();
    if(dimker == 0)
    {
      // The Kernel is just {0}, so it doesn't have a basis properly speaking, but let's
      // avoid crashing/asserting as that depends on floating point calculations. Let's
      // just return a single column vector filled with zeros.
      dst.setZero();
      return;


  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
            MatrixType::MaxColsAtCompileTime,
            MatrixType::MaxRowsAtCompileTime)
  };

  template<typename Dest> void evalTo(Dest& dst) const
  {
    using std::abs;
    if(rank() == 0)
    {
      // The Image is just {0}, so it doesn't have a basis properly speaking, but let's
      // avoid crashing/asserting as that depends on floating point calculations. Let's
      // just return a single column vector filled with zeros.
      dst.setZero();
      return;
    }




  static inline void run(
    const MatrixType& matrix,
    const typename MatrixType::RealScalar& absDeterminantThreshold,
    ResultType& result,
    typename ResultType::Scalar& determinant,
    bool& invertible
  )
  {
    using std::abs;
    determinant = matrix.coeff(0,0);
    invertible = abs(determinant) > absDeterminantThreshold;
    if(invertible) result.coeffRef(0,0) = typename ResultType::Scalar(1) / determinant;
  }
};

/****************************
*** Size 2 implementation ***

  static inline void run(
    const MatrixType& matrix,
    const typename MatrixType::RealScalar& absDeterminantThreshold,
    ResultType& inverse,
    typename ResultType::Scalar& determinant,
    bool& invertible
  )
  {
    using std::abs;
    typedef typename ResultType::Scalar Scalar;
    determinant = matrix.determinant();
    invertible = abs(determinant) > absDeterminantThreshold;
    if(!invertible) return;
    const Scalar invdet = Scalar(1) / determinant;
    compute_inverse_size2_helper(matrix, invdet, inverse);
  }
};

  static inline void run(
    const MatrixType& matrix,
    const typename MatrixType::RealScalar& absDeterminantThreshold,
    ResultType& inverse,
    typename ResultType::Scalar& determinant,
    bool& invertible
  )
  {
    using std::abs;
    typedef typename ResultType::Scalar Scalar;
    Matrix<Scalar,3,1> cofactors_col0;
    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
    determinant = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
    invertible = abs(determinant) > absDeterminantThreshold;
    if(!invertible) return;

  static inline void run(
    const MatrixType& matrix,
    const typename MatrixType::RealScalar& absDeterminantThreshold,
    ResultType& inverse,
    typename ResultType::Scalar& determinant,
    bool& invertible
  )
  {
    using std::abs;
    determinant = matrix.determinant();
    invertible = abs(determinant) > absDeterminantThreshold;
    if(invertible) compute_inverse<MatrixType, ResultType>::run(matrix, inverse);
  }
};

/*************************
*** MatrixBase methods ***




    /** \returns the rank of the matrix of which *this is the QR decomposition.
      *
      * \note This method has to determine which pivots should be considered nonzero.
      *       For that, it uses the threshold value that you can control by calling
      *       setThreshold(const RealScalar&).
      */
    inline Index rank() const
    {
      using std::abs;
      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
      Index result = 0;
      for(Index i = 0; i < m_nonzero_pivots; ++i)
        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
      return result;
    }

    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
      *
      * \note This method has to determine which pivots should be considered nonzero.
      *       For that, it uses the threshold value that you can control by calling
      *       setThreshold(const RealScalar&).

    RealScalar m_prescribedThreshold, m_maxpivot;
    Index m_nonzero_pivots;
    Index m_det_pq;
};

template<typename MatrixType>
typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const
{
  using std::abs;
  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return abs(m_qr.diagonal().prod());
}

template<typename MatrixType>
typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::logAbsDeterminant() const
{
  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return m_qr.diagonal().cwiseAbs().array().log().sum();
}

template<typename MatrixType>
ColPivHouseholderQR<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const MatrixType& matrix)
{
  using std::abs;
  Index rows = matrix.rows();
  Index cols = matrix.cols();
  Index size = matrix.diagonalSize();

  m_qr = matrix;
  m_hCoeffs.resize(size);

  m_temp.resize(cols);

    // generate the householder vector, store it below the diagonal
    RealScalar beta;
    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);

    // apply the householder transformation to the diagonal coefficient
    m_qr.coeffRef(k,k) = beta;

    // remember the maximum absolute value of diagonal coefficients
    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);

    // apply the householder transformation
    m_qr.bottomRightCorner(rows-k, cols-k-1)
        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));

    // update our table of squared norms of the columns
    m_colSqNorms.tail(cols-k-1) -= m_qr.row(k).tail(cols-k-1).cwiseAbs2();
  }





#define EIGEN_MKL_QR_COLPIV(EIGTYPE, MKLTYPE, MKLPREFIX, EIGCOLROW, MKLCOLROW) \
template<> inline \
ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >& \
ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >::compute( \
              const Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>& matrix) \
\
{ \
  using std::abs; \
  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
  typedef MatrixType::Scalar Scalar; \
  typedef MatrixType::RealScalar RealScalar; \
  Index rows = matrix.rows();\
  Index cols = matrix.cols();\
  Index size = matrix.diagonalSize();\
\
  m_qr = matrix;\

  m_colsPermutation.indices().setZero(); \
\
  lapack_int lda = m_qr.outerStride(), i; \
  lapack_int matrix_order = MKLCOLROW; \
  LAPACKE_##MKLPREFIX##geqp3( matrix_order, rows, cols, (MKLTYPE*)m_qr.data(), lda, (lapack_int*)m_colsPermutation.indices().data(), (MKLTYPE*)m_hCoeffs.data()); \
  m_isInitialized = true; \
  m_maxpivot=m_qr.diagonal().cwiseAbs().maxCoeff(); \
  m_hCoeffs.adjointInPlace(); \
  RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold(); \
  lapack_int *perm = m_colsPermutation.indices().data(); \
  for(i=0;i<size;i++) { \
    m_nonzero_pivots += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);\
  } \
  for(i=0;i<cols;i++) perm[i]--;\
\
  /*m_det_pq = (number_of_transpositions%2) ? -1 : 1;  // TODO: It's not needed now; fix upon availability in Eigen */ \
\
  return *this; \
}





    /** \returns the rank of the matrix of which *this is the QR decomposition.
      *
      * \note This method has to determine which pivots should be considered nonzero.
      *       For that, it uses the threshold value that you can control by calling
      *       setThreshold(const RealScalar&).
      */
    inline Index rank() const
    {
      using std::abs;
      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
      Index result = 0;
      for(Index i = 0; i < m_nonzero_pivots; ++i)
        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
      return result;
    }

    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
      *
      * \note This method has to determine which pivots should be considered nonzero.
      *       For that, it uses the threshold value that you can control by calling
      *       setThreshold(const RealScalar&).

    Index m_nonzero_pivots;
    RealScalar m_precision;
    Index m_det_pq;
};

template<typename MatrixType>
typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const
{
  using std::abs;
  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return abs(m_qr.diagonal().prod());
}

template<typename MatrixType>
typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::logAbsDeterminant() const
{
  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return m_qr.diagonal().cwiseAbs().array().log().sum();
}

template<typename MatrixType>
FullPivHouseholderQR<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(const MatrixType& matrix)
{
  using std::abs;
  Index rows = matrix.rows();
  Index cols = matrix.cols();
  Index size = (std::min)(rows,cols);

  m_qr = matrix;
  m_hCoeffs.resize(size);

  m_temp.resize(cols);

      ++number_of_transpositions;
    }

    RealScalar beta;
    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
    m_qr.coeffRef(k,k) = beta;

    // remember the maximum absolute value of diagonal coefficients
    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);

    m_qr.bottomRightCorner(rows-k, cols-k-1)
        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
  }

  m_cols_permutation.setIdentity(cols);
  for(Index k = 0; k < size; ++k)
    m_cols_permutation.applyTranspositionOnTheRight(k, m_cols_transpositions.coeff(k));




    HCoeffsType m_hCoeffs;
    RowVectorType m_temp;
    bool m_isInitialized;
};

template<typename MatrixType>
typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const
{
  using std::abs;
  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return abs(m_qr.diagonal().prod());
}

template<typename MatrixType>
typename MatrixType::RealScalar HouseholderQR<MatrixType>::logAbsDeterminant() const
{
  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return m_qr.diagonal().cwiseAbs().array().log().sum();




struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, true>
{
  typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  typedef typename SVD::Index Index;
  static void run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Index p, Index q)
  {
    using std::sqrt;
    Scalar z;
    JacobiRotation<Scalar> rot;
    RealScalar n = sqrt(abs2(work_matrix.coeff(p,p)) + abs2(work_matrix.coeff(q,p)));
    if(n==0)
    {
      z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
      work_matrix.row(p) *= z;
      if(svd.computeU()) svd.m_matrixU.col(p) *= conj(z);

  }
};

template<typename MatrixType, typename RealScalar, typename Index>
void real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q,
                            JacobiRotation<RealScalar> *j_left,
                            JacobiRotation<RealScalar> *j_right)
{
  using std::sqrt;
  Matrix<RealScalar,2,2> m;
  m << real(matrix.coeff(p,p)), real(matrix.coeff(p,q)),
       real(matrix.coeff(q,p)), real(matrix.coeff(q,q));
  JacobiRotation<RealScalar> rot1;
  RealScalar t = m.coeff(0,0) + m.coeff(1,1);
  RealScalar d = m.coeff(1,0) - m.coeff(0,1);
  if(t == RealScalar(0))
  {

  if(m_cols>m_rows) m_qr_precond_morecols.allocate(*this);
  if(m_rows>m_cols) m_qr_precond_morerows.allocate(*this);
}

template<typename MatrixType, int QRPreconditioner>
JacobiSVD<MatrixType, QRPreconditioner>&
JacobiSVD<MatrixType, QRPreconditioner>::compute(const MatrixType& matrix, unsigned int computationOptions)
{
  using std::abs;
  allocate(matrix.rows(), matrix.cols(), computationOptions);

  // currently we stop when we reach precision 2*epsilon as the last bit of precision can require an unreasonable number of iterations,
  // only worsening the precision of U and V as we accumulate more rotations
  const RealScalar precision = RealScalar(2) * NumTraits<Scalar>::epsilon();

  // limit for very small denormal numbers to be considered zero in order to avoid infinite loops (see bug 286)
  const RealScalar considerAsZero = RealScalar(2) * std::numeric_limits<RealScalar>::denorm_min();

    for(Index p = 1; p < m_diagSize; ++p)
    {
      for(Index q = 0; q < p; ++q)
      {
        // if this 2x2 sub-matrix is not diagonal already...
        // notice that this comparison will evaluate to false if any NaN is involved, ensuring that NaN's don't
        // keep us iterating forever. Similarly, small denormal numbers are considered zero.
        using std::max;
        RealScalar threshold = (max)(considerAsZero, precision * (max)(abs(m_workMatrix.coeff(p,p)),
                                                                       abs(m_workMatrix.coeff(q,q))));
        if((max)(abs(m_workMatrix.coeff(p,q)),abs(m_workMatrix.coeff(q,p))) > threshold)
        {
          finished = false;

          // perform SVD decomposition of 2x2 sub-matrix corresponding to indices p,q to make it diagonal
          internal::svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner>::run(m_workMatrix, *this, p, q);
          JacobiRotation<RealScalar> j_left, j_right;
          internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right);


      }
    }
  }

  /*** step 3. The work matrix is now diagonal, so ensure it's positive so its diagonal entries are the singular values ***/

  for(Index i = 0; i < m_diagSize; ++i)
  {
    RealScalar a = abs(m_workMatrix.coeff(i,i));
    m_singularValues.coeffRef(i) = a;
    if(computeU() && (a!=RealScalar(0))) m_matrixU.col(i) *= m_workMatrix.coeff(i,i)/a;
  }

  /*** step 4. Sort singular values in descending order and compute the number of nonzero singular values ***/

  m_nonzeroSingularValues = m_diagSize;
  for(Index i = 0; i < m_diagSize; i++)




  m_factorizationIsOk = false;
}


template<typename Derived>
template<bool DoLDLT>
void SimplicialCholeskyBase<Derived>::factorize_preordered(const CholMatrixType& ap)
{
  using std::sqrt;
  
  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
  eigen_assert(ap.rows()==ap.cols());
  const Index size = ap.rows();
  eigen_assert(m_parent.size()==size);
  eigen_assert(m_nonZerosPerCol.size()==size);

  const Index* Lp = m_matrix.outerIndexPtr();
  Index* Li = m_matrix.innerIndexPtr();

    else
    {
      Index p = Lp[k] + m_nonZerosPerCol[k]++;
      Li[p] = k ;                /* store L(k,k) = sqrt (d) in column k */
      if(d <= RealScalar(0)) {
        ok = false;              /* failure, matrix is not positive definite */
        break;
      }
      Lx[p] = sqrt(d) ;
    }
  }

  m_info = ok ? Success : NumericalIssue;
  m_factorizationIsOk = true;
}

namespace internal {




      * \param vec the vector on which we iterate
      * \param epsilon the minimal value used to prune zero coefficients.
      * In practice, all coefficients having a magnitude smaller than \a epsilon
      * are skipped.
      */
    Iterator(const AmbiVector& vec, RealScalar epsilon = 0)
      : m_vector(vec)
    {
      using std::abs;
      m_epsilon = epsilon;
      m_isDense = m_vector.m_mode==IsDense;
      if (m_isDense)
      {
        m_currentEl = 0;   // this is to avoid a compilation warning
        m_cachedValue = 0; // this is to avoid a compilation warning
        m_cachedIndex = m_vector.m_start-1;
        ++(*this);
      }
      else
      {
        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
        m_currentEl = m_vector.m_llStart;
        while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<=m_epsilon)
          m_currentEl = llElements[m_currentEl].next;
        if (m_currentEl<0)
        {
          m_cachedValue = 0; // this is to avoid a compilation warning
          m_cachedIndex = -1;
        }
        else
        {


    Index index() const { return m_cachedIndex; }
    Scalar value() const { return m_cachedValue; }

    operator bool() const { return m_cachedIndex>=0; }

    Iterator& operator++()
    {
      using std::abs;
      if (m_isDense)
      {
        do {
          ++m_cachedIndex;
        } while (m_cachedIndex<m_vector.m_end && abs(m_vector.m_buffer[m_cachedIndex])<m_epsilon);
        if (m_cachedIndex<m_vector.m_end)
          m_cachedValue = m_vector.m_buffer[m_cachedIndex];
        else
          m_cachedIndex=-1;
      }
      else
      {
        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
        do {
          m_currentEl = llElements[m_currentEl].next;
        } while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<m_epsilon);
        if (m_currentEl<0)
        {
          m_cachedIndex = -1;
        }
        else
        {
          m_cachedIndex = llElements[m_currentEl].index;
          m_cachedValue = llElements[m_currentEl].value;




{
  return internal::real((*this).cwiseAbs2().sum());
}

template<typename Derived>
inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
SparseMatrixBase<Derived>::norm() const
{
  using std::sqrt;
  return sqrt(squaredNorm());
}

} // end namespace Eigen

#endif // EIGEN_SPARSE_DOT_H




    EIGEN_STRONG_INLINE SparseSparseProduct(const Lhs& lhs, const Rhs& rhs, const RealScalar& tolerance)
      : m_lhs(lhs), m_rhs(rhs), m_tolerance(tolerance), m_conservative(false)
    {
      init();
    }

    SparseSparseProduct pruned(const Scalar& reference = 0, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision()) const
    {
      using std::abs;
      return SparseSparseProduct(m_lhs,m_rhs,abs(reference)*epsilon);
    }

    template<typename Dest>
    void evalTo(Dest& result) const
    {
      if(m_conservative)
        internal::conservative_sparse_sparse_product_selector<_LhsNested, _RhsNested, Dest>::run(lhs(),rhs(),result);
      else




  DenseIndex ret;
  if(*incx==1)  vector(x,*n).cwiseAbs().minCoeff(&ret);
  else          vector(x,*n,std::abs(*incx)).cwiseAbs().minCoeff(&ret);
  return ret+1;
}

int EIGEN_BLAS_FUNC(rotg)(RealScalar *pa, RealScalar *pb, RealScalar *pc, RealScalar *ps)
{
  using std::sqrt;
  using std::abs;
  
  Scalar& a = *reinterpret_cast<Scalar*>(pa);
  Scalar& b = *reinterpret_cast<Scalar*>(pb);
  RealScalar* c = pc;
  Scalar* s = reinterpret_cast<Scalar*>(ps);

  #if !ISCOMPLEX
  Scalar r,z;
  Scalar aa = abs(a);
  Scalar ab = abs(b);
  if((aa+ab)==Scalar(0))
  {
    *c = 1;
    *s = 0;
    r = 0;
    z = 0;
  }
  else
  {
    r = sqrt(a*a + b*b);
    Scalar amax = aa>ab ? a : b;
    r = amax>0 ? r : -r;
    *c = a/r;
    *s = b/r;
    z = 1;
    if (aa > ab) z = *s;
    if (ab > aa && *c!=RealScalar(0))
      z = Scalar(1)/ *c;
  }
  *pa = r;
  *pb = z;
  #else
  Scalar alpha;
  RealScalar norm,scale;
  if(abs(a)==RealScalar(0))
  {
    *c = RealScalar(0);
    *s = Scalar(1);
    a = b;
  }
  else
  {
    scale = abs(a) + abs(b);
    norm = scale*sqrt((internal::abs2(a/scale))+ (internal::abs2(b/scale)));
    alpha = a/abs(a);
    *c = abs(a)/norm;
    *s = alpha*internal::conj(b)/norm;
    a = alpha*norm;
  }
  #endif

//   JacobiRotation<Scalar> r;
//   r.makeGivens(a,b);
//   *c = r.c();




  PATHS
  $ENV{UMFPACKDIR}
  ${INCLUDE_INSTALL_DIR}
  PATH_SUFFIXES
  suitesparse
  ufsparse
)

if(NOT UMFPACK_LIBRARIES)

find_library(UMFPACK_LIBRARIES umfpack PATHS $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR})

if(UMFPACK_LIBRARIES)
  if (NOT UMFPACK_LIBDIR)
    get_filename_component(UMFPACK_LIBDIR ${UMFPACK_LIBRARIES} PATH)
  endif(NOT UMFPACK_LIBDIR)

  find_library(AMD_LIBRARY amd PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR})

  if (COLAMD_LIBRARY)
    set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${COLAMD_LIBRARY})
  #else (COLAMD_LIBRARY)
  #  set(UMFPACK_LIBRARIES FALSE)
  endif (COLAMD_LIBRARY)

endif(UMFPACK_LIBRARIES)

endif()

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(UMFPACK DEFAULT_MSG
                                  UMFPACK_INCLUDES UMFPACK_LIBRARIES)

mark_as_advanced(UMFPACK_INCLUDES UMFPACK_LIBRARIES AMD_LIBRARY COLAMD_LIBRARY)




    // check normalized() and normalize()
    VERIFY_IS_APPROX(v1, v1.norm() * v1.normalized());
    v3 = v1;
    v3.normalize();
    VERIFY_IS_APPROX(v1, v1.norm() * v3);
    VERIFY_IS_APPROX(v3, v1.normalized());
    VERIFY_IS_APPROX(v3.norm(), RealScalar(1));
  }
  VERIFY_IS_MUCH_SMALLER_THAN(abs(vzero.dot(v1)),  static_cast<RealScalar>(1));
  
  // check compatibility of dot and adjoint
  
  ref = NumTraits<Scalar>::IsInteger ? 0 : (std::max)((std::max)(v1.norm(),v2.norm()),(std::max)((square * v2).norm(),(square.adjoint() * v1).norm()));
  VERIFY(test_isApproxWithRef(v1.dot(square * v2), (square.adjoint() * v1).dot(v2), ref));

  // like in testBasicStuff, test operator() to check const-qualification
  Index r = internal::random<Index>(0, rows-1),




  VERIFY( (m1 == m1(r,c) ).any() );

  // test Select
  VERIFY_IS_APPROX( (m1<m2).select(m1,m2), m1.cwiseMin(m2) );
  VERIFY_IS_APPROX( (m1>m2).select(m1,m2), m1.cwiseMax(m2) );
  Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
  for (int j=0; j<cols; ++j)
  for (int i=0; i<rows; ++i)
    m3(i,j) = abs(m1(i,j))<mid ? 0 : m1(i,j);
  VERIFY_IS_APPROX( (m1.abs()<ArrayType::Constant(rows,cols,mid))
                        .select(ArrayType::Zero(rows,cols),m1), m3);
  // shorter versions:
  VERIFY_IS_APPROX( (m1.abs()<ArrayType::Constant(rows,cols,mid))
                        .select(0,m1), m3);
  VERIFY_IS_APPROX( (m1.abs()>=ArrayType::Constant(rows,cols,mid))
                        .select(m1,0), m3);
  // even shorter version:


  ArrayType m1 = ArrayType::Random(rows, cols),
             m2 = ArrayType::Random(rows, cols),
             m3(rows, cols);

  Scalar  s1 = internal::random<Scalar>();

  // these tests are mostly to check possible compilation issues.
//   VERIFY_IS_APPROX(m1.sin(), std::sin(m1));
  VERIFY_IS_APPROX(m1.sin(), sin(m1));
//   VERIFY_IS_APPROX(m1.cos(), std::cos(m1));
  VERIFY_IS_APPROX(m1.cos(), cos(m1));
//   VERIFY_IS_APPROX(m1.asin(), std::asin(m1));
  VERIFY_IS_APPROX(m1.asin(), asin(m1));
//   VERIFY_IS_APPROX(m1.acos(), std::acos(m1));
  VERIFY_IS_APPROX(m1.acos(), acos(m1));
//   VERIFY_IS_APPROX(m1.tan(), std::tan(m1));
  VERIFY_IS_APPROX(m1.tan(), tan(m1));
  
  VERIFY_IS_APPROX(cos(m1+RealScalar(3)*m2), cos((m1+RealScalar(3)*m2).eval()));
//   VERIFY_IS_APPROX(std::cos(m1+RealScalar(3)*m2), std::cos((m1+RealScalar(3)*m2).eval()));

//   VERIFY_IS_APPROX(m1.abs().sqrt(), std::sqrt(std::abs(m1)));
  VERIFY_IS_APPROX(m1.abs().sqrt(), sqrt(abs(m1)));
  VERIFY_IS_APPROX(m1.abs(), sqrt(internal::abs2(m1)));

  VERIFY_IS_APPROX(internal::abs2(internal::real(m1)) + internal::abs2(internal::imag(m1)), internal::abs2(m1));
  VERIFY_IS_APPROX(internal::abs2(real(m1)) + internal::abs2(imag(m1)), internal::abs2(m1));
  if(!NumTraits<Scalar>::IsComplex)
    VERIFY_IS_APPROX(internal::real(m1), m1);

  //VERIFY_IS_APPROX(m1.abs().log(), std::log(std::abs(m1)));
  VERIFY_IS_APPROX(m1.abs().log(), log(abs(m1)));

//   VERIFY_IS_APPROX(m1.exp(), std::exp(m1));
  VERIFY_IS_APPROX(m1.exp() * m2.exp(), exp(m1+m2));
  VERIFY_IS_APPROX(m1.exp(), exp(m1));
  VERIFY_IS_APPROX(m1.exp() / m2.exp(),(m1-m2).exp());

  VERIFY_IS_APPROX(m1.pow(2), m1.square());
  VERIFY_IS_APPROX(pow(m1,2), m1.square());

  ArrayType exponents = ArrayType::Constant(rows, cols, RealScalar(2));
  VERIFY_IS_APPROX(Eigen::pow(m1,exponents), m1.square());

  m3 = m1.abs();
  VERIFY_IS_APPROX(m3.pow(RealScalar(0.5)), m3.sqrt());
  VERIFY_IS_APPROX(pow(m3,RealScalar(0.5)), m3.sqrt());

  // scalar by array division
  const RealScalar tiny = sqrt(std::numeric_limits<RealScalar>::epsilon());
  s1 += Scalar(tiny);
  m1 += ArrayType::Constant(rows,cols,Scalar(tiny));
  VERIFY_IS_APPROX(s1/m1, s1 * m1.inverse());
}

template<typename ArrayType> void array_complex(const ArrayType& m)
{
  typedef typename ArrayType::Index Index;

  Index rows = m.rows();
  Index cols = m.cols();

  ArrayType m1 = ArrayType::Random(rows, cols),
            m2(rows, cols);

  for (Index i = 0; i < m.rows(); ++i)
    for (Index j = 0; j < m.cols(); ++j)
      m2(i,j) = sqrt(m1(i,j));

  VERIFY_IS_APPROX(m1.sqrt(), m2);
//   VERIFY_IS_APPROX(m1.sqrt(), std::sqrt(m1));
  VERIFY_IS_APPROX(m1.sqrt(), Eigen::sqrt(m1));
}

template<typename ArrayType> void min_max(const ArrayType& m)
{
  typedef typename ArrayType::Index Index;
  typedef typename ArrayType::Scalar Scalar;

  Index rows = m.rows();




  VERIFY( (m1.array() == m1(r,c) ).any() );

  // test Select
  VERIFY_IS_APPROX( (m1.array()<m2.array()).select(m1,m2), m1.cwiseMin(m2) );
  VERIFY_IS_APPROX( (m1.array()>m2.array()).select(m1,m2), m1.cwiseMax(m2) );
  Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
  for (int j=0; j<cols; ++j)
  for (int i=0; i<rows; ++i)
    m3(i,j) = abs(m1(i,j))<mid ? 0 : m1(i,j);
  VERIFY_IS_APPROX( (m1.array().abs()<MatrixType::Constant(rows,cols,mid).array())
                        .select(MatrixType::Zero(rows,cols),m1), m3);
  // shorter versions:
  VERIFY_IS_APPROX( (m1.array().abs()<MatrixType::Constant(rows,cols,mid).array())
                        .select(0,m1), m3);
  VERIFY_IS_APPROX( (m1.array().abs()>=MatrixType::Constant(rows,cols,mid).array())
                        .select(m1,0), m3);
  // even shorter version:


  // TODO allows colwise/rowwise for array
  VERIFY_IS_APPROX(((m1.array().abs()+1)>RealScalar(0.1)).matrix().colwise().count(), VectorOfIndices::Constant(cols,rows).transpose());
  VERIFY_IS_APPROX(((m1.array().abs()+1)>RealScalar(0.1)).matrix().rowwise().count(), VectorOfIndices::Constant(rows, cols));
}

template<typename VectorType> void lpNorm(const VectorType& v)
{
  using std::sqrt;
  VectorType u = VectorType::Random(v.size());

  VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), u.cwiseAbs().maxCoeff());
  VERIFY_IS_APPROX(u.template lpNorm<1>(), u.cwiseAbs().sum());
  VERIFY_IS_APPROX(u.template lpNorm<2>(), sqrt(u.array().abs().square().sum()));
  VERIFY_IS_APPROX(internal::pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.array().abs().pow(5).sum());
}

template<typename MatrixType> void cwise_min_max(const MatrixType& m)
{
  typedef typename MatrixType::Index Index;
  typedef typename MatrixType::Scalar Scalar;





    Vector2f sides = M-m;
    VERIFY_IS_APPROX(sides, box.sizes() );
    VERIFY_IS_APPROX(sides[1], box.sizes()[1] );
    VERIFY_IS_APPROX(sides[1], box.sizes().maxCoeff() );
    VERIFY_IS_APPROX(sides[0], box.sizes().minCoeff() );

    VERIFY_IS_APPROX( 14.0f, box.volume() );
    VERIFY_IS_APPROX( 53.0f, box.diagonal().squaredNorm() );
    VERIFY_IS_APPROX( std::sqrt( 53.0f ), box.diagonal().norm() );

    VERIFY_IS_APPROX( m, box.corner( BoxType::BottomLeft ) );
    VERIFY_IS_APPROX( M, box.corner( BoxType::TopRight ) );
    Vector2f bottomRight; bottomRight << M[0], m[1];
    Vector2f topLeft; topLeft << m[0], M[1];
    VERIFY_IS_APPROX( bottomRight, box.corner( BoxType::BottomRight ) );
    VERIFY_IS_APPROX( topLeft, box.corner( BoxType::TopLeft ) );
}




  typedef Matrix<Scalar,3,1> CoeffsType;

  for(int i = 0; i < 10; i++)
  {
    Vector center = Vector::Random();
    Vector u = Vector::Random();
    Vector v = Vector::Random();
    Scalar a = internal::random<Scalar>();
    while (abs(a-1) < 1e-4) a = internal::random<Scalar>();
    while (u.norm() < 1e-4) u = Vector::Random();
    while (v.norm() < 1e-4) v = Vector::Random();

    HLine line_u = HLine::Through(center + u, center + a*u);
    HLine line_v = HLine::Through(center + v, center + a*v);

    // the line equations should be normalized so that a^2+b^2=1
    VERIFY_IS_APPROX(line_u.normal().norm(), Scalar(1));




  VectorType p0 = VectorType::Random(dim);
  VectorType p1 = VectorType::Random(dim);

  VectorType d0 = VectorType::Random(dim).normalized();

  LineType l0(p0, d0);

  Scalar s0 = internal::random<Scalar>();
  Scalar s1 = abs(internal::random<Scalar>());

  VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0), RealScalar(1) );
  VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0+s0*d0), RealScalar(1) );
  VERIFY_IS_APPROX( (l0.projection(p1)-p1).norm(), l0.distance(p1) );
  VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(l0.projection(p1)), RealScalar(1) );
  VERIFY_IS_APPROX( Scalar(l0.distance((p0+s0*d0) + d0.unitOrthogonal() * s1)), s1 );

  // casting





  Scalar theta_tot = AA(q1*q0.inverse()).angle();
  if(theta_tot>M_PI)
    theta_tot = 2.*M_PI-theta_tot;
  for(Scalar t=0; t<=1.001; t+=0.1)
  {
    QuatType q = q0.slerp(t,q1);
    Scalar theta = AA(q*q0.inverse()).angle();
    VERIFY(abs(q.norm() - 1) < largeEps);
    if(theta_tot==0)  VERIFY(theta_tot==0);
    else              VERIFY(abs(theta/theta_tot - t) < largeEps);
  }
}

template<typename Scalar, int Options> void quaternion(void)
{
  /* this test covers the following files:
     Quaternion.h
  */


  // concatenation
  q1 *= q2;

  q1 = AngleAxisx(a, v0.normalized());
  q2 = AngleAxisx(a, v1.normalized());

  // angular distance
  Scalar refangle = abs(AngleAxisx(q1.inverse()*q2).angle());
  if (refangle>Scalar(M_PI))
    refangle = Scalar(2)*Scalar(M_PI) - refangle;

  if((q1.coeffs()-q2.coeffs()).norm() > 10*largeEps)
  {
    VERIFY_IS_MUCH_SMALLER_THAN(abs(q1.angularDistance(q2) - refangle), Scalar(1));
  }

  // rotation matrix conversion
  VERIFY_IS_APPROX(q1 * v2, q1.toRotationMatrix() * v2);
  VERIFY_IS_APPROX(q1 * q2 * v2,
    q1.toRotationMatrix() * q2.toRotationMatrix() * v2);

  VERIFY(  (q2*q1).isApprox(q1*q2, largeEps)



  // angle-axis conversion
  AngleAxisx aa = AngleAxisx(q1);
  VERIFY_IS_APPROX(q1 * v1, Quaternionx(aa) * v1);

  // Do not execute the test if the rotation angle is almost zero, or
  // the rotation axis and v1 are almost parallel.
  if (abs(aa.angle()) > 5*test_precision<Scalar>()
      && (aa.axis() - v1.normalized()).norm() < 1.99
      && (aa.axis() + v1.normalized()).norm() < 1.99) 
  {
    VERIFY_IS_NOT_APPROX(q1 * v1, Quaternionx(AngleAxisx(aa.angle()*2,aa.axis())) * v1);
  }

  // from two vector creation
  VERIFY_IS_APPROX( v2.normalized(),(q2.setFromTwoVectors(v1, v2)*v1).normalized());




  VERIFY_IS_APPROX((t0 * v1).template head<3>(), AlignedScaling3(v0) * v1);
}

template<typename Scalar, int Mode, int Options> void transformations()
{
  /* this test covers the following files:
     Cross.h Quaternion.h, Transform.cpp
  */
  using std::cos;
  typedef Matrix<Scalar,2,2> Matrix2;
  typedef Matrix<Scalar,3,3> Matrix3;
  typedef Matrix<Scalar,4,4> Matrix4;
  typedef Matrix<Scalar,2,1> Vector2;
  typedef Matrix<Scalar,3,1> Vector3;
  typedef Matrix<Scalar,4,1> Vector4;
  typedef Quaternion<Scalar> Quaternionx;
  typedef AngleAxis<Scalar> AngleAxisx;

          v1 = Vector3::Random();
  Matrix3 matrot1, m;

  Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
  Scalar s0 = internal::random<Scalar>();

  VERIFY_IS_APPROX(v0, AngleAxisx(a, v0.normalized()) * v0);
  VERIFY_IS_APPROX(-v0, AngleAxisx(Scalar(M_PI), v0.unitOrthogonal()) * v0);
  VERIFY_IS_APPROX(cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0));
  m = AngleAxisx(a, v0.normalized()).toRotationMatrix().adjoint();
  VERIFY_IS_APPROX(Matrix3::Identity(), m * AngleAxisx(a, v0.normalized()));
  VERIFY_IS_APPROX(Matrix3::Identity(), AngleAxisx(a, v0.normalized()) * m);

  Quaternionx q1, q2;
  q1 = AngleAxisx(a, v0.normalized());
  q2 = AngleAxisx(a, v1.normalized());


  m = q1.toRotationMatrix();
  aa1 = m;
  VERIFY_IS_APPROX(AngleAxisx(m).toRotationMatrix(),
    Quaternionx(m).toRotationMatrix());

  // Transform
  // TODO complete the tests !
  a = 0;
  while (abs(a)<Scalar(0.1))
    a = internal::random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI));
  q1 = AngleAxisx(a, v0.normalized());
  Transform3 t0, t1, t2;

  // first test setIdentity() and Identity()
  t0.setIdentity();
  VERIFY_IS_APPROX(t0.matrix(), Transform3::MatrixType::Identity());
  t0.matrix().setZero();

  t5 = t5*t5;
  VERIFY_IS_APPROX(t5, t4*t4);

  // 2D transformation
  Transform2 t20, t21;
  Vector2 v20 = Vector2::Random();
  Vector2 v21 = Vector2::Random();
  for (int k=0; k<2; ++k)
    if (abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3);
  t21.setIdentity();
  t21.linear() = Rotation2D<Scalar>(a).toRotationMatrix();
  VERIFY_IS_APPROX(t20.fromPositionOrientationScale(v20,a,v21).matrix(),
    t21.pretranslate(v20).scale(v21).matrix());

  t21.setIdentity();
  t21.linear() = Rotation2D<Scalar>(-a).toRotationMatrix();
  VERIFY( (t20.fromPositionOrientationScale(v20,a,v21)




  VERIFY(invertible);
  VERIFY_IS_APPROX(identity, m1*m2);

  //Second: a rank one matrix (not invertible, except for 1x1 matrices)
  VectorType v3 = VectorType::Random(rows);
  MatrixType m3 = v3*v3.transpose(), m4(rows,cols);
  m3.computeInverseAndDetWithCheck(m4, det, invertible);
  VERIFY( rows==1 ? invertible : !invertible );
  VERIFY_IS_MUCH_SMALLER_THAN(abs(det-m3.determinant()), RealScalar(1));
  m3.computeInverseWithCheck(m4, invertible);
  VERIFY( rows==1 ? invertible : !invertible );
#endif

  // check in-place inversion
  if(MatrixType::RowsAtCompileTime>=2 && MatrixType::RowsAtCompileTime<=4)
  {
    // in-place is forbidden





  // this test relies a lot on Random.h, and there's not much more that we can do
  // to test it, hence I consider that we will have tested Random.h
  MatrixType m1 = MatrixType::Random(rows, cols),
             m2 = MatrixType::Random(rows, cols),
             m3(rows, cols);

  Scalar s1 = internal::random<Scalar>();
  while (abs(s1)<1e-3) s1 = internal::random<Scalar>();

  Index r = internal::random<Index>(0, rows-1),
        c = internal::random<Index>(0, cols-1);

  VERIFY_IS_APPROX(-(-m1),                  m1);
  VERIFY_IS_APPROX(m1+m1,                   2*m1);
  VERIFY_IS_APPROX(m1+m2-m1,                m2);
  VERIFY_IS_APPROX(-m2+m1+m2,               m1);




template<> std::string type_name<std::complex<float> >() { return "complex<float>"; }
template<> std::string type_name<std::complex<double> >() { return "complex<double>"; }
template<> std::string type_name<std::complex<int> >() { return "complex<int>"; }

// forward declaration of the main test function
void EIGEN_CAT(test_,EIGEN_TEST_FUNC)();

using namespace Eigen;
using std::abs;
using std::sqrt;

void set_repeat_from_string(const char *str)
{
  errno = 0;
  g_repeat = int(strtoul(str, 0, 10));
  if(errno || g_repeat <= 0)
  {
    std::cout << "Invalid repeat value " << str << std::endl;




  
  VERIFY(( internal::is_same<float,internal::remove_reference<float&>::type >::value));
  VERIFY(( internal::is_same<const float,internal::remove_reference<const float&>::type >::value));
  VERIFY(( internal::is_same<float,internal::remove_pointer<float*>::type >::value));
  VERIFY(( internal::is_same<const float,internal::remove_pointer<const float*>::type >::value));
  VERIFY(( internal::is_same<float,internal::remove_pointer<float* const >::type >::value));
  
  VERIFY(internal::meta_sqrt<1>::ret == 1);
  #define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt<X>::ret == int(std::sqrt(double(X))))
  VERIFY_META_SQRT(2);
  VERIFY_META_SQRT(3);
  VERIFY_META_SQRT(4);
  VERIFY_META_SQRT(5);
  VERIFY_META_SQRT(6);
  VERIFY_META_SQRT(8);
  VERIFY_META_SQRT(9);
  VERIFY_META_SQRT(15);




  EIGEN_ALIGN16 Scalar data2[internal::packet_traits<Scalar>::size*4];
  EIGEN_ALIGN16 Packet packets[PacketSize*2];
  EIGEN_ALIGN16 Scalar ref[internal::packet_traits<Scalar>::size*4];
  RealScalar refvalue = 0;
  for (int i=0; i<size; ++i)
  {
    data1[i] = internal::random<Scalar>()/RealScalar(PacketSize);
    data2[i] = internal::random<Scalar>()/RealScalar(PacketSize);
    refvalue = (std::max)(refvalue,abs(data1[i]));
  }

  internal::pstore(data2, internal::pload<Packet>(data1));
  VERIFY(areApprox(data1, data2, PacketSize) && "aligned load/store");

  for (int offset=0; offset<PacketSize; ++offset)
  {
    internal::pstore(data2, internal::ploadu<Packet>(data1+offset));

  EIGEN_ALIGN16 Scalar data2[internal::packet_traits<Scalar>::size*4];
  EIGEN_ALIGN16 Scalar ref[internal::packet_traits<Scalar>::size*4];

  for (int i=0; i<size; ++i)
  {
    data1[i] = internal::random<Scalar>(-1e3,1e3);
    data2[i] = internal::random<Scalar>(-1e3,1e3);
  }
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSin, std::sin, internal::psin);
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasCos, std::cos, internal::pcos);
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasTan, std::tan, internal::ptan);
  
  for (int i=0; i<size; ++i)
  {
    data1[i] = internal::random<Scalar>(-1,1);
    data2[i] = internal::random<Scalar>(-1,1);
  }
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasASin, std::asin, internal::pasin);
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasACos, std::acos, internal::pacos);

  for (int i=0; i<size; ++i)
  {
    data1[i] = internal::random<Scalar>(-87,88);
    data2[i] = internal::random<Scalar>(-87,88);
  }
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasExp, std::exp, internal::pexp);

  for (int i=0; i<size; ++i)
  {
    data1[i] = internal::random<Scalar>(0,1e6);
    data2[i] = internal::random<Scalar>(0,1e6);
  }
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLog, std::log, internal::plog);
  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSqrt, std::sqrt, internal::psqrt);

  ref[0] = data1[0];
  for (int i=0; i<PacketSize; ++i)
    ref[0] = (std::min)(ref[0],data1[i]);
  VERIFY(internal::isApprox(ref[0], internal::predux_min(internal::pload<Packet>(data1))) && "internal::predux_min");

  CHECK_CWISE2((std::min), internal::pmin);
  CHECK_CWISE2((std::max), internal::pmax);
  CHECK_CWISE1(abs, internal::pabs);

  ref[0] = data1[0];
  for (int i=0; i<PacketSize; ++i)
    ref[0] = (std::max)(ref[0],data1[i]);
  VERIFY(internal::isApprox(ref[0], internal::predux_max(internal::pload<Packet>(data1))) && "internal::predux_max");
  
  for (int i=0; i<PacketSize; ++i)
    ref[i] = data1[0]+Scalar(i);

Lines 36-44 template<typename T> void test_pastix_T_ Link Here

(-)a/test/pastix_support.cpp (-1 / +1 lines)
36	}	36	}
37		37
38	void test_pastix_support()	38	void test_pastix_support()
39	{	39	{
40	CALL_SUBTEST_1(test_pastix_T<float>());	40	CALL_SUBTEST_1(test_pastix_T<float>());
41	CALL_SUBTEST_2(test_pastix_T<double>());	41	CALL_SUBTEST_2(test_pastix_T<double>());
42	CALL_SUBTEST_3( (test_pastix_T_LU<std::complex<float> >()) );	42	CALL_SUBTEST_3( (test_pastix_T_LU<std::complex<float> >()) );
43	CALL_SUBTEST_4(test_pastix_T_LU<std::complex<double> >());	43	CALL_SUBTEST_4(test_pastix_T_LU<std::complex<double> >());
44	}	44	}




  typedef typename MatrixType::RealScalar RealScalar;
  double error_sum = 0., error_max = 0.;
  for(int i = 0; i < repeat; ++i)
  {
    MatrixType m;
    RealScalar absdet;
    do {
      m = MatrixType::Random();
      absdet = abs(m.determinant());
    } while(absdet < NumTraits<Scalar>::epsilon());
    MatrixType inv = m.inverse();
    double error = double( (m*inv-MatrixType::Identity()).norm() * absdet / NumTraits<Scalar>::epsilon() );
    error_sum += error;
    error_max = (std::max)(error_max, error);
  }
  std::cerr << "inverse_general_4x4, Scalar = " << type_name<Scalar>() << std::endl;
  double error_avg = error_sum / repeat;




  Matrix<Scalar,Rows,Cols2> m3 = m1*m2;
  m2 = Matrix<Scalar,Cols,Cols2>::Random(Cols,Cols2);
  m2 = qr.solve(m3);
  VERIFY_IS_APPROX(m3, m1*m2);
}

template<typename MatrixType> void qr_invertible()
{
  using std::log;
  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
  typedef typename MatrixType::Scalar Scalar;

  int size = internal::random<int>(10,50);

  MatrixType m1(size, size), m2(size, size), m3(size, size);
  m1 = MatrixType::Random(size,size);


  HouseholderQR<MatrixType> qr(m1);
  m3 = MatrixType::Random(size,size);
  m2 = qr.solve(m3);
  VERIFY_IS_APPROX(m3, m1*m2);

  // now construct a matrix with prescribed determinant
  m1.setZero();
  for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
  RealScalar absdet = abs(m1.diagonal().prod());
  m3 = qr.householderQ(); // get a unitary
  m1 = m3 * m1 * m3;
  qr.compute(m1);
  VERIFY_IS_APPROX(absdet, qr.absDeterminant());
  VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
}

template<typename MatrixType> void qr_verify_assert()
{
  MatrixType tmp;

  HouseholderQR<MatrixType> qr;
  VERIFY_RAISES_ASSERT(qr.matrixQR())




  Matrix<Scalar,Rows,Cols2> m3 = m1*m2;
  m2 = Matrix<Scalar,Cols,Cols2>::Random(Cols,Cols2);
  m2 = qr.solve(m3);
  VERIFY_IS_APPROX(m3, m1*m2);
}

template<typename MatrixType> void qr_invertible()
{
  using std::log;
  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
  typedef typename MatrixType::Scalar Scalar;

  int size = internal::random<int>(10,50);

  MatrixType m1(size, size), m2(size, size), m3(size, size);
  m1 = MatrixType::Random(size,size);


  ColPivHouseholderQR<MatrixType> qr(m1);
  m3 = MatrixType::Random(size,size);
  m2 = qr.solve(m3);
  //VERIFY_IS_APPROX(m3, m1*m2);

  // now construct a matrix with prescribed determinant
  m1.setZero();
  for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
  RealScalar absdet = abs(m1.diagonal().prod());
  m3 = qr.householderQ(); // get a unitary
  m1 = m3 * m1 * m3;
  qr.compute(m1);
  VERIFY_IS_APPROX(absdet, qr.absDeterminant());
  VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
}

template<typename MatrixType> void qr_verify_assert()
{
  MatrixType tmp;

  ColPivHouseholderQR<MatrixType> qr;
  VERIFY_RAISES_ASSERT(qr.matrixQR())




  MatrixType m3 = m1*m2;
  m2 = MatrixType::Random(cols,cols2);
  m2 = qr.solve(m3);
  VERIFY_IS_APPROX(m3, m1*m2);
}

template<typename MatrixType> void qr_invertible()
{
  using std::log;
  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
  typedef typename MatrixType::Scalar Scalar;

  int size = internal::random<int>(10,50);

  MatrixType m1(size, size), m2(size, size), m3(size, size);
  m1 = MatrixType::Random(size,size);



  m3 = MatrixType::Random(size,size);
  m2 = qr.solve(m3);
  VERIFY_IS_APPROX(m3, m1*m2);

  // now construct a matrix with prescribed determinant
  m1.setZero();
  for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
  RealScalar absdet = abs(m1.diagonal().prod());
  m3 = qr.matrixQ(); // get a unitary
  m1 = m3 * m1 * m3;
  qr.compute(m1);
  VERIFY_IS_APPROX(absdet, qr.absDeterminant());
  VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
}

template<typename MatrixType> void qr_verify_assert()
{
  MatrixType tmp;

  FullPivHouseholderQR<MatrixType> qr;
  VERIFY_RAISES_ASSERT(qr.matrixQR())





  RealQZ<MatrixType> qz(A,B);
  
  VERIFY_IS_EQUAL(qz.info(), Success);
  // check for zeros
  bool all_zeros = true;
  for (Index i=0; i<A.cols(); i++)
    for (Index j=0; j<i; j++) {
      if (abs(qz.matrixT()(i,j))!=Scalar(0.0))
        all_zeros = false;
      if (j<i-1 && abs(qz.matrixS()(i,j))!=Scalar(0.0))
        all_zeros = false;
      if (j==i-1 && j>0 && abs(qz.matrixS()(i,j))!=Scalar(0.0) && abs(qz.matrixS()(i-1,j-1))!=Scalar(0.0))
        all_zeros = false;
    }
  VERIFY_IS_EQUAL(all_zeros, true);
  VERIFY_IS_APPROX(qz.matrixQ()*qz.matrixS()*qz.matrixZ(), A);
  VERIFY_IS_APPROX(qz.matrixQ()*qz.matrixT()*qz.matrixZ(), B);
  VERIFY_IS_APPROX(qz.matrixQ()*qz.matrixQ().adjoint(), MatrixType::Identity(dim,dim));
  VERIFY_IS_APPROX(qz.matrixZ()*qz.matrixZ().adjoint(), MatrixType::Identity(dim,dim));
}




    RealScalar minc(internal::real(v.coeff(0))), maxc(internal::real(v.coeff(0)));
    for(int j = 0; j < i; j++)
    {
      s += v[j];
      p *= v_for_prod[j];
      minc = (std::min)(minc, internal::real(v[j]));
      maxc = (std::max)(maxc, internal::real(v[j]));
    }
    VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.head(i).sum()), Scalar(1));
    VERIFY_IS_APPROX(p, v_for_prod.head(i).prod());
    VERIFY_IS_APPROX(minc, v.real().head(i).minCoeff());
    VERIFY_IS_APPROX(maxc, v.real().head(i).maxCoeff());
  }

  for(int i = 0; i < size-1; i++)
  {
    Scalar s(0), p(1);
    RealScalar minc(internal::real(v.coeff(i))), maxc(internal::real(v.coeff(i)));
    for(int j = i; j < size; j++)
    {
      s += v[j];
      p *= v_for_prod[j];
      minc = (std::min)(minc, internal::real(v[j]));
      maxc = (std::max)(maxc, internal::real(v[j]));
    }
    VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.tail(size-i).sum()), Scalar(1));
    VERIFY_IS_APPROX(p, v_for_prod.tail(size-i).prod());
    VERIFY_IS_APPROX(minc, v.real().tail(size-i).minCoeff());
    VERIFY_IS_APPROX(maxc, v.real().tail(size-i).maxCoeff());
  }

  for(int i = 0; i < size/2; i++)
  {
    Scalar s(0), p(1);
    RealScalar minc(internal::real(v.coeff(i))), maxc(internal::real(v.coeff(i)));
    for(int j = i; j < size-i; j++)
    {
      s += v[j];
      p *= v_for_prod[j];
      minc = (std::min)(minc, internal::real(v[j]));
      maxc = (std::max)(maxc, internal::real(v[j]));
    }
    VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.segment(i, size-2*i).sum()), Scalar(1));
    VERIFY_IS_APPROX(p, v_for_prod.segment(i, size-2*i).prod());
    VERIFY_IS_APPROX(minc, v.real().segment(i, size-2*i).minCoeff());
    VERIFY_IS_APPROX(maxc, v.real().segment(i, size-2*i).maxCoeff());
  }
  
  // test empty objects
  VERIFY_IS_APPROX(v.head(0).sum(),   Scalar(0));
  VERIFY_IS_APPROX(v.tail(0).prod(),  Scalar(1));

Lines 35-43 template<typename T> void test_sparselu_ Link Here

(-)a/test/sparselu.cpp (-1 / +1 lines)
35	}	35	}
36		36
37	void test_sparselu()	37	void test_sparselu()
38	{	38	{
39	CALL_SUBTEST_1(test_sparselu_T<float>());	39	CALL_SUBTEST_1(test_sparselu_T<float>());
40	CALL_SUBTEST_2(test_sparselu_T<double>());	40	CALL_SUBTEST_2(test_sparselu_T<double>());
41	CALL_SUBTEST_3(test_sparselu_T<std::complex<float> >());	41	CALL_SUBTEST_3(test_sparselu_T<std::complex<float> >());
42	CALL_SUBTEST_4(test_sparselu_T<std::complex<double> >());	42	CALL_SUBTEST_4(test_sparselu_T<std::complex<double> >());
43	}	43	}




  return x;
}

template<typename MatrixType> void stable_norm(const MatrixType& m)
{
  /* this test covers the following files:
     StableNorm.h
  */
  using std::sqrt;
  typedef typename MatrixType::Index Index;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;

  // Check the basic machine-dependent constants.
  {
    int ibeta, it, iemin, iemax;


  VERIFY_IS_APPROX(vrand.stableNorm(),      vrand.norm());
  VERIFY_IS_APPROX(vrand.blueNorm(),        vrand.norm());
  VERIFY_IS_APPROX(vrand.hypotNorm(),       vrand.norm());

  RealScalar size = static_cast<RealScalar>(m.size());

  // test isFinite
  VERIFY(!isFinite( std::numeric_limits<RealScalar>::infinity()));
  VERIFY(!isFinite(sqrt(-abs(big))));

  // test overflow
  VERIFY(isFinite(sqrt(size)*abs(big)));
  VERIFY_IS_NOT_APPROX(sqrt(copy(vbig.squaredNorm())),   abs(sqrt(size)*big)); // here the default norm must fail
  VERIFY_IS_APPROX(vbig.stableNorm(), sqrt(size)*abs(big));
  VERIFY_IS_APPROX(vbig.blueNorm(),   sqrt(size)*abs(big));
  VERIFY_IS_APPROX(vbig.hypotNorm(),  sqrt(size)*abs(big));

  // test underflow
  VERIFY(isFinite(sqrt(size)*abs(small)));
  VERIFY_IS_NOT_APPROX(sqrt(copy(vsmall.squaredNorm())),   abs(sqrt(size)*small)); // here the default norm must fail
  VERIFY_IS_APPROX(vsmall.stableNorm(), sqrt(size)*abs(small));
  VERIFY_IS_APPROX(vsmall.blueNorm(),   sqrt(size)*abs(small));
  VERIFY_IS_APPROX(vsmall.hypotNorm(),  sqrt(size)*abs(small));

// Test compilation of cwise() version
  VERIFY_IS_APPROX(vrand.colwise().stableNorm(),      vrand.colwise().norm());
  VERIFY_IS_APPROX(vrand.colwise().blueNorm(),        vrand.colwise().norm());
  VERIFY_IS_APPROX(vrand.colwise().hypotNorm(),       vrand.colwise().norm());
  VERIFY_IS_APPROX(vrand.rowwise().stableNorm(),      vrand.rowwise().norm());
  VERIFY_IS_APPROX(vrand.rowwise().blueNorm(),        vrand.rowwise().norm());
  VERIFY_IS_APPROX(vrand.rowwise().hypotNorm(),       vrand.rowwise().norm());




void run_test(int dim, int num_elements)
{
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
  typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> MatrixX;
  typedef Matrix<Scalar, Eigen::Dynamic, 1> VectorX;

  // MUST be positive because in any other case det(cR_t) may become negative for
  // odd dimensions!
  const Scalar c = abs(internal::random<Scalar>());

  MatrixX R = randMatrixSpecialUnitary<Scalar>(dim);
  VectorX t = Scalar(50)*VectorX::Random(dim,1);

  MatrixX cR_t = MatrixX::Identity(dim+1,dim+1);
  cR_t.block(0,0,dim,dim) = c*R;
  cR_t.block(0,dim,dim,1) = t;


  typedef Matrix<Scalar, Dimension+1, Dimension+1> HomMatrix;
  typedef Matrix<Scalar, Dimension, Dimension> FixedMatrix;
  typedef Matrix<Scalar, Dimension, 1> FixedVector;

  const int dim = Dimension;

  // MUST be positive because in any other case det(cR_t) may become negative for
  // odd dimensions!
  const Scalar c = abs(internal::random<Scalar>());

  FixedMatrix R = randMatrixSpecialUnitary<Scalar>(dim);
  FixedVector t = Scalar(50)*FixedVector::Random(dim,1);

  HomMatrix cR_t = HomMatrix::Identity(dim+1,dim+1);
  cR_t.block(0,0,dim,dim) = c*R;
  cR_t.block(0,dim,dim,1) = t;





    inline Scalar squaredNorm() const
    {
      eigen_assert(m_coeffs.w()==Scalar(0));
      return m_coeffs.squaredNorm();
    }

    inline Scalar norm() const
    {
      using std::sqrt;
      return sqrt(squaredNorm());
    }

    inline AlignedVector3 cross(const AlignedVector3& other) const
    {
      return AlignedVector3(m_coeffs.cross3(other.m_coeffs));
    }

    template<typename Derived>




  std::vector<int> m_stageRadix;
  std::vector<int> m_stageRemainder;
  std::vector<Complex> m_scratchBuf;
  bool m_inverse;

  inline
    void make_twiddles(int nfft,bool inverse)
    {
      using std::acos;
      m_inverse = inverse;
      m_twiddles.resize(nfft);
      Scalar phinc =  (inverse?2:-2)* acos( (Scalar) -1)  / nfft;
      for (int i=0;i<nfft;++i)
        m_twiddles[i] = exp( Complex(0,i*phinc) );
    }

  void factorize(int nfft)

        pd.factorize(nfft);
      }
      return pd;
    }

  inline
    Complex * real_twiddles(int ncfft2)
    {
      using std::acos;
      std::vector<Complex> & twidref = m_realTwiddles[ncfft2];// creates new if not there
      if ( (int)twidref.size() != ncfft2 ) {
        twidref.resize(ncfft2);
        int ncfft= ncfft2<<1;
        Scalar pi =  acos( Scalar(-1) );
        for (int k=1;k<=ncfft2;++k) 
          twidref[k-1] = exp( Complex(0,-pi * (Scalar(k) / ncfft + Scalar(.5)) ) );
      }




    PermutationType m_perm; 
    
}; 

template<typename Scalar, int _UpLo, typename OrderingType>
template<typename _MatrixType>
void IncompleteCholesky<Scalar,_UpLo, OrderingType>::factorize(const _MatrixType& mat)
{
  using std::sqrt;
  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first"); 
  
  // FIXME Stability: We should probably compute the scaling factors and the shifts that are needed to ensure a succesful LLT factorization and an efficient preconditioner. 
  
  // Dropping strategies : Keep only the p largest elements per column, where p is the number of elements in the column of the original matrix. Other strategies will be added
  
  // Apply the fill-reducing permutation computed in analyzePattern()
  if (m_perm.rows() == mat.rows() )

     //  p is the original number of elements in the column (without the diagonal)
     int p = colPtr[j+1] - colPtr[j] - 2 ; 
     internal::QuickSplit(curCol, irow, p); 
     if(RealScalar(diag) <= 0) 
     { //FIXME We can use heuristics (Kershaw, 1978 or above reference ) to get a dynamic shift
       m_info = NumericalIssue; 
       return; 
     }
     RealScalar rdiag = sqrt(RealScalar(diag));
     Scalar scal = Scalar(1)/rdiag; 
     vals[colPtr[j]] = rdiag;
     // Insert the largest p elements in the matrix and scale them meanwhile  
     int cpt = 0; 
     for (int i = colPtr[j]+1; i < colPtr[j+1]; i++)
     {
       vals[i] = curCol(cpt) * scal; 
       rowIdx[i] = irow(cpt); 




    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)
    {




  * # The distance between two eigenvalues in different clusters is
  *   more than separation().
  * The implementation follows Algorithm 4.1 in the paper of Davies
  * and Higham. 
  */
template <typename MatrixType, typename AtomicType>
void MatrixFunction<MatrixType,AtomicType,1>::partitionEigenvalues()
{
  using std::abs;
  const Index rows = m_T.rows();
  VectorType diag = m_T.diagonal(); // contains eigenvalues of A

  for (Index i=0; i<rows; ++i) {
    // Find set containing diag(i), adding a new set if necessary
    typename ListOfClusters::iterator qi = findCluster(diag(i));
    if (qi == m_clusters.end()) {
      Cluster l;
      l.push_back(diag(i));
      m_clusters.push_back(l);
      qi = m_clusters.end();
      --qi;
    }

    // Look for other element to add to the set
    for (Index j=i+1; j<rows; ++j) {
      if (abs(diag(j) - diag(i)) <= separation() && std::find(qi->begin(), qi->end(), diag(j)) == qi->end()) {
        typename ListOfClusters::iterator qj = findCluster(diag(j));
        if (qj == m_clusters.end()) {
          qi->push_back(diag(j));
        } else {
          qi->insert(qi->end(), qj->begin(), qj->end());
          m_clusters.erase(qj);
        }
      }
    }
  }
}

/** \brief Find cluster in #m_clusters containing some value 
  * \param[in] key Value to find
  * \returns Iterator to cluster containing \c key, or




  }
}

/** \brief Compute logarithm of triangular matrices with size > 2. 
  * \details This uses a inverse scale-and-square algorithm. */
template <typename MatrixType>
void MatrixLogarithmAtomic<MatrixType>::computeBig(const MatrixType& A, MatrixType& result)
{
  using std::pow;
  int numberOfSquareRoots = 0;
  int numberOfExtraSquareRoots = 0;
  int degree;
  MatrixType T = A;
  const RealScalar maxNormForPade = maxPadeDegree<= 5? 5.3149729967117310e-1:                     // single precision
                                    maxPadeDegree<= 7? 2.6429608311114350e-1:                     // double precision
                                    maxPadeDegree<= 8? 2.32777776523703892094e-1L:                // extended precision
                                    maxPadeDegree<=10? 1.05026503471351080481093652651105e-1L:    // double-double
                                                       1.1880960220216759245467951592883642e-1L;  // quadruple precision

  while (true) {
    RealScalar normTminusI = (T - MatrixType::Identity(T.rows(), T.rows())).cwiseAbs().colwise().sum().maxCoeff();
    if (normTminusI < maxNormForPade) {
      degree = getPadeDegree(normTminusI);
      int degree2 = getPadeDegree(normTminusI / RealScalar(2));
      if ((degree - degree2 <= 1) || (numberOfExtraSquareRoots == 1)) 
        break;
      ++numberOfExtraSquareRoots;
    }
    MatrixType sqrtT;
    MatrixSquareRootTriangular<MatrixType>(T).compute(sqrtT);
    T = sqrtT;
    ++numberOfSquareRoots;
  }





}

// pre:  T is quasi-upper-triangular and sqrtT is a zero matrix of the same size
// post: the diagonal blocks of sqrtT are the square roots of the diagonal blocks of T
template <typename MatrixType>
void MatrixSquareRootQuasiTriangular<MatrixType>::computeDiagonalPartOfSqrt(MatrixType& sqrtT, 
									  const MatrixType& T)
{
  using std::sqrt;
  const Index size = m_A.rows();
  for (Index i = 0; i < size; i++) {
    if (i == size - 1 || T.coeff(i+1, i) == 0) {
      eigen_assert(T(i,i) > 0);
      sqrtT.coeffRef(i,i) = sqrt(T.coeff(i,i));
    }
    else {
      compute2x2diagonalBlock(sqrtT, T, i);
      ++i;
    }
  }
}


 private:
    const MatrixType& m_A;
};

template <typename MatrixType>
template <typename ResultType> 
void MatrixSquareRootTriangular<MatrixType>::compute(ResultType &result)
{
  using std::sqrt;
  // Compute Schur decomposition of m_A
  const ComplexSchur<MatrixType> schurOfA(m_A);  
  const MatrixType& T = schurOfA.matrixT();
  const MatrixType& U = schurOfA.matrixU();

  // Compute square root of T and store it in upper triangular part of result
  // This uses that the square root of triangular matrices can be computed directly.
  result.resize(m_A.rows(), m_A.cols());
  typedef typename MatrixType::Index Index;
  for (Index i = 0; i < m_A.rows(); i++) {
    result.coeffRef(i,i) = sqrt(T.coeff(i,i));
  }
  for (Index j = 1; j < m_A.cols(); j++) {
    for (Index i = j-1; i >= 0; i--) {
      typedef typename MatrixType::Scalar Scalar;
      // if i = j-1, then segment has length 0 so tmp = 0
      Scalar tmp = (result.row(i).segment(i+1,j-i-1) * result.col(j).segment(i+1,j-i-1)).value();
      // denominator may be zero if original matrix is singular
      result.coeffRef(i,j) = (T.coeff(i,j) - tmp) / (result.coeff(i,i) + result.coeff(j,j));





    return LevenbergMarquardtSpace::NotStarted;
}

template<typename FunctorType, typename Scalar>
LevenbergMarquardtSpace::Status
LevenbergMarquardt<FunctorType,Scalar>::minimizeOneStep(FVectorType  &x)
{
    using std::abs;
    assert(x.size()==n); // check the caller is not cheating us

    /* calculate the jacobian matrix. */
    Index df_ret = functor.df(x, fjac);
    if (df_ret<0)
        return LevenbergMarquardtSpace::UserAsked;
    if (df_ret>0)
        // numerical diff, we evaluated the function df_ret times

    wa4.applyOnTheLeft(qrfac.householderQ().adjoint());
    qtf = wa4.head(n);

    /* compute the norm of the scaled gradient. */
    gnorm = 0.;
    if (fnorm != 0.)
        for (Index j = 0; j < n; ++j)
            if (wa2[permutation.indices()[j]] != 0.)
                gnorm = (std::max)(gnorm, abs( fjac.col(j).head(j+1).dot(qtf.head(j+1)/fnorm) / wa2[permutation.indices()[j]]));

    /* test for convergence of the gradient norm. */
    if (gnorm <= parameters.gtol)
        return LevenbergMarquardtSpace::CosinusTooSmall;

    /* rescale if necessary. */
    if (!useExternalScaling)
        diag = diag.cwiseMax(wa2);

            wa2 = diag.cwiseProduct(x);
            fvec = wa4;
            xnorm = wa2.stableNorm();
            fnorm = fnorm1;
            ++iter;
        }

        /* tests for convergence. */
        if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. && delta <= parameters.xtol * xnorm)
            return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
        if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
            return LevenbergMarquardtSpace::RelativeReductionTooSmall;
        if (delta <= parameters.xtol * xnorm)
            return LevenbergMarquardtSpace::RelativeErrorTooSmall;

        /* tests for termination and stringent tolerances. */
        if (nfev >= parameters.maxfev)
            return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
        if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() && Scalar(.5) * ratio <= 1.)
            return LevenbergMarquardtSpace::FtolTooSmall;
        if (delta <= NumTraits<Scalar>::epsilon() * xnorm)
            return LevenbergMarquardtSpace::XtolTooSmall;
        if (gnorm <= NumTraits<Scalar>::epsilon())
            return LevenbergMarquardtSpace::GtolTooSmall;

    } while (ratio < Scalar(1e-4));


            delta = parameters.factor;
    }

    /* compute the norm of the scaled gradient. */
    gnorm = 0.;
    if (fnorm != 0.)
        for (j = 0; j < n; ++j)
            if (wa2[permutation.indices()[j]] != 0.)
                gnorm = (std::max)(gnorm, abs( fjac.col(j).head(j+1).dot(qtf.head(j+1)/fnorm) / wa2[permutation.indices()[j]]));

    /* test for convergence of the gradient norm. */
    if (gnorm <= parameters.gtol)
        return LevenbergMarquardtSpace::CosinusTooSmall;

    /* rescale if necessary. */
    if (!useExternalScaling)
        diag = diag.cwiseMax(wa2);

            wa2 = diag.cwiseProduct(x);
            fvec = wa4;
            xnorm = wa2.stableNorm();
            fnorm = fnorm1;
            ++iter;
        }

        /* tests for convergence. */
        if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. && delta <= parameters.xtol * xnorm)
            return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
        if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
            return LevenbergMarquardtSpace::RelativeReductionTooSmall;
        if (delta <= parameters.xtol * xnorm)
            return LevenbergMarquardtSpace::RelativeErrorTooSmall;

        /* tests for termination and stringent tolerances. */
        if (nfev >= parameters.maxfev)
            return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
        if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() && Scalar(.5) * ratio <= 1.)
            return LevenbergMarquardtSpace::FtolTooSmall;
        if (delta <= NumTraits<Scalar>::epsilon() * xnorm)
            return LevenbergMarquardtSpace::XtolTooSmall;
        if (gnorm <= NumTraits<Scalar>::epsilon())
            return LevenbergMarquardtSpace::GtolTooSmall;

    } while (ratio < Scalar(1e-4));





        ValuesAtCompileTime = Functor::ValuesAtCompileTime
    };

    /**
      * return the number of evaluation of functor
     */
    int df(const InputType& _x, JacobianType &jac) const
    {
        using std::sqrt;
        using std::abs;
        /* Local variables */
        Scalar h;
        int nfev=0;
        const typename InputType::Index n = _x.size();
        const Scalar eps = sqrt(((std::max)(epsfcn,NumTraits<Scalar>::epsilon() )));
        ValueType val1, val2;
        InputType x = _x;
        // TODO : we should do this only if the size is not already known
        val1.resize(Functor::values());
        val2.resize(Functor::values());

        // initialization
        switch(mode) {

                // do nothing
                break;
            default:
                assert(false);
        };

        // Function Body
        for (int j = 0; j < n; ++j) {
            h = eps * abs(x[j]);
            if (h == 0.) {
                h = eps;
            }
            switch(mode) {
                case Forward:
                    x[j] += h;
                    Functor::operator()(x, val2);
                    nfev++;




      return true; }
  }
}


template< typename _Scalar, int _Deg >
void companion<_Scalar,_Deg>::balance()
{
  using std::abs;
  EIGEN_STATIC_ASSERT( Deg == Dynamic || 1 < Deg, YOU_MADE_A_PROGRAMMING_MISTAKE );
  const Index deg   = m_monic.size();
  const Index deg_1 = deg-1;

  bool hasConverged=false;
  while( !hasConverged )
  {
    hasConverged = true;




     * \param[out] bi_seq : the back insertion sequence (stl concept)
     * \param[in]  absImaginaryThreshold : the maximum bound of the imaginary part of a complex
     *  number that is considered as real.
     * */
    template<typename Stl_back_insertion_sequence>
    inline void realRoots( Stl_back_insertion_sequence& bi_seq,
        const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision() ) const
    {
      using std::abs;
      bi_seq.clear();
      for(Index i=0; i<m_roots.size(); ++i )
      {
        if( abs( m_roots[i].imag() ) < absImaginaryThreshold ){
          bi_seq.push_back( m_roots[i].real() ); }
      }
    }

  protected:
    template<typename squaredNormBinaryPredicate>
    inline const RootType& selectComplexRoot_withRespectToNorm( squaredNormBinaryPredicate& pred ) const
    {


  protected:
    template<typename squaredRealPartBinaryPredicate>
    inline const RealScalar& selectRealRoot_withRespectToAbsRealPart(
        squaredRealPartBinaryPredicate& pred,
        bool& hasArealRoot,
        const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision() ) const
    {
      using std::abs;
      hasArealRoot = false;
      Index res=0;
      RealScalar abs2(0);

      for( Index i=0; i<m_roots.size(); ++i )
      {
        if( abs( m_roots[i].imag() ) < absImaginaryThreshold )
        {
          if( !hasArealRoot )
          {
            hasArealRoot = true;
            res = i;
            abs2 = m_roots[i].real() * m_roots[i].real();
          }
          else

            {
              abs2 = currAbs2;
              res = i;
            }
          }
        }
        else
        {
          if( abs( m_roots[i].imag() ) < abs( m_roots[res].imag() ) ){
            res = i; }
        }
      }
      return internal::real_ref(m_roots[res]);
    }


    template<typename RealPartBinaryPredicate>
    inline const RealScalar& selectRealRoot_withRespectToRealPart(
        RealPartBinaryPredicate& pred,
        bool& hasArealRoot,
        const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision() ) const
    {
      using std::abs;
      hasArealRoot = false;
      Index res=0;
      RealScalar val(0);

      for( Index i=0; i<m_roots.size(); ++i )
      {
        if( abs( m_roots[i].imag() ) < absImaginaryThreshold )
        {
          if( !hasArealRoot )
          {
            hasArealRoot = true;
            res = i;
            val = m_roots[i].real();
          }
          else

            {
              val = curr;
              res = i;
            }
          }
        }
        else
        {
          if( abs( m_roots[i].imag() ) < abs( m_roots[res].imag() ) ){
            res = i; }
        }
      }
      return internal::real_ref(m_roots[res]);
    }

  public:
    /**




 *
 *  <i><b>Precondition:</b></i>
 *  <dd> the leading coefficient of the input polynomial poly must be non zero </dd>
 */
template <typename Polynomial>
inline
typename NumTraits<typename Polynomial::Scalar>::Real cauchy_max_bound( const Polynomial& poly )
{
  using std::abs;
  typedef typename Polynomial::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real Real;

  assert( Scalar(0) != poly[poly.size()-1] );
  const Scalar inv_leading_coeff = Scalar(1)/poly[poly.size()-1];
  Real cb(0);

  for( DenseIndex i=0; i<poly.size()-1; ++i ){
    cb += abs(poly[i]*inv_leading_coeff); }
  return cb + Real(1);
}

/** \ingroup Polynomials_Module
 * \returns a minimum bound for the absolute value of any non zero root of the polynomial.
 * \param[in] poly : the vector of coefficients of the polynomial ordered
 *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
 *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
 */
template <typename Polynomial>
inline
typename NumTraits<typename Polynomial::Scalar>::Real cauchy_min_bound( const Polynomial& poly )
{
  using std::abs;
  typedef typename Polynomial::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real Real;

  DenseIndex i=0;
  while( i<poly.size()-1 && Scalar(0) == poly(i) ){ ++i; }
  if( poly.size()-1 == i ){
    return Real(1); }

  const Scalar inv_min_coeff = Scalar(1)/poly[i];
  Real cb(1);
  for( DenseIndex j=i+1; j<poly.size(); ++j ){
    cb += abs(poly[j]*inv_min_coeff); }
  return Real(1)/cb;
}

/** \ingroup Polynomials_Module
 * Given the roots of a polynomial compute the coefficients in the
 * monomial basis of the monic polynomial with same roots and minimal degree.
 * If RootVector is a vector of complexes, Polynomial should also be a vector
 * of complexes.




#include "main.h"
#include <Eigen/MPRealSupport>
#include <Eigen/LU>
#include <Eigen/Eigenvalues>
#include <sstream>

using namespace mpfr;
using namespace std;
using namespace Eigen;

void test_mpreal_support()
{
  // set precision to 256 bits (double has only 53 bits)
  mpreal::set_default_prec(256);
  typedef Matrix<mpreal,Eigen::Dynamic,Eigen::Dynamic> MatrixXmp;





}




template< int Deg, typename POLYNOMIAL, typename ROOTS, typename REAL_ROOTS >
void evalSolverSugarFunction( const POLYNOMIAL& pols, const ROOTS& roots, const REAL_ROOTS& real_roots )
{
  using std::sqrt;
  typedef typename POLYNOMIAL::Scalar Scalar;

  typedef PolynomialSolver<Scalar, Deg >              PolynomialSolverType;

  PolynomialSolverType psolve;
  if( aux_evalSolver<Deg, POLYNOMIAL, PolynomialSolverType>( pols, psolve ) )
  {
    //It is supposed that

    typedef typename PolynomialSolverType::RootsType    RootsType;
    typedef Matrix<Scalar,Deg,1>                        EvalRootsType;

    //Test realRoots
    std::vector< Real > calc_realRoots;
    psolve.realRoots( calc_realRoots );
    VERIFY( calc_realRoots.size() == (size_t)real_roots.size() );

    const Scalar psPrec = sqrt( test_precision<Scalar>() );

    for( size_t i=0; i<calc_realRoots.size(); ++i )
    {
      bool found = false;
      for( size_t j=0; j<calc_realRoots.size()&& !found; ++j )
      {
        if( internal::isApprox( calc_realRoots[i], real_roots[j] ), psPrec ){
          found = true; }
      }
      VERIFY( found );
    }

    //Test greatestRoot
    VERIFY( internal::isApprox( roots.array().abs().maxCoeff(),
          abs( psolve.greatestRoot() ), psPrec ) );

    //Test smallestRoot
    VERIFY( internal::isApprox( roots.array().abs().minCoeff(),
          abs( psolve.smallestRoot() ), psPrec ) );

    bool hasRealRoot;
    //Test absGreatestRealRoot
    Real r = psolve.absGreatestRealRoot( hasRealRoot );
    VERIFY( hasRealRoot == (real_roots.size() > 0 ) );
    if( hasRealRoot ){
      VERIFY( internal::isApprox( real_roots.array().abs().maxCoeff(), abs(r), psPrec ) );  }

    //Test absSmallestRealRoot
    r = psolve.absSmallestRealRoot( hasRealRoot );
    VERIFY( hasRealRoot == (real_roots.size() > 0 ) );
    if( hasRealRoot ){
      VERIFY( internal::isApprox( real_roots.array().abs().minCoeff(), abs( r ), psPrec ) ); }

    //Test greatestRealRoot
    r = psolve.greatestRealRoot( hasRealRoot );
    VERIFY( hasRealRoot == (real_roots.size() > 0 ) );
    if( hasRealRoot ){
      VERIFY( internal::isApprox( real_roots.array().maxCoeff(), r, psPrec ) ); }

    //Test smallestRealRoot

Return to bug 314

Lines 243-258 namespace internal { Link Here

(-)a/Eigen/src/Cholesky/LDLT.h (+1 lines)
243		243
244	template<int UpLo> struct ldlt_inplace;	244	template<int UpLo> struct ldlt_inplace;
245		245
246	template<> struct ldlt_inplace<Lower>	246	template<> struct ldlt_inplace<Lower>
247	{	247	{
248	template<typename MatrixType, typename TranspositionType, typename Workspace>	248	template<typename MatrixType, typename TranspositionType, typename Workspace>
249	static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, int* sign=0)	249	static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, int* sign=0)
250	{	250	{
		251	using std::abs;
251	typedef typename MatrixType::Scalar Scalar;	252	typedef typename MatrixType::Scalar Scalar;
252	typedef typename MatrixType::RealScalar RealScalar;	253	typedef typename MatrixType::RealScalar RealScalar;
253	typedef typename MatrixType::Index Index;	254	typedef typename MatrixType::Index Index;
254	eigen_assert(mat.rows()==mat.cols());	255	eigen_assert(mat.rows()==mat.cols());
255	const Index size = mat.rows();	256	const Index size = mat.rows();
256		257
257	if (size <= 1)	258	if (size <= 1)
258	{	259	{

Lines 119-135 EIGEN_STRONG_INLINE typename NumTraits<t Link Here

(-)a/Eigen/src/Core/Dot.h (-1 / +2 lines)
119	* In both cases, it consists in the square root of the sum of the square of all the matrix entries.	119	* In both cases, it consists in the square root of the sum of the square of all the matrix entries.
120	* For vectors, this is also equals to the square root of the dot product of \c *this with itself.	120	* For vectors, this is also equals to the square root of the dot product of \c *this with itself.
121	*	121	*
122	* \sa dot(), squaredNorm()	122	* \sa dot(), squaredNorm()
123	*/	123	*/
124	template<typename Derived>	124	template<typename Derived>
125	inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm() const	125	inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm() const
126	{	126	{
127	return internal::sqrt(squaredNorm());	127	using std::sqrt;
		128	return sqrt(squaredNorm());
128	}	129	}
129		130
130	/** \returns an expression of the quotient of *this by its own norm.	131	/** \returns an expression of the quotient of *this by its own norm.
131	*	132	*
132	* \only_for_vectors	133	* \only_for_vectors
133	*	134	*
134	* \sa norm(), normalize()	135	* \sa norm(), normalize()
135	*/	136	*/

Lines 246-288 struct conj_retval Link Here

(-)a/Eigen/src/Core/MathFunctions.h (-142 lines)
246		246
247	template<typename Scalar>	247	template<typename Scalar>
248	inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)	248	inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)
249	{	249	{
250	return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);	250	return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
251	}	251	}
252		252
253	/****************************************************************************	253	/****************************************************************************
254	* Implementation of abs *
255	****************************************************************************/
256
257	template<typename Scalar>
258	struct abs_impl
259	{
260	typedef typename NumTraits<Scalar>::Real RealScalar;
261	static inline RealScalar run(const Scalar& x)
262	{
263	using std::abs;
264	return abs(x);
265	}
266	};
267
268	template<typename Scalar>
269	struct abs_retval
270	{
271	typedef typename NumTraits<Scalar>::Real type;
272	};
273
274	template<typename Scalar>
275	inline EIGEN_MATHFUNC_RETVAL(abs, Scalar) abs(const Scalar& x)
276	{
277	return EIGEN_MATHFUNC_IMPL(abs, Scalar)::run(x);
278	}
279
280	/****************************************************************************
281	* Implementation of abs2 *	254	* Implementation of abs2 *
282	****************************************************************************/	255	****************************************************************************/
283		256
284	template<typename Scalar>	257	template<typename Scalar>
285	struct abs2_impl	258	struct abs2_impl
286	{	259	{
287	typedef typename NumTraits<Scalar>::Real RealScalar;	260	typedef typename NumTraits<Scalar>::Real RealScalar;
288	static inline RealScalar run(const Scalar& x)	261	static inline RealScalar run(const Scalar& x)
Lines 400-530 struct cast_impl Link Here
400		373
401	template<typename OldType, typename NewType>	374	template<typename OldType, typename NewType>
402	inline NewType cast(const OldType& x)	375	inline NewType cast(const OldType& x)
403	{	376	{
404	return cast_impl<OldType, NewType>::run(x);	377	return cast_impl<OldType, NewType>::run(x);
405	}	378	}
406		379
407	/****************************************************************************	380	/****************************************************************************
408	* Implementation of sqrt *
409	****************************************************************************/
410
411	template<typename Scalar, bool IsInteger>
412	struct sqrt_default_impl
413	{
414	static inline Scalar run(const Scalar& x)
415	{
416	using std::sqrt;
417	return sqrt(x);
418	}
419	};
420
421	template<typename Scalar>
422	struct sqrt_default_impl<Scalar, true>
423	{
424	static inline Scalar run(const Scalar&)
425	{
426	#ifdef EIGEN2_SUPPORT
427	eigen_assert(!NumTraits<Scalar>::IsInteger);
428	#else
429	EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
430	#endif
431	return Scalar(0);
432	}
433	};
434
435	template<typename Scalar>
436	struct sqrt_impl : sqrt_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {};
437
438	template<typename Scalar>
439	struct sqrt_retval
440	{
441	typedef Scalar type;
442	};
443
444	template<typename Scalar>
445	inline EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(const Scalar& x)
446	{
447	return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x);
448	}
449
450	/****************************************************************************
451	* Implementation of standard unary real functions (exp, log, sin, cos, ... *
452	****************************************************************************/
453
454	// This macro instanciate all the necessary template mechanism which is common to all unary real functions.
455	#define EIGEN_MATHFUNC_STANDARD_REAL_UNARY(NAME) \
456	template<typename Scalar, bool IsInteger> struct NAME##_default_impl { \
457	static inline Scalar run(const Scalar& x) { using std::NAME; return NAME(x); } \
458	}; \
459	template<typename Scalar> struct NAME##_default_impl<Scalar, true> { \
460	static inline Scalar run(const Scalar&) { \
461	EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar) \
462	return Scalar(0); \
463	} \
464	}; \
465	template<typename Scalar> struct NAME##_impl \
466	: NAME##_default_impl<Scalar, NumTraits<Scalar>::IsInteger> \
467	{}; \
468	template<typename Scalar> struct NAME##_retval { typedef Scalar type; }; \
469	template<typename Scalar> \
470	inline EIGEN_MATHFUNC_RETVAL(NAME, Scalar) NAME(const Scalar& x) { \
471	return EIGEN_MATHFUNC_IMPL(NAME, Scalar)::run(x); \
472	}
473
474	EIGEN_MATHFUNC_STANDARD_REAL_UNARY(exp)
475	EIGEN_MATHFUNC_STANDARD_REAL_UNARY(log)
476	EIGEN_MATHFUNC_STANDARD_REAL_UNARY(sin)
477	EIGEN_MATHFUNC_STANDARD_REAL_UNARY(cos)
478	EIGEN_MATHFUNC_STANDARD_REAL_UNARY(tan)
479	EIGEN_MATHFUNC_STANDARD_REAL_UNARY(asin)
480	EIGEN_MATHFUNC_STANDARD_REAL_UNARY(acos)
481
482	/****************************************************************************
483	* Implementation of atan2 *
484	****************************************************************************/
485
486	template<typename Scalar, bool IsInteger>
487	struct atan2_default_impl
488	{
489	typedef Scalar retval;
490	static inline Scalar run(const Scalar& x, const Scalar& y)
491	{
492	using std::atan2;
493	return atan2(x, y);
494	}
495	};
496
497	template<typename Scalar>
498	struct atan2_default_impl<Scalar, true>
499	{
500	static inline Scalar run(const Scalar&, const Scalar&)
501	{
502	EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
503	return Scalar(0);
504	}
505	};
506
507	template<typename Scalar>
508	struct atan2_impl : atan2_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {};
509
510	template<typename Scalar>
511	struct atan2_retval
512	{
513	typedef Scalar type;
514	};
515
516	template<typename Scalar>
517	inline EIGEN_MATHFUNC_RETVAL(atan2, Scalar) atan2(const Scalar& x, const Scalar& y)
518	{
519	return EIGEN_MATHFUNC_IMPL(atan2, Scalar)::run(x, y);
520	}
521
522	/****************************************************************************
523	* Implementation of atanh2 *	381	* Implementation of atanh2 *
524	****************************************************************************/	382	****************************************************************************/
525		383
526	template<typename Scalar, bool IsInteger>	384	template<typename Scalar, bool IsInteger>
527	struct atanh2_default_impl	385	struct atanh2_default_impl
528	{	386	{
529	typedef Scalar retval;	387	typedef Scalar retval;
530	typedef typename NumTraits<Scalar>::Real RealScalar;	388	typedef typename NumTraits<Scalar>::Real RealScalar;

Lines 185-200 template<typename _MatrixType, int _UpLo Link Here

(-)a/Eigen/src/Cholesky/LLT.h (+2 lines)
185		185
186	namespace internal {	186	namespace internal {
187		187
188	template<typename Scalar, int UpLo> struct llt_inplace;	188	template<typename Scalar, int UpLo> struct llt_inplace;
189		189
190	template<typename MatrixType, typename VectorType>	190	template<typename MatrixType, typename VectorType>
191	static typename MatrixType::Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)	191	static typename MatrixType::Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
192	{	192	{
		193	using std::sqrt;
193	typedef typename MatrixType::Scalar Scalar;	194	typedef typename MatrixType::Scalar Scalar;
194	typedef typename MatrixType::RealScalar RealScalar;	195	typedef typename MatrixType::RealScalar RealScalar;
195	typedef typename MatrixType::Index Index;	196	typedef typename MatrixType::Index Index;
196	typedef typename MatrixType::ColXpr ColXpr;	197	typedef typename MatrixType::ColXpr ColXpr;
197	typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;	198	typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
198	typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;	199	typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
199	typedef Matrix<Scalar,Dynamic,1> TempVectorType;	200	typedef Matrix<Scalar,Dynamic,1> TempVectorType;
200	typedef typename TempVectorType::SegmentReturnType TempVecSegment;	201	typedef typename TempVectorType::SegmentReturnType TempVecSegment;
Lines 258-273 static typename MatrixType::Index llt_ra Link Here
258	}	259	}
259		260
260	template<typename Scalar> struct llt_inplace<Scalar, Lower>	261	template<typename Scalar> struct llt_inplace<Scalar, Lower>
261	{	262	{
262	typedef typename NumTraits<Scalar>::Real RealScalar;	263	typedef typename NumTraits<Scalar>::Real RealScalar;
263	template<typename MatrixType>	264	template<typename MatrixType>
264	static typename MatrixType::Index unblocked(MatrixType& mat)	265	static typename MatrixType::Index unblocked(MatrixType& mat)
265	{	266	{
		267	using std::sqrt;
266	typedef typename MatrixType::Index Index;	268	typedef typename MatrixType::Index Index;
267		269
268	eigen_assert(mat.rows()==mat.cols());	270	eigen_assert(mat.rows()==mat.cols());
269	const Index size = mat.rows();	271	const Index size = mat.rows();
270	for(Index k = 0; k < size; ++k)	272	for(Index k = 0; k < size; ++k)
271	{	273	{
272	Index rs = size-k-1; // remaining size	274	Index rs = size-k-1; // remaining size
273		275

Lines 281-301 MatrixBase<Derived>::asDiagonal() const Link Here

(-)a/Eigen/src/Core/DiagonalMatrix.h (-1 / +2 lines)
281	* Example: \include MatrixBase_isDiagonal.cpp	281	* Example: \include MatrixBase_isDiagonal.cpp
282	* Output: \verbinclude MatrixBase_isDiagonal.out	282	* Output: \verbinclude MatrixBase_isDiagonal.out
283	*	283	*
284	* \sa asDiagonal()	284	* \sa asDiagonal()
285	*/	285	*/
286	template<typename Derived>	286	template<typename Derived>
287	bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const	287	bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const
288	{	288	{
		289	using std::abs;
289	if(cols() != rows()) return false;	290	if(cols() != rows()) return false;
290	RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);	291	RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);
291	for(Index j = 0; j < cols(); ++j)	292	for(Index j = 0; j < cols(); ++j)
292	{	293	{
293	RealScalar absOnDiagonal = internal::abs(coeff(j,j));	294	RealScalar absOnDiagonal = abs(coeff(j,j));
294	if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;	295	if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;
295	}	296	}
296	for(Index j = 0; j < cols(); ++j)	297	for(Index j = 0; j < cols(); ++j)
297	for(Index i = 0; i < j; ++i)	298	for(Index i = 0; i < j; ++i)
298	{	299	{
299	if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;	300	if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;
300	if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;	301	if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;
301	}	302	}

Lines 282-298 struct functor_traits<scalar_opposite_op Link Here

(-)a/Eigen/src/Core/Functors.h (-9 / +9 lines)
282	/** \internal	282	/** \internal
283	* \brief Template functor to compute the absolute value of a scalar	283	* \brief Template functor to compute the absolute value of a scalar
284	*	284	*
285	* \sa class CwiseUnaryOp, Cwise::abs	285	* \sa class CwiseUnaryOp, Cwise::abs
286	*/	286	*/
287	template<typename Scalar> struct scalar_abs_op {	287	template<typename Scalar> struct scalar_abs_op {
288	EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)	288	EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
289	typedef typename NumTraits<Scalar>::Real result_type;	289	typedef typename NumTraits<Scalar>::Real result_type;
290	EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return internal::abs(a); }	290	EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { using std::abs; return abs(a); }
291	template<typename Packet>	291	template<typename Packet>
292	EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const	292	EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
293	{ return internal::pabs(a); }	293	{ return internal::pabs(a); }
294	};	294	};
295	template<typename Scalar>	295	template<typename Scalar>
296	struct functor_traits<scalar_abs_op<Scalar> >	296	struct functor_traits<scalar_abs_op<Scalar> >
297	{	297	{
298	enum {	298	enum {
Lines 416-448 struct functor_traits<scalar_imag_ref_op Link Here
416	/** \internal	416	/** \internal
417	*	417	*
418	* \brief Template functor to compute the exponential of a scalar	418	* \brief Template functor to compute the exponential of a scalar
419	*	419	*
420	* \sa class CwiseUnaryOp, Cwise::exp()	420	* \sa class CwiseUnaryOp, Cwise::exp()
421	*/	421	*/
422	template<typename Scalar> struct scalar_exp_op {	422	template<typename Scalar> struct scalar_exp_op {
423	EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)	423	EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
424	inline const Scalar operator() (const Scalar& a) const { return internal::exp(a); }	424	inline const Scalar operator() (const Scalar& a) const { using std::exp; return exp(a); }
425	typedef typename packet_traits<Scalar>::type Packet;	425	typedef typename packet_traits<Scalar>::type Packet;
426	inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }	426	inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
427	};	427	};
428	template<typename Scalar>	428	template<typename Scalar>
429	struct functor_traits<scalar_exp_op<Scalar> >	429	struct functor_traits<scalar_exp_op<Scalar> >
430	{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasExp }; };	430	{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasExp }; };
431		431
432	/** \internal	432	/** \internal
433	*	433	*
434	* \brief Template functor to compute the logarithm of a scalar	434	* \brief Template functor to compute the logarithm of a scalar
435	*	435	*
436	* \sa class CwiseUnaryOp, Cwise::log()	436	* \sa class CwiseUnaryOp, Cwise::log()
437	*/	437	*/
438	template<typename Scalar> struct scalar_log_op {	438	template<typename Scalar> struct scalar_log_op {
439	EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)	439	EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
440	inline const Scalar operator() (const Scalar& a) const { return internal::log(a); }	440	inline const Scalar operator() (const Scalar& a) const { using std::log; return log(a); }
441	typedef typename packet_traits<Scalar>::type Packet;	441	typedef typename packet_traits<Scalar>::type Packet;
442	inline Packet packetOp(const Packet& a) const { return internal::plog(a); }	442	inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
443	};	443	};
444	template<typename Scalar>	444	template<typename Scalar>
445	struct functor_traits<scalar_log_op<Scalar> >	445	struct functor_traits<scalar_log_op<Scalar> >
446	{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; };	446	{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; };
447		447
448	/** \internal	448	/** \internal
Lines 669-685 struct functor_traits<scalar_add_op<Scal Link Here
669	{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAdd }; };	669	{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAdd }; };
670		670
671	/** \internal	671	/** \internal
672	* \brief Template functor to compute the square root of a scalar	672	* \brief Template functor to compute the square root of a scalar
673	* \sa class CwiseUnaryOp, Cwise::sqrt()	673	* \sa class CwiseUnaryOp, Cwise::sqrt()
674	*/	674	*/
675	template<typename Scalar> struct scalar_sqrt_op {	675	template<typename Scalar> struct scalar_sqrt_op {
676	EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)	676	EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
677	inline const Scalar operator() (const Scalar& a) const { return internal::sqrt(a); }	677	inline const Scalar operator() (const Scalar& a) const { using std::sqrt; return sqrt(a); }
678	typedef typename packet_traits<Scalar>::type Packet;	678	typedef typename packet_traits<Scalar>::type Packet;
679	inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }	679	inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
680	};	680	};
681	template<typename Scalar>	681	template<typename Scalar>
682	struct functor_traits<scalar_sqrt_op<Scalar> >	682	struct functor_traits<scalar_sqrt_op<Scalar> >
683	{ enum {	683	{ enum {
684	Cost = 5 * NumTraits<Scalar>::MulCost,	684	Cost = 5 * NumTraits<Scalar>::MulCost,
685	PacketAccess = packet_traits<Scalar>::HasSqrt	685	PacketAccess = packet_traits<Scalar>::HasSqrt
Lines 687-703 struct functor_traits<scalar_sqrt_op<Sca Link Here
687	};	687	};
688		688
689	/** \internal	689	/** \internal
690	* \brief Template functor to compute the cosine of a scalar	690	* \brief Template functor to compute the cosine of a scalar
691	* \sa class CwiseUnaryOp, ArrayBase::cos()	691	* \sa class CwiseUnaryOp, ArrayBase::cos()
692	*/	692	*/
693	template<typename Scalar> struct scalar_cos_op {	693	template<typename Scalar> struct scalar_cos_op {
694	EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)	694	EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
695	inline Scalar operator() (const Scalar& a) const { return internal::cos(a); }	695	inline Scalar operator() (const Scalar& a) const { using std::cos; return cos(a); }
696	typedef typename packet_traits<Scalar>::type Packet;	696	typedef typename packet_traits<Scalar>::type Packet;
697	inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }	697	inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
698	};	698	};
699	template<typename Scalar>	699	template<typename Scalar>
700	struct functor_traits<scalar_cos_op<Scalar> >	700	struct functor_traits<scalar_cos_op<Scalar> >
701	{	701	{
702	enum {	702	enum {
703	Cost = 5 * NumTraits<Scalar>::MulCost,	703	Cost = 5 * NumTraits<Scalar>::MulCost,
Lines 706-722 struct functor_traits<scalar_cos_op<Scal Link Here
706	};	706	};
707		707
708	/** \internal	708	/** \internal
709	* \brief Template functor to compute the sine of a scalar	709	* \brief Template functor to compute the sine of a scalar
710	* \sa class CwiseUnaryOp, ArrayBase::sin()	710	* \sa class CwiseUnaryOp, ArrayBase::sin()
711	*/	711	*/
712	template<typename Scalar> struct scalar_sin_op {	712	template<typename Scalar> struct scalar_sin_op {
713	EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)	713	EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
714	inline const Scalar operator() (const Scalar& a) const { return internal::sin(a); }	714	inline const Scalar operator() (const Scalar& a) const { using std::sin; return sin(a); }
715	typedef typename packet_traits<Scalar>::type Packet;	715	typedef typename packet_traits<Scalar>::type Packet;
716	inline Packet packetOp(const Packet& a) const { return internal::psin(a); }	716	inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
717	};	717	};
718	template<typename Scalar>	718	template<typename Scalar>
719	struct functor_traits<scalar_sin_op<Scalar> >	719	struct functor_traits<scalar_sin_op<Scalar> >
720	{	720	{
721	enum {	721	enum {
722	Cost = 5 * NumTraits<Scalar>::MulCost,	722	Cost = 5 * NumTraits<Scalar>::MulCost,
Lines 726-742 struct functor_traits<scalar_sin_op<Scal Link Here
726		726
727		727
728	/** \internal	728	/** \internal
729	* \brief Template functor to compute the tan of a scalar	729	* \brief Template functor to compute the tan of a scalar
730	* \sa class CwiseUnaryOp, ArrayBase::tan()	730	* \sa class CwiseUnaryOp, ArrayBase::tan()
731	*/	731	*/
732	template<typename Scalar> struct scalar_tan_op {	732	template<typename Scalar> struct scalar_tan_op {
733	EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)	733	EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
734	inline const Scalar operator() (const Scalar& a) const { return internal::tan(a); }	734	inline const Scalar operator() (const Scalar& a) const { using std::tan; return tan(a); }
735	typedef typename packet_traits<Scalar>::type Packet;	735	typedef typename packet_traits<Scalar>::type Packet;
736	inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }	736	inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
737	};	737	};
738	template<typename Scalar>	738	template<typename Scalar>
739	struct functor_traits<scalar_tan_op<Scalar> >	739	struct functor_traits<scalar_tan_op<Scalar> >
740	{	740	{
741	enum {	741	enum {
742	Cost = 5 * NumTraits<Scalar>::MulCost,	742	Cost = 5 * NumTraits<Scalar>::MulCost,
Lines 745-761 struct functor_traits<scalar_tan_op<Scal Link Here
745	};	745	};
746		746
747	/** \internal	747	/** \internal
748	* \brief Template functor to compute the arc cosine of a scalar	748	* \brief Template functor to compute the arc cosine of a scalar
749	* \sa class CwiseUnaryOp, ArrayBase::acos()	749	* \sa class CwiseUnaryOp, ArrayBase::acos()
750	*/	750	*/
751	template<typename Scalar> struct scalar_acos_op {	751	template<typename Scalar> struct scalar_acos_op {
752	EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)	752	EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
753	inline const Scalar operator() (const Scalar& a) const { return internal::acos(a); }	753	inline const Scalar operator() (const Scalar& a) const { using std::acos; return acos(a); }
754	typedef typename packet_traits<Scalar>::type Packet;	754	typedef typename packet_traits<Scalar>::type Packet;
755	inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }	755	inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
756	};	756	};
757	template<typename Scalar>	757	template<typename Scalar>
758	struct functor_traits<scalar_acos_op<Scalar> >	758	struct functor_traits<scalar_acos_op<Scalar> >
759	{	759	{
760	enum {	760	enum {
761	Cost = 5 * NumTraits<Scalar>::MulCost,	761	Cost = 5 * NumTraits<Scalar>::MulCost,
Lines 764-780 struct functor_traits<scalar_acos_op<Sca Link Here
764	};	764	};
765		765
766	/** \internal	766	/** \internal
767	* \brief Template functor to compute the arc sine of a scalar	767	* \brief Template functor to compute the arc sine of a scalar
768	* \sa class CwiseUnaryOp, ArrayBase::asin()	768	* \sa class CwiseUnaryOp, ArrayBase::asin()
769	*/	769	*/
770	template<typename Scalar> struct scalar_asin_op {	770	template<typename Scalar> struct scalar_asin_op {
771	EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)	771	EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
772	inline const Scalar operator() (const Scalar& a) const { return internal::asin(a); }	772	inline const Scalar operator() (const Scalar& a) const { using std::asin; return asin(a); }
773	typedef typename packet_traits<Scalar>::type Packet;	773	typedef typename packet_traits<Scalar>::type Packet;
774	inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }	774	inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
775	};	775	};
776	template<typename Scalar>	776	template<typename Scalar>
777	struct functor_traits<scalar_asin_op<Scalar> >	777	struct functor_traits<scalar_asin_op<Scalar> >
778	{	778	{
779	enum {	779	enum {
780	Cost = 5 * NumTraits<Scalar>::MulCost,	780	Cost = 5 * NumTraits<Scalar>::MulCost,

Lines 1-22 Link Here

(-)a/Eigen/src/Core/GlobalFunctions.h (-28 / +16 lines)
1	// This file is part of Eigen, a lightweight C++ template library	1	// This file is part of Eigen, a lightweight C++ template library
2	// for linear algebra.	2	// for linear algebra.
3	//	3	//
4	// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>	4	// Copyright (C) 2010-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
5	// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>	5	// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
6	//	6	//
7	// This Source Code Form is subject to the terms of the Mozilla	7	// This Source Code Form is subject to the terms of the Mozilla
8	// Public License v. 2.0. If a copy of the MPL was not distributed	8	// Public License v. 2.0. If a copy of the MPL was not distributed
9	// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.	9	// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10		10
11	#ifndef EIGEN_GLOBAL_FUNCTIONS_H	11	#ifndef EIGEN_GLOBAL_FUNCTIONS_H
12	#define EIGEN_GLOBAL_FUNCTIONS_H	12	#define EIGEN_GLOBAL_FUNCTIONS_H
13		13
14	#define EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(NAME,FUNCTOR) \	14	#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR) \
15	template<typename Derived> \	15	template<typename Derived> \
16	inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \	16	inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
17	NAME(const Eigen::ArrayBase<Derived>& x) { \	17	NAME(const Eigen::ArrayBase<Derived>& x) { \
18	return x.derived(); \	18	return x.derived(); \
19	}	19	}
20		20
21	#define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \	21	#define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \
22	\	22	\
Lines 30-78 Link Here
30	{ \	30	{ \
31	static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) \	31	static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) \
32	{ \	32	{ \
33	return x.derived(); \	33	return x.derived(); \
34	} \	34	} \
35	};	35	};
36		36
37		37
38	namespace std	38	namespace Eigen
39	{	39	{
40	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(real,scalar_real_op)	40	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(real,scalar_real_op)
41	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(imag,scalar_imag_op)	41	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(imag,scalar_imag_op)
42	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sin,scalar_sin_op)	42	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sin,scalar_sin_op)
43	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(cos,scalar_cos_op)	43	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cos,scalar_cos_op)
44	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(asin,scalar_asin_op)	44	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asin,scalar_asin_op)
45	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(acos,scalar_acos_op)	45	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos,scalar_acos_op)
46	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(tan,scalar_tan_op)	46	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tan,scalar_tan_op)
47	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(exp,scalar_exp_op)	47	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(exp,scalar_exp_op)
48	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(log,scalar_log_op)	48	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log,scalar_log_op)
49	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(abs,scalar_abs_op)	49	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs,scalar_abs_op)
50	EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sqrt,scalar_sqrt_op)	50	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sqrt,scalar_sqrt_op)
51		51
52	template<typename Derived>	52	template<typename Derived>
53	inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar>, const Derived>	53	inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar>, const Derived>
54	pow(const Eigen::ArrayBase<Derived>& x, const typename Derived::Scalar& exponent) {	54	pow(const Eigen::ArrayBase<Derived>& x, const typename Derived::Scalar& exponent) {
55	return x.derived().pow(exponent);	55	return x.derived().pow(exponent);
56	}	56	}
57		57
58	template<typename Derived>	58	template<typename Derived>
59	inline const Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const Derived, const Derived>	59	inline const Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const Derived, const Derived>
60	pow(const Eigen::ArrayBase<Derived>& x, const Eigen::ArrayBase<Derived>& exponents)	60	pow(const Eigen::ArrayBase<Derived>& x, const Eigen::ArrayBase<Derived>& exponents)
61	{	61	{
62	return Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const Derived, const Derived>(	62	return Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const Derived, const Derived>(
63	x.derived(),	63	x.derived(),
64	exponents.derived()	64	exponents.derived()
65	);	65	);
66	}	66	}
67	}	67
68
69	namespace Eigen
70	{
71	/**	68	/**
72	* \brief Component-wise division of a scalar by array elements.	69	* \brief Component-wise division of a scalar by array elements.
73	**/	70	**/
74	template <typename Derived>	71	template <typename Derived>
75	inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived>	72	inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived>
76	operator/(typename Derived::Scalar s, const Eigen::ArrayBase<Derived>& a)	73	operator/(typename Derived::Scalar s, const Eigen::ArrayBase<Derived>& a)
77	{	74	{
78	return Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived>(	75	return Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived>(
Lines 80-103 namespace Eigen Link Here
80	Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>(s)	77	Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>(s)
81	);	78	);
82	}	79	}
83		80
84	namespace internal	81	namespace internal
85	{	82	{
86	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op)	83	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op)
87	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op)	84	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op)
88	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sin,scalar_sin_op)
89	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(cos,scalar_cos_op)
90	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(asin,scalar_asin_op)
91	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(acos,scalar_acos_op)
92	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(tan,scalar_tan_op)
93	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(exp,scalar_exp_op)
94	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(log,scalar_log_op)
95	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs,scalar_abs_op)
96	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op)	85	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op)
97	EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sqrt,scalar_sqrt_op)
98	}	86	}
99	}	87	}
100		88
101	// TODO: cleanly disable those functions that are not supported on Array (internal::real_ref, internal::random, internal::isApprox...)	89	// TODO: cleanly disable those functions that are not supported on Array (internal::real_ref, internal::random, internal::isApprox...)
102		90
103	#endif // EIGEN_GLOBAL_FUNCTIONS_H	91	#endif // EIGEN_GLOBAL_FUNCTIONS_H

Lines 39-68 inline void stable_norm_kernel(const Exp Link Here

(-)a/Eigen/src/Core/StableNorm.h (-10 / +13 lines)
39	*	39	*
40	* \sa norm(), blueNorm(), hypotNorm()	40	* \sa norm(), blueNorm(), hypotNorm()
41	*/	41	*/
42	template<typename Derived>	42	template<typename Derived>
43	inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real	43	inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
44	MatrixBase<Derived>::stableNorm() const	44	MatrixBase<Derived>::stableNorm() const
45	{	45	{
46	using std::min;	46	using std::min;
		47	using std::sqrt;
47	const Index blockSize = 4096;	48	const Index blockSize = 4096;
48	RealScalar scale(0);	49	RealScalar scale(0);
49	RealScalar invScale(1);	50	RealScalar invScale(1);
50	RealScalar ssq(0); // sum of square	51	RealScalar ssq(0); // sum of square
51	enum {	52	enum {
52	Alignment = (int(Flags)&DirectAccessBit) \|\| (int(Flags)&AlignedBit) ? 1 : 0	53	Alignment = (int(Flags)&DirectAccessBit) \|\| (int(Flags)&AlignedBit) ? 1 : 0
53	};	54	};
54	Index n = size();	55	Index n = size();
55	Index bi = internal::first_aligned(derived());	56	Index bi = internal::first_aligned(derived());
56	if (bi>0)	57	if (bi>0)
57	internal::stable_norm_kernel(this->head(bi), ssq, scale, invScale);	58	internal::stable_norm_kernel(this->head(bi), ssq, scale, invScale);
58	for (; bi<n; bi+=blockSize)	59	for (; bi<n; bi+=blockSize)
59	internal::stable_norm_kernel(this->segment(bi,(min)(blockSize, n - bi)).template forceAlignedAccessIf<Alignment>(), ssq, scale, invScale);	60	internal::stable_norm_kernel(this->segment(bi,(min)(blockSize, n - bi)).template forceAlignedAccessIf<Alignment>(), ssq, scale, invScale);
60	return scale * internal::sqrt(ssq);	61	return scale * sqrt(ssq);
61	}	62	}
62		63
63	/** \returns the \em l2 norm of \c *this using the Blue's algorithm.	64	/** \returns the \em l2 norm of \c *this using the Blue's algorithm.
64	* A Portable Fortran Program to Find the Euclidean Norm of a Vector,	65	* A Portable Fortran Program to Find the Euclidean Norm of a Vector,
65	* ACM TOMS, Vol 4, Issue 1, 1978.	66	* ACM TOMS, Vol 4, Issue 1, 1978.
66	*	67	*
67	* For architecture/scalar types without vectorization, this version	68	* For architecture/scalar types without vectorization, this version
68	* is much faster than stableNorm(). Otherwise the stableNorm() is faster.	69	* is much faster than stableNorm(). Otherwise the stableNorm() is faster.
Lines 71-86 MatrixBase<Derived>::stableNorm() const Link Here
71	*/	72	*/
72	template<typename Derived>	73	template<typename Derived>
73	inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real	74	inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
74	MatrixBase<Derived>::blueNorm() const	75	MatrixBase<Derived>::blueNorm() const
75	{	76	{
76	using std::pow;	77	using std::pow;
77	using std::min;	78	using std::min;
78	using std::max;	79	using std::max;
		80	using std::sqrt;
		81	using std::abs;
79	static Index nmax = -1;	82	static Index nmax = -1;
80	static RealScalar b1, b2, s1m, s2m, overfl, rbig, relerr;	83	static RealScalar b1, b2, s1m, s2m, overfl, rbig, relerr;
81	if(nmax <= 0)	84	if(nmax <= 0)
82	{	85	{
83	int nbig, ibeta, it, iemin, iemax, iexp;	86	int nbig, ibeta, it, iemin, iemax, iexp;
84	RealScalar abig, eps;	87	RealScalar abig, eps;
85	// This program calculates the machine-dependent constants	88	// This program calculates the machine-dependent constants
86	// bl, b2, slm, s2m, relerr overfl, nmax	89	// bl, b2, slm, s2m, relerr overfl, nmax
Lines 104-169 MatrixBase<Derived>::blueNorm() const Link Here
104		107
105	iexp = (2-iemin)/2;	108	iexp = (2-iemin)/2;
106	s1m = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp))); // scaling factor for lower range	109	s1m = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp))); // scaling factor for lower range
107	iexp = - ((iemax+it)/2);	110	iexp = - ((iemax+it)/2);
108	s2m = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp))); // scaling factor for upper range	111	s2m = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp))); // scaling factor for upper range
109		112
110	overfl = rbig*s2m; // overflow boundary for abig	113	overfl = rbig*s2m; // overflow boundary for abig
111	eps = RealScalar(pow(double(ibeta), 1-it));	114	eps = RealScalar(pow(double(ibeta), 1-it));
112	relerr = internal::sqrt(eps); // tolerance for neglecting asml	115	relerr = sqrt(eps); // tolerance for neglecting asml
113	abig = RealScalar(1.0/eps - 1.0);	116	abig = RealScalar(1.0/eps - 1.0);
114	if (RealScalar(nbig)>abig) nmax = int(abig); // largest safe n	117	if (RealScalar(nbig)>abig) nmax = int(abig); // largest safe n
115	else nmax = nbig;	118	else nmax = nbig;
116	}	119	}
117	Index n = size();	120	Index n = size();
118	RealScalar ab2 = b2 / RealScalar(n);	121	RealScalar ab2 = b2 / RealScalar(n);
119	RealScalar asml = RealScalar(0);	122	RealScalar asml = RealScalar(0);
120	RealScalar amed = RealScalar(0);	123	RealScalar amed = RealScalar(0);
121	RealScalar abig = RealScalar(0);	124	RealScalar abig = RealScalar(0);
122	for(Index j=0; j<n; ++j)	125	for(Index j=0; j<n; ++j)
123	{	126	{
124	RealScalar ax = internal::abs(coeff(j));	127	RealScalar ax = abs(coeff(j));
125	if(ax > ab2) abig += internal::abs2(ax*s2m);	128	if(ax > ab2) abig += internal::abs2(ax*s2m);
126	else if(ax < b1) asml += internal::abs2(ax*s1m);	129	else if(ax < b1) asml += internal::abs2(ax*s1m);
127	else amed += internal::abs2(ax);	130	else amed += internal::abs2(ax);
128	}	131	}
129	if(abig > RealScalar(0))	132	if(abig > RealScalar(0))
130	{	133	{
131	abig = internal::sqrt(abig);	134	abig = sqrt(abig);
132	if(abig > overfl)	135	if(abig > overfl)
133	{	136	{
134	return rbig;	137	return rbig;
135	}	138	}
136	if(amed > RealScalar(0))	139	if(amed > RealScalar(0))
137	{	140	{
138	abig = abig/s2m;	141	abig = abig/s2m;
139	amed = internal::sqrt(amed);	142	amed = sqrt(amed);
140	}	143	}
141	else	144	else
142	return abig/s2m;	145	return abig/s2m;
143	}	146	}
144	else if(asml > RealScalar(0))	147	else if(asml > RealScalar(0))
145	{	148	{
146	if (amed > RealScalar(0))	149	if (amed > RealScalar(0))
147	{	150	{
148	abig = internal::sqrt(amed);	151	abig = sqrt(amed);
149	amed = internal::sqrt(asml) / s1m;	152	amed = sqrt(asml) / s1m;
150	}	153	}
151	else	154	else
152	return internal::sqrt(asml)/s1m;	155	return sqrt(asml)/s1m;
153	}	156	}
154	else	157	else
155	return internal::sqrt(amed);	158	return sqrt(amed);
156	asml = (min)(abig, amed);	159	asml = (min)(abig, amed);
157	abig = (max)(abig, amed);	160	abig = (max)(abig, amed);
158	if(asml <= abig*relerr)	161	if(asml <= abig*relerr)
159	return abig;	162	return abig;
160	else	163	else
161	return abig * internal::sqrt(RealScalar(1) + internal::abs2(asml/abig));	164	return abig * sqrt(RealScalar(1) + internal::abs2(asml/abig));
162	}	165	}
163		166
164	/** \returns the \em l2 norm of \c *this avoiding undeflow and overflow.	167	/** \returns the \em l2 norm of \c *this avoiding undeflow and overflow.
165	* This version use a concatenation of hypot() calls, and it is very slow.	168	* This version use a concatenation of hypot() calls, and it is very slow.
166	*	169	*
167	* \sa norm(), stableNorm()	170	* \sa norm(), stableNorm()
168	*/	171	*/
169	template<typename Derived>	172	template<typename Derived>

Lines 776-828 MatrixBase<Derived>::triangularView() co Link Here

(-)a/Eigen/src/Core/TriangularMatrix.h (-4 / +6 lines)
776	/** \returns true if *this is approximately equal to an upper triangular matrix,	776	/** \returns true if *this is approximately equal to an upper triangular matrix,
777	* within the precision given by \a prec.	777	* within the precision given by \a prec.
778	*	778	*
779	* \sa isLowerTriangular()	779	* \sa isLowerTriangular()
780	*/	780	*/
781	template<typename Derived>	781	template<typename Derived>
782	bool MatrixBase<Derived>::isUpperTriangular(const RealScalar& prec) const	782	bool MatrixBase<Derived>::isUpperTriangular(const RealScalar& prec) const
783	{	783	{
		784	using std::abs;
784	RealScalar maxAbsOnUpperPart = static_cast<RealScalar>(-1);	785	RealScalar maxAbsOnUpperPart = static_cast<RealScalar>(-1);
785	for(Index j = 0; j < cols(); ++j)	786	for(Index j = 0; j < cols(); ++j)
786	{	787	{
787	Index maxi = (std::min)(j, rows()-1);	788	Index maxi = (std::min)(j, rows()-1);
788	for(Index i = 0; i <= maxi; ++i)	789	for(Index i = 0; i <= maxi; ++i)
789	{	790	{
790	RealScalar absValue = internal::abs(coeff(i,j));	791	RealScalar absValue = abs(coeff(i,j));
791	if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;	792	if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;
792	}	793	}
793	}	794	}
794	RealScalar threshold = maxAbsOnUpperPart * prec;	795	RealScalar threshold = maxAbsOnUpperPart * prec;
795	for(Index j = 0; j < cols(); ++j)	796	for(Index j = 0; j < cols(); ++j)
796	for(Index i = j+1; i < rows(); ++i)	797	for(Index i = j+1; i < rows(); ++i)
797	if(internal::abs(coeff(i, j)) > threshold) return false;	798	if(abs(coeff(i, j)) > threshold) return false;
798	return true;	799	return true;
799	}	800	}
800		801
801	/** \returns true if *this is approximately equal to a lower triangular matrix,	802	/** \returns true if *this is approximately equal to a lower triangular matrix,
802	* within the precision given by \a prec.	803	* within the precision given by \a prec.
803	*	804	*
804	* \sa isUpperTriangular()	805	* \sa isUpperTriangular()
805	*/	806	*/
806	template<typename Derived>	807	template<typename Derived>
807	bool MatrixBase<Derived>::isLowerTriangular(const RealScalar& prec) const	808	bool MatrixBase<Derived>::isLowerTriangular(const RealScalar& prec) const
808	{	809	{
		810	using std::abs;
809	RealScalar maxAbsOnLowerPart = static_cast<RealScalar>(-1);	811	RealScalar maxAbsOnLowerPart = static_cast<RealScalar>(-1);
810	for(Index j = 0; j < cols(); ++j)	812	for(Index j = 0; j < cols(); ++j)
811	for(Index i = j; i < rows(); ++i)	813	for(Index i = j; i < rows(); ++i)
812	{	814	{
813	RealScalar absValue = internal::abs(coeff(i,j));	815	RealScalar absValue = abs(coeff(i,j));
814	if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;	816	if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;
815	}	817	}
816	RealScalar threshold = maxAbsOnLowerPart * prec;	818	RealScalar threshold = maxAbsOnLowerPart * prec;
817	for(Index j = 1; j < cols(); ++j)	819	for(Index j = 1; j < cols(); ++j)
818	{	820	{
819	Index maxi = (std::min)(j, rows()-1);	821	Index maxi = (std::min)(j, rows()-1);
820	for(Index i = 0; i < maxi; ++i)	822	for(Index i = 0; i < maxi; ++i)
821	if(internal::abs(coeff(i, j)) > threshold) return false;	823	if(abs(coeff(i, j)) > threshold) return false;
822	}	824	}
823	return true;	825	return true;
824	}	826	}
825		827
826	} // end namespace Eigen	828	} // end namespace Eigen
827		829
828	#endif // EIGEN_TRIANGULARMATRIX_H	830	#endif // EIGEN_TRIANGULARMATRIX_H

Lines 10-33 Link Here

(-)a/Eigen/src/Eigen2Support/MathFunctions.h (-7 / +7 lines)
10	#ifndef EIGEN2_MATH_FUNCTIONS_H	10	#ifndef EIGEN2_MATH_FUNCTIONS_H
11	#define EIGEN2_MATH_FUNCTIONS_H	11	#define EIGEN2_MATH_FUNCTIONS_H
12		12
13	namespace Eigen {	13	namespace Eigen {
14		14
15	template<typename T> inline typename NumTraits<T>::Real ei_real(const T& x) { return internal::real(x); }	15	template<typename T> inline typename NumTraits<T>::Real ei_real(const T& x) { return internal::real(x); }
16	template<typename T> inline typename NumTraits<T>::Real ei_imag(const T& x) { return internal::imag(x); }	16	template<typename T> inline typename NumTraits<T>::Real ei_imag(const T& x) { return internal::imag(x); }
17	template<typename T> inline T ei_conj(const T& x) { return internal::conj(x); }	17	template<typename T> inline T ei_conj(const T& x) { return internal::conj(x); }
18	template<typename T> inline typename NumTraits<T>::Real ei_abs (const T& x) { return internal::abs(x); }	18	template<typename T> inline typename NumTraits<T>::Real ei_abs (const T& x) { using std::abs; return abs(x); }
19	template<typename T> inline typename NumTraits<T>::Real ei_abs2(const T& x) { return internal::abs2(x); }	19	template<typename T> inline typename NumTraits<T>::Real ei_abs2(const T& x) { return internal::abs2(x); }
20	template<typename T> inline T ei_sqrt(const T& x) { return internal::sqrt(x); }	20	template<typename T> inline T ei_sqrt(const T& x) { using std::sqrt; return sqrt(x); }
21	template<typename T> inline T ei_exp (const T& x) { return internal::exp(x); }	21	template<typename T> inline T ei_exp (const T& x) { using std::exp; return exp(x); }
22	template<typename T> inline T ei_log (const T& x) { return internal::log(x); }	22	template<typename T> inline T ei_log (const T& x) { using std::log; return log(x); }
23	template<typename T> inline T ei_sin (const T& x) { return internal::sin(x); }	23	template<typename T> inline T ei_sin (const T& x) { using std::sin; return sin(x); }
24	template<typename T> inline T ei_cos (const T& x) { return internal::cos(x); }	24	template<typename T> inline T ei_cos (const T& x) { using std::cos; return cos(x); }
25	template<typename T> inline T ei_atan2(const T& x,const T& y) { return internal::atan2(x,y); }	25	template<typename T> inline T ei_atan2(const T& x,const T& y) { using std::atan2; return atan2(x,y); }
26	template<typename T> inline T ei_pow (const T& x,const T& y) { return internal::pow(x,y); }	26	template<typename T> inline T ei_pow (const T& x,const T& y) { return internal::pow(x,y); }
27	template<typename T> inline T ei_random () { return internal::random<T>(); }	27	template<typename T> inline T ei_random () { return internal::random<T>(); }
28	template<typename T> inline T ei_random (const T& x, const T& y) { return internal::random(x, y); }	28	template<typename T> inline T ei_random (const T& x, const T& y) { return internal::random(x, y); }
29		29
30	template<typename T> inline T precision () { return NumTraits<T>::dummy_precision(); }	30	template<typename T> inline T precision () { return NumTraits<T>::dummy_precision(); }
31	template<typename T> inline T machine_epsilon () { return NumTraits<T>::epsilon(); }	31	template<typename T> inline T machine_epsilon () { return NumTraits<T>::epsilon(); }
32		32
33		33

Lines 253-272 inline bool ComplexSchur<MatrixType>::su Link Here

(-)a/Eigen/src/Eigenvalues/ComplexSchur.h (-1 / +2 lines)
253	return false;	253	return false;
254	}	254	}
255		255
256		256
257	/** Compute the shift in the current QR iteration. */	257	/** Compute the shift in the current QR iteration. */
258	template<typename MatrixType>	258	template<typename MatrixType>
259	typename ComplexSchur<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::computeShift(Index iu, Index iter)	259	typename ComplexSchur<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::computeShift(Index iu, Index iter)
260	{	260	{
		261	using std::abs;
261	if (iter == 10 \|\| iter == 20)	262	if (iter == 10 \|\| iter == 20)
262	{	263	{
263	// exceptional shift, taken from http://www.netlib.org/eispack/comqr.f	264	// exceptional shift, taken from http://www.netlib.org/eispack/comqr.f
264	return internal::abs(internal::real(m_matT.coeff(iu,iu-1))) + internal::abs(internal::real(m_matT.coeff(iu-1,iu-2)));	265	return abs(internal::real(m_matT.coeff(iu,iu-1))) + abs(internal::real(m_matT.coeff(iu-1,iu-2)));
265	}	266	}
266		267
267	// compute the shift as one of the eigenvalues of t, the 2x2	268	// compute the shift as one of the eigenvalues of t, the 2x2
268	// diagonal block on the bottom of the active submatrix	269	// diagonal block on the bottom of the active submatrix
269	Matrix<ComplexScalar,2,2> t = m_matT.template block<2,2>(iu-1,iu-1);	270	Matrix<ComplexScalar,2,2> t = m_matT.template block<2,2>(iu-1,iu-1);
270	RealScalar normt = t.cwiseAbs().sum();	271	RealScalar normt = t.cwiseAbs().sum();
271	t /= normt; // the normalization by sf is to avoid under/overflow	272	t /= normt; // the normalization by sf is to avoid under/overflow
272		273

Lines 359-374 typename EigenSolver<MatrixType>::Eigenv Link Here

(-)a/Eigen/src/Eigenvalues/EigenSolver.h (-8 / +12 lines)
359	}	359	}
360	return matV;	360	return matV;
361	}	361	}
362		362
363	template<typename MatrixType>	363	template<typename MatrixType>
364	EigenSolver<MatrixType>&	364	EigenSolver<MatrixType>&
365	EigenSolver<MatrixType>::compute(const MatrixType& matrix, bool computeEigenvectors)	365	EigenSolver<MatrixType>::compute(const MatrixType& matrix, bool computeEigenvectors)
366	{	366	{
		367	using std::sqrt;
		368	using std::abs;
367	assert(matrix.cols() == matrix.rows());	369	assert(matrix.cols() == matrix.rows());
368		370
369	// Reduce to real Schur form.	371	// Reduce to real Schur form.
370	m_realSchur.compute(matrix, computeEigenvectors);	372	m_realSchur.compute(matrix, computeEigenvectors);
371		373
372	if (m_realSchur.info() == Success)	374	if (m_realSchur.info() == Success)
373	{	375	{
374	m_matT = m_realSchur.matrixT();	376	m_matT = m_realSchur.matrixT();
Lines 383-399 EigenSolver<MatrixType>::compute(const M Link Here
383	if (i == matrix.cols() - 1 \|\| m_matT.coeff(i+1, i) == Scalar(0))	385	if (i == matrix.cols() - 1 \|\| m_matT.coeff(i+1, i) == Scalar(0))
384	{	386	{
385	m_eivalues.coeffRef(i) = m_matT.coeff(i, i);	387	m_eivalues.coeffRef(i) = m_matT.coeff(i, i);
386	++i;	388	++i;
387	}	389	}
388	else	390	else
389	{	391	{
390	Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i+1, i+1));	392	Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i+1, i+1));
391	Scalar z = internal::sqrt(internal::abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));	393	Scalar z = sqrt(abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));
392	m_eivalues.coeffRef(i) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, z);	394	m_eivalues.coeffRef(i) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, z);
393	m_eivalues.coeffRef(i+1) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, -z);	395	m_eivalues.coeffRef(i+1) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, -z);
394	i += 2;	396	i += 2;
395	}	397	}
396	}	398	}
397		399
398	// Compute eigenvectors.	400	// Compute eigenvectors.
399	if (computeEigenvectors)	401	if (computeEigenvectors)
Lines 405-422 EigenSolver<MatrixType>::compute(const M Link Here
405		407
406	return *this;	408	return *this;
407	}	409	}
408		410
409	// Complex scalar division.	411	// Complex scalar division.
410	template<typename Scalar>	412	template<typename Scalar>
411	std::complex<Scalar> cdiv(Scalar xr, Scalar xi, Scalar yr, Scalar yi)	413	std::complex<Scalar> cdiv(Scalar xr, Scalar xi, Scalar yr, Scalar yi)
412	{	414	{
		415	using std::abs;
413	Scalar r,d;	416	Scalar r,d;
414	if (internal::abs(yr) > internal::abs(yi))	417	if (abs(yr) > abs(yi))
415	{	418	{
416	r = yi/yr;	419	r = yi/yr;
417	d = yr + r*yi;	420	d = yr + r*yi;
418	return std::complex<Scalar>((xr + rxi)/d, (xi - rxr)/d);	421	return std::complex<Scalar>((xr + rxi)/d, (xi - rxr)/d);
419	}	422	}
420	else	423	else
421	{	424	{
422	r = yr/yi;	425	r = yr/yi;
Lines 424-439 std::complex<Scalar> cdiv(Scalar xr, Sca Link Here
424	return std::complex<Scalar>((rxr + xi)/d, (rxi - xr)/d);	427	return std::complex<Scalar>((rxr + xi)/d, (rxi - xr)/d);
425	}	428	}
426	}	429	}
427		430
428		431
429	template<typename MatrixType>	432	template<typename MatrixType>
430	void EigenSolver<MatrixType>::doComputeEigenvectors()	433	void EigenSolver<MatrixType>::doComputeEigenvectors()
431	{	434	{
		435	using std::abs;
432	const Index size = m_eivec.cols();	436	const Index size = m_eivec.cols();
433	const Scalar eps = NumTraits<Scalar>::epsilon();	437	const Scalar eps = NumTraits<Scalar>::epsilon();
434		438
435	// inefficient! this is already computed in RealSchur	439	// inefficient! this is already computed in RealSchur
436	Scalar norm(0);	440	Scalar norm(0);
437	for (Index j = 0; j < size; ++j)	441	for (Index j = 0; j < size; ++j)
438	{	442	{
439	norm += m_matT.row(j).segment((std::max)(j-1,Index(0)), size-(std::max)(j-1,Index(0))).cwiseAbs().sum();	443	norm += m_matT.row(j).segment((std::max)(j-1,Index(0)), size-(std::max)(j-1,Index(0))).cwiseAbs().sum();
Lines 479-514 void EigenSolver<MatrixType>::doComputeE Link Here
479	}	483	}
480	else // Solve real equations	484	else // Solve real equations
481	{	485	{
482	Scalar x = m_matT.coeff(i,i+1);	486	Scalar x = m_matT.coeff(i,i+1);
483	Scalar y = m_matT.coeff(i+1,i);	487	Scalar y = m_matT.coeff(i+1,i);
484	Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();	488	Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();
485	Scalar t = (x * lastr - lastw * r) / denom;	489	Scalar t = (x * lastr - lastw * r) / denom;
486	m_matT.coeffRef(i,n) = t;	490	m_matT.coeffRef(i,n) = t;
487	if (internal::abs(x) > internal::abs(lastw))	491	if (abs(x) > abs(lastw))
488	m_matT.coeffRef(i+1,n) = (-r - w * t) / x;	492	m_matT.coeffRef(i+1,n) = (-r - w * t) / x;
489	else	493	else
490	m_matT.coeffRef(i+1,n) = (-lastr - y * t) / lastw;	494	m_matT.coeffRef(i+1,n) = (-lastr - y * t) / lastw;
491	}	495	}
492		496
493	// Overflow control	497	// Overflow control
494	Scalar t = internal::abs(m_matT.coeff(i,n));	498	Scalar t = abs(m_matT.coeff(i,n));
495	if ((eps * t) * t > Scalar(1))	499	if ((eps * t) * t > Scalar(1))
496	m_matT.col(n).tail(size-i) /= t;	500	m_matT.col(n).tail(size-i) /= t;
497	}	501	}
498	}	502	}
499	}	503	}
500	else if (q < Scalar(0) && n > 0) // Complex vector	504	else if (q < Scalar(0) && n > 0) // Complex vector
501	{	505	{
502	Scalar lastra(0), lastsa(0), lastw(0);	506	Scalar lastra(0), lastsa(0), lastw(0);
503	Index l = n-1;	507	Index l = n-1;
504		508
505	// Last vector component imaginary so matrix is triangular	509	// Last vector component imaginary so matrix is triangular
506	if (internal::abs(m_matT.coeff(n,n-1)) > internal::abs(m_matT.coeff(n-1,n)))	510	if (abs(m_matT.coeff(n,n-1)) > abs(m_matT.coeff(n-1,n)))
507	{	511	{
508	m_matT.coeffRef(n-1,n-1) = q / m_matT.coeff(n,n-1);	512	m_matT.coeffRef(n-1,n-1) = q / m_matT.coeff(n,n-1);
509	m_matT.coeffRef(n-1,n) = -(m_matT.coeff(n,n) - p) / m_matT.coeff(n,n-1);	513	m_matT.coeffRef(n-1,n) = -(m_matT.coeff(n,n) - p) / m_matT.coeff(n,n-1);
510	}	514	}
511	else	515	else
512	{	516	{
513	std::complex<Scalar> cc = cdiv<Scalar>(0.0,-m_matT.coeff(n-1,n),m_matT.coeff(n-1,n-1)-p,q);	517	std::complex<Scalar> cc = cdiv<Scalar>(0.0,-m_matT.coeff(n-1,n),m_matT.coeff(n-1,n-1)-p,q);
514	m_matT.coeffRef(n-1,n-1) = internal::real(cc);	518	m_matT.coeffRef(n-1,n-1) = internal::real(cc);
Lines 540-576 void EigenSolver<MatrixType>::doComputeE Link Here
540	else	544	else
541	{	545	{
542	// Solve complex equations	546	// Solve complex equations
543	Scalar x = m_matT.coeff(i,i+1);	547	Scalar x = m_matT.coeff(i,i+1);
544	Scalar y = m_matT.coeff(i+1,i);	548	Scalar y = m_matT.coeff(i+1,i);
545	Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;	549	Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;
546	Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;	550	Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;
547	if ((vr == 0.0) && (vi == 0.0))	551	if ((vr == 0.0) && (vi == 0.0))
548	vr = eps * norm * (internal::abs(w) + internal::abs(q) + internal::abs(x) + internal::abs(y) + internal::abs(lastw));	552	vr = eps * norm * (abs(w) + abs(q) + abs(x) + abs(y) + abs(lastw));
549		553
550	std::complex<Scalar> cc = cdiv(xlastra-lastwra+qsa,xlastsa-lastwsa-qra,vr,vi);	554	std::complex<Scalar> cc = cdiv(xlastra-lastwra+qsa,xlastsa-lastwsa-qra,vr,vi);
551	m_matT.coeffRef(i,n-1) = internal::real(cc);	555	m_matT.coeffRef(i,n-1) = internal::real(cc);
552	m_matT.coeffRef(i,n) = internal::imag(cc);	556	m_matT.coeffRef(i,n) = internal::imag(cc);
553	if (internal::abs(x) > (internal::abs(lastw) + internal::abs(q)))	557	if (abs(x) > (abs(lastw) + abs(q)))
554	{	558	{
555	m_matT.coeffRef(i+1,n-1) = (-ra - w * m_matT.coeff(i,n-1) + q * m_matT.coeff(i,n)) / x;	559	m_matT.coeffRef(i+1,n-1) = (-ra - w * m_matT.coeff(i,n-1) + q * m_matT.coeff(i,n)) / x;
556	m_matT.coeffRef(i+1,n) = (-sa - w * m_matT.coeff(i,n) - q * m_matT.coeff(i,n-1)) / x;	560	m_matT.coeffRef(i+1,n) = (-sa - w * m_matT.coeff(i,n) - q * m_matT.coeff(i,n-1)) / x;
557	}	561	}
558	else	562	else
559	{	563	{
560	cc = cdiv(-lastra-ym_matT.coeff(i,n-1),-lastsa-ym_matT.coeff(i,n),lastw,q);	564	cc = cdiv(-lastra-ym_matT.coeff(i,n-1),-lastsa-ym_matT.coeff(i,n),lastw,q);
561	m_matT.coeffRef(i+1,n-1) = internal::real(cc);	565	m_matT.coeffRef(i+1,n-1) = internal::real(cc);
562	m_matT.coeffRef(i+1,n) = internal::imag(cc);	566	m_matT.coeffRef(i+1,n) = internal::imag(cc);
563	}	567	}
564	}	568	}
565		569
566	// Overflow control	570	// Overflow control
567	using std::max;	571	using std::max;
568	Scalar t = (max)(internal::abs(m_matT.coeff(i,n-1)),internal::abs(m_matT.coeff(i,n)));	572	Scalar t = (max)(abs(m_matT.coeff(i,n-1)),abs(m_matT.coeff(i,n)));
569	if ((eps * t) * t > Scalar(1))	573	if ((eps * t) * t > Scalar(1))
570	m_matT.block(i, n-1, size-i, 2) /= t;	574	m_matT.block(i, n-1, size-i, 2) /= t;
571		575
572	}	576	}
573	}	577	}
574		578
575	// We handled a pair of complex conjugate eigenvalues, so need to skip them both	579	// We handled a pair of complex conjugate eigenvalues, so need to skip them both
576	n--;	580	n--;

Lines 285-300 template<typename _MatrixType> class Gen Link Here

(-)a/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h (-1 / +3 lines)
285	// // TODO	285	// // TODO
286	// return matV;	286	// return matV;
287	//}	287	//}
288		288
289	template<typename MatrixType>	289	template<typename MatrixType>
290	GeneralizedEigenSolver<MatrixType>&	290	GeneralizedEigenSolver<MatrixType>&
291	GeneralizedEigenSolver<MatrixType>::compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors)	291	GeneralizedEigenSolver<MatrixType>::compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors)
292	{	292	{
		293	using std::sqrt;
		294	using std::abs;
293	eigen_assert(A.cols() == A.rows() && B.cols() == A.rows() && B.cols() == B.rows());	295	eigen_assert(A.cols() == A.rows() && B.cols() == A.rows() && B.cols() == B.rows());
294		296
295	// Reduce to generalized real Schur form:	297	// Reduce to generalized real Schur form:
296	// A = Q S Z and B = Q T Z	298	// A = Q S Z and B = Q T Z
297	m_realQZ.compute(A, B, computeEigenvectors);	299	m_realQZ.compute(A, B, computeEigenvectors);
298		300
299	if (m_realQZ.info() == Success)	301	if (m_realQZ.info() == Success)
300	{	302	{
Lines 312-328 GeneralizedEigenSolver<MatrixType>::comp Link Here
312	{	314	{
313	m_alphas.coeffRef(i) = m_matS.coeff(i, i);	315	m_alphas.coeffRef(i) = m_matS.coeff(i, i);
314	m_betas.coeffRef(i) = m_realQZ.matrixT().coeff(i,i);	316	m_betas.coeffRef(i) = m_realQZ.matrixT().coeff(i,i);
315	++i;	317	++i;
316	}	318	}
317	else	319	else
318	{	320	{
319	Scalar p = Scalar(0.5) * (m_matS.coeff(i, i) - m_matS.coeff(i+1, i+1));	321	Scalar p = Scalar(0.5) * (m_matS.coeff(i, i) - m_matS.coeff(i+1, i+1));
320	Scalar z = internal::sqrt(internal::abs(p * p + m_matS.coeff(i+1, i) * m_matS.coeff(i, i+1)));	322	Scalar z = sqrt(abs(p * p + m_matS.coeff(i+1, i) * m_matS.coeff(i, i+1)));
321	m_alphas.coeffRef(i) = ComplexScalar(m_matS.coeff(i+1, i+1) + p, z);	323	m_alphas.coeffRef(i) = ComplexScalar(m_matS.coeff(i+1, i+1) + p, z);
322	m_alphas.coeffRef(i+1) = ComplexScalar(m_matS.coeff(i+1, i+1) + p, -z);	324	m_alphas.coeffRef(i+1) = ComplexScalar(m_matS.coeff(i+1, i+1) + p, -z);
323		325
324	m_betas.coeffRef(i) = m_realQZ.matrixT().coeff(i,i);	326	m_betas.coeffRef(i) = m_realQZ.matrixT().coeff(i,i);
325	m_betas.coeffRef(i+1) = m_realQZ.matrixT().coeff(i,i);	327	m_betas.coeffRef(i+1) = m_realQZ.matrixT().coeff(i,i);
326	i += 2;	328	i += 2;
327	}	329	}
328	}	330	}

Lines 116-135 SelfAdjointView<MatrixType, UpLo>::eigen Link Here

(-)a/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h (-1 / +2 lines)
116	* Output: \verbinclude MatrixBase_operatorNorm.out	116	* Output: \verbinclude MatrixBase_operatorNorm.out
117	*	117	*
118	* \sa SelfAdjointView::eigenvalues(), SelfAdjointView::operatorNorm()	118	* \sa SelfAdjointView::eigenvalues(), SelfAdjointView::operatorNorm()
119	*/	119	*/
120	template<typename Derived>	120	template<typename Derived>
121	inline typename MatrixBase<Derived>::RealScalar	121	inline typename MatrixBase<Derived>::RealScalar
122	MatrixBase<Derived>::operatorNorm() const	122	MatrixBase<Derived>::operatorNorm() const
123	{	123	{
		124	using std::sqrt;
124	typename Derived::PlainObject m_eval(derived());	125	typename Derived::PlainObject m_eval(derived());
125	// FIXME if it is really guaranteed that the eigenvalues are already sorted,	126	// FIXME if it is really guaranteed that the eigenvalues are already sorted,
126	// then we don't need to compute a maxCoeff() here, comparing the 1st and last ones is enough.	127	// then we don't need to compute a maxCoeff() here, comparing the 1st and last ones is enough.
127	return internal::sqrt((m_eval*m_eval.adjoint())	128	return sqrt((m_eval*m_eval.adjoint())
128	.eval()	129	.eval()
129	.template selfadjointView<Lower>()	130	.template selfadjointView<Lower>()
130	.eigenvalues()	131	.eigenvalues()
131	.maxCoeff()	132	.maxCoeff()
132	);	133	);
133	}	134	}
134		135
135	/** \brief Computes the L2 operator norm	136	/** \brief Computes the L2 operator norm

Lines 273-331 namespace Eigen { Link Here

(-)a/Eigen/src/Eigenvalues/RealQZ.h (-7 / +13 lines)
273	}	273	}
274	}	274	}
275		275
276		276
277	/** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0) */	277	/** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0) */
278	template<typename MatrixType>	278	template<typename MatrixType>
279	inline typename MatrixType::Index RealQZ<MatrixType>::findSmallSubdiagEntry(Index iu)	279	inline typename MatrixType::Index RealQZ<MatrixType>::findSmallSubdiagEntry(Index iu)
280	{	280	{
		281	using std::abs;
281	Index res = iu;	282	Index res = iu;
282	while (res > 0)	283	while (res > 0)
283	{	284	{
284	Scalar s = internal::abs(m_S.coeff(res-1,res-1)) + internal::abs(m_S.coeff(res,res));	285	Scalar s = abs(m_S.coeff(res-1,res-1)) + abs(m_S.coeff(res,res));
285	if (s == Scalar(0.0))	286	if (s == Scalar(0.0))
286	s = m_normOfS;	287	s = m_normOfS;
287	if (internal::abs(m_S.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)	288	if (abs(m_S.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
288	break;	289	break;
289	res--;	290	res--;
290	}	291	}
291	return res;	292	return res;
292	}	293	}
293		294
294	/** \internal Look for single small diagonal element T(res, res) for res between f and l, and return res (or f-1) */	295	/** \internal Look for single small diagonal element T(res, res) for res between f and l, and return res (or f-1) */
295	template<typename MatrixType>	296	template<typename MatrixType>
296	inline typename MatrixType::Index RealQZ<MatrixType>::findSmallDiagEntry(Index f, Index l)	297	inline typename MatrixType::Index RealQZ<MatrixType>::findSmallDiagEntry(Index f, Index l)
297	{	298	{
		299	using std::abs;
298	Index res = l;	300	Index res = l;
299	while (res >= f) {	301	while (res >= f) {
300	if (internal::abs(m_T.coeff(res,res)) <= NumTraits<Scalar>::epsilon() * m_normOfT)	302	if (abs(m_T.coeff(res,res)) <= NumTraits<Scalar>::epsilon() * m_normOfT)
301	break;	303	break;
302	res--;	304	res--;
303	}	305	}
304	return res;	306	return res;
305	}	307	}
306		308
307	/** \internal decouple 2x2 diagonal block in rows i, i+1 if eigenvalues are real */	309	/** \internal decouple 2x2 diagonal block in rows i, i+1 if eigenvalues are real */
308	template<typename MatrixType>	310	template<typename MatrixType>
309	inline void RealQZ<MatrixType>::splitOffTwoRows(Index i)	311	inline void RealQZ<MatrixType>::splitOffTwoRows(Index i)
310	{	312	{
		313	using std::abs;
		314	using std::sqrt;
311	const Index dim=m_S.cols();	315	const Index dim=m_S.cols();
312	if (internal::abs(m_S.coeff(i+1,i)==Scalar(0)))	316	if (abs(m_S.coeff(i+1,i)==Scalar(0)))
313	return;	317	return;
314	Index z = findSmallDiagEntry(i,i+1);	318	Index z = findSmallDiagEntry(i,i+1);
315	if (z==i-1)	319	if (z==i-1)
316	{	320	{
317	// block of (S T^{-1})	321	// block of (S T^{-1})
318	Matrix2s STi = m_T.template block<2,2>(i,i).template triangularView<Upper>().	322	Matrix2s STi = m_T.template block<2,2>(i,i).template triangularView<Upper>().
319	template solve<OnTheRight>(m_S.template block<2,2>(i,i));	323	template solve<OnTheRight>(m_S.template block<2,2>(i,i));
320	Scalar p = Scalar(0.5)*(STi(0,0)-STi(1,1));	324	Scalar p = Scalar(0.5)*(STi(0,0)-STi(1,1));
321	Scalar q = pp + STi(1,0)STi(0,1);	325	Scalar q = pp + STi(1,0)STi(0,1);
322	if (q>=0) {	326	if (q>=0) {
323	Scalar z = internal::sqrt(q);	327	Scalar z = sqrt(q);
324	// one QR-like iteration for ABi - lambda I	328	// one QR-like iteration for ABi - lambda I
325	// is enough - when we know exact eigenvalue in advance,	329	// is enough - when we know exact eigenvalue in advance,
326	// convergence is immediate	330	// convergence is immediate
327	JRs G;	331	JRs G;
328	if (p>=0)	332	if (p>=0)
329	G.makeGivens(p + z, STi(1,0));	333	G.makeGivens(p + z, STi(1,0));
330	else	334	else
331	G.makeGivens(p - z, STi(1,0));	335	G.makeGivens(p - z, STi(1,0));
Lines 388-404 namespace Eigen { Link Here
388	m_S.coeffRef(l,l-1)=Scalar(0.0);	392	m_S.coeffRef(l,l-1)=Scalar(0.0);
389	// update Z	393	// update Z
390	if (m_computeQZ)	394	if (m_computeQZ)
391	m_Z.applyOnTheLeft(l,l-1,G.adjoint());	395	m_Z.applyOnTheLeft(l,l-1,G.adjoint());
392	}	396	}
393		397
394	/** \internal QR-like iterative step for block f..l */	398	/** \internal QR-like iterative step for block f..l */
395	template<typename MatrixType>	399	template<typename MatrixType>
396	inline void RealQZ<MatrixType>::step(Index f, Index l, Index iter) {	400	inline void RealQZ<MatrixType>::step(Index f, Index l, Index iter)
		401	{
		402	using std::abs;
397	const Index dim = m_S.cols();	403	const Index dim = m_S.cols();
398		404
399	// x, y, z	405	// x, y, z
400	Scalar x, y, z;	406	Scalar x, y, z;
401	if (iter==10)	407	if (iter==10)
402	{	408	{
403	// Wilkinson ad hoc shift	409	// Wilkinson ad hoc shift
404	const Scalar	410	const Scalar
Lines 406-422 namespace Eigen { Link Here
406	a21=m_S.coeff(f+1,f+0), a22=m_S.coeff(f+1,f+1), a32=m_S.coeff(f+2,f+1),	412	a21=m_S.coeff(f+1,f+0), a22=m_S.coeff(f+1,f+1), a32=m_S.coeff(f+2,f+1),
407	b12=m_T.coeff(f+0,f+1),	413	b12=m_T.coeff(f+0,f+1),
408	b11i=Scalar(1.0)/m_T.coeff(f+0,f+0),	414	b11i=Scalar(1.0)/m_T.coeff(f+0,f+0),
409	b22i=Scalar(1.0)/m_T.coeff(f+1,f+1),	415	b22i=Scalar(1.0)/m_T.coeff(f+1,f+1),
410	a87=m_S.coeff(l-1,l-2),	416	a87=m_S.coeff(l-1,l-2),
411	a98=m_S.coeff(l-0,l-1),	417	a98=m_S.coeff(l-0,l-1),
412	b77i=Scalar(1.0)/m_T.coeff(l-2,l-2),	418	b77i=Scalar(1.0)/m_T.coeff(l-2,l-2),
413	b88i=Scalar(1.0)/m_T.coeff(l-1,l-1);	419	b88i=Scalar(1.0)/m_T.coeff(l-1,l-1);
414	Scalar ss = internal::abs(a87b77i) + internal::abs(a98b88i),	420	Scalar ss = abs(a87b77i) + abs(a98b88i),
415	lpl = Scalar(1.5)*ss,	421	lpl = Scalar(1.5)*ss,
416	ll = ss*ss;	422	ll = ss*ss;
417	x = ll + a11a11b11ib11i - lpla11b11i + a12a21b11ib22i	423	x = ll + a11a11b11ib11i - lpla11b11i + a12a21b11ib22i
418	- a11a21b12b11ib11i*b22i;	424	- a11a21b12b11ib11i*b22i;
419	y = a11a21b11ib11i - lpla21b11i + a21a22b11ib22i	425	y = a11a21b11ib11i - lpla21b11i + a21a22b11ib22i
420	- a21a21b12b11ib11i*b22i;	426	- a21a21b12b11ib11i*b22i;
421	z = a21a32b11i*b22i;	427	z = a21a32b11i*b22i;
422	}	428	}

Lines 309-353 inline typename MatrixType::Scalar RealS Link Here

(-)a/Eigen/src/Eigenvalues/RealSchur.h (-8 / +14 lines)
309	norm += m_matT.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();	309	norm += m_matT.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
310	return norm;	310	return norm;
311	}	311	}
312		312
313	/** \internal Look for single small sub-diagonal element and returns its index */	313	/** \internal Look for single small sub-diagonal element and returns its index */
314	template<typename MatrixType>	314	template<typename MatrixType>
315	inline typename MatrixType::Index RealSchur<MatrixType>::findSmallSubdiagEntry(Index iu, Scalar norm)	315	inline typename MatrixType::Index RealSchur<MatrixType>::findSmallSubdiagEntry(Index iu, Scalar norm)
316	{	316	{
		317	using std::abs;
317	Index res = iu;	318	Index res = iu;
318	while (res > 0)	319	while (res > 0)
319	{	320	{
320	Scalar s = internal::abs(m_matT.coeff(res-1,res-1)) + internal::abs(m_matT.coeff(res,res));	321	Scalar s = abs(m_matT.coeff(res-1,res-1)) + abs(m_matT.coeff(res,res));
321	if (s == 0.0)	322	if (s == 0.0)
322	s = norm;	323	s = norm;
323	if (internal::abs(m_matT.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)	324	if (abs(m_matT.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
324	break;	325	break;
325	res--;	326	res--;
326	}	327	}
327	return res;	328	return res;
328	}	329	}
329		330
330	/** \internal Update T given that rows iu-1 and iu decouple from the rest. */	331	/** \internal Update T given that rows iu-1 and iu decouple from the rest. */
331	template<typename MatrixType>	332	template<typename MatrixType>
332	inline void RealSchur<MatrixType>::splitOffTwoRows(Index iu, bool computeU, Scalar exshift)	333	inline void RealSchur<MatrixType>::splitOffTwoRows(Index iu, bool computeU, Scalar exshift)
333	{	334	{
		335	using std::sqrt;
		336	using std::abs;
334	const Index size = m_matT.cols();	337	const Index size = m_matT.cols();
335		338
336	// The eigenvalues of the 2x2 matrix [a b; c d] are	339	// The eigenvalues of the 2x2 matrix [a b; c d] are
337	// trace +/- sqrt(discr/4) where discr = tr^2 - 4*det, tr = a + d, det = ad - bc	340	// trace +/- sqrt(discr/4) where discr = tr^2 - 4*det, tr = a + d, det = ad - bc
338	Scalar p = Scalar(0.5) * (m_matT.coeff(iu-1,iu-1) - m_matT.coeff(iu,iu));	341	Scalar p = Scalar(0.5) * (m_matT.coeff(iu-1,iu-1) - m_matT.coeff(iu,iu));
339	Scalar q = p * p + m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu); // q = tr^2 / 4 - det = discr/4	342	Scalar q = p * p + m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu); // q = tr^2 / 4 - det = discr/4
340	m_matT.coeffRef(iu,iu) += exshift;	343	m_matT.coeffRef(iu,iu) += exshift;
341	m_matT.coeffRef(iu-1,iu-1) += exshift;	344	m_matT.coeffRef(iu-1,iu-1) += exshift;
342		345
343	if (q >= Scalar(0)) // Two real eigenvalues	346	if (q >= Scalar(0)) // Two real eigenvalues
344	{	347	{
345	Scalar z = internal::sqrt(internal::abs(q));	348	Scalar z = sqrt(abs(q));
346	JacobiRotation<Scalar> rot;	349	JacobiRotation<Scalar> rot;
347	if (p >= Scalar(0))	350	if (p >= Scalar(0))
348	rot.makeGivens(p + z, m_matT.coeff(iu, iu-1));	351	rot.makeGivens(p + z, m_matT.coeff(iu, iu-1));
349	else	352	else
350	rot.makeGivens(p - z, m_matT.coeff(iu, iu-1));	353	rot.makeGivens(p - z, m_matT.coeff(iu, iu-1));
351		354
352	m_matT.rightCols(size-iu+1).applyOnTheLeft(iu-1, iu, rot.adjoint());	355	m_matT.rightCols(size-iu+1).applyOnTheLeft(iu-1, iu, rot.adjoint());
353	m_matT.topRows(iu+1).applyOnTheRight(iu-1, iu, rot);	356	m_matT.topRows(iu+1).applyOnTheRight(iu-1, iu, rot);
Lines 359-430 inline void RealSchur<MatrixType>::split Link Here
359	if (iu > 1)	362	if (iu > 1)
360	m_matT.coeffRef(iu-1, iu-2) = Scalar(0);	363	m_matT.coeffRef(iu-1, iu-2) = Scalar(0);
361	}	364	}
362		365
363	/** \internal Form shift in shiftInfo, and update exshift if an exceptional shift is performed. */	366	/** \internal Form shift in shiftInfo, and update exshift if an exceptional shift is performed. */
364	template<typename MatrixType>	367	template<typename MatrixType>
365	inline void RealSchur<MatrixType>::computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo)	368	inline void RealSchur<MatrixType>::computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo)
366	{	369	{
		370	using std::sqrt;
		371	using std::abs;
367	shiftInfo.coeffRef(0) = m_matT.coeff(iu,iu);	372	shiftInfo.coeffRef(0) = m_matT.coeff(iu,iu);
368	shiftInfo.coeffRef(1) = m_matT.coeff(iu-1,iu-1);	373	shiftInfo.coeffRef(1) = m_matT.coeff(iu-1,iu-1);
369	shiftInfo.coeffRef(2) = m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);	374	shiftInfo.coeffRef(2) = m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);
370		375
371	// Wilkinson's original ad hoc shift	376	// Wilkinson's original ad hoc shift
372	if (iter == 10)	377	if (iter == 10)
373	{	378	{
374	exshift += shiftInfo.coeff(0);	379	exshift += shiftInfo.coeff(0);
375	for (Index i = 0; i <= iu; ++i)	380	for (Index i = 0; i <= iu; ++i)
376	m_matT.coeffRef(i,i) -= shiftInfo.coeff(0);	381	m_matT.coeffRef(i,i) -= shiftInfo.coeff(0);
377	Scalar s = internal::abs(m_matT.coeff(iu,iu-1)) + internal::abs(m_matT.coeff(iu-1,iu-2));	382	Scalar s = abs(m_matT.coeff(iu,iu-1)) + abs(m_matT.coeff(iu-1,iu-2));
378	shiftInfo.coeffRef(0) = Scalar(0.75) * s;	383	shiftInfo.coeffRef(0) = Scalar(0.75) * s;
379	shiftInfo.coeffRef(1) = Scalar(0.75) * s;	384	shiftInfo.coeffRef(1) = Scalar(0.75) * s;
380	shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s;	385	shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s;
381	}	386	}
382		387
383	// MATLAB's new ad hoc shift	388	// MATLAB's new ad hoc shift
384	if (iter == 30)	389	if (iter == 30)
385	{	390	{
386	Scalar s = (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);	391	Scalar s = (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
387	s = s * s + shiftInfo.coeff(2);	392	s = s * s + shiftInfo.coeff(2);
388	if (s > Scalar(0))	393	if (s > Scalar(0))
389	{	394	{
390	s = internal::sqrt(s);	395	s = sqrt(s);
391	if (shiftInfo.coeff(1) < shiftInfo.coeff(0))	396	if (shiftInfo.coeff(1) < shiftInfo.coeff(0))
392	s = -s;	397	s = -s;
393	s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);	398	s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
394	s = shiftInfo.coeff(0) - shiftInfo.coeff(2) / s;	399	s = shiftInfo.coeff(0) - shiftInfo.coeff(2) / s;
395	exshift += s;	400	exshift += s;
396	for (Index i = 0; i <= iu; ++i)	401	for (Index i = 0; i <= iu; ++i)
397	m_matT.coeffRef(i,i) -= s;	402	m_matT.coeffRef(i,i) -= s;
398	shiftInfo.setConstant(Scalar(0.964));	403	shiftInfo.setConstant(Scalar(0.964));
399	}	404	}
400	}	405	}
401	}	406	}
402		407
403	/** \internal Compute index im at which Francis QR step starts and the first Householder vector. */	408	/** \internal Compute index im at which Francis QR step starts and the first Householder vector. */
404	template<typename MatrixType>	409	template<typename MatrixType>
405	inline void RealSchur<MatrixType>::initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector)	410	inline void RealSchur<MatrixType>::initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector)
406	{	411	{
		412	using std::abs;
407	Vector3s& v = firstHouseholderVector; // alias to save typing	413	Vector3s& v = firstHouseholderVector; // alias to save typing
408		414
409	for (im = iu-2; im >= il; --im)	415	for (im = iu-2; im >= il; --im)
410	{	416	{
411	const Scalar Tmm = m_matT.coeff(im,im);	417	const Scalar Tmm = m_matT.coeff(im,im);
412	const Scalar r = shiftInfo.coeff(0) - Tmm;	418	const Scalar r = shiftInfo.coeff(0) - Tmm;
413	const Scalar s = shiftInfo.coeff(1) - Tmm;	419	const Scalar s = shiftInfo.coeff(1) - Tmm;
414	v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / m_matT.coeff(im+1,im) + m_matT.coeff(im,im+1);	420	v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / m_matT.coeff(im+1,im) + m_matT.coeff(im,im+1);
415	v.coeffRef(1) = m_matT.coeff(im+1,im+1) - Tmm - r - s;	421	v.coeffRef(1) = m_matT.coeff(im+1,im+1) - Tmm - r - s;
416	v.coeffRef(2) = m_matT.coeff(im+2,im+1);	422	v.coeffRef(2) = m_matT.coeff(im+2,im+1);
417	if (im == il) {	423	if (im == il) {
418	break;	424	break;
419	}	425	}
420	const Scalar lhs = m_matT.coeff(im,im-1) * (internal::abs(v.coeff(1)) + internal::abs(v.coeff(2)));	426	const Scalar lhs = m_matT.coeff(im,im-1) * (abs(v.coeff(1)) + abs(v.coeff(2)));
421	const Scalar rhs = v.coeff(0) * (internal::abs(m_matT.coeff(im-1,im-1)) + internal::abs(Tmm) + internal::abs(m_matT.coeff(im+1,im+1)));	427	const Scalar rhs = v.coeff(0) * (abs(m_matT.coeff(im-1,im-1)) + abs(Tmm) + abs(m_matT.coeff(im+1,im+1)));
422	if (internal::abs(lhs) < NumTraits<Scalar>::epsilon() * rhs)	428	if (abs(lhs) < NumTraits<Scalar>::epsilon() * rhs)
423	{	429	{
424	break;	430	break;
425	}	431	}
426	}	432	}
427	}	433	}
428		434
429	/** \internal Perform a Francis QR step involving rows il:iu and columns im:iu. */	435	/** \internal Perform a Francis QR step involving rows il:iu and columns im:iu. */
430	template<typename MatrixType>	436	template<typename MatrixType>

Lines 379-394 namespace internal { Link Here

(-)a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h (-1 / +4 lines)
379	template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>	379	template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
380	static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n);	380	static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n);
381	}	381	}
382		382
383	template<typename MatrixType>	383	template<typename MatrixType>
384	SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>	384	SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
385	::compute(const MatrixType& matrix, int options)	385	::compute(const MatrixType& matrix, int options)
386	{	386	{
		387	using std::abs;
387	eigen_assert(matrix.cols() == matrix.rows());	388	eigen_assert(matrix.cols() == matrix.rows());
388	eigen_assert((options&~(EigVecMask\|GenEigMask))==0	389	eigen_assert((options&~(EigVecMask\|GenEigMask))==0
389	&& (options&EigVecMask)!=EigVecMask	390	&& (options&EigVecMask)!=EigVecMask
390	&& "invalid option parameter");	391	&& "invalid option parameter");
391	bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;	392	bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
392	Index n = matrix.cols();	393	Index n = matrix.cols();
393	m_eivalues.resize(n,1);	394	m_eivalues.resize(n,1);
394		395
Lines 416-432 SelfAdjointEigenSolver<MatrixType>& Self Link Here
416		417
417	Index end = n-1;	418	Index end = n-1;
418	Index start = 0;	419	Index start = 0;
419	Index iter = 0; // total number of iterations	420	Index iter = 0; // total number of iterations
420		421
421	while (end>0)	422	while (end>0)
422	{	423	{
423	for (Index i = start; i<end; ++i)	424	for (Index i = start; i<end; ++i)
424	if (internal::isMuchSmallerThan(internal::abs(m_subdiag[i]),(internal::abs(diag[i])+internal::abs(diag[i+1]))))	425	if (internal::isMuchSmallerThan(abs(m_subdiag[i]),(abs(diag[i])+abs(diag[i+1]))))
425	m_subdiag[i] = 0;	426	m_subdiag[i] = 0;
426		427
427	// find the largest unreduced block	428	// find the largest unreduced block
428	while (end>0 && m_subdiag[end-1]==0)	429	while (end>0 && m_subdiag[end-1]==0)
429	{	430	{
430	end--;	431	end--;
431	}	432	}
432	if (end<=0)	433	if (end<=0)
Lines 670-685 template<typename SolverType> struct dir Link Here
670	const Scalar t0 = Scalar(0.5) * sqrt( abs2(m(0,0)-m(1,1)) + Scalar(4)m(1,0)m(1,0));	671	const Scalar t0 = Scalar(0.5) * sqrt( abs2(m(0,0)-m(1,1)) + Scalar(4)m(1,0)m(1,0));
671	const Scalar t1 = Scalar(0.5) * (m(0,0) + m(1,1));	672	const Scalar t1 = Scalar(0.5) * (m(0,0) + m(1,1));
672	roots(0) = t1 - t0;	673	roots(0) = t1 - t0;
673	roots(1) = t1 + t0;	674	roots(1) = t1 + t0;
674	}	675	}
675		676
676	static inline void run(SolverType& solver, const MatrixType& mat, int options)	677	static inline void run(SolverType& solver, const MatrixType& mat, int options)
677	{	678	{
		679	using std::sqrt;
678	eigen_assert(mat.cols() == 2 && mat.cols() == mat.rows());	680	eigen_assert(mat.cols() == 2 && mat.cols() == mat.rows());
679	eigen_assert((options&~(EigVecMask\|GenEigMask))==0	681	eigen_assert((options&~(EigVecMask\|GenEigMask))==0
680	&& (options&EigVecMask)!=EigVecMask	682	&& (options&EigVecMask)!=EigVecMask
681	&& "invalid option parameter");	683	&& "invalid option parameter");
682	bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;	684	bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
683		685
684	MatrixType& eivecs = solver.m_eivec;	686	MatrixType& eivecs = solver.m_eivec;
685	VectorType& eivals = solver.m_eivalues;	687	VectorType& eivals = solver.m_eivalues;
Lines 731-746 SelfAdjointEigenSolver<MatrixType>& Self Link Here
731	internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>::run(*this,matrix,options);	733	internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>::run(*this,matrix,options);
732	return *this;	734	return *this;
733	}	735	}
734		736
735	namespace internal {	737	namespace internal {
736	template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>	738	template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
737	static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n)	739	static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n)
738	{	740	{
		741	using std::abs;
739	RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5);	742	RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5);
740	RealScalar e = subdiag[end-1];	743	RealScalar e = subdiag[end-1];
741	// Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still	744	// Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still
742	// underflow thus leading to inf/NaN values when using the following commented code:	745	// underflow thus leading to inf/NaN values when using the following commented code:
743	// RealScalar e2 = abs2(subdiag[end-1]);	746	// RealScalar e2 = abs2(subdiag[end-1]);
744	// RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));	747	// RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));
745	// This explain the following, somewhat more complicated, version:	748	// This explain the following, somewhat more complicated, version:
746	RealScalar mu = diag[end];	749	RealScalar mu = diag[end];

Lines 462-477 template<typename MatrixType> Link Here

(-)a/Eigen/src/Eigenvalues/Tridiagonalization.h (+1 lines)
462	struct tridiagonalization_inplace_selector<MatrixType,3,false>	462	struct tridiagonalization_inplace_selector<MatrixType,3,false>
463	{	463	{
464	typedef typename MatrixType::Scalar Scalar;	464	typedef typename MatrixType::Scalar Scalar;
465	typedef typename MatrixType::RealScalar RealScalar;	465	typedef typename MatrixType::RealScalar RealScalar;
466		466
467	template<typename DiagonalType, typename SubDiagonalType>	467	template<typename DiagonalType, typename SubDiagonalType>
468	static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ)	468	static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ)
469	{	469	{
		470	using std::sqrt;
470	diag[0] = mat(0,0);	471	diag[0] = mat(0,0);
471	RealScalar v1norm2 = abs2(mat(2,0));	472	RealScalar v1norm2 = abs2(mat(2,0));
472	if(v1norm2 == RealScalar(0))	473	if(v1norm2 == RealScalar(0))
473	{	474	{
474	diag[1] = mat(1,1);	475	diag[1] = mat(1,1);
475	diag[2] = mat(2,2);	476	diag[2] = mat(2,2);
476	subdiag[0] = mat(1,0);	477	subdiag[0] = mat(1,0);
477	subdiag[1] = mat(2,1);	478	subdiag[1] = mat(2,1);

Lines 243-266 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTO Link Here

(-)a/Eigen/src/Geometry/AlignedBox.h (-2 / +2 lines)
243	inline Scalar squaredExteriorDistance(const AlignedBox& b) const;	243	inline Scalar squaredExteriorDistance(const AlignedBox& b) const;
244		244
245	/** \returns the distance between the point \a p and the box \c *this,	245	/** \returns the distance between the point \a p and the box \c *this,
246	* and zero if \a p is inside the box.	246	* and zero if \a p is inside the box.
247	* \sa squaredExteriorDistance()	247	* \sa squaredExteriorDistance()
248	*/	248	*/
249	template<typename Derived>	249	template<typename Derived>
250	inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const	250	inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
251	{ return internal::sqrt(NonInteger(squaredExteriorDistance(p))); }	251	{ using std::sqrt; return sqrt(NonInteger(squaredExteriorDistance(p))); }
252		252
253	/** \returns the distance between the boxes \a b and \c *this,	253	/** \returns the distance between the boxes \a b and \c *this,
254	* and zero if the boxes intersect.	254	* and zero if the boxes intersect.
255	* \sa squaredExteriorDistance()	255	* \sa squaredExteriorDistance()
256	*/	256	*/
257	inline NonInteger exteriorDistance(const AlignedBox& b) const	257	inline NonInteger exteriorDistance(const AlignedBox& b) const
258	{ return internal::sqrt(NonInteger(squaredExteriorDistance(b))); }	258	{ using std::sqrt; return sqrt(NonInteger(squaredExteriorDistance(b))); }
259		259
260	/** \returns \c *this with scalar type casted to \a NewScalarType	260	/** \returns \c *this with scalar type casted to \a NewScalarType
261	*	261	*
262	* Note that if \a NewScalarType is equal to the current scalar type of \c *this	262	* Note that if \a NewScalarType is equal to the current scalar type of \c *this
263	* then this function smartly returns a const reference to \c *this.	263	* then this function smartly returns a const reference to \c *this.
264	*/	264	*/
265	template<typename NewScalarType>	265	template<typename NewScalarType>
266	inline typename internal::cast_return_type<AlignedBox,	266	inline typename internal::cast_return_type<AlignedBox,

Lines 156-181 typedef AngleAxis<double> AngleAxisd; Link Here

(-)a/Eigen/src/Geometry/AngleAxis.h (-3 / +6 lines)
156	*/	156	*/
157	template<typename Scalar>	157	template<typename Scalar>
158	template<typename QuatDerived>	158	template<typename QuatDerived>
159	AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const QuaternionBase<QuatDerived>& q)	159	AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const QuaternionBase<QuatDerived>& q)
160	{	160	{
161	using std::acos;	161	using std::acos;
162	using std::min;	162	using std::min;
163	using std::max;	163	using std::max;
		164	using std::sqrt;
164	Scalar n2 = q.vec().squaredNorm();	165	Scalar n2 = q.vec().squaredNorm();
165	if (n2 < NumTraits<Scalar>::dummy_precision()*NumTraits<Scalar>::dummy_precision())	166	if (n2 < NumTraits<Scalar>::dummy_precision()*NumTraits<Scalar>::dummy_precision())
166	{	167	{
167	m_angle = 0;	168	m_angle = 0;
168	m_axis << 1, 0, 0;	169	m_axis << 1, 0, 0;
169	}	170	}
170	else	171	else
171	{	172	{
172	m_angle = Scalar(2)*acos((min)((max)(Scalar(-1),q.w()),Scalar(1)));	173	m_angle = Scalar(2)*acos((min)((max)(Scalar(-1),q.w()),Scalar(1)));
173	m_axis = q.vec() / internal::sqrt(n2);	174	m_axis = q.vec() / sqrt(n2);
174	}	175	}
175	return *this;	176	return *this;
176	}	177	}
177		178
178	/** Set \c *this from a 3x3 rotation matrix \a mat.	179	/** Set \c *this from a 3x3 rotation matrix \a mat.
179	*/	180	*/
180	template<typename Scalar>	181	template<typename Scalar>
181	template<typename Derived>	182	template<typename Derived>
Lines 197-215 AngleAxis<Scalar>& AngleAxis<Scalar>::fr Link Here
197	}	198	}
198		199
199	/** Constructs and \returns an equivalent 3x3 rotation matrix.	200	/** Constructs and \returns an equivalent 3x3 rotation matrix.
200	*/	201	*/
201	template<typename Scalar>	202	template<typename Scalar>
202	typename AngleAxis<Scalar>::Matrix3	203	typename AngleAxis<Scalar>::Matrix3
203	AngleAxis<Scalar>::toRotationMatrix(void) const	204	AngleAxis<Scalar>::toRotationMatrix(void) const
204	{	205	{
		206	using std::sin;
		207	using std::cos;
205	Matrix3 res;	208	Matrix3 res;
206	Vector3 sin_axis = internal::sin(m_angle) * m_axis;	209	Vector3 sin_axis = sin(m_angle) * m_axis;
207	Scalar c = internal::cos(m_angle);	210	Scalar c = cos(m_angle);
208	Vector3 cos1_axis = (Scalar(1)-c) * m_axis;	211	Vector3 cos1_axis = (Scalar(1)-c) * m_axis;
209		212
210	Scalar tmp;	213	Scalar tmp;
211	tmp = cos1_axis.x() * m_axis.y();	214	tmp = cos1_axis.x() * m_axis.y();
212	res.coeffRef(0,1) = tmp - sin_axis.z();	215	res.coeffRef(0,1) = tmp - sin_axis.z();
213	res.coeffRef(1,0) = tmp + sin_axis.z();	216	res.coeffRef(1,0) = tmp + sin_axis.z();
214		217
215	tmp = cos1_axis.x() * m_axis.z();	218	tmp = cos1_axis.x() * m_axis.z();

Lines 27-82 namespace Eigen { Link Here

(-)a/Eigen/src/Geometry/EulerAngles.h (-8 / +9 lines)
27	* * AngleAxisf(ea[1], Vector3f::UnitX())	27	* * AngleAxisf(ea[1], Vector3f::UnitX())
28	* * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode	28	* * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
29	* This corresponds to the right-multiply conventions (with right hand side frames).	29	* This corresponds to the right-multiply conventions (with right hand side frames).
30	*/	30	*/
31	template<typename Derived>	31	template<typename Derived>
32	inline Matrix<typename MatrixBase<Derived>::Scalar,3,1>	32	inline Matrix<typename MatrixBase<Derived>::Scalar,3,1>
33	MatrixBase<Derived>::eulerAngles(Index a0, Index a1, Index a2) const	33	MatrixBase<Derived>::eulerAngles(Index a0, Index a1, Index a2) const
34	{	34	{
		35	using std::atan2;
35	/* Implemented from Graphics Gems IV */	36	/* Implemented from Graphics Gems IV */
36	EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3)	37	EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3)
37		38
38	Matrix<Scalar,3,1> res;	39	Matrix<Scalar,3,1> res;
39	typedef Matrix<typename Derived::Scalar,2,1> Vector2;	40	typedef Matrix<typename Derived::Scalar,2,1> Vector2;
40	const Scalar epsilon = NumTraits<Scalar>::dummy_precision();	41	const Scalar epsilon = NumTraits<Scalar>::dummy_precision();
41		42
42	const Index odd = ((a0+1)%3 == a1) ? 0 : 1;	43	const Index odd = ((a0+1)%3 == a1) ? 0 : 1;
43	const Index i = a0;	44	const Index i = a0;
44	const Index j = (a0 + 1 + odd)%3;	45	const Index j = (a0 + 1 + odd)%3;
45	const Index k = (a0 + 2 - odd)%3;	46	const Index k = (a0 + 2 - odd)%3;
46		47
47	if (a0==a2)	48	if (a0==a2)
48	{	49	{
49	Scalar s = Vector2(coeff(j,i) , coeff(k,i)).norm();	50	Scalar s = Vector2(coeff(j,i) , coeff(k,i)).norm();
50	res[1] = internal::atan2(s, coeff(i,i));	51	res[1] = atan2(s, coeff(i,i));
51	if (s > epsilon)	52	if (s > epsilon)
52	{	53	{
53	res[0] = internal::atan2(coeff(j,i), coeff(k,i));	54	res[0] = atan2(coeff(j,i), coeff(k,i));
54	res[2] = internal::atan2(coeff(i,j),-coeff(i,k));	55	res[2] = atan2(coeff(i,j),-coeff(i,k));
55	}	56	}
56	else	57	else
57	{	58	{
58	res[0] = Scalar(0);	59	res[0] = Scalar(0);
59	res[2] = (coeff(i,i)>0?1:-1)*internal::atan2(-coeff(k,j), coeff(j,j));	60	res[2] = (coeff(i,i)>0?1:-1)*atan2(-coeff(k,j), coeff(j,j));
60	}	61	}
61	}	62	}
62	else	63	else
63	{	64	{
64	Scalar c = Vector2(coeff(i,i) , coeff(i,j)).norm();	65	Scalar c = Vector2(coeff(i,i) , coeff(i,j)).norm();
65	res[1] = internal::atan2(-coeff(i,k), c);	66	res[1] = atan2(-coeff(i,k), c);
66	if (c > epsilon)	67	if (c > epsilon)
67	{	68	{
68	res[0] = internal::atan2(coeff(j,k), coeff(k,k));	69	res[0] = atan2(coeff(j,k), coeff(k,k));
69	res[2] = internal::atan2(coeff(i,j), coeff(i,i));	70	res[2] = atan2(coeff(i,j), coeff(i,i));
70	}	71	}
71	else	72	else
72	{	73	{
73	res[0] = Scalar(0);	74	res[0] = Scalar(0);
74	res[2] = (coeff(i,k)>0?1:-1)*internal::atan2(-coeff(k,j), coeff(j,j));	75	res[2] = (coeff(i,k)>0?1:-1)*atan2(-coeff(k,j), coeff(j,j));
75	}	76	}
76	}	77	}
77	if (!odd)	78	if (!odd)
78	res = -res;	79	res = -res;
79	return res;	80	return res;
80	}	81	}
81		82
82	} // end namespace Eigen	83	} // end namespace Eigen

Lines 130-146 public: Link Here

(-)a/Eigen/src/Geometry/Hyperplane.h (-2 / +3 lines)
130	/** \returns the signed distance between the plane \c *this and a point \a p.	130	/** \returns the signed distance between the plane \c *this and a point \a p.
131	* \sa absDistance()	131	* \sa absDistance()
132	*/	132	*/
133	inline Scalar signedDistance(const VectorType& p) const { return normal().dot(p) + offset(); }	133	inline Scalar signedDistance(const VectorType& p) const { return normal().dot(p) + offset(); }
134		134
135	/** \returns the absolute distance between the plane \c *this and a point \a p.	135	/** \returns the absolute distance between the plane \c *this and a point \a p.
136	* \sa signedDistance()	136	* \sa signedDistance()
137	*/	137	*/
138	inline Scalar absDistance(const VectorType& p) const { return internal::abs(signedDistance(p)); }	138	inline Scalar absDistance(const VectorType& p) const { using std::abs; return abs(signedDistance(p)); }
139		139
140	/** \returns the projection of a point \a p onto the plane \c *this.	140	/** \returns the projection of a point \a p onto the plane \c *this.
141	*/	141	*/
142	inline VectorType projection(const VectorType& p) const { return p - signedDistance(p) * normal(); }	142	inline VectorType projection(const VectorType& p) const { return p - signedDistance(p) * normal(); }
143		143
144	/** \returns a constant reference to the unit normal vector of the plane, which corresponds	144	/** \returns a constant reference to the unit normal vector of the plane, which corresponds
145	* to the linear part of the implicit equation.	145	* to the linear part of the implicit equation.
146	*/	146	*/
Lines 173-195 public: Link Here
173	/** \returns the intersection of *this with \a other.	173	/** \returns the intersection of *this with \a other.
174	*	174	*
175	* \warning The ambient space must be a plane, i.e. have dimension 2, so that \c *this and \a other are lines.	175	* \warning The ambient space must be a plane, i.e. have dimension 2, so that \c *this and \a other are lines.
176	*	176	*
177	* \note If \a other is approximately parallel to this, this method will return any point on this.	177	* \note If \a other is approximately parallel to this, this method will return any point on this.
178	*/	178	*/
179	VectorType intersection(const Hyperplane& other) const	179	VectorType intersection(const Hyperplane& other) const
180	{	180	{
		181	using std::abs;
181	EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)	182	EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
182	Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0);	183	Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0);
183	// since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests	184	// since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests
184	// whether the two lines are approximately parallel.	185	// whether the two lines are approximately parallel.
185	if(internal::isMuchSmallerThan(det, Scalar(1)))	186	if(internal::isMuchSmallerThan(det, Scalar(1)))
186	{ // special case where the two lines are approximately parallel. Pick any point on the first line.	187	{ // special case where the two lines are approximately parallel. Pick any point on the first line.
187	if(internal::abs(coeffs().coeff(1))>internal::abs(coeffs().coeff(0)))	188	if(abs(coeffs().coeff(1))>abs(coeffs().coeff(0)))
188	return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0));	189	return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0));
189	else	190	else
190	return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0));	191	return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0));
191	}	192	}
192	else	193	else
193	{ // general case	194	{ // general case
194	Scalar invdet = Scalar(1) / det;	195	Scalar invdet = Scalar(1) / det;
195	return VectorType(invdet(coeffs().coeff(1)other.coeffs().coeff(2)-other.coeffs().coeff(1)*coeffs().coeff(2)),	196	return VectorType(invdet(coeffs().coeff(1)other.coeffs().coeff(2)-other.coeffs().coeff(1)*coeffs().coeff(2)),

Lines 82-98 public: Link Here

(-)a/Eigen/src/Geometry/ParametrizedLine.h (-1 / +1 lines)
82	RealScalar squaredDistance(const VectorType& p) const	82	RealScalar squaredDistance(const VectorType& p) const
83	{	83	{
84	VectorType diff = p - origin();	84	VectorType diff = p - origin();
85	return (diff - direction().dot(diff) * direction()).squaredNorm();	85	return (diff - direction().dot(diff) * direction()).squaredNorm();
86	}	86	}
87	/** \returns the distance of a point \a p to its projection onto the line \c *this.	87	/** \returns the distance of a point \a p to its projection onto the line \c *this.
88	* \sa squaredDistance()	88	* \sa squaredDistance()
89	*/	89	*/
90	RealScalar distance(const VectorType& p) const { return internal::sqrt(squaredDistance(p)); }	90	RealScalar distance(const VectorType& p) const { using std::sqrt; return sqrt(squaredDistance(p)); }
91		91
92	/** \returns the projection of a point \a p onto the line \c this. /	92	/** \returns the projection of a point \a p onto the line \c this. /
93	VectorType projection(const VectorType& p) const	93	VectorType projection(const VectorType& p) const
94	{ return origin() + direction().dot(p-origin()) * direction(); }	94	{ return origin() + direction().dot(p-origin()) * direction(); }
95		95
96	VectorType pointAt(const Scalar& t) const;	96	VectorType pointAt(const Scalar& t) const;
97		97
98	template <int OtherOptions>	98	template <int OtherOptions>

Lines 500-518 EIGEN_STRONG_INLINE Derived& QuaternionB Link Here

(-)a/Eigen/src/Geometry/Quaternion.h (-10 / +17 lines)
500	return derived();	500	return derived();
501	}	501	}
502		502
503	/** Set \c this from an angle-axis \a aa and returns a reference to \c this	503	/** Set \c this from an angle-axis \a aa and returns a reference to \c this
504	*/	504	*/
505	template<class Derived>	505	template<class Derived>
506	EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const AngleAxisType& aa)	506	EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const AngleAxisType& aa)
507	{	507	{
		508	using std::cos;
		509	using std::sin;
508	Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings	510	Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings
509	this->w() = internal::cos(ha);	511	this->w() = cos(ha);
510	this->vec() = internal::sin(ha) * aa.axis();	512	this->vec() = sin(ha) * aa.axis();
511	return derived();	513	return derived();
512	}	514	}
513		515
514	/** Set \c *this from the expression \a xpr:	516	/** Set \c *this from the expression \a xpr:
515	* - if \a xpr is a 4x1 vector, then \a xpr is assumed to be a quaternion	517	* - if \a xpr is a 4x1 vector, then \a xpr is assumed to be a quaternion
516	* - if \a xpr is a 3x3 matrix, then \a xpr is assumed to be rotation matrix	518	* - if \a xpr is a 3x3 matrix, then \a xpr is assumed to be rotation matrix
517	* and \a xpr is converted to a quaternion	519	* and \a xpr is converted to a quaternion
518	*/	520	*/
Lines 576-591 QuaternionBase<Derived>::toRotationMatri Link Here
576	* Note that the two input vectors do \b not have to be normalized, and	578	* Note that the two input vectors do \b not have to be normalized, and
577	* do not need to have the same norm.	579	* do not need to have the same norm.
578	*/	580	*/
579	template<class Derived>	581	template<class Derived>
580	template<typename Derived1, typename Derived2>	582	template<typename Derived1, typename Derived2>
581	inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)	583	inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
582	{	584	{
583	using std::max;	585	using std::max;
		586	using std::sqrt;
584	Vector3 v0 = a.normalized();	587	Vector3 v0 = a.normalized();
585	Vector3 v1 = b.normalized();	588	Vector3 v1 = b.normalized();
586	Scalar c = v1.dot(v0);	589	Scalar c = v1.dot(v0);
587		590
588	// if dot == -1, vectors are nearly opposites	591	// if dot == -1, vectors are nearly opposites
589	// => accuraletly compute the rotation axis by computing the	592	// => accuraletly compute the rotation axis by computing the
590	// intersection of the two planes. This is done by solving:	593	// intersection of the two planes. This is done by solving:
591	// x^T v0 = 0	594	// x^T v0 = 0
Lines 596-617 inline Derived& QuaternionBase<Derived>: Link Here
596	if (c < Scalar(-1)+NumTraits<Scalar>::dummy_precision())	599	if (c < Scalar(-1)+NumTraits<Scalar>::dummy_precision())
597	{	600	{
598	c = max<Scalar>(c,-1);	601	c = max<Scalar>(c,-1);
599	Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();	602	Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
600	JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);	603	JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
601	Vector3 axis = svd.matrixV().col(2);	604	Vector3 axis = svd.matrixV().col(2);
602		605
603	Scalar w2 = (Scalar(1)+c)*Scalar(0.5);	606	Scalar w2 = (Scalar(1)+c)*Scalar(0.5);
604	this->w() = internal::sqrt(w2);	607	this->w() = sqrt(w2);
605	this->vec() = axis * internal::sqrt(Scalar(1) - w2);	608	this->vec() = axis * sqrt(Scalar(1) - w2);
606	return derived();	609	return derived();
607	}	610	}
608	Vector3 axis = v0.cross(v1);	611	Vector3 axis = v0.cross(v1);
609	Scalar s = internal::sqrt((Scalar(1)+c)*Scalar(2));	612	Scalar s = sqrt((Scalar(1)+c)*Scalar(2));
610	Scalar invs = Scalar(1)/s;	613	Scalar invs = Scalar(1)/s;
611	this->vec() = axis * invs;	614	this->vec() = axis * invs;
612	this->w() = s * Scalar(0.5);	615	this->w() = s * Scalar(0.5);
613		616
614	return derived();	617	return derived();
615	}	618	}
616		619
617		620
Lines 672-738 QuaternionBase<Derived>::conjugate() con Link Here
672	* \sa dot()	675	* \sa dot()
673	*/	676	*/
674	template <class Derived>	677	template <class Derived>
675	template <class OtherDerived>	678	template <class OtherDerived>
676	inline typename internal::traits<Derived>::Scalar	679	inline typename internal::traits<Derived>::Scalar
677	QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& other) const	680	QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& other) const
678	{	681	{
679	using std::acos;	682	using std::acos;
680	double d = internal::abs(this->dot(other));	683	using std::abs;
		684	double d = abs(this->dot(other));
681	if (d>=1.0)	685	if (d>=1.0)
682	return Scalar(0);	686	return Scalar(0);
683	return static_cast<Scalar>(2 * acos(d));	687	return static_cast<Scalar>(2 * acos(d));
684	}	688	}
685		689
686	/** \returns the spherical linear interpolation between the two quaternions	690	/** \returns the spherical linear interpolation between the two quaternions
687	* \c *this and \a other at the parameter \a t	691	* \c *this and \a other at the parameter \a t
688	*/	692	*/
689	template <class Derived>	693	template <class Derived>
690	template <class OtherDerived>	694	template <class OtherDerived>
691	Quaternion<typename internal::traits<Derived>::Scalar>	695	Quaternion<typename internal::traits<Derived>::Scalar>
692	QuaternionBase<Derived>::slerp(Scalar t, const QuaternionBase<OtherDerived>& other) const	696	QuaternionBase<Derived>::slerp(Scalar t, const QuaternionBase<OtherDerived>& other) const
693	{	697	{
694	using std::acos;	698	using std::acos;
		699	using std::sin;
		700	using std::abs;
695	static const Scalar one = Scalar(1) - NumTraits<Scalar>::epsilon();	701	static const Scalar one = Scalar(1) - NumTraits<Scalar>::epsilon();
696	Scalar d = this->dot(other);	702	Scalar d = this->dot(other);
697	Scalar absD = internal::abs(d);	703	Scalar absD = abs(d);
698		704
699	Scalar scale0;	705	Scalar scale0;
700	Scalar scale1;	706	Scalar scale1;
701		707
702	if(absD>=one)	708	if(absD>=one)
703	{	709	{
704	scale0 = Scalar(1) - t;	710	scale0 = Scalar(1) - t;
705	scale1 = t;	711	scale1 = t;
706	}	712	}
707	else	713	else
708	{	714	{
709	// theta is the angle between the 2 quaternions	715	// theta is the angle between the 2 quaternions
710	Scalar theta = acos(absD);	716	Scalar theta = acos(absD);
711	Scalar sinTheta = internal::sin(theta);	717	Scalar sinTheta = sin(theta);
712		718
713	scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta;	719	scale0 = sin( ( Scalar(1) - t ) * theta) / sinTheta;
714	scale1 = internal::sin( ( t * theta) ) / sinTheta;	720	scale1 = sin( ( t * theta) ) / sinTheta;
715	}	721	}
716	if(d<0) scale1 = -scale1;	722	if(d<0) scale1 = -scale1;
717		723
718	return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());	724	return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
719	}	725	}
720		726
721	namespace internal {	727	namespace internal {
722		728
723	// set from a rotation matrix	729	// set from a rotation matrix
724	template<typename Other>	730	template<typename Other>
725	struct quaternionbase_assign_impl<Other,3,3>	731	struct quaternionbase_assign_impl<Other,3,3>
726	{	732	{
727	typedef typename Other::Scalar Scalar;	733	typedef typename Other::Scalar Scalar;
728	typedef DenseIndex Index;	734	typedef DenseIndex Index;
729	template<class Derived> static inline void run(QuaternionBase<Derived>& q, const Other& mat)	735	template<class Derived> static inline void run(QuaternionBase<Derived>& q, const Other& mat)
730	{	736	{
		737	using std::sqrt;
731	// This algorithm comes from "Quaternion Calculus and Fast Animation",	738	// This algorithm comes from "Quaternion Calculus and Fast Animation",
732	// Ken Shoemake, 1987 SIGGRAPH course notes	739	// Ken Shoemake, 1987 SIGGRAPH course notes
733	Scalar t = mat.trace();	740	Scalar t = mat.trace();
734	if (t > Scalar(0))	741	if (t > Scalar(0))
735	{	742	{
736	t = sqrt(t + Scalar(1.0));	743	t = sqrt(t + Scalar(1.0));
737	q.w() = Scalar(0.5)*t;	744	q.w() = Scalar(0.5)*t;
738	t = Scalar(0.5)/t;	745	t = Scalar(0.5)/t;

Lines 128-154 typedef Rotation2D<double> Rotation2Dd; Link Here

(-)a/Eigen/src/Geometry/Rotation2D.h (-3 / +6 lines)
128	/** Set \c *this from a 2x2 rotation matrix \a mat.	128	/** Set \c *this from a 2x2 rotation matrix \a mat.
129	* In other words, this function extract the rotation angle	129	* In other words, this function extract the rotation angle
130	* from the rotation matrix.	130	* from the rotation matrix.
131	*/	131	*/
132	template<typename Scalar>	132	template<typename Scalar>
133	template<typename Derived>	133	template<typename Derived>
134	Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)	134	Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
135	{	135	{
		136	using std::atan2;
136	EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)	137	EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
137	m_angle = internal::atan2(mat.coeff(1,0), mat.coeff(0,0));	138	m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
138	return *this;	139	return *this;
139	}	140	}
140		141
141	/** Constructs and \returns an equivalent 2x2 rotation matrix.	142	/** Constructs and \returns an equivalent 2x2 rotation matrix.
142	*/	143	*/
143	template<typename Scalar>	144	template<typename Scalar>
144	typename Rotation2D<Scalar>::Matrix2	145	typename Rotation2D<Scalar>::Matrix2
145	Rotation2D<Scalar>::toRotationMatrix(void) const	146	Rotation2D<Scalar>::toRotationMatrix(void) const
146	{	147	{
147	Scalar sinA = internal::sin(m_angle);	148	using std::sin;
148	Scalar cosA = internal::cos(m_angle);	149	using std::cos;
		150	Scalar sinA = sin(m_angle);
		151	Scalar cosA = cos(m_angle);
149	return (Matrix2() << cosA, -sinA, sinA, cosA).finished();	152	return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
150	}	153	}
151		154
152	} // end namespace Eigen	155	} // end namespace Eigen
153		156
154	#endif // EIGEN_ROTATION2D_H	157	#endif // EIGEN_ROTATION2D_H

Lines 62-92 void MatrixBase<Derived>::makeHouseholde Link Here

(-)a/Eigen/src/Householder/Householder.h (-1 / +2 lines)
62	*/	62	*/
63	template<typename Derived>	63	template<typename Derived>
64	template<typename EssentialPart>	64	template<typename EssentialPart>
65	void MatrixBase<Derived>::makeHouseholder(	65	void MatrixBase<Derived>::makeHouseholder(
66	EssentialPart& essential,	66	EssentialPart& essential,
67	Scalar& tau,	67	Scalar& tau,
68	RealScalar& beta) const	68	RealScalar& beta) const
69	{	69	{
		70	using std::sqrt;
70	EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)	71	EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)
71	VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size()-1);	72	VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size()-1);
72		73
73	RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm();	74	RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm();
74	Scalar c0 = coeff(0);	75	Scalar c0 = coeff(0);
75		76
76	if(tailSqNorm == RealScalar(0) && internal::imag(c0)==RealScalar(0))	77	if(tailSqNorm == RealScalar(0) && internal::imag(c0)==RealScalar(0))
77	{	78	{
78	tau = RealScalar(0);	79	tau = RealScalar(0);
79	beta = internal::real(c0);	80	beta = internal::real(c0);
80	essential.setZero();	81	essential.setZero();
81	}	82	}
82	else	83	else
83	{	84	{
84	beta = internal::sqrt(internal::abs2(c0) + tailSqNorm);	85	beta = sqrt(internal::abs2(c0) + tailSqNorm);
85	if (internal::real(c0)>=RealScalar(0))	86	if (internal::real(c0)>=RealScalar(0))
86	beta = -beta;	87	beta = -beta;
87	essential = tail / (c0 - beta);	88	essential = tail / (c0 - beta);
88	tau = internal::conj((beta - c0) / beta);	89	tau = internal::conj((beta - c0) / beta);
89	}	90	}
90	}	91	}
91		92
92	/** Apply the elementary reflector H given by	93	/** Apply the elementary reflector H given by

Lines 76-114 template<typename Scalar> class JacobiRo Link Here

(-)a/Eigen/src/Jacobi/Jacobi.h (-14 / +20 lines)
76	/** Makes \c *this as a Jacobi rotation \a J such that applying \a J on both the right and left sides of the selfadjoint 2x2 matrix	76	/** Makes \c *this as a Jacobi rotation \a J such that applying \a J on both the right and left sides of the selfadjoint 2x2 matrix
77	* \f$ B = \left ( \begin{array}{cc} x & y \\ \overline y & z \end{array} \right )\f$ yields a diagonal matrix \f$ A = J^* B J \f$	77	* \f$ B = \left ( \begin{array}{cc} x & y \\ \overline y & z \end{array} \right )\f$ yields a diagonal matrix \f$ A = J^* B J \f$
78	*	78	*
79	* \sa MatrixBase::makeJacobi(const MatrixBase<Derived>&, Index, Index), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()	79	* \sa MatrixBase::makeJacobi(const MatrixBase<Derived>&, Index, Index), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
80	*/	80	*/
81	template<typename Scalar>	81	template<typename Scalar>
82	bool JacobiRotation<Scalar>::makeJacobi(RealScalar x, Scalar y, RealScalar z)	82	bool JacobiRotation<Scalar>::makeJacobi(RealScalar x, Scalar y, RealScalar z)
83	{	83	{
		84	using std::sqrt;
		85	using std::abs;
84	typedef typename NumTraits<Scalar>::Real RealScalar;	86	typedef typename NumTraits<Scalar>::Real RealScalar;
85	if(y == Scalar(0))	87	if(y == Scalar(0))
86	{	88	{
87	m_c = Scalar(1);	89	m_c = Scalar(1);
88	m_s = Scalar(0);	90	m_s = Scalar(0);
89	return false;	91	return false;
90	}	92	}
91	else	93	else
92	{	94	{
93	RealScalar tau = (x-z)/(RealScalar(2)*internal::abs(y));	95	RealScalar tau = (x-z)/(RealScalar(2)*abs(y));
94	RealScalar w = internal::sqrt(internal::abs2(tau) + RealScalar(1));	96	RealScalar w = sqrt(internal::abs2(tau) + RealScalar(1));
95	RealScalar t;	97	RealScalar t;
96	if(tau>RealScalar(0))	98	if(tau>RealScalar(0))
97	{	99	{
98	t = RealScalar(1) / (tau + w);	100	t = RealScalar(1) / (tau + w);
99	}	101	}
100	else	102	else
101	{	103	{
102	t = RealScalar(1) / (tau - w);	104	t = RealScalar(1) / (tau - w);
103	}	105	}
104	RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);	106	RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
105	RealScalar n = RealScalar(1) / internal::sqrt(internal::abs2(t)+RealScalar(1));	107	RealScalar n = RealScalar(1) / sqrt(internal::abs2(t)+RealScalar(1));
106	m_s = - sign_t * (internal::conj(y) / internal::abs(y)) * internal::abs(t) * n;	108	m_s = - sign_t * (internal::conj(y) / abs(y)) * abs(t) * n;
107	m_c = n;	109	m_c = n;
108	return true;	110	return true;
109	}	111	}
110	}	112	}
111		113
112	/** Makes \c *this as a Jacobi rotation \c J such that applying \a J on both the right and left sides of the 2x2 selfadjoint matrix	114	/** Makes \c *this as a Jacobi rotation \c J such that applying \a J on both the right and left sides of the 2x2 selfadjoint matrix
113	* \f$ B = \left ( \begin{array}{cc} \text{this}_{pp} & \text{this}_{pq} \\ (\text{this}_{pq})^* & \text{this}_{qq} \end{array} \right )\f$ yields	115	* \f$ B = \left ( \begin{array}{cc} \text{this}_{pp} & \text{this}_{pq} \\ (\text{this}_{pq})^* & \text{this}_{qq} \end{array} \right )\f$ yields
114	* a diagonal matrix \f$ A = J^* B J \f$	116	* a diagonal matrix \f$ A = J^* B J \f$
Lines 147-243 void JacobiRotation<Scalar>::makeGivens( Link Here
147	makeGivens(p, q, z, typename internal::conditional<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>::type());	149	makeGivens(p, q, z, typename internal::conditional<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>::type());
148	}	150	}
149		151
150		152
151	// specialization for complexes	153	// specialization for complexes
152	template<typename Scalar>	154	template<typename Scalar>
153	void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type)	155	void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type)
154	{	156	{
		157	using std::sqrt;
		158	using std::abs;
155	if(q==Scalar(0))	159	if(q==Scalar(0))
156	{	160	{
157	m_c = internal::real(p)<0 ? Scalar(-1) : Scalar(1);	161	m_c = internal::real(p)<0 ? Scalar(-1) : Scalar(1);
158	m_s = 0;	162	m_s = 0;
159	if(r) r = m_c p;	163	if(r) r = m_c p;
160	}	164	}
161	else if(p==Scalar(0))	165	else if(p==Scalar(0))
162	{	166	{
163	m_c = 0;	167	m_c = 0;
164	m_s = -q/internal::abs(q);	168	m_s = -q/abs(q);
165	if(r) *r = internal::abs(q);	169	if(r) *r = abs(q);
166	}	170	}
167	else	171	else
168	{	172	{
169	RealScalar p1 = internal::norm1(p);	173	RealScalar p1 = internal::norm1(p);
170	RealScalar q1 = internal::norm1(q);	174	RealScalar q1 = internal::norm1(q);
171	if(p1>=q1)	175	if(p1>=q1)
172	{	176	{
173	Scalar ps = p / p1;	177	Scalar ps = p / p1;
174	RealScalar p2 = internal::abs2(ps);	178	RealScalar p2 = internal::abs2(ps);
175	Scalar qs = q / p1;	179	Scalar qs = q / p1;
176	RealScalar q2 = internal::abs2(qs);	180	RealScalar q2 = internal::abs2(qs);
177		181
178	RealScalar u = internal::sqrt(RealScalar(1) + q2/p2);	182	RealScalar u = sqrt(RealScalar(1) + q2/p2);
179	if(internal::real(p)<RealScalar(0))	183	if(internal::real(p)<RealScalar(0))
180	u = -u;	184	u = -u;
181		185
182	m_c = Scalar(1)/u;	186	m_c = Scalar(1)/u;
183	m_s = -qsinternal::conj(ps)(m_c/p2);	187	m_s = -qsinternal::conj(ps)(m_c/p2);
184	if(r) r = p u;	188	if(r) r = p u;
185	}	189	}
186	else	190	else
187	{	191	{
188	Scalar ps = p / q1;	192	Scalar ps = p / q1;
189	RealScalar p2 = internal::abs2(ps);	193	RealScalar p2 = internal::abs2(ps);
190	Scalar qs = q / q1;	194	Scalar qs = q / q1;
191	RealScalar q2 = internal::abs2(qs);	195	RealScalar q2 = internal::abs2(qs);
192		196
193	RealScalar u = q1 * internal::sqrt(p2 + q2);	197	RealScalar u = q1 * sqrt(p2 + q2);
194	if(internal::real(p)<RealScalar(0))	198	if(internal::real(p)<RealScalar(0))
195	u = -u;	199	u = -u;
196		200
197	p1 = internal::abs(p);	201	p1 = abs(p);
198	ps = p/p1;	202	ps = p/p1;
199	m_c = p1/u;	203	m_c = p1/u;
200	m_s = -internal::conj(ps) * (q/u);	204	m_s = -internal::conj(ps) * (q/u);
201	if(r) r = ps u;	205	if(r) r = ps u;
202	}	206	}
203	}	207	}
204	}	208	}
205		209
206	// specialization for reals	210	// specialization for reals
207	template<typename Scalar>	211	template<typename Scalar>
208	void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)	212	void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)
209	{	213	{
		214	using std::sqrt;
		215	using std::abs;
210	if(q==Scalar(0))	216	if(q==Scalar(0))
211	{	217	{
212	m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);	218	m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
213	m_s = Scalar(0);	219	m_s = Scalar(0);
214	if(r) *r = internal::abs(p);	220	if(r) *r = abs(p);
215	}	221	}
216	else if(p==Scalar(0))	222	else if(p==Scalar(0))
217	{	223	{
218	m_c = Scalar(0);	224	m_c = Scalar(0);
219	m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);	225	m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
220	if(r) *r = internal::abs(q);	226	if(r) *r = abs(q);
221	}	227	}
222	else if(internal::abs(p) > internal::abs(q))	228	else if(abs(p) > abs(q))
223	{	229	{
224	Scalar t = q/p;	230	Scalar t = q/p;
225	Scalar u = internal::sqrt(Scalar(1) + internal::abs2(t));	231	Scalar u = sqrt(Scalar(1) + internal::abs2(t));
226	if(p<Scalar(0))	232	if(p<Scalar(0))
227	u = -u;	233	u = -u;
228	m_c = Scalar(1)/u;	234	m_c = Scalar(1)/u;
229	m_s = -t * m_c;	235	m_s = -t * m_c;
230	if(r) r = p u;	236	if(r) r = p u;
231	}	237	}
232	else	238	else
233	{	239	{
234	Scalar t = p/q;	240	Scalar t = p/q;
235	Scalar u = internal::sqrt(Scalar(1) + internal::abs2(t));	241	Scalar u = sqrt(Scalar(1) + internal::abs2(t));
236	if(q<Scalar(0))	242	if(q<Scalar(0))
237	u = -u;	243	u = -u;
238	m_s = -Scalar(1)/u;	244	m_s = -Scalar(1)/u;
239	m_c = -t * m_s;	245	m_c = -t * m_s;
240	if(r) r = q u;	246	if(r) r = q u;
241	}	247	}
242		248
243	}	249	}

Lines 288-308 template<typename _MatrixType> class Ful Link Here

(-)a/Eigen/src/LU/FullPivLU.h (-2 / +5 lines)
288	/** \returns the rank of the matrix of which *this is the LU decomposition.	288	/** \returns the rank of the matrix of which *this is the LU decomposition.
289	*	289	*
290	* \note This method has to determine which pivots should be considered nonzero.	290	* \note This method has to determine which pivots should be considered nonzero.
291	* For that, it uses the threshold value that you can control by calling	291	* For that, it uses the threshold value that you can control by calling
292	* setThreshold(const RealScalar&).	292	* setThreshold(const RealScalar&).
293	*/	293	*/
294	inline Index rank() const	294	inline Index rank() const
295	{	295	{
		296	using std::abs;
296	eigen_assert(m_isInitialized && "LU is not initialized.");	297	eigen_assert(m_isInitialized && "LU is not initialized.");
297	RealScalar premultiplied_threshold = internal::abs(m_maxpivot) * threshold();	298	RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
298	Index result = 0;	299	Index result = 0;
299	for(Index i = 0; i < m_nonzero_pivots; ++i)	300	for(Index i = 0; i < m_nonzero_pivots; ++i)
300	result += (internal::abs(m_lu.coeff(i,i)) > premultiplied_threshold);	301	result += (abs(m_lu.coeff(i,i)) > premultiplied_threshold);
301	return result;	302	return result;
302	}	303	}
303		304
304	/** \returns the dimension of the kernel of the matrix of which *this is the LU decomposition.	305	/** \returns the dimension of the kernel of the matrix of which *this is the LU decomposition.
305	*	306	*
306	* \note This method has to determine which pivots should be considered nonzero.	307	* \note This method has to determine which pivots should be considered nonzero.
307	* For that, it uses the threshold value that you can control by calling	308	* For that, it uses the threshold value that you can control by calling
308	* setThreshold(const RealScalar&).	309	* setThreshold(const RealScalar&).
Lines 542-557 struct kernel_retval<FullPivLU<_MatrixTy Link Here
542		543
543	enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(	544	enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
544	MatrixType::MaxColsAtCompileTime,	545	MatrixType::MaxColsAtCompileTime,
545	MatrixType::MaxRowsAtCompileTime)	546	MatrixType::MaxRowsAtCompileTime)
546	};	547	};
547		548
548	template<typename Dest> void evalTo(Dest& dst) const	549	template<typename Dest> void evalTo(Dest& dst) const
549	{	550	{
		551	using std::abs;
550	const Index cols = dec().matrixLU().cols(), dimker = cols - rank();	552	const Index cols = dec().matrixLU().cols(), dimker = cols - rank();
551	if(dimker == 0)	553	if(dimker == 0)
552	{	554	{
553	// The Kernel is just {0}, so it doesn't have a basis properly speaking, but let's	555	// The Kernel is just {0}, so it doesn't have a basis properly speaking, but let's
554	// avoid crashing/asserting as that depends on floating point calculations. Let's	556	// avoid crashing/asserting as that depends on floating point calculations. Let's
555	// just return a single column vector filled with zeros.	557	// just return a single column vector filled with zeros.
556	dst.setZero();	558	dst.setZero();
557	return;	559	return;
Lines 627-642 struct image_retval<FullPivLU<_MatrixTyp Link Here
627		629
628	enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(	630	enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
629	MatrixType::MaxColsAtCompileTime,	631	MatrixType::MaxColsAtCompileTime,
630	MatrixType::MaxRowsAtCompileTime)	632	MatrixType::MaxRowsAtCompileTime)
631	};	633	};
632		634
633	template<typename Dest> void evalTo(Dest& dst) const	635	template<typename Dest> void evalTo(Dest& dst) const
634	{	636	{
		637	using std::abs;
635	if(rank() == 0)	638	if(rank() == 0)
636	{	639	{
637	// The Image is just {0}, so it doesn't have a basis properly speaking, but let's	640	// The Image is just {0}, so it doesn't have a basis properly speaking, but let's
638	// avoid crashing/asserting as that depends on floating point calculations. Let's	641	// avoid crashing/asserting as that depends on floating point calculations. Let's
639	// just return a single column vector filled with zeros.	642	// just return a single column vector filled with zeros.
640	dst.setZero();	643	dst.setZero();
641	return;	644	return;
642	}	645	}

Lines 50-65 struct compute_inverse_and_det_with_chec Link Here

(-)a/Eigen/src/LU/Inverse.h (+4 lines)
50	static inline void run(	50	static inline void run(
51	const MatrixType& matrix,	51	const MatrixType& matrix,
52	const typename MatrixType::RealScalar& absDeterminantThreshold,	52	const typename MatrixType::RealScalar& absDeterminantThreshold,
53	ResultType& result,	53	ResultType& result,
54	typename ResultType::Scalar& determinant,	54	typename ResultType::Scalar& determinant,
55	bool& invertible	55	bool& invertible
56	)	56	)
57	{	57	{
		58	using std::abs;
58	determinant = matrix.coeff(0,0);	59	determinant = matrix.coeff(0,0);
59	invertible = abs(determinant) > absDeterminantThreshold;	60	invertible = abs(determinant) > absDeterminantThreshold;
60	if(invertible) result.coeffRef(0,0) = typename ResultType::Scalar(1) / determinant;	61	if(invertible) result.coeffRef(0,0) = typename ResultType::Scalar(1) / determinant;
61	}	62	}
62	};	63	};
63		64
64	/****************************	65	/****************************
65	* Size 2 implementation *	66	* Size 2 implementation *
Lines 93-108 struct compute_inverse_and_det_with_chec Link Here
93	static inline void run(	94	static inline void run(
94	const MatrixType& matrix,	95	const MatrixType& matrix,
95	const typename MatrixType::RealScalar& absDeterminantThreshold,	96	const typename MatrixType::RealScalar& absDeterminantThreshold,
96	ResultType& inverse,	97	ResultType& inverse,
97	typename ResultType::Scalar& determinant,	98	typename ResultType::Scalar& determinant,
98	bool& invertible	99	bool& invertible
99	)	100	)
100	{	101	{
		102	using std::abs;
101	typedef typename ResultType::Scalar Scalar;	103	typedef typename ResultType::Scalar Scalar;
102	determinant = matrix.determinant();	104	determinant = matrix.determinant();
103	invertible = abs(determinant) > absDeterminantThreshold;	105	invertible = abs(determinant) > absDeterminantThreshold;
104	if(!invertible) return;	106	if(!invertible) return;
105	const Scalar invdet = Scalar(1) / determinant;	107	const Scalar invdet = Scalar(1) / determinant;
106	compute_inverse_size2_helper(matrix, invdet, inverse);	108	compute_inverse_size2_helper(matrix, invdet, inverse);
107	}	109	}
108	};	110	};
Lines 162-177 struct compute_inverse_and_det_with_chec Link Here
162	static inline void run(	164	static inline void run(
163	const MatrixType& matrix,	165	const MatrixType& matrix,
164	const typename MatrixType::RealScalar& absDeterminantThreshold,	166	const typename MatrixType::RealScalar& absDeterminantThreshold,
165	ResultType& inverse,	167	ResultType& inverse,
166	typename ResultType::Scalar& determinant,	168	typename ResultType::Scalar& determinant,
167	bool& invertible	169	bool& invertible
168	)	170	)
169	{	171	{
		172	using std::abs;
170	typedef typename ResultType::Scalar Scalar;	173	typedef typename ResultType::Scalar Scalar;
171	Matrix<Scalar,3,1> cofactors_col0;	174	Matrix<Scalar,3,1> cofactors_col0;
172	cofactors_col0.coeffRef(0) = cofactor_3x3<MatrixType,0,0>(matrix);	175	cofactors_col0.coeffRef(0) = cofactor_3x3<MatrixType,0,0>(matrix);
173	cofactors_col0.coeffRef(1) = cofactor_3x3<MatrixType,1,0>(matrix);	176	cofactors_col0.coeffRef(1) = cofactor_3x3<MatrixType,1,0>(matrix);
174	cofactors_col0.coeffRef(2) = cofactor_3x3<MatrixType,2,0>(matrix);	177	cofactors_col0.coeffRef(2) = cofactor_3x3<MatrixType,2,0>(matrix);
175	determinant = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();	178	determinant = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
176	invertible = abs(determinant) > absDeterminantThreshold;	179	invertible = abs(determinant) > absDeterminantThreshold;
177	if(!invertible) return;	180	if(!invertible) return;
Lines 246-261 struct compute_inverse_and_det_with_chec Link Here
246	static inline void run(	249	static inline void run(
247	const MatrixType& matrix,	250	const MatrixType& matrix,
248	const typename MatrixType::RealScalar& absDeterminantThreshold,	251	const typename MatrixType::RealScalar& absDeterminantThreshold,
249	ResultType& inverse,	252	ResultType& inverse,
250	typename ResultType::Scalar& determinant,	253	typename ResultType::Scalar& determinant,
251	bool& invertible	254	bool& invertible
252	)	255	)
253	{	256	{
		257	using std::abs;
254	determinant = matrix.determinant();	258	determinant = matrix.determinant();
255	invertible = abs(determinant) > absDeterminantThreshold;	259	invertible = abs(determinant) > absDeterminantThreshold;
256	if(invertible) compute_inverse<MatrixType, ResultType>::run(matrix, inverse);	260	if(invertible) compute_inverse<MatrixType, ResultType>::run(matrix, inverse);
257	}	261	}
258	};	262	};
259		263
260	/*************************	264	/*************************
261	* MatrixBase methods *	265	* MatrixBase methods *

Lines 176-196 template<typename _MatrixType> class Col Link Here

(-)a/Eigen/src/QR/ColPivHouseholderQR.h (-4 / +7 lines)
176	/** \returns the rank of the matrix of which *this is the QR decomposition.	176	/** \returns the rank of the matrix of which *this is the QR decomposition.
177	*	177	*
178	* \note This method has to determine which pivots should be considered nonzero.	178	* \note This method has to determine which pivots should be considered nonzero.
179	* For that, it uses the threshold value that you can control by calling	179	* For that, it uses the threshold value that you can control by calling
180	* setThreshold(const RealScalar&).	180	* setThreshold(const RealScalar&).
181	*/	181	*/
182	inline Index rank() const	182	inline Index rank() const
183	{	183	{
		184	using std::abs;
184	eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");	185	eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
185	RealScalar premultiplied_threshold = internal::abs(m_maxpivot) * threshold();	186	RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
186	Index result = 0;	187	Index result = 0;
187	for(Index i = 0; i < m_nonzero_pivots; ++i)	188	for(Index i = 0; i < m_nonzero_pivots; ++i)
188	result += (internal::abs(m_qr.coeff(i,i)) > premultiplied_threshold);	189	result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
189	return result;	190	return result;
190	}	191	}
191		192
192	/** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.	193	/** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
193	*	194	*
194	* \note This method has to determine which pivots should be considered nonzero.	195	* \note This method has to determine which pivots should be considered nonzero.
195	* For that, it uses the threshold value that you can control by calling	196	* For that, it uses the threshold value that you can control by calling
196	* setThreshold(const RealScalar&).	197	* setThreshold(const RealScalar&).
Lines 337-368 template<typename _MatrixType> class Col Link Here
337	RealScalar m_prescribedThreshold, m_maxpivot;	338	RealScalar m_prescribedThreshold, m_maxpivot;
338	Index m_nonzero_pivots;	339	Index m_nonzero_pivots;
339	Index m_det_pq;	340	Index m_det_pq;
340	};	341	};
341		342
342	template<typename MatrixType>	343	template<typename MatrixType>
343	typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const	344	typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const
344	{	345	{
		346	using std::abs;
345	eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");	347	eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
346	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");	348	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
347	return internal::abs(m_qr.diagonal().prod());	349	return abs(m_qr.diagonal().prod());
348	}	350	}
349		351
350	template<typename MatrixType>	352	template<typename MatrixType>
351	typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::logAbsDeterminant() const	353	typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::logAbsDeterminant() const
352	{	354	{
353	eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");	355	eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
354	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");	356	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
355	return m_qr.diagonal().cwiseAbs().array().log().sum();	357	return m_qr.diagonal().cwiseAbs().array().log().sum();
356	}	358	}
357		359
358	template<typename MatrixType>	360	template<typename MatrixType>
359	ColPivHouseholderQR<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const MatrixType& matrix)	361	ColPivHouseholderQR<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const MatrixType& matrix)
360	{	362	{
		363	using std::abs;
361	Index rows = matrix.rows();	364	Index rows = matrix.rows();
362	Index cols = matrix.cols();	365	Index cols = matrix.cols();
363	Index size = matrix.diagonalSize();	366	Index size = matrix.diagonalSize();
364		367
365	m_qr = matrix;	368	m_qr = matrix;
366	m_hCoeffs.resize(size);	369	m_hCoeffs.resize(size);
367		370
368	m_temp.resize(cols);	371	m_temp.resize(cols);
Lines 421-437 ColPivHouseholderQR<MatrixType>& ColPivH Link Here
421	// generate the householder vector, store it below the diagonal	424	// generate the householder vector, store it below the diagonal
422	RealScalar beta;	425	RealScalar beta;
423	m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);	426	m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
424		427
425	// apply the householder transformation to the diagonal coefficient	428	// apply the householder transformation to the diagonal coefficient
426	m_qr.coeffRef(k,k) = beta;	429	m_qr.coeffRef(k,k) = beta;
427		430
428	// remember the maximum absolute value of diagonal coefficients	431	// remember the maximum absolute value of diagonal coefficients
429	if(internal::abs(beta) > m_maxpivot) m_maxpivot = internal::abs(beta);	432	if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
430		433
431	// apply the householder transformation	434	// apply the householder transformation
432	m_qr.bottomRightCorner(rows-k, cols-k-1)	435	m_qr.bottomRightCorner(rows-k, cols-k-1)
433	.applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));	436	.applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
434		437
435	// update our table of squared norms of the columns	438	// update our table of squared norms of the columns
436	m_colSqNorms.tail(cols-k-1) -= m_qr.row(k).tail(cols-k-1).cwiseAbs2();	439	m_colSqNorms.tail(cols-k-1) -= m_qr.row(k).tail(cols-k-1).cwiseAbs2();
437	}	440	}

Lines 42-57 namespace Eigen { Link Here

(-)a/Eigen/src/QR/ColPivHouseholderQR_MKL.h (-2 / +3 lines)
42		42
43	#define EIGEN_MKL_QR_COLPIV(EIGTYPE, MKLTYPE, MKLPREFIX, EIGCOLROW, MKLCOLROW) \	43	#define EIGEN_MKL_QR_COLPIV(EIGTYPE, MKLTYPE, MKLPREFIX, EIGCOLROW, MKLCOLROW) \
44	template<> inline \	44	template<> inline \
45	ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >& \	45	ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >& \
46	ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >::compute( \	46	ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >::compute( \
47	const Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>& matrix) \	47	const Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>& matrix) \
48	\	48	\
49	{ \	49	{ \
		50	using std::abs; \
50	typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \	51	typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
51	typedef MatrixType::Scalar Scalar; \	52	typedef MatrixType::Scalar Scalar; \
52	typedef MatrixType::RealScalar RealScalar; \	53	typedef MatrixType::RealScalar RealScalar; \
53	Index rows = matrix.rows();\	54	Index rows = matrix.rows();\
54	Index cols = matrix.cols();\	55	Index cols = matrix.cols();\
55	Index size = matrix.diagonalSize();\	56	Index size = matrix.diagonalSize();\
56	\	57	\
57	m_qr = matrix;\	58	m_qr = matrix;\
Lines 66-85 ColPivHouseholderQR<Matrix<EIGTYPE, Dyna Link Here
66	m_colsPermutation.indices().setZero(); \	67	m_colsPermutation.indices().setZero(); \
67	\	68	\
68	lapack_int lda = m_qr.outerStride(), i; \	69	lapack_int lda = m_qr.outerStride(), i; \
69	lapack_int matrix_order = MKLCOLROW; \	70	lapack_int matrix_order = MKLCOLROW; \
70	LAPACKE_##MKLPREFIX##geqp3( matrix_order, rows, cols, (MKLTYPE)m_qr.data(), lda, (lapack_int)m_colsPermutation.indices().data(), (MKLTYPE*)m_hCoeffs.data()); \	71	LAPACKE_##MKLPREFIX##geqp3( matrix_order, rows, cols, (MKLTYPE)m_qr.data(), lda, (lapack_int)m_colsPermutation.indices().data(), (MKLTYPE*)m_hCoeffs.data()); \
71	m_isInitialized = true; \	72	m_isInitialized = true; \
72	m_maxpivot=m_qr.diagonal().cwiseAbs().maxCoeff(); \	73	m_maxpivot=m_qr.diagonal().cwiseAbs().maxCoeff(); \
73	m_hCoeffs.adjointInPlace(); \	74	m_hCoeffs.adjointInPlace(); \
74	RealScalar premultiplied_threshold = internal::abs(m_maxpivot) * threshold(); \	75	RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold(); \
75	lapack_int *perm = m_colsPermutation.indices().data(); \	76	lapack_int *perm = m_colsPermutation.indices().data(); \
76	for(i=0;i<size;i++) { \	77	for(i=0;i<size;i++) { \
77	m_nonzero_pivots += (internal::abs(m_qr.coeff(i,i)) > premultiplied_threshold);\	78	m_nonzero_pivots += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);\
78	} \	79	} \
79	for(i=0;i<cols;i++) perm[i]--;\	80	for(i=0;i<cols;i++) perm[i]--;\
80	\	81	\
81	/m_det_pq = (number_of_transpositions%2) ? -1 : 1; // TODO: It's not needed now; fix upon availability in Eigen / \	82	/m_det_pq = (number_of_transpositions%2) ? -1 : 1; // TODO: It's not needed now; fix upon availability in Eigen / \
82	\	83	\
83	return *this; \	84	return *this; \
84	}	85	}
85		86

Lines 196-216 template<typename _MatrixType> class Ful Link Here

(-)a/Eigen/src/QR/FullPivHouseholderQR.h (-4 / +7 lines)
196	/** \returns the rank of the matrix of which *this is the QR decomposition.	196	/** \returns the rank of the matrix of which *this is the QR decomposition.
197	*	197	*
198	* \note This method has to determine which pivots should be considered nonzero.	198	* \note This method has to determine which pivots should be considered nonzero.
199	* For that, it uses the threshold value that you can control by calling	199	* For that, it uses the threshold value that you can control by calling
200	* setThreshold(const RealScalar&).	200	* setThreshold(const RealScalar&).
201	*/	201	*/
202	inline Index rank() const	202	inline Index rank() const
203	{	203	{
		204	using std::abs;
204	eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");	205	eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
205	RealScalar premultiplied_threshold = internal::abs(m_maxpivot) * threshold();	206	RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
206	Index result = 0;	207	Index result = 0;
207	for(Index i = 0; i < m_nonzero_pivots; ++i)	208	for(Index i = 0; i < m_nonzero_pivots; ++i)
208	result += (internal::abs(m_qr.coeff(i,i)) > premultiplied_threshold);	209	result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
209	return result;	210	return result;
210	}	211	}
211		212
212	/** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.	213	/** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
213	*	214	*
214	* \note This method has to determine which pivots should be considered nonzero.	215	* \note This method has to determine which pivots should be considered nonzero.
215	* For that, it uses the threshold value that you can control by calling	216	* For that, it uses the threshold value that you can control by calling
216	* setThreshold(const RealScalar&).	217	* setThreshold(const RealScalar&).
Lines 357-388 template<typename _MatrixType> class Ful Link Here
357	Index m_nonzero_pivots;	358	Index m_nonzero_pivots;
358	RealScalar m_precision;	359	RealScalar m_precision;
359	Index m_det_pq;	360	Index m_det_pq;
360	};	361	};
361		362
362	template<typename MatrixType>	363	template<typename MatrixType>
363	typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const	364	typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const
364	{	365	{
		366	using std::abs;
365	eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");	367	eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
366	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");	368	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
367	return internal::abs(m_qr.diagonal().prod());	369	return abs(m_qr.diagonal().prod());
368	}	370	}
369		371
370	template<typename MatrixType>	372	template<typename MatrixType>
371	typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::logAbsDeterminant() const	373	typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::logAbsDeterminant() const
372	{	374	{
373	eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");	375	eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
374	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");	376	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
375	return m_qr.diagonal().cwiseAbs().array().log().sum();	377	return m_qr.diagonal().cwiseAbs().array().log().sum();
376	}	378	}
377		379
378	template<typename MatrixType>	380	template<typename MatrixType>
379	FullPivHouseholderQR<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(const MatrixType& matrix)	381	FullPivHouseholderQR<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(const MatrixType& matrix)
380	{	382	{
		383	using std::abs;
381	Index rows = matrix.rows();	384	Index rows = matrix.rows();
382	Index cols = matrix.cols();	385	Index cols = matrix.cols();
383	Index size = (std::min)(rows,cols);	386	Index size = (std::min)(rows,cols);
384		387
385	m_qr = matrix;	388	m_qr = matrix;
386	m_hCoeffs.resize(size);	389	m_hCoeffs.resize(size);
387		390
388	m_temp.resize(cols);	391	m_temp.resize(cols);
Lines 434-450 FullPivHouseholderQR<MatrixType>& FullPi Link Here
434	++number_of_transpositions;	437	++number_of_transpositions;
435	}	438	}
436		439
437	RealScalar beta;	440	RealScalar beta;
438	m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);	441	m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
439	m_qr.coeffRef(k,k) = beta;	442	m_qr.coeffRef(k,k) = beta;
440		443
441	// remember the maximum absolute value of diagonal coefficients	444	// remember the maximum absolute value of diagonal coefficients
442	if(internal::abs(beta) > m_maxpivot) m_maxpivot = internal::abs(beta);	445	if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
443		446
444	m_qr.bottomRightCorner(rows-k, cols-k-1)	447	m_qr.bottomRightCorner(rows-k, cols-k-1)
445	.applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));	448	.applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
446	}	449	}
447		450
448	m_cols_permutation.setIdentity(cols);	451	m_cols_permutation.setIdentity(cols);
449	for(Index k = 0; k < size; ++k)	452	for(Index k = 0; k < size; ++k)
450	m_cols_permutation.applyTranspositionOnTheRight(k, m_cols_transpositions.coeff(k));	453	m_cols_permutation.applyTranspositionOnTheRight(k, m_cols_transpositions.coeff(k));

Lines 176-194 template<typename _MatrixType> class Hou Link Here

(-)a/Eigen/src/QR/HouseholderQR.h (-1 / +2 lines)
176	HCoeffsType m_hCoeffs;	176	HCoeffsType m_hCoeffs;
177	RowVectorType m_temp;	177	RowVectorType m_temp;
178	bool m_isInitialized;	178	bool m_isInitialized;
179	};	179	};
180		180
181	template<typename MatrixType>	181	template<typename MatrixType>
182	typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const	182	typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const
183	{	183	{
		184	using std::abs;
184	eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");	185	eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
185	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");	186	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
186	return internal::abs(m_qr.diagonal().prod());	187	return abs(m_qr.diagonal().prod());
187	}	188	}
188		189
189	template<typename MatrixType>	190	template<typename MatrixType>
190	typename MatrixType::RealScalar HouseholderQR<MatrixType>::logAbsDeterminant() const	191	typename MatrixType::RealScalar HouseholderQR<MatrixType>::logAbsDeterminant() const
191	{	192	{
192	eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");	193	eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
193	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");	194	eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
194	return m_qr.diagonal().cwiseAbs().array().log().sum();	195	return m_qr.diagonal().cwiseAbs().array().log().sum();