Fixes for some gcc 4 warnings in intern/. More than 100 lines of warnings
[blender.git] / intern / iksolver / intern / TNT / vecadaptor.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
31 #ifndef VECADAPTOR_H
32 #define VECADAPTOR_H
33
34 #include <cstdlib>
35 #include <iostream>
36 #include <cassert>
37
38 #include "subscript.h"
39
40 #ifdef TNT_USE_REGIONS
41 #include "region1d.h"
42 #endif
43
44 namespace TNT
45 {
46
47 //  see "tntreq.h" for TNT requirements for underlying vector
48 //  class.  This need NOT be the STL vector<> class, but a subset
49 //  that provides minimal services.
50 //
51 //  This is a container adaptor that provides the following services.
52 //
53 //      o)  adds 1-offset operator() access ([] is always 0 offset)
54 //      o)  adds TNT_BOUNDS_CHECK to () and []
55 //      o)  adds initialization from strings, e.g.  "1.0 2.0 3.0";
56 //      o)  adds newsize(N) function (does not preserve previous values)
57 //      o)  adds dim() and dim(1)
58 //      o)  adds free() function to release memory used by vector
59 //      o)  adds regions, e.g. A(Index(1,10)) = ... 
60 //      o)  add getVector() method to return adapted container
61 //      o)  adds simple I/O for ostreams
62
63 template <class BBVec>
64 class Vector_Adaptor
65 {
66
67   public:
68     typedef   typename BBVec::value_type T;
69     typedef         T   value_type;
70     typedef         T   element_type;
71     typedef         T*  pointer;
72     typedef         T*  iterator;
73     typedef         T&  reference;
74     typedef const   T*  const_iterator;
75     typedef const   T&  const_reference;
76     
77     Subscript lbound() const { return 1; }
78
79   protected:
80     BBVec v_;
81     T* vm1_;
82
83   public:
84
85     Subscript size() const { return v_.size(); }
86
87     // These were removed so that the ANSI C++ valarray class
88     // would work as a possible storage container.
89     //
90     //
91     //iterator begin() { return v_.begin();}
92     //iterator begin() { return &v_[0];}
93     //
94     //iterator end()   { return v_.end(); }
95     //iterator end()   { return &v_[0] + v_.size(); }
96     //
97     //const_iterator begin() const { return v_.begin();}
98     //const_iterator begin() const { return &v_[0];}
99     //
100     //const_iterator end()  const { return v_.end(); }
101     //const_iterator end()  const { return &v_[0] + v_.size(); }
102
103     BBVec& getVector() { return v_; }
104     Subscript dim() const { return v_.size(); }
105     Subscript dim(Subscript i)
106     {
107 #ifdef TNT_BOUNDS_CHECK
108         assert(i==TNT_BASE_OFFSET);
109 #endif
110         return (i==TNT_BASE_OFFSET ? v_.size() : 0 );
111     }
112     Vector_Adaptor() : v_() {};
113     Vector_Adaptor(const Vector_Adaptor<BBVec> &A) : v_(A.v_) 
114     { 
115         vm1_ = ( v_.size() > 0 ? &(v_[0]) -1 : NULL); 
116
117     } 
118
119     Vector_Adaptor(Subscript N, const T& value = T()) : v_(N)
120     {
121         for (Subscript i=0; i<N; i++)
122              v_[i]  = value;
123         
124         vm1_ = ( v_.size() > 0 ? &(v_[0]) -1 : NULL); 
125     }
126
127     Vector_Adaptor(Subscript N, const T* values) : v_(N)
128     {
129         for (Subscript i=0; i<N; i++)
130              v_[i]  = values[i];
131         vm1_ = ( v_.size() > 0 ? &(v_[0]) -1 : NULL); 
132     } 
133     Vector_Adaptor(const BBVec & A) : v_(A) 
134     {
135         vm1_ = ( v_.size() > 0 ? &(v_[0]) -1 : NULL); 
136     }
137
138     // NOTE: this assumes that BBVec(0) constructor creates an 
139     //  null vector that does not take up space...  It would be
140     //  great to require that BBVec have a corresponding free()
141     //  function, but in particular STL vectors do not.
142     //
143     Vector_Adaptor<BBVec>& free()
144     {
145         return *this = Vector_Adaptor<BBVec>(0);
146     }
147
148     Vector_Adaptor<BBVec>& operator=(const Vector_Adaptor<BBVec> &A) 
149     { 
150         v_ = A.v_ ; 
151         vm1_ = ( v_.size() > 0 ? &(v_[0]) -1 : NULL); 
152         return *this;
153     }
154
155     Vector_Adaptor<BBVec>& newsize(Subscript N)
156     {
157         // NOTE: this is not as efficient as it could be
158         // but to retain compatiblity with STL interface
159         // we cannot assume underlying implementation
160         // has a newsize() function.
161
162         return *this = Vector_Adaptor<BBVec>(N);
163
164     }
165
166     Vector_Adaptor<BBVec>& operator=(const T &a) 
167     {
168         Subscript i;
169         Subscript N = v_.size();    
170         for (i=0; i<N; i++)
171             v_[i] = a;
172
173         return *this;
174     }
175
176     Vector_Adaptor<BBVec>& resize(Subscript N) 
177     { 
178         if (N == size()) return *this;
179
180         Vector_Adaptor<BBVec> tmp(N);
181         Subscript n =  (N < size() ? N : size());  // min(N, size());
182         Subscript i;
183
184         for (i=0; i<n; i++)
185             tmp[i] = v_[i];
186             
187
188         return (*this = tmp);
189
190     }
191
192
193     reference operator()(Subscript i)
194     { 
195 #ifdef TNT_BOUNDS_CHECK
196         assert(1<=i);
197         assert(i<=dim());
198 #endif
199         return vm1_[i]; 
200     }
201
202     const_reference operator()(Subscript i) const
203     { 
204 #ifdef TNT_BOUNDS_CHECK
205         assert(1<=i);
206         assert(i<=dim());
207 #endif
208         return vm1_[i]; 
209     }
210
211     reference operator[](Subscript i)
212     { 
213 #ifdef TNT_BOUNDS_CHECK
214         assert(0<=i);
215         assert(i<dim());
216 #endif
217         return v_[i]; 
218     }
219
220     const_reference operator[](Subscript i) const
221     { 
222 #ifdef TNT_BOUNDS_CHECK
223         assert(0<=i);
224         assert(i<dim());
225 #endif
226         return v_[i]; 
227     }
228
229
230 #ifdef TNT_USE_REGIONS
231     // "index-aware" features, all of these are 1-based offsets
232
233     typedef Region1D<Vector_Adaptor<BBVec> > Region;
234
235     typedef const_Region1D< Vector_Adaptor<BBVec> > const_Region;
236
237     Region operator()(const Index1D &I)
238     {   return Region(*this, I); }
239
240     Region operator()(const Subscript i1, Subscript i2)
241     {   return Region(*this, i1, i2); }
242
243     const_Region operator()(const Index1D &I) const
244     {   return const_Region(*this, I); }
245
246     const_Region operator()(const Subscript i1, Subscript i2) const
247     {   return const_Region(*this, i1, i2); }
248 #endif
249 // TNT_USE_REGIONS
250
251
252 };
253
254 #include <iostream>
255
256 template <class BBVec>
257 std::ostream& operator<<(std::ostream &s, const Vector_Adaptor<BBVec> &A)
258 {
259     Subscript M=A.size();
260
261     s << M << endl;
262     for (Subscript i=1; i<=M; i++)
263             s << A(i) << endl;
264     return s;
265 }
266
267 template <class BBVec>
268 std::istream& operator>>(std::istream &s, Vector_Adaptor<BBVec> &A)
269 {
270     Subscript N;
271     
272     s >> N;
273
274     A.resize(N);
275
276     for (Subscript i=1; i<=N; i++)
277         s >> A(i);
278
279     return s;
280 }
281
282 } // namespace TNT
283
284 #endif
285