Attachment #713 for bug #279

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

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




  *
  * \returns a reference to \c *this
  */
template<typename Derived>
template<typename OtherDerived>
EIGEN_STRONG_INLINE Derived &
ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)
{
  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

/** replaces \c *this by \c *this + \a other.
  *
  * \returns a reference to \c *this
  */
template<typename Derived>
template<typename OtherDerived>
EIGEN_STRONG_INLINE Derived &
ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)
{
  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

/** replaces \c *this by \c *this * \a other coefficient wise.
  *
  * \returns a reference to \c *this
  */
template<typename Derived>




  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
  
  dense_assignment_loop<Kernel>::run(kernel);
}

template<typename DstXprType, typename SrcXprType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(const DstXprType& dst, const SrcXprType& src)
{
  call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
}

/***************************************************************************
* Part 6 : Generic assignment
***************************************************************************/

// Based on the respective shapes of the destination and source,
// the class AssignmentKind determine the kind of assignment mechanism.

// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.
// So this intermediate function removes everything related to "assume-aliasing" such that Assignment
// does not has to bother about these annoying details.

template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src)
{
  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(const Dst& dst, const Src& src)
{
  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
                     
// Deal with "assume-aliasing"
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
  typename plain_matrix_type<Src>::type tmp(src);

  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
  
  Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias(Dst& dst, const Src& src)
{
  call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}

template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)
{
  Index dstRows = src.rows();
  Index dstCols = src.cols();

  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
  
  Assignment<Dst,Src,Func>::run(dst, src, func);
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
{
  call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}

// forward declaration
template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);

// Generic Dense to Dense assignment
template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Scalar>

};

// Generic assignment through evalTo.
// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Scalar>
{
  EIGEN_DEVICE_FUNC
  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
    src.evalTo(dst);
  }
};

} // namespace internal





  *
  * \returns a reference to \c *this
  */
template<typename Derived>
template<typename OtherDerived>
EIGEN_STRONG_INLINE Derived &
MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
{
  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

/** replaces \c *this by \c *this + \a other.
  *
  * \returns a reference to \c *this
  */
template<typename Derived>
template<typename OtherDerived>
EIGEN_STRONG_INLINE Derived &
MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
{
  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

} // end namespace Eigen

#endif // EIGEN_CWISE_BINARY_OP_H





struct Diagonal2Dense {};

template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };

// Diagonal matrix to Dense assignment
template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense, Scalar>
{
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    dst.setZero();
    dst.diagonal() = src.diagonal();
  }
  
  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  { dst.diagonal() += src.diagonal(); }
  
  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  { dst.diagonal() -= src.diagonal(); }
};

} // namespace internal

} // end namespace Eigen

#endif // EIGEN_DIAGONALMATRIX_H




                && U::IsVectorAtCompileTime
                && ((int(T::RowsAtCompileTime) == 1 && int(U::ColsAtCompileTime) == 1)
                      |  // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
                         // revert to || as soon as not needed anymore.
                    (int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1))
>
struct dot_nocheck
{
  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
  typedef typename conj_prod::result_type ResScalar;
  EIGEN_DEVICE_FUNC
  static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
  {
    return a.template binaryExpr<conj_prod>(b).sum();
  }
};

template<typename T, typename U>
struct dot_nocheck<T, U, true>
{
  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
  typedef typename conj_prod::result_type ResScalar;
  EIGEN_DEVICE_FUNC
  static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
  {
    return a.transpose().template binaryExpr<conj_prod>(b).sum();
  }
};

} // end namespace internal

/** \returns the dot product of *this with other.
  *
  * \only_for_vectors

  * (sesquilinear) dot product, conjugate-linear in the first variable and linear in the
  * second variable.
  *
  * \sa squaredNorm(), norm()
  */
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
  typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;
  EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);





  call_assignment(derived(), other.derived());
  return derived();
}

template<typename Derived>
template<typename OtherDerived>
Derived& DenseBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
{
  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

template<typename Derived>
template<typename OtherDerived>
Derived& DenseBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
{
  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

} // end namespace Eigen

#endif // EIGEN_EIGENBASE_H





    template<typename DiagonalDerived>
    EIGEN_DEVICE_FUNC
    const Product<Derived, DiagonalDerived, LazyProduct>
    operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;

    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
    dot(const MatrixBase<OtherDerived>& other) const;

    EIGEN_DEVICE_FUNC RealScalar squaredNorm() const;
    EIGEN_DEVICE_FUNC RealScalar norm() const;
    RealScalar stableNorm() const;
    RealScalar blueNorm() const;
    RealScalar hypotNorm() const;
    EIGEN_DEVICE_FUNC const PlainObject normalized() const;

    inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
    inline BDCSVD<PlainObject>    bdcSvd(unsigned int computationOptions = 0) const;

/////////// Geometry module ///////////

    #ifndef EIGEN_PARSED_BY_DOXYGEN
    /// \internal helper struct to form the return type of the cross product
    template<typename OtherDerived> struct cross_product_return_type {
      typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
      typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;
    };
    #endif // EIGEN_PARSED_BY_DOXYGEN
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
#ifndef EIGEN_PARSED_BY_DOXYGEN
    inline typename cross_product_return_type<OtherDerived>::type
#else




    typedef typename ExpressionType::Scalar Scalar;
    
    explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}
    
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other)
    {
      call_assignment_no_alias(m_expression, other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
      return m_expression;
    }
    
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other)
    {
      call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
      return m_expression;
    }
    
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other)
    {
      call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
      return m_expression;
    }

    EIGEN_DEVICE_FUNC
    ExpressionType& expression() const
    {
      return m_expression;
    }




    EIGEN_DEVICE_FUNC 
    EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
    {
      // I don't think we need this resize call since the lazyAssign will anyways resize
      // and lazyAssign will be called by the assign selector.
      //_resize_to_match(other);
      // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
      // it wouldn't allow to copy a row-vector into a column-vector.
      internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
      return this->derived();
    }

    template<typename T0, typename T1>
    EIGEN_DEVICE_FUNC
    EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
    {
      EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&




namespace Eigen {

template<typename Lhs, typename Rhs, int Option, typename StorageKind> class ProductImpl;

namespace internal {

// Determine the scalar of Product<Lhs, Rhs>. This is normally the same as Lhs::Scalar times
// Rhs::Scalar, but product with permutation matrices inherit the scalar of the other factor.
// TODO: this could be removed once ScalarBinaryOpTraits handles void.
template<typename Lhs, typename Rhs, typename LhsShape = typename evaluator_traits<Lhs>::Shape, 
         typename RhsShape = typename evaluator_traits<Rhs>::Shape >
struct product_result_scalar
{
  typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
};

template<typename Lhs, typename Rhs, typename RhsShape>
struct product_result_scalar<Lhs, Rhs, PermutationShape, RhsShape>
{
  typedef typename Rhs::Scalar Scalar;
};





  }
  
protected:  
  PlainObject m_result;
};

// Dense = Product
template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::assign_op<Scalar,typename Product<Lhs,Rhs,Options>::Scalar>, Dense2Dense,
  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct),Scalar>::type>
{
  typedef Product<Lhs,Rhs,Options> SrcXprType;
  static EIGEN_STRONG_INLINE
  void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename SrcXprType::Scalar> &)
  {
    // FIXME shall we handle nested_eval here?
    generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
  }
};

// Dense += Product
template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::add_assign_op<Scalar,typename Product<Lhs,Rhs,Options>::Scalar>, Dense2Dense,
  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct),Scalar>::type>
{
  typedef Product<Lhs,Rhs,Options> SrcXprType;
  static EIGEN_STRONG_INLINE
  void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,typename SrcXprType::Scalar> &)
  {
    // FIXME shall we handle nested_eval here?
    generic_product_impl<Lhs, Rhs>::addTo(dst, src.lhs(), src.rhs());
  }
};

// Dense -= Product
template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::sub_assign_op<Scalar,typename Product<Lhs,Rhs,Options>::Scalar>, Dense2Dense,
  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct),Scalar>::type>
{
  typedef Product<Lhs,Rhs,Options> SrcXprType;
  static EIGEN_STRONG_INLINE
  void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,typename SrcXprType::Scalar> &)
  {
    // FIXME shall we handle nested_eval here?
    generic_product_impl<Lhs, Rhs>::subTo(dst, src.lhs(), src.rhs());
  }
};


// Dense ?= scalar * Product

};

//----------------------------------------
// Catch "Dense ?= xpr + Product<>" expression to save one temporary
// FIXME we could probably enable these rules for any product, i.e., not only Dense and DefaultProduct
// TODO enable it for "Dense ?= xpr - Product<>" as well.

template<typename OtherXpr, typename Lhs, typename Rhs>
struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
                                               const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
  static const bool value = true;
};

template<typename DstXprType, typename OtherXpr, typename ProductType, typename Func1, typename Func2>
struct assignment_from_xpr_plus_product
{
  typedef CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar,typename ProductType::Scalar>, const OtherXpr, const ProductType> SrcXprType;
  template<typename InitialFunc>
  static EIGEN_STRONG_INLINE
  void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/)
  {
    call_assignment_no_alias(dst, src.lhs(), Func1());
    call_assignment_no_alias(dst, src.rhs(), Func2());
  }
};

template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar>
struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<OtherScalar,ProdScalar>, const OtherXpr,
                                           const Product<Lhs,Rhs,DefaultProduct> >, internal::assign_op<DstScalar,SrcScalar>, Dense2Dense>
  : assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<DstScalar,OtherScalar>, internal::add_assign_op<DstScalar,ProdScalar> >
{};
template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar>
struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<OtherScalar,ProdScalar>, const OtherXpr,
                                           const Product<Lhs,Rhs,DefaultProduct> >, internal::add_assign_op<DstScalar,SrcScalar>, Dense2Dense>
  : assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<DstScalar,OtherScalar>, internal::add_assign_op<DstScalar,ProdScalar> >
{};
template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar>
struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<OtherScalar,ProdScalar>, const OtherXpr,
                                           const Product<Lhs,Rhs,DefaultProduct> >, internal::sub_assign_op<DstScalar,SrcScalar>, Dense2Dense>
  : assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<DstScalar,OtherScalar>, internal::sub_assign_op<DstScalar,ProdScalar> >
{};
//----------------------------------------

template<typename Lhs, typename Rhs>
struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,InnerProduct>
{
  template<typename Dst>
  static inline void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)

{
  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
  
  template<typename Dst>
  static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
  {
    // Same as: dst.noalias() = lhs.lazyProduct(rhs);
    // but easier on the compiler side
    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op<typename Dst::Scalar,Scalar>());
  }
  
  template<typename Dst>
  static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
  {
    // dst.noalias() += lhs.lazyProduct(rhs);
    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op<typename Dst::Scalar,Scalar>());
  }
  
  template<typename Dst>
  static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
  {
    // dst.noalias() -= lhs.lazyProduct(rhs);
    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op<typename Dst::Scalar,Scalar>());
  }
  
//   template<typename Dst>
//   static inline void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
//   { dst.noalias() += alpha * lhs.lazyProduct(rhs); }
};

// This specialization enforces the use of a coefficient-based evaluation strategy

/***************************************************************************
* Diagonal products
***************************************************************************/
  
template<typename MatrixType, typename DiagonalType, typename Derived, int ProductOrder>
struct diagonal_product_evaluator_base
  : evaluator_base<Derived>
{
   typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar;
public:
  enum {
    CoeffReadCost = NumTraits<Scalar>::MulCost + evaluator<MatrixType>::CoeffReadCost + evaluator<DiagonalType>::CoeffReadCost,
    
    MatrixFlags = evaluator<MatrixType>::Flags,
    DiagFlags = evaluator<DiagonalType>::Flags,
    _StorageOrder = MatrixFlags & RowMajorBit ? RowMajor : ColMajor,
    _ScalarAccessOnDiag =  !((int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheLeft)




  * \sa trace(), prod(), mean()
  */
template<typename Derived>
EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
DenseBase<Derived>::sum() const
{
  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
    return Scalar(0);
  return derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>());
}

/** \returns the mean of all coefficients of *this
*
* \sa trace(), prod(), sum()
*/
template<typename Derived>
EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
DenseBase<Derived>::mean() const
{
#ifdef __INTEL_COMPILER
  #pragma warning push
  #pragma warning ( disable : 2259 )
#endif
  return Scalar(derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>())) / Scalar(this->size());
#ifdef __INTEL_COMPILER
  #pragma warning pop
#endif
}

/** \returns the product of all coefficients of *this
  *
  * Example: \include MatrixBase_prod.cpp




    EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type)
    {
      Base::construct(expr);
    }

    template<typename Expression>
    EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type)
    {
      internal::call_assignment_no_alias(m_object,expr,internal::assign_op<Scalar,Scalar>());
      Base::construct(m_object);
    }

  protected:
    TPlainObjectType m_object;
};

} // end namespace Eigen




// 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_SELFCWISEBINARYOP_H
#define EIGEN_SELFCWISEBINARYOP_H

namespace Eigen { 

// TODO generalize the scalar type of 'other'

template<typename Derived>
EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator*=(const Scalar& other)
{
  typedef typename Derived::PlainObject PlainObject;
  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::mul_assign_op<Scalar,Scalar>());
  return derived();
}

template<typename Derived>
EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator+=(const Scalar& other)
{
  typedef typename Derived::PlainObject PlainObject;
  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::add_assign_op<Scalar,Scalar>());
  return derived();
}

template<typename Derived>
EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator-=(const Scalar& other)
{
  typedef typename Derived::PlainObject PlainObject;
  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::sub_assign_op<Scalar,Scalar>());
  return derived();
}

template<typename Derived>
EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator/=(const Scalar& other)
{
  typedef typename Derived::PlainObject PlainObject;
  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::div_assign_op<Scalar,Scalar>());
  return derived();
}

} // end namespace Eigen

#endif // EIGEN_SELFCWISEBINARYOP_H




  
protected:  
  PlainObject m_result;
};

// Specialization for "dst = dec.solve(rhs)"
// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef Solve<DecType,RhsType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    // FIXME shall we resize dst here?
    src.dec()._solve_impl(src.rhs(), dst);
  }
};

// Specialization for "dst = dec.transpose().solve(rhs)"
template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
struct Assignment<DstXprType, Solve<Transpose<const DecType>,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    src.dec().nestedExpression().template _solve_impl_transposed<false>(src.rhs(), dst);
  }
};

// Specialization for "dst = dec.adjoint().solve(rhs)"
template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
struct Assignment<DstXprType, Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType>,
                  internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    src.dec().nestedExpression().nestedExpression().template _solve_impl_transposed<true>(src.rhs(), dst);
  }
};

} // end namepsace internal

} // end namespace Eigen




      * \sa DenseCoeffsBase::innerStride() */
    EIGEN_DEVICE_FUNC
    inline Index innerStride() const { return derived().nestedExpression().innerStride(); }

    /** \sa MatrixBase::operator+=() */
    template<typename Other>
    EIGEN_DEVICE_FUNC
    TriangularViewType&  operator+=(const DenseBase<Other>& other) {
      internal::call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename Other::Scalar>());
      return derived();
    }
    /** \sa MatrixBase::operator-=() */
    template<typename Other>
    EIGEN_DEVICE_FUNC
    TriangularViewType&  operator-=(const DenseBase<Other>& other) {
      internal::call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename Other::Scalar>());
      return derived();
    }
    
    /** \sa MatrixBase::operator*=() */
    EIGEN_DEVICE_FUNC
    TriangularViewType&  operator*=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = derived().nestedExpression() * other; }
    /** \sa DenseBase::operator/=() */
    EIGEN_DEVICE_FUNC

***************************************************************************/

// FIXME should we keep that possibility
template<typename MatrixType, unsigned int Mode>
template<typename OtherDerived>
inline TriangularView<MatrixType, Mode>&
TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const MatrixBase<OtherDerived>& other)
{
  internal::call_assignment_no_alias(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

// FIXME should we keep that possibility
template<typename MatrixType, unsigned int Mode>
template<typename OtherDerived>
void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)
{

  
  triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
}

template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_triangular_assignment_loop(const DstXprType& dst, const SrcXprType& src)
{
  call_triangular_assignment_loop<Mode,SetOpposite>(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
}

template<> struct AssignmentKind<TriangularShape,TriangularShape> { typedef Triangular2Triangular Kind; };
template<> struct AssignmentKind<DenseShape,TriangularShape>      { typedef Triangular2Dense      Kind; };
template<> struct AssignmentKind<TriangularShape,DenseShape>      { typedef Dense2Triangular      Kind; };


template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>

  other.derived().resize(this->rows(), this->cols());
  internal::call_triangular_assignment_loop<Derived::Mode,(Derived::Mode&SelfAdjoint)==0 /* SetOpposite */>(other.derived(), derived().nestedExpression());
}

namespace internal {
  
// Triangular = Product
template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular, Scalar>
{
  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename SrcXprType::Scalar> &)
  {
    dst.setZero();
    dst._assignProduct(src, 1);
  }
};

// Triangular += Product
template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular, Scalar>
{
  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,typename SrcXprType::Scalar> &)
  {
    dst._assignProduct(src, 1);
  }
};

// Triangular -= Product
template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular, Scalar>
{
  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,typename SrcXprType::Scalar> &)
  {
    dst._assignProduct(src, -1);
  }
};

} // end namespace internal

} // end namespace Eigen




      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
      m_matrix /= extendedTo(other.derived());
      return const_cast<ExpressionType&>(m_matrix);
    }

    /** Returns the expression of the sum of the vector \a other to each subvector of \c *this */
    template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
    CwiseBinaryOp<internal::scalar_sum_op<Scalar,typename OtherDerived::Scalar>,
                  const ExpressionTypeNestedCleaned,
                  const typename ExtendedType<OtherDerived>::Type>
    operator+(const DenseBase<OtherDerived>& other) const
    {
      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
      return m_matrix + extendedTo(other.derived());
    }

    /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    CwiseBinaryOp<internal::scalar_difference_op<Scalar,typename OtherDerived::Scalar>,
                  const ExpressionTypeNestedCleaned,
                  const typename ExtendedType<OtherDerived>::Type>
    operator-(const DenseBase<OtherDerived>& other) const
    {
      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
      return m_matrix - extendedTo(other.derived());
    }




namespace Eigen {

namespace internal {
  
/** \internal
  * \brief Template functor for scalar/packet assignment
  *
  */
template<typename DstScalar,typename SrcScalar> struct assign_op {

  EIGEN_EMPTY_STRUCT_CTOR(assign_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a = b; }
  
  template<int Alignment, typename Packet>
  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
  { internal::pstoret<DstScalar,Packet,Alignment>(a,b); }
};
template<typename DstScalar,typename SrcScalar>
struct functor_traits<assign_op<DstScalar,SrcScalar> > {
  enum {
    Cost = NumTraits<DstScalar>::ReadCost,
    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::Vectorizable && packet_traits<SrcScalar>::Vectorizable
  };
};

/** \internal
  * \brief Template functor for scalar/packet assignment with addition
  *
  */
template<typename DstScalar,typename SrcScalar> struct add_assign_op {

  EIGEN_EMPTY_STRUCT_CTOR(add_assign_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a += b; }
  
  template<int Alignment, typename Packet>
  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::padd(internal::ploadt<Packet,Alignment>(a),b)); }
};
template<typename DstScalar,typename SrcScalar>
struct functor_traits<add_assign_op<DstScalar,SrcScalar> > {
  enum {
    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasAdd
  };
};

/** \internal
  * \brief Template functor for scalar/packet assignment with subtraction
  *
  */
template<typename DstScalar,typename SrcScalar> struct sub_assign_op {

  EIGEN_EMPTY_STRUCT_CTOR(sub_assign_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
  
  template<int Alignment, typename Packet>
  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::psub(internal::ploadt<Packet,Alignment>(a),b)); }
};
template<typename DstScalar,typename SrcScalar>
struct functor_traits<sub_assign_op<DstScalar,SrcScalar> > {
  enum {
    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasSub
  };
};

/** \internal
  * \brief Template functor for scalar/packet assignment with multiplication
  *
  */
template<typename DstScalar, typename SrcScalar=DstScalar>

};
template<typename DstScalar, typename SrcScalar>
struct functor_traits<mul_assign_op<DstScalar,SrcScalar> > {
  enum {
    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasMul
  };
};
template<typename DstScalar,typename SrcScalar> struct functor_is_product_like<mul_assign_op<DstScalar,SrcScalar> > { enum { ret = 1 }; };

/** \internal
  * \brief Template functor for scalar/packet assignment with diviving
  *
  */
template<typename DstScalar, typename SrcScalar=DstScalar> struct div_assign_op {

  EIGEN_EMPTY_STRUCT_CTOR(div_assign_op)

};
template<typename DstScalar, typename SrcScalar>
struct functor_traits<div_assign_op<DstScalar,SrcScalar> > {
  enum {
    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasDiv
  };
};
template<typename DstScalar,typename SrcScalar> struct functor_is_product_like<div_assign_op<DstScalar,SrcScalar> > { enum { ret = 1 }; };

/** \internal
  * \brief Template functor for scalar/packet assignment with swapping
  *
  * It works as follow. For a non-vectorized evaluation loop, we have:
  *   for(i) func(A.coeffRef(i), B.coeff(i));
  * where B is a SwapWrapper expression. The trick is to make SwapWrapper::coeff behaves like a non-const coeffRef.
  * Actually, SwapWrapper might not even be needed since even if B is a plain expression, since it has to be writable





//---------- associative binary functors ----------

/** \internal
  * \brief Template functor to compute the sum of two scalars
  *
  * \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, DenseBase::sum()
  */
template<typename LhsScalar,typename RhsScalar> struct scalar_sum_op {
  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_sum_op>::ReturnType result_type;
  EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a + b; }
  template<typename Packet>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
  { return internal::padd(a,b); }
  template<typename Packet>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
  { return internal::predux(a); }
};
template<typename LhsScalar,typename RhsScalar>
struct functor_traits<scalar_sum_op<LhsScalar,RhsScalar> > {
  enum {
    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2, // rough estimate!
    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasAdd && packet_traits<RhsScalar>::HasAdd
    // TODO vectorize mixed sum
  };
};

/** \internal
  * \brief Template specialization to deprecate the summation of boolean expressions.
  * This is required to solve Bug 426.
  * \sa DenseBase::count(), DenseBase::any(), ArrayBase::cast(), MatrixBase::cast()
  */
template<> struct scalar_sum_op<bool,bool> : scalar_sum_op<int,int> {
  EIGEN_DEPRECATED
  scalar_sum_op() {}
};


/** \internal
  * \brief Template functor to compute the product of two scalars
  *
  * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux()
  */
template<typename LhsScalar,typename RhsScalar> struct scalar_product_op {
  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_product_op>::ReturnType result_type;
    // TODO vectorize mixed product
    Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
  };
  typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
  EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; }
  template<typename Packet>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
  { return internal::pmul(a,b); }
  template<typename Packet>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
  { return internal::predux_mul(a); }
};
template<typename LhsScalar,typename RhsScalar>
struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > {
  enum {
    Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2, // rough estimate!
    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
    // TODO vectorize mixed product
  };
};

/** \internal
  * \brief Template functor to compute the conjugate product of two scalars
  *
  * This is a short cut for conj(x) * y which is needed for optimization purpose; in Eigen2 support mode, this becomes x * conj(y)
  */
template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op {

  enum {
    Conj = NumTraits<LhsScalar>::IsComplex
  };
  
  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_product_op>::ReturnType result_type;
  
  EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const
  { return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); }
  
  template<typename Packet>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
  { return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); }


//---------- non associative binary functors ----------

/** \internal
  * \brief Template functor to compute the difference of two scalars
  *
  * \sa class CwiseBinaryOp, MatrixBase::operator-
  */
template<typename LhsScalar,typename RhsScalar> struct scalar_difference_op {
  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_difference_op>::ReturnType result_type;
  EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a - b; }
  template<typename Packet>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
  { return internal::psub(a,b); }
};
template<typename LhsScalar,typename RhsScalar>
struct functor_traits<scalar_difference_op<LhsScalar,RhsScalar> > {
  enum {
    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasSub && packet_traits<RhsScalar>::HasSub
  };
};

/** \internal
  * \brief Template functor to compute the quotient of two scalars
  *
  * \sa class CwiseBinaryOp, Cwise::operator/()
  */
template<typename LhsScalar,typename RhsScalar> struct scalar_quotient_op {
  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotient_op>::ReturnType result_type;
    // TODO vectorize mixed product
    Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv
  };
  typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
  EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }
  template<typename Packet>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
  { return internal::pdiv(a,b); }
};
template<typename LhsScalar,typename RhsScalar>
struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
  typedef typename scalar_quotient_op<LhsScalar,RhsScalar>::result_type result_type;
  enum {
    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv,
    Cost = NumTraits<result_type>::template Div<PacketAccess>::Cost
  };
};



/** \internal
  * \brief Template functor to compute the and of two booleans

  typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
};
template<typename Scalar>
struct functor_traits<scalar_multiple_op<Scalar> >
{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };

template<typename Scalar1, typename Scalar2>
struct scalar_multiple2_op {
  typedef typename ScalarBinaryOpTraits<Scalar1,Scalar2>::ReturnType result_type;
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { }
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { }
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; }
  typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
};
template<typename Scalar1,typename Scalar2>
struct functor_traits<scalar_multiple2_op<Scalar1,Scalar2> >
{ enum { Cost = NumTraits<Scalar1>::MulCost, PacketAccess = false }; };

  typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
};
template<typename Scalar>
struct functor_traits<scalar_quotient1_op<Scalar> >
{ enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };

template<typename Scalar1, typename Scalar2>
struct scalar_quotient2_op {
  typedef typename ScalarBinaryOpTraits<Scalar1,Scalar2>::ReturnType result_type;
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_quotient2_op(const scalar_quotient2_op& other) : m_other(other.m_other) { }
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_quotient2_op(const Scalar2& other) : m_other(other) { }
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a / m_other; }
  typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
};
template<typename Scalar1,typename Scalar2>
struct functor_traits<scalar_quotient2_op<Scalar1,Scalar2> >
{ enum { Cost = 2 * NumTraits<Scalar1>::MulCost, PacketAccess = false }; };

// In Eigen, any binary op (Product, CwiseBinaryOp) require the Lhs and Rhs to have the same scalar type, except for multiplication
// where the mixing of different types is handled by scalar_product_traits
// In particular, real * complex<real> is allowed.
// FIXME move this to functor_traits adding a functor_default
template<typename Functor> struct functor_is_product_like { enum { ret = 0 }; };
template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_conj_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_quotient_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };


/** \internal
  * \brief Template functor to add a scalar to a fixed other one
  * \sa class CwiseUnaryOp, Array::operator+
  */
/* If you wonder why doing the pset1() in packetOp() is an optimization check scalar_multiple_op */
template<typename Scalar>
struct scalar_add_op {




 *  real*cplx : load lhs as (a0,a0,a1,a1), and mul as usual
 */
template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs, bool _ConjRhs>
class gebp_traits
{
public:
  typedef _LhsScalar LhsScalar;
  typedef _RhsScalar RhsScalar;
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;

  enum {
    ConjLhs = _ConjLhs,
    ConjRhs = _ConjRhs,
    Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,
    LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
    RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
    ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,

};

template<typename RealScalar, bool _ConjLhs>
class gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false>
{
public:
  typedef std::complex<RealScalar> LhsScalar;
  typedef RealScalar RhsScalar;
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;

  enum {
    ConjLhs = _ConjLhs,
    ConjRhs = false,
    Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,
    LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
    RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
    ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,




template<
  typename Index,
  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>
struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor>
{
  typedef gebp_traits<RhsScalar,LhsScalar> Traits;
  
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
  static EIGEN_STRONG_INLINE void run(
    Index rows, Index cols, Index depth,
    const LhsScalar* lhs, Index lhsStride,
    const RhsScalar* rhs, Index rhsStride,
    ResScalar* res, Index resStride,
    ResScalar alpha,
    level3_blocking<RhsScalar,LhsScalar>& blocking,
    GemmParallelInfo<Index>* info = 0)

  typename Index,
  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>
struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor>
{

typedef gebp_traits<LhsScalar,RhsScalar> Traits;
  
typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
static void run(Index rows, Index cols, Index depth,
  const LhsScalar* _lhs, Index lhsStride,
  const RhsScalar* _rhs, Index rhsStride,
  ResScalar* _res, Index resStride,
  ResScalar alpha,
  level3_blocking<LhsScalar,RhsScalar>& blocking,
  GemmParallelInfo<Index>* info = 0)
{




                              int ResStorageOrder, int  UpLo, int Version = Specialized>
struct general_matrix_matrix_triangular_product;

// as usual if the result is row major => we transpose the product
template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int  UpLo, int Version>
struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,UpLo,Version>
{
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* lhs, Index lhsStride,
                                      const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resStride,
                                      const ResScalar& alpha, level3_blocking<RhsScalar,LhsScalar>& blocking)
  {
    general_matrix_matrix_triangular_product<Index,
        RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
        LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
        ColMajor, UpLo==Lower?Upper:Lower>
      ::run(size,depth,rhs,rhsStride,lhs,lhsStride,res,resStride,alpha,blocking);
  }
};

template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int  UpLo, int Version>
struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,UpLo,Version>
{
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* _lhs, Index lhsStride,
                                      const RhsScalar* _rhs, Index rhsStride, ResScalar* _res, Index resStride,
                                      const ResScalar& alpha, level3_blocking<LhsScalar,RhsScalar>& blocking)
  {
    typedef gebp_traits<LhsScalar,RhsScalar> Traits;

    typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
    typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;




 * One might also wonder why in the EvenAligned case we perform unaligned loads instead of using the aligned-loads plus re-alignment
 * strategy as in the FirstAligned case. The reason is that we observed that unaligned loads on a 8 byte boundary are not too slow
 * compared to unaligned loads on a 4 byte boundary.
 *
 */
template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
{
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;

enum {
  Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable
              && int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),
  LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
  RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
  ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1
};

 *
 * Mixing type logic:
 *  - alpha is always a complex (or converted to a complex)
 *  - no vectorization
 */
template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
{
typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;

enum {
  Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable
              && int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),
  LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
  RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
  ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1
};




namespace internal {

template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder, int Version=Specialized>
struct triangular_matrix_vector_product;

template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
{
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
  enum {
    IsLower = ((Mode&Lower)==Lower),
    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
  };
  static EIGEN_DONT_INLINE  void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
                                     const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha);
};

          RhsMapper(&rhs.coeffRef(size), rhsIncr),
          _res, resIncr, alpha);
    }
  }

template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
{
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
  enum {
    IsLower = ((Mode&Lower)==Lower),
    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
  };
  static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
                                    const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha);
};




template<typename MatrixType> class SparseView;
template<typename ExpressionType> class WithFormat;
template<typename MatrixType> struct CommaInitializer;
template<typename Derived> class ReturnByValue;
template<typename ExpressionType> class ArrayWrapper;
template<typename ExpressionType> class MatrixWrapper;
template<typename Derived> class SolverBase;
template<typename XprType> class InnerIterator;
template<typename ScalarA, typename ScalarB, typename BinaryOp=void> struct ScalarBinaryOpTraits;

namespace internal {
template<typename DecompositionType> struct kernel_retval_base;
template<typename DecompositionType> struct kernel_retval;
template<typename DecompositionType> struct image_retval_base;
template<typename DecompositionType> struct image_retval;
} // end namespace internal


template<typename Lhs, typename Rhs> struct LazyProductReturnType;

namespace internal {

// Provides scalar/packet-wise product and product with accumulation
// with optional conjugation of the arguments.
template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;

template<typename LhsScalar,typename RhsScalar> struct scalar_sum_op;
template<typename LhsScalar,typename RhsScalar> struct scalar_difference_op;
template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op;
template<typename Scalar> struct scalar_opposite_op;
template<typename Scalar> struct scalar_conjugate_op;
template<typename Scalar> struct scalar_real_op;
template<typename Scalar> struct scalar_imag_op;
template<typename Scalar> struct scalar_abs_op;
template<typename Scalar> struct scalar_abs2_op;
template<typename Scalar> struct scalar_sqrt_op;




  template<typename OtherDerived> \
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> \
  (METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
  { \
    return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(), other.derived()); \
  }

// the expression type of a cwise product
#define EIGEN_CWISE_BINARY_RETURN_TYPE(LHS,RHS,OPNAME) \
    CwiseBinaryOp< \
      EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)< \
          typename internal::traits<LHS>::Scalar, \
          typename internal::traits<RHS>::Scalar \
      >, \
      const LHS, \
      const RHS \
    >

#ifdef EIGEN_EXCEPTIONS




};

/** \internal determines whether the product of two numeric types is allowed and what the return type is */
template<typename T, typename U> struct scalar_product_traits
{
  enum { Defined = 0 };
};

template<typename T> struct scalar_product_traits<T,T>
{
  enum {
    // Cost = NumTraits<T>::MulCost,
    Defined = 1
  };
  typedef T ReturnType;
};

template<typename T> struct scalar_product_traits<T,std::complex<T> >
{
  enum {
    // Cost = 2*NumTraits<T>::MulCost,
    Defined = 1
  };
  typedef std::complex<T> ReturnType;
};

template<typename T> struct scalar_product_traits<std::complex<T>, T>
{
  enum {
    // Cost = 2*NumTraits<T>::MulCost,
    Defined = 1
  };
  typedef std::complex<T> ReturnType;
};

// FIXME quick workaround around current limitation of result_of
// template<typename Scalar, typename ArgType0, typename ArgType1>
// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> {
// typedef typename scalar_product_traits<typename remove_all<ArgType0>::type, typename remove_all<ArgType1>::type>::ReturnType type;
// };

} // end namespace internal


template<typename T>
T div_ceil(const T &a, const T &b)
{
  return (a+b-1) / b;
}

} // end namespace numext


/** \class ScalarBinaryOpTraits
  * \ingroup Core_Module
  *
  * \brief Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is.
  *
  * \sa CwiseBinaryOp
  */
template<typename ScalarA, typename ScalarB, typename BinaryOp>
struct ScalarBinaryOpTraits
#ifndef EIGEN_PARSED_BY_DOXYGEN
  // for backward compatibility, use the hints given by the (deprecated) internal::scalar_product_traits class.
  : internal::scalar_product_traits<ScalarA,ScalarB>
#endif // EIGEN_PARSED_BY_DOXYGEN
{};

template<typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<T,T,BinaryOp>
{
  enum { Defined = 1 };
  typedef T ReturnType;
};

template<typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<T,std::complex<T>,BinaryOp>
{
  enum { Defined = 1 };
  typedef std::complex<T> ReturnType;
};

template<typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<std::complex<T>, T,BinaryOp>
{
  enum { Defined = 1 };
  typedef std::complex<T> ReturnType;
};

} // end namespace Eigen

#endif // EIGEN_META_H




  if(f&NoPreferredStorageOrderBit)  res += " | NoPreferredStorageOrderBit";
  
  return res;
}
#endif

} // end namespace internal

// We require Lhs and Rhs to have "compatible" scalar types.
// that would take two operands of different types. If there were such an example, then this check should be
// moved to the BinaryOp functors, on a per-case basis. This would however require a change in the BinaryOp functors, as
// currently they take only one typename Scalar template parameter.
// It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
// So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
// add together a float matrix and a double matrix.
// Treat "void" as a special case. Needed for permutation products. TODO: this should be handled by ScalarBinaryOpTraits
#define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \
  EIGEN_STATIC_ASSERT(int(internal::is_same_or_void<LHS, RHS>::value) || int(ScalarBinaryOpTraits<LHS, RHS,BINOP>::Defined), \
                        ? int(internal::scalar_product_traits<LHS, RHS>::Defined) \
                        : int(internal::is_same_or_void<LHS, RHS>::value)), \
    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
    
} // end namespace Eigen

#endif // EIGEN_XPRHELPER_H




  inline VectorType& (min)() { return m_min; }
  /** \returns the maximal corner */
  inline const VectorType& (max)() const { return m_max; }
  /** \returns a non const reference to the maximal corner */
  inline VectorType& (max)() { return m_max; }

  /** \returns the center of the box */
  inline const CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>,
                            const CwiseBinaryOp<internal::scalar_sum_op<Scalar,Scalar>, const VectorType, const VectorType> >
  center() const
  { return (m_min+m_max)/2; }

  /** \returns the lengths of the sides of the bounding box.
    * Note that this function does not get the same
    * result for integral or floating scalar types: see
    */
  inline const CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> sizes() const
  { return m_max - m_min; }

  /** \returns the volume of the bounding box */
  inline Scalar volume() const
  { return sizes().prod(); }

  /** \returns an expression for the bounding box diagonal vector
    * if the length of the diagonal is needed: diagonal().norm()
    * will provide it.
    */
  inline CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> diagonal() const
  { return sizes(); }

  /** \returns the vertex of the bounding box at the corner defined by
    * the corner-id corner. It works only for a 1D, 2D or 3D bounding box.
    * For 1D bounding boxes corners are named by 2 enum constants:
    * BottomLeft and BottomRight.
    * For 2D bounding boxes, corners are named by 4 enum constants:
    * BottomLeft, BottomRight, TopLeft, TopRight.




  }

protected:
  PlainObject m_temp;
};

// dense = homogeneous
template< typename DstXprType, typename ArgType, typename Scalar>
struct Assignment<DstXprType, Homogeneous<ArgType,Vertical>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense, Scalar>
{
  typedef Homogeneous<ArgType,Vertical> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
  {
    dst.template topRows<ArgType::RowsAtCompileTime>(src.nestedExpression().rows()) = src.nestedExpression();
    dst.row(dst.rows()-1).setOnes();
  }
};

// dense = homogeneous
template< typename DstXprType, typename ArgType, typename Scalar>
struct Assignment<DstXprType, Homogeneous<ArgType,Horizontal>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense, Scalar>
{
  typedef Homogeneous<ArgType,Horizontal> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
  {
    dst.template leftCols<ArgType::ColsAtCompileTime>(src.nestedExpression().cols()) = src.nestedExpression();
    dst.col(dst.cols()-1).setOnes();
  }
};

template<typename LhsArg, typename Rhs, int ProductTag>
struct generic_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs, HomogeneousShape, DenseShape, ProductTag>

    Dim  = Lhs::ColsAtCompileTime,
    Rows = Lhs::RowsAtCompileTime
  };
  typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type          LinearBlockConst;
  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
  typedef typename Rhs::ConstRowXpr                                     ConstantColumn;
  typedef Replicate<const ConstantColumn,Rows,1>                        ConstantBlock;
  typedef Product<Lhs,LinearBlock,LazyProduct>                          LinearProduct;
  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
};

template<typename Lhs, typename Rhs, int ProductTag>
struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape>
 : public evaluator<typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs>::Xpr>
{
  typedef Product<Lhs, Rhs, LazyProduct> XprType;
  typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs> helper;

    Dim = Rhs::RowsAtCompileTime,
    Cols = Rhs::ColsAtCompileTime
  };
  typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type          LinearBlockConst;
  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
  typedef typename Lhs::ConstColXpr                                     ConstantColumn;
  typedef Replicate<const ConstantColumn,1,Cols>                        ConstantBlock;
  typedef Product<LinearBlock,Rhs,LazyProduct>                          LinearProduct;
  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
};

template<typename Lhs, typename Rhs, int ProductTag>
struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape>
 : public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression>::Xpr>
{
  typedef Product<Lhs, Rhs, LazyProduct> XprType;
  typedef homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression> helper;




  {
    Index start = k+1+h.m_shift;
    return Block<const VectorsType,1,Dynamic>(h.m_vectors, k, start, 1, h.rows()-start).transpose();
  }
};

template<typename OtherScalarType, typename MatrixType> struct matrix_type_times_scalar_type
{
  typedef typename ScalarBinaryOpTraits<OtherScalarType, typename MatrixType::Scalar>::ReturnType
    ResultScalar;
  typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
                 0, MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime> Type;
};

} // end namespace internal

template<typename VectorsType, typename CoeffsType, int Side> class HouseholderSequence




  
protected:  
  PlainObject m_result;
};

// Specialization for "dst = dec.solveWithGuess(rhs)"
// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
template<typename DstXprType, typename DecType, typename RhsType, typename GuessType, typename Scalar>
struct Assignment<DstXprType, SolveWithGuess<DecType,RhsType,GuessType>, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    // FIXME shall we resize dst here?
    dst = src.guess();
    src.dec()._solve_with_guess_impl(src.rhs(), dst/*, src.guess()*/);
  }
};

} // end namepsace internal




}

#endif

namespace internal {


/***** Implementation of inverse() *****************************************************/
template<typename DstXprType, typename MatrixType>
struct Assignment<DstXprType, Inverse<FullPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivLU<MatrixType>::Scalar>, Dense2Dense>
{
  typedef FullPivLU<MatrixType> LuType;
  typedef Inverse<LuType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename MatrixType::Scalar> &)
  {
    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
  }
};
} // end namespace internal

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





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

} // end namespace internal

namespace internal {

// Specialization for "dense = dense_xpr.inverse()"
template<typename DstXprType, typename XprType>
struct Assignment<DstXprType, Inverse<XprType>, internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar>, Dense2Dense>
{
  typedef Inverse<XprType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar> &)
  {
    // FIXME shall we resize dst here?
    const int Size = EIGEN_PLAIN_ENUM_MIN(XprType::ColsAtCompileTime,DstXprType::ColsAtCompileTime);
    EIGEN_ONLY_USED_FOR_DEBUG(Size);
    eigen_assert(( (Size<=1) || (Size>4) || (extract_data(src.nestedExpression())!=extract_data(dst)))
              && "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");

    typedef typename internal::nested_eval<XprType,XprType::ColsAtCompileTime>::type  ActualXprType;




}

/***** Implementation details *****************************************************/

namespace internal {

/***** Implementation of inverse() *****************************************************/
template<typename DstXprType, typename MatrixType, typename Scalar>
struct Assignment<DstXprType, Inverse<PartialPivLU<MatrixType> >, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef PartialPivLU<MatrixType> LuType;
  typedef Inverse<LuType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
  }
};
} // end namespace internal

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





  for(Index i = 0; i < nonzero_pivots; ++i) dst.row(m_colsPermutation.indices().coeff(i)) = c.row(i);
  for(Index i = nonzero_pivots; i < cols(); ++i) dst.row(m_colsPermutation.indices().coeff(i)).setZero();
}
#endif

namespace internal {

template<typename DstXprType, typename MatrixType, typename Scalar>
struct Assignment<DstXprType, Inverse<ColPivHouseholderQR<MatrixType> >, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef ColPivHouseholderQR<MatrixType> QrType;
  typedef Inverse<QrType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
  }
};

} // end namespace internal

/** \returns the matrix Q as a sequence of householder transformations.




  // Undo permutation to get x = P^{-1} * y.
  dst = colsPermutation() * dst;
}
#endif

namespace internal {

template<typename DstXprType, typename MatrixType, typename Scalar>
struct Assignment<DstXprType, Inverse<CompleteOrthogonalDecomposition<MatrixType> >, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef CompleteOrthogonalDecomposition<MatrixType> CodType;
  typedef Inverse<CodType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.rows()));
  }
};

} // end namespace internal

/** \returns the matrix Q as a sequence of householder transformations */




  for(Index i = 0; i < l_rank; ++i) dst.row(m_cols_permutation.indices().coeff(i)) = c.row(i);
  for(Index i = l_rank; i < cols(); ++i) dst.row(m_cols_permutation.indices().coeff(i)).setZero();
}
#endif

namespace internal {
  
template<typename DstXprType, typename MatrixType, typename Scalar>
struct Assignment<DstXprType, Inverse<FullPivHouseholderQR<MatrixType> >, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
{
  typedef FullPivHouseholderQR<MatrixType> QrType;
  typedef Inverse<QrType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {    
    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
  }
};

/** \ingroup QR_Module
  *
  * \brief Expression type for return value of FullPivHouseholderQR::matrixQ()




  return derived();
}

template<typename Derived>
template<typename OtherDerived>
inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other)
{
  // by default sparse evaluation do not alias, so we can safely bypass the generic call_assignment routine
  internal::Assignment<Derived,OtherDerived,internal::assign_op<Scalar,typename OtherDerived::Scalar> >
          ::run(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

template<typename Derived>
inline Derived& SparseMatrixBase<Derived>::operator=(const Derived& other)
{
  internal::call_assignment_no_alias(derived(), other.derived());
  return derived();

    dst = temp.markAsRValue();
  }
}

// Generic Sparse to Sparse assignment
template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Sparse, Scalar>
{
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    assign_sparse_to_sparse(dst.derived(), src.derived());
  }
};

// Generic Sparse to Dense assignment
template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Dense, Scalar>
{
  static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
  {
    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());

    if(internal::is_same<Functor,internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> >::value)
      dst.setZero();
    
    internal::evaluator<SrcXprType> srcEval(src);
    internal::evaluator<DstXprType> dstEval(dst);
    const Index outerEvaluationSize = (internal::evaluator<SrcXprType>::Flags&RowMajorBit) ? src.rows() : src.cols();
    for (Index j=0; j<outerEvaluationSize; ++j)
      for (typename internal::evaluator<SrcXprType>::InnerIterator i(srcEval,j); i; ++i)
        func.assignCoeff(dstEval.coeffRef(i.row(),i.col()), i.value());
  }
};

// Specialization for "dst = dec.solve(rhs)"
// NOTE we need to specialize it for Sparse2Sparse to avoid ambiguous specialization error
template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Sparse2Sparse, Scalar>
{
  typedef Solve<DecType,RhsType> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    src.dec()._solve_impl(src.rhs(), dst);
  }
};

struct Diagonal2Sparse {};

template<> struct AssignmentKind<SparseShape,DiagonalShape> { typedef Diagonal2Sparse Kind; };

template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Sparse, Scalar>
{
  typedef typename DstXprType::StorageIndex StorageIndex;
  typedef Array<StorageIndex,Dynamic,1> ArrayXI;
  typedef Array<Scalar,Dynamic,1> ArrayXS;
  template<int Options>
  static void run(SparseMatrix<Scalar,Options,StorageIndex> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    Index size = src.diagonal().size();
    dst.makeCompressed();
    dst.resizeNonZeros(size);
    Map<ArrayXI>(dst.innerIndexPtr(), size).setLinSpaced(0,StorageIndex(size)-1);
    Map<ArrayXI>(dst.outerIndexPtr(), size+1).setLinSpaced(0,StorageIndex(size));
    Map<ArrayXS>(dst.valuePtr(), size) = src.diagonal();
  }
  
  template<typename DstDerived>
  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    dst.diagonal() = src.diagonal();
  }
  
  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  { dst.diagonal() += src.diagonal(); }
  
  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  { dst.diagonal() -= src.diagonal(); }
};
} // end namespace internal

} // end namespace Eigen

#endif // EIGEN_SPARSEASSIGN_H




{
  return derived() = derived() + other.derived();
}

template<typename Derived>
template<typename OtherDerived>
Derived& SparseMatrixBase<Derived>::operator+=(const DiagonalBase<OtherDerived>& other)
{
  call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

template<typename Derived>
template<typename OtherDerived>
Derived& SparseMatrixBase<Derived>::operator-=(const DiagonalBase<OtherDerived>& other)
{
  call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}
    
template<typename Derived>
template<typename OtherDerived>
EIGEN_STRONG_INLINE const typename SparseMatrixBase<Derived>::template CwiseProductDenseReturnType<OtherDerived>::Type
SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) const
{
  return typename CwiseProductDenseReturnType<OtherDerived>::Type(derived(), other.derived());
}

template<typename DenseDerived, typename SparseDerived>
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
operator+(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
{
  return CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
}

template<typename SparseDerived, typename DenseDerived>
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
operator+(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
{
  return CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
}

template<typename DenseDerived, typename SparseDerived>
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
operator-(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
{
  return CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
}

template<typename SparseDerived, typename DenseDerived>
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
operator-(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
{
  return CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
}

} // end namespace Eigen

#endif // EIGEN_SPARSE_CWISE_BINARY_OP_H




    res.coeffRef(i,col) += alpha * tmp;
  }
  
};

// FIXME: what is the purpose of the following specialization? Is it for the BlockedSparse format?
// -> let's disable it for now as it is conflicting with generic scalar*matrix and matrix*scalar operators
// template<typename T1, typename T2/*, int _Options, typename _StrideType*/>
// struct ScalarBinaryOpTraits<T1, Ref<T2/*, _Options, _StrideType*/> >
// {
//   enum {
//     Defined = 1
//   };
//   typedef typename CwiseUnaryOp<scalar_multiple2_op<T1, typename T2::Scalar>, T2>::PlainObject ReturnType;
// };

template<typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>

  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
  {
    evaluator<Lhs> lhsEval(lhs);
    for(Index c=0; c<rhs.cols(); ++c)
    {
      for(Index j=0; j<lhs.outerSize(); ++j)
      {
//        typename Res::Scalar rhs_j = alpha * rhs.coeff(j,c);
        typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j,c));
        for(LhsInnerIterator it(lhsEval,j); it ;++it)
          res.coeffRef(it.index(),c) += it.value() * rhs_j;
      }
    }
  }
};

template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>




    //---

    template<typename InputIterators>
    void setFromTriplets(const InputIterators& begin, const InputIterators& end);

    template<typename InputIterators,typename DupFunctor>
    void setFromTriplets(const InputIterators& begin, const InputIterators& end, DupFunctor dup_func);

    void sumupDuplicates() { collapseDuplicates(internal::scalar_sum_op<Scalar,Scalar>()); }

    template<typename DupFunctor>
    void collapseDuplicates(DupFunctor dup_func = DupFunctor());

    //---
    
    /** \internal
      * same as insert(Index,Index) except that the indices are given relative to the storage order */

  * \warning The list of triplets is read multiple times (at least twice). Therefore, it is not recommended to define
  * an abstract iterator over a complex data-structure that would be expensive to evaluate. The triplets should rather
  * be explicitely stored into a std::vector for instance.
  */
template<typename Scalar, int _Options, typename _Index>
template<typename InputIterators>
void SparseMatrix<Scalar,_Options,_Index>::setFromTriplets(const InputIterators& begin, const InputIterators& end)
{
  internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,_Options,_Index> >(begin, end, *this, internal::scalar_sum_op<Scalar,Scalar>());
}

/** The same as setFromTriplets but when duplicates are met the functor \a dup_func is applied:
  * \code
  * value = dup_func(OldValue, NewValue)
  * \endcode 
  * Here is a C++11 example keeping the latest entry only:
  * \code




    Derived& operator+=(const DiagonalBase<OtherDerived>& other);
    template<typename OtherDerived>
    Derived& operator-=(const DiagonalBase<OtherDerived>& other);

    Derived& operator*=(const Scalar& other);
    Derived& operator/=(const Scalar& other);

    template<typename OtherDerived> struct CwiseProductDenseReturnType {
      typedef CwiseBinaryOp<internal::scalar_product_op<typename ScalarBinaryOpTraits<
                                                          typename internal::traits<Derived>::Scalar,
                                                          typename internal::traits<OtherDerived>::Scalar
                                                        >::ReturnType>,
                            const Derived,
                            const OtherDerived
                          > Type;
    };





// sparse-triangular * sparse
template<typename Lhs, typename Rhs, int ProductType>
struct generic_product_impl<Lhs, Rhs, SparseTriangularShape, SparseShape, ProductType>
 : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
{};

// dense = sparse-product (can be sparse*sparse, sparse*perm, etc.)
template< typename DstXprType, typename Lhs, typename Rhs>
struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
{
  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
  {
    generic_product_impl<Lhs, Rhs>::evalTo(dst,src.lhs(),src.rhs());
  }
};

// dense += sparse-product (can be sparse*sparse, sparse*perm, etc.)
template< typename DstXprType, typename Lhs, typename Rhs>
struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::add_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
{
  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
  {
    generic_product_impl<Lhs, Rhs>::addTo(dst,src.lhs(),src.rhs());
  }
};

// dense -= sparse-product (can be sparse*sparse, sparse*perm, etc.)
template< typename DstXprType, typename Lhs, typename Rhs>
struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::sub_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
{
  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
  {
    generic_product_impl<Lhs, Rhs>::subTo(dst,src.lhs(),src.rhs());
  }
};

template<typename Lhs, typename Rhs, int Options>
struct unary_evaluator<SparseView<Product<Lhs, Rhs, Options> >, IteratorBased>
 : public evaluator<typename Product<Lhs, Rhs, DefaultProduct>::PlainObject>




template<> struct AssignmentKind<SparseShape,SparseSelfAdjointShape> { typedef SparseSelfAdjoint2Sparse Kind; };
template<> struct AssignmentKind<SparseSelfAdjointShape,SparseShape> { typedef Sparse2Sparse Kind; };

template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse, Scalar>
{
  typedef typename DstXprType::StorageIndex StorageIndex;
  template<typename DestScalar,int StorageOrder>
  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
  }
  
  template<typename DestScalar>
  static void run(DynamicSparseMatrix<DestScalar,ColMajor,StorageIndex>& dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    // TODO directly evaluate into dst;
    SparseMatrix<DestScalar,ColMajor,StorageIndex> tmp(dst.rows(),dst.cols());
    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), tmp);
    dst = tmp;
  }
};


    MatrixTypeNested m_matrix;
    const Perm& m_perm;

};

namespace internal {
  
template<typename DstXprType, typename MatrixType, int Mode, typename Scalar>
struct Assignment<DstXprType, SparseSymmetricPermutationProduct<MatrixType,Mode>, internal::assign_op<Scalar,typename MatrixType::Scalar>, Sparse2Sparse>
{
  typedef SparseSymmetricPermutationProduct<MatrixType,Mode> SrcXprType;
  typedef typename DstXprType::StorageIndex DstIndex;
  template<int Options>
  static void run(SparseMatrix<Scalar,Options,DstIndex> &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
  {
    // internal::permute_symm_to_fullsymm<Mode>(m_matrix,_dest,m_perm.indices().data());
    SparseMatrix<Scalar,(Options&RowMajor)==RowMajor ? ColMajor : RowMajor, DstIndex> tmp;
    internal::permute_symm_to_fullsymm<Mode>(src.matrix(),tmp,src.perm().indices().data());
    dst = tmp;
  }
  
  template<typename DestType,unsigned int DestMode>
  static void run(SparseSelfAdjointView<DestType,DestMode>& dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
  {
    internal::permute_symm_to_symm<Mode,DestMode>(src.matrix(),dst.matrix(),src.perm().indices().data());
  }
};

} // end namespace internal

} // end namespace Eigen




struct evaluator_traits<SparseQRMatrixQReturnType<SparseQRType> >
{
  typedef typename SparseQRType::MatrixType MatrixType;
  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
  typedef SparseShape Shape;
};

template< typename DstXprType, typename SparseQRType>
struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Sparse>
{
  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
  typedef typename DstXprType::Scalar Scalar;
  typedef typename DstXprType::StorageIndex StorageIndex;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
  {
    typename DstXprType::PlainObject idMat(src.m_qr.rows(), src.m_qr.rows());
    idMat.setIdentity();
    // Sort the sparse householder reflectors if needed
    const_cast<SparseQRType *>(&src.m_qr)->_sort_matrix_Q();
    dst = SparseQR_QProduct<SparseQRType, DstXprType>(src.m_qr, idMat, false);
  }
};

template< typename DstXprType, typename SparseQRType>
struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Dense>
{
  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
  typedef typename DstXprType::Scalar Scalar;
  typedef typename DstXprType::StorageIndex StorageIndex;
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
  {
    dst = src.m_qr.matrixQ() * DstXprType::Identity(src.m_qr.rows(), src.m_qr.rows());
  }
};

} // end namespace internal

} // end namespace Eigen




/** \returns an expression of the coefficient wise product of \c *this and \a other
  *
  * \sa MatrixBase::cwiseProduct
  */
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
operator*(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{
  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
}

/** \returns an expression of the coefficient wise quotient of \c *this and \a other
  *
  * \sa MatrixBase::cwiseQuotient
  */
template<typename OtherDerived>
EIGEN_DEVICE_FUNC




// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2006-2008 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/.

// This file is a base class plugin containing common coefficient wise functions.

/** \returns an expression of the difference of \c *this and \a other
  *
  * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-().
  *
  * \sa class CwiseBinaryOp, operator-=()
  */
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,difference)
operator-(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{
  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,difference)(derived(), other.derived());
}

/** \returns an expression of the sum of \c *this and \a other
  *
  * \note If you want to add a given scalar to all coefficients, see Cwise::operator+().
  *
  * \sa class CwiseBinaryOp, operator+=()
  */
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,sum)
operator+(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{
  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,sum)(derived(), other.derived());
}

/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
  *
  * The template parameter \a CustomBinaryOp is the type of the functor
  * of the custom operator (see class CwiseBinaryOp for an example)
  *
  * Here is an example illustrating the use of custom functors:
  * \include class_CwiseBinaryOp.cpp




operator/(const Scalar& scalar) const
{
  return ScalarQuotient1ReturnType(derived(), internal::scalar_quotient1_op<Scalar>(scalar));
}

/** Overloaded for efficiently multipling with compatible scalar types */
template <typename T>
EIGEN_DEVICE_FUNC inline
typename internal::enable_if<ScalarBinaryOpTraits<T,Scalar>::Defined,
                             const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,T>, const Derived> >::type
operator*(const T& scalar) const
{
#ifdef EIGEN_SPECIAL_SCALAR_MULTIPLE_PLUGIN
  EIGEN_SPECIAL_SCALAR_MULTIPLE_PLUGIN
#endif
  return CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,T>, const Derived>(
            derived(), internal::scalar_multiple2_op<Scalar,T>(scalar) );


EIGEN_DEVICE_FUNC
inline friend const ScalarMultipleReturnType
operator*(const Scalar& scalar, const StorageBaseType& matrix)
{ return matrix*scalar; }

template <typename T>
EIGEN_DEVICE_FUNC inline friend
typename internal::enable_if<ScalarBinaryOpTraits<Scalar,T>::Defined,
                             const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,T>, const Derived> >::type
operator*(const T& scalar, const StorageBaseType& matrix)
{
#ifdef EIGEN_SPECIAL_SCALAR_MULTIPLE_PLUGIN
  EIGEN_SPECIAL_SCALAR_MULTIPLE_PLUGIN
#endif
  return CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,T>, const Derived>(
            matrix.derived(), internal::scalar_multiple2_op<Scalar,T>(scalar) );
}

template <typename T>
EIGEN_DEVICE_FUNC inline
typename internal::enable_if<ScalarBinaryOpTraits<Scalar,T>::Defined,
                             const CwiseUnaryOp<internal::scalar_quotient2_op<Scalar,T>, const Derived> >::type
operator/(const T& scalar) const
{
#ifdef EIGEN_SPECIAL_SCALAR_MULTIPLE_PLUGIN
  EIGEN_SPECIAL_SCALAR_MULTIPLE_PLUGIN
#endif
  return CwiseUnaryOp<internal::scalar_quotient2_op<Scalar,T>, const Derived>(
            derived(), internal::scalar_quotient2_op<Scalar,T>(scalar) );




  *
  * Example: \include MatrixBase_cwiseProduct.cpp
  * Output: \verbinclude MatrixBase_cwiseProduct.out
  *
  * \sa class CwiseBinaryOp, cwiseAbs2
  */
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{
  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
}

/** \returns an expression of the coefficient-wise == operator of *this and \a other
  *
  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
  * isMuchSmallerThan().




namespace internal {

template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder>
struct packed_triangular_matrix_vector_product;

template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs>
struct packed_triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor>
{
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
  enum {
    IsLower     = (Mode & Lower)   ==Lower,
    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
  };
  static void run(Index size, const LhsScalar* lhs, const RhsScalar* rhs, ResScalar* res, ResScalar alpha)
  {
    internal::conj_if<ConjRhs> cj;

      lhs += IsLower ? size-i: i+1;
    }
  };
};

template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs>
struct packed_triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor>
{
  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
  enum {
    IsLower     = (Mode & Lower)   ==Lower,
    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
  };
  static void run(Index size, const LhsScalar* lhs, const RhsScalar* rhs, ResScalar* res, ResScalar alpha)
  {
    internal::conj_if<ConjRhs> cj;




  // reductions
  VERIFY_IS_APPROX(m1.abs().colwise().sum().sum(), m1.abs().sum());
  VERIFY_IS_APPROX(m1.abs().rowwise().sum().sum(), m1.abs().sum());
  using std::abs;
  VERIFY_IS_MUCH_SMALLER_THAN(abs(m1.colwise().sum().sum() - m1.sum()), m1.abs().sum());
  VERIFY_IS_MUCH_SMALLER_THAN(abs(m1.rowwise().sum().sum() - m1.sum()), m1.abs().sum());
  if (!internal::isMuchSmallerThan(abs(m1.sum() - (m1+m2).sum()), m1.abs().sum(), test_precision<Scalar>()))
      VERIFY_IS_NOT_APPROX(((m1+m2).rowwise().sum()).sum(), m1.sum());
  VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op<Scalar,Scalar>()));

  // vector-wise ops
  m3 = m1;
  VERIFY_IS_APPROX(m3.colwise() += cv1, m1.colwise() + cv1);
  m3 = m1;
  VERIFY_IS_APPROX(m3.colwise() -= cv1, m1.colwise() - cv1);
  m3 = m1;
  VERIFY_IS_APPROX(m3.rowwise() += rv1, m1.rowwise() + rv1);




  typedef Matrix<std::complex<double>, SizeAtCompileType, SizeAtCompileType> Mat_cd;
  typedef Matrix<float, SizeAtCompileType, 1> Vec_f;
  typedef Matrix<double, SizeAtCompileType, 1> Vec_d;
  typedef Matrix<std::complex<float>, SizeAtCompileType, 1> Vec_cf;
  typedef Matrix<std::complex<double>, SizeAtCompileType, 1> Vec_cd;

  Mat_f mf    = Mat_f::Random(size,size);
  Mat_d md    = mf.template cast<double>();
  //Mat_d rd    = md;
  Mat_cf mcf  = Mat_cf::Random(size,size);
  Mat_cd mcd  = mcf.template cast<complex<double> >();
  Mat_cd rcd = mcd;
  Vec_f vf    = Vec_f::Random(size,1);
  Vec_d vd    = vf.template cast<double>();
  Vec_cf vcf  = Vec_cf::Random(size,1);
  Vec_cd vcd  = vcf.template cast<complex<double> >();
  float           sf  = internal::random<float>();
  double          sd  = internal::random<double>();
  complex<float>  scf = internal::random<complex<float> >();
  complex<double> scd = internal::random<complex<double> >();


  mf+mf;

//   VERIFY_RAISES_ASSERT(mf+md); // does not even compile
  // this one does not even compile with C++11
  VERIFY_RAISES_ASSERT(mf+mcf);
#endif

#ifdef EIGEN_DONT_VECTORIZE
  VERIFY_RAISES_ASSERT(vf=vd);
  VERIFY_RAISES_ASSERT(vf+=vd);
  VERIFY_RAISES_ASSERT(mcd=md);
#endif
  
  // check scalar products
  VERIFY_IS_APPROX(vcf * sf , vcf * complex<float>(sf));
  VERIFY_IS_APPROX(sd * vcd, complex<double>(sd) * vcd);
  VERIFY_IS_APPROX(vf * scf , vf.template cast<complex<float> >() * scf);
  VERIFY_IS_APPROX(scd * vd, scd * vd.template cast<complex<double> >());


  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = sd * md * mcd),
                   Mat_cd((sd * md.template cast<CD>().eval() * mcd).template triangularView<Upper>()));
  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = scd * mcd * md),
                   Mat_cd((scd * mcd * md.template cast<CD>().eval()).template triangularView<Upper>()));
  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = scd * md * mcd),
                   Mat_cd((scd * md.template cast<CD>().eval() * mcd).template triangularView<Upper>()));



  VERIFY_IS_APPROX( md.array()  * mcd.array(), md.template cast<CD>().eval().array() * mcd.array() );
  VERIFY_IS_APPROX( mcd.array() * md.array(),  mcd.array() * md.template cast<CD>().eval().array() );

  VERIFY_IS_APPROX( md.array()  + mcd.array(), md.template cast<CD>().eval().array() + mcd.array() );
  VERIFY_IS_APPROX( mcd.array() + md.array(),  mcd.array() + md.template cast<CD>().eval().array() );

  VERIFY_IS_APPROX( md.array()  - mcd.array(), md.template cast<CD>().eval().array() - mcd.array() );
  VERIFY_IS_APPROX( mcd.array() - md.array(),  mcd.array() - md.template cast<CD>().eval().array() );

//   VERIFY_IS_APPROX( md.array() / mcd.array(), md.template cast<CD>().eval().array() / mcd.array() );
  VERIFY_IS_APPROX( mcd.array() / md.array(), mcd.array() / md.template cast<CD>().eval().array() );

  rcd = mcd;
  VERIFY_IS_APPROX( rcd = md, md.template cast<CD>().eval() );
  rcd = mcd;
  VERIFY_IS_APPROX( rcd += md, mcd + md.template cast<CD>().eval() );
  rcd = mcd;
  VERIFY_IS_APPROX( rcd -= md, mcd - md.template cast<CD>().eval() );
  rcd = mcd;
  VERIFY_IS_APPROX( rcd.array() *= md.array(), mcd.array() * md.template cast<CD>().eval().array() );
  rcd = mcd;
  VERIFY_IS_APPROX( rcd.array() /= md.array(), mcd.array() / md.template cast<CD>().eval().array() );

  rcd = mcd;
  VERIFY_IS_APPROX( rcd += md + mcd*md, mcd + (md.template cast<CD>().eval()) + mcd*(md.template cast<CD>().eval()));

  rcd = mcd;
  VERIFY_IS_APPROX( rcd += mcd + md*md, mcd + mcd + ((md*md).template cast<CD>().eval()) );
}

void test_mixingtypes()
{
  for(int i = 0; i < g_repeat; i++) {
    CALL_SUBTEST_1(mixingtypes<3>());
    CALL_SUBTEST_2(mixingtypes<4>());
    CALL_SUBTEST_3(mixingtypes<Dynamic>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE)));




    else if((B_Rows==Dynamic || B_Cols==Dynamic) && (b.size()==0))
    {
      b.resize(a.size());
      b.setZero();
    }
  }
};

} // end namespace internal

template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols>
struct ScalarBinaryOpTraits<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>,A_Scalar>
{
  enum { Defined = 1 };
  typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> ReturnType;
};

template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols>
struct ScalarBinaryOpTraits<A_Scalar, Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> >
{
  enum { Defined = 1 };
  typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> ReturnType;
};

template<typename DerType>
struct ScalarBinaryOpTraits<AutoDiffScalar<DerType>,typename DerType::Scalar>
{
  enum { Defined = 1 };
  typedef AutoDiffScalar<DerType> ReturnType;
};

template<typename DerType>
struct ScalarBinaryOpTraits<typename DerType::Scalar,AutoDiffScalar<DerType> >
{
  enum { Defined = 1 };
  typedef AutoDiffScalar<DerType> ReturnType;
};

} // end namespace internal

#define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC,CODE) \
  template<typename DerType> \
  inline const Eigen::AutoDiffScalar<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<typename Eigen::internal::traits<typename Eigen::internal::remove_all<DerType>::type>::Scalar>, const typename Eigen::internal::remove_all<DerType>::type> > \
  FUNC(const Eigen::AutoDiffScalar<DerType>& x) { \
    using namespace Eigen; \
    typedef typename Eigen::internal::traits<typename Eigen::internal::remove_all<DerType>::type>::Scalar Scalar; \
    typedef AutoDiffScalar<CwiseUnaryOp<Eigen::internal::scalar_multiple_op<Scalar>, const typename Eigen::internal::remove_all<DerType>::type> > ReturnType; \
    CODE; \





namespace internal {

template<typename _Lhs, typename _Rhs>
struct traits<KroneckerProduct<_Lhs,_Rhs> >
{
  typedef typename remove_all<_Lhs>::type Lhs;
  typedef typename remove_all<_Rhs>::type Rhs;
  typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
  typedef typename promote_index_type<typename Lhs::StorageIndex, typename Rhs::StorageIndex>::type StorageIndex;

  enum {
    Rows = size_at_compile_time<traits<Lhs>::RowsAtCompileTime, traits<Rhs>::RowsAtCompileTime>::ret,
    Cols = size_at_compile_time<traits<Lhs>::ColsAtCompileTime, traits<Rhs>::ColsAtCompileTime>::ret,
    MaxRows = size_at_compile_time<traits<Lhs>::MaxRowsAtCompileTime, traits<Rhs>::MaxRowsAtCompileTime>::ret,
    MaxCols = size_at_compile_time<traits<Lhs>::MaxColsAtCompileTime, traits<Rhs>::MaxColsAtCompileTime>::ret
  };

};

template<typename _Lhs, typename _Rhs>
struct traits<KroneckerProductSparse<_Lhs,_Rhs> >
{
  typedef MatrixXpr XprKind;
  typedef typename remove_all<_Lhs>::type Lhs;
  typedef typename remove_all<_Rhs>::type Rhs;
  typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
  typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind, typename traits<Rhs>::StorageKind, scalar_product_op<typename Lhs::Scalar, typename Rhs::Scalar> >::ret StorageKind;
  typedef typename promote_index_type<typename Lhs::StorageIndex, typename Rhs::StorageIndex>::type StorageIndex;

  enum {
    LhsFlags = Lhs::Flags,
    RhsFlags = Rhs::Flags,

    RowsAtCompileTime = size_at_compile_time<traits<Lhs>::RowsAtCompileTime, traits<Rhs>::RowsAtCompileTime>::ret,

Return to bug 279

Lines 171-200 template<typename Derived> class ArrayBa Link Here

(-)a/Eigen/src/Core/ArrayBase.h (-2 / +2 lines)
171	*	171	*
172	* \returns a reference to \c *this	172	* \returns a reference to \c *this
173	*/	173	*/
174	template<typename Derived>	174	template<typename Derived>
175	template<typename OtherDerived>	175	template<typename OtherDerived>
176	EIGEN_STRONG_INLINE Derived &	176	EIGEN_STRONG_INLINE Derived &
177	ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)	177	ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)
178	{	178	{
179	call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar>());	179	call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
180	return derived();	180	return derived();
181	}	181	}
182		182
183	/** replaces \c this by \c this + \a other.	183	/** replaces \c this by \c this + \a other.
184	*	184	*
185	* \returns a reference to \c *this	185	* \returns a reference to \c *this
186	*/	186	*/
187	template<typename Derived>	187	template<typename Derived>
188	template<typename OtherDerived>	188	template<typename OtherDerived>
189	EIGEN_STRONG_INLINE Derived &	189	EIGEN_STRONG_INLINE Derived &
190	ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)	190	ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)
191	{	191	{
192	call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar>());	192	call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
193	return derived();	193	return derived();
194	}	194	}
195		195
196	/** replaces \c this by \c this * \a other coefficient wise.	196	/** replaces \c this by \c this * \a other coefficient wise.
197	*	197	*
198	* \returns a reference to \c *this	198	* \returns a reference to \c *this
199	*/	199	*/
200	template<typename Derived>	200	template<typename Derived>

Lines 155-183 public: Link Here

(-)a/Eigen/src/Core/CwiseBinaryOp.h (-2 / +2 lines)
155	*	155	*
156	* \returns a reference to \c *this	156	* \returns a reference to \c *this
157	*/	157	*/
158	template<typename Derived>	158	template<typename Derived>
159	template<typename OtherDerived>	159	template<typename OtherDerived>
160	EIGEN_STRONG_INLINE Derived &	160	EIGEN_STRONG_INLINE Derived &
161	MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)	161	MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
162	{	162	{
163	call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar>());	163	call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
164	return derived();	164	return derived();
165	}	165	}
166		166
167	/** replaces \c this by \c this + \a other.	167	/** replaces \c this by \c this + \a other.
168	*	168	*
169	* \returns a reference to \c *this	169	* \returns a reference to \c *this
170	*/	170	*/
171	template<typename Derived>	171	template<typename Derived>
172	template<typename OtherDerived>	172	template<typename OtherDerived>
173	EIGEN_STRONG_INLINE Derived &	173	EIGEN_STRONG_INLINE Derived &
174	MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)	174	MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
175	{	175	{
176	call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar>());	176	call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
177	return derived();	177	return derived();
178	}	178	}
179		179
180	} // end namespace Eigen	180	} // end namespace Eigen
181		181
182	#endif // EIGEN_CWISE_BINARY_OP_H	182	#endif // EIGEN_CWISE_BINARY_OP_H
183		183

Lines 23-54 template<typename T, typename U, Link Here

(-)a/Eigen/src/Core/Dot.h (-5 / +7 lines)
23	&& U::IsVectorAtCompileTime	23	&& U::IsVectorAtCompileTime
24	&& ((int(T::RowsAtCompileTime) == 1 && int(U::ColsAtCompileTime) == 1)	24	&& ((int(T::RowsAtCompileTime) == 1 && int(U::ColsAtCompileTime) == 1)
25	\| // FIXME \| instead of \|\| to please GCC 4.4.0 stupid warning "suggest parentheses around &&".	25	\| // FIXME \| instead of \|\| to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
26	// revert to \|\| as soon as not needed anymore.	26	// revert to \|\| as soon as not needed anymore.
27	(int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1))	27	(int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1))
28	>	28	>
29	struct dot_nocheck	29	struct dot_nocheck
30	{	30	{
31	typedef typename scalar_product_traits<typename traits<T>::Scalar,typename traits<U>::Scalar>::ReturnType ResScalar;	31	typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
		32	typedef typename conj_prod::result_type ResScalar;
32	EIGEN_DEVICE_FUNC	33	EIGEN_DEVICE_FUNC
33	static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)	34	static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
34	{	35	{
35	return a.template binaryExpr<scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> >(b).sum();	36	return a.template binaryExpr<conj_prod>(b).sum();
36	}	37	}
37	};	38	};
38		39
39	template<typename T, typename U>	40	template<typename T, typename U>
40	struct dot_nocheck<T, U, true>	41	struct dot_nocheck<T, U, true>
41	{	42	{
42	typedef typename scalar_product_traits<typename traits<T>::Scalar,typename traits<U>::Scalar>::ReturnType ResScalar;	43	typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
		44	typedef typename conj_prod::result_type ResScalar;
43	EIGEN_DEVICE_FUNC	45	EIGEN_DEVICE_FUNC
44	static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)	46	static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
45	{	47	{
46	return a.transpose().template binaryExpr<scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> >(b).sum();	48	return a.transpose().template binaryExpr<conj_prod>(b).sum();
47	}	49	}
48	};	50	};
49		51
50	} // end namespace internal	52	} // end namespace internal
51		53
52	/** \returns the dot product of *this with other.	54	/** \returns the dot product of *this with other.
53	*	55	*
54	* \only_for_vectors	56	* \only_for_vectors
Lines 57-73 struct dot_nocheck<T, U, true> Link Here
57	* (sesquilinear) dot product, conjugate-linear in the first variable and linear in the	59	* (sesquilinear) dot product, conjugate-linear in the first variable and linear in the
58	* second variable.	60	* second variable.
59	*	61	*
60	* \sa squaredNorm(), norm()	62	* \sa squaredNorm(), norm()
61	*/	63	*/
62	template<typename Derived>	64	template<typename Derived>
63	template<typename OtherDerived>	65	template<typename OtherDerived>
64	EIGEN_DEVICE_FUNC	66	EIGEN_DEVICE_FUNC
65	typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType	67	typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
66	MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const	68	MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
67	{	69	{
68	EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)	70	EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
69	EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)	71	EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
70	EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)	72	EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
71	typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;	73	typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;
72	EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);	74	EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);
73		75

Lines 682-698 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE vo Link Here

(-)a/Eigen/src/Core/AssignEvaluator.h (-6 / +6 lines)
682	Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());	682	Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
683		683
684	dense_assignment_loop<Kernel>::run(kernel);	684	dense_assignment_loop<Kernel>::run(kernel);
685	}	685	}
686		686
687	template<typename DstXprType, typename SrcXprType>	687	template<typename DstXprType, typename SrcXprType>
688	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(const DstXprType& dst, const SrcXprType& src)	688	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(const DstXprType& dst, const SrcXprType& src)
689	{	689	{
690	call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar>());	690	call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
691	}	691	}
692		692
693	/***************************************************************************	693	/***************************************************************************
694	* Part 6 : Generic assignment	694	* Part 6 : Generic assignment
695	***************************************************************************/	695	***************************************************************************/
696		696
697	// Based on the respective shapes of the destination and source,	697	// Based on the respective shapes of the destination and source,
698	// the class AssignmentKind determine the kind of assignment mechanism.	698	// the class AssignmentKind determine the kind of assignment mechanism.
Lines 717-739 struct Assignment; Link Here
717	// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.	717	// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.
718	// So this intermediate function removes everything related to "assume-aliasing" such that Assignment	718	// So this intermediate function removes everything related to "assume-aliasing" such that Assignment
719	// does not has to bother about these annoying details.	719	// does not has to bother about these annoying details.
720		720
721	template<typename Dst, typename Src>	721	template<typename Dst, typename Src>
722	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	722	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
723	void call_assignment(Dst& dst, const Src& src)	723	void call_assignment(Dst& dst, const Src& src)
724	{	724	{
725	call_assignment(dst, src, internal::assign_op<typename Dst::Scalar>());	725	call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
726	}	726	}
727	template<typename Dst, typename Src>	727	template<typename Dst, typename Src>
728	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	728	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
729	void call_assignment(const Dst& dst, const Src& src)	729	void call_assignment(const Dst& dst, const Src& src)
730	{	730	{
731	call_assignment(dst, src, internal::assign_op<typename Dst::Scalar>());	731	call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
732	}	732	}
733		733
734	// Deal with "assume-aliasing"	734	// Deal with "assume-aliasing"
735	template<typename Dst, typename Src, typename Func>	735	template<typename Dst, typename Src, typename Func>
736	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	736	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
737	void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)	737	void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
738	{	738	{
739	typename plain_matrix_type<Src>::type tmp(src);	739	typename plain_matrix_type<Src>::type tmp(src);
Lines 782-798 void call_assignment_no_alias(Dst& dst, Link Here
782	EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);	782	EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
783		783
784	Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);	784	Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
785	}	785	}
786	template<typename Dst, typename Src>	786	template<typename Dst, typename Src>
787	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	787	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
788	void call_assignment_no_alias(Dst& dst, const Src& src)	788	void call_assignment_no_alias(Dst& dst, const Src& src)
789	{	789	{
790	call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar>());	790	call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
791	}	791	}
792		792
793	template<typename Dst, typename Src, typename Func>	793	template<typename Dst, typename Src, typename Func>
794	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	794	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
795	void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)	795	void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)
796	{	796	{
797	Index dstRows = src.rows();	797	Index dstRows = src.rows();
798	Index dstCols = src.cols();	798	Index dstCols = src.cols();
Lines 804-820 void call_assignment_no_alias_no_transpo Link Here
804	EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)	804	EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
805		805
806	Assignment<Dst,Src,Func>::run(dst, src, func);	806	Assignment<Dst,Src,Func>::run(dst, src, func);
807	}	807	}
808	template<typename Dst, typename Src>	808	template<typename Dst, typename Src>
809	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	809	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
810	void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)	810	void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
811	{	811	{
812	call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar>());	812	call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
813	}	813	}
814		814
815	// forward declaration	815	// forward declaration
816	template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);	816	template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);
817		817
818	// Generic Dense to Dense assignment	818	// Generic Dense to Dense assignment
819	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>	819	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
820	struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Scalar>	820	struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Scalar>
Lines 833-849 struct Assignment<DstXprType, SrcXprType Link Here
833	};	833	};
834		834
835	// Generic assignment through evalTo.	835	// Generic assignment through evalTo.
836	// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.	836	// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
837	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>	837	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
838	struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Scalar>	838	struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Scalar>
839	{	839	{
840	EIGEN_DEVICE_FUNC	840	EIGEN_DEVICE_FUNC
841	static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar> &/func/)	841	static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/func/)
842	{	842	{
843	eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());	843	eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
844	src.evalTo(dst);	844	src.evalTo(dst);
845	}	845	}
846	};	846	};
847		847
848	} // namespace internal	848	} // namespace internal
849		849

Lines 315-340 template<> struct storage_kind_to_shape< Link Here

(-)a/Eigen/src/Core/DiagonalMatrix.h (-3 / +3 lines)
315	struct Diagonal2Dense {};	315	struct Diagonal2Dense {};
316		316
317	template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };	317	template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };
318		318
319	// Diagonal matrix to Dense assignment	319	// Diagonal matrix to Dense assignment
320	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>	320	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
321	struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense, Scalar>	321	struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense, Scalar>
322	{	322	{
323	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar> &/func/)	323	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/func/)
324	{	324	{
325	dst.setZero();	325	dst.setZero();
326	dst.diagonal() = src.diagonal();	326	dst.diagonal() = src.diagonal();
327	}	327	}
328		328
329	static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar> &/func/)	329	static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/func/)
330	{ dst.diagonal() += src.diagonal(); }	330	{ dst.diagonal() += src.diagonal(); }
331		331
332	static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar> &/func/)	332	static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/func/)
333	{ dst.diagonal() -= src.diagonal(); }	333	{ dst.diagonal() -= src.diagonal(); }
334	};	334	};
335		335
336	} // namespace internal	336	} // namespace internal
337		337
338	} // end namespace Eigen	338	} // end namespace Eigen
339		339
340	#endif // EIGEN_DIAGONALMATRIX_H	340	#endif // EIGEN_DIAGONALMATRIX_H

Lines 133-155 Derived& DenseBase<Derived>::operator=(c Link Here

(-)a/Eigen/src/Core/EigenBase.h (-2 / +2 lines)
133	call_assignment(derived(), other.derived());	133	call_assignment(derived(), other.derived());
134	return derived();	134	return derived();
135	}	135	}
136		136
137	template<typename Derived>	137	template<typename Derived>
138	template<typename OtherDerived>	138	template<typename OtherDerived>
139	Derived& DenseBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)	139	Derived& DenseBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
140	{	140	{
141	call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar>());	141	call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
142	return derived();	142	return derived();
143	}	143	}
144		144
145	template<typename Derived>	145	template<typename Derived>
146	template<typename OtherDerived>	146	template<typename OtherDerived>
147	Derived& DenseBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)	147	Derived& DenseBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
148	{	148	{
149	call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar>());	149	call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
150	return derived();	150	return derived();
151	}	151	}
152		152
153	} // end namespace Eigen	153	} // end namespace Eigen
154		154
155	#endif // EIGEN_EIGENBASE_H	155	#endif // EIGEN_EIGENBASE_H

Lines 188-204 template<typename Derived> class MatrixB Link Here

(-)a/Eigen/src/Core/MatrixBase.h (-2 / +2 lines)
188		188
189	template<typename DiagonalDerived>	189	template<typename DiagonalDerived>
190	EIGEN_DEVICE_FUNC	190	EIGEN_DEVICE_FUNC
191	const Product<Derived, DiagonalDerived, LazyProduct>	191	const Product<Derived, DiagonalDerived, LazyProduct>
192	operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;	192	operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
193		193
194	template<typename OtherDerived>	194	template<typename OtherDerived>
195	EIGEN_DEVICE_FUNC	195	EIGEN_DEVICE_FUNC
196	typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType	196	typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
197	dot(const MatrixBase<OtherDerived>& other) const;	197	dot(const MatrixBase<OtherDerived>& other) const;
198		198
199	EIGEN_DEVICE_FUNC RealScalar squaredNorm() const;	199	EIGEN_DEVICE_FUNC RealScalar squaredNorm() const;
200	EIGEN_DEVICE_FUNC RealScalar norm() const;	200	EIGEN_DEVICE_FUNC RealScalar norm() const;
201	RealScalar stableNorm() const;	201	RealScalar stableNorm() const;
202	RealScalar blueNorm() const;	202	RealScalar blueNorm() const;
203	RealScalar hypotNorm() const;	203	RealScalar hypotNorm() const;
204	EIGEN_DEVICE_FUNC const PlainObject normalized() const;	204	EIGEN_DEVICE_FUNC const PlainObject normalized() const;
Lines 376-392 template<typename Derived> class MatrixB Link Here
376	inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;	376	inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
377	inline BDCSVD<PlainObject> bdcSvd(unsigned int computationOptions = 0) const;	377	inline BDCSVD<PlainObject> bdcSvd(unsigned int computationOptions = 0) const;
378		378
379	/////////// Geometry module ///////////	379	/////////// Geometry module ///////////
380		380
381	#ifndef EIGEN_PARSED_BY_DOXYGEN	381	#ifndef EIGEN_PARSED_BY_DOXYGEN
382	/// \internal helper struct to form the return type of the cross product	382	/// \internal helper struct to form the return type of the cross product
383	template<typename OtherDerived> struct cross_product_return_type {	383	template<typename OtherDerived> struct cross_product_return_type {
384	typedef typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;	384	typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
385	typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;	385	typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;
386	};	386	};
387	#endif // EIGEN_PARSED_BY_DOXYGEN	387	#endif // EIGEN_PARSED_BY_DOXYGEN
388	template<typename OtherDerived>	388	template<typename OtherDerived>
389	EIGEN_DEVICE_FUNC	389	EIGEN_DEVICE_FUNC
390	#ifndef EIGEN_PARSED_BY_DOXYGEN	390	#ifndef EIGEN_PARSED_BY_DOXYGEN
391	inline typename cross_product_return_type<OtherDerived>::type	391	inline typename cross_product_return_type<OtherDerived>::type
392	#else	392	#else

Lines 34-66 class NoAlias Link Here

(-)a/Eigen/src/Core/NoAlias.h (-3 / +3 lines)
34	typedef typename ExpressionType::Scalar Scalar;	34	typedef typename ExpressionType::Scalar Scalar;
35		35
36	explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}	36	explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}
37		37
38	template<typename OtherDerived>	38	template<typename OtherDerived>
39	EIGEN_DEVICE_FUNC	39	EIGEN_DEVICE_FUNC
40	EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other)	40	EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other)
41	{	41	{
42	call_assignment_no_alias(m_expression, other.derived(), internal::assign_op<Scalar>());	42	call_assignment_no_alias(m_expression, other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
43	return m_expression;	43	return m_expression;
44	}	44	}
45		45
46	template<typename OtherDerived>	46	template<typename OtherDerived>
47	EIGEN_DEVICE_FUNC	47	EIGEN_DEVICE_FUNC
48	EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other)	48	EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other)
49	{	49	{
50	call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op<Scalar>());	50	call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
51	return m_expression;	51	return m_expression;
52	}	52	}
53		53
54	template<typename OtherDerived>	54	template<typename OtherDerived>
55	EIGEN_DEVICE_FUNC	55	EIGEN_DEVICE_FUNC
56	EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other)	56	EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other)
57	{	57	{
58	call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op<Scalar>());	58	call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
59	return m_expression;	59	return m_expression;
60	}	60	}
61		61
62	EIGEN_DEVICE_FUNC	62	EIGEN_DEVICE_FUNC
63	ExpressionType& expression() const	63	ExpressionType& expression() const
64	{	64	{
65	return m_expression;	65	return m_expression;
66	}	66	}

Lines 713-729 class PlainObjectBase : public internal: Link Here

(-)a/Eigen/src/Core/PlainObjectBase.h (-1 / +1 lines)
713	EIGEN_DEVICE_FUNC	713	EIGEN_DEVICE_FUNC
714	EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)	714	EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
715	{	715	{
716	// I don't think we need this resize call since the lazyAssign will anyways resize	716	// I don't think we need this resize call since the lazyAssign will anyways resize
717	// and lazyAssign will be called by the assign selector.	717	// and lazyAssign will be called by the assign selector.
718	//_resize_to_match(other);	718	//_resize_to_match(other);
719	// the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because	719	// the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
720	// it wouldn't allow to copy a row-vector into a column-vector.	720	// it wouldn't allow to copy a row-vector into a column-vector.
721	internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar>());	721	internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
722	return this->derived();	722	return this->derived();
723	}	723	}
724		724
725	template<typename T0, typename T1>	725	template<typename T0, typename T1>
726	EIGEN_DEVICE_FUNC	726	EIGEN_DEVICE_FUNC
727	EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)	727	EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
728	{	728	{
729	EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&	729	EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&

Lines 13-33 Link Here

(-)a/Eigen/src/Core/Product.h (-1 / +2 lines)
13	namespace Eigen {	13	namespace Eigen {
14		14
15	template<typename Lhs, typename Rhs, int Option, typename StorageKind> class ProductImpl;	15	template<typename Lhs, typename Rhs, int Option, typename StorageKind> class ProductImpl;
16		16
17	namespace internal {	17	namespace internal {
18		18
19	// Determine the scalar of Product<Lhs, Rhs>. This is normally the same as Lhs::Scalar times	19	// Determine the scalar of Product<Lhs, Rhs>. This is normally the same as Lhs::Scalar times
20	// Rhs::Scalar, but product with permutation matrices inherit the scalar of the other factor.	20	// Rhs::Scalar, but product with permutation matrices inherit the scalar of the other factor.
		21	// TODO: this could be removed once ScalarBinaryOpTraits handles void.
21	template<typename Lhs, typename Rhs, typename LhsShape = typename evaluator_traits<Lhs>::Shape,	22	template<typename Lhs, typename Rhs, typename LhsShape = typename evaluator_traits<Lhs>::Shape,
22	typename RhsShape = typename evaluator_traits<Rhs>::Shape >	23	typename RhsShape = typename evaluator_traits<Rhs>::Shape >
23	struct product_result_scalar	24	struct product_result_scalar
24	{	25	{
25	typedef typename scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;	26	typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
26	};	27	};
27		28
28	template<typename Lhs, typename Rhs, typename RhsShape>	29	template<typename Lhs, typename Rhs, typename RhsShape>
29	struct product_result_scalar<Lhs, Rhs, PermutationShape, RhsShape>	30	struct product_result_scalar<Lhs, Rhs, PermutationShape, RhsShape>
30	{	31	{
31	typedef typename Rhs::Scalar Scalar;	32	typedef typename Rhs::Scalar Scalar;
32	};	33	};
33		34

Lines 119-168 struct product_evaluator<Product<Lhs, Rh Link Here

(-)a/Eigen/src/Core/ProductEvaluators.h (-27 / +28 lines)
119	}	119	}
120		120
121	protected:	121	protected:
122	PlainObject m_result;	122	PlainObject m_result;
123	};	123	};
124		124
125	// Dense = Product	125	// Dense = Product
126	template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>	126	template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
127	struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::assign_op<Scalar>, Dense2Dense,	127	struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::assign_op<Scalar,typename Product<Lhs,Rhs,Options>::Scalar>, Dense2Dense,
128	typename enable_if<(Options==DefaultProduct \|\| Options==AliasFreeProduct),Scalar>::type>	128	typename enable_if<(Options==DefaultProduct \|\| Options==AliasFreeProduct),Scalar>::type>
129	{	129	{
130	typedef Product<Lhs,Rhs,Options> SrcXprType;	130	typedef Product<Lhs,Rhs,Options> SrcXprType;
131	static EIGEN_STRONG_INLINE	131	static EIGEN_STRONG_INLINE
132	void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	132	void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename SrcXprType::Scalar> &)
133	{	133	{
134	// FIXME shall we handle nested_eval here?	134	// FIXME shall we handle nested_eval here?
135	generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());	135	generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
136	}	136	}
137	};	137	};
138		138
139	// Dense += Product	139	// Dense += Product
140	template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>	140	template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
141	struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::add_assign_op<Scalar>, Dense2Dense,	141	struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::add_assign_op<Scalar,typename Product<Lhs,Rhs,Options>::Scalar>, Dense2Dense,
142	typename enable_if<(Options==DefaultProduct \|\| Options==AliasFreeProduct),Scalar>::type>	142	typename enable_if<(Options==DefaultProduct \|\| Options==AliasFreeProduct),Scalar>::type>
143	{	143	{
144	typedef Product<Lhs,Rhs,Options> SrcXprType;	144	typedef Product<Lhs,Rhs,Options> SrcXprType;
145	static EIGEN_STRONG_INLINE	145	static EIGEN_STRONG_INLINE
146	void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar> &)	146	void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,typename SrcXprType::Scalar> &)
147	{	147	{
148	// FIXME shall we handle nested_eval here?	148	// FIXME shall we handle nested_eval here?
149	generic_product_impl<Lhs, Rhs>::addTo(dst, src.lhs(), src.rhs());	149	generic_product_impl<Lhs, Rhs>::addTo(dst, src.lhs(), src.rhs());
150	}	150	}
151	};	151	};
152		152
153	// Dense -= Product	153	// Dense -= Product
154	template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>	154	template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
155	struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::sub_assign_op<Scalar>, Dense2Dense,	155	struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::sub_assign_op<Scalar,typename Product<Lhs,Rhs,Options>::Scalar>, Dense2Dense,
156	typename enable_if<(Options==DefaultProduct \|\| Options==AliasFreeProduct),Scalar>::type>	156	typename enable_if<(Options==DefaultProduct \|\| Options==AliasFreeProduct),Scalar>::type>
157	{	157	{
158	typedef Product<Lhs,Rhs,Options> SrcXprType;	158	typedef Product<Lhs,Rhs,Options> SrcXprType;
159	static EIGEN_STRONG_INLINE	159	static EIGEN_STRONG_INLINE
160	void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar> &)	160	void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,typename SrcXprType::Scalar> &)
161	{	161	{
162	// FIXME shall we handle nested_eval here?	162	// FIXME shall we handle nested_eval here?
163	generic_product_impl<Lhs, Rhs>::subTo(dst, src.lhs(), src.rhs());	163	generic_product_impl<Lhs, Rhs>::subTo(dst, src.lhs(), src.rhs());
164	}	164	}
165	};	165	};
166		166
167		167
168	// Dense ?= scalar * Product	168	// Dense ?= scalar * Product
Lines 182-228 struct Assignment<DstXprType, CwiseUnary Link Here
182	};	182	};
183		183
184	//----------------------------------------	184	//----------------------------------------
185	// Catch "Dense ?= xpr + Product<>" expression to save one temporary	185	// Catch "Dense ?= xpr + Product<>" expression to save one temporary
186	// FIXME we could probably enable these rules for any product, i.e., not only Dense and DefaultProduct	186	// FIXME we could probably enable these rules for any product, i.e., not only Dense and DefaultProduct
187	// TODO enable it for "Dense ?= xpr - Product<>" as well.	187	// TODO enable it for "Dense ?= xpr - Product<>" as well.
188		188
189	template<typename OtherXpr, typename Lhs, typename Rhs>	189	template<typename OtherXpr, typename Lhs, typename Rhs>
190	struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar>, const OtherXpr,	190	struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
191	const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {	191	const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
192	static const bool value = true;	192	static const bool value = true;
193	};	193	};
194		194
195	template<typename DstXprType, typename OtherXpr, typename ProductType, typename Scalar, typename Func1, typename Func2>	195	template<typename DstXprType, typename OtherXpr, typename ProductType, typename Func1, typename Func2>
196	struct assignment_from_xpr_plus_product	196	struct assignment_from_xpr_plus_product
197	{	197	{
198	typedef CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const OtherXpr, const ProductType> SrcXprType;	198	typedef CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar,typename ProductType::Scalar>, const OtherXpr, const ProductType> SrcXprType;
		199	template<typename InitialFunc>
199	static EIGEN_STRONG_INLINE	200	static EIGEN_STRONG_INLINE
200	void run(DstXprType &dst, const SrcXprType &src, const Func1& func)	201	void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /func/)
201	{	202	{
202	call_assignment_no_alias(dst, src.lhs(), func);	203	call_assignment_no_alias(dst, src.lhs(), Func1());
203	call_assignment_no_alias(dst, src.rhs(), Func2());	204	call_assignment_no_alias(dst, src.rhs(), Func2());
204	}	205	}
205	};	206	};
206		207
207	template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename Scalar>	208	template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar>
208	struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const OtherXpr,	209	struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<OtherScalar,ProdScalar>, const OtherXpr,
209	const Product<Lhs,Rhs,DefaultProduct> >, internal::assign_op<Scalar>, Dense2Dense>	210	const Product<Lhs,Rhs,DefaultProduct> >, internal::assign_op<DstScalar,SrcScalar>, Dense2Dense>
210	: assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, Scalar, internal::assign_op<Scalar>, internal::add_assign_op<Scalar> >	211	: assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<DstScalar,OtherScalar>, internal::add_assign_op<DstScalar,ProdScalar> >
211	{};	212	{};
212	template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename Scalar>	213	template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar>
213	struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const OtherXpr,	214	struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<OtherScalar,ProdScalar>, const OtherXpr,
214	const Product<Lhs,Rhs,DefaultProduct> >, internal::add_assign_op<Scalar>, Dense2Dense>	215	const Product<Lhs,Rhs,DefaultProduct> >, internal::add_assign_op<DstScalar,SrcScalar>, Dense2Dense>
215	: assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, Scalar, internal::add_assign_op<Scalar>, internal::add_assign_op<Scalar> >	216	: assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<DstScalar,OtherScalar>, internal::add_assign_op<DstScalar,ProdScalar> >
216	{};	217	{};
217	template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename Scalar>	218	template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar>
218	struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const OtherXpr,	219	struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_sum_op<OtherScalar,ProdScalar>, const OtherXpr,
219	const Product<Lhs,Rhs,DefaultProduct> >, internal::sub_assign_op<Scalar>, Dense2Dense>	220	const Product<Lhs,Rhs,DefaultProduct> >, internal::sub_assign_op<DstScalar,SrcScalar>, Dense2Dense>
220	: assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, Scalar, internal::sub_assign_op<Scalar>, internal::sub_assign_op<Scalar> >	221	: assignment_from_xpr_plus_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<DstScalar,OtherScalar>, internal::sub_assign_op<DstScalar,ProdScalar> >
221	{};	222	{};
222	//----------------------------------------	223	//----------------------------------------
223		224
224	template<typename Lhs, typename Rhs>	225	template<typename Lhs, typename Rhs>
225	struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,InnerProduct>	226	struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,InnerProduct>
226	{	227	{
227	template<typename Dst>	228	template<typename Dst>
228	static inline void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)	229	static inline void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
Lines 364-394 struct generic_product_impl<Lhs,Rhs,Dens Link Here
364	{	365	{
365	typedef typename Product<Lhs,Rhs>::Scalar Scalar;	366	typedef typename Product<Lhs,Rhs>::Scalar Scalar;
366		367
367	template<typename Dst>	368	template<typename Dst>
368	static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)	369	static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
369	{	370	{
370	// Same as: dst.noalias() = lhs.lazyProduct(rhs);	371	// Same as: dst.noalias() = lhs.lazyProduct(rhs);
371	// but easier on the compiler side	372	// but easier on the compiler side
372	call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op<Scalar>());	373	call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op<typename Dst::Scalar,Scalar>());
373	}	374	}
374		375
375	template<typename Dst>	376	template<typename Dst>
376	static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)	377	static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
377	{	378	{
378	// dst.noalias() += lhs.lazyProduct(rhs);	379	// dst.noalias() += lhs.lazyProduct(rhs);
379	call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op<Scalar>());	380	call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op<typename Dst::Scalar,Scalar>());
380	}	381	}
381		382
382	template<typename Dst>	383	template<typename Dst>
383	static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)	384	static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
384	{	385	{
385	// dst.noalias() -= lhs.lazyProduct(rhs);	386	// dst.noalias() -= lhs.lazyProduct(rhs);
386	call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op<Scalar>());	387	call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op<typename Dst::Scalar,Scalar>());
387	}	388	}
388		389
389	// template<typename Dst>	390	// template<typename Dst>
390	// static inline void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)	391	// static inline void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
391	// { dst.noalias() += alpha * lhs.lazyProduct(rhs); }	392	// { dst.noalias() += alpha * lhs.lazyProduct(rhs); }
392	};	393	};
393		394
394	// This specialization enforces the use of a coefficient-based evaluation strategy	395	// This specialization enforces the use of a coefficient-based evaluation strategy
Lines 730-746 struct generic_product_impl<Lhs,Rhs,Dens Link Here
730	/***************************************************************************	731	/***************************************************************************
731	* Diagonal products	732	* Diagonal products
732	***************************************************************************/	733	***************************************************************************/
733		734
734	template<typename MatrixType, typename DiagonalType, typename Derived, int ProductOrder>	735	template<typename MatrixType, typename DiagonalType, typename Derived, int ProductOrder>
735	struct diagonal_product_evaluator_base	736	struct diagonal_product_evaluator_base
736	: evaluator_base<Derived>	737	: evaluator_base<Derived>
737	{	738	{
738	typedef typename scalar_product_traits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar;	739	typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar;
739	public:	740	public:
740	enum {	741	enum {
741	CoeffReadCost = NumTraits<Scalar>::MulCost + evaluator<MatrixType>::CoeffReadCost + evaluator<DiagonalType>::CoeffReadCost,	742	CoeffReadCost = NumTraits<Scalar>::MulCost + evaluator<MatrixType>::CoeffReadCost + evaluator<DiagonalType>::CoeffReadCost,
742		743
743	MatrixFlags = evaluator<MatrixType>::Flags,	744	MatrixFlags = evaluator<MatrixType>::Flags,
744	DiagFlags = evaluator<DiagonalType>::Flags,	745	DiagFlags = evaluator<DiagonalType>::Flags,
745	_StorageOrder = MatrixFlags & RowMajorBit ? RowMajor : ColMajor,	746	_StorageOrder = MatrixFlags & RowMajorBit ? RowMajor : ColMajor,
746	_ScalarAccessOnDiag = !((int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheLeft)	747	_ScalarAccessOnDiag = !((int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheLeft)

Lines 445-476 DenseBase<Derived>::maxCoeff() const Link Here

(-)a/Eigen/src/Core/Redux.h (-2 / +2 lines)
445	* \sa trace(), prod(), mean()	445	* \sa trace(), prod(), mean()
446	*/	446	*/
447	template<typename Derived>	447	template<typename Derived>
448	EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar	448	EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
449	DenseBase<Derived>::sum() const	449	DenseBase<Derived>::sum() const
450	{	450	{
451	if(SizeAtCompileTime==0 \|\| (SizeAtCompileTime==Dynamic && size()==0))	451	if(SizeAtCompileTime==0 \|\| (SizeAtCompileTime==Dynamic && size()==0))
452	return Scalar(0);	452	return Scalar(0);
453	return derived().redux(Eigen::internal::scalar_sum_op<Scalar>());	453	return derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>());
454	}	454	}
455		455
456	/** \returns the mean of all coefficients of *this	456	/** \returns the mean of all coefficients of *this
457	*	457	*
458	* \sa trace(), prod(), sum()	458	* \sa trace(), prod(), sum()
459	*/	459	*/
460	template<typename Derived>	460	template<typename Derived>
461	EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar	461	EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
462	DenseBase<Derived>::mean() const	462	DenseBase<Derived>::mean() const
463	{	463	{
464	#ifdef __INTEL_COMPILER	464	#ifdef __INTEL_COMPILER
465	#pragma warning push	465	#pragma warning push
466	#pragma warning ( disable : 2259 )	466	#pragma warning ( disable : 2259 )
467	#endif	467	#endif
468	return Scalar(derived().redux(Eigen::internal::scalar_sum_op<Scalar>())) / Scalar(this->size());	468	return Scalar(derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>())) / Scalar(this->size());
469	#ifdef __INTEL_COMPILER	469	#ifdef __INTEL_COMPILER
470	#pragma warning pop	470	#pragma warning pop
471	#endif	471	#endif
472	}	472	}
473		473
474	/** \returns the product of all coefficients of *this	474	/** \returns the product of all coefficients of *this
475	*	475	*
476	* Example: \include MatrixBase_prod.cpp	476	* Example: \include MatrixBase_prod.cpp

Lines 257-273 template<typename TPlainObjectType, int Link Here

(-)a/Eigen/src/Core/Ref.h (-1 / +1 lines)
257	EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type)	257	EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type)
258	{	258	{
259	Base::construct(expr);	259	Base::construct(expr);
260	}	260	}
261		261
262	template<typename Expression>	262	template<typename Expression>
263	EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type)	263	EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type)
264	{	264	{
265	internal::call_assignment_no_alias(m_object,expr,internal::assign_op<Scalar>());	265	internal::call_assignment_no_alias(m_object,expr,internal::assign_op<Scalar,Scalar>());
266	Base::construct(m_object);	266	Base::construct(m_object);
267	}	267	}
268		268
269	protected:	269	protected:
270	TPlainObjectType m_object;	270	TPlainObjectType m_object;
271	};	271	};
272		272
273	} // end namespace Eigen	273	} // end namespace Eigen

Lines 7-49 Link Here

(-)a/Eigen/src/Core/SelfCwiseBinaryOp.h (-4 / +6 lines)
7	// Public License v. 2.0. If a copy of the MPL was not distributed	7	// Public License v. 2.0. If a copy of the MPL was not distributed
8	// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.	8	// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9		9
10	#ifndef EIGEN_SELFCWISEBINARYOP_H	10	#ifndef EIGEN_SELFCWISEBINARYOP_H
11	#define EIGEN_SELFCWISEBINARYOP_H	11	#define EIGEN_SELFCWISEBINARYOP_H
12		12
13	namespace Eigen {	13	namespace Eigen {
14		14
		15	// TODO generalize the scalar type of 'other'
		16
15	template<typename Derived>	17	template<typename Derived>
16	EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator*=(const Scalar& other)	18	EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator*=(const Scalar& other)
17	{	19	{
18	typedef typename Derived::PlainObject PlainObject;	20	typedef typename Derived::PlainObject PlainObject;
19	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::mul_assign_op<Scalar>());	21	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::mul_assign_op<Scalar,Scalar>());
20	return derived();	22	return derived();
21	}	23	}
22		24
23	template<typename Derived>	25	template<typename Derived>
24	EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator+=(const Scalar& other)	26	EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator+=(const Scalar& other)
25	{	27	{
26	typedef typename Derived::PlainObject PlainObject;	28	typedef typename Derived::PlainObject PlainObject;
27	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::add_assign_op<Scalar>());	29	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::add_assign_op<Scalar,Scalar>());
28	return derived();	30	return derived();
29	}	31	}
30		32
31	template<typename Derived>	33	template<typename Derived>
32	EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator-=(const Scalar& other)	34	EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator-=(const Scalar& other)
33	{	35	{
34	typedef typename Derived::PlainObject PlainObject;	36	typedef typename Derived::PlainObject PlainObject;
35	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::sub_assign_op<Scalar>());	37	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::sub_assign_op<Scalar,Scalar>());
36	return derived();	38	return derived();
37	}	39	}
38		40
39	template<typename Derived>	41	template<typename Derived>
40	EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator/=(const Scalar& other)	42	EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator/=(const Scalar& other)
41	{	43	{
42	typedef typename Derived::PlainObject PlainObject;	44	typedef typename Derived::PlainObject PlainObject;
43	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::div_assign_op<Scalar>());	45	internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::div_assign_op<Scalar,Scalar>());
44	return derived();	46	return derived();
45	}	47	}
46		48
47	} // end namespace Eigen	49	} // end namespace Eigen
48		50
49	#endif // EIGEN_SELFCWISEBINARYOP_H	51	#endif // EIGEN_SELFCWISEBINARYOP_H

Lines 129-171 struct evaluator<Solve<Decomposition,Rhs Link Here

(-)a/Eigen/src/Core/Solve.h (-6 / +7 lines)
129		129
130	protected:	130	protected:
131	PlainObject m_result;	131	PlainObject m_result;
132	};	132	};
133		133
134	// Specialization for "dst = dec.solve(rhs)"	134	// Specialization for "dst = dec.solve(rhs)"
135	// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere	135	// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
136	template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>	136	template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
137	struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar>, Dense2Dense, Scalar>	137	struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
138	{	138	{
139	typedef Solve<DecType,RhsType> SrcXprType;	139	typedef Solve<DecType,RhsType> SrcXprType;
140	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	140	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
141	{	141	{
142	// FIXME shall we resize dst here?	142	// FIXME shall we resize dst here?
143	src.dec()._solve_impl(src.rhs(), dst);	143	src.dec()._solve_impl(src.rhs(), dst);
144	}	144	}
145	};	145	};
146		146
147	// Specialization for "dst = dec.transpose().solve(rhs)"	147	// Specialization for "dst = dec.transpose().solve(rhs)"
148	template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>	148	template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
149	struct Assignment<DstXprType, Solve<Transpose<const DecType>,RhsType>, internal::assign_op<Scalar>, Dense2Dense, Scalar>	149	struct Assignment<DstXprType, Solve<Transpose<const DecType>,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
150	{	150	{
151	typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;	151	typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
152	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	152	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
153	{	153	{
154	src.dec().nestedExpression().template _solve_impl_transposed<false>(src.rhs(), dst);	154	src.dec().nestedExpression().template _solve_impl_transposed<false>(src.rhs(), dst);
155	}	155	}
156	};	156	};
157		157
158	// Specialization for "dst = dec.adjoint().solve(rhs)"	158	// Specialization for "dst = dec.adjoint().solve(rhs)"
159	template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>	159	template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
160	struct Assignment<DstXprType, Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType>, internal::assign_op<Scalar>, Dense2Dense, Scalar>	160	struct Assignment<DstXprType, Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType>,
		161	internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
161	{	162	{
162	typedef Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType> SrcXprType;	163	typedef Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType> SrcXprType;
163	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	164	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
164	{	165	{
165	src.dec().nestedExpression().nestedExpression().template _solve_impl_transposed<true>(src.rhs(), dst);	166	src.dec().nestedExpression().nestedExpression().template _solve_impl_transposed<true>(src.rhs(), dst);
166	}	167	}
167	};	168	};
168		169
169	} // end namepsace internal	170	} // end namepsace internal
170		171
171	} // end namespace Eigen	172	} // end namespace Eigen

Lines 362-385 template<typename _MatrixType, unsigned Link Here

(-)a/Eigen/src/Core/TriangularMatrix.h (-10 / +10 lines)
362	* \sa DenseCoeffsBase::innerStride() */	362	* \sa DenseCoeffsBase::innerStride() */
363	EIGEN_DEVICE_FUNC	363	EIGEN_DEVICE_FUNC
364	inline Index innerStride() const { return derived().nestedExpression().innerStride(); }	364	inline Index innerStride() const { return derived().nestedExpression().innerStride(); }
365		365
366	/** \sa MatrixBase::operator+=() */	366	/** \sa MatrixBase::operator+=() */
367	template<typename Other>	367	template<typename Other>
368	EIGEN_DEVICE_FUNC	368	EIGEN_DEVICE_FUNC
369	TriangularViewType& operator+=(const DenseBase<Other>& other) {	369	TriangularViewType& operator+=(const DenseBase<Other>& other) {
370	internal::call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar>());	370	internal::call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename Other::Scalar>());
371	return derived();	371	return derived();
372	}	372	}
373	/** \sa MatrixBase::operator-=() */	373	/** \sa MatrixBase::operator-=() */
374	template<typename Other>	374	template<typename Other>
375	EIGEN_DEVICE_FUNC	375	EIGEN_DEVICE_FUNC
376	TriangularViewType& operator-=(const DenseBase<Other>& other) {	376	TriangularViewType& operator-=(const DenseBase<Other>& other) {
377	internal::call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar>());	377	internal::call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename Other::Scalar>());
378	return derived();	378	return derived();
379	}	379	}
380		380
381	/** \sa MatrixBase::operator=() /	381	/** \sa MatrixBase::operator=() /
382	EIGEN_DEVICE_FUNC	382	EIGEN_DEVICE_FUNC
383	TriangularViewType& operator=(const typename internal::traits<MatrixType>::Scalar& other) { return this = derived().nestedExpression() * other; }	383	TriangularViewType& operator=(const typename internal::traits<MatrixType>::Scalar& other) { return this = derived().nestedExpression() * other; }
384	/** \sa DenseBase::operator/=() */	384	/** \sa DenseBase::operator/=() */
385	EIGEN_DEVICE_FUNC	385	EIGEN_DEVICE_FUNC
Lines 547-563 template<typename _MatrixType, unsigned Link Here
547	***************************************************************************/	547	***************************************************************************/
548		548
549	// FIXME should we keep that possibility	549	// FIXME should we keep that possibility
550	template<typename MatrixType, unsigned int Mode>	550	template<typename MatrixType, unsigned int Mode>
551	template<typename OtherDerived>	551	template<typename OtherDerived>
552	inline TriangularView<MatrixType, Mode>&	552	inline TriangularView<MatrixType, Mode>&
553	TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const MatrixBase<OtherDerived>& other)	553	TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const MatrixBase<OtherDerived>& other)
554	{	554	{
555	internal::call_assignment_no_alias(derived(), other.derived(), internal::assign_op<Scalar>());	555	internal::call_assignment_no_alias(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
556	return derived();	556	return derived();
557	}	557	}
558		558
559	// FIXME should we keep that possibility	559	// FIXME should we keep that possibility
560	template<typename MatrixType, unsigned int Mode>	560	template<typename MatrixType, unsigned int Mode>
561	template<typename OtherDerived>	561	template<typename OtherDerived>
562	void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)	562	void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)
563	{	563	{
Lines 799-815 void call_triangular_assignment_loop(con Link Here
799		799
800	triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);	800	triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
801	}	801	}
802		802
803	template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType>	803	template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType>
804	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	804	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
805	void call_triangular_assignment_loop(const DstXprType& dst, const SrcXprType& src)	805	void call_triangular_assignment_loop(const DstXprType& dst, const SrcXprType& src)
806	{	806	{
807	call_triangular_assignment_loop<Mode,SetOpposite>(dst, src, internal::assign_op<typename DstXprType::Scalar>());	807	call_triangular_assignment_loop<Mode,SetOpposite>(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
808	}	808	}
809		809
810	template<> struct AssignmentKind<TriangularShape,TriangularShape> { typedef Triangular2Triangular Kind; };	810	template<> struct AssignmentKind<TriangularShape,TriangularShape> { typedef Triangular2Triangular Kind; };
811	template<> struct AssignmentKind<DenseShape,TriangularShape> { typedef Triangular2Dense Kind; };	811	template<> struct AssignmentKind<DenseShape,TriangularShape> { typedef Triangular2Dense Kind; };
812	template<> struct AssignmentKind<TriangularShape,DenseShape> { typedef Dense2Triangular Kind; };	812	template<> struct AssignmentKind<TriangularShape,DenseShape> { typedef Dense2Triangular Kind; };
813		813
814		814
815	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>	815	template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
Lines 928-970 void TriangularBase<Derived>::evalToLazy Link Here
928	other.derived().resize(this->rows(), this->cols());	928	other.derived().resize(this->rows(), this->cols());
929	internal::call_triangular_assignment_loop<Derived::Mode,(Derived::Mode&SelfAdjoint)==0 /* SetOpposite */>(other.derived(), derived().nestedExpression());	929	internal::call_triangular_assignment_loop<Derived::Mode,(Derived::Mode&SelfAdjoint)==0 /* SetOpposite */>(other.derived(), derived().nestedExpression());
930	}	930	}
931		931
932	namespace internal {	932	namespace internal {
933		933
934	// Triangular = Product	934	// Triangular = Product
935	template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>	935	template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
936	struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<Scalar>, Dense2Triangular, Scalar>	936	struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular, Scalar>
937	{	937	{
938	typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;	938	typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
939	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	939	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename SrcXprType::Scalar> &)
940	{	940	{
941	dst.setZero();	941	dst.setZero();
942	dst._assignProduct(src, 1);	942	dst._assignProduct(src, 1);
943	}	943	}
944	};	944	};
945		945
946	// Triangular += Product	946	// Triangular += Product
947	template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>	947	template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
948	struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<Scalar>, Dense2Triangular, Scalar>	948	struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular, Scalar>
949	{	949	{
950	typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;	950	typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
951	static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar> &)	951	static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,typename SrcXprType::Scalar> &)
952	{	952	{
953	dst._assignProduct(src, 1);	953	dst._assignProduct(src, 1);
954	}	954	}
955	};	955	};
956		956
957	// Triangular -= Product	957	// Triangular -= Product
958	template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>	958	template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
959	struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<Scalar>, Dense2Triangular, Scalar>	959	struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular, Scalar>
960	{	960	{
961	typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;	961	typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
962	static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar> &)	962	static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,typename SrcXprType::Scalar> &)
963	{	963	{
964	dst._assignProduct(src, -1);	964	dst._assignProduct(src, -1);
965	}	965	}
966	};	966	};
967		967
968	} // end namespace internal	968	} // end namespace internal
969		969
970	} // end namespace Eigen	970	} // end namespace Eigen

Lines 535-564 template<typename ExpressionType, int Di Link Here

(-)a/Eigen/src/Core/VectorwiseOp.h (-2 / +2 lines)
535	EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)	535	EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
536	EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)	536	EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
537	m_matrix /= extendedTo(other.derived());	537	m_matrix /= extendedTo(other.derived());
538	return const_cast<ExpressionType&>(m_matrix);	538	return const_cast<ExpressionType&>(m_matrix);
539	}	539	}
540		540
541	/** Returns the expression of the sum of the vector \a other to each subvector of \c this /	541	/** Returns the expression of the sum of the vector \a other to each subvector of \c this /
542	template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC	542	template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
543	CwiseBinaryOp<internal::scalar_sum_op<Scalar>,	543	CwiseBinaryOp<internal::scalar_sum_op<Scalar,typename OtherDerived::Scalar>,
544	const ExpressionTypeNestedCleaned,	544	const ExpressionTypeNestedCleaned,
545	const typename ExtendedType<OtherDerived>::Type>	545	const typename ExtendedType<OtherDerived>::Type>
546	operator+(const DenseBase<OtherDerived>& other) const	546	operator+(const DenseBase<OtherDerived>& other) const
547	{	547	{
548	EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)	548	EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
549	EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)	549	EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
550	return m_matrix + extendedTo(other.derived());	550	return m_matrix + extendedTo(other.derived());
551	}	551	}
552		552
553	/** Returns the expression of the difference between each subvector of \c this and the vector \a other /	553	/** Returns the expression of the difference between each subvector of \c this and the vector \a other /
554	template<typename OtherDerived>	554	template<typename OtherDerived>
555	EIGEN_DEVICE_FUNC	555	EIGEN_DEVICE_FUNC
556	CwiseBinaryOp<internal::scalar_difference_op<Scalar>,	556	CwiseBinaryOp<internal::scalar_difference_op<Scalar,typename OtherDerived::Scalar>,
557	const ExpressionTypeNestedCleaned,	557	const ExpressionTypeNestedCleaned,
558	const typename ExtendedType<OtherDerived>::Type>	558	const typename ExtendedType<OtherDerived>::Type>
559	operator-(const DenseBase<OtherDerived>& other) const	559	operator-(const DenseBase<OtherDerived>& other) const
560	{	560	{
561	EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)	561	EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
562	EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)	562	EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
563	return m_matrix - extendedTo(other.derived());	563	return m_matrix - extendedTo(other.derived());
564	}	564	}

Lines 13-84 Link Here

(-)a/Eigen/src/Core/functors/AssignmentFunctors.h (-26 / +24 lines)
13	namespace Eigen {	13	namespace Eigen {
14		14
15	namespace internal {	15	namespace internal {
16		16
17	/** \internal	17	/** \internal
18	* \brief Template functor for scalar/packet assignment	18	* \brief Template functor for scalar/packet assignment
19	*	19	*
20	*/	20	*/
21	template<typename Scalar> struct assign_op {	21	template<typename DstScalar,typename SrcScalar> struct assign_op {
22		22
23	EIGEN_EMPTY_STRUCT_CTOR(assign_op)	23	EIGEN_EMPTY_STRUCT_CTOR(assign_op)
24	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Scalar& a, const Scalar& b) const { a = b; }	24	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a = b; }
25		25
26	template<int Alignment, typename Packet>	26	template<int Alignment, typename Packet>
27	EIGEN_STRONG_INLINE void assignPacket(Scalar* a, const Packet& b) const	27	EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
28	{ internal::pstoret<Scalar,Packet,Alignment>(a,b); }	28	{ internal::pstoret<DstScalar,Packet,Alignment>(a,b); }
29	};	29	};
30	template<typename Scalar>	30	template<typename DstScalar,typename SrcScalar>
31	struct functor_traits<assign_op<Scalar> > {	31	struct functor_traits<assign_op<DstScalar,SrcScalar> > {
32	enum {	32	enum {
33	Cost = NumTraits<Scalar>::ReadCost,	33	Cost = NumTraits<DstScalar>::ReadCost,
34	PacketAccess = packet_traits<Scalar>::Vectorizable	34	PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::Vectorizable && packet_traits<SrcScalar>::Vectorizable
35	};	35	};
36	};	36	};
37		37
38	/** \internal	38	/** \internal
39	* \brief Template functor for scalar/packet assignment with addition	39	* \brief Template functor for scalar/packet assignment with addition
40	*	40	*
41	*/	41	*/
42	template<typename Scalar> struct add_assign_op {	42	template<typename DstScalar,typename SrcScalar> struct add_assign_op {
43		43
44	EIGEN_EMPTY_STRUCT_CTOR(add_assign_op)	44	EIGEN_EMPTY_STRUCT_CTOR(add_assign_op)
45	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Scalar& a, const Scalar& b) const { a += b; }	45	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a += b; }
46		46
47	template<int Alignment, typename Packet>	47	template<int Alignment, typename Packet>
48	EIGEN_STRONG_INLINE void assignPacket(Scalar* a, const Packet& b) const	48	EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
49	{ internal::pstoret<Scalar,Packet,Alignment>(a,internal::padd(internal::ploadt<Packet,Alignment>(a),b)); }	49	{ internal::pstoret<DstScalar,Packet,Alignment>(a,internal::padd(internal::ploadt<Packet,Alignment>(a),b)); }
50	};	50	};
51	template<typename Scalar>	51	template<typename DstScalar,typename SrcScalar>
52	struct functor_traits<add_assign_op<Scalar> > {	52	struct functor_traits<add_assign_op<DstScalar,SrcScalar> > {
53	enum {	53	enum {
54	Cost = NumTraits<Scalar>::ReadCost + NumTraits<Scalar>::AddCost,	54	Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
55	PacketAccess = packet_traits<Scalar>::HasAdd	55	PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasAdd
56	};	56	};
57	};	57	};
58		58
59	/** \internal	59	/** \internal
60	* \brief Template functor for scalar/packet assignment with subtraction	60	* \brief Template functor for scalar/packet assignment with subtraction
61	*	61	*
62	*/	62	*/
63	template<typename Scalar> struct sub_assign_op {	63	template<typename DstScalar,typename SrcScalar> struct sub_assign_op {
64		64
65	EIGEN_EMPTY_STRUCT_CTOR(sub_assign_op)	65	EIGEN_EMPTY_STRUCT_CTOR(sub_assign_op)
66	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Scalar& a, const Scalar& b) const { a -= b; }	66	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
67		67
68	template<int Alignment, typename Packet>	68	template<int Alignment, typename Packet>
69	EIGEN_STRONG_INLINE void assignPacket(Scalar* a, const Packet& b) const	69	EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
70	{ internal::pstoret<Scalar,Packet,Alignment>(a,internal::psub(internal::ploadt<Packet,Alignment>(a),b)); }	70	{ internal::pstoret<DstScalar,Packet,Alignment>(a,internal::psub(internal::ploadt<Packet,Alignment>(a),b)); }
71	};	71	};
72	template<typename Scalar>	72	template<typename DstScalar,typename SrcScalar>
73	struct functor_traits<sub_assign_op<Scalar> > {	73	struct functor_traits<sub_assign_op<DstScalar,SrcScalar> > {
74	enum {	74	enum {
75	Cost = NumTraits<Scalar>::ReadCost + NumTraits<Scalar>::AddCost,	75	Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
76	PacketAccess = packet_traits<Scalar>::HasSub	76	PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasSub
77	};	77	};
78	};	78	};
79		79
80	/** \internal	80	/** \internal
81	* \brief Template functor for scalar/packet assignment with multiplication	81	* \brief Template functor for scalar/packet assignment with multiplication
82	*	82	*
83	*/	83	*/
84	template<typename DstScalar, typename SrcScalar=DstScalar>	84	template<typename DstScalar, typename SrcScalar=DstScalar>
Lines 93-109 struct mul_assign_op { Link Here
93	};	93	};
94	template<typename DstScalar, typename SrcScalar>	94	template<typename DstScalar, typename SrcScalar>
95	struct functor_traits<mul_assign_op<DstScalar,SrcScalar> > {	95	struct functor_traits<mul_assign_op<DstScalar,SrcScalar> > {
96	enum {	96	enum {
97	Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,	97	Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
98	PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasMul	98	PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasMul
99	};	99	};
100	};	100	};
101	template<typename DstScalar,typename SrcScalar> struct functor_is_product_like<mul_assign_op<DstScalar,SrcScalar> > { enum { ret = 1 }; };
102		101
103	/** \internal	102	/** \internal
104	* \brief Template functor for scalar/packet assignment with diviving	103	* \brief Template functor for scalar/packet assignment with diviving
105	*	104	*
106	*/	105	*/
107	template<typename DstScalar, typename SrcScalar=DstScalar> struct div_assign_op {	106	template<typename DstScalar, typename SrcScalar=DstScalar> struct div_assign_op {
108		107
109	EIGEN_EMPTY_STRUCT_CTOR(div_assign_op)	108	EIGEN_EMPTY_STRUCT_CTOR(div_assign_op)
Lines 115-131 template<typename DstScalar, typename Sr Link Here
115	};	114	};
116	template<typename DstScalar, typename SrcScalar>	115	template<typename DstScalar, typename SrcScalar>
117	struct functor_traits<div_assign_op<DstScalar,SrcScalar> > {	116	struct functor_traits<div_assign_op<DstScalar,SrcScalar> > {
118	enum {	117	enum {
119	Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,	118	Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
120	PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasDiv	119	PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasDiv
121	};	120	};
122	};	121	};
123	template<typename DstScalar,typename SrcScalar> struct functor_is_product_like<div_assign_op<DstScalar,SrcScalar> > { enum { ret = 1 }; };
124		122
125	/** \internal	123	/** \internal
126	* \brief Template functor for scalar/packet assignment with swapping	124	* \brief Template functor for scalar/packet assignment with swapping
127	*	125	*
128	* It works as follow. For a non-vectorized evaluation loop, we have:	126	* It works as follow. For a non-vectorized evaluation loop, we have:
129	* for(i) func(A.coeffRef(i), B.coeff(i));	127	* for(i) func(A.coeffRef(i), B.coeff(i));
130	* where B is a SwapWrapper expression. The trick is to make SwapWrapper::coeff behaves like a non-const coeffRef.	128	* where B is a SwapWrapper expression. The trick is to make SwapWrapper::coeff behaves like a non-const coeffRef.
131	* Actually, SwapWrapper might not even be needed since even if B is a plain expression, since it has to be writable	129	* Actually, SwapWrapper might not even be needed since even if B is a plain expression, since it has to be writable

Lines 16-101 namespace internal { Link Here

(-)a/Eigen/src/Core/functors/BinaryFunctors.h (-39 / +25 lines)
16		16
17	//---------- associative binary functors ----------	17	//---------- associative binary functors ----------
18		18
19	/** \internal	19	/** \internal
20	* \brief Template functor to compute the sum of two scalars	20	* \brief Template functor to compute the sum of two scalars
21	*	21	*
22	* \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, DenseBase::sum()	22	* \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, DenseBase::sum()
23	*/	23	*/
24	template<typename Scalar> struct scalar_sum_op {	24	template<typename LhsScalar,typename RhsScalar> struct scalar_sum_op {
25	// typedef Scalar result_type;	25	typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_sum_op>::ReturnType result_type;
26	EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)	26	EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)
27	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; }	27	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a + b; }
28	template<typename Packet>	28	template<typename Packet>
29	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const	29	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
30	{ return internal::padd(a,b); }	30	{ return internal::padd(a,b); }
31	template<typename Packet>	31	template<typename Packet>
32	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const	32	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
33	{ return internal::predux(a); }	33	{ return internal::predux(a); }
34	};	34	};
35	template<typename Scalar>	35	template<typename LhsScalar,typename RhsScalar>
36	struct functor_traits<scalar_sum_op<Scalar> > {	36	struct functor_traits<scalar_sum_op<LhsScalar,RhsScalar> > {
37	enum {	37	enum {
38	Cost = NumTraits<Scalar>::AddCost,	38	Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2, // rough estimate!
39	PacketAccess = packet_traits<Scalar>::HasAdd	39	PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasAdd && packet_traits<RhsScalar>::HasAdd
		40	// TODO vectorize mixed sum
40	};	41	};
41	};	42	};
42		43
43	/** \internal	44	/** \internal
44	* \brief Template specialization to deprecate the summation of boolean expressions.	45	* \brief Template specialization to deprecate the summation of boolean expressions.
45	* This is required to solve Bug 426.	46	* This is required to solve Bug 426.
46	* \sa DenseBase::count(), DenseBase::any(), ArrayBase::cast(), MatrixBase::cast()	47	* \sa DenseBase::count(), DenseBase::any(), ArrayBase::cast(), MatrixBase::cast()
47	*/	48	*/
48	template<> struct scalar_sum_op<bool> : scalar_sum_op<int> {	49	template<> struct scalar_sum_op<bool,bool> : scalar_sum_op<int,int> {
49	EIGEN_DEPRECATED	50	EIGEN_DEPRECATED
50	scalar_sum_op() {}	51	scalar_sum_op() {}
51	};	52	};
52		53
53		54
54	/** \internal	55	/** \internal
55	* \brief Template functor to compute the product of two scalars	56	* \brief Template functor to compute the product of two scalars
56	*	57	*
57	* \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux()	58	* \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux()
58	*/	59	*/
59	template<typename LhsScalar,typename RhsScalar> struct scalar_product_op {	60	template<typename LhsScalar,typename RhsScalar> struct scalar_product_op {
60	enum {	61	typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_product_op>::ReturnType result_type;
61	// TODO vectorize mixed product
62	Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
63	};
64	typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
65	EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)	62	EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)
66	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; }	63	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; }
67	template<typename Packet>	64	template<typename Packet>
68	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const	65	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
69	{ return internal::pmul(a,b); }	66	{ return internal::pmul(a,b); }
70	template<typename Packet>	67	template<typename Packet>
71	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const	68	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
72	{ return internal::predux_mul(a); }	69	{ return internal::predux_mul(a); }
73	};	70	};
74	template<typename LhsScalar,typename RhsScalar>	71	template<typename LhsScalar,typename RhsScalar>
75	struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > {	72	struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > {
76	enum {	73	enum {
77	Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2, // rough estimate!	74	Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2, // rough estimate!
78	PacketAccess = scalar_product_op<LhsScalar,RhsScalar>::Vectorizable	75	PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
		76	// TODO vectorize mixed product
79	};	77	};
80	};	78	};
81		79
82	/** \internal	80	/** \internal
83	* \brief Template functor to compute the conjugate product of two scalars	81	* \brief Template functor to compute the conjugate product of two scalars
84	*	82	*
85	* This is a short cut for conj(x) * y which is needed for optimization purpose; in Eigen2 support mode, this becomes x * conj(y)	83	* This is a short cut for conj(x) * y which is needed for optimization purpose; in Eigen2 support mode, this becomes x * conj(y)
86	*/	84	*/
87	template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op {	85	template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op {
88		86
89	enum {	87	enum {
90	Conj = NumTraits<LhsScalar>::IsComplex	88	Conj = NumTraits<LhsScalar>::IsComplex
91	};	89	};
92		90
93	typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;	91	typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_product_op>::ReturnType result_type;
94		92
95	EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op)	93	EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op)
96	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const	94	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const
97	{ return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); }	95	{ return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); }
98		96
99	template<typename Packet>	97	template<typename Packet>
100	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const	98	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
101	{ return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); }	99	{ return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); }
Lines 264-316 struct functor_traits<scalar_binary_pow_ Link Here
264		262
265	//---------- non associative binary functors ----------	263	//---------- non associative binary functors ----------
266		264
267	/** \internal	265	/** \internal
268	* \brief Template functor to compute the difference of two scalars	266	* \brief Template functor to compute the difference of two scalars
269	*	267	*
270	* \sa class CwiseBinaryOp, MatrixBase::operator-	268	* \sa class CwiseBinaryOp, MatrixBase::operator-
271	*/	269	*/
272	template<typename Scalar> struct scalar_difference_op {	270	template<typename LhsScalar,typename RhsScalar> struct scalar_difference_op {
		271	typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_difference_op>::ReturnType result_type;
273	EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)	272	EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
274	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; }	273	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a - b; }
275	template<typename Packet>	274	template<typename Packet>
276	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const	275	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
277	{ return internal::psub(a,b); }	276	{ return internal::psub(a,b); }
278	};	277	};
279	template<typename Scalar>	278	template<typename LhsScalar,typename RhsScalar>
280	struct functor_traits<scalar_difference_op<Scalar> > {	279	struct functor_traits<scalar_difference_op<LhsScalar,RhsScalar> > {
281	enum {	280	enum {
282	Cost = NumTraits<Scalar>::AddCost,	281	Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
283	PacketAccess = packet_traits<Scalar>::HasSub	282	PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasSub && packet_traits<RhsScalar>::HasSub
284	};	283	};
285	};	284	};
286		285
287	/** \internal	286	/** \internal
288	* \brief Template functor to compute the quotient of two scalars	287	* \brief Template functor to compute the quotient of two scalars
289	*	288	*
290	* \sa class CwiseBinaryOp, Cwise::operator/()	289	* \sa class CwiseBinaryOp, Cwise::operator/()
291	*/	290	*/
292	template<typename LhsScalar,typename RhsScalar> struct scalar_quotient_op {	291	template<typename LhsScalar,typename RhsScalar> struct scalar_quotient_op {
293	enum {	292	typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotient_op>::ReturnType result_type;
294	// TODO vectorize mixed product
295	Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv
296	};
297	typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
298	EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)	293	EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
299	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }	294	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }
300	template<typename Packet>	295	template<typename Packet>
301	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const	296	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
302	{ return internal::pdiv(a,b); }	297	{ return internal::pdiv(a,b); }
303	};	298	};
304	template<typename LhsScalar,typename RhsScalar>	299	template<typename LhsScalar,typename RhsScalar>
305	struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {	300	struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
306	typedef typename scalar_quotient_op<LhsScalar,RhsScalar>::result_type result_type;	301	typedef typename scalar_quotient_op<LhsScalar,RhsScalar>::result_type result_type;
307	enum {	302	enum {
308	PacketAccess = scalar_quotient_op<LhsScalar,RhsScalar>::Vectorizable,	303	PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv,
309	Cost = NumTraits<result_type>::template Div<PacketAccess>::Cost	304	Cost = NumTraits<result_type>::template Div<PacketAccess>::Cost
310	};	305	};
311	};	306	};
312		307
313		308
314		309
315	/** \internal	310	/** \internal
316	* \brief Template functor to compute the and of two booleans	311	* \brief Template functor to compute the and of two booleans
Lines 441-457 struct scalar_multiple_op { Link Here
441	typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;	436	typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
442	};	437	};
443	template<typename Scalar>	438	template<typename Scalar>
444	struct functor_traits<scalar_multiple_op<Scalar> >	439	struct functor_traits<scalar_multiple_op<Scalar> >
445	{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };	440	{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
446		441
447	template<typename Scalar1, typename Scalar2>	442	template<typename Scalar1, typename Scalar2>
448	struct scalar_multiple2_op {	443	struct scalar_multiple2_op {
449	typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType result_type;	444	typedef typename ScalarBinaryOpTraits<Scalar1,Scalar2>::ReturnType result_type;
450	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { }	445	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { }
451	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { }	446	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { }
452	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; }	447	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; }
453	typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;	448	typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
454	};	449	};
455	template<typename Scalar1,typename Scalar2>	450	template<typename Scalar1,typename Scalar2>
456	struct functor_traits<scalar_multiple2_op<Scalar1,Scalar2> >	451	struct functor_traits<scalar_multiple2_op<Scalar1,Scalar2> >
457	{ enum { Cost = NumTraits<Scalar1>::MulCost, PacketAccess = false }; };	452	{ enum { Cost = NumTraits<Scalar1>::MulCost, PacketAccess = false }; };
Lines 476-510 struct scalar_quotient1_op { Link Here
476	typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;	471	typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
477	};	472	};
478	template<typename Scalar>	473	template<typename Scalar>
479	struct functor_traits<scalar_quotient1_op<Scalar> >	474	struct functor_traits<scalar_quotient1_op<Scalar> >
480	{ enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };	475	{ enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };
481		476
482	template<typename Scalar1, typename Scalar2>	477	template<typename Scalar1, typename Scalar2>
483	struct scalar_quotient2_op {	478	struct scalar_quotient2_op {
484	typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType result_type;	479	typedef typename ScalarBinaryOpTraits<Scalar1,Scalar2>::ReturnType result_type;
485	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_quotient2_op(const scalar_quotient2_op& other) : m_other(other.m_other) { }	480	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_quotient2_op(const scalar_quotient2_op& other) : m_other(other.m_other) { }
486	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_quotient2_op(const Scalar2& other) : m_other(other) { }	481	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_quotient2_op(const Scalar2& other) : m_other(other) { }
487	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a / m_other; }	482	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a / m_other; }
488	typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;	483	typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
489	};	484	};
490	template<typename Scalar1,typename Scalar2>	485	template<typename Scalar1,typename Scalar2>
491	struct functor_traits<scalar_quotient2_op<Scalar1,Scalar2> >	486	struct functor_traits<scalar_quotient2_op<Scalar1,Scalar2> >
492	{ enum { Cost = 2 * NumTraits<Scalar1>::MulCost, PacketAccess = false }; };	487	{ enum { Cost = 2 * NumTraits<Scalar1>::MulCost, PacketAccess = false }; };
493		488
494	// In Eigen, any binary op (Product, CwiseBinaryOp) require the Lhs and Rhs to have the same scalar type, except for multiplication
495	// where the mixing of different types is handled by scalar_product_traits
496	// In particular, real * complex<real> is allowed.
497	// FIXME move this to functor_traits adding a functor_default
498	template<typename Functor> struct functor_is_product_like { enum { ret = 0 }; };
499	template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
500	template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_conj_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
501	template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_quotient_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
502
503		489
504	/** \internal	490	/** \internal
505	* \brief Template functor to add a scalar to a fixed other one	491	* \brief Template functor to add a scalar to a fixed other one
506	* \sa class CwiseUnaryOp, Array::operator+	492	* \sa class CwiseUnaryOp, Array::operator+
507	*/	493	*/
508	/* If you wonder why doing the pset1() in packetOp() is an optimization check scalar_multiple_op */	494	/* If you wonder why doing the pset1() in packetOp() is an optimization check scalar_multiple_op */
509	template<typename Scalar>	495	template<typename Scalar>
510	struct scalar_add_op {	496	struct scalar_add_op {

Lines 358-374 inline void computeProductBlockingSizes( Link Here

(-)a/Eigen/src/Core/products/GeneralBlockPanelKernel.h (-2 / +2 lines)
358	* real*cplx : load lhs as (a0,a0,a1,a1), and mul as usual	358	* real*cplx : load lhs as (a0,a0,a1,a1), and mul as usual
359	*/	359	*/
360	template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs, bool _ConjRhs>	360	template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs, bool _ConjRhs>
361	class gebp_traits	361	class gebp_traits
362	{	362	{
363	public:	363	public:
364	typedef _LhsScalar LhsScalar;	364	typedef _LhsScalar LhsScalar;
365	typedef _RhsScalar RhsScalar;	365	typedef _RhsScalar RhsScalar;
366	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	366	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
367		367
368	enum {	368	enum {
369	ConjLhs = _ConjLhs,	369	ConjLhs = _ConjLhs,
370	ConjRhs = _ConjRhs,	370	ConjRhs = _ConjRhs,
371	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,	371	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,
372	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,	372	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
373	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,	373	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
374	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,	374	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,
Lines 473-489 protected: Link Here
473	};	473	};
474		474
475	template<typename RealScalar, bool _ConjLhs>	475	template<typename RealScalar, bool _ConjLhs>
476	class gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false>	476	class gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false>
477	{	477	{
478	public:	478	public:
479	typedef std::complex<RealScalar> LhsScalar;	479	typedef std::complex<RealScalar> LhsScalar;
480	typedef RealScalar RhsScalar;	480	typedef RealScalar RhsScalar;
481	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	481	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
482		482
483	enum {	483	enum {
484	ConjLhs = _ConjLhs,	484	ConjLhs = _ConjLhs,
485	ConjRhs = false,	485	ConjRhs = false,
486	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,	486	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,
487	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,	487	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
488	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,	488	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
489	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,	489	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,

Lines 20-36 template<typename _LhsScalar, typename _ Link Here

(-)a/Eigen/src/Core/products/GeneralMatrixMatrix.h (-2 / +2 lines)
20	template<	20	template<
21	typename Index,	21	typename Index,
22	typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,	22	typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
23	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>	23	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>
24	struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor>	24	struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor>
25	{	25	{
26	typedef gebp_traits<RhsScalar,LhsScalar> Traits;	26	typedef gebp_traits<RhsScalar,LhsScalar> Traits;
27		27
28	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	28	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
29	static EIGEN_STRONG_INLINE void run(	29	static EIGEN_STRONG_INLINE void run(
30	Index rows, Index cols, Index depth,	30	Index rows, Index cols, Index depth,
31	const LhsScalar* lhs, Index lhsStride,	31	const LhsScalar* lhs, Index lhsStride,
32	const RhsScalar* rhs, Index rhsStride,	32	const RhsScalar* rhs, Index rhsStride,
33	ResScalar* res, Index resStride,	33	ResScalar* res, Index resStride,
34	ResScalar alpha,	34	ResScalar alpha,
35	level3_blocking<RhsScalar,LhsScalar>& blocking,	35	level3_blocking<RhsScalar,LhsScalar>& blocking,
36	GemmParallelInfo<Index>* info = 0)	36	GemmParallelInfo<Index>* info = 0)
Lines 50-66 template< Link Here
50	typename Index,	50	typename Index,
51	typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,	51	typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
52	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>	52	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>
53	struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor>	53	struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor>
54	{	54	{
55		55
56	typedef gebp_traits<LhsScalar,RhsScalar> Traits;	56	typedef gebp_traits<LhsScalar,RhsScalar> Traits;
57		57
58	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	58	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
59	static void run(Index rows, Index cols, Index depth,	59	static void run(Index rows, Index cols, Index depth,
60	const LhsScalar* _lhs, Index lhsStride,	60	const LhsScalar* _lhs, Index lhsStride,
61	const RhsScalar* _rhs, Index rhsStride,	61	const RhsScalar* _rhs, Index rhsStride,
62	ResScalar* _res, Index resStride,	62	ResScalar* _res, Index resStride,
63	ResScalar alpha,	63	ResScalar alpha,
64	level3_blocking<LhsScalar,RhsScalar>& blocking,	64	level3_blocking<LhsScalar,RhsScalar>& blocking,
65	GemmParallelInfo<Index>* info = 0)	65	GemmParallelInfo<Index>* info = 0)
66	{	66	{

Lines 35-68 template <typename Index, Link Here

(-)a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h (-2 / +2 lines)
35	int ResStorageOrder, int UpLo, int Version = Specialized>	35	int ResStorageOrder, int UpLo, int Version = Specialized>
36	struct general_matrix_matrix_triangular_product;	36	struct general_matrix_matrix_triangular_product;
37		37
38	// as usual if the result is row major => we transpose the product	38	// as usual if the result is row major => we transpose the product
39	template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,	39	template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
40	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int UpLo, int Version>	40	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int UpLo, int Version>
41	struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,UpLo,Version>	41	struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,UpLo,Version>
42	{	42	{
43	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	43	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
44	static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* lhs, Index lhsStride,	44	static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* lhs, Index lhsStride,
45	const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resStride,	45	const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resStride,
46	const ResScalar& alpha, level3_blocking<RhsScalar,LhsScalar>& blocking)	46	const ResScalar& alpha, level3_blocking<RhsScalar,LhsScalar>& blocking)
47	{	47	{
48	general_matrix_matrix_triangular_product<Index,	48	general_matrix_matrix_triangular_product<Index,
49	RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,	49	RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
50	LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,	50	LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
51	ColMajor, UpLo==Lower?Upper:Lower>	51	ColMajor, UpLo==Lower?Upper:Lower>
52	::run(size,depth,rhs,rhsStride,lhs,lhsStride,res,resStride,alpha,blocking);	52	::run(size,depth,rhs,rhsStride,lhs,lhsStride,res,resStride,alpha,blocking);
53	}	53	}
54	};	54	};
55		55
56	template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,	56	template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
57	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int UpLo, int Version>	57	typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int UpLo, int Version>
58	struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,UpLo,Version>	58	struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,UpLo,Version>
59	{	59	{
60	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	60	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
61	static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* _lhs, Index lhsStride,	61	static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* _lhs, Index lhsStride,
62	const RhsScalar* _rhs, Index rhsStride, ResScalar* _res, Index resStride,	62	const RhsScalar* _rhs, Index rhsStride, ResScalar* _res, Index resStride,
63	const ResScalar& alpha, level3_blocking<LhsScalar,RhsScalar>& blocking)	63	const ResScalar& alpha, level3_blocking<LhsScalar,RhsScalar>& blocking)
64	{	64	{
65	typedef gebp_traits<LhsScalar,RhsScalar> Traits;	65	typedef gebp_traits<LhsScalar,RhsScalar> Traits;
66		66
67	typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;	67	typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
68	typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;	68	typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;

Lines 53-69 namespace internal { Link Here

(-)a/Eigen/src/Core/products/GeneralMatrixVector.h (-2 / +2 lines)
53	* One might also wonder why in the EvenAligned case we perform unaligned loads instead of using the aligned-loads plus re-alignment	53	* One might also wonder why in the EvenAligned case we perform unaligned loads instead of using the aligned-loads plus re-alignment
54	* strategy as in the FirstAligned case. The reason is that we observed that unaligned loads on a 8 byte boundary are not too slow	54	* strategy as in the FirstAligned case. The reason is that we observed that unaligned loads on a 8 byte boundary are not too slow
55	* compared to unaligned loads on a 4 byte boundary.	55	* compared to unaligned loads on a 4 byte boundary.
56	*	56	*
57	*/	57	*/
58	template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>	58	template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
59	struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>	59	struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
60	{	60	{
61	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	61	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
62		62
63	enum {	63	enum {
64	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable	64	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable
65	&& int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),	65	&& int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),
66	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,	66	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
67	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,	67	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
68	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1	68	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1
69	};	69	};
Lines 329-345 EIGEN_DONT_INLINE void general_matrix_ve Link Here
329	*	329	*
330	* Mixing type logic:	330	* Mixing type logic:
331	* - alpha is always a complex (or converted to a complex)	331	* - alpha is always a complex (or converted to a complex)
332	* - no vectorization	332	* - no vectorization
333	*/	333	*/
334	template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>	334	template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
335	struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>	335	struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
336	{	336	{
337	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	337	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
338		338
339	enum {	339	enum {
340	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable	340	Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable
341	&& int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),	341	&& int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),
342	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,	342	LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
343	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,	343	RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
344	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1	344	ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1
345	};	345	};

Lines 15-31 namespace Eigen { Link Here

(-)a/Eigen/src/Core/products/TriangularMatrixVector.h (-2 / +2 lines)
15	namespace internal {	15	namespace internal {
16		16
17	template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder, int Version=Specialized>	17	template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder, int Version=Specialized>
18	struct triangular_matrix_vector_product;	18	struct triangular_matrix_vector_product;
19		19
20	template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>	20	template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
21	struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>	21	struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
22	{	22	{
23	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	23	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
24	enum {	24	enum {
25	IsLower = ((Mode&Lower)==Lower),	25	IsLower = ((Mode&Lower)==Lower),
26	HasUnitDiag = (Mode & UnitDiag)==UnitDiag,	26	HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
27	HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag	27	HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
28	};	28	};
29	static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,	29	static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
30	const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha);	30	const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha);
31	};	31	};
Lines 86-102 EIGEN_DONT_INLINE void triangular_matrix Link Here
86	RhsMapper(&rhs.coeffRef(size), rhsIncr),	86	RhsMapper(&rhs.coeffRef(size), rhsIncr),
87	_res, resIncr, alpha);	87	_res, resIncr, alpha);
88	}	88	}
89	}	89	}
90		90
91	template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>	91	template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
92	struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>	92	struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
93	{	93	{
94	typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar;	94	typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
95	enum {	95	enum {
96	IsLower = ((Mode&Lower)==Lower),	96	IsLower = ((Mode&Lower)==Lower),
97	HasUnitDiag = (Mode & UnitDiag)==UnitDiag,	97	HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
98	HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag	98	HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
99	};	99	};
100	static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,	100	static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
101	const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha);	101	const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha);
102	};	102	};

Lines 125-140 template<typename MatrixType, unsigned i Link Here

(-)a/Eigen/src/Core/util/ForwardDeclarations.h (-2 / +3 lines)
125	template<typename MatrixType> class SparseView;	125	template<typename MatrixType> class SparseView;
126	template<typename ExpressionType> class WithFormat;	126	template<typename ExpressionType> class WithFormat;
127	template<typename MatrixType> struct CommaInitializer;	127	template<typename MatrixType> struct CommaInitializer;
128	template<typename Derived> class ReturnByValue;	128	template<typename Derived> class ReturnByValue;
129	template<typename ExpressionType> class ArrayWrapper;	129	template<typename ExpressionType> class ArrayWrapper;
130	template<typename ExpressionType> class MatrixWrapper;	130	template<typename ExpressionType> class MatrixWrapper;
131	template<typename Derived> class SolverBase;	131	template<typename Derived> class SolverBase;
132	template<typename XprType> class InnerIterator;	132	template<typename XprType> class InnerIterator;
		133	template<typename ScalarA, typename ScalarB, typename BinaryOp=void> struct ScalarBinaryOpTraits;
133		134
134	namespace internal {	135	namespace internal {
135	template<typename DecompositionType> struct kernel_retval_base;	136	template<typename DecompositionType> struct kernel_retval_base;
136	template<typename DecompositionType> struct kernel_retval;	137	template<typename DecompositionType> struct kernel_retval;
137	template<typename DecompositionType> struct image_retval_base;	138	template<typename DecompositionType> struct image_retval_base;
138	template<typename DecompositionType> struct image_retval;	139	template<typename DecompositionType> struct image_retval;
139	} // end namespace internal	140	} // end namespace internal
140		141
Lines 169-186 struct ProductReturnType; Link Here
169	template<typename Lhs, typename Rhs> struct LazyProductReturnType;	170	template<typename Lhs, typename Rhs> struct LazyProductReturnType;
170		171
171	namespace internal {	172	namespace internal {
172		173
173	// Provides scalar/packet-wise product and product with accumulation	174	// Provides scalar/packet-wise product and product with accumulation
174	// with optional conjugation of the arguments.	175	// with optional conjugation of the arguments.
175	template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;	176	template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
176		177
177	template<typename Scalar> struct scalar_sum_op;	178	template<typename LhsScalar,typename RhsScalar> struct scalar_sum_op;
178	template<typename Scalar> struct scalar_difference_op;	179	template<typename LhsScalar,typename RhsScalar> struct scalar_difference_op;
179	template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op;	180	template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op;
180	template<typename Scalar> struct scalar_opposite_op;	181	template<typename Scalar> struct scalar_opposite_op;
181	template<typename Scalar> struct scalar_conjugate_op;	182	template<typename Scalar> struct scalar_conjugate_op;
182	template<typename Scalar> struct scalar_real_op;	183	template<typename Scalar> struct scalar_real_op;
183	template<typename Scalar> struct scalar_imag_op;	184	template<typename Scalar> struct scalar_imag_op;
184	template<typename Scalar> struct scalar_abs_op;	185	template<typename Scalar> struct scalar_abs_op;
185	template<typename Scalar> struct scalar_abs2_op;	186	template<typename Scalar> struct scalar_abs2_op;
186	template<typename Scalar> struct scalar_sqrt_op;	187	template<typename Scalar> struct scalar_sqrt_op;

Lines 880-898 namespace Eigen { Link Here

(-)a/Eigen/src/Core/util/Macros.h (-2 / +2 lines)
880	template<typename OtherDerived> \	880	template<typename OtherDerived> \
881	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> \	881	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> \
882	(METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \	882	(METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
883	{ \	883	{ \
884	return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(), other.derived()); \	884	return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(), other.derived()); \
885	}	885	}
886		886
887	// the expression type of a cwise product	887	// the expression type of a cwise product
888	#define EIGEN_CWISE_PRODUCT_RETURN_TYPE(LHS,RHS) \	888	#define EIGEN_CWISE_BINARY_RETURN_TYPE(LHS,RHS,OPNAME) \
889	CwiseBinaryOp< \	889	CwiseBinaryOp< \
890	internal::scalar_product_op< \	890	EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)< \
891	typename internal::traits<LHS>::Scalar, \	891	typename internal::traits<LHS>::Scalar, \
892	typename internal::traits<RHS>::Scalar \	892	typename internal::traits<RHS>::Scalar \
893	>, \	893	>, \
894	const LHS, \	894	const LHS, \
895	const RHS \	895	const RHS \
896	>	896	>
897		897
898	#ifdef EIGEN_EXCEPTIONS	898	#ifdef EIGEN_EXCEPTIONS

Lines 370-412 struct meta_least_common_multiple<A,B,K, Link Here

(-)a/Eigen/src/Core/util/Meta.h (-27 / +37 lines)
370	};	370	};
371		371
372	/** \internal determines whether the product of two numeric types is allowed and what the return type is */	372	/** \internal determines whether the product of two numeric types is allowed and what the return type is */
373	template<typename T, typename U> struct scalar_product_traits	373	template<typename T, typename U> struct scalar_product_traits
374	{	374	{
375	enum { Defined = 0 };	375	enum { Defined = 0 };
376	};	376	};
377		377
378	template<typename T> struct scalar_product_traits<T,T>
379	{
380	enum {
381	// Cost = NumTraits<T>::MulCost,
382	Defined = 1
383	};
384	typedef T ReturnType;
385	};
386
387	template<typename T> struct scalar_product_traits<T,std::complex<T> >
388	{
389	enum {
390	// Cost = 2*NumTraits<T>::MulCost,
391	Defined = 1
392	};
393	typedef std::complex<T> ReturnType;
394	};
395
396	template<typename T> struct scalar_product_traits<std::complex<T>, T>
397	{
398	enum {
399	// Cost = 2*NumTraits<T>::MulCost,
400	Defined = 1
401	};
402	typedef std::complex<T> ReturnType;
403	};
404
405	// FIXME quick workaround around current limitation of result_of	378	// FIXME quick workaround around current limitation of result_of
406	// template<typename Scalar, typename ArgType0, typename ArgType1>	379	// template<typename Scalar, typename ArgType0, typename ArgType1>
407	// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> {	380	// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> {
408	// typedef typename scalar_product_traits<typename remove_all<ArgType0>::type, typename remove_all<ArgType1>::type>::ReturnType type;	381	// typedef typename scalar_product_traits<typename remove_all<ArgType0>::type, typename remove_all<ArgType1>::type>::ReturnType type;
409	// };	382	// };
410		383
411	} // end namespace internal	384	} // end namespace internal
412		385
Lines 429-439 using std::numeric_limits; Link Here
429	template<typename T>	402	template<typename T>
430	T div_ceil(const T &a, const T &b)	403	T div_ceil(const T &a, const T &b)
431	{	404	{
432	return (a+b-1) / b;	405	return (a+b-1) / b;
433	}	406	}
434		407
435	} // end namespace numext	408	} // end namespace numext
436		409
		410
		411	/** \class ScalarBinaryOpTraits
		412	* \ingroup Core_Module
		413	*
		414	* \brief Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is.
		415	*
		416	* \sa CwiseBinaryOp
		417	*/
		418	template<typename ScalarA, typename ScalarB, typename BinaryOp>
		419	struct ScalarBinaryOpTraits
		420	#ifndef EIGEN_PARSED_BY_DOXYGEN
		421	// for backward compatibility, use the hints given by the (deprecated) internal::scalar_product_traits class.
		422	: internal::scalar_product_traits<ScalarA,ScalarB>
		423	#endif // EIGEN_PARSED_BY_DOXYGEN
		424	{};
		425
		426	template<typename T, typename BinaryOp>
		427	struct ScalarBinaryOpTraits<T,T,BinaryOp>
		428	{
		429	enum { Defined = 1 };
		430	typedef T ReturnType;
		431	};
		432
		433	template<typename T, typename BinaryOp>
		434	struct ScalarBinaryOpTraits<T,std::complex<T>,BinaryOp>
		435	{
		436	enum { Defined = 1 };
		437	typedef std::complex<T> ReturnType;
		438	};
		439
		440	template<typename T, typename BinaryOp>
		441	struct ScalarBinaryOpTraits<std::complex<T>, T,BinaryOp>
		442	{
		443	enum { Defined = 1 };
		444	typedef std::complex<T> ReturnType;
		445	};
		446
437	} // end namespace Eigen	447	} // end namespace Eigen
438		448
439	#endif // EIGEN_META_H	449	#endif // EIGEN_META_H

Lines 644-667 std::string demangle_flags(int f) Link Here

(-)a/Eigen/src/Core/util/XprHelper.h (-7 / +3 lines)
644	if(f&NoPreferredStorageOrderBit) res += " \| NoPreferredStorageOrderBit";	644	if(f&NoPreferredStorageOrderBit) res += " \| NoPreferredStorageOrderBit";
645		645
646	return res;	646	return res;
647	}	647	}
648	#endif	648	#endif
649		649
650	} // end namespace internal	650	} // end namespace internal
651		651
652	// we require Lhs and Rhs to have the same scalar type. Currently there is no example of a binary functor	652	// We require Lhs and Rhs to have "compatible" scalar types.
653	// that would take two operands of different types. If there were such an example, then this check should be
654	// moved to the BinaryOp functors, on a per-case basis. This would however require a change in the BinaryOp functors, as
655	// currently they take only one typename Scalar template parameter.
656	// It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.	653	// It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
657	// So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to	654	// So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
658	// add together a float matrix and a double matrix.	655	// add together a float matrix and a double matrix.
		656	// Treat "void" as a special case. Needed for permutation products. TODO: this should be handled by ScalarBinaryOpTraits
659	#define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \	657	#define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \
660	EIGEN_STATIC_ASSERT((internal::functor_is_product_like<BINOP>::ret \	658	EIGEN_STATIC_ASSERT(int(internal::is_same_or_void<LHS, RHS>::value) \|\| int(ScalarBinaryOpTraits<LHS, RHS,BINOP>::Defined), \
661	? int(internal::scalar_product_traits<LHS, RHS>::Defined) \
662	: int(internal::is_same_or_void<LHS, RHS>::value)), \
663	YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)	659	YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
664		660
665	} // end namespace Eigen	661	} // end namespace Eigen
666		662
667	#endif // EIGEN_XPRHELPER_H	663	#endif // EIGEN_XPRHELPER_H

Lines 107-142 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTO Link Here

(-)a/Eigen/src/Geometry/AlignedBox.h (-3 / +3 lines)
107	inline VectorType& (min)() { return m_min; }	107	inline VectorType& (min)() { return m_min; }
108	/** \returns the maximal corner */	108	/** \returns the maximal corner */
109	inline const VectorType& (max)() const { return m_max; }	109	inline const VectorType& (max)() const { return m_max; }
110	/** \returns a non const reference to the maximal corner */	110	/** \returns a non const reference to the maximal corner */
111	inline VectorType& (max)() { return m_max; }	111	inline VectorType& (max)() { return m_max; }
112		112
113	/** \returns the center of the box */	113	/** \returns the center of the box */
114	inline const CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>,	114	inline const CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>,
115	const CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const VectorType, const VectorType> >	115	const CwiseBinaryOp<internal::scalar_sum_op<Scalar,Scalar>, const VectorType, const VectorType> >
116	center() const	116	center() const
117	{ return (m_min+m_max)/2; }	117	{ return (m_min+m_max)/2; }
118		118
119	/** \returns the lengths of the sides of the bounding box.	119	/** \returns the lengths of the sides of the bounding box.
120	* Note that this function does not get the same	120	* Note that this function does not get the same
121	* result for integral or floating scalar types: see	121	* result for integral or floating scalar types: see
122	*/	122	*/
123	inline const CwiseBinaryOp< internal::scalar_difference_op<Scalar>, const VectorType, const VectorType> sizes() const	123	inline const CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> sizes() const
124	{ return m_max - m_min; }	124	{ return m_max - m_min; }
125		125
126	/** \returns the volume of the bounding box */	126	/** \returns the volume of the bounding box */
127	inline Scalar volume() const	127	inline Scalar volume() const
128	{ return sizes().prod(); }	128	{ return sizes().prod(); }
129		129
130	/** \returns an expression for the bounding box diagonal vector	130	/** \returns an expression for the bounding box diagonal vector
131	* if the length of the diagonal is needed: diagonal().norm()	131	* if the length of the diagonal is needed: diagonal().norm()
132	* will provide it.	132	* will provide it.
133	*/	133	*/
134	inline CwiseBinaryOp< internal::scalar_difference_op<Scalar>, const VectorType, const VectorType> diagonal() const	134	inline CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> diagonal() const
135	{ return sizes(); }	135	{ return sizes(); }
136		136
137	/** \returns the vertex of the bounding box at the corner defined by	137	/** \returns the vertex of the bounding box at the corner defined by
138	* the corner-id corner. It works only for a 1D, 2D or 3D bounding box.	138	* the corner-id corner. It works only for a 1D, 2D or 3D bounding box.
139	* For 1D bounding boxes corners are named by 2 enum constants:	139	* For 1D bounding boxes corners are named by 2 enum constants:
140	* BottomLeft and BottomRight.	140	* BottomLeft and BottomRight.
141	* For 2D bounding boxes, corners are named by 4 enum constants:	141	* For 2D bounding boxes, corners are named by 4 enum constants:
142	* BottomLeft, BottomRight, TopLeft, TopRight.	142	* BottomLeft, BottomRight, TopLeft, TopRight.

Lines 324-355 struct unary_evaluator<Homogeneous<ArgTy Link Here

(-)a/Eigen/src/Geometry/Homogeneous.h (-6 / +6 lines)
324	}	324	}
325		325
326	protected:	326	protected:
327	PlainObject m_temp;	327	PlainObject m_temp;
328	};	328	};
329		329
330	// dense = homogeneous	330	// dense = homogeneous
331	template< typename DstXprType, typename ArgType, typename Scalar>	331	template< typename DstXprType, typename ArgType, typename Scalar>
332	struct Assignment<DstXprType, Homogeneous<ArgType,Vertical>, internal::assign_op<Scalar>, Dense2Dense, Scalar>	332	struct Assignment<DstXprType, Homogeneous<ArgType,Vertical>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense, Scalar>
333	{	333	{
334	typedef Homogeneous<ArgType,Vertical> SrcXprType;	334	typedef Homogeneous<ArgType,Vertical> SrcXprType;
335	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	335	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
336	{	336	{
337	dst.template topRows<ArgType::RowsAtCompileTime>(src.nestedExpression().rows()) = src.nestedExpression();	337	dst.template topRows<ArgType::RowsAtCompileTime>(src.nestedExpression().rows()) = src.nestedExpression();
338	dst.row(dst.rows()-1).setOnes();	338	dst.row(dst.rows()-1).setOnes();
339	}	339	}
340	};	340	};
341		341
342	// dense = homogeneous	342	// dense = homogeneous
343	template< typename DstXprType, typename ArgType, typename Scalar>	343	template< typename DstXprType, typename ArgType, typename Scalar>
344	struct Assignment<DstXprType, Homogeneous<ArgType,Horizontal>, internal::assign_op<Scalar>, Dense2Dense, Scalar>	344	struct Assignment<DstXprType, Homogeneous<ArgType,Horizontal>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense, Scalar>
345	{	345	{
346	typedef Homogeneous<ArgType,Horizontal> SrcXprType;	346	typedef Homogeneous<ArgType,Horizontal> SrcXprType;
347	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	347	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
348	{	348	{
349	dst.template leftCols<ArgType::ColsAtCompileTime>(src.nestedExpression().cols()) = src.nestedExpression();	349	dst.template leftCols<ArgType::ColsAtCompileTime>(src.nestedExpression().cols()) = src.nestedExpression();
350	dst.col(dst.cols()-1).setOnes();	350	dst.col(dst.cols()-1).setOnes();
351	}	351	}
352	};	352	};
353		353
354	template<typename LhsArg, typename Rhs, int ProductTag>	354	template<typename LhsArg, typename Rhs, int ProductTag>
355	struct generic_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs, HomogeneousShape, DenseShape, ProductTag>	355	struct generic_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs, HomogeneousShape, DenseShape, ProductTag>
Lines 368-384 struct homogeneous_right_product_refacto Link Here
368	Dim = Lhs::ColsAtCompileTime,	368	Dim = Lhs::ColsAtCompileTime,
369	Rows = Lhs::RowsAtCompileTime	369	Rows = Lhs::RowsAtCompileTime
370	};	370	};
371	typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type LinearBlockConst;	371	typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type LinearBlockConst;
372	typedef typename remove_const<LinearBlockConst>::type LinearBlock;	372	typedef typename remove_const<LinearBlockConst>::type LinearBlock;
373	typedef typename Rhs::ConstRowXpr ConstantColumn;	373	typedef typename Rhs::ConstRowXpr ConstantColumn;
374	typedef Replicate<const ConstantColumn,Rows,1> ConstantBlock;	374	typedef Replicate<const ConstantColumn,Rows,1> ConstantBlock;
375	typedef Product<Lhs,LinearBlock,LazyProduct> LinearProduct;	375	typedef Product<Lhs,LinearBlock,LazyProduct> LinearProduct;
376	typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;	376	typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
377	};	377	};
378		378
379	template<typename Lhs, typename Rhs, int ProductTag>	379	template<typename Lhs, typename Rhs, int ProductTag>
380	struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape>	380	struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape>
381	: public evaluator<typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs>::Xpr>	381	: public evaluator<typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs>::Xpr>
382	{	382	{
383	typedef Product<Lhs, Rhs, LazyProduct> XprType;	383	typedef Product<Lhs, Rhs, LazyProduct> XprType;
384	typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs> helper;	384	typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs> helper;
Lines 409-425 struct homogeneous_left_product_refactor Link Here
409	Dim = Rhs::RowsAtCompileTime,	409	Dim = Rhs::RowsAtCompileTime,
410	Cols = Rhs::ColsAtCompileTime	410	Cols = Rhs::ColsAtCompileTime
411	};	411	};
412	typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type LinearBlockConst;	412	typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type LinearBlockConst;
413	typedef typename remove_const<LinearBlockConst>::type LinearBlock;	413	typedef typename remove_const<LinearBlockConst>::type LinearBlock;
414	typedef typename Lhs::ConstColXpr ConstantColumn;	414	typedef typename Lhs::ConstColXpr ConstantColumn;
415	typedef Replicate<const ConstantColumn,1,Cols> ConstantBlock;	415	typedef Replicate<const ConstantColumn,1,Cols> ConstantBlock;
416	typedef Product<LinearBlock,Rhs,LazyProduct> LinearProduct;	416	typedef Product<LinearBlock,Rhs,LazyProduct> LinearProduct;
417	typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;	417	typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
418	};	418	};
419		419
420	template<typename Lhs, typename Rhs, int ProductTag>	420	template<typename Lhs, typename Rhs, int ProductTag>
421	struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape>	421	struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape>
422	: public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression>::Xpr>	422	: public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression>::Xpr>
423	{	423	{
424	typedef Product<Lhs, Rhs, LazyProduct> XprType;	424	typedef Product<Lhs, Rhs, LazyProduct> XprType;
425	typedef homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression> helper;	425	typedef homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression> helper;

Lines 103-119 struct hseq_side_dependent_impl<VectorsT Link Here

(-)a/Eigen/src/Householder/HouseholderSequence.h (-1 / +1 lines)
103	{	103	{
104	Index start = k+1+h.m_shift;	104	Index start = k+1+h.m_shift;
105	return Block<const VectorsType,1,Dynamic>(h.m_vectors, k, start, 1, h.rows()-start).transpose();	105	return Block<const VectorsType,1,Dynamic>(h.m_vectors, k, start, 1, h.rows()-start).transpose();
106	}	106	}
107	};	107	};
108		108
109	template<typename OtherScalarType, typename MatrixType> struct matrix_type_times_scalar_type	109	template<typename OtherScalarType, typename MatrixType> struct matrix_type_times_scalar_type
110	{	110	{
111	typedef typename scalar_product_traits<OtherScalarType, typename MatrixType::Scalar>::ReturnType	111	typedef typename ScalarBinaryOpTraits<OtherScalarType, typename MatrixType::Scalar>::ReturnType
112	ResultScalar;	112	ResultScalar;
113	typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,	113	typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
114	0, MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime> Type;	114	0, MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime> Type;
115	};	115	};
116		116
117	} // end namespace internal	117	} // end namespace internal
118		118
119	template<typename VectorsType, typename CoeffsType, int Side> class HouseholderSequence	119	template<typename VectorsType, typename CoeffsType, int Side> class HouseholderSequence

Lines 86-105 struct evaluator<SolveWithGuess<Decompos Link Here

(-)a/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h (-2 / +2 lines)
86		86
87	protected:	87	protected:
88	PlainObject m_result;	88	PlainObject m_result;
89	};	89	};
90		90
91	// Specialization for "dst = dec.solveWithGuess(rhs)"	91	// Specialization for "dst = dec.solveWithGuess(rhs)"
92	// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere	92	// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
93	template<typename DstXprType, typename DecType, typename RhsType, typename GuessType, typename Scalar>	93	template<typename DstXprType, typename DecType, typename RhsType, typename GuessType, typename Scalar>
94	struct Assignment<DstXprType, SolveWithGuess<DecType,RhsType,GuessType>, internal::assign_op<Scalar>, Dense2Dense, Scalar>	94	struct Assignment<DstXprType, SolveWithGuess<DecType,RhsType,GuessType>, internal::assign_op<Scalar,Scalar>, Dense2Dense, Scalar>
95	{	95	{
96	typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;	96	typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;
97	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	97	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
98	{	98	{
99	// FIXME shall we resize dst here?	99	// FIXME shall we resize dst here?
100	dst = src.guess();	100	dst = src.guess();
101	src.dec()._solve_with_guess_impl(src.rhs(), dst/, src.guess()/);	101	src.dec()._solve_with_guess_impl(src.rhs(), dst/, src.guess()/);
102	}	102	}
103	};	103	};
104		104
105	} // end namepsace internal	105	} // end namepsace internal

Lines 834-855 void FullPivLU<_MatrixType>::_solve_impl Link Here

(-)a/Eigen/src/LU/FullPivLU.h (-3 / +3 lines)
834	}	834	}
835		835
836	#endif	836	#endif
837		837
838	namespace internal {	838	namespace internal {
839		839
840		840
841	/*** Implementation of inverse() ***************************************************/	841	/*** Implementation of inverse() ***************************************************/
842	template<typename DstXprType, typename MatrixType, typename Scalar>	842	template<typename DstXprType, typename MatrixType>
843	struct Assignment<DstXprType, Inverse<FullPivLU<MatrixType> >, internal::assign_op<Scalar>, Dense2Dense, Scalar>	843	struct Assignment<DstXprType, Inverse<FullPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivLU<MatrixType>::Scalar>, Dense2Dense>
844	{	844	{
845	typedef FullPivLU<MatrixType> LuType;	845	typedef FullPivLU<MatrixType> LuType;
846	typedef Inverse<LuType> SrcXprType;	846	typedef Inverse<LuType> SrcXprType;
847	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar> &)	847	static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename MatrixType::Scalar> &)
848	{	848	{
849	dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));	849	dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
850	}	850	}
851	};	851	};
852	} // end namespace internal	852	} // end namespace internal
853		853
854	/***** MatrixBase methods ***************************************************************/	854	/***** MatrixBase methods ***************************************************************/
855		855