Fixed a stupid bug when exporting meshes with empty material slots.
[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
43 using namespace std;
44
45 namespace TNT
46 {
47
48 template <class T>
49 class Fortran_Sparse_Vector 
50 {
51
52
53   public:
54
55     typedef Subscript   size_type;
56     typedef         T   value_type;
57     typedef         T   element_type;
58     typedef         T*  pointer;
59     typedef         T*  iterator;
60     typedef         T&  reference;
61     typedef const   T*  const_iterator;
62     typedef const   T&  const_reference;
63
64     Subscript lbound() const { return 1;}
65  
66   protected:
67     Vector<T>   val_;
68     Vector<Subscript> index_;
69     Subscript dim_;                  // prescribed dimension
70
71
72   public:
73
74     // size and shape information
75
76     Subscript dim() const { return dim_; }
77     Subscript num_nonzeros() const { return val_.dim(); }
78
79     // access
80
81     T& val(Subscript i) { return val_(i); }
82     const T& val(Subscript i) const { return val_(i); }
83
84     Subscript &index(Subscript i) { return index_(i); }
85     const Subscript &index(Subscript i) const { return index_(i); }
86
87     // constructors
88
89     Fortran_Sparse_Vector() : val_(), index_(), dim_(0)  {};
90     Fortran_Sparse_Vector(Subscript N, Subscript nz) : val_(nz), 
91             index_(nz), dim_(N)  {};
92     Fortran_Sparse_Vector(Subscript N, Subscript nz, const T *values,
93         const Subscript *indices): val_(nz, values), index_(nz, indices),
94             dim_(N) {}
95
96     Fortran_Sparse_Vector(const Fortran_Sparse_Vector<T> &S): 
97         val_(S.val_), index_(S.index_), dim_(S.dim_) {}
98
99     // initialize from string, e.g.
100     //
101     //  Fortran_Sparse_Vector<T> A(N, 2, "1.0 2.1", "1 3");
102     //
103     Fortran_Sparse_Vector(Subscript N, Subscript nz, char *v,
104         char *ind) : val_(nz, v), index_(nz, ind), dim_(N) {}
105     
106     // assignments
107
108     Fortran_Sparse_Vector<T> & newsize(Subscript N, Subscript nz)
109     {
110         val_.newsize(nz);
111         index_.newsize(nz);
112         dim_ = N;
113         return *this;
114     }
115
116     Fortran_Sparse_Vector<T> & operator=( const Fortran_Sparse_Vector<T> &A)
117     {
118         val_ = A.val_;
119         index_ = A.index_;
120         dim_ = A.dim_;
121
122         return *this;
123     }
124
125     // methods
126
127
128
129 };
130
131
132 /* ***************************  I/O  ********************************/
133
134 template <class T>
135 ostream& operator<<(ostream &s, const Fortran_Sparse_Vector<T> &A)
136 {
137     // output format is :   N nz val1 ind1 val2 ind2 ... 
138     Subscript nz=A.num_nonzeros();
139
140     s <<  A.dim() << " " << nz << endl;
141
142     for (Subscript i=1; i<=nz; i++)
143         s   << A.val(i) << "  " << A.index(i) << endl;
144     s << endl;
145
146     return s;
147 }
148
149
150 template <class T>
151 istream& operator>>(istream &s, Fortran_Sparse_Vector<T> &A)
152 {
153     // output format is :   N nz val1 ind1 val2 ind2 ... 
154
155     Subscript N;
156     Subscript nz;
157
158     s >> N >> nz;
159
160     A.newsize(N, nz);
161
162     for (Subscript i=1; i<=nz; i++)
163             s >>  A.val(i) >> A.index(i);
164
165
166     return s;
167 }
168
169 } // namespace TNT
170
171 #endif // FSPVEC_H
172