doxygen: intern/smoke tagged.
[blender.git] / intern / smoke / intern / tnt / tnt_vec.h
1 /** \file smoke/intern/tnt/tnt_vec.h
2  *  \ingroup smoke
3  */
4 /*
5 *
6 * Template Numerical Toolkit (TNT)
7 *
8 * Mathematical and Computational Sciences Division
9 * National Institute of Technology,
10 * Gaithersburg, MD USA
11 *
12 *
13 * This software was developed at the National Institute of Standards and
14 * Technology (NIST) by employees of the Federal Government in the course
15 * of their official duties. Pursuant to title 17 Section 105 of the
16 * United States Code, this software is not subject to copyright protection
17 * and is in the public domain. NIST assumes no responsibility whatsoever for
18 * its use by other parties, and makes no guarantees, expressed or implied,
19 * about its quality, reliability, or any other characteristic.
20 *
21 */
22
23
24
25 #ifndef TNT_VEC_H
26 #define TNT_VEC_H
27
28 #include "tnt_subscript.h"
29 #include <cstdlib>
30 #include <cassert>
31 #include <iostream>
32 #include <sstream>
33
34 namespace TNT
35 {
36
37 /**
38  <b>[Deprecatred]</b>  Value-based vector class from pre-1.0
39         TNT version.  Kept here for backward compatiblity, but should
40         use the newer TNT::Array1D classes instead.
41
42 */
43
44 template <class T>
45 class Vector 
46 {
47
48
49   public:
50
51     typedef Subscript   size_type;
52     typedef         T   value_type;
53     typedef         T   element_type;
54     typedef         T*  pointer;
55     typedef         T*  iterator;
56     typedef         T&  reference;
57     typedef const   T*  const_iterator;
58     typedef const   T&  const_reference;
59
60     Subscript lbound() const { return 1;}
61  
62   protected:
63     T* v_;                  
64     T* vm1_;        // pointer adjustment for optimzied 1-offset indexing
65     Subscript n_;
66
67     // internal helper function to create the array
68     // of row pointers
69
70     void initialize(Subscript N)
71     {
72         // adjust pointers so that they are 1-offset:
73         // v_[] is the internal contiguous array, it is still 0-offset
74         //
75         assert(v_ == NULL);
76         v_ = new T[N];
77         assert(v_  != NULL);
78         vm1_ = v_-1;
79         n_ = N;
80     }
81    
82     void copy(const T*  v)
83     {
84         Subscript N = n_;
85         Subscript i;
86
87 #ifdef TNT_UNROLL_LOOPS
88         Subscript Nmod4 = N & 3;
89         Subscript N4 = N - Nmod4;
90
91         for (i=0; i<N4; i+=4)
92         {
93             v_[i] = v[i];
94             v_[i+1] = v[i+1];
95             v_[i+2] = v[i+2];
96             v_[i+3] = v[i+3];
97         }
98
99         for (i=N4; i< N; i++)
100             v_[i] = v[i];
101 #else
102
103         for (i=0; i< N; i++)
104             v_[i] = v[i];
105 #endif      
106     }
107
108     void set(const T& val)
109     {
110         Subscript N = n_;
111         Subscript i;
112
113 #ifdef TNT_UNROLL_LOOPS
114         Subscript Nmod4 = N & 3;
115         Subscript N4 = N - Nmod4;
116
117         for (i=0; i<N4; i+=4)
118         {
119             v_[i] = val;
120             v_[i+1] = val;
121             v_[i+2] = val;
122             v_[i+3] = val; 
123         }
124
125         for (i=N4; i< N; i++)
126             v_[i] = val;
127 #else
128
129         for (i=0; i< N; i++)
130             v_[i] = val;
131         
132 #endif      
133     }
134     
135
136
137     void destroy()
138     {     
139         /* do nothing, if no memory has been previously allocated */
140         if (v_ == NULL) return ;
141
142         /* if we are here, then matrix was previously allocated */
143         delete [] (v_);     
144
145         v_ = NULL;
146         vm1_ = NULL;
147     }
148
149
150   public:
151
152     // access
153
154     iterator begin() { return v_;}
155     iterator end()   { return v_ + n_; }
156     iterator begin() const { return v_;}
157     iterator end() const  { return v_ + n_; }
158
159     // destructor
160
161     ~Vector() 
162     {
163         destroy();
164     }
165
166     // constructors
167
168     Vector() : v_(0), vm1_(0), n_(0)  {};
169
170     Vector(const Vector<T> &A) : v_(0), vm1_(0), n_(0)
171     {
172         initialize(A.n_);
173         copy(A.v_);
174     }
175
176     Vector(Subscript N, const T& value = T()) :  v_(0), vm1_(0), n_(0)
177     {
178         initialize(N);
179         set(value);
180     }
181
182     Vector(Subscript N, const T* v) :  v_(0), vm1_(0), n_(0)
183     {
184         initialize(N);
185         copy(v);
186     }
187
188     Vector(Subscript N, char *s) :  v_(0), vm1_(0), n_(0)
189     {
190         initialize(N);
191         std::istringstream ins(s);
192
193         Subscript i;
194
195         for (i=0; i<N; i++)
196                 ins >> v_[i];
197     }
198
199
200     // methods
201     // 
202     Vector<T>& newsize(Subscript N)
203     {
204         if (n_ == N) return *this;
205
206         destroy();
207         initialize(N);
208
209         return *this;
210     }
211
212
213     // assignments
214     //
215     Vector<T>& operator=(const Vector<T> &A)
216     {
217         if (v_ == A.v_)
218             return *this;
219
220         if (n_ == A.n_)         // no need to re-alloc
221             copy(A.v_);
222
223         else
224         {
225             destroy();
226             initialize(A.n_);
227             copy(A.v_);
228         }
229
230         return *this;
231     }
232         
233     Vector<T>& operator=(const T& scalar)
234     { 
235         set(scalar);  
236         return *this;
237     }
238
239     inline Subscript dim() const 
240     {
241         return  n_; 
242     }
243
244     inline Subscript size() const 
245     {
246         return  n_; 
247     }
248
249
250     inline reference operator()(Subscript i)
251     { 
252 #ifdef TNT_BOUNDS_CHECK
253         assert(1<=i);
254         assert(i <= n_) ;
255 #endif
256         return vm1_[i]; 
257     }
258
259     inline const_reference operator() (Subscript i) const
260     {
261 #ifdef TNT_BOUNDS_CHECK
262         assert(1<=i);
263         assert(i <= n_) ;
264 #endif
265         return vm1_[i]; 
266     }
267
268     inline reference operator[](Subscript i)
269     { 
270 #ifdef TNT_BOUNDS_CHECK
271         assert(0<=i);
272         assert(i < n_) ;
273 #endif
274         return v_[i]; 
275     }
276
277     inline const_reference operator[](Subscript i) const
278     {
279 #ifdef TNT_BOUNDS_CHECK
280         assert(0<=i);
281
282
283
284
285
286
287         assert(i < n_) ;
288 #endif
289         return v_[i]; 
290     }
291
292
293
294 };
295
296
297 /* ***************************  I/O  ********************************/
298
299 template <class T>
300 std::ostream& operator<<(std::ostream &s, const Vector<T> &A)
301 {
302     Subscript N=A.dim();
303
304     s <<  N << "\n";
305
306     for (Subscript i=0; i<N; i++)
307         s   << A[i] << " " << "\n";
308     s << "\n";
309
310     return s;
311 }
312
313 template <class T>
314 std::istream & operator>>(std::istream &s, Vector<T> &A)
315 {
316
317     Subscript N;
318
319     s >> N;
320
321     if ( !(N == A.size() ))
322     {
323         A.newsize(N);
324     }
325
326
327     for (Subscript i=0; i<N; i++)
328             s >>  A[i];
329
330
331     return s;
332 }
333
334 // *******************[ basic matrix algorithms ]***************************
335
336
337 template <class T>
338 Vector<T> operator+(const Vector<T> &A, 
339     const Vector<T> &B)
340 {
341     Subscript N = A.dim();
342
343     assert(N==B.dim());
344
345     Vector<T> tmp(N);
346     Subscript i;
347
348     for (i=0; i<N; i++)
349             tmp[i] = A[i] + B[i];
350
351     return tmp;
352 }
353
354 template <class T>
355 Vector<T> operator-(const Vector<T> &A, 
356     const Vector<T> &B)
357 {
358     Subscript N = A.dim();
359
360     assert(N==B.dim());
361
362     Vector<T> tmp(N);
363     Subscript i;
364
365     for (i=0; i<N; i++)
366             tmp[i] = A[i] - B[i];
367
368     return tmp;
369 }
370
371 template <class T>
372 Vector<T> operator*(const Vector<T> &A, 
373     const Vector<T> &B)
374 {
375     Subscript N = A.dim();
376
377     assert(N==B.dim());
378
379     Vector<T> tmp(N);
380     Subscript i;
381
382     for (i=0; i<N; i++)
383             tmp[i] = A[i] * B[i];
384
385     return tmp;
386 }
387
388
389 template <class T>
390 T dot_prod(const Vector<T> &A, const Vector<T> &B)
391 {
392     Subscript N = A.dim();
393     assert(N == B.dim());
394
395     Subscript i;
396     T sum = 0;
397
398     for (i=0; i<N; i++)
399         sum += A[i] * B[i];
400
401     return sum;
402 }
403
404 }   /* namespace TNT */
405
406 #endif
407 // TNT_VEC_H