mirror of
https://gitlab.com/libeigen/eigen.git
synced 2026-04-10 11:34:33 +08:00
add experimental code for sparse matrix:
- uses the common "Compressed Column Storage" scheme - supports every unary and binary operators with xpr template assuming binaryOp(0,0) == 0 and unaryOp(0) = 0 (otherwise a sparse matrix doesnot make sense) - this is the first commit, so of course, there are still several shorcommings !
This commit is contained in:
Gael Guennebaud
331
Eigen/src/Sparse/SparseMatrix.h
Normal file
331
Eigen/src/Sparse/SparseMatrix.h
Normal file
@@ -0,0 +1,331 @@
|
||||
// This file is part of Eigen, a lightweight C++ template library
|
||||
// for linear algebra. Eigen itself is part of the KDE project.
|
||||
//
|
||||
// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
|
||||
//
|
||||
// Eigen is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Lesser General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// Alternatively, you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of
|
||||
// the License, or (at your option) any later version.
|
||||
//
|
||||
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
||||
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public
|
||||
// License and a copy of the GNU General Public License along with
|
||||
// Eigen. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef EIGEN_SPARSEMATRIX_H
|
||||
#define EIGEN_SPARSEMATRIX_H
|
||||
|
||||
template<typename _Scalar> class SparseMatrix;
|
||||
|
||||
/** \class SparseMatrix
|
||||
*
|
||||
* \brief Sparse matrix
|
||||
*
|
||||
* \param _Scalar the scalar type, i.e. the type of the coefficients
|
||||
*
|
||||
* See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme.
|
||||
*
|
||||
*/
|
||||
template<typename _Scalar>
|
||||
struct ei_traits<SparseMatrix<_Scalar> >
|
||||
{
|
||||
typedef _Scalar Scalar;
|
||||
enum {
|
||||
RowsAtCompileTime = Dynamic,
|
||||
ColsAtCompileTime = Dynamic,
|
||||
MaxRowsAtCompileTime = Dynamic,
|
||||
MaxColsAtCompileTime = Dynamic,
|
||||
Flags = 0,
|
||||
CoeffReadCost = NumTraits<Scalar>::ReadCost
|
||||
};
|
||||
};
|
||||
|
||||
template<typename _Scalar>
|
||||
class SparseMatrix : public MatrixBase<SparseMatrix<_Scalar> >
|
||||
{
|
||||
public:
|
||||
EIGEN_GENERIC_PUBLIC_INTERFACE(SparseMatrix)
|
||||
|
||||
protected:
|
||||
|
||||
int* m_colPtrs;
|
||||
SparseArray<Scalar> m_data;
|
||||
int m_rows;
|
||||
int m_cols;
|
||||
|
||||
inline int _rows() const { return m_rows; }
|
||||
inline int _cols() const { return m_cols; }
|
||||
|
||||
inline const Scalar& _coeff(int row, int col) const
|
||||
{
|
||||
int id = m_colPtrs[col];
|
||||
int end = m_colPtrs[col+1];
|
||||
while (id<end && m_data.index(id)!=row)
|
||||
{
|
||||
++id;
|
||||
}
|
||||
if (id==end)
|
||||
return 0;
|
||||
return m_data.value(id);
|
||||
}
|
||||
|
||||
inline Scalar& _coeffRef(int row, int col)
|
||||
{
|
||||
int id = m_colPtrs[cols];
|
||||
int end = m_colPtrs[cols+1];
|
||||
while (id<end && m_data.index(id)!=row)
|
||||
{
|
||||
++id;
|
||||
}
|
||||
ei_assert(id!=end);
|
||||
return m_data.value(id);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
class InnerIterator;
|
||||
|
||||
inline int rows() const { return _rows(); }
|
||||
inline int cols() const { return _cols(); }
|
||||
/** \returns the number of non zero coefficients */
|
||||
inline int nonZeros() const { return m_data.size(); }
|
||||
|
||||
inline const Scalar& operator() (int row, int col) const
|
||||
{
|
||||
return _coeff(row, col);
|
||||
}
|
||||
|
||||
inline Scalar& operator() (int row, int col)
|
||||
{
|
||||
return _coeffRef(row, col);
|
||||
}
|
||||
|
||||
inline void startFill(int reserveSize = 1000)
|
||||
{
|
||||
m_data.clear();
|
||||
m_data.reserve(reserveSize);
|
||||
for (int i=0; i<=m_cols; ++i)
|
||||
m_colPtrs[i] = 0;
|
||||
}
|
||||
|
||||
inline Scalar& fill(int row, int col)
|
||||
{
|
||||
if (m_colPtrs[col+1]==0)
|
||||
{
|
||||
int i=col;
|
||||
while (i>=0 && m_colPtrs[i]==0)
|
||||
{
|
||||
m_colPtrs[i] = m_data.size();
|
||||
--i;
|
||||
}
|
||||
m_colPtrs[col+1] = m_colPtrs[col];
|
||||
}
|
||||
assert(m_colPtrs[col+1] == m_data.size());
|
||||
int id = m_colPtrs[col+1];
|
||||
m_colPtrs[col+1]++;
|
||||
|
||||
m_data.append(0, row);
|
||||
return m_data.value(id);
|
||||
}
|
||||
|
||||
inline void endFill()
|
||||
{
|
||||
int size = m_data.size();
|
||||
int i = m_cols;
|
||||
// find the last filled column
|
||||
while (i>=0 && m_colPtrs[i]==0)
|
||||
--i;
|
||||
i++;
|
||||
while (i<=m_cols)
|
||||
{
|
||||
m_colPtrs[i] = size;
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
void resize(int rows, int cols)
|
||||
{
|
||||
if (m_cols != cols)
|
||||
{
|
||||
delete[] m_colPtrs;
|
||||
m_colPtrs = new int [cols+1];
|
||||
m_rows = rows;
|
||||
m_cols = cols;
|
||||
}
|
||||
}
|
||||
|
||||
inline SparseMatrix(int rows, int cols)
|
||||
: m_rows(0), m_cols(0), m_colPtrs(0)
|
||||
{
|
||||
resize(rows, cols);
|
||||
}
|
||||
|
||||
inline SparseMatrix& operator=(const SparseMatrix& other)
|
||||
{
|
||||
resize(other.rows(), other.cols());
|
||||
m_colPtrs = other.m_colPtrs;
|
||||
for (int col=0; col<=cols(); ++col)
|
||||
m_colPtrs[col] = other.m_colPtrs[col];
|
||||
m_data = other.m_data;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename OtherDerived>
|
||||
inline SparseMatrix& operator=(const MatrixBase<OtherDerived>& other)
|
||||
{
|
||||
resize(other.rows(), other.cols());
|
||||
startFill(std::max(m_rows,m_cols)*2);
|
||||
for (int col=0; col<cols(); ++col)
|
||||
{
|
||||
for (typename OtherDerived::InnerIterator it(other.derived(), col); it; ++it)
|
||||
{
|
||||
Scalar v = it.value();
|
||||
if (v!=Scalar(0))
|
||||
fill(it.index(),col) = v;
|
||||
}
|
||||
}
|
||||
endFill();
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// old explicit operator+
|
||||
// template<typename Other>
|
||||
// SparseMatrix operator+(const Other& other)
|
||||
// {
|
||||
// SparseMatrix res(rows(), cols());
|
||||
// res.startFill(nonZeros()*3);
|
||||
// for (int col=0; col<cols(); ++col)
|
||||
// {
|
||||
// InnerIterator row0(*this,col);
|
||||
// typename Other::InnerIterator row1(other,col);
|
||||
// while (row0 && row1)
|
||||
// {
|
||||
// if (row0.index()==row1.index())
|
||||
// {
|
||||
// std::cout << "both " << col << " " << row0.index() << "\n";
|
||||
// Scalar v = row0.value() + row1.value();
|
||||
// if (v!=Scalar(0))
|
||||
// res.fill(row0.index(),col) = v;
|
||||
// ++row0;
|
||||
// ++row1;
|
||||
// }
|
||||
// else if (row0.index()<row1.index())
|
||||
// {
|
||||
// std::cout << "row0 " << col << " " << row0.index() << "\n";
|
||||
// Scalar v = row0.value();
|
||||
// if (v!=Scalar(0))
|
||||
// res.fill(row0.index(),col) = v;
|
||||
// ++row0;
|
||||
// }
|
||||
// else if (row1)
|
||||
// {
|
||||
// std::cout << "row1 " << col << " " << row0.index() << "\n";
|
||||
// Scalar v = row1.value();
|
||||
// if (v!=Scalar(0))
|
||||
// res.fill(row1.index(),col) = v;
|
||||
// ++row1;
|
||||
// }
|
||||
// }
|
||||
// while (row0)
|
||||
// {
|
||||
// std::cout << "row0 " << col << " " << row0.index() << "\n";
|
||||
// Scalar v = row0.value();
|
||||
// if (v!=Scalar(0))
|
||||
// res.fill(row0.index(),col) = v;
|
||||
// ++row0;
|
||||
// }
|
||||
// while (row1)
|
||||
// {
|
||||
// std::cout << "row1 " << col << " " << row1.index() << "\n";
|
||||
// Scalar v = row1.value();
|
||||
// if (v!=Scalar(0))
|
||||
// res.fill(row1.index(),col) = v;
|
||||
// ++row1;
|
||||
// }
|
||||
// }
|
||||
// res.endFill();
|
||||
// return res;
|
||||
// // return binaryOp(other, ei_scalar_sum_op<Scalar>());
|
||||
// }
|
||||
|
||||
|
||||
// WARNING for efficiency reason it currently outputs the transposed matrix
|
||||
friend std::ostream & operator << (std::ostream & s, const SparseMatrix& m)
|
||||
{
|
||||
s << "Nonzero entries:\n";
|
||||
for (uint i=0; i<m.nonZeros(); ++i)
|
||||
{
|
||||
s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
|
||||
}
|
||||
s << std::endl;
|
||||
s << std::endl;
|
||||
s << "Column pointers:\n";
|
||||
for (uint i=0; i<m.cols(); ++i)
|
||||
{
|
||||
s << m.m_colPtrs[i] << " ";
|
||||
}
|
||||
s << std::endl;
|
||||
s << std::endl;
|
||||
s << "Matrix (transposed):\n";
|
||||
for (int j=0; j<m.cols(); j++ )
|
||||
{
|
||||
int end = m.m_colPtrs[j+1];
|
||||
int i=0;
|
||||
for (int id=m.m_colPtrs[j]; id<end; id++)
|
||||
{
|
||||
int row = m.m_data.index(id);
|
||||
// fill with zeros
|
||||
for (int k=i; k<row; ++k)
|
||||
s << "0 ";
|
||||
i = row+1;
|
||||
s << m.m_data.value(id) << " ";
|
||||
}
|
||||
for (int k=i; k<m.rows(); ++k)
|
||||
s << "0 ";
|
||||
s << std::endl;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
/** Destructor */
|
||||
inline ~SparseMatrix()
|
||||
{
|
||||
delete[] m_colPtrs;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Scalar>
|
||||
class SparseMatrix<Scalar>::InnerIterator
|
||||
{
|
||||
public:
|
||||
InnerIterator(const SparseMatrix& mat, int col)
|
||||
: m_matrix(mat), m_id(mat.m_colPtrs[col]), m_start(m_id), m_end(mat.m_colPtrs[col+1])
|
||||
{}
|
||||
|
||||
InnerIterator& operator++() { m_id++; return *this; }
|
||||
|
||||
Scalar value() { return m_matrix.m_data.value(m_id); }
|
||||
|
||||
int index() const { return m_matrix.m_data.index(m_id); }
|
||||
|
||||
operator bool() const { return (m_id < m_end) && (m_id>=m_start); }
|
||||
|
||||
protected:
|
||||
const SparseMatrix& m_matrix;
|
||||
int m_id;
|
||||
const int m_start;
|
||||
const int m_end;
|
||||
};
|
||||
|
||||
#endif // EIGEN_SPARSEMATRIX_H
|
||||
Reference in New Issue
Block a user