tnt_sparse_vector.h

#ifndef TNT_SPARSE_VECTOR_H
#define TNT_SPARSE_VECTOR_H
 
/*
*
* Template Numerical Toolkit (TNT)
*
* Mathematical and Computational Sciences Division
* National Institute of Technology,
* Gaithersburg, MD USA
*
*
* This software was developed at the National Institute of Standards and
* Technology (NIST) by employees of the Federal Government in the course
* of their official duties. Pursuant to title 17 Section 105 of the
* United States Code, this software is not subject to copyright protection
* and is in the public domain. NIST assumes no responsibility whatsoever for
* its use by other parties, and makes no guarantees, expressed or implied,
* about its quality, reliability, or any other characteristic.
*
*/
 
 
 
#include <vector>
#include "tnt_vector.h"
 
namespace TNT
{
//namespace Linear_Algebra
//{
 
 
 
template <class T, class Integer>
class Sparse_Vector_Element
{
        private:
 
                T val_;
                Integer index_;
 
        public:
 
                Sparse_Vector_Element(const T& a, const Integer &i) : 
                        val_(a), index_(i) {}
                
 
                const T& value() const { return val_; } 
                Integer index() const { return index_; } 
 
                T& value() { return val_; }
                Integer& index() { return index_; }
 
                    
 
};
 
 
template <class T>
class Sparse_Vector
{
    /* sparse vector indices are 0-based internally. */
 
  private:
 
        // (value, index) pairs
        //
        std::vector< Sparse_Vector_Element<T, Subscript> > s_;    
 
    int dim_;                   // dimension
        int num_nonzeros_;      // number of nonzeros
 
 
 
 
public:
        typedef typename 
                std::vector< Sparse_Vector_Element<T, Subscript> >::const_iterator 
                                                                                                                            const_iterator;
 
 
        const_iterator begin() const { return s_.begin(); }
        const_iterator end() const { return s_.end(); }
 
        inline const T& value(Subscript i) const { return s_[i].value(); }
        inline Subscript index(Subscript i) const {return  s_[i].index(); }
      
    inline T dot_product(const Vector<T>& x) const
    {
        T sum(0);
 
        for ( const_iterator p = begin(); p < end(); p++)
        {
                        sum += p->value() * x[p->index()];
        }
       return sum;
    }
 
    Sparse_Vector() : s_(), dim_(0), num_nonzeros_(0) {}
    Sparse_Vector(Subscript N): dim_(N), num_nonzeros_(0) {}
 
            
 
    Sparse_Vector(Subscript N, Subscript nz, const T* Val, const Subscript *I):
                    dim_(N),
                    num_nonzeros_(0)
                    {
                        insert(nz, Val, I); 
                    }
   
 
 
    void   insert(const T& val, Subscript i)
    {
 
            s_.push_back( Sparse_Vector_Element<T, Subscript>(val,i) );
            num_nonzeros_++;
    }
 
    void   insert(Subscript nz, const T* Val, const Subscript *I)
    {
 
            for (int count=0; count<nz; count++)
            {
                insert(Val[count], I[count]);   
            }
    }
 
 
    void insert_base_one(const T& val, Subscript i)
    {
        insert(val, i-1);
    }
 
    void   insert_base_one(Subscript nz, const T* Val, const Subscript *I)
    {
            for (int count=0; count<nz; count++)
            {
                insert(Val[count], I[count]-1); 
            }
    }
        
 
 
  inline   int    dim() const   {return dim_;}
  int          num_nonzeros() const {return num_nonzeros_;}
 
 
 
 
    inline double norm() const
    {
        T sum(0.0);
 
        for (const_iterator p = begin(); p < end(); p++)
        {
            sum += p->value() * p->value();
        }
 
        return sqrt(sum);
    }
 
    std::ostream & print(std::ostream &s) const
    {
        for (typename Sparse_Vector<T>::const_iterator p = begin(); 
                        p < end(); p++)
        {
                s << "( " << p->value() << ", " << p->index() << " ) \n";
        }
        return s;
    }
 
    std::ostream & print_base_one(std::ostream &s) const
    {
        for (typename Sparse_Vector<T>::const_iterator p = begin(); 
                        p < end(); p++)
        {
                s << "( " << p->value() << ", " << p->index()+1 << " ) \n";
        }
        return s;
    }
 
            
};
 
 
 
template <class T>
inline T dot_product(const Sparse_Vector<T> &s, const Vector<T> &x)
{
    return s.dot_product(x);
}
 
template <class T>
inline T dot_product(const Vector<T> &x, const Sparse_Vector<T> &s)
{
    return s.dot_product(x);
}
 
template <class T>
inline T operator*(const Vector<T> &x, const Sparse_Vector<T> &s)
{
    return dot_product(x,s);
}
 
template <class T>
inline T operator*(const Sparse_Vector<T> &s, const Vector<T> &x)
{
    return dot_product(x,s);
}
 
 
template <class T>
inline double norm( const Sparse_Vector<T> & s)
{
    return s.norm();
}
 
 
template <class T>
std::ostream& operator<<(std::ostream &s, const Sparse_Vector<T> &A)
{
 
        return  A.print(s);
}
 
 
//}  /* namspace TNT::Linear_Algebra */
}    /* namspace TNT */
 
#endif
// TNT_SPARSE_VECTOR_H