/[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 1312 by ksteube, Mon Sep 24 06:18:44 2007 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        DataArray eTwo(defaultValue);
595        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
596          eTwo.getView()(i)=i+2.0;
597        }
598    
599        myData.setTaggedValueFromCPP(1,eTwo.getView());
600    
601        assert(myData.getLength()==6);
602    
603        myDataView = myData.getDataPoint(0,0);
604        assert(myDataView==eTwo.getView());
605        assert(!myDataView.isEmpty());
606        assert(myDataView.getOffset()==3);
607        assert(myDataView.getRank()==1);
608        assert(myDataView.noValues()==3);
609        assert(myDataView.getShape().size()==1);
610        assert(myDataView(0)==2);
611        assert(myDataView(1)==3);
612        assert(myDataView(2)==4);
613    
614        sampleData=myData.getSampleDataByTag(1);
615        for (int i=0; i<myDataView.noValues(); i++) {
616          assert(sampleData[i]==i+2);
617        }
618    
619      }
620    
621      {
622    
623        cout << "\tCreate a DataTagged object via tag() method." << endl;
624    
625        DataArrayView::ShapeType viewShape;
626        viewShape.push_back(2);
627        viewShape.push_back(3);
628        Data myData(1.3,viewShape,FunctionSpace(),false);
629        myData.tag();
630    
631        //cout << myData.toString() << endl;
632    
633        assert(!myData.isEmpty());
634        assert(myData.isTagged());
635        assert(myData.getTagNumber(0)==1);
636        assert(myData.getDataPointRank()==2);
637        assert(myData.getLength()==6);
638    
639        // check default value
640        DataArrayView myDataView = myData.getPointDataView();
641        assert(!myDataView.isEmpty());
642        assert(myDataView.getOffset()==0);
643        assert(myDataView.getRank()==2);
644        assert(myDataView.noValues()==6);
645        assert(myDataView.getShape().size()==2);
646        assert(myDataView(0,0)==1.3);
647        assert(myDataView(0,1)==1.3);
648        assert(myDataView(0,2)==1.3);
649        assert(myDataView(1,0)==1.3);
650        assert(myDataView(1,1)==1.3);
651        assert(myDataView(1,2)==1.3);
652    
653        // check value for data-point (0,0).
654        myDataView = myData.getDataPoint(0,0);
655        assert(!myDataView.isEmpty());
656        assert(myDataView.getOffset()==0);
657        assert(myDataView.getRank()==2);
658        assert(myDataView.noValues()==6);
659        assert(myDataView.getShape().size()==2);
660        assert(myDataView(0,0)==1.3);
661        assert(myDataView(0,1)==1.3);
662        assert(myDataView(0,2)==1.3);
663        assert(myDataView(1,0)==1.3);
664        assert(myDataView(1,1)==1.3);
665        assert(myDataView(1,2)==1.3);
666    
667      }
668    
669    }
670    
671  void DataTestCase::testDataTaggedExceptions() {  void DataTestCase::testDataTaggedExceptions() {
672    
673    cout << endl;    cout << endl;
674    
675    cout << "\tTest DataTagged operations exceptions." << endl;    cout << "\tTest DataTagged exceptions." << endl;
676    
677    Data myData;    Data myData;
678    DataArrayView myView;    DataArrayView myView;
# Line 315  void DataTestCase::testDataTaggedExcepti Line 686  void DataTestCase::testDataTaggedExcepti
686        assert(true);        assert(true);
687    }    }
688    
   /*  
689    try {    try {
690        myData.setTaggedValue(0,myView);;        myData.setTaggedValueFromCPP(0,myView);;
691        assert(false);        assert(false);
692    }    }
693    catch (EsysException& e) {    catch (EsysException& e) {
694        //cout << e.what() << endl;        //cout << e.what() << endl;
695        assert(true);        assert(true);
696    }    }
   */  
   
 }  
   
 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());  
697    
698  }  }
699    
# Line 397  void DataTestCase::testOperations() { Line 736  void DataTestCase::testOperations() {
736      }      }
737    }    }
738    
739    Data base(dataView);    Data baseEx(dataView,FunctionSpace(),true);
740      Data baseCon(dataView,FunctionSpace(),false);
741      Data baseTag(dataView,FunctionSpace(),false);
742      baseTag.tag();
743    
744      assert(baseEx.isExpanded());
745      assert(baseCon.isConstant());
746      assert(baseTag.isTagged());
747    
748      Data resultEx;
749      Data resultCon;
750      Data resultTag;
751    
752    // test unary operations    // test unary operations
753    
754      double tmp;
755    cout << "\tTest Data::pow." << endl;    cout << "\tTest Data::pow." << endl;
756    Data power(3.0,shape,FunctionSpace(),true);    Data power(3.0,shape,FunctionSpace(),true);
757    Data result(base.powD(power));    resultEx.copy(baseEx.powD(power));
758      resultCon.copy(baseCon.powD(power));
759      resultTag.copy(baseTag.powD(power));
760    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
761      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
762        assert(result.getPointDataView()(i,j) == pow(dataView.index(i,j),3.0));        tmp=pow(dataView.index(i,j),3.0);
763          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
764          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
765          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
766      }      }
767    }    }
768    
769    cout << "\tTest Data::sin." << endl;    cout << "\tTest Data::sin." << endl;
770    result.copy(base.sin());    resultEx.copy(baseEx.sin());
771    assert(true);    resultCon.copy(baseCon.sin());
772      resultTag.copy(baseTag.sin());
773      for (int i=0;i<shape[0];i++) {
774        for (int j=0;j<shape[1];j++) {
775          tmp=sin((double)dataView.index(i,j));
776          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
777          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
778          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
779        }
780      }
781    
782    cout << "\tTest Data::cos." << endl;    cout << "\tTest Data::cos." << endl;
783    result.copy(base.cos());    resultEx.copy(baseEx.cos());
784    assert(true);    resultCon.copy(baseCon.cos());
785      resultTag.copy(baseTag.cos());
786      for (int i=0;i<shape[0];i++) {
787        for (int j=0;j<shape[1];j++) {
788          tmp=cos((double)dataView.index(i,j));
789          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
790          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
791          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
792        }
793      }
794    
795    cout << "\tTest Data::tan." << endl;    cout << "\tTest Data::tan." << endl;
796    result.copy(base.tan());    resultEx.copy(baseEx.tan());
797    assert(true);    resultCon.copy(baseCon.tan());
798      resultTag.copy(baseTag.tan());
799      for (int i=0;i<shape[0];i++) {
800        for (int j=0;j<shape[1];j++) {
801          tmp=tan((double)dataView.index(i,j));
802          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
803          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
804          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
805        }
806      }
807    
808    cout << "\tTest Data::asin." << endl;    cout << "\tTest Data::asin." << endl;
809    result.copy(base.asin());    resultEx.copy(baseEx.asin());
810      resultCon.copy(baseCon.asin());
811      resultTag.copy(baseTag.asin());
812    assert(true);    assert(true);
813    
814    cout << "\tTest Data::acos." << endl;    cout << "\tTest Data::acos." << endl;
815    result.copy(base.acos());    resultEx.copy(baseEx.acos());
816      resultCon.copy(baseCon.acos());
817      resultTag.copy(baseTag.acos());
818    assert(true);    assert(true);
819    
820    cout << "\tTest Data::atan." << endl;    cout << "\tTest Data::atan." << endl;
821    result.copy(base.atan());    resultEx.copy(baseEx.atan());
822    assert(true);    resultCon.copy(baseCon.atan());
823      resultTag.copy(baseTag.atan());
824      for (int i=0;i<shape[0];i++) {
825        for (int j=0;j<shape[1];j++) {
826          tmp=atan((double)dataView.index(i,j));
827          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
828          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
829          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
830        }
831      }
832    
833    cout << "\tTest Data::sinh." << endl;    cout << "\tTest Data::sinh." << endl;
834    result.copy(base.sinh());    resultEx.copy(baseEx.sinh());
835    assert(true);    resultCon.copy(baseCon.sinh());
836      resultTag.copy(baseTag.sinh());
837      for (int i=0;i<shape[0];i++) {
838        for (int j=0;j<shape[1];j++) {
839          tmp=sinh((double)dataView.index(i,j));
840          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
841          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
842          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
843        }
844      }
845    
846    cout << "\tTest Data::cosh." << endl;    cout << "\tTest Data::cosh." << endl;
847    result.copy(base.cosh());    resultEx.copy(baseEx.cosh());
848    assert(true);    resultCon.copy(baseCon.cosh());
849      resultTag.copy(baseTag.cosh());
850      for (int i=0;i<shape[0];i++) {
851        for (int j=0;j<shape[1];j++) {
852          tmp=cosh((double)dataView.index(i,j));
853          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
854          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
855          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
856        }
857      }
858    
859    cout << "\tTest Data::tanh." << endl;    cout << "\tTest Data::tanh." << endl;
860    result.copy(base.tanh());    resultEx.copy(baseEx.tanh());
861    assert(true);    resultCon.copy(baseCon.tanh());
862      resultTag.copy(baseTag.tanh());
863      for (int i=0;i<shape[0];i++) {
864        for (int j=0;j<shape[1];j++) {
865          tmp=tanh((double)dataView.index(i,j));
866          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
867          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
868          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
869        }
870      }
871    
872    cout << "\tTest Data::asinh." << endl;    cout << "\tTest Data::asinh." << endl;
873    result.copy(base.asinh());    resultEx.copy(baseEx.asinh());
874      resultCon.copy(baseCon.asinh());
875      resultTag.copy(baseTag.asinh());
876    assert(true);    assert(true);
877    
878    cout << "\tTest Data::acosh." << endl;    cout << "\tTest Data::acosh." << endl;
879    result.copy(base.acosh());    resultEx.copy(baseEx.acosh());
880      resultCon.copy(baseCon.acosh());
881      resultTag.copy(baseTag.acosh());
882    assert(true);    assert(true);
883    
884    cout << "\tTest Data::atanh." << endl;    cout << "\tTest Data::atanh." << endl;
885    result.copy(base.atanh());    resultEx.copy(baseEx.atanh());
886      resultCon.copy(baseCon.atanh());
887      resultTag.copy(baseTag.atanh());
888    assert(true);    assert(true);
889    
890    cout << "\tTest Data::log." << endl;    cout << "\tTest Data::log." << endl;
891    result.copy(base.log());    resultEx.copy(baseEx.log());
892      resultCon.copy(baseCon.log());
893      resultTag.copy(baseTag.log());
894    assert(true);    assert(true);
895    
   //cout << "\tTest Data::ln." << endl;  
   //result.copy(base.ln());  
   //assert(true);  
   
896    cout << "\tTest Data::abs." << endl;    cout << "\tTest Data::abs." << endl;
897    result.copy(base.abs());    resultEx.copy(baseEx.abs());
898    assert(true);    resultCon.copy(baseCon.abs());
899      resultTag.copy(baseTag.abs());
900      for (int i=0;i<shape[0];i++) {
901        for (int j=0;j<shape[1];j++) {
902          tmp=abs((double)dataView.index(i,j));
903          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
904          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
905          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
906        }
907      }
908    
909    cout << "\tTest Data::sign." << endl;    cout << "\tTest Data::sign." << endl;
910    result.copy(base.sign());    resultEx.copy(baseEx.sign());
911      resultCon.copy(baseCon.sign());
912      resultTag.copy(baseTag.sign());
913    assert(true);    assert(true);
914    
915    cout << "\tTest Data::exp." << endl;    cout << "\tTest Data::exp." << endl;
916    result.copy(base.exp());    resultEx.copy(baseEx.exp());
917    assert(true);    resultCon.copy(baseCon.exp());
918      resultTag.copy(baseTag.exp());
919      for (int i=0;i<shape[0];i++) {
920        for (int j=0;j<shape[1];j++) {
921          tmp=exp((double)dataView.index(i,j));
922          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
923          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
924          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
925        }
926      }
927    
928    cout << "\tTest Data::sqrt." << endl;    cout << "\tTest Data::sqrt." << endl;
929    result.copy(base.sqrt());    resultEx.copy(baseEx.sqrt());
930    assert(true);    resultCon.copy(baseCon.sqrt());
931      resultTag.copy(baseTag.sqrt());
932      for (int i=0;i<shape[0];i++) {
933        for (int j=0;j<shape[1];j++) {
934          tmp=sqrt((double)dataView.index(i,j));
935          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
936          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
937          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
938        }
939      }
940    
941    cout << "\tTest Data::neg." << endl;    cout << "\tTest Data::neg." << endl;
942    result.copy(base.neg());    resultEx.copy(baseEx.neg());
943      resultCon.copy(baseCon.neg());
944      resultTag.copy(baseTag.neg());
945    assert(true);    assert(true);
946    
947    cout << "\tTest Data::pos." << endl;    cout << "\tTest Data::pos." << endl;
948    result.copy(base.pos());    resultEx.copy(baseEx.pos());
949      resultCon.copy(baseCon.pos());
950      resultTag.copy(baseTag.pos());
951    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
952      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
953        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)));
954          assert(std::abs(resultCon.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
955          assert(std::abs(resultTag.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
956      }      }
957    }    }
958    
959    // test reduction operations    // test reduction operations
960    
961    cout << "\tTest Data::Lsup." << endl;    cout << "\tTest Data::Lsup." << endl;
962    assert(base.Lsup() == 5);    assert(std::abs(baseEx.Lsup() - 5) <= REL_TOL*5);
963      assert(std::abs(baseCon.Lsup() - 5) <= REL_TOL*5);
964      assert(std::abs(baseTag.Lsup() - 5) <= REL_TOL*5);
965    
966    cout << "\tTest Data::sup." << endl;    cout << "\tTest Data::sup." << endl;
967    assert(base.sup() == 5);    assert(std::abs(baseEx.sup() - 5) <= REL_TOL*5);
968      assert(std::abs(baseCon.sup() - 5) <= REL_TOL*5);
969      assert(std::abs(baseTag.sup() - 5) <= REL_TOL*5);
970    
971    cout << "\tTest Data::inf." << endl;    cout << "\tTest Data::inf." << endl;
972    assert(base.inf() == 0);    assert(std::abs(baseEx.inf() - 0) <= REL_TOL*0);
973      assert(std::abs(baseCon.inf() - 0) <= REL_TOL*0);
974      assert(std::abs(baseTag.inf() - 0) <= REL_TOL*0);
975    
976    // test data-point reduction operations    // test data-point reduction operations
977    
978    cout << "\tTest Data::minval." << endl;    cout << "\tTest Data::minval." << endl;
979    result.copy(base.minval());    resultEx.copy(baseEx.minval());
980    assert(result.getPointDataView()() == 0);    resultCon.copy(baseCon.minval());
981      resultTag.copy(baseTag.minval());
982      assert(std::abs(resultEx.getPointDataView()() - 0) <= REL_TOL*0);
983      assert(std::abs(resultCon.getPointDataView()() - 0) <= REL_TOL*0);
984      assert(std::abs(resultTag.getPointDataView()() - 0) <= REL_TOL*0);
985    
986    cout << "\tTest Data::maxval." << endl;    cout << "\tTest Data::maxval." << endl;
987    result.copy(base.maxval());    resultEx.copy(baseEx.maxval());
988    assert(result.getPointDataView()() == 5);    resultCon.copy(baseCon.maxval());
989      resultTag.copy(baseTag.maxval());
990    //cout << "\tTest Data::length." << endl;    assert(std::abs(resultEx.getPointDataView()() - 5) <= REL_TOL*5);
991    //result.copy(base.length());    assert(std::abs(resultCon.getPointDataView()() - 5) <= REL_TOL*5);
992    //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);  
993    
994  }  }
995    
 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);  
   
 }  
996    
997  void DataTestCase::testMemAlloc() {  void DataTestCase::testMemAlloc() {
998    

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

  ViewVC Help
Powered by ViewVC 1.1.26