Various minor fixes

Eigen/src/Core/ProductEvaluators.h

@@ -602,7 +602,7 @@ struct generic_product_impl<Lhs,Rhs,TriangularShape,DenseShape,ProductTag>
   template<typename Dest>
   static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
   {
-    triangular_product_impl<Lhs::Mode,true,typename Lhs::MatrixType,false,Rhs, Rhs::IsVectorAtCompileTime>
+    triangular_product_impl<Lhs::Mode,true,typename Lhs::MatrixType,false,Rhs, Rhs::ColsAtCompileTime==1>
         ::run(dst, lhs.nestedExpression(), rhs, alpha);
   }
 };
@@ -636,7 +636,7 @@ struct generic_product_impl<Lhs,Rhs,DenseShape,TriangularShape,ProductTag>
   template<typename Dest>
   static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
   {
-    triangular_product_impl<Rhs::Mode,false,Lhs,Lhs::IsVectorAtCompileTime, typename Rhs::MatrixType, false>::run(dst, lhs, rhs.nestedExpression(), alpha);
+    triangular_product_impl<Rhs::Mode,false,Lhs,Lhs::RowsAtCompileTime==1, typename Rhs::MatrixType, false>::run(dst, lhs, rhs.nestedExpression(), alpha);
   }
 };
 

Eigen/src/Core/TriangularMatrix.h

@@ -176,7 +176,7 @@ struct traits<TriangularView<MatrixType, _Mode> > : traits<MatrixType>
   typedef MatrixType ExpressionType;
   enum {
     Mode = _Mode,
-    Flags = (MatrixTypeNestedCleaned::Flags & (HereditaryBits | LvalueBit) & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit))) | Mode
+    Flags = (MatrixTypeNestedCleaned::Flags & (HereditaryBits | LvalueBit) & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)))
 #ifndef EIGEN_TEST_EVALUATORS
     ,
     CoeffReadCost = MatrixTypeNestedCleaned::CoeffReadCost
@@ -206,7 +206,6 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView
   protected:
     typedef typename internal::traits<TriangularView>::MatrixTypeNested MatrixTypeNested;
     typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRef MatrixTypeNestedNonRef;
-    typedef typename internal::traits<TriangularView>::MatrixTypeNestedCleaned MatrixTypeNestedCleaned;
 
     typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
     
@@ -214,6 +213,7 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView
 
     typedef typename internal::traits<TriangularView>::StorageKind StorageKind;
     typedef typename internal::traits<TriangularView>::Index Index;
+    typedef typename internal::traits<TriangularView>::MatrixTypeNestedCleaned NestedExpression;
 
     enum {
       Mode = _Mode,
@@ -229,6 +229,8 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView
     {}
     
     using Base::operator=;
+    TriangularView& operator=(const TriangularView &other)
+    { return Base::operator=(other); }
 
     EIGEN_DEVICE_FUNC
     inline Index rows() const { return m_matrix.rows(); }
@@ -236,9 +238,9 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView
     inline Index cols() const { return m_matrix.cols(); }
 
     EIGEN_DEVICE_FUNC
-    const MatrixTypeNestedCleaned& nestedExpression() const { return m_matrix; }
+    const NestedExpression& nestedExpression() const { return m_matrix; }
     EIGEN_DEVICE_FUNC
-    MatrixTypeNestedCleaned& nestedExpression() { return *const_cast<MatrixTypeNestedCleaned*>(&m_matrix); }
+    NestedExpression& nestedExpression() { return *const_cast<NestedExpression*>(&m_matrix); }
 
     /** \sa MatrixBase::conjugate() */
     EIGEN_DEVICE_FUNC
@@ -416,7 +418,7 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_Mat
 
     EIGEN_DEVICE_FUNC
     TriangularViewType& operator=(const TriangularViewImpl& other)
-    { return *this = other.nestedExpression(); }
+    { return *this = other.derived().nestedExpression(); }
 
     template<typename OtherDerived>
     EIGEN_DEVICE_FUNC
@@ -462,11 +464,11 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_Mat
     template<typename OtherDerived> friend
     EIGEN_DEVICE_FUNC
     TriangularProduct<Mode, false, OtherDerived, OtherDerived::RowsAtCompileTime==1, MatrixType, false>
-    operator*(const MatrixBase<OtherDerived>& lhs, const TriangularVieImplw& rhs)
+    operator*(const MatrixBase<OtherDerived>& lhs, const TriangularViewImpl& rhs)
     {
       return TriangularProduct
               <Mode, false, OtherDerived, OtherDerived::RowsAtCompileTime==1, MatrixType, false>
-              (lhs.derived(),rhs.nestedExpression());
+              (lhs.derived(),rhs.derived().nestedExpression());
     }
 #endif
 
@@ -827,20 +829,20 @@ TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const MatrixBase<OtherDer
 // FIXME should we keep that possibility
 template<typename MatrixType, unsigned int Mode>
 template<typename OtherDerived>
-void TriangularViewImp<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)
+void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)
 {
   enum {
     unroll = MatrixType::SizeAtCompileTime != Dynamic
           && internal::traits<OtherDerived>::CoeffReadCost != Dynamic
           && MatrixType::SizeAtCompileTime*internal::traits<OtherDerived>::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT
   };
-  eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols());
+  eigen_assert(derived().rows() == other.rows() && derived().cols() == other.cols());
 
   internal::triangular_assignment_selector
     <MatrixType, OtherDerived, int(Mode),
     unroll ? int(MatrixType::SizeAtCompileTime) : Dynamic,
     false // do not change the opposite triangular part
-    >::run(m_matrix.const_cast_derived(), other.derived());
+    >::run(derived().nestedExpression().const_cast_derived(), other.derived());
 }
 
 
@@ -872,13 +874,13 @@ void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const TriangularBas
                    && MatrixType::SizeAtCompileTime * internal::traits<OtherDerived>::CoeffReadCost / 2
                         <= EIGEN_UNROLLING_LIMIT
   };
-  eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols());
+  eigen_assert(derived().rows() == other.rows() && derived().cols() == other.cols());
 
   internal::triangular_assignment_selector
     <MatrixType, OtherDerived, int(Mode),
     unroll ? int(MatrixType::SizeAtCompileTime) : Dynamic,
     false // preserve the opposite triangular part
-    >::run(m_matrix.const_cast_derived(), other.derived().nestedExpression());
+    >::run(derived().nestedExpression().const_cast_derived(), other.derived().nestedExpression());
 }
 
 #endif // EIGEN_TEST_EVALUATORS
@@ -1043,13 +1045,13 @@ struct evaluator_traits<TriangularView<MatrixType,Mode> >
 };
 
 template<typename MatrixType, unsigned int Mode>
-struct evaluator<TriangularView<MatrixType,Mode> >
+struct unary_evaluator<TriangularView<MatrixType,Mode>, IndexBased>
  : evaluator<typename internal::remove_all<MatrixType>::type>
 {
   typedef TriangularView<MatrixType,Mode> XprType;
   typedef evaluator<typename internal::remove_all<MatrixType>::type> Base;
-  typedef evaluator type;
+  typedef evaluator<XprType> type;
-  evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
+  unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
 };
 
 // Additional assignment kinds:

Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h

@@ -270,7 +270,7 @@ TriangularView<MatrixType,UpLo>& TriangularViewImpl<MatrixType,UpLo,Dense>::_ass
   
   general_product_to_triangular_selector<MatrixType, ProductType, UpLo, internal::traits<ProductType>::InnerSize==1>::run(derived().nestedExpression().const_cast_derived(), prod, alpha);
   
-  return *this;
+  return derived();
 }
 #else
 template<typename MatrixType, unsigned int UpLo>
@@ -282,7 +282,7 @@ TriangularView<MatrixType,UpLo>& TriangularViewImpl<MatrixType,UpLo,Dense>::assi
   general_product_to_triangular_selector<MatrixType, ProductDerived, UpLo, (_Lhs::ColsAtCompileTime==1) || (_Rhs::RowsAtCompileTime==1)>
     ::run(derived().nestedExpression().const_cast_derived(), prod.derived(), alpha);
   
-  return *this;
+  return derived();
 }
 #endif
 } // end namespace Eigen

Eigen/src/SparseCore/SparseAssign.h

@@ -173,6 +173,7 @@ struct Sparse2Sparse {};
 struct Sparse2Dense  {};
 
 template<> struct AssignmentKind<SparseShape,SparseShape> { typedef Sparse2Sparse Kind; };
+template<> struct AssignmentKind<SparseShape,SparseTriangularShape> { typedef Sparse2Sparse Kind; };
 template<> struct AssignmentKind<DenseShape,SparseShape>  { typedef Sparse2Dense  Kind; };
 
 

Eigen/src/SparseCore/SparseSelfAdjointView.h

@@ -238,7 +238,7 @@ template<typename DerivedU>
 SparseSelfAdjointView<MatrixType,Mode>&
 SparseSelfAdjointView<MatrixType,Mode>::rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha)
 {
-  SparseMatrix<Scalar,MatrixType::Flags&RowMajorBit?RowMajor:ColMajor> tmp = u * u.adjoint();
+  SparseMatrix<Scalar,(MatrixType::Flags&RowMajorBit)?RowMajor:ColMajor> tmp = u * u.adjoint();
   if(alpha==Scalar(0))
     m_matrix.const_cast_derived() = tmp.template triangularView<Mode>();
   else

Eigen/src/SparseCore/SparseTriangularView.h

@@ -1,7 +1,7 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
 // Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
 //
 // This Source Code Form is subject to the terms of the Mozilla
@@ -13,15 +13,6 @@
 
 namespace Eigen { 
 
-namespace internal {
-  
-// template<typename MatrixType, int Mode>
-// struct traits<SparseTriangularView<MatrixType,Mode> >
-// : public traits<MatrixType>
-// {};
-
-} // namespace internal
-
 template<typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType,Mode,Sparse>
   : public SparseMatrixBase<TriangularView<MatrixType,Mode> >
 {
@@ -76,7 +67,7 @@ class TriangularViewImpl<MatrixType,Mode,Sparse>::InnerIterator : public MatrixT
   public:
 
     EIGEN_STRONG_INLINE InnerIterator(const TriangularViewImpl& view, Index outer)
-      : Base(view.nestedExpression(), outer), m_returnOne(false)
+      : Base(view.derived().nestedExpression(), outer), m_returnOne(false)
     {
       if(SkipFirst)
       {
@@ -146,7 +137,7 @@ class TriangularViewImpl<MatrixType,Mode,Sparse>::ReverseInnerIterator : public
   public:
 
     EIGEN_STRONG_INLINE ReverseInnerIterator(const TriangularViewType& view, Index outer)
-      : Base(view.nestedExpression(), outer)
+      : Base(view.derived().nestedExpression(), outer)
     {
       eigen_assert((!HasUnitDiag) && "ReverseInnerIterator does not support yet triangular views with a unit diagonal");
       if(SkipLast) {
@@ -172,6 +163,115 @@ class TriangularViewImpl<MatrixType,Mode,Sparse>::ReverseInnerIterator : public
     }
 };
 
+#ifdef EIGEN_TEST_EVALUATORS
+namespace internal {
+
+template<typename ArgType, unsigned int Mode>
+struct unary_evaluator<TriangularView<ArgType,Mode>, IteratorBased>
+ : evaluator_base<TriangularView<ArgType,Mode> >
+{
+  typedef TriangularView<ArgType,Mode> XprType;
+  
+protected:
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::Index Index;
+  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  
+  enum { SkipFirst = ((Mode&Lower) && !(ArgType::Flags&RowMajorBit))
+                    || ((Mode&Upper) &&  (ArgType::Flags&RowMajorBit)),
+         SkipLast = !SkipFirst,
+         SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
+         HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
+  };
+  
+public:
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = XprType::Flags
+  };
+    
+  unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()) {}
+  
+  class InnerIterator : public EvalIterator
+  {
+      typedef EvalIterator Base;
+    public:
+
+      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
+        : Base(xprEval.m_argImpl,outer)
+      {
+        if(SkipFirst)
+        {
+          while((*this) && ((HasUnitDiag||SkipDiag)  ? this->index()<=outer : this->index()<outer))
+            Base::operator++();
+          if(HasUnitDiag)
+            m_returnOne = true;
+        }
+        else if(HasUnitDiag && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+        {
+          if((!SkipFirst) && Base::operator bool())
+            Base::operator++();
+          m_returnOne = true;
+        }
+      }
+
+      EIGEN_STRONG_INLINE InnerIterator& operator++()
+      {
+        if(HasUnitDiag && m_returnOne)
+          m_returnOne = false;
+        else
+        {
+          Base::operator++();
+          if(HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+          {
+            if((!SkipFirst) && Base::operator bool())
+              Base::operator++();
+            m_returnOne = true;
+          }
+        }
+        return *this;
+      }
+      
+      EIGEN_STRONG_INLINE operator bool() const
+      {
+        if(HasUnitDiag && m_returnOne)
+          return true;
+        if(SkipFirst) return  Base::operator bool();
+        else
+        {
+          if (SkipDiag) return (Base::operator bool() && this->index() < this->outer());
+          else return (Base::operator bool() && this->index() <= this->outer());
+        }
+      }
+
+//       inline Index row() const { return (ArgType::Flags&RowMajorBit ? Base::outer() : this->index()); }
+//       inline Index col() const { return (ArgType::Flags&RowMajorBit ? this->index() : Base::outer()); }
+      inline Index index() const
+      {
+        if(HasUnitDiag && m_returnOne)  return Base::outer();
+        else                            return Base::index();
+      }
+      inline Scalar value() const
+      {
+        if(HasUnitDiag && m_returnOne)  return Scalar(1);
+        else                            return Base::value();
+      }
+
+    protected:
+      bool m_returnOne;
+    private:
+      Scalar& valueRef();
+  };
+  
+protected:
+  typename evaluator<ArgType>::type m_argImpl;
+};
+
+} // end namespace internal
+#endif
+
 template<typename Derived>
 template<int Mode>
 inline const TriangularView<Derived, Mode>

Eigen/src/SparseCore/SparseUtil.h

@@ -54,7 +54,7 @@ EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, /=)
   typedef typename Eigen::internal::traits<Derived >::Index Index; \
   enum { RowsAtCompileTime = Eigen::internal::traits<Derived >::RowsAtCompileTime, \
         ColsAtCompileTime = Eigen::internal::traits<Derived >::ColsAtCompileTime, \
-        Flags = Eigen::internal::traits<Derived >::Flags, \
+        Flags = Eigen::internal::traits<Derived>::Flags, \
         CoeffReadCost = Eigen::internal::traits<Derived >::CoeffReadCost, \
         SizeAtCompileTime = Base::SizeAtCompileTime, \
         IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
@@ -72,7 +72,7 @@ EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, /=)
   typedef typename Eigen::internal::traits<Derived >::Index Index; \
   enum { RowsAtCompileTime = Eigen::internal::traits<Derived >::RowsAtCompileTime, \
         ColsAtCompileTime = Eigen::internal::traits<Derived >::ColsAtCompileTime, \
-        Flags = Eigen::internal::traits<Derived >::Flags, \
+        Flags = Eigen::internal::traits<Derived>::Flags, \
         SizeAtCompileTime = Base::SizeAtCompileTime, \
         IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
   using Base::derived; \

test/CMakeLists.txt

@@ -216,7 +216,6 @@ ei_add_test(jacobi)
 ei_add_test(jacobisvd)
 ei_add_test(householder)
 if(NOT EIGEN_TEST_EVALUATORS)
-  ei_add_test(cwiseop) # Eigen2 related
   ei_add_test(geo_orthomethods)
   ei_add_test(geo_homogeneous)
   ei_add_test(geo_quaternion)