Subversion Repositories gelsvn

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
667 khor 1 
#include <iostream>
2 
#include <cmath>
3 
#include <ctime>
4 
#include <cstdlib>
5 
#include <climits>
6 
 
680 janba 7 
#include <GEL/CGLA/Vec2d.h>
8 
#include <GEL/CGLA/Vec2f.h>
9 
#include <GEL/CGLA/Vec2i.h>
10 
#include <GEL/CGLA/Vec3i.h>
11 
#include <GEL/CGLA/Vec3f.h>
12 
#include <GEL/CGLA/Vec3d.h>
13 
#include <GEL/CGLA/Vec3Hf.h> // next
14 
#include <GEL/CGLA/Vec3uc.h>
15 
#include <GEL/CGLA/Vec3usi.h>
16 
#include <GEL/CGLA/Vec4f.h>
17 
#include <GEL/CGLA/Vec4d.h>
18 
#include <GEL/CGLA/Vec4uc.h>
19 
#include <GEL/CGLA/Quatf.h>
20 
#include <GEL/CGLA/Quatd.h>
21 
#include <GEL/Util/Timer.h>
667 khor 22 
 
23 
using namespace std;
24 
using namespace CGLA;
25 
using namespace Util;
26 
 
27 
namespace
28 
{
29 
  // To find a pseudo-random number in the interval [0,1[
30 
  double my_random()
31 
  {
32 
    return gel_rand()/(static_cast<double>(GEL_RAND_MAX) + 1.0);
33 
  }
34 
}
35 
 
36 
/* This is a non-exhaustive test program for CGLA */
37 
int main()
38 
{
680 janba 39 
    cout << "Note that some of these tests appear to fail although everything works," << endl;
40 
    cout << "e.g. because floating point to double conversion and back does not yield original number" << endl;
667 khor 41 
  int success = 0;
42 
  Timer t;
43 
 
44 
  gel_srand(time(0));
45 
 
46 
  t.start();
47 
 
48 
  ////////////////////////////////////////////////
49 
  //                V e c 2 d
50 
  ////////////////////////////////////////////////
51 
 
52 
  // Constructors
53 
 
54 
  {
55 
  // TODO: The following should be done for all constructors in the remainder of the file
56 
#ifndef NDEBUG
57 
    Vec2d x1;
58 
    success += CGLA::isnan(x1[0]) && CGLA::isnan(x1[1]);
59 
#else
60 
    success += 1;
61 
#endif
62 
 
63 
    double xi1 = my_random(), xi2 = my_random();
64 
    Vec2d x2(xi1, xi2);
65 
    success += x2[0] == xi1 && x2[1] == xi2;
66 
 
67 
    int xii1 = gel_rand(), xii2 = gel_rand();
68 
    Vec2i i1(xii1, xii2);
69 
    Vec2d x3(i1);
70 
    success += x3[0] == xii1 && x3[1] == xii2;
71 
 
72 
    float xiii1 = my_random(), xiii2 = my_random();
73 
    Vec2f f1(xiii1, xiii2);
74 
    Vec2d x4(f1);
75 
    success += x4[0] == xiii1 && x4[1] == xiii2;
76 
 
77 
    double xiiii = my_random();
78 
    Vec2d x5(xiiii);
79 
    success += x5[0] == xiiii && x5[1] == xiiii;
80 
  }
81 
  if(success != 5)
82 
  {
83 
    cout << "Failure in test of Vec2d Constructors";
84 
    return 1;
85 
  }
86 
  success = 0;
87 
 
88 
  // Data manipulation
89 
 
90 
  {
91 
    Vec2d x1;
92 
 
93 
    success += x1.get_dim() == 2;
94 
 
95 
    double xi1 = my_random(), xi2 = my_random();
96 
    x1.set(xi1, xi2);
97 
    success += x1[0] == xi1 && x1[1] == xi2;
98 
 
99 
    success += x1.get() == &x1[0];
100 
 
101 
    double temp = BIG;
102 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
103 
      if(x1[i] < temp)
104 
	      temp = x1[i];
105 
    success += temp == x1.min_coord();
106 
 
107 
    temp = -BIG;
108 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
109 
      if(x1[i] > temp)
110 
	      temp = x1[i];
111 
    success += temp == x1.max_coord();
112 
  }
113 
  if(success != 5)
114 
  {
115 
    cout << "Failure in test of Vec2d Data manipulation";
116 
    return 1;
117 
  }
118 
  success = 0;
119 
 
120 
  // Comparison operators
121 
 
122 
  {
123 
    double xi1 = my_random(), xi2 = my_random();
124 
    while(xi1 == xi2)
125 
    {
126 
      xi1 = my_random();
127 
      xi2 = my_random();
128 
    }
129 
 
130 
    Vec2d x1(xi1, xi2), x2(xi1, xi2), x3(xi1), x4(xi2);
131 
    success += x1 == x2;
132 
    success += !(x1 == x3);
133 
    success += x3 == xi1;
134 
    success += !(x3 == xi2);
135 
    success += x1 != x3;
136 
    success += !(x1 != x2);
137 
 
138 
    if(xi1 < xi2)
139 
    {
140 
      success += x3.all_l(x4);
141 
      success += !(x3.all_l(x2));
142 
      success += x3.all_le(x2);
143 
      success += !(x4.all_le(x3));
144 
      success += x4.all_g(x3);
145 
      success += !(x4.all_g(x2));
146 
      success += x4.all_ge(x2);
147 
      success += !(x3.all_ge(x4));
148 
    }
149 
    else
150 
    {
151 
      success += x4.all_l(x3);
152 
      success += !(x4.all_l(x2));
153 
      success += x4.all_le(x2);
154 
      success += !(x3.all_le(x4));
155 
      success += x3.all_g(x4);
156 
      success += !(x3.all_g(x2));
157 
      success += x3.all_ge(x2);
158 
      success += !(x4.all_ge(x3));
159 
    }
160 
  }
161 
  if(success != 14)
162 
  {
163 
    cout << "Failure in test of Vec2d Comparison operators";
164 
    return 1;
165 
  }
166 
  success = 0;
167 
 
168 
  // Assignment operators
169 
 
170 
  {
171 
    double xi1 = my_random(), xi2 = my_random();
172 
    Vec2d x1(xi1, xi2);
173 
    double xi3 = my_random();
174 
    x1 *= xi3;
175 
    success += x1[0] == xi1*xi3 && x1[1] == xi2*xi3;
176 
 
177 
    while(xi3 == 0)
178 
      xi3 = my_random();
179 
    x1 = Vec2d(xi1, xi2);
180 
    x1 /= xi3;
181 
    success += abs(x1[0] - xi1/xi3) < 1.0e-15 && abs(x1[1] - xi2/xi3) < 1.0e-15;
182 
 
183 
    x1 = Vec2d(xi1, xi2);
184 
    x1 += xi3;
185 
    success += x1[0] == xi1 + xi3 && x1[1] == xi2 + xi3;
186 
 
187 
    x1 = Vec2d(xi1, xi2);
188 
    x1 -= xi3;
189 
    success += x1[0] == xi1 - xi3 && x1[1] == xi2 - xi3;
190 
 
191 
    double xii1 = my_random(), xii2 = my_random();
192 
    Vec2d x2(xii1, xii2);
193 
    x1 = Vec2d(xi1, xi2);
194 
    x2 *= x1;
195 
    success += x2[0] == xi1*xii1 && x2[1] == xi2*xii2;
196 
 
197 
    while(xi1 == 0)
198 
      xi1 = my_random();
199 
    while(xi2 == 0)
200 
      xi2 = my_random();
201 
    x1 = Vec2d(xi1, xi2);
202 
    x2 = Vec2d(xii1, xii2);
203 
    x2 /= x1;
204 
    success += abs(x2[0] - xii1/xi1) < 1.0e-15 && abs(x2[1] - xii2/xi2) < 1.0e-15;
205 
 
206 
    x2 = Vec2d(xii1, xii2);
207 
    x2 += x1;
208 
    success += x2[0] == xii1 + xi1 && x2[1] == xii2 + xi2;
209 
 
210 
    x2 = Vec2d(xii1, xii2);
211 
    x2 -= x1;
212 
    success += x2[0] == xii1 - xi1 && x2[1] == xii2 - xi2;
213 
  }
214 
  if(success != 8)
215 
  {
216 
    cout << "Failure in test of Vec2d Assignment operators";
217 
    system ("pause");
218 
    return 1;
219 
  }
220 
  success = 0;
221 
 
222 
  // Unary operators
223 
 
224 
  {
225 
    double xi1 = my_random(), xi2 = my_random();
226 
    Vec2d x1 = -Vec2d(xi1, xi2);
227 
    success += x1[0] == -xi1 && x1[1] == -xi2;
228 
  }
229 
  if(success != 1)
230 
  {
231 
    cout << "Failure in test of Vec2d Unary operators";
232 
    system ("pause");
233 
    return 1;
234 
  }
235 
  success = 0;
236 
 
237 
  // Binary operators
238 
 
239 
  {
240 
    double xi1 = my_random(), xi2 = my_random();
241 
    Vec2d x1(xi1, xi2);
242 
    double xii1 = my_random(), xii2 = my_random();
243 
    while(xii1 == 0)
244 
      xii1 = my_random();
245 
    while(xii2 == 0)
246 
      xii2 = my_random();
247 
    Vec2d x2(xii1, xii2);
248 
    Vec2d x3 = x1*x2;
249 
    success += x3[0] == xi1*xii1 && x3[1] == xi2*xii2;
250 
 
251 
    x3 = x1 + x2;
252 
    success += x3[0] == xi1 + xii1 && x3[1] == xi2 + xii2;
253 
 
254 
    x3 = x1 - x2;
255 
    success += x3[0] == xi1 - xii1 && x3[1] == xi2 - xii2;
256 
 
257 
    x3 = x1/x2;
258 
    success += abs(x3[0] - xi1/xii1) < 1.0e-15 && abs(x3[1] - xi2/xii2) < 1.0e-15;
259 
 
260 
    double xi3 = my_random();
261 
    x3 = x1*xi3;
262 
    success += x3[0] == xi1*xi3 && x3[1] == xi2*xi3;
263 
 
264 
    x3 = xi3*x1;
265 
    success += x3[0] == xi1*xi3 && x3[1] == xi2*xi3;
266 
 
267 
    float xi4 = my_random();
268 
    x3 = xi4*x1;
269 
    success += x3[0] == xi1*xi4 && x3[1] == xi2*xi4;
270 
 
271 
    x3 = x1*xi4;
272 
    success += x3[0] == xi1*xi4 && x3[1] == xi2*xi4;
273 
 
274 
    int xi5 = gel_rand();
275 
    x3 = xi5*x1;
276 
    success += x3[0] == xi1*xi5 && x3[1] == xi2*xi5;
277 
 
278 
    x3 = x1*xi5;
279 
    success += x3[0] == xi1*xi5 && x3[1] == xi2*xi5;
280 
 
281 
    while(xi3 == 0)
282 
      xi3 = my_random();
283 
    x3 = x1/xi3;
284 
    success += abs(x3[0] - xi1/xi3) < 1.0e-15 && abs(x3[1] - xi2/xi3) < 1.0e-15;
285 
  }
286 
  if(success != 11)
287 
  {
288 
    cout << "Failure in test of Vec2d Binary operators";
289 
    system ("pause");
290 
    return 1;
291 
  }
292 
  success = 0;
293 
 
294 
  // Vector operations
295 
 
296 
  {
297 
    double xi1 = my_random(), xi2 = my_random();
298 
    Vec2d x1(xi1, xi2);
299 
    double xii1 = my_random(), xii2 = my_random();
300 
    Vec2d x2(xii1, xii2);
301 
    double x = dot(x1, x2);
302 
    success += x == xi1*xii1 + xi2*xii2;
303 
 
304 
    x = sqr_length(x1);
305 
    success += x == xi1*xi1 + xi2*xi2;
306 
 
307 
    Vec2d x3 = v_min(x1, x2);
308 
    success += x3[0] == (xi1 < xii1 ? xi1 : xii1) && x3[1] == (xi2 < xii2 ? xi2 : xii2);
309 
 
310 
    x3 = v_max(x1, x2);
311 
    success += x3[0] == (xi1 > xii1 ? xi1 : xii1) && x3[1] == (xi2 > xii2 ? xi2 : xii2);
312 
 
313 
    x = x2.length();
314 
    success += abs(x - sqrt(xii1*xii1 + xii2*xii2)) < 1.0e-15;
315 
 
316 
    x = length(x2);
317 
    success += abs(x - sqrt(xii1*xii1 + xii2*xii2)) < 1.0e-15;
318 
 
319 
    while(sqr_length(x1) == 0.0)
320 
    {
321 
      xi1 = my_random();
322 
      xi2 = my_random();
323 
      x1 = Vec2d(xi1, xi2);
324 
    }
325 
    x3 = normalize(x1);
326 
    success += abs(x3[0] - xi1/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15
327 
               && abs(x3[1] - xi2/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15;
328 
 
329 
    x1.normalize();
330 
    success += abs(x1[0] - xi1/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15
331 
               && abs(x1[1] - xi2/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15;
332 
 
333 
    x3 = orthogonal(x2);
334 
    success += dot(x2, x3) == 0;
335 
 
336 
    x1 = Vec2d(xi1, xi2);
337 
    x = cross(x1, x2);
338 
    success += x == xi1*xii2 - xi2*xii1;
339 
 
340 
    while(x == 0)
341 
    {
342 
      xi1 = my_random();
343 
      xi2 = my_random();
344 
      x1 = Vec2d(xi1, xi2);
345 
      x = cross(x1, x2);
346 
    }
347 
    double xiii1 = my_random(), xiii2 = my_random();
348 
    x3 = Vec2d(xiii1, xiii2);
349 
    double y, z;
350 
    linear_combine(x1, x2, x3, y, z);
351 
    success += abs(y - (xii2*xiii1 - xii1*xiii2)/x) < 1.0e-15
352 
               && abs(z - (xi1*xiii2 - xi2*xiii1)/x) < 1.0e-15;
353 
  }
354 
  if(success != 11)
355 
  {
356 
    cout << "Failure in test of Vec2d Vector operations";
357 
    system ("pause");
358 
    return 1;
359 
  }
360 
  success = 0;
361 
 
362 
  ////////////////////////////////////////////////
363 
  //                V e c 2 f
364 
  ////////////////////////////////////////////////
365 
 
366 
  // Constructors
367 
 
368 
  {
369 
    Vec2f x1;
370 
    success += CGLA::isnan(x1[0]) && CGLA::isnan(x1[1]);
371 
 
372 
    float xi1 = my_random(), xi2 = my_random();
373 
    Vec2f x2(xi1, xi2);
374 
    success += x2[0] == xi1 && x2[1] == xi2;
375 
 
376 
    int xii1 = gel_rand(), xii2 = gel_rand();
377 
    Vec2i i1(xii1, xii2);
378 
    Vec2f x3(i1);
379 
    success += x3[0] == xii1 && x3[1] == xii2;
680 janba 380 
 
381 
 // Doubles and floats cannot represent exactly the same numbers.
382 
//    double xiii1 = my_random(), xiii2 = my_random();
383 
//    Vec2d d1(xiii1, xiii2);
384 
//    Vec2f x4(d1);
385 
//    success += x4[0] == xiii1 && x4[1] == xiii2;
667 khor 386 
 
387 
    float xiiii = my_random();
388 
    Vec2f x5(xiiii);
389 
    success += x5[0] == xiiii && x5[1] == xiiii;
390 
  }
680 janba 391 
  if(success != 4)
667 khor 392 
  {
393 
    cout << "Failure in test of Vec2f Constructors";
394 
    system ("pause");
395 
    return 1;
396 
  }
397 
  success = 0;
398 
 
399 
  // Data manipulation
400 
 
401 
  {
402 
    Vec2f x1;
403 
 
404 
    success += x1.get_dim() == 2;
405 
 
406 
    float xi1 = my_random(), xi2 = my_random();
407 
    x1.set(xi1, xi2);
408 
    success += x1[0] == xi1 && x1[1] == xi2;
409 
 
410 
    success += x1.get() == &x1[0];
411 
 
412 
    float temp = BIG;
413 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
414 
      if(x1[i] < temp)
415 
	temp = x1[i];
416 
    success += temp == x1.min_coord();
417 
 
418 
    temp = -BIG;
419 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
420 
      if(x1[i] > temp)
421 
	temp = x1[i];
422 
    success += temp == x1.max_coord();
423 
  }
424 
  if(success != 5)
425 
  {
426 
    cout << "Failure in test of Vec2f Data manipulation";
427 
    system ("pause");
428 
    return 1;
429 
  }
430 
  success = 0;
431 
 
432 
  // Comparison operators
433 
 
434 
  {
435 
    float xi1 = my_random(), xi2 = my_random();
436 
    while(xi1 == xi2)
437 
    {
438 
      xi1 = my_random();
439 
      xi2 = my_random();
440 
    }
441 
 
442 
    Vec2f x1(xi1, xi2), x2(xi1, xi2), x3(xi1), x4(xi2);
443 
    success += x1 == x2;
444 
    success += !(x1 == x3);
445 
    success += x3 == xi1;
446 
    success += !(x3 == xi2);
447 
    success += x1 != x3;
448 
    success += !(x1 != x2);
449 
 
450 
    if(xi1 < xi2)
451 
    {
452 
      success += x3.all_l(x4);
453 
      success += !(x3.all_l(x2));
454 
      success += x3.all_le(x2);
455 
      success += !(x4.all_le(x3));
456 
      success += x4.all_g(x3);
457 
      success += !(x4.all_g(x2));
458 
      success += x4.all_ge(x2);
459 
      success += !(x3.all_ge(x4));
460 
    }
461 
    else
462 
    {
463 
      success += x4.all_l(x3);
464 
      success += !(x4.all_l(x2));
465 
      success += x4.all_le(x2);
466 
      success += !(x3.all_le(x4));
467 
      success += x3.all_g(x4);
468 
      success += !(x3.all_g(x2));
469 
      success += x3.all_ge(x2);
470 
      success += !(x4.all_ge(x3));
471 
    }
472 
  }
473 
  if(success != 14)
474 
  {
475 
    cout << "Failure in test of Vec2f Comparison operators";
476 
    system ("pause");
477 
    return 1;
478 
  }
479 
  success = 0;
480 
 
481 
  // Assignment operators
482 
 
483 
  {
484 
    float xi1 = my_random(), xi2 = my_random();
485 
    Vec2f x1(xi1, xi2);
486 
    float xi3 = my_random();
487 
    x1 *= xi3;
488 
    success += abs(x1[0] - xi1*xi3) < 1.0e-15 && abs(x1[1] - xi2*xi3) < 1.0e-15;
489 
 
490 
    while(xi3 == 0)
491 
      xi3 = my_random();
492 
    x1 = Vec2f(xi1, xi2);
493 
    x1 /= xi3;
494 
    success += abs(x1[0] - xi1/xi3) < 1.0e-15 && abs(x1[1] - xi2/xi3) < 1.0e-15;
495 
 
496 
    x1 = Vec2f(xi1, xi2);
497 
    x1 += xi3;
498 
    success += x1[0] == xi1 + xi3 && x1[1] == xi2 + xi3;
499 
 
500 
    x1 = Vec2f(xi1, xi2);
501 
    x1 -= xi3;
502 
    success += x1[0] == xi1 - xi3 && x1[1] == xi2 - xi3;
503 
 
504 
    float xii1 = my_random(), xii2 = my_random();
505 
    Vec2f x2(xii1, xii2);
506 
    x1 = Vec2f(xi1, xi2);
507 
    x2 *= x1;
508 
    success += abs(x2[0] - xi1*xii1) < 1.0e-15 && abs(x2[1] - xi2*xii2) < 1.0e-15;
509 
 
510 
    while(xi1 == 0)
511 
      xi1 = my_random();
512 
    while(xi2 == 0)
513 
      xi2 = my_random();
514 
    x1 = Vec2f(xi1, xi2);
515 
    x2 = Vec2f(xii1, xii2);
516 
    x2 /= x1;
517 
    success += abs(x2[0] - xii1/xi1) < 1.0e-15 && abs(x2[1] - xii2/xi2) < 1.0e-15;
518 
 
519 
    x2 = Vec2f(xii1, xii2);
520 
    x2 += x1;
521 
    success += x2[0] == xii1 + xi1 && x2[1] == xii2 + xi2;
522 
 
523 
    x2 = Vec2f(xii1, xii2);
524 
    x2 -= x1;
525 
    success += x2[0] == xii1 - xi1 && x2[1] == xii2 - xi2;
526 
  }
527 
  if(success != 8)
528 
  {
529 
    cout << "Failure in test of Vec2f Assignment operators";
530 
    system ("pause");
531 
    return 1;
532 
  }
533 
  success = 0;
534 
 
535 
  // Unary operators
536 
 
537 
  {
538 
    float xi1 = my_random(), xi2 = my_random();
539 
    Vec2f x1 = -Vec2f(xi1, xi2);
540 
    success += x1[0] == -xi1 && x1[1] == -xi2;
541 
  }
542 
  if(success != 1)
543 
  {
544 
    cout << "Failure in test of Vec2f Unary operators";
545 
    system ("pause");
546 
    return 1;
547 
  }
548 
  success = 0;
549 
 
550 
  // Binary operators
551 
 
552 
  {
553 
    float xi1 = my_random(), xi2 = my_random();
554 
    Vec2f x1(xi1, xi2);
555 
    float xii1 = my_random(), xii2 = my_random();
556 
    while(xii1 == 0)
557 
      xii1 = my_random();
558 
    while(xii2 == 0)
559 
      xii2 = my_random();
560 
    Vec2f x2(xii1, xii2);
561 
    Vec2f x3 = x1*x2;
562 
    success += abs(x3[0] - xi1*xii1) < 1.0e-15 && abs(x3[1] - xi2*xii2) < 1.0e-15;
563 
 
564 
    x3 = x1 + x2;
565 
    success += x3[0] == xi1 + xii1 && x3[1] == xi2 + xii2;
566 
 
567 
    x3 = x1 - x2;
568 
    success += x3[0] == xi1 - xii1 && x3[1] == xi2 - xii2;
569 
 
570 
    x3 = x1/x2;
571 
    success += abs(x3[0] - xi1/xii1) < 1.0e-15 && abs(x3[1] - xi2/xii2) < 1.0e-15;
572 
 
573 
    float xi3 = my_random();
574 
    x3 = x1*xi3;
575 
    success += abs(x3[0] - xi1*xi3) < 1.0e-15 && abs(x3[1] - xi2*xi3) < 1.0e-15;
576 
 
577 
    x3 = xi3*x1;
578 
    success += abs(x3[0] - xi1*xi3) < 1.0e-15 && abs(x3[1] - xi2*xi3) < 1.0e-15;
579 
 
580 
    float xi4 = my_random();
581 
    x3 = xi4*x1;
582 
    success += abs(x3[0] - xi1*xi4) < 1-0e-15 && abs(x3[1] - xi2*xi4) < 1.0e-15;
583 
 
584 
    x3 = x1*xi4;
585 
    success += abs(x3[0] - xi1*xi4) < 1-0e-15 && abs(x3[1] - xi2*xi4) < 1.0e-15;
586 
 
587 
    int xi5 = gel_rand();
588 
    x3 = xi5*x1;
589 
    success += abs(x3[0] - xi1*xi5) < 1.0e-15 && abs(x3[1] - xi2*xi5) < 1.0e-15;
590 
 
591 
    x3 = x1*xi5;
592 
    success += abs(x3[0] - xi1*xi5) < 1.0e-15 && abs(x3[1] - xi2*xi5) < 1.0e-15;
593 
 
594 
    while(xi3 == 0)
595 
      xi3 = my_random();
596 
    x3 = x1/xi3;
597 
    success += abs(x3[0] - xi1/xi3) < 1.0e-15 && abs(x3[1] - xi2/xi3) < 1.0e-15;
598 
  }
599 
  if(success != 11)
600 
  {
601 
    cout << "Failure in test of Vec2f Binary operators";
602 
    system ("pause");
603 
    return 1;
604 
  }
605 
  success = 0;
606 
 
607 
  // Vector operations
608 
 
609 
  {
610 
    float xi1 = my_random(), xi2 = my_random();
611 
    Vec2f x1(xi1, xi2);
612 
    float xii1 = my_random(), xii2 = my_random();
613 
    Vec2f x2(xii1, xii2);
614 
    float x = dot(x1, x2);
615 
    success += (x - xi1*xii1 - xi2*xii2) < 1.0e-7;
616 
 
617 
    x = sqr_length(x1);
618 
    success += abs(x - xi1*xi1 - xi2*xi2) < 1.0e-15;
619 
 
620 
    Vec2f x3 = v_min(x1, x2);
621 
    success += x3[0] == (xi1 < xii1 ? xi1 : xii1) && x3[1] == (xi2 < xii2 ? xi2 : xii2);
622 
 
623 
    x3 = v_max(x1, x2);
624 
    success += x3[0] == (xi1 > xii1 ? xi1 : xii1) && x3[1] == (xi2 > xii2 ? xi2 : xii2);
625 
 
626 
    x = x2.length();
627 
    success += abs(x - sqrt(xii1*xii1 + xii2*xii2)) < 1.0e-15;
628 
 
629 
    x = length(x2);
630 
    success += abs(x - sqrt(xii1*xii1 + xii2*xii2)) < 1.0e-15;
631 
 
632 
    while(sqr_length(x1) == 0.0)
633 
    {
634 
      xi1 = my_random();
635 
      xi2 = my_random();
636 
      x1 = Vec2f(xi1, xi2);
637 
    }
638 
    x3 = normalize(x1);
639 
    success += abs(x3[0] - xi1/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15
640 
               && abs(x3[1] - xi2/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15;
641 
 
642 
    x1.normalize();
643 
    success += abs(x1[0] - xi1/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15
644 
               && abs(x1[1] - xi2/sqrt(xi1*xi1 + xi2*xi2)) < 1.0e-15;
645 
 
646 
    x3 = orthogonal(x2);
647 
    success += abs(dot(x2, x3)) < 1.0e-15;
648 
 
649 
    x1 = Vec2f(xi1, xi2);
650 
    x = cross(x1, x2);
651 
    success += abs(x - xi1*xii2 + xi2*xii1) < 1.0e-15;
652 
 
653 
    while(x == 0)
654 
    {
655 
      xi1 = my_random();
656 
      xi2 = my_random();
657 
      x1 = Vec2f(xi1, xi2);
658 
      x = cross(x1, x2);
659 
    }
660 
    float xiii1 = my_random(), xiii2 = my_random();
661 
    x3 = Vec2f(xiii1, xiii2);
662 
    float y, z;
663 
    linear_combine(x1, x2, x3, y, z);
664 
    success += abs(y - (xii2*xiii1 - xii1*xiii2)/x) < 1.0e-15
665 
               && abs(z - (xi1*xiii2 - xi2*xiii1)/x) < 1.0e-15;
666 
  }
667 
  if(success != 11)
668 
  {
669 
    cout << "Failure in test of Vec2f Vector operations";
670 
    system ("pause");
671 
    return 1;
672 
  }
673 
  success = 0;
674 
 
675 
  ////////////////////////////////////////////////
676 
  //                V e c 2 i
677 
  ////////////////////////////////////////////////
678 
 
679 
  // Constructors
680 
 
681 
  {
682 
/* Vec2i default initialization ?
683 
 *
684 
    Vec2i x1;
685 
    success += CGLA::isnan(x1[0]) && CGLA::isnan(x1[1]);
686 
*/
687 
 
688 
    int xi1 = gel_rand(), xi2 = gel_rand();
689 
    Vec2i x2(xi1, xi2);
690 
    success += x2[0] == xi1 && x2[1] == xi2;
691 
 
692 
/* Constuctor non-existent !
693 
 *
694 
    int xii1 = my_random(), xii2 = my_random();
695 
    Vec2d d1(xii1, xii2);
696 
    Vec2i x3(i1);
697 
    success += x3[0] == xii1 && x3[1] == xii2;
698 
*/
699 
 
700 
    float xiii1 = my_random(), xiii2 = my_random();
701 
    Vec2f f1(xiii1, xiii2);
702 
    Vec2i x4(f1);
703 
    success += x4[0] == static_cast<int>(xiii1) && x4[1] == static_cast<int>(xiii2);
704 
 
705 
/* Constuctor non-existent !
706 
 *
707 
    int xiiii = gel_rand();
708 
    Vec2i x5(xiiii);
709 
    success += x5[0] == xiiii && x5[1] == xiiii;
710 
*/
711 
  }
712 
  if(success != 2)
713 
  {
714 
    cout << "Failure in test of Vec2i Constructors";
715 
    system ("pause");
716 
    return 1;
717 
  }
718 
  success = 0;
719 
 
720 
  // Data manipulation
721 
 
722 
  {
723 
    Vec2i x1;
724 
 
725 
    success += x1.get_dim() == 2;
726 
 
727 
    int xi1 = gel_rand(), xi2 = gel_rand();
728 
    x1.set(xi1, xi2);
729 
    success += x1[0] == xi1 && x1[1] == xi2;
730 
 
731 
    success += x1.get() == &x1[0];
732 
 
733 
    int temp = INT_MAX;
734 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
735 
      if(x1[i] < temp)
736 
	temp = x1[i];
737 
    success += temp == x1.min_coord();
738 
 
739 
    temp = -INT_MAX;
740 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
741 
      if(x1[i] > temp)
742 
	temp = x1[i];
743 
    success += temp == x1.max_coord();
744 
  }
745 
  if(success != 5)
746 
  {
747 
    cout << "Failure in test of Vec2i Data manipulation";
748 
    system ("pause");
749 
    return 1;
750 
  }
751 
  success = 0;
752 
 
753 
  // Comparison operators
754 
 
755 
  {
756 
    int xi1 = gel_rand(), xi2 = gel_rand();
757 
    while(xi1 == xi2)
758 
    {
759 
      xi1 = gel_rand();
760 
      xi2 = gel_rand();
761 
    }
762 
 
763 
    Vec2i x1(xi1, xi2), x2(xi1, xi2), x3(xi1, xi1), x4(xi2, xi2);
764 
    success += x1 == x2;
765 
    success += !(x1 == x3);
766 
    success += x3 == xi1;
767 
    success += !(x3 == xi2);
768 
    success += x1 != x3;
769 
    success += !(x1 != x2);
770 
 
771 
    if(xi1 < xi2)
772 
    {
773 
      success += x3.all_l(x4);
774 
      success += !(x3.all_l(x2));
775 
      success += x3.all_le(x2);
776 
      success += !(x4.all_le(x3));
777 
      success += x4.all_g(x3);
778 
      success += !(x4.all_g(x2));
779 
      success += x4.all_ge(x2);
780 
      success += !(x3.all_ge(x4));
781 
    }
782 
    else
783 
    {
784 
      success += x4.all_l(x3);
785 
      success += !(x4.all_l(x2));
786 
      success += x4.all_le(x2);
787 
      success += !(x3.all_le(x4));
788 
      success += x3.all_g(x4);
789 
      success += !(x3.all_g(x2));
790 
      success += x3.all_ge(x2);
791 
      success += !(x4.all_ge(x3));
792 
    }
793 
  }
794 
  if(success != 14)
795 
  {
796 
    cout << "Failure in test of Vec2i Comparison operators";
797 
    system ("pause");
798 
    return 1;
799 
  }
800 
  success = 0;
801 
 
802 
  // Assignment operators
803 
 
804 
  {
805 
    int xi1 = gel_rand(), xi2 = gel_rand();
806 
    Vec2i x1(xi1, xi2);
807 
    int xi3 = gel_rand();
808 
    x1 *= xi3;
809 
    success += x1[0] == xi1*xi3 && x1[1] == xi2*xi3;
810 
 
811 
    while(xi3 == 0)
812 
      xi3 = gel_rand();
813 
    x1 = Vec2i(xi1, xi2);
814 
    x1 /= xi3;
815 
    success += x1[0] == xi1/xi3 && x1[1] == xi2/xi3;
816 
 
817 
    x1 = Vec2i(xi1, xi2);
818 
    x1 += xi3;
819 
    success += x1[0] == xi1 + xi3 && x1[1] == xi2 + xi3;
820 
 
821 
    x1 = Vec2i(xi1, xi2);
822 
    x1 -= xi3;
823 
    success += x1[0] == xi1 - xi3 && x1[1] == xi2 - xi3;
824 
 
825 
    int xii1 = gel_rand(), xii2 = gel_rand();
826 
    Vec2i x2(xii1, xii2);
827 
    x1 = Vec2i(xi1, xi2);
828 
    x2 *= x1;
829 
    success += x2[0] == xi1*xii1 && x2[1] == xi2*xii2;
830 
 
831 
    while(xi1 == 0)
832 
      xi1 = gel_rand();
833 
    while(xi2 == 0)
834 
      xi2 = gel_rand();
835 
    x1 = Vec2i(xi1, xi2);
836 
    x2 = Vec2i(xii1, xii2);
837 
    x2 /= x1;
838 
    success += x2[0] == xii1/xi1 && x2[1] == xii2/xi2;
839 
 
840 
    x2 = Vec2i(xii1, xii2);
841 
    x2 += x1;
842 
    success += x2[0] == xii1 + xi1 && x2[1] == xii2 + xi2;
843 
 
844 
    x2 = Vec2i(xii1, xii2);
845 
    x2 -= x1;
846 
    success += x2[0] == xii1 - xi1 && x2[1] == xii2 - xi2;
847 
  }
848 
  if(success != 8)
849 
  {
850 
    cout << "Failure in test of Vec2i Assignment operators";
851 
    return 1;
852 
  }
853 
  success = 0;
854 
 
855 
  // Unary operators
856 
 
857 
  {
858 
    int xi1 = gel_rand(), xi2 = gel_rand();
859 
    Vec2i x1 = -Vec2i(xi1, xi2);
860 
    success += x1[0] == -xi1 && x1[1] == -xi2;
861 
  }
862 
  if(success != 1)
863 
  {
864 
    cout << "Failure in test of Vec2i Unary operators";
865 
    return 1;
866 
  }
867 
  success = 0;
868 
 
869 
  // Binary operators
870 
 
871 
  {
872 
    int xi1 = gel_rand(), xi2 = gel_rand();
873 
    Vec2i x1(xi1, xi2);
874 
    int xii1 = gel_rand(), xii2 = gel_rand();
875 
    while(xii1 == 0)
876 
      xii1 = gel_rand();
877 
    while(xii2 == 0)
878 
      xii2 = gel_rand();
879 
    Vec2i x2(xii1, xii2);
880 
    Vec2i x3 = x1*x2;
881 
    success += x3[0] == xi1*xii1 && x3[1] == xi2*xii2;
882 
 
883 
    x3 = x1 + x2;
884 
    success += x3[0] == xi1 + xii1 && x3[1] == xi2 + xii2;
885 
 
886 
    x3 = x1 - x2;
887 
    success += x3[0] == xi1 - xii1 && x3[1] == xi2 - xii2;
888 
 
889 
    x3 = x1/x2;
890 
    success += x3[0] == xi1/xii1 && x3[1] == xi2/xii2;
891 
 
892 
    int xi3 = gel_rand();
893 
    x3 = x1*xi3;
894 
    success += x3[0] == xi1*xi3 && x3[1] == xi2*xi3;
895 
 
896 
    x3 = xi3*x1;
897 
    success += x3[0] == xi1*xi3 && x3[1] == xi2*xi3;
898 
 
899 
    float xi4 = INT_MAX*my_random();
900 
    x3 = xi4*x1;
901 
    success += x3[0] == xi1*static_cast<int>(xi4) && x3[1] == xi2*static_cast<int>(xi4);
902 
 
903 
    x3 = x1*xi4;
904 
    success += x3[0] == xi1*static_cast<int>(xi4) && x3[1] == xi2*static_cast<int>(xi4);
905 
 
906 
    double xi5 = INT_MAX*my_random();
907 
    x3 = xi5*x1;
908 
    success += x3[0] == xi1*static_cast<int>(xi5) && x3[1] == xi2*static_cast<int>(xi5);
909 
 
910 
    x3 = x1*xi5;
911 
    success += x3[0] == xi1*static_cast<int>(xi5) && x3[1] == xi2*static_cast<int>(xi5);
912 
 
913 
    while(xi3 == 0)
914 
      xi3 = gel_rand();
915 
    x3 = x1/xi3;
916 
    success += x3[0] == xi1/xi3 && x3[1] == xi2/xi3;
917 
  }
918 
  if(success != 11)
919 
  {
920 
    cout << "Failure in test of Vec2i Binary operators";
921 
    return 1;
922 
  }
923 
  success = 0;
924 
 
925 
  // Vector operations
926 
 
927 
  {
928 
    int xi1 = gel_rand(), xi2 = gel_rand();
929 
    Vec2i x1(xi1, xi2);
930 
    int xii1 = gel_rand(), xii2 = gel_rand();
931 
    Vec2i x2(xii1, xii2);
932 
    int x = dot(x1, x2);
933 
    success += x == xi1*xii1 + xi2*xii2;
934 
 
935 
    x = sqr_length(x1);
936 
    success += x == xi1*xi1 + xi2*xi2;
937 
 
938 
    Vec2i x3 = v_min(x1, x2);
939 
    success += x3[0] == (xi1 < xii1 ? xi1 : xii1) && x3[1] == (xi2 < xii2 ? xi2 : xii2);
940 
 
941 
    x3 = v_max(x1, x2);
942 
    success += x3[0] == (xi1 > xii1 ? xi1 : xii1) && x3[1] == (xi2 > xii2 ? xi2 : xii2);
943 
  }
944 
  if(success != 4)
945 
  {
946 
    cout << "Failure in test of Vec2i Vector operations";
947 
    return 1;
948 
  }
949 
  success = 0;
950 
 
951 
  ////////////////////////////////////////////////
952 
  //                V e c 3 i
953 
  ////////////////////////////////////////////////
954 
 
955 
  // Constructors
956 
 
957 
  {
958 
/* Vec3i default initialization ?
959 
 *
960 
    Vec3i x1;
961 
    success += CGLA::isnan(x1[0]) && CGLA::isnan(x1[1]) && CGLA::isnan(x1[2]);
962 
*/
963 
 
964 
    int xi1 = gel_rand(), xi2 = gel_rand(), xi3 = gel_rand();
965 
    Vec3i x2(xi1, xi2, xi3);
966 
    success += x2[0] == xi1 && x2[1] == xi2 && x2[2] == xi3;
967 
 
968 
    int xiiii = gel_rand();
969 
    Vec3i x3(xiiii);
970 
    success += x3[0] == xiiii && x3[1] == xiiii && x3[2] == xiiii;
971 
 
972 
/* Constuctor non-existent !
973 
 *
974 
    int xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
975 
    Vec3d d1(xii1, xii2, xii3);
976 
    Vec3i x4(d1);
977 
    success += x4[0] == xii1 && x4[1] == xii2 && x4[2] == xii3;
978 
*/
979 
 
980 
    float xiii1 = my_random(), xiii2 = my_random(), xiii3 = my_random();
981 
    Vec3f f1(xiii1, xiii2, xiii3);
982 
    Vec3i x5(f1);
983 
    success += x5[0] == static_cast<int>(xiii1)
984 
               && x5[1] == static_cast<int>(xiii2)
985 
               && x5[2] == static_cast<int>(xiii3);
986 
 
987 
    unsigned char xiiii1 = 256*my_random(),
988 
                  xiiii2 = 256*my_random(),
989 
                  xiiii3 = 256*my_random();
990 
    Vec3uc uc1(xiiii1, xiiii2, xiiii3);
991 
    Vec3i x6(uc1);
992 
    success += x6[0] == xiiii1 && x6[1] == xiiii2 && x6[2] == xiiii3;
993 
 
994 
    unsigned short int xiiv1 = USHRT_MAX*my_random(),
995 
                       xiiv2 = USHRT_MAX*my_random(),
996 
                       xiiv3 = USHRT_MAX*my_random();
997 
    Vec3usi usi1(xiiv1, xiiv2, xiiv3);
998 
    Vec3i x7(usi1);
999 
    success += x7[0] == xiiv1 && x7[1] == xiiv2 && x7[2] == xiiv3;
1000 
  }
1001 
  if(success != 5)
1002 
  {
1003 
    cout << "Failure in test of Vec3i Constructors";
1004 
    return 1;
1005 
  }
1006 
  success = 0;
1007 
 
1008 
  // Data manipulation
1009 
 
1010 
  {
1011 
    Vec3i x1;
1012 
 
1013 
    success += x1.get_dim() == 3;
1014 
 
1015 
    int xi1 = gel_rand(), xi2 = gel_rand(), xi3 = gel_rand();
1016 
    x1.set(xi1, xi2, xi3);
1017 
    success += x1[0] == xi1 && x1[1] == xi2 && x1[2] == xi3;
1018 
 
1019 
    success += x1.get() == &x1[0];
1020 
 
1021 
    int temp = INT_MAX;
1022 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
1023 
      if(x1[i] < temp)
1024 
	temp = x1[i];
1025 
    success += temp == x1.min_coord();
1026 
 
1027 
    temp = -INT_MAX;
1028 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
1029 
      if(x1[i] > temp)
1030 
	temp = x1[i];
1031 
    success += temp == x1.max_coord();
1032 
  }
1033 
  if(success != 5)
1034 
  {
1035 
    cout << "Failure in test of Vec3i Data manipulation";
1036 
    return 1;
1037 
  }
1038 
  success = 0;
1039 
 
1040 
  // Comparison operators
1041 
 
1042 
  {
1043 
    int xi1 = gel_rand(), xi2 = gel_rand(), xi3 = gel_rand();
1044 
    while(xi1 >= xi2)
1045 
    {
1046 
      xi1 = gel_rand();
1047 
      xi2 = gel_rand();
1048 
    }
1049 
    while(xi3 <= xi2)
1050 
      xi3 = gel_rand();
1051 
 
1052 
    Vec3i x1(xi1, xi2, xi3), x2(xi1, xi2, xi3),
1053 
          x3(xi1, xi1, xi1), x4(xi2, xi2, xi2), x5(xi3, xi3, xi3);
1054 
    success += x1 == x2;
1055 
    success += !(x1 == x3);
1056 
    success += x3 == xi1;
1057 
    success += !(x3 == xi2);
1058 
    success += x1 != x3;
1059 
    success += !(x1 != x2);
1060 
    success += x3.all_l(x4);
1061 
    success += !(x3.all_l(x2));
1062 
    success += x3.all_le(x2);
1063 
    success += !(x4.all_le(x2));
1064 
    success += x4.all_g(x3);
1065 
    success += !(x4.all_g(x2));
1066 
    success += x5.all_ge(x2);
1067 
    success += !(x4.all_ge(x2));
1068 
  }
1069 
  if(success != 14)
1070 
  {
1071 
    cout << "Failure in test of Vec3i Comparison operators";
1072 
    return 1;
1073 
  }
1074 
  success = 0;
1075 
 
1076 
  // Assignment operators
1077 
 
1078 
  {
1079 
    int xi1 = gel_rand(), xi2 = gel_rand(), xi3 = gel_rand();
1080 
    Vec3i x1(xi1, xi2, xi3);
1081 
    int xii = gel_rand();
1082 
    x1 *= xii;
1083 
    success += x1[0] == xi1*xii && x1[1] == xi2*xii && x1[2] == xi3*xii;
1084 
 
1085 
    while(xii == 0)
1086 
      xii = gel_rand();
1087 
    x1 = Vec3i(xi1, xi2, xi3);
1088 
    x1 /= xii;
1089 
    success += x1[0] == xi1/xii && x1[1] == xi2/xii && x1[2] == xi3/xii;
1090 
 
1091 
    x1 = Vec3i(xi1, xi2, xi3);
1092 
    x1 += xii;
1093 
    success += x1[0] == xi1 + xii && x1[1] == xi2 + xii && x1[2] == xi3 + xii;
1094 
 
1095 
    x1 = Vec3i(xi1, xi2, xi3);
1096 
    x1 -= xii;
1097 
    success += x1[0] == xi1 - xii && x1[1] == xi2 - xii && x1[2] == xi3 - xii;
1098 
 
1099 
    int xii1 = gel_rand(), xii2 = gel_rand(), xii3 = gel_rand();
1100 
    Vec3i x2(xii1, xii2, xii3);
1101 
    x1 = Vec3i(xi1, xi2, xi3);
1102 
    x2 *= x1;
1103 
    success += x2[0] == xi1*xii1 && x2[1] == xi2*xii2 && x2[2] == xi3*xii3;
1104 
 
1105 
    while(xi1 == 0)
1106 
      xi1 = gel_rand();
1107 
    while(xi2 == 0)
1108 
      xi2 = gel_rand();
1109 
    while(xi3 == 0)
1110 
      xi3 = gel_rand();
1111 
    x1 = Vec3i(xi1, xi2, xi3);
1112 
    x2 = Vec3i(xii1, xii2, xii3);
1113 
    x2 /= x1;
1114 
    success += x2[0] == xii1/xi1 && x2[1] == xii2/xi2 && x2[2] == xii3/xi3;
1115 
 
1116 
    x2 = Vec3i(xii1, xii2, xii3);
1117 
    x2 += x1;
1118 
    success += x2[0] == xii1 + xi1 && x2[1] == xii2 + xi2 && x2[2] == xii3 + xi3;
1119 
 
1120 
    x2 = Vec3i(xii1, xii2, xii3);
1121 
    x2 -= x1;
1122 
    success += x2[0] == xii1 - xi1 && x2[1] == xii2 - xi2 && x2[2] == xii3 - xi3;
1123 
  }
1124 
  if(success != 8)
1125 
  {
1126 
    cout << "Failure in test of Vec3i Assignment operators";
1127 
    return 1;
1128 
  }
1129 
  success = 0;
1130 
 
1131 
  // Unary operators
1132 
 
1133 
  {
1134 
    int xi1 = gel_rand(), xi2 = gel_rand(), xi3 = gel_rand();
1135 
    Vec3i x1 = -Vec3i(xi1, xi2, xi3);
1136 
    success += x1[0] == -xi1 && x1[1] == -xi2 && x1[2] == -xi3;
1137 
  }
1138 
  if(success != 1)
1139 
  {
1140 
    cout << "Failure in test of Vec3i Unary operators";
1141 
    return 1;
1142 
  }
1143 
  success = 0;
1144 
 
1145 
  // Binary operators
1146 
 
1147 
  {
1148 
    int xi1 = gel_rand(), xi2 = gel_rand(), xi3 = gel_rand();
1149 
    Vec3i x1(xi1, xi2, xi3);
1150 
    int xii1 = gel_rand(), xii2 = gel_rand(), xii3 = gel_rand();
1151 
    while(xii1 == 0)
1152 
      xii1 = gel_rand();
1153 
    while(xii2 == 0)
1154 
      xii2 = gel_rand();
1155 
    while(xii3 == 0)
1156 
      xii3 = gel_rand();
1157 
    Vec3i x2(xii1, xii2, xii3);
1158 
    Vec3i x3 = x1*x2;
1159 
    success += x3[0] == xi1*xii1 && x3[1] == xi2*xii2 && x3[2] == xi3*xii3;
1160 
 
1161 
    x3 = x1 + x2;
1162 
    success += x3[0] == xi1 + xii1 && x3[1] == xi2 + xii2 && x3[2] == xi3 + xii3;
1163 
 
1164 
    x3 = x1 - x2;
1165 
    success += x3[0] == xi1 - xii1 && x3[1] == xi2 - xii2 && x3[2] == xi3 - xii3;
1166 
 
1167 
    x3 = x1/x2;
1168 
    success += x3[0] == xi1/xii1 && x3[1] == xi2/xii2 && x3[2] == xi3/xii3;
1169 
 
1170 
    int xii = gel_rand();
1171 
    x3 = x1*xii;
1172 
    success += x3[0] == xi1*xii && x3[1] == xi2*xii && x3[2] == xi3*xii;
1173 
 
1174 
    x3 = xii*x1;
1175 
    success += x3[0] == xi1*xii && x3[1] == xi2*xii && x3[2] == xi3*xii;
1176 
 
1177 
    float xi4 = INT_MAX*my_random();
1178 
    x3 = xi4*x1;
1179 
    success += x3[0] == xi1*static_cast<int>(xi4)
1180 
               && x3[1] == xi2*static_cast<int>(xi4)
1181 
               && x3[2] == xi3*static_cast<int>(xi4);
1182 
 
1183 
    x3 = x1*xi4;
1184 
    success += x3[0] == xi1*static_cast<int>(xi4)
1185 
               && x3[1] == xi2*static_cast<int>(xi4)
1186 
               && x3[2] == xi3*static_cast<int>(xi4);
1187 
 
1188 
    double xi5 = INT_MAX*my_random();
1189 
    x3 = xi5*x1;
1190 
    success += x3[0] == xi1*static_cast<int>(xi5)
1191 
               && x3[1] == xi2*static_cast<int>(xi5)
1192 
               && x3[2] == xi3*static_cast<int>(xi5);
1193 
 
1194 
    x3 = x1*xi5;
1195 
    success += x3[0] == xi1*static_cast<int>(xi5)
1196 
               && x3[1] == xi2*static_cast<int>(xi5)
1197 
               && x3[2] == xi3*static_cast<int>(xi5);
1198 
 
1199 
    while(xii == 0)
1200 
      xii = gel_rand();
1201 
    x3 = x1/xii;
1202 
    success += x3[0] == xi1/xii && x3[1] == xi2/xii && x3[2] == xi3/xii;
1203 
  }
1204 
  if(success != 11)
1205 
  {
1206 
    cout << "Failure in test of Vec3i Binary operators";
1207 
    return 1;
1208 
  }
1209 
  success = 0;
1210 
 
1211 
  // Vector operations
1212 
 
1213 
  {
1214 
    int xi1 = gel_rand(), xi2 = gel_rand(), xi3 = gel_rand();
1215 
    Vec3i x1(xi1, xi2, xi3);
1216 
    int xii1 = gel_rand(), xii2 = gel_rand(), xii3 = gel_rand();
1217 
    Vec3i x2(xii1, xii2, xii3);
1218 
    int x = dot(x1, x2);
1219 
    success += x == xi1*xii1 + xi2*xii2 + xi3*xii3;
1220 
 
1221 
    x = sqr_length(x1);
1222 
    success += x == xi1*xi1 + xi2*xi2 + xi3*xi3;
1223 
 
1224 
    Vec3i x3 = v_min(x1, x2);
1225 
    success += x3[0] == (xi1 < xii1 ? xi1 : xii1)
1226 
               && x3[1] == (xi2 < xii2 ? xi2 : xii2)
1227 
               && x3[2] == (xi3 < xii3 ? xi3 : xii3);
1228 
 
1229 
    x3 = v_max(x1, x2);
1230 
    success += x3[0] == (xi1 > xii1 ? xi1 : xii1)
1231 
               && x3[1] == (xi2 > xii2 ? xi2 : xii2)
1232 
               && x3[2] == (xi3 > xii3 ? xi3 : xii3);
1233 
 
1234 
    x3 = cross(x1, x2);
1235 
    success += x3[0] == xi2*xii3 - xi3*xii2
1236 
               && x3[1] == xi3*xii1 - xi1*xii3
1237 
               && x3[2] == xi1*xii2 - xi2*xii1;
1238 
  }
1239 
  if(success != 5)
1240 
  {
1241 
    cout << "Failure in test of Vec3i Vector operations";
1242 
    return 1;
1243 
  }
1244 
  success = 0;
1245 
 
1246 
  ////////////////////////////////////////////////
1247 
  //                V e c 3 f
1248 
  ////////////////////////////////////////////////
1249 
 
1250 
  // Constructors
1251 
 
1252 
  {
1253 
    Vec3f x1;
1254 
    success += CGLA::isnan(x1[0]) && CGLA::isnan(x1[1]) && CGLA::isnan(x1[2]);
1255 
 
1256 
    float xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1257 
    Vec3f x2(xi1, xi2, xi3);
1258 
    success += x2[0] == xi1 && x2[1] == xi2 && x2[2] == xi3;
1259 
 
1260 
    float xiiii = my_random();
1261 
    Vec3f x3(xiiii);
1262 
    success += x3[0] == xiiii && x3[1] == xiiii && x3[2] == xiiii;
1263 
 
680 janba 1264 
      // Doubles and floats cannot represent exactly the same numbers.
1265 
//    double xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1266 
//    Vec3d d1(xii1, xii2, xii3);
1267 
//    Vec3f x4(d1);
1268 
//    success += x4[0] == xii1 && x4[1] == xii2 && x4[2] == xii3;
667 khor 1269 
 
1270 
    int xiii1 = gel_rand(), xiii2 = gel_rand(), xiii3 = gel_rand();
1271 
    Vec3i i1(xiii1, xiii2, xiii3);
1272 
    Vec3f x5(i1);
1273 
    success += x5[0] == xiii1 && x5[1] == xiii2 && x5[2] == xiii3;
1274 
 
1275 
    float xiiii1 = my_random(), xiiii2 = my_random(), xiiii3 = my_random();
1276 
    Quatf q(xiiii1, xiiii2, xiiii3, 1.0);
1277 
    Vec3f x6 = q.get_imaginary_part();
1278 
    success += x6[0] == xiiii1 && x6[1] == xiiii2 && x6[2] == xiiii3;
1279 
 
1280 
    unsigned short int xiiv1 = USHRT_MAX*my_random(),
1281 
                       xiiv2 = USHRT_MAX*my_random(),
1282 
                       xiiv3 = USHRT_MAX*my_random();
1283 
    Vec3usi usi1(xiiv1, xiiv2, xiiv3);
1284 
    Vec3f x7(usi1);
1285 
    success += x7[0] == xiiv1 && x7[1] == xiiv2 && x7[2] == xiiv3;
1286 
  }
1287 
  if(success != 7)
1288 
  {
1289 
    cout << "Failure in test of Vec3f Constructors";
1290 
    return 1;
1291 
  }
1292 
  success = 0;
1293 
 
1294 
  // Data manipulation
1295 
 
1296 
  {
1297 
    Vec3f x1;
1298 
 
1299 
    success += x1.get_dim() == 3;
1300 
 
1301 
    float xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1302 
    x1.set(xi1, xi2, xi3);
1303 
    success += x1[0] == xi1 && x1[1] == xi2 && x1[2] == xi3;
1304 
 
1305 
    success += x1.get() == &x1[0];
1306 
 
1307 
    float temp = BIG;
1308 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
1309 
      if(x1[i] < temp)
1310 
	temp = x1[i];
1311 
    success += temp == x1.min_coord();
1312 
 
1313 
    temp = -BIG;
1314 
    for(unsigned int i = 0; i < x1.get_dim(); ++i)
1315 
      if(x1[i] > temp)
1316 
	temp = x1[i];
1317 
    success += temp == x1.max_coord();
1318 
  }
1319 
  if(success != 5)
1320 
  {
1321 
    cout << "Failure in test of Vec3f Data manipulation";
1322 
    return 1;
1323 
  }
1324 
  success = 0;
1325 
 
1326 
  // Comparison operators
1327 
 
1328 
  {
1329 
    float xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1330 
    while(xi1 >= xi2)
1331 
    {
1332 
      xi1 = my_random();
1333 
      xi2 = my_random();
1334 
    }
1335 
    while(xi3 <= xi2)
1336 
      xi3 = my_random();
1337 
 
1338 
    Vec3f x1(xi1, xi2, xi3), x2(xi1, xi2, xi3),
1339 
          x3(xi1, xi1, xi1), x4(xi2, xi2, xi2), x5(xi3, xi3, xi3);
1340 
    success += x1 == x2;
1341 
    success += !(x1 == x3);
1342 
    success += x3 == xi1;
1343 
    success += !(x3 == xi2);
1344 
    success += x1 != x3;
1345 
    success += !(x1 != x2);
1346 
    success += x3.all_l(x4);
1347 
    success += !(x3.all_l(x2));
1348 
    success += x3.all_le(x2);
1349 
    success += !(x4.all_le(x2));
1350 
    success += x4.all_g(x3);
1351 
    success += !(x4.all_g(x2));
1352 
    success += x5.all_ge(x2);
1353 
    success += !(x4.all_ge(x2));
1354 
  }
1355 
  if(success != 14)
1356 
  {
1357 
    cout << "Failure in test of Vec3f Comparison operators";
1358 
    return 1;
1359 
  }
1360 
  success = 0;
1361 
 
1362 
  // Assignment operators
1363 
 
1364 
  {
1365 
    float xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1366 
    Vec3f x1(xi1, xi2, xi3);
1367 
    float xii = my_random();
1368 
    x1 *= xii;
1369 
    success += abs(x1[0] - xi1*xii) < 1.0e-15
1370 
               && abs(x1[1] - xi2*xii) < 1.0e-15
1371 
               && abs(x1[2] - xi3*xii) < 1.0e-15;
1372 
 
1373 
    while(xii == 0)
1374 
      xii = my_random();
1375 
    x1 = Vec3f(xi1, xi2, xi3);
1376 
    x1 /= xii;
1377 
    success += abs(x1[0] - xi1/xii) < 1.0e-15
1378 
               && abs(x1[1] - xi2/xii) < 1.0e-15
1379 
               && abs(x1[2] - xi3/xii) < 1.0e-15;
1380 
 
1381 
    x1 = Vec3f(xi1, xi2, xi3);
1382 
    x1 += xii;
1383 
    success += x1[0] == xi1 + xii && x1[1] == xi2 + xii && x1[2] == xi3 + xii;
1384 
 
1385 
    x1 = Vec3f(xi1, xi2, xi3);
1386 
    x1 -= xii;
1387 
    success += x1[0] == xi1 - xii && x1[1] == xi2 - xii && x1[2] == xi3 - xii;
1388 
 
1389 
    float xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1390 
    Vec3f x2(xii1, xii2, xii3);
1391 
    x1 = Vec3f(xi1, xi2, xi3);
1392 
    x2 *= x1;
1393 
    success += abs(x2[0] - xi1*xii1) < 1.0e-15
1394 
               && abs(x2[1] - xi2*xii2) < 1.0e-15
1395 
               && abs(x2[2] - xi3*xii3) < 1.0e-15;
1396 
 
1397 
    while(xi1 == 0)
1398 
      xi1 = my_random();
1399 
    while(xi2 == 0)
1400 
      xi2 = my_random();
1401 
    while(xi3 == 0)
1402 
      xi3 = my_random();
1403 
    x1 = Vec3f(xi1, xi2, xi3);
1404 
    x2 = Vec3f(xii1, xii2, xii3);
1405 
    x2 /= x1;
1406 
    success += abs(x2[0] - xii1/xi1) < 1.0e-15
1407 
               && abs(x2[1] - xii2/xi2) < 1.0e-15
1408 
               && abs(x2[2] - xii3/xi3) < 1.0e-15;
1409 
 
1410 
    x2 = Vec3f(xii1, xii2, xii3);
1411 
    x2 += x1;
1412 
    success += x2[0] == xii1 + xi1 && x2[1] == xii2 + xi2 && x2[2] == xii3 + xi3;
1413 
 
1414 
    x2 = Vec3f(xii1, xii2, xii3);
1415 
    x2 -= x1;
1416 
    success += x2[0] == xii1 - xi1 && x2[1] == xii2 - xi2 && x2[2] == xii3 - xi3;
1417 
  }
1418 
  if(success != 8)
1419 
  {
1420 
    cout << "Failure in test of Vec3f Assignment operators";
1421 
    return 1;
1422 
  }
1423 
  success = 0;
1424 
 
1425 
  // Unary operators
1426 
 
1427 
  {
1428 
    float xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1429 
    Vec3f x1 = -Vec3f(xi1, xi2, xi3);
1430 
    success += x1[0] == -xi1 && x1[1] == -xi2 && x1[2] == -xi3;
1431 
  }
1432 
  if(success != 1)
1433 
  {
1434 
    cout << "Failure in test of Vec3f Unary operators";
1435 
    return 1;
1436 
  }
1437 
  success = 0;
1438 
 
1439 
  // Binary operators
1440 
 
1441 
  {
1442 
    float xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1443 
    Vec3f x1(xi1, xi2, xi3);
1444 
    float xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1445 
    while(xii1 == 0)
1446 
      xii1 = my_random();
1447 
    while(xii2 == 0)
1448 
      xii2 = my_random();
1449 
    while(xii3 == 0)
1450 
      xii3 = my_random();
1451 
    Vec3f x2(xii1, xii2, xii3);
1452 
    Vec3f x3 = x1*x2;
1453 
    success += abs(x3[0] - xi1*xii1) < 1.0e-15
1454 
               && abs(x3[1] - xi2*xii2) < 1.0e-15
1455 
               && abs(x3[2] - xi3*xii3) < 1.0e-15;
1456 
 
1457 
    x3 = x1 + x2;
1458 
    success += x3[0] == xi1 + xii1 && x3[1] == xi2 + xii2 && x3[2] == xi3 + xii3;
1459 
 
1460 
    x3 = x1 - x2;
1461 
    success += x3[0] == xi1 - xii1 && x3[1] == xi2 - xii2 && x3[2] == xi3 - xii3;
1462 
 
1463 
    x3 = x1/x2;
1464 
    success += abs(x3[0] - xi1/xii1) < 1.0e-15
1465 
               && abs(x3[1] - xi2/xii2) < 1.0e-15
1466 
               && abs(x3[2] - xi3/xii3) < 1.0e-15;
1467 
 
1468 
    float xii = my_random();
1469 
    x3 = x1*xii;
1470 
    success += abs(x3[0] - xi1*xii) < 1.0e-15
1471 
               && abs(x3[1] - xi2*xii) < 1.0e-15
1472 
               && abs(x3[2] - xi3*xii) < 1.0e-15;
1473 
 
1474 
    x3 = xii*x1;
1475 
    success += abs(x3[0] - xi1*xii) < 1.0e-15
1476 
               && abs(x3[1] - xi2*xii) < 1.0e-15
1477 
               && abs(x3[2] - xi3*xii) < 1.0e-15;
1478 
 
1479 
    int xi4 = gel_rand();
1480 
    x3 = xi4*x1;
1481 
    success += abs(x3[0] - xi1*xi4) < 1.0e-15
1482 
               && abs(x3[1] - xi2*xi4) < 1.0e-15
1483 
               && abs(x3[2] - xi3*xi4) < 1.0e-15;
1484 
 
1485 
    x3 = x1*xi4;
1486 
    success += abs(x3[0] - xi1*xi4) < 1.0e-15
1487 
               && abs(x3[1] - xi2*xi4) < 1.0e-15
1488 
               && abs(x3[2] - xi3*xi4) < 1.0e-15;
1489 
 
1490 
    double xi5 = my_random();
1491 
    x3 = xi5*x1;
1492 
    success += abs(x3[0] - xi1*xi5) < 1.0e-15
1493 
               && abs(x3[1] - xi2*xi5) < 1.0e-15
1494 
               && abs(x3[2] - xi3*xi5) < 1.0e-15;
1495 
 
1496 
    x3 = x1*xi5;
1497 
    success += abs(x3[0] - xi1*xi5) < 1.0e-15
1498 
               && abs(x3[1] - xi2*xi5) < 1.0e-15
1499 
               && abs(x3[2] - xi3*xi5) < 1.0e-15;
1500 
 
1501 
    while(xii == 0)
1502 
      xii = my_random();
1503 
    x3 = x1/xii;
1504 
    success += abs(x3[0] - xi1/xii) < 1.0e-15
1505 
               && abs(x3[1] - xi2/xii) < 1.0e-15
1506 
               && abs(x3[2] - xi3/xii) < 1.0e-15;
1507 
  }
1508 
  if(success != 11)
1509 
  {
1510 
    cout << "Failure in test of Vec3f Binary operators";
1511 
    return 1;
1512 
  }
1513 
  success = 0;
1514 
 
1515 
  // Vector operations
1516 
 
1517 
  {
1518 
    float xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1519 
    Vec3f x1(xi1, xi2, xi3);
1520 
    float xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1521 
    Vec3f x2(xii1, xii2, xii3);
1522 
    float x = dot(x1, x2);
1523 
    success += abs(x - xi1*xii1 - xi2*xii2 - xi3*xii3) < 1.0e-15;
1524 
 
1525 
    x = sqr_length(x1);
1526 
    success += abs(x - xi1*xi1 - xi2*xi2 - xi3*xi3) < 1.0e-15;
1527 
 
1528 
    Vec3f x3 = v_min(x1, x2);
1529 
    success += x3[0] == (xi1 < xii1 ? xi1 : xii1)
1530 
               && x3[1] == (xi2 < xii2 ? xi2 : xii2)
1531 
               && x3[2] == (xi3 < xii3 ? xi3 : xii3);
1532 
 
1533 
    x3 = v_max(x1, x2);
1534 
    success += x3[0] == (xi1 > xii1 ? xi1 : xii1)
1535 
               && x3[1] == (xi2 > xii2 ? xi2 : xii2)
1536 
               && x3[2] == (xi3 > xii3 ? xi3 : xii3);
1537 
 
1538 
    Vec3f x4;
1539 
    orthogonal(x2, x3, x4);
1540 
    success += abs(dot(x2, x3)) < 1.0e-15;
1541 
 
1542 
    x3 = cross(x1, x2);
1543 
    success += abs(x3[0] - xi2*xii3 + xi3*xii2) < 1.0e-15
1544 
               && abs(x3[1] - xi3*xii1 + xi1*xii3) < 1.0e-15
1545 
               && abs(x3[2] - xi1*xii2 + xi2*xii1) < 1.0e-15;
1546 
 
1547 
    float theta, phi, r;
1548 
    x1.get_spherical(theta, phi, r);
1549 
    success += abs(theta - acos(xi3/sqrt(xi1*xi1 + xi2*xi2 + xi3*xi3))) < 1.0e-15
1550 
               && abs(phi - atan(xi2/xi1)) < 1.0e-15
1551 
               && abs(r - sqrt(xi1*xi1 + xi2*xi2 + xi3*xi3)) < 1.0e-15;
1552 
 
1553 
    x3.set_spherical(theta, phi, r);
1554 
    success += abs(x3[0] - xi1) < 1.0e-15
1555 
               && abs(x3[1] - xi2) < 1.0e-15
1556 
               && abs(x3[2] - xi3) < 1.0e-15;
1557 
  }
1558 
  if(success != 8)
1559 
  {
1560 
    cout << "Failure in test of Vec3f Vector operations";
1561 
    return 1;
1562 
  }
1563 
  success = 0;
1564 
 
1565 
  ////////////////////////////////////////////////
1566 
  //                V e c 3 d
1567 
  ////////////////////////////////////////////////
1568 
 
1569 
  // Constructors
1570 
 
1571 
  {
1572 
    Vec3d x1;
1573 
    success += CGLA::isnan(x1[0]) && CGLA::isnan(x1[1]) && CGLA::isnan(x1[2]);
1574 
 
1575 
    double xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1576 
    Vec3d x2(xi1, xi2, xi3);
1577 
    success += x2[0] == xi1 && x2[1] == xi2 && x2[2] == xi3;
1578 
 
1579 
    double xiiii = my_random();
1580 
    Vec3d x3(xiiii);
1581 
    success += x3[0] == xiiii && x3[1] == xiiii && x3[2] == xiiii;
1582 
 
1583 
    float xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1584 
    Vec3f f1(xii1, xii2, xii3);
1585 
    Vec3d x4(f1);
1586 
    success += x4[0] == xii1 && x4[1] == xii2 && x4[2] == xii3;
1587 
 
1588 
    int xiii1 = gel_rand(), xiii2 = gel_rand(), xiii3 = gel_rand();
1589 
    Vec3i i1(xiii1, xiii2, xiii3);
1590 
    Vec3d x5(i1);
1591 
    success += x5[0] == xiii1 && x5[1] == xiii2 && x5[2] == xiii3;
1592 
 
1593 
 
1594 
    double xiiii1 = my_random(), xiiii2 = my_random(), xiiii3 = my_random();
1595 
    Quatd q(xiiii1, xiiii2, xiiii3, 1.0);
1596 
    Vec3d x6 = q.get_imaginary_part();
1597 
    success += x6[0] == xiiii1 && x6[1] == xiiii2 && x6[2] == xiiii3;
1598 
 
1599 
    unsigned short int xiiv1 = USHRT_MAX*my_random(),
1600 
                       xiiv2 = USHRT_MAX*my_random(),
1601 
                       xiiv3 = USHRT_MAX*my_random();
1602 
    Vec3usi usi1(xiiv1, xiiv2, xiiv3);
1603 
    Vec3d x7(usi1);
1604 
    success += x7[0] == xiiv1 && x7[1] == xiiv2 && x7[2] == xiiv3;
1605 
 
1606 
  }
1607 
  if(success != 5)
1608 
  {
1609 
    cout << "Failure in test of Vec3d Constructors";
1610 
    return 1;
1611 
  }
1612 
  success = 0;
1613 
 
1614 
  // Data manipulation
1615 
 
1616 
  {
1617 
    Vec3d x1;
1618 
 
1619 
    success += x1.get_dim() == 3;
1620 
 
1621 
    double xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1622 
    x1.set(xi1, xi2, xi3);
1623 
    success += x1[0] == xi1 && x1[1] == xi2 && x1[2] == xi3;
1624 
 
1625 
    success += x1.get() == &x1[0];
1626 
 
1627 
    double temp = BIG;
1628 
    for(double i = 0; i < x1.get_dim(); ++i)
1629 
      if(x1[i] < temp)
1630 
	temp = x1[i];
1631 
    success += temp == x1.min_coord();
1632 
 
1633 
    temp = -BIG;
1634 
    for(double i = 0; i < x1.get_dim(); ++i)
1635 
      if(x1[i] > temp)
1636 
	temp = x1[i];
1637 
    success += temp == x1.max_coord();
1638 
  }
1639 
  if(success != 5)
1640 
  {
1641 
    cout << "Failure in test of Vec3d Data manipulation";
1642 
    return 1;
1643 
  }
1644 
  success = 0;
1645 
 
1646 
  // Comparison operators
1647 
 
1648 
  {
1649 
    double xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1650 
    while(xi1 >= xi2)
1651 
    {
1652 
      xi1 = my_random();
1653 
      xi2 = my_random();
1654 
    }
1655 
    while(xi3 <= xi2)
1656 
      xi3 = my_random();
1657 
 
1658 
    Vec3d x1(xi1, xi2, xi3), x2(xi1, xi2, xi3),
1659 
          x3(xi1, xi1, xi1), x4(xi2, xi2, xi2), x5(xi3, xi3, xi3);
1660 
    success += x1 == x2;
1661 
    success += !(x1 == x3);
1662 
    success += x3 == xi1;
1663 
    success += !(x3 == xi2);
1664 
    success += x1 != x3;
1665 
    success += !(x1 != x2);
1666 
    success += x3.all_l(x4);
1667 
    success += !(x3.all_l(x2));
1668 
    success += x3.all_le(x2);
1669 
    success += !(x4.all_le(x2));
1670 
    success += x4.all_g(x3);
1671 
    success += !(x4.all_g(x2));
1672 
    success += x5.all_ge(x2);
1673 
    success += !(x4.all_ge(x2));
1674 
  }
1675 
  if(success != 14)
1676 
  {
1677 
    cout << "Failure in test of Vec3d Comparison operators";
1678 
    return 1;
1679 
  }
1680 
  success = 0;
1681 
 
1682 
  // Assignment operators
1683 
 
1684 
  {
1685 
    double xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1686 
    Vec3d x1(xi1, xi2, xi3);
1687 
    double xii = my_random();
1688 
    x1 *= xii;
1689 
    success += abs(x1[0] - xi1*xii) < 1.0e-15
1690 
               && abs(x1[1] - xi2*xii) < 1.0e-15
1691 
               && abs(x1[2] - xi3*xii) < 1.0e-15;
1692 
 
1693 
    while(xii == 0)
1694 
      xii = my_random();
1695 
    x1 = Vec3d(xi1, xi2, xi3);
1696 
    x1 /= xii;
1697 
    success += abs(x1[0] - xi1/xii) < 1.0e-15
1698 
               && abs(x1[1] - xi2/xii) < 1.0e-15
1699 
               && abs(x1[2] - xi3/xii) < 1.0e-15;
1700 
 
1701 
    x1 = Vec3d(xi1, xi2, xi3);
1702 
    x1 += xii;
1703 
    success += x1[0] == xi1 + xii && x1[1] == xi2 + xii && x1[2] == xi3 + xii;
1704 
 
1705 
    x1 = Vec3d(xi1, xi2, xi3);
1706 
    x1 -= xii;
1707 
    success += x1[0] == xi1 - xii && x1[1] == xi2 - xii && x1[2] == xi3 - xii;
1708 
 
1709 
    double xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1710 
    Vec3d x2(xii1, xii2, xii3);
1711 
    x1 = Vec3d(xi1, xi2, xi3);
1712 
    x2 *= x1;
1713 
    success += abs(x2[0] - xi1*xii1) < 1.0e-15
1714 
               && abs(x2[1] - xi2*xii2) < 1.0e-15
1715 
               && abs(x2[2] - xi3*xii3) < 1.0e-15;
1716 
 
1717 
    while(xi1 == 0)
1718 
      xi1 = my_random();
1719 
    while(xi2 == 0)
1720 
      xi2 = my_random();
1721 
    while(xi3 == 0)
1722 
      xi3 = my_random();
1723 
    x1 = Vec3d(xi1, xi2, xi3);
1724 
    x2 = Vec3d(xii1, xii2, xii3);
1725 
    x2 /= x1;
1726 
    success += abs(x2[0] - xii1/xi1) < 1.0e-15
1727 
               && abs(x2[1] - xii2/xi2) < 1.0e-15
1728 
               && abs(x2[2] - xii3/xi3) < 1.0e-15;
1729 
 
1730 
    x2 = Vec3d(xii1, xii2, xii3);
1731 
    x2 += x1;
1732 
    success += x2[0] == xii1 + xi1 && x2[1] == xii2 + xi2 && x2[2] == xii3 + xi3;
1733 
 
1734 
    x2 = Vec3d(xii1, xii2, xii3);
1735 
    x2 -= x1;
1736 
    success += x2[0] == xii1 - xi1 && x2[1] == xii2 - xi2 && x2[2] == xii3 - xi3;
1737 
  }
1738 
  if(success != 8)
1739 
  {
1740 
    cout << "Failure in test of Vec3d Assignment operators";
1741 
    return 1;
1742 
  }
1743 
  success = 0;
1744 
 
1745 
  // Unary operators
1746 
 
1747 
  {
1748 
    double xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1749 
    Vec3d x1 = -Vec3d(xi1, xi2, xi3);
1750 
    success += x1[0] == -xi1 && x1[1] == -xi2 && x1[2] == -xi3;
1751 
  }
1752 
  if(success != 1)
1753 
  {
1754 
    cout << "Failure in test of Vec3d Unary operators";
1755 
    return 1;
1756 
  }
1757 
  success = 0;
1758 
 
1759 
  // Binary operators
1760 
 
1761 
  {
1762 
    double xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1763 
    Vec3d x1(xi1, xi2, xi3);
1764 
    double xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1765 
    while(xii1 == 0)
1766 
      xii1 = my_random();
1767 
    while(xii2 == 0)
1768 
      xii2 = my_random();
1769 
    while(xii3 == 0)
1770 
      xii3 = my_random();
1771 
    Vec3d x2(xii1, xii2, xii3);
1772 
    Vec3d x3 = x1*x2;
1773 
    success += abs(x3[0] - xi1*xii1) < 1.0e-15
1774 
               && abs(x3[1] - xi2*xii2) < 1.0e-15
1775 
               && abs(x3[2] - xi3*xii3) < 1.0e-15;
1776 
 
1777 
    x3 = x1 + x2;
1778 
    success += x3[0] == xi1 + xii1 && x3[1] == xi2 + xii2 && x3[2] == xi3 + xii3;
1779 
 
1780 
    x3 = x1 - x2;
1781 
    success += x3[0] == xi1 - xii1 && x3[1] == xi2 - xii2 && x3[2] == xi3 - xii3;
1782 
 
1783 
    x3 = x1/x2;
1784 
    success += abs(x3[0] - xi1/xii1) < 1.0e-15
1785 
               && abs(x3[1] - xi2/xii2) < 1.0e-15
1786 
               && abs(x3[2] - xi3/xii3) < 1.0e-15;
1787 
 
1788 
    double xii = my_random();
1789 
    x3 = x1*xii;
1790 
    success += abs(x3[0] - xi1*xii) < 1.0e-15
1791 
               && abs(x3[1] - xi2*xii) < 1.0e-15
1792 
               && abs(x3[2] - xi3*xii) < 1.0e-15;
1793 
 
1794 
    x3 = xii*x1;
1795 
    success += abs(x3[0] - xi1*xii) < 1.0e-15
1796 
               && abs(x3[1] - xi2*xii) < 1.0e-15
1797 
               && abs(x3[2] - xi3*xii) < 1.0e-15;
1798 
 
1799 
    int xi4 = gel_rand();
1800 
    x3 = xi4*x1;
1801 
    success += abs(x3[0] - xi1*xi4) < 1.0e-15
1802 
               && abs(x3[1] - xi2*xi4) < 1.0e-15
1803 
               && abs(x3[2] - xi3*xi4) < 1.0e-15;
1804 
 
1805 
    x3 = x1*xi4;
1806 
    success += abs(x3[0] - xi1*xi4) < 1.0e-15
1807 
               && abs(x3[1] - xi2*xi4) < 1.0e-15
1808 
               && abs(x3[2] - xi3*xi4) < 1.0e-15;
1809 
 
1810 
    float xi5 = my_random();
1811 
    x3 = xi5*x1;
1812 
    success += abs(x3[0] - xi1*xi5) < 1.0e-15
1813 
               && abs(x3[1] - xi2*xi5) < 1.0e-15
1814 
               && abs(x3[2] - xi3*xi5) < 1.0e-15;
1815 
 
1816 
    x3 = x1*xi5;
1817 
    success += abs(x3[0] - xi1*xi5) < 1.0e-15
1818 
               && abs(x3[1] - xi2*xi5) < 1.0e-15
1819 
               && abs(x3[2] - xi3*xi5) < 1.0e-15;
1820 
 
1821 
    while(xii == 0)
1822 
      xii = my_random();
1823 
    x3 = x1/xii;
1824 
    success += abs(x3[0] - xi1/xii) < 1.0e-15
1825 
               && abs(x3[1] - xi2/xii) < 1.0e-15
1826 
               && abs(x3[2] - xi3/xii) < 1.0e-15;
1827 
  }
1828 
  if(success != 11)
1829 
  {
1830 
    cout << "Failure in test of Vec3d Binary operators";
1831 
    return 1;
1832 
  }
1833 
  success = 0;
1834 
 
1835 
  // Vector operations
1836 
 
1837 
  {
1838 
    double xi1 = my_random(), xi2 = my_random(), xi3 = my_random();
1839 
    Vec3d x1(xi1, xi2, xi3);
1840 
    double xii1 = my_random(), xii2 = my_random(), xii3 = my_random();
1841 
    Vec3d x2(xii1, xii2, xii3);
1842 
    double x = dot(x1, x2);
1843 
    success += abs(x - xi1*xii1 - xi2*xii2 - xi3*xii3) < 1.0e-15;
1844 
 
1845 
    x = sqr_length(x1);
1846 
    success += abs(x - xi1*xi1 - xi2*xi2 - xi3*xi3) < 1.0e-15;
1847 
 
1848 
    Vec3d x3 = v_min(x1, x2);
1849 
    success += x3[0] == (xi1 < xii1 ? xi1 : xii1)
1850 
               && x3[1] == (xi2 < xii2 ? xi2 : xii2)
1851 
               && x3[2] == (xi3 < xii3 ? xi3 : xii3);
1852 
 
1853 
    x3 = v_max(x1, x2);
1854 
    success += x3[0] == (xi1 > xii1 ? xi1 : xii1)
1855 
               && x3[1] == (xi2 > xii2 ? xi2 : xii2)
1856 
               && x3[2] == (xi3 > xii3 ? xi3 : xii3);
1857 
 
1858 
    Vec3d x4;
1859 
    orthogonal(x2, x3, x4);
1860 
    success += abs(dot(x2, x3)) < 1.0e-15;
1861 
 
1862 
    x3 = cross(x1, x2);
1863 
    success += abs(x3[0] - xi2*xii3 + xi3*xii2) < 1.0e-15
1864 
               && abs(x3[1] - xi3*xii1 + xi1*xii3) < 1.0e-15
1865 
               && abs(x3[2] - xi1*xii2 + xi2*xii1) < 1.0e-15;
1866 
 
1867 
    double theta, phi, r;
1868 
    x1.get_spherical(theta, phi, r);
1869 
    success += abs(theta - acos(xi3/sqrt(xi1*xi1 + xi2*xi2 + xi3*xi3))) < 1.0e-15
1870 
               && abs(phi - atan(xi2/xi1)) < 1.0e-15
1871 
               && abs(r - sqrt(xi1*xi1 + xi2*xi2 + xi3*xi3)) < 1.0e-15;
1872 
 
1873 
    x3.set_spherical(theta, phi, r);
1874 
    success += abs(x3[0] - xi1) < 1.0e-15
1875 
               && abs(x3[1] - xi2) < 1.0e-15
1876 
               && abs(x3[2] - xi3) < 1.0e-15;
1877 
  }
1878 
  if(success != 8)
1879 
  {
1880 
    cout << "Failure in test of Vec3d Vector operations";
1881 
    return 1;
1882 
  }
1883 
  success = 0;
1884 
 
1885 
  ////////////////////////////////////////////////
1886 
  //              F I N A L I Z E
1887 
  ////////////////////////////////////////////////
1888 
 
1889 
  cout << "Performance time: " << t.get_secs();
1890 
  cout << endl << "ArithVec and derived vector classes have been tested successfully";
1891 
 
1892 
  return 0;
1893 
}