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