Home | History | Annotate | Download | only in SparseCore 
      1 // This file is part of Eigen, a lightweight C++ template library
      2 // for linear algebra.
      3 //
      4 // Copyright (C) 2012 Gael Guennebaud <gael.guennebaud (at) inria.fr>
      5 //
      6 // This Source Code Form is subject to the terms of the Mozilla
      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/.
      9 
     10 #ifndef EIGEN_SPARSE_PERMUTATION_H
     11 #define EIGEN_SPARSE_PERMUTATION_H
     12 
     13 // This file implements sparse * permutation products
     14 
     15 namespace Eigen {
     16 
     17 namespace internal {
     18 
     19 template<typename ExpressionType, int Side, bool Transposed>
     20 struct permutation_matrix_product<ExpressionType, Side, Transposed, SparseShape>
     21 {
     22     typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
     23     typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
     24 
     25     typedef typename MatrixTypeCleaned::Scalar Scalar;
     26     typedef typename MatrixTypeCleaned::StorageIndex StorageIndex;
     27 
     28     enum {
     29       SrcStorageOrder = MatrixTypeCleaned::Flags&RowMajorBit ? RowMajor : ColMajor,
     30       MoveOuter = SrcStorageOrder==RowMajor ? Side==OnTheLeft : Side==OnTheRight
     31     };
     32 
     33     typedef typename internal::conditional<MoveOuter,
     34         SparseMatrix<Scalar,SrcStorageOrder,StorageIndex>,
     35         SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> >::type ReturnType;
     36 
     37     template<typename Dest,typename PermutationType>
     38     static inline void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
     39     {
     40       MatrixType mat(xpr);
     41       if(MoveOuter)
     42       {
     43         SparseMatrix<Scalar,SrcStorageOrder,StorageIndex> tmp(mat.rows(), mat.cols());
     44         Matrix<StorageIndex,Dynamic,1> sizes(mat.outerSize());
     45         for(Index j=0; j<mat.outerSize(); ++j)
     46         {
     47           Index jp = perm.indices().coeff(j);
     48           sizes[((Side==OnTheLeft) ^ Transposed) ? jp : j] = StorageIndex(mat.innerVector(((Side==OnTheRight) ^ Transposed) ? jp : j).nonZeros());
     49         }
     50         tmp.reserve(sizes);
     51         for(Index j=0; j<mat.outerSize(); ++j)
     52         {
     53           Index jp = perm.indices().coeff(j);
     54           Index jsrc = ((Side==OnTheRight) ^ Transposed) ? jp : j;
     55           Index jdst = ((Side==OnTheLeft) ^ Transposed) ? jp : j;
     56           for(typename MatrixTypeCleaned::InnerIterator it(mat,jsrc); it; ++it)
     57             tmp.insertByOuterInner(jdst,it.index()) = it.value();
     58         }
     59         dst = tmp;
     60       }
     61       else
     62       {
     63         SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> tmp(mat.rows(), mat.cols());
     64         Matrix<StorageIndex,Dynamic,1> sizes(tmp.outerSize());
     65         sizes.setZero();
     66         PermutationMatrix<Dynamic,Dynamic,StorageIndex> perm_cpy;
     67         if((Side==OnTheLeft) ^ Transposed)
     68           perm_cpy = perm;
     69         else
     70           perm_cpy = perm.transpose();
     71 
     72         for(Index j=0; j<mat.outerSize(); ++j)
     73           for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
     74             sizes[perm_cpy.indices().coeff(it.index())]++;
     75         tmp.reserve(sizes);
     76         for(Index j=0; j<mat.outerSize(); ++j)
     77           for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
     78             tmp.insertByOuterInner(perm_cpy.indices().coeff(it.index()),j) = it.value();
     79         dst = tmp;
     80       }
     81     }
     82 };
     83 
     84 }
     85 
     86 namespace internal {
     87 
     88 template <int ProductTag> struct product_promote_storage_type<Sparse,             PermutationStorage, ProductTag> { typedef Sparse ret; };
     89 template <int ProductTag> struct product_promote_storage_type<PermutationStorage, Sparse,             ProductTag> { typedef Sparse ret; };
     90 
     91 // TODO, the following two overloads are only needed to define the right temporary type through
     92 // typename traits<permutation_sparse_matrix_product<Rhs,Lhs,OnTheRight,false> >::ReturnType
     93 // whereas it should be correctly handled by traits<Product<> >::PlainObject
     94 
     95 template<typename Lhs, typename Rhs, int ProductTag>
     96 struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, PermutationShape, SparseShape>
     97   : public evaluator<typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType>
     98 {
     99   typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
    100   typedef typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType PlainObject;
    101   typedef evaluator<PlainObject> Base;
    102 
    103   enum {
    104     Flags = Base::Flags | EvalBeforeNestingBit
    105   };
    106 
    107   explicit product_evaluator(const XprType& xpr)
    108     : m_result(xpr.rows(), xpr.cols())
    109   {
    110     ::new (static_cast<Base*>(this)) Base(m_result);
    111     generic_product_impl<Lhs, Rhs, PermutationShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
    112   }
    113 
    114 protected:
    115   PlainObject m_result;
    116 };
    117 
    118 template<typename Lhs, typename Rhs, int ProductTag>
    119 struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, SparseShape, PermutationShape >
    120   : public evaluator<typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType>
    121 {
    122   typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
    123   typedef typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType PlainObject;
    124   typedef evaluator<PlainObject> Base;
    125 
    126   enum {
    127     Flags = Base::Flags | EvalBeforeNestingBit
    128   };
    129 
    130   explicit product_evaluator(const XprType& xpr)
    131     : m_result(xpr.rows(), xpr.cols())
    132   {
    133     ::new (static_cast<Base*>(this)) Base(m_result);
    134     generic_product_impl<Lhs, Rhs, SparseShape, PermutationShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
    135   }
    136 
    137 protected:
    138   PlainObject m_result;
    139 };
    140 
    141 } // end namespace internal
    142 
    143 /** \returns the matrix with the permutation applied to the columns
    144   */
    145 template<typename SparseDerived, typename PermDerived>
    146 inline const Product<SparseDerived, PermDerived, AliasFreeProduct>
    147 operator*(const SparseMatrixBase<SparseDerived>& matrix, const PermutationBase<PermDerived>& perm)
    148 { return Product<SparseDerived, PermDerived, AliasFreeProduct>(matrix.derived(), perm.derived()); }
    149 
    150 /** \returns the matrix with the permutation applied to the rows
    151   */
    152 template<typename SparseDerived, typename PermDerived>
    153 inline const Product<PermDerived, SparseDerived, AliasFreeProduct>
    154 operator*( const PermutationBase<PermDerived>& perm, const SparseMatrixBase<SparseDerived>& matrix)
    155 { return  Product<PermDerived, SparseDerived, AliasFreeProduct>(perm.derived(), matrix.derived()); }
    156 
    157 
    158 /** \returns the matrix with the inverse permutation applied to the columns.
    159   */
    160 template<typename SparseDerived, typename PermutationType>
    161 inline const Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>
    162 operator*(const SparseMatrixBase<SparseDerived>& matrix, const InverseImpl<PermutationType, PermutationStorage>& tperm)
    163 {
    164   return Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>(matrix.derived(), tperm.derived());
    165 }
    166 
    167 /** \returns the matrix with the inverse permutation applied to the rows.
    168   */
    169 template<typename SparseDerived, typename PermutationType>
    170 inline const Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>
    171 operator*(const InverseImpl<PermutationType,PermutationStorage>& tperm, const SparseMatrixBase<SparseDerived>& matrix)
    172 {
    173   return Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>(tperm.derived(), matrix.derived());
    174 }
    175 
    176 } // end namespace Eigen
    177 
    178 #endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
    179