7ebba6f882d1931cf41f9398e5b0654dbc9c331f
[blender.git] / intern / iksolver / intern / TNT / fspvec.h
1 /**
2  * $Id$
3  */
4
5 /*
6
7 *
8 * Template Numerical Toolkit (TNT): Linear Algebra Module
9 *
10 * Mathematical and Computational Sciences Division
11 * National Institute of Technology,
12 * Gaithersburg, MD USA
13 *
14 *
15 * This software was developed at the National Institute of Standards and
16 * Technology (NIST) by employees of the Federal Government in the course
17 * of their official duties. Pursuant to title 17 Section 105 of the
18 * United States Code, this software is not subject to copyright protection
19 * and is in the public domain.  The Template Numerical Toolkit (TNT) is
20 * an experimental system.  NIST assumes no responsibility whatsoever for
21 * its use by other parties, and makes no guarantees, expressed or implied,
22 * about its quality, reliability, or any other characteristic.
23 *
24 * BETA VERSION INCOMPLETE AND SUBJECT TO CHANGE
25 * see http://math.nist.gov/tnt for latest updates.
26 *
27 */
28
29
30 //  Templated sparse vector (Fortran conventions).
31 //  Used primarily to interface with Fortran sparse matrix libaries.
32 //  (CANNOT BE USED AS AN STL CONTAINER.)
33
34 #ifndef FSPVEC_H
35 #define FSPVEC_H
36
37 #include "tnt.h"
38 #include "vec.h"
39 #include <cstdlib>
40 #include <cassert>
41 #include <iostream>
42 #include <strstream>
43
44 using namespace std;
45
46 namespace TNT
47 {
48
49 template <class T>
50 class Fortran_Sparse_Vector 
51 {
52
53
54   public:
55
56     typedef Subscript   size_type;
57     typedef         T   value_type;
58     typedef         T   element_type;
59     typedef         T*  pointer;
60     typedef         T*  iterator;
61     typedef         T&  reference;
62     typedef const   T*  const_iterator;
63     typedef const   T&  const_reference;
64
65     Subscript lbound() const { return 1;}
66  
67   protected:
68     Vector<T>   val_;
69     Vector<Subscript> index_;
70     Subscript dim_;                  // prescribed dimension
71
72
73   public:
74
75     // size and shape information
76
77     Subscript dim() const { return dim_; }
78     Subscript num_nonzeros() const { return val_.dim(); }
79
80     // access
81
82     T& val(Subscript i) { return val_(i); }
83     const T& val(Subscript i) const { return val_(i); }
84
85     Subscript &index(Subscript i) { return index_(i); }
86     const Subscript &index(Subscript i) const { return index_(i); }
87
88     // constructors
89
90     Fortran_Sparse_Vector() : val_(), index_(), dim_(0)  {};
91     Fortran_Sparse_Vector(Subscript N, Subscript nz) : val_(nz), 
92             index_(nz), dim_(N)  {};
93     Fortran_Sparse_Vector(Subscript N, Subscript nz, const T *values,
94         const Subscript *indices): val_(nz, values), index_(nz, indices),
95             dim_(N) {}
96
97     Fortran_Sparse_Vector(const Fortran_Sparse_Vector<T> &S): 
98         val_(S.val_), index_(S.index_), dim_(S.dim_) {}
99
100     // initialize from string, e.g.
101     //
102     //  Fortran_Sparse_Vector<T> A(N, 2, "1.0 2.1", "1 3");
103     //
104     Fortran_Sparse_Vector(Subscript N, Subscript nz, char *v,
105         char *ind) : val_(nz, v), index_(nz, ind), dim_(N) {}
106     
107     // assignments
108
109     Fortran_Sparse_Vector<T> & newsize(Subscript N, Subscript nz)
110     {
111         val_.newsize(nz);
112         index_.newsize(nz);
113         dim_ = N;
114         return *this;
115     }
116
117     Fortran_Sparse_Vector<T> & operator=( const Fortran_Sparse_Vector<T> &A)
118     {
119         val_ = A.val_;
120         index_ = A.index_;
121         dim_ = A.dim_;
122
123         return *this;
124     }
125
126     // methods
127
128
129
130 };
131
132
133 /* ***************************  I/O  ********************************/
134
135 template <class T>
136 ostream& operator<<(ostream &s, const Fortran_Sparse_Vector<T> &A)
137 {
138     // output format is :   N nz val1 ind1 val2 ind2 ... 
139     Subscript nz=A.num_nonzeros();
140
141     s <<  A.dim() << " " << nz << endl;
142
143     for (Subscript i=1; i<=nz; i++)
144         s   << A.val(i) << "  " << A.index(i) << endl;
145     s << endl;
146
147     return s;
148 }
149
150
151 template <class T>
152 istream& operator>>(istream &s, Fortran_Sparse_Vector<T> &A)
153 {
154     // output format is :   N nz val1 ind1 val2 ind2 ... 
155
156     Subscript N;
157     Subscript nz;
158
159     s >> N >> nz;
160
161     A.newsize(N, nz);
162
163     for (Subscript i=1; i<=nz; i++)
164             s >>  A.val(i) >> A.index(i);
165
166
167     return s;
168 }
169
170 } // namespace TNT
171
172 #endif // FSPVEC_H
173