/[escript]/trunk/escript/test/DataTestCase.cpp
ViewVC logotype

Diff of /trunk/escript/test/DataTestCase.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/escript/test/Data/DataTestCase.cpp revision 311 by jgs, Mon Dec 5 02:59:54 2005 UTC trunk/escript/test/DataTestCase.cpp revision 1388 by trankine, Fri Jan 11 07:45:58 2008 UTC
# Line 1  Line 1 
 // $Id$  
 /*  
  *****************************************************************************  
  *                                                                           *  
  *       COPYRIGHT  ACcESS  -  All Rights Reserved                           *  
  *                                                                           *  
  * This software is the property of ACcESS. No part of this code             *  
  * may be copied in any form or by any means without the expressed written   *  
  * consent of ACcESS.  Copying, use or modification of this software         *  
  * by any unauthorised person is illegal unless that person has a software   *  
  * license agreement with ACcESS.                                            *  
  *                                                                           *  
  *****************************************************************************  
 */  
 #include "esysUtils/EsysException.h"  
 #include "escript/Data/Data.h"  
 #include "escript/Data/FunctionSpace.h"  
1    
2  #include "DataTestCase.h"  /* $Id$ */
3    
4    /*******************************************************
5     *
6     *           Copyright 2003-2007 by ACceSS MNRF
7     *       Copyright 2007 by University of Queensland
8     *
9     *                http://esscc.uq.edu.au
10     *        Primary Business: Queensland, Australia
11     *  Licensed under the Open Software License version 3.0
12     *     http://www.opensource.org/licenses/osl-3.0.php
13     *
14     *******************************************************/
15    
16  #include <iostream>  #include <iostream>
17    #if (defined _WIN32) && (defined __INTEL_COMPILER)
18    #include <mathimf.h>
19    #else
20  #include <math.h>  #include <math.h>
21    #endif
22    
23    #include "DataTestCase.h"
24    
25    #include "escript/FunctionSpace.h"
26    #include "esysUtils/EsysException.h"
27    
28    #include "escript/Data.h"
29    
30    
31  using namespace std;  using namespace std;
32  using namespace CppUnitTest;  using namespace CppUnitTest;
# Line 41  void DataTestCase::testSlicing() { Line 48  void DataTestCase::testSlicing() {
48    cout << endl;    cout << endl;
49    
50    {    {
51    
52        cout << "\tTest get-slicing DataConstant" << endl;
53    
54      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
     //  
     // weak tests for slicing DataConstant  
     cout << "\tTest slicing DataConstant" << endl;  
55      viewShape.push_back(2);      viewShape.push_back(2);
56      viewShape.push_back(3);      viewShape.push_back(3);
57      Data temp(1.3,viewShape,FunctionSpace(),false);      Data data(1.3,viewShape,FunctionSpace(),false);
58    
59        //cout << data.toString() << endl;
60    
61      DataArrayView::RegionType region;      DataArrayView::RegionType region;
62      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
63      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
64      Data slice(temp.getSlice(region));  
65      assert(slice.getDataPointRank()==0);      Data slice1(data.getSlice(region));
66      assert(slice.getDataPoint(0,0)()==1.3);  
67      //      //cout << slice1.toString() << endl;
68      // try the same but this time to produce a matrix containing one value  
69        assert(slice1.getDataPointRank()==0);
70        assert(slice1.getDataPoint(0,0)()==1.3);
71    
72      region.clear();      region.clear();
73      region.push_back(DataArrayView::RegionType::value_type(0,1));      region.push_back(DataArrayView::RegionType::value_type(0,1));
74      region.push_back(DataArrayView::RegionType::value_type(0,1));      region.push_back(DataArrayView::RegionType::value_type(0,1));
75      slice=temp.getSlice(region);  
76      assert(slice.getDataPointRank()==2);      Data slice2(data.getSlice(region));
77      assert(slice.getDataPoint(0,0)(0,0)==1.3);  
78        //cout << slice2.toString() << endl;
79    
80        assert(slice2.getDataPointRank()==2);
81        assert(slice2.getDataPoint(0,0)(0,0)==1.3);
82    
83        region.clear();
84        region.push_back(DataArrayView::RegionType::value_type(0,1));
85        region.push_back(DataArrayView::RegionType::value_type(0,2));
86    
87        Data slice3(data.getSlice(region));
88    
89        //cout << slice3.toString() << endl;
90    
91        assert(slice3.getDataPointRank()==2);
92        assert(slice3.getDataPoint(0,0)(0,0)==1.3);
93        assert(slice3.getDataPoint(0,0)(0,1)==1.3);
94    
95    }    }
96    
97    {    {
98    
99        cout << "\tTest set-slicing DataConstant" << endl;
100    
101      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
102        Data source(10.0,viewShape,FunctionSpace(),false);
103    
104        //cout << source.toString() << endl;
105    
106        viewShape.push_back(2);
107        viewShape.push_back(3);
108        Data target(1.3,viewShape,FunctionSpace(),false);
109    
110        //cout << target.toString() << endl;
111    
112        DataArrayView::RegionType region;
113        region.push_back(DataArrayView::RegionType::value_type(0,0));
114        region.push_back(DataArrayView::RegionType::value_type(0,0));
115    
116        target.setSlice(source,region);
117    
118        //cout << target.toString() << endl;
119    
120        assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
121    
122      }
123    
124      {
125    
126        cout << "\tTest get-slicing DataTagged" << endl;
127    
128      //      //
129      // weak tests for slicing DataExpanded      // create a DataTagged with a default value only
130      cout << "\tTest slicing DataExpanded" << endl;  
131        DataArrayView::ShapeType viewShape;
132      viewShape.push_back(2);      viewShape.push_back(2);
133      viewShape.push_back(3);      viewShape.push_back(3);
134      Data temp(1.3,viewShape,FunctionSpace(),true);      Data data(1.3,viewShape,FunctionSpace(),false);
135      temp.getDataPoint(0,0)(0,0)=0.0;      data.tag();
136      temp.getDataPoint(0,0)(1,1)=1.0;      data.getDataPoint(0,0)(0,0)=1.0;
137        data.getDataPoint(0,0)(1,1)=2.0;
138    
139        //cout << data.toString() << endl;
140    
141        //
142        // create a scalar slice
143    
144      DataArrayView::RegionType region;      DataArrayView::RegionType region;
145      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
146      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
147      Data slice(temp.getSlice(region));  
148      assert(slice.getDataPointRank()==0);      Data slice1(data.getSlice(region));
149      assert(slice.getDataPoint(0,0)()==0.0);  
150        //cout << slice1.toString() << endl;
151    
152        assert(slice1.isTagged());
153        assert(slice1.getDataPointRank()==0);
154        assert(slice1.getDataPoint(0,0)()==1.0);
155    
156      //      //
157      // try the same but this time to produce a matrix containing one value      // create a rank 2 slice with one value
158    
159      region.clear();      region.clear();
160      region.push_back(DataArrayView::RegionType::value_type(0,1));      region.push_back(DataArrayView::RegionType::value_type(0,1));
161      region.push_back(DataArrayView::RegionType::value_type(0,1));      region.push_back(DataArrayView::RegionType::value_type(0,1));
162      slice=temp.getSlice(region);  
163      assert(slice.getDataPointRank()==2);      Data slice2(data.getSlice(region));
164      assert(slice.getDataPoint(0,0)(0,0)==0.0);  
165        //cout << slice2.toString() << endl;
166    
167        assert(slice2.isTagged());
168        assert(slice2.getDataPointRank()==2);
169        assert(slice2.getDataPoint(0,0)(0,0)==1.0);
170    
171        //
172        // create a rank 2 slice with four values
173    
174      region.clear();      region.clear();
175      region.push_back(DataArrayView::RegionType::value_type(0,2));      region.push_back(DataArrayView::RegionType::value_type(0,2));
176      region.push_back(DataArrayView::RegionType::value_type(0,2));      region.push_back(DataArrayView::RegionType::value_type(0,2));
177      slice=temp.getSlice(region);  
178      assert(slice.getDataPoint(0,0)(0,0)==0.0);      Data slice3(data.getSlice(region));
179      assert(slice.getDataPoint(0,0)(1,1)==1.0);  
180        //cout << slice3.toString() << endl;
181    
182        assert(slice3.isTagged());
183        assert(slice3.getDataPointRank()==2);
184        assert(slice3.getDataPoint(0,0)(0,0)==1.0);
185        assert(slice3.getDataPoint(0,0)(0,1)==1.3);
186        assert(slice3.getDataPoint(0,0)(1,0)==1.3);
187        assert(slice3.getDataPoint(0,0)(1,1)==2.0);
188    
189        //
190        // add a value for tag "1"
191    
192        DataArrayView::ValueType viewData(6);
193        for (int i=0;i<viewData.size();i++) {
194          viewData[i]=i;
195        }
196        DataArrayView dataView(viewData,viewShape);
197    
198        data.setTaggedValueFromCPP(1, dataView);
199    
200        //
201        // create a full slice
202    
203        region.clear();
204        region.push_back(DataArrayView::RegionType::value_type(0,2));
205        region.push_back(DataArrayView::RegionType::value_type(0,3));
206    
207        Data slice4(data.getSlice(region));
208    
209        //cout << slice4.toString() << endl;
210    
211        assert(slice4.isTagged());
212        assert(slice4.getDataPointRank()==2);
213        assert(slice4.getDataPoint(0,0)(0,0)==0);
214        assert(slice4.getDataPoint(0,0)(0,1)==2);
215        assert(slice4.getDataPoint(0,0)(0,2)==4);
216        assert(slice4.getDataPoint(0,0)(1,0)==1);
217        assert(slice4.getDataPoint(0,0)(1,1)==3);
218        assert(slice4.getDataPoint(0,0)(1,2)==5);
219    
220    }    }
221    
222    {    {
223    
224        cout << "\tTest set-slicing DataTagged" << endl;
225    
226        //
227        // create a source DataTagged with a scalar default value only
228    
229      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
230        Data source(10.0,viewShape,FunctionSpace(),false);
231        source.tag();
232    
233        //cout << "source:\n" << source.toString() << endl;
234    
235      //      //
236      // weak tests for slicing DataTagged      // create a target DataTagged with a rank 2 default value only
237      cout << "\tTest slicing DataTagged" << endl;  
238      viewShape.push_back(2);      viewShape.push_back(2);
239      viewShape.push_back(3);      viewShape.push_back(3);
240      Data temp(1.3,viewShape,FunctionSpace(),false);      Data target(1.3,viewShape,FunctionSpace(),false);
241        target.tag();
242    
243        //cout << "target:\n" << target.toString() << endl;
244    
245      //      //
246      // convert the data to tagged      // set a slice in target from source
247      temp.tag();  
248        DataArrayView::RegionType region;
249        region.push_back(DataArrayView::RegionType::value_type(1,1));
250        region.push_back(DataArrayView::RegionType::value_type(1,1));
251    
252        target.setSlice(source,region);
253    
254        //cout << "target:\n" << target.toString() << endl;
255    
256        assert(target.isTagged());
257        assert(target.getDataPointRank()==2);
258        assert(target.getDataPoint(0,0)(0,0)==1.3);
259        assert(target.getDataPoint(0,0)(0,1)==1.3);
260        assert(target.getDataPoint(0,0)(0,2)==1.3);
261        assert(target.getDataPoint(0,0)(1,0)==1.3);
262        assert(target.getDataPoint(0,0)(1,1)==source.getDataPoint(0,0)());
263        assert(target.getDataPoint(0,0)(1,2)==1.3);
264    
265        //
266        // add a value for tag "1" to target
267    
268        DataArrayView::ValueType viewData(6);
269        for (int i=0;i<viewData.size();i++) {
270          viewData[i]=i;
271        }
272        DataArrayView dataView(viewData,viewShape);
273    
274        target.setTaggedValueFromCPP(1, dataView);
275    
276        //cout << "target:\n" << target.toString() << endl;
277    
278        //
279        // set a slice in target from source
280    
281        region.clear();
282        region.push_back(DataArrayView::RegionType::value_type(0,0));
283        region.push_back(DataArrayView::RegionType::value_type(1,1));
284    
285        target.setSlice(source,region);
286    
287        //cout << "target:\n" << target.toString() << endl;
288    
289        assert(target.isTagged());
290        assert(target.getDataPointRank()==2);
291        assert(target.getDataPoint(0,0)(0,0)==0);
292        assert(target.getDataPoint(0,0)(0,1)==source.getDataPoint(0,0)());
293        assert(target.getDataPoint(0,0)(0,2)==4);
294        assert(target.getDataPoint(0,0)(1,0)==1);
295        assert(target.getDataPoint(0,0)(1,1)==3);
296        assert(target.getDataPoint(0,0)(1,2)==5);
297    
298        //
299        // add a value for tag "2" to source
300    
301        DataArrayView::ShapeType viewShape2;
302        DataArrayView::ValueType viewData2(1);
303        viewData2[0]=6;
304        DataArrayView dataView2(viewData2,viewShape2);
305    
306        source.setTaggedValueFromCPP(2, dataView2);
307    
308        //cout << "source:\n" << source.toString() << endl;
309    
310        //
311        // set a slice in target from source
312    
313        region.clear();
314        region.push_back(DataArrayView::RegionType::value_type(0,0));
315        region.push_back(DataArrayView::RegionType::value_type(1,1));
316    
317        target.setSlice(source,region);
318    
319        //cout << "target:\n" << target.toString() << endl;
320    
321        assert(target.isTagged());
322        assert(target.getDataPointRank()==2);
323    
324        // use a non-existant tag so we get a pointer to the default value
325        // ie: the first element in the data array
326        DataAbstract::ValueType::value_type* targetData=target.getSampleDataByTag(9);
327        for (int i=0; i<target.getLength(); i++) {
328          assert(targetData[i]>=0);
329        }
330        assert(targetData[0]==1.3);
331        assert(targetData[1]==1.3);
332        assert(targetData[2]==10);
333        assert(targetData[3]==10);
334        assert(targetData[4]==1.3);
335        assert(targetData[5]==1.3);
336        assert(targetData[6]==0);
337        assert(targetData[7]==1);
338        assert(targetData[8]==10);
339        assert(targetData[9]==3);
340        assert(targetData[10]==4);
341        assert(targetData[11]==5);
342        assert(targetData[12]==1.3);
343        assert(targetData[13]==1.3);
344        assert(targetData[14]==6);
345        assert(targetData[15]==10);
346        assert(targetData[16]==1.3);
347        assert(targetData[17]==1.3);
348    
349      }
350    
351      {
352    
353        cout << "\tTest get-slicing DataExpanded" << endl;
354    
355        DataArrayView::ShapeType viewShape;
356        viewShape.push_back(2);
357        viewShape.push_back(3);
358        Data temp(1.3,viewShape,FunctionSpace(),true);
359    
360      temp.getDataPoint(0,0)(0,0)=0.0;      temp.getDataPoint(0,0)(0,0)=0.0;
361      temp.getDataPoint(0,0)(1,1)=1.0;      temp.getDataPoint(0,0)(1,1)=1.0;
362    
363      DataArrayView::RegionType region;      DataArrayView::RegionType region;
364      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
365      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
366    
367      Data slice(temp.getSlice(region));      Data slice(temp.getSlice(region));
368    
369      assert(slice.getDataPointRank()==0);      assert(slice.getDataPointRank()==0);
370      assert(slice.getDataPoint(0,0)()==0.0);      assert(slice.getDataPoint(0,0)()==0.0);
371      //  
     // try the same but this time to produce a matrix containing one value  
372      region.clear();      region.clear();
373      region.push_back(DataArrayView::RegionType::value_type(0,1));      region.push_back(DataArrayView::RegionType::value_type(0,1));
374      region.push_back(DataArrayView::RegionType::value_type(0,1));      region.push_back(DataArrayView::RegionType::value_type(0,1));
375    
376      slice=temp.getSlice(region);      slice=temp.getSlice(region);
377    
378      assert(slice.getDataPointRank()==2);      assert(slice.getDataPointRank()==2);
379      assert(slice.getDataPoint(0,0)(0,0)==0.0);      assert(slice.getDataPoint(0,0)(0,0)==0.0);
380    
381      region.clear();      region.clear();
382      region.push_back(DataArrayView::RegionType::value_type(0,2));      region.push_back(DataArrayView::RegionType::value_type(0,2));
383      region.push_back(DataArrayView::RegionType::value_type(0,2));      region.push_back(DataArrayView::RegionType::value_type(0,2));
384    
385      slice=temp.getSlice(region);      slice=temp.getSlice(region);
386    
387      assert(slice.getDataPoint(0,0)(0,0)==0.0);      assert(slice.getDataPoint(0,0)(0,0)==0.0);
388      assert(slice.getDataPoint(0,0)(1,1)==1.0);      assert(slice.getDataPoint(0,0)(1,1)==1.0);
   }  
389    
   {  
     DataArrayView::ShapeType viewShape;  
     Data source(10.0,viewShape,FunctionSpace(),false);  
     //  
     // weak tests for setting a slice of DataConstant  
     cout << "\tTest slicing DataConstant" << endl;  
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     Data target(1.3,viewShape,FunctionSpace(),false);  
     DataArrayView::RegionType region;  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
     target.setSlice(source,region);  
     assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());  
390    }    }
391    
392    {    {
393    
394        cout << "\tTest set-slicing DataExpanded" << endl;
395    
396      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
397      Data source(10.0,viewShape,FunctionSpace(),true);      Data source(10.0,viewShape,FunctionSpace(),true);
398      //  
     // weak tests for setting a slice of DataExpanded  
399      viewShape.push_back(2);      viewShape.push_back(2);
400      viewShape.push_back(3);      viewShape.push_back(3);
401      Data target(1.3,viewShape,FunctionSpace(),true);      Data target(1.3,viewShape,FunctionSpace(),true);
     DataArrayView::RegionType region;  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
     target.setSlice(source,region);  
     assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());  
   }  
402    
   {  
     DataArrayView::ShapeType viewShape;  
     Data source(10.0,viewShape,FunctionSpace(),false);  
     source.tag();  
     //  
     // weak tests for slicing DataTagged  
     cout << "\tTest slicing DataTagged" << endl;  
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     Data target(1.3,viewShape,FunctionSpace(),false);  
     //  
     // convert the data to tagged  
     target.tag();  
403      DataArrayView::RegionType region;      DataArrayView::RegionType region;
404      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
405      region.push_back(DataArrayView::RegionType::value_type(0,0));      region.push_back(DataArrayView::RegionType::value_type(0,0));
406    
407      target.setSlice(source,region);      target.setSlice(source,region);
408    
409      assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());      assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
410    
411    }    }
412    
413  }  }
414    
415  void DataTestCase::testMore() {  void DataTestCase::testAll() {
416    
417    cout << endl;    cout << endl;
418    
# Line 211  void DataTestCase::testMore() { Line 439  void DataTestCase::testMore() {
439    result=exData*cData;    result=exData*cData;
440    assert(result.isExpanded());    assert(result.isExpanded());
441    
   assert(result.Lsup()==4);  
   assert(result.sup()==4);  
   assert(result.inf()==0);  
   
   result=exData+cData;  
   result=exData-cData;  
   result=exData/cData;  
   
   cout << "\tExercise wherePositive method" << endl;  
   assert(!exData.wherePositive().isEmpty());  
   
   cout << "\tExercise copyWithMask method" << endl;  
   exData.copyWithMask(result, exData.wherePositive());  
   assert(!exData.wherePositive().isEmpty());  
   
442  }  }
443    
444  void DataTestCase::testAll() {  void DataTestCase::testMore() {
445    
446    cout << endl;    cout << endl;
447    
# Line 243  void DataTestCase::testAll() { Line 456  void DataTestCase::testAll() {
456    DataArrayView myView(viewData,viewShape);    DataArrayView myView(viewData,viewShape);
457    
458    bool expanded=true;    bool expanded=true;
   
459    Data exData(myView,FunctionSpace(),expanded);    Data exData(myView,FunctionSpace(),expanded);
460    Data cData(myView);    Data cData(myView);
461    Data result;    Data result;
# Line 256  void DataTestCase::testAll() { Line 468  void DataTestCase::testAll() {
468    result=exData*cData;    result=exData*cData;
469    assert(result.isExpanded());    assert(result.isExpanded());
470    
471      assert(result.Lsup()==4);
472      assert(result.sup()==4);
473      assert(result.inf()==0);
474    
475      result=exData+cData;
476      result=exData-cData;
477      result=exData/cData;
478    
479      cout << "\tExercise wherePositive method" << endl;
480      assert(!exData.wherePositive().isEmpty());
481    
482      cout << "\tExercise copyWithMask method" << endl;
483      exData.copyWithMask(result, exData.wherePositive());
484      assert(!exData.wherePositive().isEmpty());
485    
486  }  }
487    
488  void DataTestCase::testDataConstant() {  void DataTestCase::testDataConstant() {
# Line 297  void DataTestCase::testDataConstant() { Line 524  void DataTestCase::testDataConstant() {
524    
525  }  }
526    
527    void DataTestCase::testDataTagged() {
528    
529      cout << endl;
530    
531      {
532    
533        cout << "\tCreate a DataTagged object with a default value only." << endl;
534    
535        DataTagged::TagListType keys;
536    
537        DataTagged::ValueListType values;
538    
539        DataArrayView::ShapeType viewShape;
540        viewShape.push_back(3);
541    
542        DataArrayView::ValueType viewData(3);
543        for (int i=0;i<viewShape[0];i++) {
544          viewData[i]=i;
545        }
546        DataArrayView defaultValue(viewData,viewShape);
547    
548        bool expanded=false;
549    
550        Data myData(keys,values,defaultValue,FunctionSpace(),expanded);
551    
552        // cout << myData.toString() << endl;
553    
554        assert(!myData.isEmpty());
555        assert(myData.isTagged());
556        assert(myData.getTagNumber(0)==1);
557        assert(myData.getDataPointRank()==1);
558        assert(myData.getLength()==3);
559    
560        DataArrayView myDataView = myData.getPointDataView();
561        assert(!myDataView.isEmpty());
562        assert(myDataView.getOffset()==0);
563        assert(myDataView.getRank()==1);
564        assert(myDataView.noValues()==3);
565        assert(myDataView.getShape().size()==1);
566        assert(myDataView(0)==0.0);
567        assert(myDataView(1)==1.0);
568        assert(myDataView(2)==2.0);
569    
570        myDataView = myData.getDataPoint(0,0);
571        assert(!myDataView.isEmpty());
572        assert(myDataView.getOffset()==0);
573        assert(myDataView.getRank()==1);
574        assert(myDataView.noValues()==3);
575        assert(myDataView.getShape().size()==1);
576        assert(myDataView(0)==0.0);
577        assert(myDataView(1)==1.0);
578        assert(myDataView(2)==2.0);
579    
580        double* sampleData=myData.getSampleData(0);
581        for (int i=0; i<myDataView.noValues(); i++) {
582          assert(sampleData[i]==i);
583        }
584        // use a non-existent tag so we get a pointer to
585        // the first element of the data array
586        sampleData=myData.getSampleDataByTag(9);
587        for (int i=0; i<myData.getLength(); i++) {
588          assert(sampleData[i]==i);
589        }
590    
591        cout << "\tTest setting of a tag and associated value." << endl;
592    
593        // value for tag "1"
594        DataArrayView::ValueType eTwoData(viewData);
595        DataArrayView eTwoView(eTwoData, viewShape);
596        for (int i=0;i<eTwoView.getShape()[0];i++) {
597          eTwoView(i)=i+2.0;
598        }
599    
600        myData.setTaggedValueFromCPP(1,eTwoView);
601    
602        assert(myData.getLength()==6);
603    
604        myDataView = myData.getDataPoint(0,0);
605        assert(myDataView==eTwoView);
606        assert(!myDataView.isEmpty());
607        assert(myDataView.getOffset()==3);
608        assert(myDataView.getRank()==1);
609        assert(myDataView.noValues()==3);
610        assert(myDataView.getShape().size()==1);
611        assert(myDataView(0)==2);
612        assert(myDataView(1)==3);
613        assert(myDataView(2)==4);
614    
615        sampleData=myData.getSampleDataByTag(1);
616        for (int i=0; i<myDataView.noValues(); i++) {
617          assert(sampleData[i]==i+2);
618        }
619    
620      }
621    
622      {
623    
624        cout << "\tCreate a DataTagged object via tag() method." << endl;
625    
626        DataArrayView::ShapeType viewShape;
627        viewShape.push_back(2);
628        viewShape.push_back(3);
629        Data myData(1.3,viewShape,FunctionSpace(),false);
630        myData.tag();
631    
632        //cout << myData.toString() << endl;
633    
634        assert(!myData.isEmpty());
635        assert(myData.isTagged());
636        assert(myData.getTagNumber(0)==1);
637        assert(myData.getDataPointRank()==2);
638        assert(myData.getLength()==6);
639    
640        // check default value
641        DataArrayView myDataView = myData.getPointDataView();
642        assert(!myDataView.isEmpty());
643        assert(myDataView.getOffset()==0);
644        assert(myDataView.getRank()==2);
645        assert(myDataView.noValues()==6);
646        assert(myDataView.getShape().size()==2);
647        assert(myDataView(0,0)==1.3);
648        assert(myDataView(0,1)==1.3);
649        assert(myDataView(0,2)==1.3);
650        assert(myDataView(1,0)==1.3);
651        assert(myDataView(1,1)==1.3);
652        assert(myDataView(1,2)==1.3);
653    
654        // check value for data-point (0,0).
655        myDataView = myData.getDataPoint(0,0);
656        assert(!myDataView.isEmpty());
657        assert(myDataView.getOffset()==0);
658        assert(myDataView.getRank()==2);
659        assert(myDataView.noValues()==6);
660        assert(myDataView.getShape().size()==2);
661        assert(myDataView(0,0)==1.3);
662        assert(myDataView(0,1)==1.3);
663        assert(myDataView(0,2)==1.3);
664        assert(myDataView(1,0)==1.3);
665        assert(myDataView(1,1)==1.3);
666        assert(myDataView(1,2)==1.3);
667    
668      }
669    
670    }
671    
672  void DataTestCase::testDataTaggedExceptions() {  void DataTestCase::testDataTaggedExceptions() {
673    
674    cout << endl;    cout << endl;
675    
676    cout << "\tTest DataTagged operations exceptions." << endl;    cout << "\tTest DataTagged exceptions." << endl;
677    
678    Data myData;    Data myData;
679    DataArrayView myView;    DataArrayView myView;
# Line 315  void DataTestCase::testDataTaggedExcepti Line 687  void DataTestCase::testDataTaggedExcepti
687        assert(true);        assert(true);
688    }    }
689    
   /*  
690    try {    try {
691        myData.setTaggedValue(0,myView);;        myData.setTaggedValueFromCPP(0,myView);;
692        assert(false);        assert(false);
693    }    }
694    catch (EsysException& e) {    catch (EsysException& e) {
695        //cout << e.what() << endl;        //cout << e.what() << endl;
696        assert(true);        assert(true);
697    }    }
   */  
   
 }  
   
 void DataTestCase::testDataTagged() {  
   
   cout << endl;  
   
   cout << "\tCreate a DataTagged object from a DataArrayView" << endl;  
   
   DataTagged::TagListType keys;  
   DataTagged::ValueListType values;  
   DataArrayView::ShapeType viewShape;  
   viewShape.push_back(3);  
   DataArrayView::ValueType viewData(3);  
   for (int i=0;i<viewShape[0];++i) {  
     viewData[i]=i;  
   }  
   DataArrayView myView(viewData,viewShape);  
   
   // create tagged data with no tag values just a default  
   bool expanded=false;  
   
   Data myData(keys,values,myView,FunctionSpace(),expanded);  
   assert(myData.isTagged());  
   
   cout << "\tTest some basic operations" << endl;  
   
   Data myDataCopy(myData);  
   myDataCopy.expand();  
   assert(myDataCopy.isExpanded());  
698    
699  }  }
700    
# Line 397  void DataTestCase::testOperations() { Line 737  void DataTestCase::testOperations() {
737      }      }
738    }    }
739    
740    Data base(dataView);    Data baseEx(dataView,FunctionSpace(),true);
741      Data baseCon(dataView,FunctionSpace(),false);
742      Data baseTag(dataView,FunctionSpace(),false);
743      baseTag.tag();
744    
745      assert(baseEx.isExpanded());
746      assert(baseCon.isConstant());
747      assert(baseTag.isTagged());
748    
749      Data resultEx;
750      Data resultCon;
751      Data resultTag;
752    
753    // test unary operations    // test unary operations
754    
755      double tmp;
756    cout << "\tTest Data::pow." << endl;    cout << "\tTest Data::pow." << endl;
757    Data power(3.0,shape,FunctionSpace(),true);    Data power(3.0,shape,FunctionSpace(),true);
758    Data result(base.powD(power));    resultEx.copy(baseEx.powD(power));
759      resultCon.copy(baseCon.powD(power));
760      resultTag.copy(baseTag.powD(power));
761    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
762      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
763        assert(result.getPointDataView()(i,j) == pow(dataView.index(i,j),3.0));        tmp=pow((double)dataView.index(i,j),(double)3.0);
764          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
765          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
766          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
767      }      }
768    }    }
769    
770    cout << "\tTest Data::sin." << endl;    cout << "\tTest Data::sin." << endl;
771    result.copy(base.sin());    resultEx.copy(baseEx.sin());
772    assert(true);    resultCon.copy(baseCon.sin());
773      resultTag.copy(baseTag.sin());
774      for (int i=0;i<shape[0];i++) {
775        for (int j=0;j<shape[1];j++) {
776          tmp=sin((double)dataView.index(i,j));
777          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
778          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
779          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
780        }
781      }
782    
783    cout << "\tTest Data::cos." << endl;    cout << "\tTest Data::cos." << endl;
784    result.copy(base.cos());    resultEx.copy(baseEx.cos());
785    assert(true);    resultCon.copy(baseCon.cos());
786      resultTag.copy(baseTag.cos());
787      for (int i=0;i<shape[0];i++) {
788        for (int j=0;j<shape[1];j++) {
789          tmp=cos((double)dataView.index(i,j));
790          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
791          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
792          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
793        }
794      }
795    
796    cout << "\tTest Data::tan." << endl;    cout << "\tTest Data::tan." << endl;
797    result.copy(base.tan());    resultEx.copy(baseEx.tan());
798    assert(true);    resultCon.copy(baseCon.tan());
799      resultTag.copy(baseTag.tan());
800      for (int i=0;i<shape[0];i++) {
801        for (int j=0;j<shape[1];j++) {
802          tmp=tan((double)dataView.index(i,j));
803          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
804          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
805          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
806        }
807      }
808    
809    cout << "\tTest Data::asin." << endl;    cout << "\tTest Data::asin." << endl;
810    result.copy(base.asin());    resultEx.copy(baseEx.asin());
811      resultCon.copy(baseCon.asin());
812      resultTag.copy(baseTag.asin());
813    assert(true);    assert(true);
814    
815    cout << "\tTest Data::acos." << endl;    cout << "\tTest Data::acos." << endl;
816    result.copy(base.acos());    resultEx.copy(baseEx.acos());
817      resultCon.copy(baseCon.acos());
818      resultTag.copy(baseTag.acos());
819    assert(true);    assert(true);
820    
821    cout << "\tTest Data::atan." << endl;    cout << "\tTest Data::atan." << endl;
822    result.copy(base.atan());    resultEx.copy(baseEx.atan());
823    assert(true);    resultCon.copy(baseCon.atan());
824      resultTag.copy(baseTag.atan());
825      for (int i=0;i<shape[0];i++) {
826        for (int j=0;j<shape[1];j++) {
827          tmp=atan((double)dataView.index(i,j));
828          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
829          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
830          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
831        }
832      }
833    
834    cout << "\tTest Data::sinh." << endl;    cout << "\tTest Data::sinh." << endl;
835    result.copy(base.sinh());    resultEx.copy(baseEx.sinh());
836    assert(true);    resultCon.copy(baseCon.sinh());
837      resultTag.copy(baseTag.sinh());
838      for (int i=0;i<shape[0];i++) {
839        for (int j=0;j<shape[1];j++) {
840          tmp=sinh((double)dataView.index(i,j));
841          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
842          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
843          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
844        }
845      }
846    
847    cout << "\tTest Data::cosh." << endl;    cout << "\tTest Data::cosh." << endl;
848    result.copy(base.cosh());    resultEx.copy(baseEx.cosh());
849    assert(true);    resultCon.copy(baseCon.cosh());
850      resultTag.copy(baseTag.cosh());
851      for (int i=0;i<shape[0];i++) {
852        for (int j=0;j<shape[1];j++) {
853          tmp=cosh((double)dataView.index(i,j));
854          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
855          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
856          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
857        }
858      }
859    
860    cout << "\tTest Data::tanh." << endl;    cout << "\tTest Data::tanh." << endl;
861    result.copy(base.tanh());    resultEx.copy(baseEx.tanh());
862    assert(true);    resultCon.copy(baseCon.tanh());
863      resultTag.copy(baseTag.tanh());
864      for (int i=0;i<shape[0];i++) {
865        for (int j=0;j<shape[1];j++) {
866          tmp=tanh((double)dataView.index(i,j));
867          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
868          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
869          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
870        }
871      }
872    
873    cout << "\tTest Data::asinh." << endl;    cout << "\tTest Data::asinh." << endl;
874    result.copy(base.asinh());    resultEx.copy(baseEx.asinh());
875      resultCon.copy(baseCon.asinh());
876      resultTag.copy(baseTag.asinh());
877    assert(true);    assert(true);
878    
879    cout << "\tTest Data::acosh." << endl;    cout << "\tTest Data::acosh." << endl;
880    result.copy(base.acosh());    resultEx.copy(baseEx.acosh());
881      resultCon.copy(baseCon.acosh());
882      resultTag.copy(baseTag.acosh());
883    assert(true);    assert(true);
884    
885    cout << "\tTest Data::atanh." << endl;    cout << "\tTest Data::atanh." << endl;
886    result.copy(base.atanh());    resultEx.copy(baseEx.atanh());
887      resultCon.copy(baseCon.atanh());
888      resultTag.copy(baseTag.atanh());
889    assert(true);    assert(true);
890    
891    cout << "\tTest Data::log." << endl;    cout << "\tTest Data::log." << endl;
892    result.copy(base.log());    resultEx.copy(baseEx.log());
893      resultCon.copy(baseCon.log());
894      resultTag.copy(baseTag.log());
895    assert(true);    assert(true);
896    
   //cout << "\tTest Data::ln." << endl;  
   //result.copy(base.ln());  
   //assert(true);  
   
897    cout << "\tTest Data::abs." << endl;    cout << "\tTest Data::abs." << endl;
898    result.copy(base.abs());    resultEx.copy(baseEx.abs());
899    assert(true);    resultCon.copy(baseCon.abs());
900      resultTag.copy(baseTag.abs());
901      for (int i=0;i<shape[0];i++) {
902        for (int j=0;j<shape[1];j++) {
903          tmp=abs((double)dataView.index(i,j));
904          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
905          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
906          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
907        }
908      }
909    
910    cout << "\tTest Data::sign." << endl;    cout << "\tTest Data::sign." << endl;
911    result.copy(base.sign());    resultEx.copy(baseEx.sign());
912      resultCon.copy(baseCon.sign());
913      resultTag.copy(baseTag.sign());
914    assert(true);    assert(true);
915    
916    cout << "\tTest Data::exp." << endl;    cout << "\tTest Data::exp." << endl;
917    result.copy(base.exp());    resultEx.copy(baseEx.exp());
918    assert(true);    resultCon.copy(baseCon.exp());
919      resultTag.copy(baseTag.exp());
920      for (int i=0;i<shape[0];i++) {
921        for (int j=0;j<shape[1];j++) {
922          tmp=exp((double)dataView.index(i,j));
923          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
924          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
925          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
926        }
927      }
928    
929    cout << "\tTest Data::sqrt." << endl;    cout << "\tTest Data::sqrt." << endl;
930    result.copy(base.sqrt());    resultEx.copy(baseEx.sqrt());
931    assert(true);    resultCon.copy(baseCon.sqrt());
932      resultTag.copy(baseTag.sqrt());
933      for (int i=0;i<shape[0];i++) {
934        for (int j=0;j<shape[1];j++) {
935          tmp=sqrt((double)dataView.index(i,j));
936          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
937          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
938          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
939        }
940      }
941    
942    cout << "\tTest Data::neg." << endl;    cout << "\tTest Data::neg." << endl;
943    result.copy(base.neg());    resultEx.copy(baseEx.neg());
944      resultCon.copy(baseCon.neg());
945      resultTag.copy(baseTag.neg());
946    assert(true);    assert(true);
947    
948    cout << "\tTest Data::pos." << endl;    cout << "\tTest Data::pos." << endl;
949    result.copy(base.pos());    resultEx.copy(baseEx.pos());
950      resultCon.copy(baseCon.pos());
951      resultTag.copy(baseTag.pos());
952    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
953      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
954        assert(result.getPointDataView()(i,j) == dataView.index(i,j));        assert(std::abs(resultEx.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
955          assert(std::abs(resultCon.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
956          assert(std::abs(resultTag.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
957      }      }
958    }    }
959    
960    // test reduction operations    // test reduction operations
961    
962    cout << "\tTest Data::Lsup." << endl;    cout << "\tTest Data::Lsup." << endl;
963    assert(base.Lsup() == 5);    assert(std::abs(baseEx.Lsup() - 5) <= REL_TOL*5);
964      assert(std::abs(baseCon.Lsup() - 5) <= REL_TOL*5);
965      assert(std::abs(baseTag.Lsup() - 5) <= REL_TOL*5);
966    
967    cout << "\tTest Data::sup." << endl;    cout << "\tTest Data::sup." << endl;
968    assert(base.sup() == 5);    assert(std::abs(baseEx.sup() - 5) <= REL_TOL*5);
969      assert(std::abs(baseCon.sup() - 5) <= REL_TOL*5);
970      assert(std::abs(baseTag.sup() - 5) <= REL_TOL*5);
971    
972    cout << "\tTest Data::inf." << endl;    cout << "\tTest Data::inf." << endl;
973    assert(base.inf() == 0);    assert(std::abs(baseEx.inf() - 0) <= REL_TOL*0);
974      assert(std::abs(baseCon.inf() - 0) <= REL_TOL*0);
975      assert(std::abs(baseTag.inf() - 0) <= REL_TOL*0);
976    
977    // test data-point reduction operations    // test data-point reduction operations
978    
979    cout << "\tTest Data::minval." << endl;    cout << "\tTest Data::minval." << endl;
980    result.copy(base.minval());    resultEx.copy(baseEx.minval());
981    assert(result.getPointDataView()() == 0);    resultCon.copy(baseCon.minval());
982      resultTag.copy(baseTag.minval());
983      assert(std::abs(resultEx.getPointDataView()() - 0) <= REL_TOL*0);
984      assert(std::abs(resultCon.getPointDataView()() - 0) <= REL_TOL*0);
985      assert(std::abs(resultTag.getPointDataView()() - 0) <= REL_TOL*0);
986    
987    cout << "\tTest Data::maxval." << endl;    cout << "\tTest Data::maxval." << endl;
988    result.copy(base.maxval());    resultEx.copy(baseEx.maxval());
989    assert(result.getPointDataView()() == 5);    resultCon.copy(baseCon.maxval());
990      resultTag.copy(baseTag.maxval());
991    //cout << "\tTest Data::length." << endl;    assert(std::abs(resultEx.getPointDataView()() - 5) <= REL_TOL*5);
992    //result.copy(base.length());    assert(std::abs(resultCon.getPointDataView()() - 5) <= REL_TOL*5);
993    //assert(pow(result.getPointDataView()(),2.0) == 55);    assert(std::abs(resultTag.getPointDataView()() - 5) <= REL_TOL*5);
   
   cout << "\tTest Data::trace." << endl;  
   result.copy(base.trace());  
   assert(result.getPointDataView()() == 15);  
   
   //result.copy(base.transpose(0));  
   //assert(true);  
994    
995  }  }
996    
 void DataTestCase::testRefValue() {  
   
   //  
   // Note - this test can't be run as boost::python::numeric::array  
   // objects can only be created and used from within a python thread!  
   //  
   
   cout << endl;  
   
   cout << "\tTest Data object RefValue methods." << endl;  
   
   // Create three Data object - DataExpanded, DataConstant and DataEmpty  
   DataArrayView::ShapeType viewShape;  
   viewShape.push_back(3);  
   DataArrayView::ValueType viewData(3);  
   for (int i=0;i<viewShape[0];++i) {  
     viewData[i]=i;  
   }  
   DataArrayView myView(viewData,viewShape);  
   
   bool expanded=true;  
   
   Data expandedData(myView,FunctionSpace(),expanded);  
   Data constantData(myView);  
   Data emptyData;  
   
   assert(expandedData.isExpanded());  
   assert(constantData.isConstant());  
   assert(emptyData.isEmpty());  
   
   // Check assertions are thrown for RefValue methods on DataEmpty  
   
   int ref = 0;  
   boost::python::numeric::array num_array(1.0);  
   
   try {  
       emptyData.getRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   try {  
       emptyData.setRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   
   // Check assertions are thrown for RefValue methods on DataConstant  
   try {  
       constantData.getRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   try {  
       constantData.setRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   
   // Check calls to RefValue methods on DataExpanded  
   expandedData.getRefValue(ref,num_array);  
   expandedData.setRefValue(ref,num_array);  
   
 }  
997    
998  void DataTestCase::testMemAlloc() {  void DataTestCase::testMemAlloc() {
999    

Legend:
Removed from v.311  
changed lines
  Added in v.1388

  ViewVC Help
Powered by ViewVC 1.1.26