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 *) &af;
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 *)&af;
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 *)&af;
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 *) &af;
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