sparse_matrix.hh

#ifndef SPARSE_MATRIX_HH
#define SPARSE_MATRIX_HH

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <iostream>

#include "aux.hh"

namespace LocARNA {

    template <typename T>
    class SparseMatrix {
    public:
        
        typedef T value_t; 

        typedef size_t size_type; 

        typedef std::pair<size_type,size_type> key_t; 

    protected:
                
        typedef typename unordered_map<key_t,value_t,pair_of_size_t_hash>::type map_t; 
        map_t the_map_; 
        value_t def_; 
    
    public:

        typedef typename map_t::const_iterator const_iterator;
        
        
        class element {
        private:
            SparseMatrix<T> *m_;
            key_t k_;
        public:
            element(SparseMatrix<T> *m,key_t k): m_(m),k_(k) {}

            operator value_t() {
                typename map_t::const_iterator it = m_->the_map_.find(k_);
                if ( it == m_->the_map_.end() ) 
                    return m_->def_;
                else 
                    return it->second;
            }
            
            element
            operator +=(const value_t &x) {
                const_iterator it = m_->the_map_.find(k_);
                if ( it == m_->the_map_.end() ) 
                    m_->the_map_[k_] = m_->def_ + x;
                else 
                    m_->the_map_[k_] += x;
            
                return *this;
            }
        
            element &
            operator =(const value_t &x) {
                if (x==m_->def_) {
                    m_->the_map_.erase(k_);
                } else {
                    // the following replaces m_->the_map_[k_] = x;
                    // but never calls the default constructor for value_t

                    typename map_t::iterator it = m_->the_map_.find(k_);
                    if ( it != m_->the_map_.end() ) { 
                        it->second = x;
                    } else { 
                        m_->the_map_.insert(typename map_t::value_type(k_,x));
                    }
                }
                return *this;
            }
        };
    

        SparseMatrix() : the_map_(),def_() {}
        
        explicit
        SparseMatrix(const value_t &def) : the_map_(),def_(def) {}

        element operator() (size_type i, size_type j) {
            return element(this,key_t(i,j));
        }
    
        const value_t & operator() (size_type i, size_type j) const {
            const_iterator it = the_map_.find(key_t(i,j));
            if ( it == the_map_.end() ) 
                return def_;
            else 
                return it->second;
        }
        
        void
        set(size_type i, size_type j, const value_t &val) {
            typename map_t::iterator it = the_map_.find(key_t(i,j));
            if ( it != the_map_.end() ) { 
                it->second = val;
            } else { 
                the_map_.insert(typename map_t::value_type(key_t(i,j),val));
            }
        }

        value_t & 
        ref(size_type i, size_type j) {
            typename map_t::iterator it = the_map_.find(key_t(i,j));
            if ( it == the_map_.end() ) { 
                the_map_.insert(typename map_t::value_type(key_t(i,j),def_));
                it = the_map_.find(key_t(i,j));
            }
            return it->second;
        }
    
        void
        reset(size_type i, size_type j) {
            typename map_t::iterator it = the_map_.find(key_t(i,j));
            if ( it != the_map_.end() ) { 
                the_map_.erase(key_t(i,j));
            } 
        }

        size_type
        size() const {
            return the_map_.size();
        }

        bool
        empty() const {
            return the_map_.empty();
        }
        
        void
        clear() {
            the_map_.clear();
        }

        const_iterator
        begin() const {
            return the_map_.begin();
        }
        
        const_iterator 
        end() const {
            return the_map_.end();
        }


        const value_t &
        def() const {
            return def_;
        }
    };

    template<class T>
    inline
    std::ostream &
    operator <<(std::ostream &out, const SparseMatrix<T> &m) {
        for (typename SparseMatrix<T>::const_iterator it=m.begin();
             m.end()!=it; 
             ++it) {
            out << "("<<it->first.first<<","<<it->first.second << ") " << it->second << std::endl;
        }
        return out;
    }

} //end namespace LocARNA

#endif // SPARSE_MATRIX_HH