00001 #ifndef TNT_SPARSE_VECTOR_H
00002 #define TNT_SPARSE_VECTOR_H
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <vector>
00026 #include "tnt_vector.h"
00027
00028 namespace TNT
00029 {
00030
00031
00032
00033
00034
00035 template <class T, class Integer>
00036 class Sparse_Vector_Element
00037 {
00038 private:
00039
00040 T val_;
00041 Integer index_;
00042
00043 public:
00044
00045 Sparse_Vector_Element(const T& a, const Integer &i) :
00046 val_(a), index_(i) {}
00047
00048
00049 const T& value() const { return val_; }
00050 Integer index() const { return index_; }
00051
00052 T& value() { return val_; }
00053 Integer& index() { return index_; }
00054
00055
00056
00057 };
00058
00059
00075 template <class T>
00076 class Sparse_Vector
00077 {
00078
00079
00080 private:
00081
00082
00083
00084 std::vector< Sparse_Vector_Element<T, Subscript> > s_;
00085
00086 int dim_;
00087 int num_nonzeros_;
00088
00089
00090
00091
00092 public:
00093 typedef typename
00094 std::vector< Sparse_Vector_Element<T, Subscript> >::const_iterator
00095 const_iterator;
00096
00097
00098 const_iterator begin() const { return s_.begin(); }
00099 const_iterator end() const { return s_.end(); }
00100
00101 inline const T& value(Subscript i) const { return s_[i].value(); }
00102 inline Subscript index(Subscript i) const {return s_[i].index(); }
00103
00104 inline T dot_product(const Vector<T>& x) const
00105 {
00106 T sum(0);
00107
00108 for ( const_iterator p = begin(); p < end(); p++)
00109 {
00110
00111
00112 sum += p->value() * x[p->index()];
00113 }
00114 return sum;
00115 }
00116
00117 Sparse_Vector() : s_(), dim_(0), num_nonzeros_(0) {}
00118 Sparse_Vector(Subscript N): dim_(N), num_nonzeros_(0) {}
00119
00120
00121
00122 Sparse_Vector(Subscript N, Subscript nz, const T* Val, const Subscript *I):
00123 dim_(N),
00124 num_nonzeros_(0)
00125 {
00126 insert(nz, Val, I);
00127 }
00128
00129
00130
00131 void insert(const T& val, Subscript i)
00132 {
00133
00134 s_.push_back( Sparse_Vector_Element<T, Subscript>(val,i) );
00135 num_nonzeros_++;
00136 }
00137
00138 void insert(Subscript nz, const T* Val, const Subscript *I)
00139 {
00140
00141 for (int count=0; count<nz; count++)
00142 {
00143 insert(Val[count], I[count]);
00144 }
00145 }
00146
00147
00148 void insert_base_one(const T& val, Subscript i)
00149 {
00150 insert(val, i-1);
00151 }
00152
00153 void insert_base_one(Subscript nz, const T* Val, const Subscript *I)
00154 {
00155 for (int count=0; count<nz; count++)
00156 {
00157 insert(Val[count], I[count]-1);
00158 }
00159 }
00160
00161
00162
00163 inline int dim() const {return dim_;}
00164 int num_nonzeros() const {return num_nonzeros_;}
00165
00166
00167
00168
00169 inline double norm() const
00170 {
00171 T sum(0.0);
00172
00173 for (const_iterator p = begin(); p < end(); p++)
00174 {
00175 sum += p->value() * p->value();
00176 }
00177
00178 return sqrt(sum);
00179 }
00180
00181 std::ostream & print(std::ostream &s) const
00182 {
00183 for (typename Sparse_Vector<T>::const_iterator p = begin();
00184 p < end(); p++)
00185 {
00186 s << "( " << p->value() << ", " << p->index() << " ) \n";
00187 }
00188 return s;
00189 }
00190
00191 std::ostream & print_base_one(std::ostream &s) const
00192 {
00193 for (typename Sparse_Vector<T>::const_iterator p = begin();
00194 p < end(); p++)
00195 {
00196 s << "( " << p->value() << ", " << p->index()+1 << " ) \n";
00197 }
00198 return s;
00199 }
00200
00201
00202 };
00203
00204
00205
00206 template <class T>
00207 inline T dot_product(const Sparse_Vector<T> &s, const Vector<T> &x)
00208 {
00209 return s.dot_product(x);
00210 }
00211
00212 template <class T>
00213 inline T dot_product(const Vector<T> &x, const Sparse_Vector<T> &s)
00214 {
00215 return s.dot_product(x);
00216 }
00217
00218 template <class T>
00219 inline T operator*(const Vector<T> &x, const Sparse_Vector<T> &s)
00220 {
00221 return dot_product(x,s);
00222 }
00223
00224 template <class T>
00225 inline T operator*(const Sparse_Vector<T> &s, const Vector<T> &x)
00226 {
00227 return dot_product(x,s);
00228 }
00229
00230
00231 template <class T>
00232 inline double norm( const Sparse_Vector<T> & s)
00233 {
00234 return s.norm();
00235 }
00236
00237
00238 template <class T>
00239 std::ostream& operator<<(std::ostream &s, const Sparse_Vector<T> &A)
00240 {
00241
00242 return A.print(s);
00243 }
00244
00245
00246
00247 }
00248
00249 #endif
00250