casadi 3.6.4__cp39-none-manylinux2014_x86_64.whl → 3.6.6__cp39-none-manylinux2014_x86_64.whl

casadi/include/include/eigen3/unsupported/Eigen/src/SparseExtra/DynamicSparseMatrix.h

@@ -1,404 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 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_DYNAMIC_SPARSEMATRIX_H
-#define EIGEN_DYNAMIC_SPARSEMATRIX_H
-
-namespace Eigen { 
-
-/** \deprecated use a SparseMatrix in an uncompressed mode
-  *
-  * \class DynamicSparseMatrix
-  *
-  * \brief A sparse matrix class designed for matrix assembly purpose
-  *
-  * \param _Scalar the scalar type, i.e. the type of the coefficients
-  *
-  * Unlike SparseMatrix, this class provides a much higher degree of flexibility. In particular, it allows
-  * random read/write accesses in log(rho*outer_size) where \c rho is the probability that a coefficient is
-  * nonzero and outer_size is the number of columns if the matrix is column-major and the number of rows
-  * otherwise.
-  *
-  * Internally, the data are stored as a std::vector of compressed vector. The performances of random writes might
-  * decrease as the number of nonzeros per inner-vector increase. In practice, we observed very good performance
-  * till about 100 nonzeros/vector, and the performance remains relatively good till 500 nonzeros/vectors.
-  *
-  * \see SparseMatrix
-  */
-
-namespace internal {
-template<typename _Scalar, int _Options, typename _StorageIndex>
-struct traits<DynamicSparseMatrix<_Scalar, _Options, _StorageIndex> >
-{
-  typedef _Scalar Scalar;
-  typedef _StorageIndex StorageIndex;
-  typedef Sparse StorageKind;
-  typedef MatrixXpr XprKind;
-  enum {
-    RowsAtCompileTime = Dynamic,
-    ColsAtCompileTime = Dynamic,
-    MaxRowsAtCompileTime = Dynamic,
-    MaxColsAtCompileTime = Dynamic,
-    Flags = _Options | NestByRefBit | LvalueBit,
-    CoeffReadCost = NumTraits<Scalar>::ReadCost,
-    SupportedAccessPatterns = OuterRandomAccessPattern
-  };
-};
-}
-
-template<typename _Scalar, int _Options, typename _StorageIndex>
- class  DynamicSparseMatrix
-  : public SparseMatrixBase<DynamicSparseMatrix<_Scalar, _Options, _StorageIndex> >
-{
-    typedef SparseMatrixBase<DynamicSparseMatrix> Base;
-    using Base::convert_index;
-  public:
-    EIGEN_SPARSE_PUBLIC_INTERFACE(DynamicSparseMatrix)
-    // FIXME: why are these operator already alvailable ???
-    // EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(DynamicSparseMatrix, +=)
-    // EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(DynamicSparseMatrix, -=)
-    typedef MappedSparseMatrix<Scalar,Flags> Map;
-    using Base::IsRowMajor;
-    using Base::operator=;
-    enum {
-      Options = _Options
-    };
-
-  protected:
-
-    typedef DynamicSparseMatrix<Scalar,(Flags&~RowMajorBit)|(IsRowMajor?RowMajorBit:0), StorageIndex> TransposedSparseMatrix;
-
-    Index m_innerSize;
-    std::vector<internal::CompressedStorage<Scalar,StorageIndex> > m_data;
-
-  public:
-
-    inline Index rows() const { return IsRowMajor ? outerSize() : m_innerSize; }
-    inline Index cols() const { return IsRowMajor ? m_innerSize : outerSize(); }
-    inline Index innerSize() const { return m_innerSize; }
-    inline Index outerSize() const { return convert_index(m_data.size()); }
-    inline Index innerNonZeros(Index j) const { return m_data[j].size(); }
-
-    std::vector<internal::CompressedStorage<Scalar,StorageIndex> >& _data() { return m_data; }
-    const std::vector<internal::CompressedStorage<Scalar,StorageIndex> >& _data() const { return m_data; }
-
-    /** \returns the coefficient value at given position \a row, \a col
-      * This operation involes a log(rho*outer_size) binary search.
-      */
-    inline Scalar coeff(Index row, Index col) const
-    {
-      const Index outer = IsRowMajor ? row : col;
-      const Index inner = IsRowMajor ? col : row;
-      return m_data[outer].at(inner);
-    }
-
-    /** \returns a reference to the coefficient value at given position \a row, \a col
-      * This operation involes a log(rho*outer_size) binary search. If the coefficient does not
-      * exist yet, then a sorted insertion into a sequential buffer is performed.
-      */
-    inline Scalar& coeffRef(Index row, Index col)
-    {
-      const Index outer = IsRowMajor ? row : col;
-      const Index inner = IsRowMajor ? col : row;
-      return m_data[outer].atWithInsertion(inner);
-    }
-
-    class InnerIterator;
-    class ReverseInnerIterator;
-
-    void setZero()
-    {
-      for (Index j=0; j<outerSize(); ++j)
-        m_data[j].clear();
-    }
-
-    /** \returns the number of non zero coefficients */
-    Index nonZeros() const
-    {
-      Index res = 0;
-      for (Index j=0; j<outerSize(); ++j)
-        res += m_data[j].size();
-      return res;
-    }
-
-
-
-    void reserve(Index reserveSize = 1000)
-    {
-      if (outerSize()>0)
-      {
-        Index reserveSizePerVector = (std::max)(reserveSize/outerSize(),Index(4));
-        for (Index j=0; j<outerSize(); ++j)
-        {
-          m_data[j].reserve(reserveSizePerVector);
-        }
-      }
-    }
-
-    /** Does nothing: provided for compatibility with SparseMatrix */
-    inline void startVec(Index /*outer*/) {}
-
-    /** \returns a reference to the non zero coefficient at position \a row, \a col assuming that:
-      * - the nonzero does not already exist
-      * - the new coefficient is the last one of the given inner vector.
-      *
-      * \sa insert, insertBackByOuterInner */
-    inline Scalar& insertBack(Index row, Index col)
-    {
-      return insertBackByOuterInner(IsRowMajor?row:col, IsRowMajor?col:row);
-    }
-
-    /** \sa insertBack */
-    inline Scalar& insertBackByOuterInner(Index outer, Index inner)
-    {
-      eigen_assert(outer<Index(m_data.size()) && inner<m_innerSize && "out of range");
-      eigen_assert(((m_data[outer].size()==0) || (m_data[outer].index(m_data[outer].size()-1)<inner))
-                && "wrong sorted insertion");
-      m_data[outer].append(0, inner);
-      return m_data[outer].value(m_data[outer].size()-1);
-    }
-
-    inline Scalar& insert(Index row, Index col)
-    {
-      const Index outer = IsRowMajor ? row : col;
-      const Index inner = IsRowMajor ? col : row;
-
-      Index startId = 0;
-      Index id = static_cast<Index>(m_data[outer].size()) - 1;
-      m_data[outer].resize(id+2,1);
-
-      while ( (id >= startId) && (m_data[outer].index(id) > inner) )
-      {
-        m_data[outer].index(id+1) = m_data[outer].index(id);
-        m_data[outer].value(id+1) = m_data[outer].value(id);
-        --id;
-      }
-      m_data[outer].index(id+1) = inner;
-      m_data[outer].value(id+1) = 0;
-      return m_data[outer].value(id+1);
-    }
-
-    /** Does nothing: provided for compatibility with SparseMatrix */
-    inline void finalize() {}
-
-    /** Suppress all nonzeros which are smaller than \a reference under the tolerance \a epsilon */
-    void prune(Scalar reference, RealScalar epsilon = NumTraits<RealScalar>::dummy_precision())
-    {
-      for (Index j=0; j<outerSize(); ++j)
-        m_data[j].prune(reference,epsilon);
-    }
-
-    /** Resize the matrix without preserving the data (the matrix is set to zero)
-      */
-    void resize(Index rows, Index cols)
-    {
-      const Index outerSize = IsRowMajor ? rows : cols;
-      m_innerSize = convert_index(IsRowMajor ? cols : rows);
-      setZero();
-      if (Index(m_data.size()) != outerSize)
-      {
-        m_data.resize(outerSize);
-      }
-    }
-
-    void resizeAndKeepData(Index rows, Index cols)
-    {
-      const Index outerSize = IsRowMajor ? rows : cols;
-      const Index innerSize = IsRowMajor ? cols : rows;
-      if (m_innerSize>innerSize)
-      {
-        // remove all coefficients with innerCoord>=innerSize
-        // TODO
-        //std::cerr << "not implemented yet\n";
-        exit(2);
-      }
-      if (m_data.size() != outerSize)
-      {
-        m_data.resize(outerSize);
-      }
-    }
-
-    /** The class DynamicSparseMatrix is deprecated */
-    EIGEN_DEPRECATED inline DynamicSparseMatrix()
-      : m_innerSize(0), m_data(0)
-    {
-      #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-        EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-      #endif
-      eigen_assert(innerSize()==0 && outerSize()==0);
-    }
-
-    /** The class DynamicSparseMatrix is deprecated */
-    EIGEN_DEPRECATED inline DynamicSparseMatrix(Index rows, Index cols)
-      : m_innerSize(0)
-    {
-      #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-        EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-      #endif
-      resize(rows, cols);
-    }
-
-    /** The class DynamicSparseMatrix is deprecated */
-    template<typename OtherDerived>
-    EIGEN_DEPRECATED explicit inline DynamicSparseMatrix(const SparseMatrixBase<OtherDerived>& other)
-      : m_innerSize(0)
-    {
-      #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-        EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-      #endif
-      Base::operator=(other.derived());
-    }
-
-    inline DynamicSparseMatrix(const DynamicSparseMatrix& other)
-      : Base(), m_innerSize(0)
-    {
-      #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-        EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
-      #endif
-      *this = other.derived();
-    }
-
-    inline void swap(DynamicSparseMatrix& other)
-    {
-      //EIGEN_DBG_SPARSE(std::cout << "SparseMatrix:: swap\n");
-      std::swap(m_innerSize, other.m_innerSize);
-      //std::swap(m_outerSize, other.m_outerSize);
-      m_data.swap(other.m_data);
-    }
-
-    inline DynamicSparseMatrix& operator=(const DynamicSparseMatrix& other)
-    {
-      if (other.isRValue())
-      {
-        swap(other.const_cast_derived());
-      }
-      else
-      {
-        resize(other.rows(), other.cols());
-        m_data = other.m_data;
-      }
-      return *this;
-    }
-
-    /** Destructor */
-    inline ~DynamicSparseMatrix() {}
-
-  public:
-
-    /** \deprecated
-      * Set the matrix to zero and reserve the memory for \a reserveSize nonzero coefficients. */
-    EIGEN_DEPRECATED void startFill(Index reserveSize = 1000)
-    {
-      setZero();
-      reserve(reserveSize);
-    }
-
-    /** \deprecated use insert()
-      * inserts a nonzero coefficient at given coordinates \a row, \a col and returns its reference assuming that:
-      *  1 - the coefficient does not exist yet
-      *  2 - this the coefficient with greater inner coordinate for the given outer coordinate.
-      * In other words, assuming \c *this is column-major, then there must not exists any nonzero coefficient of coordinates
-      * \c i \c x \a col such that \c i >= \a row. Otherwise the matrix is invalid.
-      *
-      * \see fillrand(), coeffRef()
-      */
-    EIGEN_DEPRECATED Scalar& fill(Index row, Index col)
-    {
-      const Index outer = IsRowMajor ? row : col;
-      const Index inner = IsRowMajor ? col : row;
-      return insertBack(outer,inner);
-    }
-
-    /** \deprecated use insert()
-      * Like fill() but with random inner coordinates.
-      * Compared to the generic coeffRef(), the unique limitation is that we assume
-      * the coefficient does not exist yet.
-      */
-    EIGEN_DEPRECATED Scalar& fillrand(Index row, Index col)
-    {
-      return insert(row,col);
-    }
-
-    /** \deprecated use finalize()
-      * Does nothing. Provided for compatibility with SparseMatrix. */
-    EIGEN_DEPRECATED void endFill() {}
-    
-#   ifdef EIGEN_DYNAMICSPARSEMATRIX_PLUGIN
-#     include EIGEN_DYNAMICSPARSEMATRIX_PLUGIN
-#   endif
- };
-
-template<typename Scalar, int _Options, typename _StorageIndex>
-class DynamicSparseMatrix<Scalar,_Options,_StorageIndex>::InnerIterator : public SparseVector<Scalar,_Options,_StorageIndex>::InnerIterator
-{
-    typedef typename SparseVector<Scalar,_Options,_StorageIndex>::InnerIterator Base;
-  public:
-    InnerIterator(const DynamicSparseMatrix& mat, Index outer)
-      : Base(mat.m_data[outer]), m_outer(outer)
-    {}
-
-    inline Index row() const { return IsRowMajor ? m_outer : Base::index(); }
-    inline Index col() const { return IsRowMajor ? Base::index() : m_outer; }
-    inline Index outer() const { return m_outer; }
-
-  protected:
-    const Index m_outer;
-};
-
-template<typename Scalar, int _Options, typename _StorageIndex>
-class DynamicSparseMatrix<Scalar,_Options,_StorageIndex>::ReverseInnerIterator : public SparseVector<Scalar,_Options,_StorageIndex>::ReverseInnerIterator
-{
-    typedef typename SparseVector<Scalar,_Options,_StorageIndex>::ReverseInnerIterator Base;
-  public:
-    ReverseInnerIterator(const DynamicSparseMatrix& mat, Index outer)
-      : Base(mat.m_data[outer]), m_outer(outer)
-    {}
-
-    inline Index row() const { return IsRowMajor ? m_outer : Base::index(); }
-    inline Index col() const { return IsRowMajor ? Base::index() : m_outer; }
-    inline Index outer() const { return m_outer; }
-
-  protected:
-    const Index m_outer;
-};
-
-namespace internal {
-
-template<typename _Scalar, int _Options, typename _StorageIndex>
-struct evaluator<DynamicSparseMatrix<_Scalar,_Options,_StorageIndex> >
-  : evaluator_base<DynamicSparseMatrix<_Scalar,_Options,_StorageIndex> >
-{
-  typedef _Scalar Scalar;
-  typedef DynamicSparseMatrix<_Scalar,_Options,_StorageIndex> SparseMatrixType;
-  typedef typename SparseMatrixType::InnerIterator InnerIterator;
-  typedef typename SparseMatrixType::ReverseInnerIterator ReverseInnerIterator;
-  
-  enum {
-    CoeffReadCost = NumTraits<_Scalar>::ReadCost,
-    Flags = SparseMatrixType::Flags
-  };
-  
-  evaluator() : m_matrix(0) {}
-  evaluator(const SparseMatrixType &mat) : m_matrix(&mat) {}
-  
-  operator SparseMatrixType&() { return m_matrix->const_cast_derived(); }
-  operator const SparseMatrixType&() const { return *m_matrix; }
-  
-  Scalar coeff(Index row, Index col) const { return m_matrix->coeff(row,col); }
-  
-  Index nonZerosEstimate() const { return m_matrix->nonZeros(); }
-
-  const SparseMatrixType *m_matrix;
-};
-
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_DYNAMIC_SPARSEMATRIX_H

casadi/include/include/eigen3/unsupported/Eigen/src/SparseExtra/MarketIO.h

@@ -1,282 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
-// Copyright (C) 2012 Desire 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_MARKET_IO_H
-#define EIGEN_SPARSE_MARKET_IO_H
-
-#include <iostream>
-#include <vector>
-
-namespace Eigen { 
-
-namespace internal 
-{
-  template <typename Scalar, typename StorageIndex>
-  inline void GetMarketLine (const char* line, StorageIndex& i, StorageIndex& j, Scalar& value)
-  {
-    std::stringstream sline(line);
-    sline >> i >> j >> value;
-  }
-
-  template<> inline void GetMarketLine (const char* line, int& i, int& j, float& value)
-  { std::sscanf(line, "%d %d %g", &i, &j, &value); }
-
-  template<> inline void GetMarketLine (const char* line, int& i, int& j, double& value)
-  { std::sscanf(line, "%d %d %lg", &i, &j, &value); }
-
-  template<> inline void GetMarketLine (const char* line, int& i, int& j, std::complex<float>& value)
-  { std::sscanf(line, "%d %d %g %g", &i, &j, &numext::real_ref(value), &numext::imag_ref(value)); }
-
-  template<> inline void GetMarketLine (const char* line, int& i, int& j, std::complex<double>& value)
-  { std::sscanf(line, "%d %d %lg %lg", &i, &j, &numext::real_ref(value), &numext::imag_ref(value)); }
-
-  template <typename Scalar, typename StorageIndex>
-  inline void GetMarketLine (const char* line, StorageIndex& i, StorageIndex& j, std::complex<Scalar>& value)
-  {
-    std::stringstream sline(line);
-    Scalar valR, valI;
-    sline >> i >> j >> valR >> valI;
-    value = std::complex<Scalar>(valR,valI);
-  }
-
-  template <typename RealScalar>
-  inline void  GetVectorElt (const std::string& line, RealScalar& val)
-  {
-    std::istringstream newline(line);
-    newline >> val;  
-  }
-
-  template <typename RealScalar>
-  inline void GetVectorElt (const std::string& line, std::complex<RealScalar>& val)
-  {
-    RealScalar valR, valI; 
-    std::istringstream newline(line);
-    newline >> valR >> valI; 
-    val = std::complex<RealScalar>(valR, valI);
-  }
-  
-  template<typename Scalar>
-  inline void putMarketHeader(std::string& header,int sym)
-  {
-    header= "%%MatrixMarket matrix coordinate ";
-    if(internal::is_same<Scalar, std::complex<float> >::value || internal::is_same<Scalar, std::complex<double> >::value)
-    {
-      header += " complex"; 
-      if(sym == Symmetric) header += " symmetric";
-      else if (sym == SelfAdjoint) header += " Hermitian";
-      else header += " general";
-    }
-    else
-    {
-      header += " real"; 
-      if(sym == Symmetric) header += " symmetric";
-      else header += " general";
-    }
-  }
-
-  template<typename Scalar, typename StorageIndex>
-  inline void PutMatrixElt(Scalar value, StorageIndex row, StorageIndex col, std::ofstream& out)
-  {
-    out << row << " "<< col << " " << value << "\n";
-  }
-  template<typename Scalar, typename StorageIndex>
-  inline void PutMatrixElt(std::complex<Scalar> value, StorageIndex row, StorageIndex col, std::ofstream& out)
-  {
-    out << row << " " << col << " " << value.real() << " " << value.imag() << "\n";
-  }
-
-
-  template<typename Scalar>
-  inline void putVectorElt(Scalar value, std::ofstream& out)
-  {
-    out << value << "\n"; 
-  }
-  template<typename Scalar>
-  inline void putVectorElt(std::complex<Scalar> value, std::ofstream& out)
-  {
-    out << value.real() << " " << value.imag()<< "\n"; 
-  }
-
-} // end namespace internal
-
-inline bool getMarketHeader(const std::string& filename, int& sym, bool& iscomplex, bool& isvector)
-{
-  sym = 0; 
-  iscomplex = false;
-  isvector = false;
-  std::ifstream in(filename.c_str(),std::ios::in);
-  if(!in)
-    return false;
-  
-  std::string line; 
-  // The matrix header is always the first line in the file 
-  std::getline(in, line); eigen_assert(in.good());
-  
-  std::stringstream fmtline(line); 
-  std::string substr[5];
-  fmtline>> substr[0] >> substr[1] >> substr[2] >> substr[3] >> substr[4];
-  if(substr[2].compare("array") == 0) isvector = true;
-  if(substr[3].compare("complex") == 0) iscomplex = true;
-  if(substr[4].compare("symmetric") == 0) sym = Symmetric;
-  else if (substr[4].compare("Hermitian") == 0) sym = SelfAdjoint;
-  
-  return true;
-}
-  
-template<typename SparseMatrixType>
-bool loadMarket(SparseMatrixType& mat, const std::string& filename)
-{
-  typedef typename SparseMatrixType::Scalar Scalar;
-  typedef typename SparseMatrixType::StorageIndex StorageIndex;
-  std::ifstream input(filename.c_str(),std::ios::in);
-  if(!input)
-    return false;
-
-  char rdbuffer[4096];
-  input.rdbuf()->pubsetbuf(rdbuffer, 4096);
-  
-  const int maxBuffersize = 2048;
-  char buffer[maxBuffersize];
-  
-  bool readsizes = false;
-
-  typedef Triplet<Scalar,StorageIndex> T;
-  std::vector<T> elements;
-  
-  Index M(-1), N(-1), NNZ(-1);
-  Index count = 0;
-  while(input.getline(buffer, maxBuffersize))
-  {
-    // skip comments   
-    //NOTE An appropriate test should be done on the header to get the  symmetry
-    if(buffer[0]=='%')
-      continue;
-
-    if(!readsizes)
-    {
-      std::stringstream line(buffer);
-      line >> M >> N >> NNZ;
-      if(M > 0 && N > 0)
-      {
-        readsizes = true;
-        mat.resize(M,N);
-        mat.reserve(NNZ);
-      }
-    }
-    else
-    { 
-      StorageIndex i(-1), j(-1);
-      Scalar value; 
-      internal::GetMarketLine(buffer, i, j, value);
-
-      i--;
-      j--;
-      if(i>=0 && j>=0 && i<M && j<N)
-      {
-        ++count;
-        elements.push_back(T(i,j,value));
-      }
-      else
-        std::cerr << "Invalid read: " << i << "," << j << "\n";        
-    }
-  }
-
-  mat.setFromTriplets(elements.begin(), elements.end());
-  if(count!=NNZ)
-    std::cerr << count << "!=" << NNZ << "\n";
-  
-  input.close();
-  return true;
-}
-
-template<typename VectorType>
-bool loadMarketVector(VectorType& vec, const std::string& filename)
-{
-   typedef typename VectorType::Scalar Scalar;
-  std::ifstream in(filename.c_str(), std::ios::in);
-  if(!in)
-    return false;
-  
-  std::string line; 
-  int n(0), col(0); 
-  do 
-  { // Skip comments
-    std::getline(in, line); eigen_assert(in.good());
-  } while (line[0] == '%');
-  std::istringstream newline(line);
-  newline  >> n >> col; 
-  eigen_assert(n>0 && col>0);
-  vec.resize(n);
-  int i = 0; 
-  Scalar value; 
-  while ( std::getline(in, line) && (i < n) ){
-    internal::GetVectorElt(line, value); 
-    vec(i++) = value; 
-  }
-  in.close();
-  if (i!=n){
-    std::cerr<< "Unable to read all elements from file " << filename << "\n";
-    return false;
-  }
-  return true;
-}
-
-template<typename SparseMatrixType>
-bool saveMarket(const SparseMatrixType& mat, const std::string& filename, int sym = 0)
-{
-  typedef typename SparseMatrixType::Scalar Scalar;
-  typedef typename SparseMatrixType::RealScalar RealScalar;
-  std::ofstream out(filename.c_str(),std::ios::out);
-  if(!out)
-    return false;
-  
-  out.flags(std::ios_base::scientific);
-  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
-  std::string header; 
-  internal::putMarketHeader<Scalar>(header, sym); 
-  out << header << std::endl; 
-  out << mat.rows() << " " << mat.cols() << " " << mat.nonZeros() << "\n";
-  int count = 0;
-  for(int j=0; j<mat.outerSize(); ++j)
-    for(typename SparseMatrixType::InnerIterator it(mat,j); it; ++it)
-    {
-      ++ count;
-      internal::PutMatrixElt(it.value(), it.row()+1, it.col()+1, out);
-    }
-  out.close();
-  return true;
-}
-
-template<typename VectorType>
-bool saveMarketVector (const VectorType& vec, const std::string& filename)
-{
- typedef typename VectorType::Scalar Scalar;
- typedef typename VectorType::RealScalar RealScalar;
- std::ofstream out(filename.c_str(),std::ios::out);
-  if(!out)
-    return false;
-  
-  out.flags(std::ios_base::scientific);
-  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
-  if(internal::is_same<Scalar, std::complex<float> >::value || internal::is_same<Scalar, std::complex<double> >::value)
-      out << "%%MatrixMarket matrix array complex general\n"; 
-  else
-    out << "%%MatrixMarket matrix array real general\n"; 
-  out << vec.size() << " "<< 1 << "\n";
-  for (int i=0; i < vec.size(); i++){
-    internal::putVectorElt(vec(i), out); 
-  }
-  out.close();
-  return true; 
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSE_MARKET_IO_H