casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.5__cp312-none-win_amd64.whl

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

@@ -1,659 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009-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_SPARSE_SELFADJOINTVIEW_H
-#define EIGEN_SPARSE_SELFADJOINTVIEW_H
-
-namespace Eigen { 
-  
-/** \ingroup SparseCore_Module
-  * \class SparseSelfAdjointView
-  *
-  * \brief Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
-  *
-  * \param MatrixType the type of the dense matrix storing the coefficients
-  * \param Mode can be either \c #Lower or \c #Upper
-  *
-  * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
-  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
-  * and most of the time this is the only way that it is used.
-  *
-  * \sa SparseMatrixBase::selfadjointView()
-  */
-namespace internal {
-  
-template<typename MatrixType, unsigned int Mode>
-struct traits<SparseSelfAdjointView<MatrixType,Mode> > : traits<MatrixType> {
-};
-
-template<int SrcMode,int DstMode,typename MatrixType,int DestOrder>
-void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
-
-template<int Mode,typename MatrixType,int DestOrder>
-void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
-
-}
-
-template<typename MatrixType, unsigned int _Mode> class SparseSelfAdjointView
-  : public EigenBase<SparseSelfAdjointView<MatrixType,_Mode> >
-{
-  public:
-    
-    enum {
-      Mode = _Mode,
-      TransposeMode = ((Mode & Upper) ? Lower : 0) | ((Mode & Lower) ? Upper : 0),
-      RowsAtCompileTime = internal::traits<SparseSelfAdjointView>::RowsAtCompileTime,
-      ColsAtCompileTime = internal::traits<SparseSelfAdjointView>::ColsAtCompileTime
-    };
-
-    typedef EigenBase<SparseSelfAdjointView> Base;
-    typedef typename MatrixType::Scalar Scalar;
-    typedef typename MatrixType::StorageIndex StorageIndex;
-    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
-    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
-    typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
-    
-    explicit inline SparseSelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
-    {
-      eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices");
-    }
-
-    inline Index rows() const { return m_matrix.rows(); }
-    inline Index cols() const { return m_matrix.cols(); }
-
-    /** \internal \returns a reference to the nested matrix */
-    const _MatrixTypeNested& matrix() const { return m_matrix; }
-    typename internal::remove_reference<MatrixTypeNested>::type& matrix() { return m_matrix; }
-
-    /** \returns an expression of the matrix product between a sparse self-adjoint matrix \c *this and a sparse matrix \a rhs.
-      *
-      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
-      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
-      */
-    template<typename OtherDerived>
-    Product<SparseSelfAdjointView, OtherDerived>
-    operator*(const SparseMatrixBase<OtherDerived>& rhs) const
-    {
-      return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
-    }
-
-    /** \returns an expression of the matrix product between a sparse matrix \a lhs and a sparse self-adjoint matrix \a rhs.
-      *
-      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
-      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
-      */
-    template<typename OtherDerived> friend
-    Product<OtherDerived, SparseSelfAdjointView>
-    operator*(const SparseMatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
-    {
-      return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
-    }
-    
-    /** Efficient sparse self-adjoint matrix times dense vector/matrix product */
-    template<typename OtherDerived>
-    Product<SparseSelfAdjointView,OtherDerived>
-    operator*(const MatrixBase<OtherDerived>& rhs) const
-    {
-      return Product<SparseSelfAdjointView,OtherDerived>(*this, rhs.derived());
-    }
-
-    /** Efficient dense vector/matrix times sparse self-adjoint matrix product */
-    template<typename OtherDerived> friend
-    Product<OtherDerived,SparseSelfAdjointView>
-    operator*(const MatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
-    {
-      return Product<OtherDerived,SparseSelfAdjointView>(lhs.derived(), rhs);
-    }
-
-    /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
-      * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
-      *
-      * \returns a reference to \c *this
-      *
-      * To perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
-      * call this function with u.adjoint().
-      */
-    template<typename DerivedU>
-    SparseSelfAdjointView& rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
-    
-    /** \returns an expression of P H P^-1 */
-    // TODO implement twists in a more evaluator friendly fashion
-    SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode> twistedBy(const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm) const
-    {
-      return SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode>(m_matrix, perm);
-    }
-
-    template<typename SrcMatrixType,int SrcMode>
-    SparseSelfAdjointView& operator=(const SparseSymmetricPermutationProduct<SrcMatrixType,SrcMode>& permutedMatrix)
-    {
-      internal::call_assignment_no_alias_no_transpose(*this, permutedMatrix);
-      return *this;
-    }
-
-    SparseSelfAdjointView& operator=(const SparseSelfAdjointView& src)
-    {
-      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
-      return *this = src.twistedBy(pnull);
-    }
-
-    // Since we override the copy-assignment operator, we need to explicitly re-declare the copy-constructor
-    EIGEN_DEFAULT_COPY_CONSTRUCTOR(SparseSelfAdjointView)
-
-    template<typename SrcMatrixType,unsigned int SrcMode>
-    SparseSelfAdjointView& operator=(const SparseSelfAdjointView<SrcMatrixType,SrcMode>& src)
-    {
-      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
-      return *this = src.twistedBy(pnull);
-    }
-    
-    void resize(Index rows, Index cols)
-    {
-      EIGEN_ONLY_USED_FOR_DEBUG(rows);
-      EIGEN_ONLY_USED_FOR_DEBUG(cols);
-      eigen_assert(rows == this->rows() && cols == this->cols()
-                && "SparseSelfadjointView::resize() does not actually allow to resize.");
-    }
-    
-  protected:
-
-    MatrixTypeNested m_matrix;
-    //mutable VectorI m_countPerRow;
-    //mutable VectorI m_countPerCol;
-  private:
-    template<typename Dest> void evalTo(Dest &) const;
-};
-
-/***************************************************************************
-* Implementation of SparseMatrixBase methods
-***************************************************************************/
-
-template<typename Derived>
-template<unsigned int UpLo>
-typename SparseMatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView() const
-{
-  return SparseSelfAdjointView<const Derived, UpLo>(derived());
-}
-
-template<typename Derived>
-template<unsigned int UpLo>
-typename SparseMatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView()
-{
-  return SparseSelfAdjointView<Derived, UpLo>(derived());
-}
-
-/***************************************************************************
-* Implementation of SparseSelfAdjointView methods
-***************************************************************************/
-
-template<typename MatrixType, unsigned int Mode>
-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();
-  if(alpha==Scalar(0))
-    m_matrix = tmp.template triangularView<Mode>();
-  else
-    m_matrix += alpha * tmp.template triangularView<Mode>();
-
-  return *this;
-}
-
-namespace internal {
-  
-// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
-//      in the future selfadjoint-ness should be defined by the expression traits
-//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
-template<typename MatrixType, unsigned int Mode>
-struct evaluator_traits<SparseSelfAdjointView<MatrixType,Mode> >
-{
-  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
-  typedef SparseSelfAdjointShape Shape;
-};
-
-struct SparseSelfAdjoint2Sparse {};
-
-template<> struct AssignmentKind<SparseShape,SparseSelfAdjointShape> { typedef SparseSelfAdjoint2Sparse Kind; };
-template<> struct AssignmentKind<SparseSelfAdjointShape,SparseShape> { typedef Sparse2Sparse Kind; };
-
-template< typename DstXprType, typename SrcXprType, typename Functor>
-struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse>
-{
-  typedef typename DstXprType::StorageIndex StorageIndex;
-  typedef internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> AssignOpType;
-
-  template<typename DestScalar,int StorageOrder>
-  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignOpType&/*func*/)
-  {
-    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
-  }
-
-  // FIXME: the handling of += and -= in sparse matrices should be cleanup so that next two overloads could be reduced to:
-  template<typename DestScalar,int StorageOrder,typename AssignFunc>
-  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignFunc& func)
-  {
-    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
-    run(tmp, src, AssignOpType());
-    call_assignment_no_alias_no_transpose(dst, tmp, func);
-  }
-
-  template<typename DestScalar,int StorageOrder>
-  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
-                  const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
-  {
-    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
-    run(tmp, src, AssignOpType());
-    dst += tmp;
-  }
-
-  template<typename DestScalar,int StorageOrder>
-  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
-                  const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
-  {
-    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
-    run(tmp, src, AssignOpType());
-    dst -= tmp;
-  }
-  
-  template<typename DestScalar>
-  static void run(DynamicSparseMatrix<DestScalar,ColMajor,StorageIndex>& dst, const SrcXprType &src, const AssignOpType&/*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;
-  }
-};
-
-} // end namespace internal
-
-/***************************************************************************
-* Implementation of sparse self-adjoint time dense matrix
-***************************************************************************/
-
-namespace internal {
-
-template<int Mode, typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
-inline void sparse_selfadjoint_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
-{
-  EIGEN_ONLY_USED_FOR_DEBUG(alpha);
-  
-  typedef typename internal::nested_eval<SparseLhsType,DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
-  typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
-  typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
-  typedef typename LhsEval::InnerIterator LhsIterator;
-  typedef typename SparseLhsType::Scalar LhsScalar;
-  
-  enum {
-    LhsIsRowMajor = (LhsEval::Flags&RowMajorBit)==RowMajorBit,
-    ProcessFirstHalf =
-              ((Mode&(Upper|Lower))==(Upper|Lower))
-          || ( (Mode&Upper) && !LhsIsRowMajor)
-          || ( (Mode&Lower) && LhsIsRowMajor),
-    ProcessSecondHalf = !ProcessFirstHalf
-  };
-  
-  SparseLhsTypeNested lhs_nested(lhs);
-  LhsEval lhsEval(lhs_nested);
-
-  // work on one column at once
-  for (Index k=0; k<rhs.cols(); ++k)
-  {
-    for (Index j=0; j<lhs.outerSize(); ++j)
-    {
-      LhsIterator i(lhsEval,j);
-      // handle diagonal coeff
-      if (ProcessSecondHalf)
-      {
-        while (i && i.index()<j) ++i;
-        if(i && i.index()==j)
-        {
-          res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
-          ++i;
-        }
-      }
-
-      // premultiplied rhs for scatters
-      typename ScalarBinaryOpTraits<AlphaType, typename DenseRhsType::Scalar>::ReturnType rhs_j(alpha*rhs(j,k));
-      // accumulator for partial scalar product
-      typename DenseResType::Scalar res_j(0);
-      for(; (ProcessFirstHalf ? i && i.index() < j : i) ; ++i)
-      {
-        LhsScalar lhs_ij = i.value();
-        if(!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
-        res_j += lhs_ij * rhs.coeff(i.index(),k);
-        res(i.index(),k) += numext::conj(lhs_ij) * rhs_j;
-      }
-      res.coeffRef(j,k) += alpha * res_j;
-
-      // handle diagonal coeff
-      if (ProcessFirstHalf && i && (i.index()==j))
-        res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
-    }
-  }
-}
-
-
-template<typename LhsView, typename Rhs, int ProductType>
-struct generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType>
-: generic_product_impl_base<LhsView, Rhs, generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType> >
-{
-  template<typename Dest>
-  static void scaleAndAddTo(Dest& dst, const LhsView& lhsView, const Rhs& rhs, const typename Dest::Scalar& alpha)
-  {
-    typedef typename LhsView::_MatrixTypeNested Lhs;
-    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
-    LhsNested lhsNested(lhsView.matrix());
-    RhsNested rhsNested(rhs);
-    
-    internal::sparse_selfadjoint_time_dense_product<LhsView::Mode>(lhsNested, rhsNested, dst, alpha);
-  }
-};
-
-template<typename Lhs, typename RhsView, int ProductType>
-struct generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType>
-: generic_product_impl_base<Lhs, RhsView, generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType> >
-{
-  template<typename Dest>
-  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const RhsView& rhsView, const typename Dest::Scalar& alpha)
-  {
-    typedef typename RhsView::_MatrixTypeNested Rhs;
-    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
-    LhsNested lhsNested(lhs);
-    RhsNested rhsNested(rhsView.matrix());
-    
-    // transpose everything
-    Transpose<Dest> dstT(dst);
-    internal::sparse_selfadjoint_time_dense_product<RhsView::TransposeMode>(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
-  }
-};
-
-// NOTE: these two overloads are needed to evaluate the sparse selfadjoint view into a full sparse matrix
-// TODO: maybe the copy could be handled by generic_product_impl so that these overloads would not be needed anymore
-
-template<typename LhsView, typename Rhs, int ProductTag>
-struct product_evaluator<Product<LhsView, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, SparseShape>
-  : public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject>
-{
-  typedef Product<LhsView, Rhs, DefaultProduct> XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
-
-  product_evaluator(const XprType& xpr)
-    : m_lhs(xpr.lhs()), m_result(xpr.rows(), xpr.cols())
-  {
-    ::new (static_cast<Base*>(this)) Base(m_result);
-    generic_product_impl<typename Rhs::PlainObject, Rhs, SparseShape, SparseShape, ProductTag>::evalTo(m_result, m_lhs, xpr.rhs());
-  }
-  
-protected:
-  typename Rhs::PlainObject m_lhs;
-  PlainObject m_result;
-};
-
-template<typename Lhs, typename RhsView, int ProductTag>
-struct product_evaluator<Product<Lhs, RhsView, DefaultProduct>, ProductTag, SparseShape, SparseSelfAdjointShape>
-  : public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject>
-{
-  typedef Product<Lhs, RhsView, DefaultProduct> XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
-
-  product_evaluator(const XprType& xpr)
-    : m_rhs(xpr.rhs()), m_result(xpr.rows(), xpr.cols())
-  {
-    ::new (static_cast<Base*>(this)) Base(m_result);
-    generic_product_impl<Lhs, typename Lhs::PlainObject, SparseShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), m_rhs);
-  }
-  
-protected:
-  typename Lhs::PlainObject m_rhs;
-  PlainObject m_result;
-};
-
-} // namespace internal
-
-/***************************************************************************
-* Implementation of symmetric copies and permutations
-***************************************************************************/
-namespace internal {
-
-template<int Mode,typename MatrixType,int DestOrder>
-void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
-{
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef SparseMatrix<Scalar,DestOrder,StorageIndex> Dest;
-  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
-  typedef evaluator<MatrixType> MatEval;
-  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
-  
-  MatEval matEval(mat);
-  Dest& dest(_dest.derived());
-  enum {
-    StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
-  };
-  
-  Index size = mat.rows();
-  VectorI count;
-  count.resize(size);
-  count.setZero();
-  dest.resize(size,size);
-  for(Index j = 0; j<size; ++j)
-  {
-    Index jp = perm ? perm[j] : j;
-    for(MatIterator it(matEval,j); it; ++it)
-    {
-      Index i = it.index();
-      Index r = it.row();
-      Index c = it.col();
-      Index ip = perm ? perm[i] : i;
-      if(Mode==int(Upper|Lower))
-        count[StorageOrderMatch ? jp : ip]++;
-      else if(r==c)
-        count[ip]++;
-      else if(( Mode==Lower && r>c) || ( Mode==Upper && r<c))
-      {
-        count[ip]++;
-        count[jp]++;
-      }
-    }
-  }
-  Index nnz = count.sum();
-  
-  // reserve space
-  dest.resizeNonZeros(nnz);
-  dest.outerIndexPtr()[0] = 0;
-  for(Index j=0; j<size; ++j)
-    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
-  for(Index j=0; j<size; ++j)
-    count[j] = dest.outerIndexPtr()[j];
-  
-  // copy data
-  for(StorageIndex j = 0; j<size; ++j)
-  {
-    for(MatIterator it(matEval,j); it; ++it)
-    {
-      StorageIndex i = internal::convert_index<StorageIndex>(it.index());
-      Index r = it.row();
-      Index c = it.col();
-      
-      StorageIndex jp = perm ? perm[j] : j;
-      StorageIndex ip = perm ? perm[i] : i;
-      
-      if(Mode==int(Upper|Lower))
-      {
-        Index k = count[StorageOrderMatch ? jp : ip]++;
-        dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
-        dest.valuePtr()[k] = it.value();
-      }
-      else if(r==c)
-      {
-        Index k = count[ip]++;
-        dest.innerIndexPtr()[k] = ip;
-        dest.valuePtr()[k] = it.value();
-      }
-      else if(( (Mode&Lower)==Lower && r>c) || ( (Mode&Upper)==Upper && r<c))
-      {
-        if(!StorageOrderMatch)
-          std::swap(ip,jp);
-        Index k = count[jp]++;
-        dest.innerIndexPtr()[k] = ip;
-        dest.valuePtr()[k] = it.value();
-        k = count[ip]++;
-        dest.innerIndexPtr()[k] = jp;
-        dest.valuePtr()[k] = numext::conj(it.value());
-      }
-    }
-  }
-}
-
-template<int _SrcMode,int _DstMode,typename MatrixType,int DstOrder>
-void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DstOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
-{
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef typename MatrixType::Scalar Scalar;
-  SparseMatrix<Scalar,DstOrder,StorageIndex>& dest(_dest.derived());
-  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
-  typedef evaluator<MatrixType> MatEval;
-  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
-
-  enum {
-    SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
-    StorageOrderMatch = int(SrcOrder) == int(DstOrder),
-    DstMode = DstOrder==RowMajor ? (_DstMode==Upper ? Lower : Upper) : _DstMode,
-    SrcMode = SrcOrder==RowMajor ? (_SrcMode==Upper ? Lower : Upper) : _SrcMode
-  };
-
-  MatEval matEval(mat);
-  
-  Index size = mat.rows();
-  VectorI count(size);
-  count.setZero();
-  dest.resize(size,size);
-  for(StorageIndex j = 0; j<size; ++j)
-  {
-    StorageIndex jp = perm ? perm[j] : j;
-    for(MatIterator it(matEval,j); it; ++it)
-    {
-      StorageIndex i = it.index();
-      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
-        continue;
-                  
-      StorageIndex ip = perm ? perm[i] : i;
-      count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
-    }
-  }
-  dest.outerIndexPtr()[0] = 0;
-  for(Index j=0; j<size; ++j)
-    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
-  dest.resizeNonZeros(dest.outerIndexPtr()[size]);
-  for(Index j=0; j<size; ++j)
-    count[j] = dest.outerIndexPtr()[j];
-  
-  for(StorageIndex j = 0; j<size; ++j)
-  {
-    
-    for(MatIterator it(matEval,j); it; ++it)
-    {
-      StorageIndex i = it.index();
-      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
-        continue;
-                  
-      StorageIndex jp = perm ? perm[j] : j;
-      StorageIndex ip = perm? perm[i] : i;
-      
-      Index k = count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
-      dest.innerIndexPtr()[k] = int(DstMode)==int(Lower) ? (std::max)(ip,jp) : (std::min)(ip,jp);
-      
-      if(!StorageOrderMatch) std::swap(ip,jp);
-      if( ((int(DstMode)==int(Lower) && ip<jp) || (int(DstMode)==int(Upper) && ip>jp)))
-        dest.valuePtr()[k] = numext::conj(it.value());
-      else
-        dest.valuePtr()[k] = it.value();
-    }
-  }
-}
-
-}
-
-// TODO implement twists in a more evaluator friendly fashion
-
-namespace internal {
-
-template<typename MatrixType, int Mode>
-struct traits<SparseSymmetricPermutationProduct<MatrixType,Mode> > : traits<MatrixType> {
-};
-
-}
-
-template<typename MatrixType,int Mode>
-class SparseSymmetricPermutationProduct
-  : public EigenBase<SparseSymmetricPermutationProduct<MatrixType,Mode> >
-{
-  public:
-    typedef typename MatrixType::Scalar Scalar;
-    typedef typename MatrixType::StorageIndex StorageIndex;
-    enum {
-      RowsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::RowsAtCompileTime,
-      ColsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::ColsAtCompileTime
-    };
-  protected:
-    typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> Perm;
-  public:
-    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
-    typedef typename MatrixType::Nested MatrixTypeNested;
-    typedef typename internal::remove_all<MatrixTypeNested>::type NestedExpression;
-    
-    SparseSymmetricPermutationProduct(const MatrixType& mat, const Perm& perm)
-      : m_matrix(mat), m_perm(perm)
-    {}
-    
-    inline Index rows() const { return m_matrix.rows(); }
-    inline Index cols() const { return m_matrix.cols(); }
-        
-    const NestedExpression& matrix() const { return m_matrix; }
-    const Perm& perm() const { return m_perm; }
-    
-  protected:
-    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
-
-#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H