sequenzo 0.1.18__cp39-cp39-macosx_10_9_universal2.whl → 0.1.20__cp39-cp39-macosx_10_9_universal2.whl

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/SparseCore/SparseProduct.h

@@ -1,181 +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_SPARSEPRODUCT_H
-#define EIGEN_SPARSEPRODUCT_H
-
-namespace Eigen { 
-
-/** \returns an expression of the product of two sparse matrices.
-  * By default a conservative product preserving the symbolic non zeros is performed.
-  * The automatic pruning of the small values can be achieved by calling the pruned() function
-  * in which case a totally different product algorithm is employed:
-  * \code
-  * C = (A*B).pruned();             // suppress numerical zeros (exact)
-  * C = (A*B).pruned(ref);
-  * C = (A*B).pruned(ref,epsilon);
-  * \endcode
-  * where \c ref is a meaningful non zero reference value.
-  * */
-template<typename Derived>
-template<typename OtherDerived>
-inline const Product<Derived,OtherDerived,AliasFreeProduct>
-SparseMatrixBase<Derived>::operator*(const SparseMatrixBase<OtherDerived> &other) const
-{
-  return Product<Derived,OtherDerived,AliasFreeProduct>(derived(), other.derived());
-}
-
-namespace internal {
-
-// sparse * sparse
-template<typename Lhs, typename Rhs, int ProductType>
-struct generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
-{
-  template<typename Dest>
-  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
-  {
-    evalTo(dst, lhs, rhs, typename evaluator_traits<Dest>::Shape());
-  }
-
-  // dense += sparse * sparse
-  template<typename Dest,typename ActualLhs>
-  static void addTo(Dest& dst, const ActualLhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
-  {
-    typedef typename nested_eval<ActualLhs,Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
-    LhsNested lhsNested(lhs);
-    RhsNested rhsNested(rhs);
-    internal::sparse_sparse_to_dense_product_selector<typename remove_all<LhsNested>::type,
-                                                      typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
-  }
-
-  // dense -= sparse * sparse
-  template<typename Dest>
-  static void subTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
-  {
-    addTo(dst, -lhs, rhs);
-  }
-
-protected:
-
-  // sparse = sparse * sparse
-  template<typename Dest>
-  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, SparseShape)
-  {
-    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
-    LhsNested lhsNested(lhs);
-    RhsNested rhsNested(rhs);
-    internal::conservative_sparse_sparse_product_selector<typename remove_all<LhsNested>::type,
-                                                          typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
-  }
-
-  // dense = sparse * sparse
-  template<typename Dest>
-  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, DenseShape)
-  {
-    dst.setZero();
-    addTo(dst, lhs, rhs);
-  }
-};
-
-// sparse * sparse-triangular
-template<typename Lhs, typename Rhs, int ProductType>
-struct generic_product_impl<Lhs, Rhs, SparseShape, SparseTriangularShape, ProductType>
- : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
-{};
-
-// 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> &)
-  {
-    Index dstRows = src.rows();
-    Index dstCols = src.cols();
-    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
-      dst.resize(dstRows, dstCols);
-    
-    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>
-{
-  typedef SparseView<Product<Lhs, Rhs, Options> > XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
-
-  explicit unary_evaluator(const XprType& xpr)
-    : m_result(xpr.rows(), xpr.cols())
-  {
-    using std::abs;
-    ::new (static_cast<Base*>(this)) Base(m_result);
-    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
-    LhsNested lhsNested(xpr.nestedExpression().lhs());
-    RhsNested rhsNested(xpr.nestedExpression().rhs());
-
-    internal::sparse_sparse_product_with_pruning_selector<typename remove_all<LhsNested>::type,
-                                                          typename remove_all<RhsNested>::type, PlainObject>::run(lhsNested,rhsNested,m_result,
-                                                                                                                  abs(xpr.reference())*xpr.epsilon());
-  }
-
-protected:
-  PlainObject m_result;
-};
-
-} // end namespace internal
-
-// sparse matrix = sparse-product (can be sparse*sparse, sparse*perm, etc.)
-template<typename Scalar, int _Options, typename _StorageIndex>
-template<typename Lhs, typename Rhs>
-SparseMatrix<Scalar,_Options,_StorageIndex>& SparseMatrix<Scalar,_Options,_StorageIndex>::operator=(const Product<Lhs,Rhs,AliasFreeProduct>& src)
-{
-  // std::cout << "in Assignment : " << DstOptions << "\n";
-  SparseMatrix dst(src.rows(),src.cols());
-  internal::generic_product_impl<Lhs, Rhs>::evalTo(dst,src.lhs(),src.rhs());
-  this->swap(dst);
-  return *this;
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSEPRODUCT_H

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/SparseCore/SparseRedux.h

@@ -1,49 +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_SPARSEREDUX_H
-#define EIGEN_SPARSEREDUX_H
-
-namespace Eigen { 
-
-template<typename Derived>
-typename internal::traits<Derived>::Scalar
-SparseMatrixBase<Derived>::sum() const
-{
-  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
-  Scalar res(0);
-  internal::evaluator<Derived> thisEval(derived());
-  for (Index j=0; j<outerSize(); ++j)
-    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
-      res += iter.value();
-  return res;
-}
-
-template<typename _Scalar, int _Options, typename _Index>
-typename internal::traits<SparseMatrix<_Scalar,_Options,_Index> >::Scalar
-SparseMatrix<_Scalar,_Options,_Index>::sum() const
-{
-  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
-  if(this->isCompressed())
-    return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
-  else
-    return Base::sum();
-}
-
-template<typename _Scalar, int _Options, typename _Index>
-typename internal::traits<SparseVector<_Scalar,_Options, _Index> >::Scalar
-SparseVector<_Scalar,_Options,_Index>::sum() const
-{
-  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
-  return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSEREDUX_H

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/SparseCore/SparseRef.h

@@ -1,397 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 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_SPARSE_REF_H
-#define EIGEN_SPARSE_REF_H
-
-namespace Eigen {
-
-enum {
-  StandardCompressedFormat = 2 /**< used by Ref<SparseMatrix> to specify whether the input storage must be in standard compressed form */
-};
-  
-namespace internal {
-
-template<typename Derived> class SparseRefBase;
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
-struct traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
-  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
-{
-  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
-  enum {
-    Options = _Options,
-    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
-  };
-
-  template<typename Derived> struct match {
-    enum {
-      StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
-      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && StorageOrderMatch
-    };
-    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
-  };
-  
-};
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
-struct traits<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
-  : public traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
-{
-  enum {
-    Flags = (traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
-  };
-};
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
-struct traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
-  : public traits<SparseVector<MatScalar,MatOptions,MatIndex> >
-{
-  typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
-  enum {
-    Options = _Options,
-    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
-  };
-
-  template<typename Derived> struct match {
-    enum {
-      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && Derived::IsVectorAtCompileTime
-    };
-    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
-  };
-
-};
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
-struct traits<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
-  : public traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
-{
-  enum {
-    Flags = (traits<SparseVector<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
-  };
-};
-
-template<typename Derived>
-struct traits<SparseRefBase<Derived> > : public traits<Derived> {};
-
-template<typename Derived> class SparseRefBase
-  : public SparseMapBase<Derived>
-{
-public:
-
-  typedef SparseMapBase<Derived> Base;
-  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseRefBase)
-
-  SparseRefBase()
-    : Base(RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime, 0, 0, 0, 0, 0)
-  {}
-  
-protected:
-
-  template<typename Expression>
-  void construct(Expression& expr)
-  {
-    if(expr.outerIndexPtr()==0)
-      ::new (static_cast<Base*>(this)) Base(expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr());
-    else
-      ::new (static_cast<Base*>(this)) Base(expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(), expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr());
-  }
-};
-
-} // namespace internal
-
-
-/** 
-  * \ingroup SparseCore_Module
-  *
-  * \brief A sparse matrix expression referencing an existing sparse expression
-  *
-  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix.
-  * \tparam Options specifies whether the a standard compressed format is required \c Options is  \c #StandardCompressedFormat, or \c 0.
-  *                The default is \c 0.
-  *
-  * \sa class Ref
-  */
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType >
-  : public internal::SparseRefBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
-#else
-template<typename SparseMatrixType, int Options>
-class Ref<SparseMatrixType, Options>
-  : public SparseMapBase<Derived,WriteAccessors> // yes, that's weird to use Derived here, but that works!
-#endif
-{
-    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
-    typedef internal::traits<Ref> Traits;
-    template<int OtherOptions>
-    inline Ref(const SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
-    template<int OtherOptions>
-    inline Ref(const MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
-  public:
-
-    typedef internal::SparseRefBase<Ref> Base;
-    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
-
-
-    #ifndef EIGEN_PARSED_BY_DOXYGEN
-    template<int OtherOptions>
-    inline Ref(SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
-    {
-      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
-      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
-      Base::construct(expr.derived());
-    }
-    
-    template<int OtherOptions>
-    inline Ref(MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
-    {
-      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
-      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
-      Base::construct(expr.derived());
-    }
-    
-    template<typename Derived>
-    inline Ref(const SparseCompressedBase<Derived>& expr)
-    #else
-    /** Implicit constructor from any sparse expression (2D matrix or 1D vector) */
-    template<typename Derived>
-    inline Ref(SparseCompressedBase<Derived>& expr)
-    #endif
-    {
-      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
-      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
-      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
-      Base::construct(expr.const_cast_derived());
-    }
-};
-
-// this is the const ref version
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-class Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
-  : public internal::SparseRefBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
-{
-    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> TPlainObjectType;
-    typedef internal::traits<Ref> Traits;
-  public:
-
-    typedef internal::SparseRefBase<Ref> Base;
-    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
-
-    template<typename Derived>
-    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
-    {
-      construct(expr.derived(), typename Traits::template match<Derived>::type());
-    }
-
-    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
-      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
-    }
-
-    template<typename OtherRef>
-    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
-      construct(other.derived(), typename Traits::template match<OtherRef>::type());
-    }
-
-    ~Ref() {
-      if(m_hasCopy) {
-        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
-        obj->~TPlainObjectType();
-      }
-    }
-
-  protected:
-
-    template<typename Expression>
-    void construct(const Expression& expr,internal::true_type)
-    {
-      if((Options & int(StandardCompressedFormat)) && (!expr.isCompressed()))
-      {
-        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
-        ::new (obj) TPlainObjectType(expr);
-        m_hasCopy = true;
-        Base::construct(*obj);
-      }
-      else
-      {
-        Base::construct(expr);
-      }
-    }
-
-    template<typename Expression>
-    void construct(const Expression& expr, internal::false_type)
-    {
-      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
-      ::new (obj) TPlainObjectType(expr);
-      m_hasCopy = true;
-      Base::construct(*obj);
-    }
-
-  protected:
-    typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
-    bool m_hasCopy;
-};
-
-
-
-/**
-  * \ingroup SparseCore_Module
-  *
-  * \brief A sparse vector expression referencing an existing sparse vector expression
-  *
-  * \tparam SparseVectorType the equivalent sparse vector type of the referenced data, it must be a template instance of class SparseVector.
-  *
-  * \sa class Ref
-  */
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-class Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType >
-  : public internal::SparseRefBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
-#else
-template<typename SparseVectorType>
-class Ref<SparseVectorType>
-  : public SparseMapBase<Derived,WriteAccessors>
-#endif
-{
-    typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
-    typedef internal::traits<Ref> Traits;
-    template<int OtherOptions>
-    inline Ref(const SparseVector<MatScalar,OtherOptions,MatIndex>& expr);
-  public:
-
-    typedef internal::SparseRefBase<Ref> Base;
-    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
-
-    #ifndef EIGEN_PARSED_BY_DOXYGEN
-    template<int OtherOptions>
-    inline Ref(SparseVector<MatScalar,OtherOptions,MatIndex>& expr)
-    {
-      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseVector<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
-      Base::construct(expr.derived());
-    }
-
-    template<typename Derived>
-    inline Ref(const SparseCompressedBase<Derived>& expr)
-    #else
-    /** Implicit constructor from any 1D sparse vector expression */
-    template<typename Derived>
-    inline Ref(SparseCompressedBase<Derived>& expr)
-    #endif
-    {
-      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
-      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
-      Base::construct(expr.const_cast_derived());
-    }
-};
-
-// this is the const ref version
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-class Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType>
-  : public internal::SparseRefBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
-{
-    typedef SparseVector<MatScalar,MatOptions,MatIndex> TPlainObjectType;
-    typedef internal::traits<Ref> Traits;
-  public:
-
-    typedef internal::SparseRefBase<Ref> Base;
-    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
-
-    template<typename Derived>
-    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
-    {
-      construct(expr.derived(), typename Traits::template match<Derived>::type());
-    }
-
-    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
-      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
-    }
-
-    template<typename OtherRef>
-    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
-      construct(other.derived(), typename Traits::template match<OtherRef>::type());
-    }
-
-    ~Ref() {
-      if(m_hasCopy) {
-        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
-        obj->~TPlainObjectType();
-      }
-    }
-
-  protected:
-
-    template<typename Expression>
-    void construct(const Expression& expr,internal::true_type)
-    {
-      Base::construct(expr);
-    }
-
-    template<typename Expression>
-    void construct(const Expression& expr, internal::false_type)
-    {
-      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
-      ::new (obj) TPlainObjectType(expr);
-      m_hasCopy = true;
-      Base::construct(*obj);
-    }
-
-  protected:
-    typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
-    bool m_hasCopy;
-};
-
-namespace internal {
-
-// FIXME shall we introduce a general evaluatior_ref that we can specialize for any sparse object once, and thus remove this copy-pasta thing...
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-struct evaluator<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
-  : evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
-{
-  typedef evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
-  typedef Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
-  evaluator() : Base() {}
-  explicit evaluator(const XprType &mat) : Base(mat) {}
-};
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-struct evaluator<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
-  : evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
-{
-  typedef evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
-  typedef Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
-  evaluator() : Base() {}
-  explicit evaluator(const XprType &mat) : Base(mat) {}
-};
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-struct evaluator<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
-  : evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
-{
-  typedef evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
-  typedef Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
-  explicit evaluator(const XprType &mat) : Base(mat) {}
-};
-
-template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
-struct evaluator<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
-  : evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
-{
-  typedef evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
-  typedef Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
-  explicit evaluator(const XprType &mat) : Base(mat) {}
-};
-
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSE_REF_H