casadi 3.6.4__cp27-none-win_amd64.whl → 3.6.6__cp27-none-win_amd64.whl

casadi/include/include/eigen3/Eigen/src/SparseCore/SparseSolverBase.h

@@ -1,124 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPARSESOLVERBASE_H
-#define EIGEN_SPARSESOLVERBASE_H
-
-namespace Eigen { 
-
-namespace internal {
-
-  /** \internal
-  * Helper functions to solve with a sparse right-hand-side and result.
-  * The rhs is decomposed into small vertical panels which are solved through dense temporaries.
-  */
-template<typename Decomposition, typename Rhs, typename Dest>
-typename enable_if<Rhs::ColsAtCompileTime!=1 && Dest::ColsAtCompileTime!=1>::type
-solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
-{
-  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
-  typedef typename Dest::Scalar DestScalar;
-  // we process the sparse rhs per block of NbColsAtOnce columns temporarily stored into a dense matrix.
-  static const Index NbColsAtOnce = 4;
-  Index rhsCols = rhs.cols();
-  Index size = rhs.rows();
-  // the temporary matrices do not need more columns than NbColsAtOnce:
-  Index tmpCols = (std::min)(rhsCols, NbColsAtOnce); 
-  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmp(size,tmpCols);
-  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmpX(size,tmpCols);
-  for(Index k=0; k<rhsCols; k+=NbColsAtOnce)
-  {
-    Index actualCols = std::min<Index>(rhsCols-k, NbColsAtOnce);
-    tmp.leftCols(actualCols) = rhs.middleCols(k,actualCols);
-    tmpX.leftCols(actualCols) = dec.solve(tmp.leftCols(actualCols));
-    dest.middleCols(k,actualCols) = tmpX.leftCols(actualCols).sparseView();
-  }
-}
-
-// Overload for vector as rhs
-template<typename Decomposition, typename Rhs, typename Dest>
-typename enable_if<Rhs::ColsAtCompileTime==1 || Dest::ColsAtCompileTime==1>::type
-solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
-{
-  typedef typename Dest::Scalar DestScalar;
-  Index size = rhs.rows();
-  Eigen::Matrix<DestScalar,Dynamic,1> rhs_dense(rhs);
-  Eigen::Matrix<DestScalar,Dynamic,1> dest_dense(size);
-  dest_dense = dec.solve(rhs_dense);
-  dest = dest_dense.sparseView();
-}
-
-} // end namespace internal
-
-/** \class SparseSolverBase
-  * \ingroup SparseCore_Module
-  * \brief A base class for sparse solvers
-  *
-  * \tparam Derived the actual type of the solver.
-  *
-  */
-template<typename Derived>
-class SparseSolverBase : internal::noncopyable
-{
-  public:
-
-    /** Default constructor */
-    SparseSolverBase()
-      : m_isInitialized(false)
-    {}
-
-    ~SparseSolverBase()
-    {}
-
-    Derived& derived() { return *static_cast<Derived*>(this); }
-    const Derived& derived() const { return *static_cast<const Derived*>(this); }
-    
-    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
-      *
-      * \sa compute()
-      */
-    template<typename Rhs>
-    inline const Solve<Derived, Rhs>
-    solve(const MatrixBase<Rhs>& b) const
-    {
-      eigen_assert(m_isInitialized && "Solver is not initialized.");
-      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
-      return Solve<Derived, Rhs>(derived(), b.derived());
-    }
-    
-    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
-      *
-      * \sa compute()
-      */
-    template<typename Rhs>
-    inline const Solve<Derived, Rhs>
-    solve(const SparseMatrixBase<Rhs>& b) const
-    {
-      eigen_assert(m_isInitialized && "Solver is not initialized.");
-      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
-      return Solve<Derived, Rhs>(derived(), b.derived());
-    }
-    
-    #ifndef EIGEN_PARSED_BY_DOXYGEN
-    /** \internal default implementation of solving with a sparse rhs */
-    template<typename Rhs,typename Dest>
-    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
-    {
-      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
-    }
-    #endif // EIGEN_PARSED_BY_DOXYGEN
-
-  protected:
-    
-    mutable bool m_isInitialized;
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSESOLVERBASE_H

casadi/include/include/eigen3/Eigen/src/SparseCore/SparseSparseProductWithPruning.h

@@ -1,198 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
-#define EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
-
-namespace Eigen { 
-
-namespace internal {
-
-
-// perform a pseudo in-place sparse * sparse product assuming all matrices are col major
-template<typename Lhs, typename Rhs, typename ResultType>
-static void sparse_sparse_product_with_pruning_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, const typename ResultType::RealScalar& tolerance)
-{
-  // return sparse_sparse_product_with_pruning_impl2(lhs,rhs,res);
-
-  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
-  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
-  typedef typename remove_all<Lhs>::type::StorageIndex StorageIndex;
-
-  // make sure to call innerSize/outerSize since we fake the storage order.
-  Index rows = lhs.innerSize();
-  Index cols = rhs.outerSize();
-  //Index size = lhs.outerSize();
-  eigen_assert(lhs.outerSize() == rhs.innerSize());
-
-  // allocate a temporary buffer
-  AmbiVector<ResScalar,StorageIndex> tempVector(rows);
-
-  // mimics a resizeByInnerOuter:
-  if(ResultType::IsRowMajor)
-    res.resize(cols, rows);
-  else
-    res.resize(rows, cols);
-  
-  evaluator<Lhs> lhsEval(lhs);
-  evaluator<Rhs> rhsEval(rhs);
-  
-  // estimate the number of non zero entries
-  // given a rhs column containing Y non zeros, we assume that the respective Y columns
-  // of the lhs differs in average of one non zeros, thus the number of non zeros for
-  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
-  // per column of the lhs.
-  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
-  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
-
-  res.reserve(estimated_nnz_prod);
-  double ratioColRes = double(estimated_nnz_prod)/(double(lhs.rows())*double(rhs.cols()));
-  for (Index j=0; j<cols; ++j)
-  {
-    // FIXME:
-    //double ratioColRes = (double(rhs.innerVector(j).nonZeros()) + double(lhs.nonZeros())/double(lhs.cols()))/double(lhs.rows());
-    // let's do a more accurate determination of the nnz ratio for the current column j of res
-    tempVector.init(ratioColRes);
-    tempVector.setZero();
-    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
-    {
-      // FIXME should be written like this: tmp += rhsIt.value() * lhs.col(rhsIt.index())
-      tempVector.restart();
-      RhsScalar x = rhsIt.value();
-      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, rhsIt.index()); lhsIt; ++lhsIt)
-      {
-        tempVector.coeffRef(lhsIt.index()) += lhsIt.value() * x;
-      }
-    }
-    res.startVec(j);
-    for (typename AmbiVector<ResScalar,StorageIndex>::Iterator it(tempVector,tolerance); it; ++it)
-      res.insertBackByOuterInner(j,it.index()) = it.value();
-  }
-  res.finalize();
-}
-
-template<typename Lhs, typename Rhs, typename ResultType,
-  int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit,
-  int RhsStorageOrder = traits<Rhs>::Flags&RowMajorBit,
-  int ResStorageOrder = traits<ResultType>::Flags&RowMajorBit>
-struct sparse_sparse_product_with_pruning_selector;
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
-    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,ResultType>(lhs, rhs, _res, tolerance);
-    res.swap(_res);
-  }
-};
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    // we need a col-major matrix to hold the result
-    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> SparseTemporaryType;
-    SparseTemporaryType _res(res.rows(), res.cols());
-    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,SparseTemporaryType>(lhs, rhs, _res, tolerance);
-    res = _res;
-  }
-};
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    // let's transpose the product to get a column x column product
-    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
-    internal::sparse_sparse_product_with_pruning_impl<Rhs,Lhs,ResultType>(rhs, lhs, _res, tolerance);
-    res.swap(_res);
-  }
-};
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
-    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
-    ColMajorMatrixLhs colLhs(lhs);
-    ColMajorMatrixRhs colRhs(rhs);
-    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,ColMajorMatrixRhs,ResultType>(colLhs, colRhs, res, tolerance);
-
-    // let's transpose the product to get a column x column product
-//     typedef SparseMatrix<typename ResultType::Scalar> SparseTemporaryType;
-//     SparseTemporaryType _res(res.cols(), res.rows());
-//     sparse_sparse_product_with_pruning_impl<Rhs,Lhs,SparseTemporaryType>(rhs, lhs, _res);
-//     res = _res.transpose();
-  }
-};
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    typedef SparseMatrix<typename Lhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixLhs;
-    RowMajorMatrixLhs rowLhs(lhs);
-    sparse_sparse_product_with_pruning_selector<RowMajorMatrixLhs,Rhs,ResultType,RowMajor,RowMajor>(rowLhs,rhs,res,tolerance);
-  }
-};
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    typedef SparseMatrix<typename Rhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixRhs;
-    RowMajorMatrixRhs rowRhs(rhs);
-    sparse_sparse_product_with_pruning_selector<Lhs,RowMajorMatrixRhs,ResultType,RowMajor,RowMajor,RowMajor>(lhs,rowRhs,res,tolerance);
-  }
-};
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
-    ColMajorMatrixRhs colRhs(rhs);
-    internal::sparse_sparse_product_with_pruning_impl<Lhs,ColMajorMatrixRhs,ResultType>(lhs, colRhs, res, tolerance);
-  }
-};
-
-template<typename Lhs, typename Rhs, typename ResultType>
-struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor>
-{
-  typedef typename ResultType::RealScalar RealScalar;
-  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
-  {
-    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
-    ColMajorMatrixLhs colLhs(lhs);
-    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,Rhs,ResultType>(colLhs, rhs, res, tolerance);
-  }
-};
-
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H

casadi/include/include/eigen3/Eigen/src/SparseCore/SparseTranspose.h

@@ -1,92 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPARSETRANSPOSE_H
-#define EIGEN_SPARSETRANSPOSE_H
-
-namespace Eigen { 
-
-namespace internal {
-  template<typename MatrixType,int CompressedAccess=int(MatrixType::Flags&CompressedAccessBit)>
-  class SparseTransposeImpl
-    : public SparseMatrixBase<Transpose<MatrixType> >
-  {};
-  
-  template<typename MatrixType>
-  class SparseTransposeImpl<MatrixType,CompressedAccessBit>
-    : public SparseCompressedBase<Transpose<MatrixType> >
-  {
-    typedef SparseCompressedBase<Transpose<MatrixType> > Base;
-  public:
-    using Base::derived;
-    typedef typename Base::Scalar Scalar;
-    typedef typename Base::StorageIndex StorageIndex;
-
-    inline Index nonZeros() const { return derived().nestedExpression().nonZeros(); }
-    
-    inline const Scalar* valuePtr() const { return derived().nestedExpression().valuePtr(); }
-    inline const StorageIndex* innerIndexPtr() const { return derived().nestedExpression().innerIndexPtr(); }
-    inline const StorageIndex* outerIndexPtr() const { return derived().nestedExpression().outerIndexPtr(); }
-    inline const StorageIndex* innerNonZeroPtr() const { return derived().nestedExpression().innerNonZeroPtr(); }
-
-    inline Scalar* valuePtr() { return derived().nestedExpression().valuePtr(); }
-    inline StorageIndex* innerIndexPtr() { return derived().nestedExpression().innerIndexPtr(); }
-    inline StorageIndex* outerIndexPtr() { return derived().nestedExpression().outerIndexPtr(); }
-    inline StorageIndex* innerNonZeroPtr() { return derived().nestedExpression().innerNonZeroPtr(); }
-  };
-}
-  
-template<typename MatrixType> class TransposeImpl<MatrixType,Sparse>
-  : public internal::SparseTransposeImpl<MatrixType>
-{
-  protected:
-    typedef internal::SparseTransposeImpl<MatrixType> Base;
-};
-
-namespace internal {
-  
-template<typename ArgType>
-struct unary_evaluator<Transpose<ArgType>, IteratorBased>
-  : public evaluator_base<Transpose<ArgType> >
-{
-    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
-  public:
-    typedef Transpose<ArgType> XprType;
-    
-    inline Index nonZerosEstimate() const {
-      return m_argImpl.nonZerosEstimate();
-    }
-
-    class InnerIterator : public EvalIterator
-    {
-    public:
-      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
-        : EvalIterator(unaryOp.m_argImpl,outer)
-      {}
-      
-      Index row() const { return EvalIterator::col(); }
-      Index col() const { return EvalIterator::row(); }
-    };
-    
-    enum {
-      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
-      Flags = XprType::Flags
-    };
-    
-    explicit unary_evaluator(const XprType& op) :m_argImpl(op.nestedExpression()) {}
-
-  protected:
-    evaluator<ArgType> m_argImpl;
-};
-
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSETRANSPOSE_H

casadi/include/include/eigen3/Eigen/src/SparseCore/SparseTriangularView.h

@@ -1,189 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009-2015 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
-// 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_SPARSE_TRIANGULARVIEW_H
-#define EIGEN_SPARSE_TRIANGULARVIEW_H
-
-namespace Eigen {
-
-/** \ingroup SparseCore_Module
-  *
-  * \brief Base class for a triangular part in a \b sparse matrix
-  *
-  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
-  * It extends class TriangularView with additional methods which are available for sparse expressions only.
-  *
-  * \sa class TriangularView, SparseMatrixBase::triangularView()
-  */
-template<typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType,Mode,Sparse>
-  : public SparseMatrixBase<TriangularView<MatrixType,Mode> >
-{
-    enum { SkipFirst = ((Mode&Lower) && !(MatrixType::Flags&RowMajorBit))
-                    || ((Mode&Upper) &&  (MatrixType::Flags&RowMajorBit)),
-           SkipLast = !SkipFirst,
-           SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
-           HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
-    };
-    
-    typedef TriangularView<MatrixType,Mode> TriangularViewType;
-    
-  protected:
-    // dummy solve function to make TriangularView happy.
-    void solve() const;
-
-    typedef SparseMatrixBase<TriangularViewType> Base;
-  public:
-    
-    EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
-    
-    typedef typename MatrixType::Nested MatrixTypeNested;
-    typedef typename internal::remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
-    typedef typename internal::remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
-
-    template<typename RhsType, typename DstType>
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
-      if(!(internal::is_same<RhsType,DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
-        dst = rhs;
-      this->solveInPlace(dst);
-    }
-
-    /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
-    template<typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& other) const;
-
-    /** Applies the inverse of \c *this to the sparse vector or matrix \a other, "in-place" */
-    template<typename OtherDerived> void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
-  
-};
-
-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::StorageIndex StorageIndex;
-  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
-  };
-    
-  explicit unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}
-  
-  inline Index nonZerosEstimate() const {
-    return m_argImpl.nonZerosEstimate();
-  }
-  
-  class InnerIterator : public EvalIterator
-  {
-      typedef EvalIterator Base;
-    public:
-
-      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
-        : Base(xprEval.m_argImpl,outer), m_returnOne(false), m_containsDiag(Base::outer()<xprEval.m_arg.innerSize())
-      {
-        if(SkipFirst)
-        {
-          while((*this) && ((HasUnitDiag||SkipDiag)  ? this->index()<=outer : this->index()<outer))
-            Base::operator++();
-          if(HasUnitDiag)
-            m_returnOne = m_containsDiag;
-        }
-        else if(HasUnitDiag && ((!Base::operator bool()) || Base::index()>=Base::outer()))
-        {
-          if((!SkipFirst) && Base::operator bool())
-            Base::operator++();
-          m_returnOne = m_containsDiag;
-        }
-      }
-
-      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 = m_containsDiag;
-          }
-        }
-        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 StorageIndex index() const
-      {
-        if(HasUnitDiag && m_returnOne)  return internal::convert_index<StorageIndex>(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;
-      bool m_containsDiag;
-    private:
-      Scalar& valueRef();
-  };
-  
-protected:
-  evaluator<ArgType> m_argImpl;
-  const ArgType& m_arg;
-};
-
-} // end namespace internal
-
-template<typename Derived>
-template<int Mode>
-inline const TriangularView<const Derived, Mode>
-SparseMatrixBase<Derived>::triangularView() const
-{
-  return TriangularView<const Derived, Mode>(derived());
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSE_TRIANGULARVIEW_H