#ifndef TLIN_SPARSEMAT_H

#define TLIN_SPARSEMAT_H

#include "tlin_basicops.h"

#include "tcg/tcg_hash.h"

namespace tlin

{

//-------------------------------------------------------------------------------

/*!

  The tlin::sparse_matrix class implements a hash-based format for storing sparse

  matrices.

  A tlin::sparse_matrix is a tlin::matrix-compliant class that allows the user to

  access the matrix in a purely random fashion, without sacrificing storage space or

  efficiency. This is achieved using a single, fast, dynamic hash container that maps

  (row, col) entries into their values, the hash function being like:

    (row, col) -> row * nCols + col;    (taken modulo nBuckets)

  Observe that if the number of buckets of the hash map is nCols, the resulting

  representation is similar to a CCS (Harwell-Boeing), with the difference that

  buckets are not sorted by row.

*/

template <typename t=""></typename>

class sparse_matrix

{

public:

	struct IdxFunctor {

		int m_cols;

		IdxFunctor(int cols) : m_cols(cols) {}

		int operator()(const std::pair<int, int=""> &key) { return key.first * m_cols + key.second; }</int,>

	};

private:

	int m_rows;

	int m_cols;

	tcg::hash<std::pair<int, int="">, T, IdxFunctor> m_hash;</std::pair<int,>

public:

	sparse_matrix() : m_rows(0), m_cols(0), m_hash(IdxFunctor(0)) {}

	sparse_matrix(int rows, int cols) : m_rows(rows), m_cols(cols), m_hash(cols) {}

	~sparse_matrix() {}

	sparse_matrix(const sparse_matrix &mat) : m_rows(mat.m_rows), m_cols(mat.m_cols), m_hash(mat.m_hash) {}

	sparse_matrix &operator=(const sparse_matrix &mat)

	{

		m_rows = mat.m_rows, m_cols = mat.m_cols, m_hash = mat.m_hash;

		return *this;

	}

	int rows() const { return m_rows; }

	int cols() const { return m_cols; }

	typedef typename tcg::hash<std::pair<int, int="">, T, IdxFunctor> HashMap;</std::pair<int,>

	tcg::hash<std::pair<int, int="">, T, IdxFunctor> &entries() { return m_hash; }</std::pair<int,>

	const tcg::hash<std::pair<int, int="">, T, IdxFunctor> &entries() const { return m_hash; }</std::pair<int,>

	//!\warning Assignments of kind: A.at(1,1) = A.at(0,0) are potentially harmful.

	//!Use A.get(x,y) on the right side instead.

	T &at(int row, int col) { return m_hash.touch(std::make_pair(row, col), 0); }

	const T get(int row, int col) const

	{

		typename HashMap::const_iterator it = m_hash.find(std::make_pair(row, col));

		return (it == m_hash.end()) ? 0 : it->m_val;

	}

	const T operator()(int row, int col) const { return get(row, col); }

	void clear() { m_hash.clear(); }

	friend void swap(sparse_matrix &a, sparse_matrix &b)

	{

		using std::swap;

		swap(a.m_rows, b.m_rows), swap(a.m_cols, b.m_cols);

		swap(a.m_hash, b.m_hash);

	}

};

//-------------------------------------------------------------------

//  The Standard matrix data type in tlin is double

typedef tlin::sparse_matrix<double> spmat;</double>

}

#endif //TLIN_SPARSEMAT_H