| 1 | #include "machdefs.h"
 | 
|---|
| 2 | 
 | 
|---|
| 3 | #include <math.h>
 | 
|---|
| 4 | #include <iostream>
 | 
|---|
| 5 | 
 | 
|---|
| 6 | #include "tarrinit.h"
 | 
|---|
| 7 | #include "array.h"
 | 
|---|
| 8 | #include "timing.h"
 | 
|---|
| 9 | 
 | 
|---|
| 10 | /*  --------------------------------------------------------- */
 | 
|---|
| 11 | /*  ---- Programme de test des operations et conversions ---  */
 | 
|---|
| 12 | /*  ----    sur les TArray/TMatrix de SOPHYA    ----          */
 | 
|---|
| 13 | /*  2000-2004      -   C. Magneville,  R. Ansari              */
 | 
|---|
| 14 | /*  carrt -> Help/Usage                                       */
 | 
|---|
| 15 | /*  Pour effectuer les tests :                                */
 | 
|---|
| 16 | /* Conversions entre arr<int> et arr<float>                   */
 | 
|---|
| 17 | /*  carrt  ac         -> Rc=0 OK                              */
 | 
|---|
| 18 | /*  carrt  ace        -> Exception/Rc=9                       */
 | 
|---|
| 19 | /*  carrt  oso        -> Rc=0 OK                              */
 | 
|---|
| 20 | /*  carrt  odo        -> Rc=0 OK                              */
 | 
|---|
| 21 | /*  --- carrt oso/odo NRow NCols  pour test grande tailles    */
 | 
|---|
| 22 | /*  --------------------------------------------------------- */
 | 
|---|
| 23 | 
 | 
|---|
| 24 | static int test_ac(bool fgszm=false);
 | 
|---|
| 25 | static int test_oso(int r, int c);
 | 
|---|
| 26 | static int test_odo(int r, int c);
 | 
|---|
| 27 | 
 | 
|---|
| 28 | static int prtlev = 0;
 | 
|---|
| 29 | static int nprt = 100;
 | 
|---|
| 30 | 
 | 
|---|
| 31 | template <class T>
 | 
|---|
| 32 | void getMinMax(TArray<T>& a, T& min, T& max) { return a.MinMax(min, max); }
 | 
|---|
| 33 | 
 | 
|---|
| 34 | int main(int narg, char* arg[])
 | 
|---|
| 35 | {
 | 
|---|
| 36 | 
 | 
|---|
| 37 |   SophyaInit();
 | 
|---|
| 38 |   InitTim();   // Initializing the CPU timer
 | 
|---|
| 39 | 
 | 
|---|
| 40 |   if (narg < 2) {
 | 
|---|
| 41 |     cout << " carrt ac/ace/oso/odo [NRow=5] [NCols=10] [prtlev=0] [nprtmax=100] \n"
 | 
|---|
| 42 |          << "   ac : array conversion test   \n" 
 | 
|---|
| 43 |          << "   ace : array conversion test + conversion with sizemismatch -> exception/rc=9  \n" 
 | 
|---|
| 44 |          << "   oso : operation same memory organisation \n" 
 | 
|---|
| 45 |          << "   odo : operation different memory organisation \n" << endl;
 | 
|---|
| 46 |     return 1;
 | 
|---|
| 47 |   }
 | 
|---|
| 48 | 
 | 
|---|
| 49 |   string opt = arg[1];
 | 
|---|
| 50 |   int nr = 5;
 | 
|---|
| 51 |   int nc = 10;
 | 
|---|
| 52 |   if (narg > 2) nr = atoi(arg[2]);
 | 
|---|
| 53 |   if (narg > 3) nc = atoi(arg[3]);
 | 
|---|
| 54 |   if (narg > 4) prtlev = atoi(arg[4]);
 | 
|---|
| 55 |   if (narg > 5) nprt = atoi(arg[5]);
 | 
|---|
| 56 | 
 | 
|---|
| 57 |   BaseArray::SetMaxPrint(nprt, prtlev);
 | 
|---|
| 58 |   int rc = 0;
 | 
|---|
| 59 |   PrtTim(" Start of Test ");
 | 
|---|
| 60 |   try {
 | 
|---|
| 61 |     if (opt == "ac") rc = test_ac(false);
 | 
|---|
| 62 |     else if (opt == "ace") rc = test_ac(true);
 | 
|---|
| 63 |     else if (opt == "oso") rc = test_oso(nr, nc);
 | 
|---|
| 64 |     else if (opt == "odo") rc = test_odo(nr, nc);
 | 
|---|
| 65 |   }
 | 
|---|
| 66 |   catch (PThrowable & exc) {
 | 
|---|
| 67 |     cerr << " catched Exception " << exc.Msg() << endl;
 | 
|---|
| 68 |     rc = 9;
 | 
|---|
| 69 |   }  
 | 
|---|
| 70 |   catch (...) {
 | 
|---|
| 71 |     cerr << " catched unknown (...) exception " << endl; 
 | 
|---|
| 72 |   }  
 | 
|---|
| 73 | 
 | 
|---|
| 74 |   PrtTim(" End of Test ");
 | 
|---|
| 75 |   cout << " ----- End of carrt - Rc= " << rc << " ----- " << endl;
 | 
|---|
| 76 |   if (rc > 255) rc = 255;
 | 
|---|
| 77 |   return rc;
 | 
|---|
| 78 | }
 | 
|---|
| 79 | 
 | 
|---|
| 80 | 
 | 
|---|
| 81 | int test_ac(bool fgszm)
 | 
|---|
| 82 | {
 | 
|---|
| 83 |   cout << "\n -----> Testing TArray Conversion <---- " << endl;
 | 
|---|
| 84 |   int rc = 0;
 | 
|---|
| 85 |   int_4 min, max;
 | 
|---|
| 86 |   TArray<int_4> ia(7,5),iac,iad;   
 | 
|---|
| 87 |   ia = RegularSequence(10., 2.);
 | 
|---|
| 88 |   TArray<r_4> ra(7,5);   
 | 
|---|
| 89 |   ra = ia;
 | 
|---|
| 90 |   if (prtlev>0) 
 | 
|---|
| 91 |     cout << " ra = ia(= RegularSequence(10., 2.)) = \n " << ra << endl;
 | 
|---|
| 92 |   iac = ra;
 | 
|---|
| 93 |   iad = iac-ia;
 | 
|---|
| 94 |   getMinMax(iad, min, max);
 | 
|---|
| 95 |   if ((min != 0) || (max != 0)) {
 | 
|---|
| 96 |     cout << "(1) !!! ERROR ra(7,5)=ia(7,5)  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 97 |     rc += 1;
 | 
|---|
| 98 |   }
 | 
|---|
| 99 |   else cout << "(1) OK  ra(7,5)=ia(7,5)  OK " << endl; 
 | 
|---|
| 100 | 
 | 
|---|
| 101 |   TArray<r_4> rb(5,3);
 | 
|---|
| 102 |   rb =  RegularSequence(20., .5);  
 | 
|---|
| 103 |   TMatrix<int_4> mx(3,5);
 | 
|---|
| 104 |   TMatrix<int_4> mxc(3,5);
 | 
|---|
| 105 |   mxc = RegularSequence(20., .5);  
 | 
|---|
| 106 |   if (prtlev>0) 
 | 
|---|
| 107 |     cout << " TArray<r_4> rb(5,3); rb =  RegularSequence(20., .5); rb : " << rb << endl;
 | 
|---|
| 108 |   mx = rb;
 | 
|---|
| 109 |   if (prtlev>0) 
 | 
|---|
| 110 |     cout << " TMatrix<int_4> mx(3,5);       mx = rb;  mx: " << mx << endl;
 | 
|---|
| 111 |   TMatrix<int_4> mxd = mxc-mx;
 | 
|---|
| 112 |   getMinMax(mxd, min, max);
 | 
|---|
| 113 |   if ((min != 0) || (max != 0)) {
 | 
|---|
| 114 |     cout << "(2) !!! ERROR mx<int>(5,3)=rb<r_4>(5,3)  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 115 |     rc += 2;
 | 
|---|
| 116 |   }
 | 
|---|
| 117 |   else cout << "(2) OK  mx<int>(5,3)=rb<r_4>(5,3)  OK " << endl; 
 | 
|---|
| 118 | 
 | 
|---|
| 119 |   TArray<r_4> rcv(10);
 | 
|---|
| 120 |   rcv = 3.1415;
 | 
|---|
| 121 |   TMatrix<r_8> mx2(rcv);
 | 
|---|
| 122 |   if (prtlev>0) 
 | 
|---|
| 123 |     cout << "   TArray<r_4> rcv(10) = 3.1415 , TMatrix<r_8> mx2(rc)=rcv : " << mx2 << endl;
 | 
|---|
| 124 |   TMatrix<int_4> mx2d = mx2-3.1415;
 | 
|---|
| 125 |   getMinMax(mxd, min, max);
 | 
|---|
| 126 |   if ((min != 0) || (max != 0)) {
 | 
|---|
| 127 |     cout << "(3) !!! ERROR mx2<r_8>(10)=rcv<r_4>(10)  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 128 |     rc += 4;
 | 
|---|
| 129 |   }
 | 
|---|
| 130 |   else cout << "(3) OK  mx2<r_8>(10)=rcv<r_4>(10)  OK " << endl; 
 | 
|---|
| 131 |   if (fgszm) {
 | 
|---|
| 132 |     TMatrix<int_4> mx3(3,5);
 | 
|---|
| 133 |     cout << "(4) Trying  TMatrix<int_4> mx3(3,5);  mx3 = rcv(10); ?? -> Exception " << endl;
 | 
|---|
| 134 |     mx3 = rcv;
 | 
|---|
| 135 |   }
 | 
|---|
| 136 |   return(rc);
 | 
|---|
| 137 | }
 | 
|---|
| 138 | 
 | 
|---|
| 139 | int test_oso(int nr, int nc)
 | 
|---|
| 140 | {
 | 
|---|
| 141 |   cout << "\n -----> Testing TArray operation TArray<int_4>(nx=" << nr << ",ny=" 
 | 
|---|
| 142 |        << nc << " ) " << endl;
 | 
|---|
| 143 |   cout << " -----> OSO (Same Mem. Mapping) Same memory mapping (default) for all arrays" << endl;
 | 
|---|
| 144 | 
 | 
|---|
| 145 |   int rc = 0;
 | 
|---|
| 146 |   int min,max;
 | 
|---|
| 147 | 
 | 
|---|
| 148 |   TArray<int_4> a(nr,nc);
 | 
|---|
| 149 |   a = 20;
 | 
|---|
| 150 |   TArray<int_4> b(nr,nc);
 | 
|---|
| 151 |   b = 9;
 | 
|---|
| 152 |   if (prtlev > 0) {
 | 
|---|
| 153 |     cout << " A = \n " << a << endl;
 | 
|---|
| 154 |     cout << " B = \n " << b << endl;
 | 
|---|
| 155 |   }
 | 
|---|
| 156 | 
 | 
|---|
| 157 |   TArray<int_4> ar;
 | 
|---|
| 158 |   ar = a+2;  
 | 
|---|
| 159 |   if (prtlev > 0) 
 | 
|---|
| 160 |     cout << "(1) AR = A+2=  " << ar << endl;
 | 
|---|
| 161 |   getMinMax(ar, min, max);
 | 
|---|
| 162 |   if ((min != 22) || (max != 22)) {
 | 
|---|
| 163 |     cout << "(1) !!! ERROR Test AR=A+2  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 164 |     rc += 1;
 | 
|---|
| 165 |   }
 | 
|---|
| 166 |   else cout << "(1) OK   Test AR=A+2  OK " << endl; 
 | 
|---|
| 167 | 
 | 
|---|
| 168 |   ar = 28-a;  
 | 
|---|
| 169 |   if (prtlev > 0) 
 | 
|---|
| 170 |     cout << "(2) AR = 28-A=  " << ar << endl;
 | 
|---|
| 171 |   getMinMax(ar, min, max);
 | 
|---|
| 172 |   if ((min != 8) || (max != 8)) {
 | 
|---|
| 173 |     cout << "(2) !!! ERROR Test AR=28-A  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 174 |     rc += 2;
 | 
|---|
| 175 |   }
 | 
|---|
| 176 |   else cout << "(2) OK   Test AR=28-A  OK " << endl;
 | 
|---|
| 177 |  
 | 
|---|
| 178 |   ar = a*3;  
 | 
|---|
| 179 |   if (prtlev > 0) 
 | 
|---|
| 180 |     cout << "(3) AR = A*3=  " << ar << endl;
 | 
|---|
| 181 |   getMinMax(ar, min, max);
 | 
|---|
| 182 |   if ((min != 60) || (max != 60)) {
 | 
|---|
| 183 |     cout << "(3) !!! ERROR Test AR=A*3  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 184 |     rc += 4;
 | 
|---|
| 185 |   }
 | 
|---|
| 186 |   else cout << "(3) OK   Test AR=A*3  OK " << endl; 
 | 
|---|
| 187 | 
 | 
|---|
| 188 |   ar = a/5;  
 | 
|---|
| 189 |   if (prtlev > 0) 
 | 
|---|
| 190 |     cout << "(4) AR = A/5=  " << ar << endl;
 | 
|---|
| 191 |   getMinMax(ar, min, max);
 | 
|---|
| 192 |   if ((min != 4) || (max != 4)) {
 | 
|---|
| 193 |     cout << "(4) !!! ERROR Test AR=A/5  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 194 |     rc += 8;
 | 
|---|
| 195 |   }
 | 
|---|
| 196 |   else cout << "(4) OK   Test AR=A/5  OK " << endl; 
 | 
|---|
| 197 | 
 | 
|---|
| 198 |   ar = 140/a;  
 | 
|---|
| 199 |   if (prtlev > 0) 
 | 
|---|
| 200 |     cout << "(5) AR = 140/A= \n " << ar << endl;
 | 
|---|
| 201 |   getMinMax(ar, min, max);
 | 
|---|
| 202 |   if ((min != 7) || (max != 7)) {
 | 
|---|
| 203 |     cout << "(5) !!! ERROR Test AR=140/A  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 204 |     rc += 16;
 | 
|---|
| 205 |   }
 | 
|---|
| 206 |   else cout << "(5) OK   Test AR=140/A  OK " << endl; 
 | 
|---|
| 207 | 
 | 
|---|
| 208 |   ar -= 3;  
 | 
|---|
| 209 |   if (prtlev > 0) 
 | 
|---|
| 210 |     cout << "(6) AR -= 3  " << ar << endl;
 | 
|---|
| 211 |   getMinMax(ar, min, max);
 | 
|---|
| 212 |   if ((min != 4) || (max != 4)) {
 | 
|---|
| 213 |     cout << "(6) !!! ERROR Test AR-=3  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 214 |     rc += 32;
 | 
|---|
| 215 |   }
 | 
|---|
| 216 |   else cout << "(6) OK   Test AR-=3  OK " << endl; 
 | 
|---|
| 217 | 
 | 
|---|
| 218 | 
 | 
|---|
| 219 |   TArray<int_4> c = a-2*b;
 | 
|---|
| 220 |   if (prtlev > 0) 
 | 
|---|
| 221 |     cout << "(7) C = A-2*B=  " << c << endl;
 | 
|---|
| 222 |   getMinMax(c, min, max);
 | 
|---|
| 223 |   if ((min != 2) || (max != 2)) {
 | 
|---|
| 224 |     cout << "(7) !!! ERROR Test C=A+2*B  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 225 |     rc += 64;
 | 
|---|
| 226 |   }
 | 
|---|
| 227 |   else cout << "(7) OK   Test C=A+2*B  OK " << endl; 
 | 
|---|
| 228 | 
 | 
|---|
| 229 |   c = (a*4+1).DivElt(b);
 | 
|---|
| 230 |   if (prtlev > 0) cout << "(8) C = (A*4+1)/B = " << c << endl;
 | 
|---|
| 231 |   getMinMax(c, min, max);
 | 
|---|
| 232 |   if ((min != 9) || (max != 9)) {
 | 
|---|
| 233 |     cout << "(8) !!! ERROR Test C = (A*4+1)/B  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 234 |     rc += 128;
 | 
|---|
| 235 |   }
 | 
|---|
| 236 |   else cout << "(8) OK   Test C = (A*4+1)/B ((DivElt) OK " << endl; 
 | 
|---|
| 237 |   
 | 
|---|
| 238 |   a = RegularSequence(1, 1);
 | 
|---|
| 239 |   b = RegularSequence(nr*nc, -1);
 | 
|---|
| 240 |   c = (a*2)+(b*2);
 | 
|---|
| 241 |   if (prtlev > 0) {
 | 
|---|
| 242 |     cout << "(9) A =  " << a << endl;
 | 
|---|
| 243 |     cout << "(9) B =  " << b << endl;
 | 
|---|
| 244 |     cout << "(9) C = 2A-2*B=  " << c << endl;
 | 
|---|
| 245 |   }
 | 
|---|
| 246 |   c /= (nr*nc+1);
 | 
|---|
| 247 |   getMinMax(c, min, max);
 | 
|---|
| 248 |   if ((min != 2) || (max != 2)) {
 | 
|---|
| 249 |     cout << "(9) !!! ERROR Test C=2A+2*B  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 250 |     rc += 256;
 | 
|---|
| 251 |   }
 | 
|---|
| 252 |   else cout << "(9) OK   Test C=2A+2*B  OK " << endl; 
 | 
|---|
| 253 |   
 | 
|---|
| 254 |   return(rc);
 | 
|---|
| 255 | }
 | 
|---|
| 256 | 
 | 
|---|
| 257 | int test_odo(int nr, int nc)
 | 
|---|
| 258 | {
 | 
|---|
| 259 |   cout << "\n -----> Testing TMatrix operation TMatrix<r_4>(nr=" << nr << ",nc=" 
 | 
|---|
| 260 |        << nc << " ) " << endl;
 | 
|---|
| 261 |   cout << " ----> ODO (Diff. Mem. Mapping) A: CMemoryMapping AR,B,C: FortranMemoryMapping" << endl;
 | 
|---|
| 262 | 
 | 
|---|
| 263 |   int rc = 0;
 | 
|---|
| 264 |   r_4 min,max;
 | 
|---|
| 265 | 
 | 
|---|
| 266 |   TMatrix<r_4> a(nr,nc,BaseArray::CMemoryMapping);
 | 
|---|
| 267 |   a = 20;
 | 
|---|
| 268 |   TMatrix<r_4> b(nr,nc,BaseArray::FortranMemoryMapping);
 | 
|---|
| 269 |   b = 9;
 | 
|---|
| 270 | 
 | 
|---|
| 271 |   TMatrix<r_4> ar(nr,nc,BaseArray::FortranMemoryMapping);
 | 
|---|
| 272 | 
 | 
|---|
| 273 |   if (prtlev > 0) {
 | 
|---|
| 274 |     cout << " A = \n " << a << endl;
 | 
|---|
| 275 |     cout << " B = \n " << b << endl;
 | 
|---|
| 276 |   }
 | 
|---|
| 277 | 
 | 
|---|
| 278 |   a.AddCst(2.,ar);
 | 
|---|
| 279 |   if (prtlev > 0) 
 | 
|---|
| 280 |     cout << "(1) AR = A+2 : a.AddCst(2,ar) : " << ar << endl;
 | 
|---|
| 281 |   getMinMax(ar, min, max);
 | 
|---|
| 282 |   if ((fabs(min-22.) > 0.0001) || (fabs(max-22.) > 0.0001)) {
 | 
|---|
| 283 |     cout << "(1) !!! ERROR Test AR=A+2  a.AddCst(2,ar)   Min=" << min << " Max=" << max << endl;
 | 
|---|
| 284 |     rc += 1;
 | 
|---|
| 285 |   }
 | 
|---|
| 286 |   else cout << "(1) OK   Test AR=A+2 a.AddCst(2,ar)  OK " << endl; 
 | 
|---|
| 287 | 
 | 
|---|
| 288 |   a.SubCst(28.,ar,true);
 | 
|---|
| 289 |   if (prtlev > 0) 
 | 
|---|
| 290 |     cout << "(2) AR = 28-A : a.SubCst(28,ar,true) :  " << ar << endl;
 | 
|---|
| 291 |   getMinMax(ar, min, max);
 | 
|---|
| 292 |   if ((fabs(min-8.) > 0.0001) || (fabs(max-8.) > 0.0001)) {
 | 
|---|
| 293 |     cout << "(2) !!! ERROR Test AR=28-A  a.SubCst(28,ar,true) Min=" << min << " Max=" << max << endl;
 | 
|---|
| 294 |     rc += 2;
 | 
|---|
| 295 |   }
 | 
|---|
| 296 |   else cout << "(2) OK   Test AR=28-A  a.SubCst(28,ar,true) OK " << endl;
 | 
|---|
| 297 |  
 | 
|---|
| 298 |   a.MulCst(3.,ar);
 | 
|---|
| 299 |   if (prtlev > 0) 
 | 
|---|
| 300 |     cout << "(3) AR = A*3= a.MulCst(3,ar)  " << ar << endl;
 | 
|---|
| 301 |   getMinMax(ar, min, max);
 | 
|---|
| 302 |   if ((fabs(min-60.) > 0.0001) || (fabs(max-60.) > 0.0001)) {
 | 
|---|
| 303 |     cout << "(3) !!! ERROR Test AR=A*3  a.MulCst(3,ar) Min=" << min << " Max=" << max << endl;
 | 
|---|
| 304 |     rc += 4;
 | 
|---|
| 305 |   }
 | 
|---|
| 306 |   else cout << "(3) OK   Test AR=A*3  a.MulCst(3,ar) OK " << endl; 
 | 
|---|
| 307 | 
 | 
|---|
| 308 |   a.DivCst(5.,ar);
 | 
|---|
| 309 |   if (prtlev > 0) 
 | 
|---|
| 310 |     cout << "(4) AR = A/5= a.DivCst(5,ar) : " << ar << endl;
 | 
|---|
| 311 |   getMinMax(ar, min, max);
 | 
|---|
| 312 |   if ((fabs(min-4.) > 0.0001) || (fabs(max-4.) > 0.0001)) {
 | 
|---|
| 313 |     cout << "(4) !!! ERROR Test AR=A/5  a.DivCst(5,ar) Min=" << min << " Max=" << max << endl;
 | 
|---|
| 314 |     rc += 8;
 | 
|---|
| 315 |   }
 | 
|---|
| 316 |   else cout << "(4) OK   Test AR=A/5  a.DivCst(5,ar) OK " << endl; 
 | 
|---|
| 317 | 
 | 
|---|
| 318 |   a.DivCst(140.,ar,true);
 | 
|---|
| 319 |   if (prtlev > 0) 
 | 
|---|
| 320 |     cout << "(5) AR = 140/A= a.DivCst(140.,ar,true) : " << ar << endl;
 | 
|---|
| 321 |   getMinMax(ar, min, max);
 | 
|---|
| 322 |   if ((fabs(min-7.) > 0.0001) || (fabs(max-7.) > 0.0001)) {
 | 
|---|
| 323 |     cout << "(5) !!! ERROR Test AR=140/A  a.DivCst(140.,ar,true) Min=" << min << " Max=" << max << endl;
 | 
|---|
| 324 |     rc += 16;
 | 
|---|
| 325 |   }
 | 
|---|
| 326 |   else cout << "(5) OK   Test AR=140/A  a.DivCst(140.,ar,true) OK " << endl; 
 | 
|---|
| 327 | 
 | 
|---|
| 328 |   ar -= 3.;  
 | 
|---|
| 329 |   if (prtlev > 0) 
 | 
|---|
| 330 |     cout << "(6) AR -= 3 " << ar << endl;
 | 
|---|
| 331 |   getMinMax(ar, min, max);
 | 
|---|
| 332 |   if ((min != 4) || (max != 4)) {
 | 
|---|
| 333 |     cout << "(6) !!! ERROR Test AR-=3  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 334 |     rc += 32;
 | 
|---|
| 335 |   }
 | 
|---|
| 336 |   else cout << "(6) OK   Test AR-=3  OK " << endl; 
 | 
|---|
| 337 | 
 | 
|---|
| 338 |   TMatrix<r_4> c(nr,nc,BaseArray::FortranMemoryMapping);
 | 
|---|
| 339 |   c = a-(b*2.0f);
 | 
|---|
| 340 |   if (prtlev > 0) cout << "(7) C = A-2*B=  " << c << endl;
 | 
|---|
| 341 | 
 | 
|---|
| 342 |   getMinMax(c, min, max);
 | 
|---|
| 343 |   if ((fabs(min-2.) > 0.0001) || (fabs(max-2.) > 0.0001)) {
 | 
|---|
| 344 |     cout << "(7) !!! ERROR Test C=A+2*B  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 345 |     rc += 64;
 | 
|---|
| 346 |   }
 | 
|---|
| 347 |   else cout << "(7) OK   Test C=A+2*B  OK " << endl; 
 | 
|---|
| 348 | 
 | 
|---|
| 349 |   c = (a*4.0f+5.5f).DivElt(b);
 | 
|---|
| 350 |   if (prtlev > 0) cout << "(8) C = (A*4+12)/B = " << c << endl;
 | 
|---|
| 351 |   getMinMax(c, min, max);
 | 
|---|
| 352 |   if ((fabs(min-9.5) > 0.0001) || (fabs(max-9.5) > 0.0001)) {
 | 
|---|
| 353 |     cout << "(8) !!! ERROR Test C = (A*4+12)/B  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 354 |     rc += 128;
 | 
|---|
| 355 |   }
 | 
|---|
| 356 |   else cout << "(8) OK   Test C = (A*4+12)/B  OK " << endl; 
 | 
|---|
| 357 | 
 | 
|---|
| 358 |   a = RegularSequence(1, 1);
 | 
|---|
| 359 |   b = RegularSequence(nr*nc, -1);
 | 
|---|
| 360 |   c = (a*2.f)+(b*2.f);
 | 
|---|
| 361 |   if (prtlev > 0) {
 | 
|---|
| 362 |     cout << "(9) A =  " << a << endl;
 | 
|---|
| 363 |     cout << "(9) B =  " << b << endl;
 | 
|---|
| 364 |     cout << "(9) C = 2A-2*B= " << c << endl;
 | 
|---|
| 365 |   }
 | 
|---|
| 366 |   c /= (nr*nc+1);
 | 
|---|
| 367 |   getMinMax(c, min, max);
 | 
|---|
| 368 |   if ((fabs(min-2.) > 0.0001) || (fabs(max-2.) > 0.0001)) {
 | 
|---|
| 369 |     cout << "(9) !!! ERROR Test3 C=2A+2*B  Min=" << min << " Max=" << max << endl;
 | 
|---|
| 370 |     rc += 256;
 | 
|---|
| 371 |   }
 | 
|---|
| 372 |   else cout << "(9) OK   Test3 C=2A+2*B  OK " << endl; 
 | 
|---|
| 373 | 
 | 
|---|
| 374 |   return(rc);
 | 
|---|
| 375 | 
 | 
|---|
| 376 | }
 | 
|---|