Initial revision
[blender.git] / intern / iksolver / intern / TNT / fspvec.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /*
33
34 *
35 * Template Numerical Toolkit (TNT): Linear Algebra Module
36 *
37 * Mathematical and Computational Sciences Division
38 * National Institute of Technology,
39 * Gaithersburg, MD USA
40 *
41 *
42 * This software was developed at the National Institute of Standards and
43 * Technology (NIST) by employees of the Federal Government in the course
44 * of their official duties. Pursuant to title 17 Section 105 of the
45 * United States Code, this software is not subject to copyright protection
46 * and is in the public domain.  The Template Numerical Toolkit (TNT) is
47 * an experimental system.  NIST assumes no responsibility whatsoever for
48 * its use by other parties, and makes no guarantees, expressed or implied,
49 * about its quality, reliability, or any other characteristic.
50 *
51 * BETA VERSION INCOMPLETE AND SUBJECT TO CHANGE
52 * see http://math.nist.gov/tnt for latest updates.
53 *
54 */
55
56
57 //  Templated sparse vector (Fortran conventions).
58 //  Used primarily to interface with Fortran sparse matrix libaries.
59 //  (CANNOT BE USED AS AN STL CONTAINER.)
60
61 #ifndef FSPVEC_H
62 #define FSPVEC_H
63
64 #include "tnt.h"
65 #include "vec.h"
66 #include <cstdlib>
67 #include <cassert>
68 #include <iostream>
69 #include <strstream>
70
71 using namespace std;
72
73 namespace TNT
74 {
75
76 template <class T>
77 class Fortran_Sparse_Vector 
78 {
79
80
81   public:
82
83     typedef Subscript   size_type;
84     typedef         T   value_type;
85     typedef         T   element_type;
86     typedef         T*  pointer;
87     typedef         T*  iterator;
88     typedef         T&  reference;
89     typedef const   T*  const_iterator;
90     typedef const   T&  const_reference;
91
92     Subscript lbound() const { return 1;}
93  
94   protected:
95     Vector<T>   val_;
96     Vector<Subscript> index_;
97     Subscript dim_;                  // prescribed dimension
98
99
100   public:
101
102     // size and shape information
103
104     Subscript dim() const { return dim_; }
105     Subscript num_nonzeros() const { return val_.dim(); }
106
107     // access
108
109     T& val(Subscript i) { return val_(i); }
110     const T& val(Subscript i) const { return val_(i); }
111
112     Subscript &index(Subscript i) { return index_(i); }
113     const Subscript &index(Subscript i) const { return index_(i); }
114
115     // constructors
116
117     Fortran_Sparse_Vector() : val_(), index_(), dim_(0)  {};
118     Fortran_Sparse_Vector(Subscript N, Subscript nz) : val_(nz), 
119             index_(nz), dim_(N)  {};
120     Fortran_Sparse_Vector(Subscript N, Subscript nz, const T *values,
121         const Subscript *indices): val_(nz, values), index_(nz, indices),
122             dim_(N) {}
123
124     Fortran_Sparse_Vector(const Fortran_Sparse_Vector<T> &S): 
125         val_(S.val_), index_(S.index_), dim_(S.dim_) {}
126
127     // initialize from string, e.g.
128     //
129     //  Fortran_Sparse_Vector<T> A(N, 2, "1.0 2.1", "1 3");
130     //
131     Fortran_Sparse_Vector(Subscript N, Subscript nz, char *v,
132         char *ind) : val_(nz, v), index_(nz, ind), dim_(N) {}
133     
134     // assignments
135
136     Fortran_Sparse_Vector<T> & newsize(Subscript N, Subscript nz)
137     {
138         val_.newsize(nz);
139         index_.newsize(nz);
140         dim_ = N;
141         return *this;
142     }
143
144     Fortran_Sparse_Vector<T> & operator=( const Fortran_Sparse_Vector<T> &A)
145     {
146         val_ = A.val_;
147         index_ = A.index_;
148         dim_ = A.dim_;
149
150         return *this;
151     }
152
153     // methods
154
155
156
157 };
158
159
160 /* ***************************  I/O  ********************************/
161
162 template <class T>
163 ostream& operator<<(ostream &s, const Fortran_Sparse_Vector<T> &A)
164 {
165     // output format is :   N nz val1 ind1 val2 ind2 ... 
166     Subscript nz=A.num_nonzeros();
167
168     s <<  A.dim() << " " << nz << endl;
169
170     for (Subscript i=1; i<=nz; i++)
171         s   << A.val(i) << "  " << A.index(i) << endl;
172     s << endl;
173
174     return s;
175 }
176
177
178 template <class T>
179 istream& operator>>(istream &s, Fortran_Sparse_Vector<T> &A)
180 {
181     // output format is :   N nz val1 ind1 val2 ind2 ... 
182
183     Subscript N;
184     Subscript nz;
185
186     s >> N >> nz;
187
188     A.newsize(N, nz);
189
190     for (Subscript i=1; i<=nz; i++)
191             s >>  A.val(i) >> A.index(i);
192
193
194     return s;
195 }
196
197 } // namespace TNT
198
199 #endif
200 // FSPVEC_H