0022922: Clean up warnings on uninitialized / unused variables
[occt.git] / src / math / math_Vector.cxx
CommitLineData
7fd59977 1//#ifndef DEB
2#define No_Standard_RangeError
3#define No_Standard_OutOfRange
4#define No_Standard_DimensionError
5//#endif
6
7#include <stdio.h>
8
9#include <math_Vector.ixx>
10#include <math_Matrix.hxx>
11
12#include <Standard_DimensionError.hxx>
13#include <Standard_DivideByZero.hxx>
14#include <Standard_RangeError.hxx>
15#include <Standard_NullValue.hxx>
16
17
18math_Vector::math_Vector(const Standard_Integer Lower,
19 const Standard_Integer Upper):
20
21 LowerIndex(Lower),
22 UpperIndex(Upper),
23 Array(Lower,Upper) {
24 Standard_RangeError_Raise_if(Lower > Upper, "");
25 }
26
27math_Vector::math_Vector(const Standard_Integer Lower,
28 const Standard_Integer Upper,
29 const Standard_Real InitialValue):
30
31 LowerIndex(Lower),
32 UpperIndex(Upper),
33 Array(Lower,Upper)
34{
35 Standard_RangeError_Raise_if(Lower > Upper, "");
36 Array.Init(InitialValue);
37}
38
39math_Vector::math_Vector(const Standard_Address Tab,
40 const Standard_Integer Lower,
41 const Standard_Integer Upper) :
42
43 LowerIndex(Lower),
44 UpperIndex(Upper),
45 Array(*((const Standard_Real *)Tab), Lower,Upper)
46{
47 Standard_RangeError_Raise_if((Lower > Upper) , "");
48}
49
50void math_Vector::Init(const Standard_Real InitialValue) {
51 Array.Init(InitialValue);
52}
53
54math_Vector::math_Vector(const math_Vector& Other):
55
56LowerIndex(Other.LowerIndex),
57UpperIndex(Other.UpperIndex),
58Array(Other.Array) {}
59
60
61void math_Vector::SetLower(const Standard_Integer Lower) {
62
63 Array.SetLower(Lower);
64 UpperIndex = UpperIndex - LowerIndex + Lower;
65 LowerIndex = Lower;
66}
67
68Standard_Real math_Vector::Norm() const {
69
70 Standard_Real Result = 0;
71
72 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
73 Result = Result + Array(Index) * Array(Index);
74 }
75 return Sqrt(Result);
76}
77
78Standard_Real math_Vector::Norm2() const {
79
80 Standard_Real Result = 0;
81
82 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
83 Result = Result + Array(Index) * Array(Index);
84 }
85 return Result;
86}
87
88Standard_Integer math_Vector::Max() const {
89
90 Standard_Integer I=0;
91 Standard_Real X = RealFirst();
92
93 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
94 if(Array(Index) > X) {
95 X = Array(Index);
96 I = Index;
97 }
98 }
99 return I;
100}
101
102Standard_Integer math_Vector::Min() const {
103
104 Standard_Integer I=0;
105 Standard_Real X = RealLast();
106
107 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
108 if(Array(Index) < X) {
109 X = Array(Index);
110 I = Index;
111 }
112 }
113 return I;
114}
115
116void math_Vector::Set(const Standard_Integer I1,
117 const Standard_Integer I2,
118 const math_Vector &V) {
119
120 Standard_RangeError_Raise_if((I1 < LowerIndex) ||
121 (I2 > UpperIndex) ||
122 (I1 > I2) ||
123 (I2 - I1 + 1 != V.Length()), "");
124
125 Standard_Integer I = V.Lower();
126 for(Standard_Integer Index = I1; Index <= I2; Index++) {
127 Array(Index) = V.Array(I);
128 I++;
129 }
130}
131
132void math_Vector::Normalize() {
133
134 Standard_Real Result = Norm();
135 Standard_NullValue_Raise_if((Result <= RealEpsilon()), "");
136 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
137 Array(Index) = Array(Index) / Result;
138 }
139}
140
141math_Vector math_Vector::Normalized() const {
142
143 math_Vector Result = *this;
144
145 Result.Normalize();
146 return Result;
147}
148
149void math_Vector::Invert() {
150 Standard_Integer J;
151 Standard_Real Temp;
152 for(Standard_Integer Index = LowerIndex;
153// Index <= LowerIndex + (Length()) >> 1 ; Index++) {
154 Index <= (LowerIndex + Length()) >> 1 ; Index++) {
155 J = UpperIndex + LowerIndex - Index;
156 Temp = Array(Index);
157 Array(Index) = Array(J);
158 Array(J) = Temp;
159 }
160}
161
162math_Vector math_Vector::Inverse() const {
163 math_Vector Result = *this;
164 Result.Invert();
165 return Result;
166}
167
168math_Vector math_Vector::Multiplied(const Standard_Real Right) const{
169
170 math_Vector Result (LowerIndex, UpperIndex);
171
172 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
173 Result.Array(Index) = Array(Index) * Right;
174 }
175 return Result;
176}
177
178math_Vector math_Vector::TMultiplied(const Standard_Real Right) const{
179
180 math_Vector Result (LowerIndex, UpperIndex);
181
182 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
183 Result.Array(Index) = Array(Index) * Right;
184 }
185 return Result;
186}
187
188
189void math_Vector::Multiply(const Standard_Real Right) {
190
191 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
192 Array(Index) = Array(Index) * Right;
193 }
194}
195
196
197void math_Vector::Divide(const Standard_Real Right) {
198
199 Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");
200
201 for(Standard_Integer Index =LowerIndex; Index <=UpperIndex; Index++) {
202 Array(Index) = Array(Index) / Right;
203 }
204}
205
206
207math_Vector math_Vector::Divided (const Standard_Real Right) const {
208
209 Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");
210 math_Vector temp = Multiplied(1./Right);
211 return temp;
212}
213
214
215void math_Vector::Add(const math_Vector& Right) {
216
217 Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
218
219 Standard_Integer I = Right.LowerIndex;
220 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
221 Array(Index) = Array(Index) + Right.Array(I);
222 I++;
223 }
224}
225
226math_Vector math_Vector::Added(const math_Vector& Right) const{
227
228 Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
229
230 math_Vector Result(LowerIndex, UpperIndex);
231
232 Standard_Integer I = Right.LowerIndex;
233 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
234 Result.Array(Index) = Array(Index) + Right.Array(I);
235 I++;
236 }
237 return Result;
238}
239
240
241
242void math_Vector::Subtract(const math_Vector& Right) {
243
244 Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
245
246 Standard_Integer I = Right.LowerIndex;
247 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
248 Array(Index) = Array(Index) - Right.Array(I);
249 I++;
250 }
251}
252
253
254math_Vector math_Vector::Subtracted (const math_Vector& Right) const {
255
256 Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
257
258 math_Vector Result(LowerIndex, UpperIndex);
259
260 Standard_Integer I = Right.LowerIndex;
261 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
262 Result.Array(Index) = Array(Index) - Right.Array(I);
263 I++;
264 }
265 return Result;
266}
267
268
269math_Vector math_Vector::Slice(const Standard_Integer I1,
270 const Standard_Integer I2) const
271{
272
273 Standard_RangeError_Raise_if((I1 < LowerIndex) ||
274 (I1 > UpperIndex) ||
275 (I2 < LowerIndex) ||
276 (I2 > UpperIndex) , "");
277
278
279 if(I2 >= I1) {
280 math_Vector Result(I1, I2);
281 for(Standard_Integer Index = I1; Index <= I2; Index++) {
282 Result.Array(Index) = Array(Index);
283 }
284 return Result;
285 }
286 else {
287 math_Vector Result(I2, I1);
288 for(Standard_Integer Index = I1; Index >= I2; Index--) {
289 Result.Array(Index) = Array(Index);
290 }
291 return Result;
292 }
293}
294
295
296void math_Vector::Add (const math_Vector& Left, const math_Vector& Right) {
297
298 Standard_DimensionError_Raise_if((Length() != Right.Length()) ||
299 (Right.Length() != Left.Length()), "");
300
301
302 Standard_Integer I = Left.LowerIndex;
303 Standard_Integer J = Right.LowerIndex;
304 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
305 Array(Index) = Left.Array(I) + Right.Array(J);
306 I++;
307 J++;
308 }
309}
310
311void math_Vector::Subtract (const math_Vector& Left,
312 const math_Vector& Right) {
313
314 Standard_DimensionError_Raise_if((Length() != Right.Length()) ||
315 (Right.Length() != Left.Length()), "");
316
317 Standard_Integer I = Left.LowerIndex;
318 Standard_Integer J = Right.LowerIndex;
319 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
320 Array(Index) = Left.Array(I) - Right.Array(J);
321 I++;
322 J++;
323 }
324}
325
326void math_Vector::Multiply(const math_Matrix& Left,
327 const math_Vector& Right) {
328
329 Standard_DimensionError_Raise_if((Length() != Left.RowNumber()) ||
330 (Left.ColNumber() != Right.Length()),
331 "");
332
333 Standard_Integer Index = LowerIndex;
334 for(Standard_Integer I = Left.LowerRowIndex; I <= Left.UpperRowIndex; I++) {
335 Array(Index) = 0.0;
336 Standard_Integer K = Right.LowerIndex;
337 for(Standard_Integer J = Left.LowerColIndex; J <= Left.UpperColIndex; J++) {
338 Array(Index) = Array(Index) + Left.Array(I, J) * Right.Array(K);
339 K++;
340 }
341 Index++;
342 }
343}
344
345void math_Vector::Multiply(const math_Vector& Left,
346 const math_Matrix& Right) {
347
348 Standard_DimensionError_Raise_if((Length() != Right.ColNumber()) ||
349 (Left.Length() != Right.RowNumber()),
350 "");
351
352 Standard_Integer Index = LowerIndex;
353 for(Standard_Integer J = Right.LowerColIndex; J <= Right.UpperColIndex; J++) {
354 Array(Index) = 0.0;
355 Standard_Integer K = Left.LowerIndex;
356 for(Standard_Integer I = Right.LowerRowIndex; I <= Right.UpperRowIndex; I++) {
357 Array(Index) = Array(Index) + Left.Array(K) * Right.Array(I, J);
358 K++;
359 }
360 Index++;
361 }
362}
363
364void math_Vector::TMultiply(const math_Matrix& TLeft,
365 const math_Vector& Right) {
366
367 Standard_DimensionError_Raise_if((Length() != TLeft.ColNumber()) ||
368 (TLeft.RowNumber() != Right.Length()),
369 "");
370
371 Standard_Integer Index = LowerIndex;
372 for(Standard_Integer I = TLeft.LowerColIndex; I <= TLeft.UpperColIndex; I++) {
373 Array(Index) = 0.0;
374 Standard_Integer K = Right.LowerIndex;
375 for(Standard_Integer J = TLeft.LowerRowIndex; J <= TLeft.UpperRowIndex; J++) {
376 Array(Index) = Array(Index) + TLeft.Array(J, I) * Right.Array(K);
377 K++;
378 }
379 Index++;
380 }
381}
382
383void math_Vector::TMultiply(const math_Vector& Left,
384 const math_Matrix& TRight) {
385
386 Standard_DimensionError_Raise_if((Length() != TRight.RowNumber()) ||
387 (Left.Length() != TRight.ColNumber()),
388 "");
389
390 Standard_Integer Index = LowerIndex;
391 for(Standard_Integer J = TRight.LowerRowIndex; J <= TRight.UpperRowIndex; J++) {
392 Array(Index) = 0.0;
393 Standard_Integer K = Left.LowerIndex;
394 for(Standard_Integer I = TRight.LowerColIndex;
395 I <= TRight.UpperColIndex; I++) {
396 Array(Index) = Array(Index) + Left.Array(K) * TRight.Array(J, I);
397 K++;
398 }
399 Index++;
400 }
401}
402
403
404
405
406Standard_Real math_Vector::Multiplied(const math_Vector& Right) const{
407 Standard_Real Result = 0;
408
409 Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
410
411 Standard_Integer I = Right.LowerIndex;
412 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
413 Result = Result + Array(Index) * Right.Array(I);
414 I++;
415 }
416 return Result;
417}
418
419math_Vector math_Vector::Opposite() {
420 math_Vector Result(LowerIndex, UpperIndex);
421
422 for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
423 Result.Array(Index) = - Array(Index);
424 }
425 return Result;
426}
427
428math_Vector math_Vector::Multiplied(const math_Matrix& Right)const {
429 Standard_DimensionError_Raise_if(Length() != Right.RowNumber(), "");
430
431 math_Vector Result(Right.LowerColIndex, Right.UpperColIndex);
7fd59977 432 for(Standard_Integer J2 = Right.LowerColIndex;
433 J2 <= Right.UpperColIndex; J2++) {
434 Array(J2) = 0.0;
435 Standard_Integer I2 = Right.LowerRowIndex;
436 for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) {
437 Result.Array(J2) = Result.Array(J2) + Array(I) *
438 Right.Array(I2, J2);
439 I2++;
440 }
441 }
442 return Result;
443}
444
445
446void math_Vector::Multiply(const Standard_Real Left,
447 const math_Vector& Right)
448{
449 Standard_DimensionError_Raise_if((Length() != Right.Length()),
450 "");
451 for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) {
452 Array(I) = Left * Right.Array(I);
453 }
454}
455
456
457math_Vector& math_Vector::Initialized(const math_Vector& Other) {
458
459 Standard_DimensionError_Raise_if(Length() != Other.Length(), "");
460
461 (Other.Array).Copy(Array);
462 return *this;
463}
464
465
466
467void math_Vector::Dump(Standard_OStream& o) const
468{
469 o << "math_Vector of Length = " << Length() << "\n";
470 for(Standard_Integer Index = LowerIndex;
471 Index <= UpperIndex; Index++) {
472 o << "math_Vector(" << Index << ") = " << Array(Index) << "\n";
473 }
474}