| [786] | 1 | #include "machdefs.h"
 | 
|---|
 | 2 | 
 | 
|---|
 | 3 | #include <math.h>
 | 
|---|
 | 4 | #include <iostream.h>
 | 
|---|
 | 5 | 
 | 
|---|
 | 6 | #include "tarrinit.h"
 | 
|---|
| [812] | 7 | #include "array.h"
 | 
|---|
| [786] | 8 | #include "timing.h"
 | 
|---|
 | 9 | 
 | 
|---|
| [812] | 10 | static void tstarr(bool tio);
 | 
|---|
 | 11 | static void tstioarr(TArray<int_4> & ia, TArray<int_4> & ib, TArray<int_4> & ic);
 | 
|---|
 | 12 | static void tstmtx(int n);
 | 
|---|
 | 13 | void _ZZ_TestTMatrixRC_YY_(TMatrix<r_8> & m);
 | 
|---|
| [786] | 14 | 
 | 
|---|
 | 15 | int main(int narg, char* arg[])
 | 
|---|
 | 16 | {
 | 
|---|
 | 17 | 
 | 
|---|
 | 18 |   SophyaInit();
 | 
|---|
 | 19 |   InitTim();   // Initializing the CPU timer
 | 
|---|
 | 20 | 
 | 
|---|
 | 21 | 
 | 
|---|
| [812] | 22 |   if (narg < 2) {
 | 
|---|
 | 23 |     cout << " arrt - TArray<T> Test - Usage arrt a/p/m/z [size=5] [prtlev=1] [nprt=50]\n" 
 | 
|---|
 | 24 |          << " a: Simple Array Test  w: a+ PPersist Test (FIO_TArray<T>) \n" 
 | 
|---|
 | 25 |          << " m: Matrix and Vector Test \n" 
 | 
|---|
 | 26 |          << " z: Appel_ZZ_TestTMatrixRC_YY_ " << endl;
 | 
|---|
 | 27 |     exit(0);
 | 
|---|
 | 28 |   }
 | 
|---|
 | 29 | 
 | 
|---|
 | 30 |   int opt = *(arg[1]);
 | 
|---|
| [786] | 31 |   int n = 5;
 | 
|---|
| [812] | 32 |   if (narg > 2) n = atoi(arg[2]);
 | 
|---|
 | 33 |   uint_4 prtlev = 1;
 | 
|---|
 | 34 |   uint_4 nprt = 50;
 | 
|---|
 | 35 |   if (narg > 3) prtlev = atoi(arg[3]);
 | 
|---|
 | 36 |   if (narg > 4) nprt = atoi(arg[4]);
 | 
|---|
| [786] | 37 | 
 | 
|---|
| [812] | 38 |   BaseArray::SetMaxPrint(nprt, prtlev);
 | 
|---|
| [786] | 39 | 
 | 
|---|
 | 40 |   try {
 | 
|---|
| [812] | 41 |     if ((opt == 'w') || (opt == 'a')) tstarr((opt=='w'));
 | 
|---|
 | 42 |     else if (opt == 'z') {
 | 
|---|
 | 43 |       if (n<5) n = 5;
 | 
|---|
 | 44 |       TMatrix<r_8> tza(n,n+3);
 | 
|---|
 | 45 |       tza = Sequence(2.,1.5);
 | 
|---|
 | 46 |       _ZZ_TestTMatrixRC_YY_(tza);
 | 
|---|
 | 47 |       TMatrix<r_8> tza2 = tza(Range(1,3), Range(2,5));
 | 
|---|
 | 48 |       _ZZ_TestTMatrixRC_YY_(tza2);
 | 
|---|
 | 49 |     }
 | 
|---|
 | 50 |     else tstmtx(n);
 | 
|---|
 | 51 |   }
 | 
|---|
 | 52 |   catch (PThrowable exc) {
 | 
|---|
 | 53 |     cerr << " catched Exception " << exc.Msg() << endl;
 | 
|---|
 | 54 |   }  
 | 
|---|
 | 55 |   catch (...) {
 | 
|---|
 | 56 |     cerr << " catched unknown (...) exception " << endl; 
 | 
|---|
 | 57 |   }  
 | 
|---|
 | 58 |   PrtTim("--- End of arrt ---");
 | 
|---|
 | 59 |   cout << " ---------------  END of ArrayTest programme -------------- " << endl;
 | 
|---|
 | 60 | }
 | 
|---|
 | 61 | 
 | 
|---|
 | 62 | 
 | 
|---|
 | 63 | void tstmtx(int n)
 | 
|---|
 | 64 | {
 | 
|---|
 | 65 |   TMatrix<r_4> ma(4,7);
 | 
|---|
 | 66 |   ma = Sequence(10., 2.);
 | 
|---|
 | 67 |   cout << "\n ::::::  Testing TMatrix - TVector ::::::  " << endl;  
 | 
|---|
 | 68 |   TMatrix<r_4> sma1 = ma(Range(1,2), Range(2,4));
 | 
|---|
 | 69 |   cout << " ----- Matrix ma = \n " << ma << endl;
 | 
|---|
 | 70 |   sma1 = 3.14;
 | 
|---|
 | 71 |   cout << " ----- Matrix ma (Avec sma1=ma(Range(1,2), Range(2,3))=3.14) = \n " << ma << endl;
 | 
|---|
 | 72 |   TMatrix<r_4> mb(2,3);
 | 
|---|
 | 73 |   mb = 50.;
 | 
|---|
 | 74 |   TMatrix<r_4> mc = mb+sma1;
 | 
|---|
 | 75 |   cout << " ----- Matrix mc = mb(=50.)+sma1(=3.14) = " << mc << endl;
 | 
|---|
 | 76 |   TMatrix<r_4> md = (float)100+mc;
 | 
|---|
 | 77 |   cout << " ----- Matrix md=100.+mc = " << md << endl;
 | 
|---|
 | 78 |   cout << " ----- Matrix md-50 = " << md-(float)50. << endl;
 | 
|---|
 | 79 | 
 | 
|---|
 | 80 |   TMatrix<int_4> ima(3,10);
 | 
|---|
 | 81 |   ima = Sequence(0.01,1.);
 | 
|---|
 | 82 |   cout << " ----- Matrix ima(3,10) = Sequence(0.01,1.) = " << ima << endl;
 | 
|---|
 | 83 |   cout << " ----- Matrix  ima.Column(3) = \n" << ima.Column(3) << endl;
 | 
|---|
 | 84 |   TVector<int_4> vcol = ima.Column(7);
 | 
|---|
 | 85 |   cout << " ----- Vector  vcol=ima.Column(7) = \n" << vcol << endl;
 | 
|---|
 | 86 |   cout << " ----- Matrix  ima.Row(0) = \n" << ima.Row(0) << endl;
 | 
|---|
| [820] | 87 |   TVector<int_4> vlig;
 | 
|---|
 | 88 |   vlig = ima.Row(1);
 | 
|---|
| [812] | 89 |   cout << " ----- Vector  vlig=ima.Row(1) = \n" << vlig << endl;
 | 
|---|
 | 90 | 
 | 
|---|
 | 91 |   TMatrix<int_4> imb(3,10);
 | 
|---|
 | 92 |   imb = Sequence(100.01,10.);
 | 
|---|
 | 93 |   cout << " ----- Matrix imb(3,10) = Sequence(100.01,10.) = " << imb << endl;
 | 
|---|
 | 94 |   TMatrix<int_4> imc = ima+imb;
 | 
|---|
 | 95 |   cout << " ----- Matrix imc=ima+imb = " << imc << endl;
 | 
|---|
 | 96 |   TMatrix<int_4> imd(3,10);
 | 
|---|
 | 97 |   TMatrix<int_4> imd2(3,10);
 | 
|---|
 | 98 |   imd += 25;
 | 
|---|
 | 99 |   imd *= 2;
 | 
|---|
 | 100 |   imd2 = 2;
 | 
|---|
 | 101 |   imd.MulElt(imd2);
 | 
|---|
 | 102 |   cout << " ----- Matrix imd (? = 100) " << imd << endl;
 | 
|---|
 | 103 |   imb -= imd;
 | 
|---|
 | 104 |   imc -= imd;
 | 
|---|
 | 105 |   cout << " ----- Matrix ((imc-=imd)-(imb-=imd))-ima (== 0 ?) " 
 | 
|---|
 | 106 |        << (imc-imb)-ima << endl;
 | 
|---|
 | 107 |   TVector<r_4> va(16, BaseArray::RowVector);
 | 
|---|
 | 108 |   va = Sequence(0.,1.);
 | 
|---|
 | 109 |   cout << " ----- Vector va = Sequence(0.,1.) = " << va << endl;
 | 
|---|
 | 110 |   va(Range(2,0,6,2)) *= 10.;
 | 
|---|
 | 111 |   cout << " ----- Vector va apres va(Range(2,0,6,2)) *= 10. " << va << endl;
 | 
|---|
 | 112 |   va(Range(0,5)) += 100.;
 | 
|---|
 | 113 |   cout << " ----- Vector va apres va(Range(0,6)) += 100. " << va << endl;
 | 
|---|
 | 114 | 
 | 
|---|
 | 115 |   cout << "\n :::::: Testing Matrix operations :::::: " << endl;
 | 
|---|
 | 116 |   TMatrix<r_4> ra(2,2), ira(2,2);
 | 
|---|
 | 117 |   ra(0,0) = 2.;   ra(0,1) = 1.;
 | 
|---|
 | 118 |   ra(1,0) = 4.;   ra(1,1) = 3.;
 | 
|---|
 | 119 |   ira(0,0) = 1.5;   ira(0,1) = -0.5;
 | 
|---|
 | 120 |   ira(1,0) = -2.;    ira(1,1) = 1.;
 | 
|---|
 | 121 |   cout << " ----- Matrix ra = \n " << ra << endl; 
 | 
|---|
 | 122 |   cout << " ----- Matrix ira = \n " << ira << endl; 
 | 
|---|
 | 123 |   cout << " ----- Matrix ira*ra = (= Identity ?) " << ira*ra << endl; 
 | 
|---|
 | 124 | 
 | 
|---|
 | 125 | 
 | 
|---|
 | 126 |   cout << "\n ::::::: Testing Matrix Inversion ::::::: " << endl;
 | 
|---|
 | 127 |   SimpleMatrixOperation<r_4> smr;
 | 
|---|
 | 128 |   TMatrix<r_4> cira = smr.Inverse(ra);
 | 
|---|
 | 129 |   cout << " ----- Matrix Inverse(ra) =  " << cira << endl;
 | 
|---|
 | 130 |   cout << " ----- ira-Inverse(ra) = " << ira-cira << endl;
 | 
|---|
 | 131 | 
 | 
|---|
 | 132 |   Matrix a(n,n);
 | 
|---|
 | 133 | 
 | 
|---|
 | 134 |     
 | 
|---|
| [857] | 135 |   //  for(int i=0; i<n; i++)
 | 
|---|
 | 136 |   //    for(int j=0; j<n; j++)  a(j,i) = GauRnd(0., 1.);
 | 
|---|
 | 137 |   a = Sequence(RandomSequence(RandomSequence::Gaussian, 0., 2.5));
 | 
|---|
 | 138 |   cout << " ----- Matrix a=Sequence(RandomSequence(RandomSequence::Gaussian, 0., 2.5)) = \n " << a << endl;
 | 
|---|
| [812] | 139 |   Vector x(n);
 | 
|---|
 | 140 |   x = Sequence(1.,3.);
 | 
|---|
 | 141 |   Vector b = a*x;
 | 
|---|
 | 142 |   cout << " ----- Vector x = \n " << x << endl;
 | 
|---|
 | 143 |   cout << " ----- Vector b = a*x = \n " << b << endl;
 | 
|---|
 | 144 |   SimpleMatrixOperation<r_8> smo;
 | 
|---|
 | 145 |   Matrix inva = smo.Inverse(a);
 | 
|---|
 | 146 |   cout << " ----- Matrix Inverse(a) = \n " << inva << endl;
 | 
|---|
 | 147 |   cout << " ----- Matrix a*Inverse(a) = \n " << inva*a << endl;
 | 
|---|
 | 148 |   cout << " ----- Matrix Inverse(a)*b (=Inv(a)*a*x) = \n " << inva*b << endl;
 | 
|---|
 | 149 |   cout << " ----- Matrix x-Inverse(a)*b = (=0 ?)\n " << x-inva*b << endl;
 | 
|---|
 | 150 | }
 | 
|---|
 | 151 | 
 | 
|---|
 | 152 | void tstarr(bool tio)
 | 
|---|
 | 153 | {
 | 
|---|
| [786] | 154 |   cout << "\n -----> Testing TArray <---- " << endl;  
 | 
|---|
| [789] | 155 |   // We create a integer array SizeX=7, SizeY=5
 | 
|---|
| [786] | 156 |   TArray<int_4> ia(7,5); 
 | 
|---|
| [789] | 157 |   // We fill it with a sequence of numbers starting at 10., with step = 2.
 | 
|---|
| [786] | 158 |   ia = Sequence(10., 2.);
 | 
|---|
| [812] | 159 |   cout << " ----- Array IA = \n " << ia << endl;
 | 
|---|
 | 160 |   // sub array extraction, Range(2,4) : starting position=2 , End=4
 | 
|---|
 | 161 |   TArray<int_4> ic = ia(Range(2,3),Range(1,3),Range(0));
 | 
|---|
 | 162 |   cout << " ----- Array IC IA(Range(2,4),Range(1,2)) = \n " << ic << endl;
 | 
|---|
| [789] | 163 |   // we set the sub-array to zero, this should reflect in the original array
 | 
|---|
 | 164 |   // sub-arrays share their data with parent array
 | 
|---|
| [786] | 165 |   ic = 0;
 | 
|---|
| [812] | 166 |   cout << " ----- Array IC Apres (=0) = \n " << ic << endl;
 | 
|---|
 | 167 |   cout << " ----- Array IA Apres IC=0 = \n " << ia << endl;
 | 
|---|
| [786] | 168 | 
 | 
|---|
 | 169 |   cout << "  :::: 3 Dim arrays ::::: " << endl;
 | 
|---|
 | 170 |   TArray<int_4>::SetMaxPrint(1000);
 | 
|---|
| [789] | 171 |   // Creating 3-dim array (X=8 x Y=7 x Z=2) , filling it with 5
 | 
|---|
| [786] | 172 |   TArray<int_4> ib(8,7,2);
 | 
|---|
 | 173 |   ib = 5;
 | 
|---|
| [812] | 174 |   cout << " ----- Array IB = \n " << ib << endl;
 | 
|---|
| [789] | 175 |   // Sub array extraction  X from 1 , size 4 - Y from 2 , size 3 , in Z default, from 0, size 1
 | 
|---|
 | 176 |   // we multiply this sub-array elements by 3
 | 
|---|
| [812] | 177 |   ib(Range(1,4),Range(2,4), Range(0)) *= 3;
 | 
|---|
 | 178 |   cout << " -- Array IB , Apres ib(Range(1,4),Range(2,4))*=3 : " << endl;
 | 
|---|
| [786] | 179 |   cout << ib;
 | 
|---|
| [812] | 180 |   cout << " -- Array ib(Range(1,4),Range(2,4)) =  : " 
 | 
|---|
 | 181 |        << ib(Range(1,4),Range(2,4), Range(0)) << endl;
 | 
|---|
| [789] | 182 | 
 | 
|---|
 | 183 |   // Creating a double array X=5 x Y=2
 | 
|---|
 | 184 |   TArray<r_4> fa(5,2);
 | 
|---|
 | 185 |   // fill it up with a sequence of 0. to 1.
 | 
|---|
 | 186 |   fa = Sequence(0.,1./(5*2));
 | 
|---|
 | 187 |   cout << " ------ TArray<r_4> fa(5,2) = \n" << fa << endl;
 | 
|---|
 | 188 |   // Create a new array from the original array , multiplying it by 2*Pi
 | 
|---|
 | 189 |   TArray<r_4> fa2 = fa*(float)(2.*M_PI); 
 | 
|---|
 | 190 |   cout << " ------ TArray<r_4> fa2=fa*2*Pi = \n" << fa2 << endl;
 | 
|---|
 | 191 |   // Compute sin(fa2) cos(fa2)
 | 
|---|
 | 192 |   cout << " ------ sin(fa2=fa*2*Pi) = \n" << sin(fa2) << endl;
 | 
|---|
 | 193 |   cout << " ------ cos(fa2=fa*2*Pi) = \n" << cos(fa2) << endl;
 | 
|---|
| [807] | 194 | 
 | 
|---|
 | 195 |   if (tio) tstioarr(ia, ib, ic);
 | 
|---|
| [786] | 196 | }
 | 
|---|
| [807] | 197 | 
 | 
|---|
 | 198 | void tstioarr(TArray<int_4> & ia, TArray<int_4> & ib, TArray<int_4> & ic)
 | 
|---|
 | 199 | {
 | 
|---|
 | 200 |   cout << " ------ tstioarr(TArray<int_4> & ia, TArray<int_4> & ib, TArray<int_4> & ic) ---- " << endl;
 | 
|---|
 | 201 |   {
 | 
|---|
 | 202 |   cout << " >>>>>> Writing in  arrt.ppf <<<<<<< " << endl;
 | 
|---|
 | 203 |   POutPersist pos("arrt.ppf");
 | 
|---|
 | 204 |   // We write  the three arrays in the stream 
 | 
|---|
 | 205 |   pos << ia << ib << ic;
 | 
|---|
 | 206 |   cout << " >>>>>> Writing in  arrtn.ppf with names <<<<<<<" << endl;
 | 
|---|
 | 207 |   POutPersist posn("arrtn.ppf");
 | 
|---|
 | 208 |   string tag = "ArrIA";
 | 
|---|
 | 209 |   posn.PutObject(ia, tag);
 | 
|---|
 | 210 |   tag = "ArrIB";
 | 
|---|
 | 211 |   posn.PutObject(ib, tag);
 | 
|---|
 | 212 |   tag = "ArrIC";
 | 
|---|
 | 213 |   posn.PutObject(ic, tag);
 | 
|---|
 | 214 |   }
 | 
|---|
 | 215 | 
 | 
|---|
 | 216 |   {
 | 
|---|
 | 217 |   cout << " >>>>>>> Reading from  arrt.ppf  <<<<< " << endl;
 | 
|---|
 | 218 |   PInPersist pis("arrt.ppf");
 | 
|---|
 | 219 |   TArray<int_4> iaa, ibb, icc; 
 | 
|---|
 | 220 |   // We read the three arrays from the stream 
 | 
|---|
 | 221 |   pis >> iaa >> ibb >> icc;
 | 
|---|
| [812] | 222 |   cout << " ----- Array IAA = \n " << iaa << endl;
 | 
|---|
 | 223 |   cout << " ----- Array IBB = \n " << ibb << endl;
 | 
|---|
 | 224 |   cout << " ----- Array ICC = \n " << icc << endl;
 | 
|---|
| [807] | 225 |   icc = 12;
 | 
|---|
| [812] | 226 |   cout << " ----- Array ICC (=12) = \n " << icc << endl;
 | 
|---|
 | 227 |   cout << " ----- Array IAA (ICC=12) = \n " << iaa << endl;
 | 
|---|
| [807] | 228 |   }
 | 
|---|
 | 229 | 
 | 
|---|
 | 230 |   {
 | 
|---|
 | 231 |   cout << " >>>>>>> Reading from  arrtn.ppf  <<<<< " << endl;
 | 
|---|
 | 232 |   PInPersist pis("arrtn.ppf");
 | 
|---|
 | 233 |   TArray<int_4> iaa, ibb, icc; 
 | 
|---|
 | 234 |   // We read the three arrays from the stream 
 | 
|---|
 | 235 |   string tag = "ArrIC";
 | 
|---|
 | 236 |   pis.GetObject(icc, tag);
 | 
|---|
 | 237 |   tag = "ArrIB";
 | 
|---|
 | 238 |   pis.GetObject(ibb, tag);
 | 
|---|
 | 239 |   tag = "ArrIA";
 | 
|---|
 | 240 |   pis.GetObject(iaa, tag);
 | 
|---|
 | 241 | 
 | 
|---|
| [812] | 242 |   cout << " ----- Array IAAA = \n " << iaa << endl;
 | 
|---|
 | 243 |   cout << " ----- Array IBBB = \n " << ibb << endl;
 | 
|---|
 | 244 |   cout << " ----- Array ICCC = \n " << icc << endl;
 | 
|---|
| [807] | 245 |   icc = 68;
 | 
|---|
| [812] | 246 |   cout << " ----- Array ICCC (=12) = \n " << icc << endl;
 | 
|---|
 | 247 |   cout << " ----- Array IAAA (ICC=12) = \n " << iaa << endl;
 | 
|---|
| [807] | 248 |   }
 | 
|---|
 | 249 | 
 | 
|---|
 | 250 | 
 | 
|---|
 | 251 | }
 | 
|---|