/[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

revision 1026 by phornby, Tue Mar 13 08:25:00 2007 UTC revision 2037 by jfenwick, Thu Nov 13 06:17:12 2008 UTC
# Line 1  Line 1 
1  // $Id$  
2  /*  /*******************************************************
3   *****************************************************************************  *
4   *                                                                           *  * Copyright (c) 2003-2008 by University of Queensland
5   *       COPYRIGHT  ACcESS  -  All Rights Reserved                           *  * Earth Systems Science Computational Center (ESSCC)
6   *                                                                           *  * http://www.uq.edu.au/esscc
7   * This software is the property of ACcESS. No part of this code             *  *
8   * may be copied in any form or by any means without the expressed written   *  * Primary Business: Queensland, Australia
9   * consent of ACcESS.  Copying, use or modification of this software         *  * Licensed under the Open Software License version 3.0
10   * by any unauthorised person is illegal unless that person has a software   *  * http://www.opensource.org/licenses/osl-3.0.php
11   * license agreement with ACcESS.                                            *  *
12   *                                                                           *  *******************************************************/
13   *****************************************************************************  
14  */  
15  #include <iostream>  #include <iostream>
16  #if (defined _WIN32) && (defined __INTEL_COMPILER)  #if (defined _WIN32) && (defined __INTEL_COMPILER)
17  #include <mathimf.h>  #include <mathimf.h>
# Line 25  Line 25 
25  #include "esysUtils/EsysException.h"  #include "esysUtils/EsysException.h"
26    
27  #include "escript/Data.h"  #include "escript/Data.h"
28    #include "escript/DataLazy.h"
29    
30    
31  using namespace std;  using namespace std;
32  using namespace CppUnitTest;  using namespace CppUnitTest;
33  using namespace escript;  using namespace escript;
34  using namespace esysUtils;  using namespace esysUtils;
35    using namespace escript::DataTypes;
36    
37  void DataTestCase::setUp() {  void DataTestCase::setUp() {
38    //    //
# Line 42  void DataTestCase::tearDown() { Line 44  void DataTestCase::tearDown() {
44    // This is called after each test has been run    // This is called after each test has been run
45  }  }
46    
 void DataTestCase::testSlicing() {  
   
   cout << endl;  
   
   {  
   
     cout << "\tTest get-slicing DataConstant" << endl;  
   
     DataArrayView::ShapeType viewShape;  
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     Data data(1.3,viewShape,FunctionSpace(),false);  
47    
     //cout << data.toString() << endl;  
48    
49      DataArrayView::RegionType region;  namespace
50      region.push_back(DataArrayView::RegionType::value_type(0,0));  {
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
   
     Data slice1(data.getSlice(region));  
   
     //cout << slice1.toString() << endl;  
   
     assert(slice1.getDataPointRank()==0);  
     assert(slice1.getDataPoint(0,0)()==1.3);  
   
     region.clear();  
     region.push_back(DataArrayView::RegionType::value_type(0,1));  
     region.push_back(DataArrayView::RegionType::value_type(0,1));  
   
     Data slice2(data.getSlice(region));  
   
     //cout << slice2.toString() << endl;  
51    
52      assert(slice2.getDataPointRank()==2);  inline
53      assert(slice2.getDataPoint(0,0)(0,0)==1.3);  DataTypes::ValueType::reference
54    getRef(Data& d,int s1, int p1, int x, int y)
55    {
56        return d.getDataAtOffset(d.getDataOffset(s1,p1)+getRelIndex(d.getDataPointShape(),x,y));
57    }
58    
59      region.clear();  inline
60      region.push_back(DataArrayView::RegionType::value_type(0,1));  DataTypes::ValueType::reference
61      region.push_back(DataArrayView::RegionType::value_type(0,2));  getRef(Data& d, int x, int y)
62    {
63        return d.getDataAtOffset(getRelIndex(d.getDataPointShape(),x,y));
64    }
65    
66      Data slice3(data.getSlice(region));  }
67    
     //cout << slice3.toString() << endl;  
68    
69      assert(slice3.getDataPointRank()==2);  void DataTestCase::testCopyingWorker(bool delayed)
70      assert(slice3.getDataPoint(0,0)(0,0)==1.3);  {
     assert(slice3.getDataPoint(0,0)(0,1)==1.3);  
71    
72    }    using namespace escript::DataTypes;
73      cout << endl;
74    
75      DataTypes::ShapeType shape;
76      shape.push_back(2);
77      shape.push_back(3);
78      DataTypes::ValueType data(DataTypes::noValues(shape),1);
79      const int NUMDATS=3;
80      Data* dats[NUMDATS];
81      const char* strs[]={"DataConstant", "DataTagged", "DataExpanded"};
82      dats[0]=new Data(new DataConstant(FunctionSpace(),shape,data));
83      dats[1]=new Data(new DataTagged(FunctionSpace(),shape,data));
84      dats[2]=new Data(new DataExpanded(FunctionSpace(),shape,data));
85      if (delayed)
86    {    {
87        dats[0]->delaySelf();
88      cout << "\tTest set-slicing DataConstant" << endl;      dats[1]->delaySelf();
89        dats[2]->delaySelf();
     DataArrayView::ShapeType viewShape;  
     Data source(10.0,viewShape,FunctionSpace(),false);  
   
     //cout << source.toString() << endl;  
   
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     Data target(1.3,viewShape,FunctionSpace(),false);  
   
     //cout << target.toString() << endl;  
   
     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);  
   
     //cout << target.toString() << endl;  
   
     assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());  
   
90    }    }
91    
92      for (int k=0;k<NUMDATS;++k)
93    {    {
94        cout << "\tTest deep copy " << strs[k] << endl;
95        Data* d=dats[k];
96        Data* deep=d->copySelf();   // test self copy
97        if (delayed)
98        {
99          assert(deep->isLazy());
100        }
101        for (int i=0;i<DataTypes::noValues(shape);++i)
102        {
103        if (d->getDataAtOffset(i)!=deep->getDataAtOffset(i))
104            assert(false);
105        }
106        if (delayed)
107        {
108           d->delaySelf();
109        }
110        d->setToZero();
111        if (delayed)
112        {
113          assert(d->isLazy());
114        }
115        for (int i=0;i<DataTypes::noValues(shape);++i)
116        {
117        if (d->getDataAtOffset(i)==deep->getDataAtOffset(i))
118            assert(false);
119        }
120            if (delayed)
121        {
122           d->delaySelf();
123           deep->delaySelf();
124        }
125        d->copy(*deep);         // test copy from object
126        if (delayed)
127        {
128          assert(d->isLazy());
129        }
130        for (int i=0;i<DataTypes::noValues(shape);++i)
131        {
132        if (d->getDataAtOffset(i)!=deep->getDataAtOffset(i))
133            assert(false);
134        }
135        d->setToZero();
136        for (int i=0;i<DataTypes::noValues(shape);++i)
137        {
138        if (d->getDataAtOffset(i)==deep->getDataAtOffset(i))
139            assert(false);
140        }
141        delete deep;
142        delete dats[k];
143      }
144    
     cout << "\tTest get-slicing DataTagged" << endl;  
   
     //  
     // create a DataTagged with a default value only  
   
     DataArrayView::ShapeType viewShape;  
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     Data data(1.3,viewShape,FunctionSpace(),false);  
     data.tag();  
     data.getDataPoint(0,0)(0,0)=1.0;  
     data.getDataPoint(0,0)(1,1)=2.0;  
   
     //cout << data.toString() << endl;  
   
     //  
     // create a scalar slice  
   
     DataArrayView::RegionType region;  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
   
     Data slice1(data.getSlice(region));  
   
     //cout << slice1.toString() << endl;  
145    
     assert(slice1.isTagged());  
     assert(slice1.getDataPointRank()==0);  
     assert(slice1.getDataPoint(0,0)()==1.0);  
146    
     //  
     // create a rank 2 slice with one value  
147    
     region.clear();  
     region.push_back(DataArrayView::RegionType::value_type(0,1));  
     region.push_back(DataArrayView::RegionType::value_type(0,1));  
148    
     Data slice2(data.getSlice(region));  
149    
150      //cout << slice2.toString() << endl;  }
151    
     assert(slice2.isTagged());  
     assert(slice2.getDataPointRank()==2);  
     assert(slice2.getDataPoint(0,0)(0,0)==1.0);  
152    
153      //  void DataTestCase::testSlicingWorker(bool delayed)
154      // create a rank 2 slice with four values  {
155    
156      region.clear();    using namespace escript::DataTypes;
157      region.push_back(DataArrayView::RegionType::value_type(0,2));    cout << endl;
158      region.push_back(DataArrayView::RegionType::value_type(0,2));    {
159       DataTypes::ShapeType viewShape;
160      Data slice3(data.getSlice(region));     viewShape.push_back(2);
161       viewShape.push_back(3);
162      //cout << slice3.toString() << endl;  
163       const int NUMDATS=3;
164      assert(slice3.isTagged());     const char* strs[]={"DataConstant", "DataTagged","DataExpanded"};
165      assert(slice3.getDataPointRank()==2);     bool tags[]={false,true,false};  // is the slice of this data supposed to be tagged
166      assert(slice3.getDataPoint(0,0)(0,0)==1.0);     Data* dats[NUMDATS];
167      assert(slice3.getDataPoint(0,0)(0,1)==1.3);     for (int k=0;k<NUMDATS;++k)
168      assert(slice3.getDataPoint(0,0)(1,0)==1.3);     {
169      assert(slice3.getDataPoint(0,0)(1,1)==2.0);          dats[k]=new Data(1.3, viewShape);
170       }
171       dats[1]->tag();
172       dats[2]->expand();
173       for (int k=0;k<NUMDATS;++k)
174       {
175        Data* temp=dats[k];
176        dats[k]=new Data(dats[k]->delay());
177        delete temp;
178       }
179       for (int k=0;k<NUMDATS;++k)
180       {
181        cout << "\t\tTest get-slicing " << strs[k] << endl;
182            dats[k]->getDataAtOffset(dats[k]->getDataOffset(0,0)+getRelIndex(viewShape,0,0))=1.0;
183            dats[k]->getDataAtOffset(dats[k]->getDataOffset(0,0)+getRelIndex(viewShape,1,1))=2.0;
184    
185            DataTypes::RegionType region;
186            region.push_back(DataTypes::RegionType::value_type(0,0));
187            region.push_back(DataTypes::RegionType::value_type(0,0));
188    
189            Data slice1(dats[k]->getSlice(region));
190    
191            if (tags[k]) {assert(slice1.isTagged());}
192            assert(slice1.getDataPointRank()==0);
193            assert(slice1.getDataPoint(0,0)==1.0);
194    
195        //
196        // create a rank 2 slice with one value
197        
198        region.clear();
199        region.push_back(DataTypes::RegionType::value_type(0,1));
200        region.push_back(DataTypes::RegionType::value_type(0,1));
201        
202        Data slice2(dats[k]->getSlice(region));
203        
204        //cout << slice2.toString() << endl;
205        
206        if (tags[k]) {assert(slice2.isTagged());}
207        assert(slice2.getDataPointRank()==2);
208        
209        assert(slice2.getDataAtOffset(slice2.getDataOffset(0,0)+getRelIndex(slice2.getDataPointShape(),0,0))==1.0);
210    
211        //
212        // create a rank 2 slice with four values
213        
214        region.clear();
215        region.push_back(DataTypes::RegionType::value_type(0,2));
216        region.push_back(DataTypes::RegionType::value_type(0,2));
217        
218        Data slice3(dats[k]->getSlice(region));
219        
220        //cout << slice3.toString() << endl;
221        
222        if (tags[k]) {assert(slice3.isTagged());}
223        assert(slice3.getDataPointRank()==2);
224        assert(getRef(slice3,0,0,0,0)==1.0);
225        assert(getRef(slice3,0,0,0,1)==1.3);
226        assert(getRef(slice3,0,0,1,0)==1.3);
227        assert(getRef(slice3,0,0,1,1)==2.0);
228       }
229    
230      //     // now some extra tests for tagged data (dats[1])
     // add a value for tag "1"  
231    
232      DataArrayView::ValueType viewData(6);     //
233      for (int i=0;i<viewData.size();i++) {     // add a value for tag "1"
       viewData[i]=i;  
     }  
     DataArrayView dataView(viewData,viewShape);  
234    
235      data.setTaggedValueFromCPP(1, dataView);     DataTypes::ValueType viewData(6);
236       for (int i=0;i<viewData.size();i++) {
237        viewData[i]=i;
238       }
239       dats[1]->setTaggedValueFromCPP(1, viewShape, viewData);
240    
241      //      //
242      // create a full slice      // create a full slice
243    
244      region.clear();     DataTypes::RegionType region;
245      region.push_back(DataArrayView::RegionType::value_type(0,2));     region.push_back(DataTypes::RegionType::value_type(0,2));
246      region.push_back(DataArrayView::RegionType::value_type(0,3));     region.push_back(DataTypes::RegionType::value_type(0,3));
247    
248       Data slice4(dats[1]->getSlice(region));
249    
250       assert(slice4.isTagged());
251       assert(slice4.getDataPointRank()==2);
252       assert(getRef(slice4,0,0,0,0)==0);
253       assert(getRef(slice4,0,0,0,1)==2);
254       assert(getRef(slice4,0,0,0,2)==4);
255       assert(getRef(slice4,0,0,1,0)==1);
256       assert(getRef(slice4,0,0,1,1)==3);
257       assert(getRef(slice4,0,0,1,2)==5);
258    
259       for (int k=0;k<NUMDATS;++k)
260       {
261        delete dats[k];
262       }
263     }
264    
265      Data slice4(data.getSlice(region));   {
266      DataTypes::ShapeType viewShape;
267      //cout << slice4.toString() << endl;    viewShape.push_back(2);
268      viewShape.push_back(3);
     assert(slice4.isTagged());  
     assert(slice4.getDataPointRank()==2);  
     assert(slice4.getDataPoint(0,0)(0,0)==0);  
     assert(slice4.getDataPoint(0,0)(0,1)==2);  
     assert(slice4.getDataPoint(0,0)(0,2)==4);  
     assert(slice4.getDataPoint(0,0)(1,0)==1);  
     assert(slice4.getDataPoint(0,0)(1,1)==3);  
     assert(slice4.getDataPoint(0,0)(1,2)==5);  
269    
270      const int NUMDATS=3;
271      const char* strs[]={"DataConstant", "DataTagged","DataExpanded"};
272      Data* dats[NUMDATS];
273      Data* src[NUMDATS];
274      for (int k=0;k<NUMDATS;++k)
275      {
276        dats[k]=new Data(1.3, viewShape);
277            src[k]=new Data(10,DataTypes::scalarShape);
278    }    }
279      dats[1]->tag();
280      src[1]->tag();
281      dats[2]->expand();
282      src[2]->expand();
283      if (delayed)
284    {    {
285        for(int k=0;k<NUMDATS;++k)
286      cout << "\tTest set-slicing DataTagged" << endl;      {
287        if (delayed)
288      //      {
289      // create a source DataTagged with a scalar default value only        Data* temp=dats[k];
290          dats[k]=new Data(dats[k]->delay());   // coz delay returns an object not a pointer
291      DataArrayView::ShapeType viewShape;        delete temp;
292      Data source(10.0,viewShape,FunctionSpace(),false);        temp=src[k];
293      source.tag();        src[k]=new Data(src[k]->delay());
294          delete temp;
295      //cout << "source:\n" << source.toString() << endl;      }
   
     //  
     // create a target DataTagged with a rank 2 default value only  
   
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     Data target(1.3,viewShape,FunctionSpace(),false);  
     target.tag();  
   
     //cout << "target:\n" << target.toString() << endl;  
   
     //  
     // set a slice in target from source  
   
     DataArrayView::RegionType region;  
     region.push_back(DataArrayView::RegionType::value_type(1,1));  
     region.push_back(DataArrayView::RegionType::value_type(1,1));  
   
     target.setSlice(source,region);  
   
     //cout << "target:\n" << target.toString() << endl;  
   
     assert(target.isTagged());  
     assert(target.getDataPointRank()==2);  
     assert(target.getDataPoint(0,0)(0,0)==1.3);  
     assert(target.getDataPoint(0,0)(0,1)==1.3);  
     assert(target.getDataPoint(0,0)(0,2)==1.3);  
     assert(target.getDataPoint(0,0)(1,0)==1.3);  
     assert(target.getDataPoint(0,0)(1,1)==source.getDataPoint(0,0)());  
     assert(target.getDataPoint(0,0)(1,2)==1.3);  
   
     //  
     // add a value for tag "1" to target  
   
     DataArrayView::ValueType viewData(6);  
     for (int i=0;i<viewData.size();i++) {  
       viewData[i]=i;  
296      }      }
297      DataArrayView dataView(viewData,viewShape);    }
298      for (int k=0;k<NUMDATS;++k)
299      target.setTaggedValueFromCPP(1, dataView);    {
300        cout << "\t\tTest set-slicing " << strs[k] << endl;
301      //cout << "target:\n" << target.toString() << endl;      Data target(1.3,viewShape);
302        if (k==2) {target.expand();}
303        DataTypes::RegionType region;
304        region.push_back(DataTypes::RegionType::value_type(1,1));
305        region.push_back(DataTypes::RegionType::value_type(1,1));
306        target.setSlice(*(src[k]),region);
307        assert(getRef(target,0,0,1,1)==src[k]->getDataPoint(0,0));
308      }
309      
310      // some extra tests on tagged data
311    
312      //    //
313      // set a slice in target from source    // add a value for tag "1" to target
314    
315      region.clear();    DataTypes::ValueType viewData(6);
316      region.push_back(DataArrayView::RegionType::value_type(0,0));    for (int i=0;i<viewData.size();i++) {
317      region.push_back(DataArrayView::RegionType::value_type(1,1));      viewData[i]=i;
318      }
319    
320      target.setSlice(source,region);    Data target(1.3,viewShape,FunctionSpace(),false);
321      target.tag();
322      target.setTaggedValueFromCPP(1, viewShape, viewData);
323    
324      //cout << "target:\n" << target.toString() << endl;      //cout << "target:\n" << target.toString() << endl;
325    
     assert(target.isTagged());  
     assert(target.getDataPointRank()==2);  
     assert(target.getDataPoint(0,0)(0,0)==0);  
     assert(target.getDataPoint(0,0)(0,1)==source.getDataPoint(0,0)());  
     assert(target.getDataPoint(0,0)(0,2)==4);  
     assert(target.getDataPoint(0,0)(1,0)==1);  
     assert(target.getDataPoint(0,0)(1,1)==3);  
     assert(target.getDataPoint(0,0)(1,2)==5);  
   
326      //      //
327      // add a value for tag "2" to source      // set a slice in target from source
   
     DataArrayView::ShapeType viewShape2;  
     DataArrayView::ValueType viewData2(1);  
     viewData2[0]=6;  
     DataArrayView dataView2(viewData2,viewShape2);  
   
     source.setTaggedValueFromCPP(2, dataView2);  
328    
329      //cout << "source:\n" << source.toString() << endl;    DataTypes::RegionType region;
330      region.push_back(DataTypes::RegionType::value_type(0,0));
331      region.push_back(DataTypes::RegionType::value_type(1,1));
332    
333      target.setSlice(*src[1],region);
334    
335      assert(target.isTagged());
336      assert(target.getDataPointRank()==2);
337      assert(getRef(target,0,0,0,0)==0);
338      assert(getRef(target,0,0,0,1)==src[1]->getDataPoint(0,0));
339      assert(getRef(target,0,0,0,2)==4);
340      assert(getRef(target,0,0,1,0)==1);
341      assert(getRef(target,0,0,1,1)==3);
342      assert(getRef(target,0,0,1,2)==5);
343    
344      //    //
345      // set a slice in target from source    // add a value for tag "2" to source
346    
347      region.clear();    DataTypes::ShapeType viewShape2;
348      region.push_back(DataArrayView::RegionType::value_type(0,0));    DataTypes::ValueType viewData2(1);
349      region.push_back(DataArrayView::RegionType::value_type(1,1));    viewData2[0]=6;
350      src[1]->setTaggedValueFromCPP(2, viewShape2, viewData2);
351    
352      target.setSlice(source,region);    region.clear();
353      region.push_back(DataTypes::RegionType::value_type(0,0));
354      region.push_back(DataTypes::RegionType::value_type(1,1));
355    
356      //cout << "target:\n" << target.toString() << endl;    target.setSlice(*src[1],region);
357    
358      assert(target.isTagged());    assert(target.isTagged());
359      assert(target.getDataPointRank()==2);    assert(target.getDataPointRank()==2);
360    
361      // use a non-existant tag so we get a pointer to the default value      // use a non-existant tag so we get a pointer to the default value
362      // ie: the first element in the data array      // ie: the first element in the data array
363      DataAbstract::ValueType::value_type* targetData=target.getSampleDataByTag(9);    DataAbstract::ValueType::value_type* targetData=target.getSampleDataByTag(9);
364      for (int i=0; i<target.getLength(); i++) {    for (int i=0; i<target.getLength(); i++) {
365        assert(targetData[i]>=0);        assert(targetData[i]>=0);
     }  
     assert(targetData[0]==1.3);  
     assert(targetData[1]==1.3);  
     assert(targetData[2]==10);  
     assert(targetData[3]==10);  
     assert(targetData[4]==1.3);  
     assert(targetData[5]==1.3);  
     assert(targetData[6]==0);  
     assert(targetData[7]==1);  
     assert(targetData[8]==10);  
     assert(targetData[9]==3);  
     assert(targetData[10]==4);  
     assert(targetData[11]==5);  
     assert(targetData[12]==1.3);  
     assert(targetData[13]==1.3);  
     assert(targetData[14]==6);  
     assert(targetData[15]==10);  
     assert(targetData[16]==1.3);  
     assert(targetData[17]==1.3);  
   
366    }    }
367      assert(targetData[0]==1.3);
368      assert(targetData[1]==1.3);
369      assert(targetData[2]==10);
370      assert(targetData[3]==1.3);
371      assert(targetData[4]==1.3);
372      assert(targetData[5]==1.3);
373      assert(targetData[6]==0);
374      assert(targetData[7]==1);
375      assert(targetData[8]==10);
376      assert(targetData[9]==3);
377      assert(targetData[10]==4);
378      assert(targetData[11]==5);
379      assert(targetData[12]==1.3);
380      assert(targetData[13]==1.3);
381      assert(targetData[14]==6);
382      assert(targetData[15]==1.3);
383      assert(targetData[16]==1.3);
384      assert(targetData[17]==1.3);
385    
   {  
   
     cout << "\tTest get-slicing DataExpanded" << endl;  
   
     DataArrayView::ShapeType viewShape;  
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     Data temp(1.3,viewShape,FunctionSpace(),true);  
   
     temp.getDataPoint(0,0)(0,0)=0.0;  
     temp.getDataPoint(0,0)(1,1)=1.0;  
   
     DataArrayView::RegionType region;  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
     region.push_back(DataArrayView::RegionType::value_type(0,0));  
   
     Data slice(temp.getSlice(region));  
   
     assert(slice.getDataPointRank()==0);  
     assert(slice.getDataPoint(0,0)()==0.0);  
   
     region.clear();  
     region.push_back(DataArrayView::RegionType::value_type(0,1));  
     region.push_back(DataArrayView::RegionType::value_type(0,1));  
   
     slice=temp.getSlice(region);  
   
     assert(slice.getDataPointRank()==2);  
     assert(slice.getDataPoint(0,0)(0,0)==0.0);  
   
     region.clear();  
     region.push_back(DataArrayView::RegionType::value_type(0,2));  
     region.push_back(DataArrayView::RegionType::value_type(0,2));  
   
     slice=temp.getSlice(region);  
   
     assert(slice.getDataPoint(0,0)(0,0)==0.0);  
     assert(slice.getDataPoint(0,0)(1,1)==1.0);  
   
   }  
386    
387      for (int k=0;k<NUMDATS;++k)
388    {    {
389        delete dats[k];
390      cout << "\tTest set-slicing DataExpanded" << endl;      delete src[k];
   
     DataArrayView::ShapeType viewShape;  
     Data source(10.0,viewShape,FunctionSpace(),true);  
   
     viewShape.push_back(2);  
     viewShape.push_back(3);  
     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)());  
   
   }  
   
 }  
   
 void DataTestCase::testAll() {  
   
   cout << endl;  
   
   cout << "\tCreate a Data object from a DataArrayView" << endl;  
   
   DataArrayView::ShapeType viewShape;  
   viewShape.push_back(3);  
   DataArrayView::ValueType viewData(3);  
   for (int i=0;i<viewShape[0];++i) {  
     viewData[i]=i;  
391    }    }
   DataArrayView myView(viewData,viewShape);  
392    
393    bool expanded=true;   }
   Data exData(myView,FunctionSpace(),expanded);  
   Data cData(myView);  
   Data result;  
394    
395    assert(exData.isExpanded());  }
   assert(cData.isConstant());  
   assert(result.isEmpty());  
396    
397    cout << "\tTest some basic operations" << endl;  // This is to test new copy routines, existing tests should remain where they are
398    result=exData*cData;  void DataTestCase::testCopying()
399    assert(result.isExpanded());  {
400      cout << "\n\tReadyData." << endl;
401      testCopyingWorker(false);
402      cout << "\n\tLazyData." << endl;
403      testCopyingWorker(true);
404    }
405    
406    void DataTestCase::testSlicing() {
407      cout << "\n\tReadyData." << endl;
408      testSlicingWorker(false);
409      cout << "\n\tLazyData." << endl;
410      testSlicingWorker(true);
411  }  }
412    
413  void DataTestCase::testMore() {  void DataTestCase::testSome() {
414    
415    cout << endl;    cout << endl;
416    
417    cout << "\tCreate a Data object from a DataArrayView" << endl;    cout << "\tCreate a Data object." << endl;
418    
419    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
420    viewShape.push_back(3);    viewShape.push_back(3);
421    DataArrayView::ValueType viewData(3);    DataTypes::ValueType viewData(3);
422    for (int i=0;i<viewShape[0];++i) {    for (int i=0;i<viewShape[0];++i) {
423      viewData[i]=i;      viewData[i]=i;
424    }    }
   DataArrayView myView(viewData,viewShape);  
425    
426    bool expanded=true;    bool expanded=true;
427    Data exData(myView,FunctionSpace(),expanded);    Data exData(viewData,viewShape,FunctionSpace(),expanded);
428    Data cData(myView);    Data cData(viewData,viewShape);
429    Data result;    Data result;
430    
431    assert(exData.isExpanded());    assert(exData.isExpanded());
# Line 484  void DataTestCase::testMore() { Line 453  void DataTestCase::testMore() {
453    
454  }  }
455    
456    
457    
458    // This method tests to see if resolve() produces results of the correct type
459    void DataTestCase::testResolveType()
460    {
461      cout << endl;
462      cout << "\tTesting resolve()\n";
463      DataTypes::ShapeType viewShape;
464      viewShape.push_back(2);
465      viewShape.push_back(3);
466      viewShape.push_back(4);
467      DataTypes::ValueType viewData(2*3*4);
468      for (int i=0;i<DataTypes::noValues(viewShape);++i) {
469        viewData[i]=i;
470      }
471      Data c1(viewData,viewShape);
472      Data t1(viewData,viewShape);
473      Data e1(viewData,viewShape);
474      t1.tag();
475      e1.expand();
476      c1.delaySelf();
477      t1.delaySelf();
478      e1.delaySelf();
479      Data d1=c1+c1;
480      assert(d1.isLazy());
481      assert((d1.resolve(),d1.isConstant()));
482      d1=c1+t1;
483      assert(d1.isLazy());
484      assert((d1.resolve(),d1.isTagged()));
485      d1=t1+c1;
486      assert(d1.isLazy());
487      assert((d1.resolve(),d1.isTagged()));
488      d1=t1+t1;
489      assert(d1.isLazy());
490      assert((d1.resolve(),d1.isTagged()));
491      d1=c1+e1;
492      assert(d1.isLazy());
493      assert((d1.resolve(),d1.isExpanded()));
494      d1=e1+c1;
495      assert(d1.isLazy());
496      assert((d1.resolve(),d1.isExpanded()));
497      d1=e1+t1;
498      assert(d1.isLazy());
499      assert((d1.resolve(),d1.isExpanded()));
500      d1=t1+e1;
501      assert(d1.isLazy());
502      assert((d1.resolve(),d1.isExpanded()));
503      d1=e1+e1;
504      assert(d1.isLazy());
505      assert((d1.resolve(),d1.isExpanded()));
506      cout << "\tTesting tag()\n";
507      c1.tag();
508      assert(c1.isTagged());
509      t1.tag();
510      assert(t1.isTagged());
511      try
512      {
513        e1.tag();
514        assert(false);      // this should have thrown
515      } catch(...) {}
516      cout << "\tTesting expand()\n";
517      Data c2(viewData,viewShape);
518      Data t2(viewData,viewShape);
519      Data e2(viewData,viewShape);
520      t2.tag();
521      e2.expand();
522      c2.delaySelf();
523      t2.delaySelf();
524      e2.delaySelf();
525      c2.expand();
526      assert(c2.isExpanded());
527      t2.expand();
528      assert(t2.isExpanded());
529      e2.expand();
530      assert(e2.isExpanded());
531    }
532    
533  void DataTestCase::testDataConstant() {  void DataTestCase::testDataConstant() {
534    
535    cout << endl;    cout << endl;
536    
537    cout << "\tCreate a DataConstant object from a DataArrayView" << endl;    cout << "\tCreate a DataConstant object." << endl;
538    
539    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
540    viewShape.push_back(2);    viewShape.push_back(2);
541    viewShape.push_back(3);    viewShape.push_back(3);
542    viewShape.push_back(4);    viewShape.push_back(4);
543    DataArrayView::ValueType viewData(2*3*4);    DataTypes::ValueType viewData(2*3*4);
544    for (int i=0;i<DataArrayView::noValues(viewShape);++i) {    for (int i=0;i<DataTypes::noValues(viewShape);++i) {
545      viewData[i]=i;      viewData[i]=i;
546    }    }
   DataArrayView myView(viewData,viewShape);  
547    
548    Data left(myView);    Data left(viewData,viewShape);
549    Data right(myView);    Data right(viewData,viewShape);
550    Data result;    Data result;
551    
552    cout << "\tTest some basic operations" << endl;    cout << "\tTest some basic operations" << endl;
# Line 531  void DataTestCase::testDataTagged() { Line 576  void DataTestCase::testDataTagged() {
576    
577      cout << "\tCreate a DataTagged object with a default value only." << endl;      cout << "\tCreate a DataTagged object with a default value only." << endl;
578    
579      DataTagged::TagListType keys;      DataTypes::ShapeType viewShape;
   
     DataTagged::ValueListType values;  
   
     DataArrayView::ShapeType viewShape;  
580      viewShape.push_back(3);      viewShape.push_back(3);
581    
582      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
583      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
584        viewData[i]=i;        viewData[i]=i;
585      }      }
586      DataArrayView defaultValue(viewData,viewShape);      int arr[1]={1};     // iso c++ does not like empty arrays
587        DataTagged* dt=new DataTagged(FunctionSpace(),viewShape,arr,viewData);
588      bool expanded=false;      Data myData(dt);
     
     Data myData(keys,values,defaultValue,FunctionSpace(),expanded);  
   
     // cout << myData.toString() << endl;  
589    
590      assert(!myData.isEmpty());      assert(!myData.isEmpty());
591      assert(myData.isTagged());      assert(myData.isTagged());
592      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
593      assert(myData.getDataPointRank()==1);      assert(myData.getDataPointRank()==1);
594      assert(myData.getLength()==3);      assert(myData.getLength()==3);
595        
596      DataArrayView myDataView = myData.getPointDataView();      assert(myData.getNoValues()==3);
597      assert(!myDataView.isEmpty());      assert(myData.getDataAtOffset(0)==0.0);
598      assert(myDataView.getOffset()==0);      assert(myData.getDataAtOffset(1)==1.0);
599      assert(myDataView.getRank()==1);      assert(myData.getDataAtOffset(2)==2.0);
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0.0);  
     assert(myDataView(1)==1.0);  
     assert(myDataView(2)==2.0);  
   
     myDataView = myData.getDataPoint(0,0);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0.0);  
     assert(myDataView(1)==1.0);  
     assert(myDataView(2)==2.0);  
600    
601      double* sampleData=myData.getSampleData(0);      double* sampleData=myData.getSampleData(0);
602      for (int i=0; i<myDataView.noValues(); i++) {      for (int i=0; i<myData.getNoValues(); i++) {
603        assert(sampleData[i]==i);        assert(sampleData[i]==i);
604      }      }
605      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
# Line 590  void DataTestCase::testDataTagged() { Line 612  void DataTestCase::testDataTagged() {
612      cout << "\tTest setting of a tag and associated value." << endl;      cout << "\tTest setting of a tag and associated value." << endl;
613    
614      // value for tag "1"      // value for tag "1"
615      DataArray eTwo(defaultValue);      DataTypes::ValueType eTwoData(viewData);
616      for (int i=0;i<eTwo.getView().getShape()[0];i++) {   //   DataArrayView eTwoView(eTwoData, viewShape);
617        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
618          eTwoData[i]=i+2.0;
619      }      }
620    
621      myData.setTaggedValueFromCPP(1,eTwo.getView());      myData.setTaggedValueFromCPP(1,viewShape, eTwoData);
622    
623      assert(myData.getLength()==6);      assert(myData.getLength()==6);
624    
625      myDataView = myData.getDataPoint(0,0);      int offset=myData.getDataOffset(0,0);
626      assert(myDataView==eTwo.getView());      assert(offset==3);
627      assert(!myDataView.isEmpty());      assert(myData.getDataPointRank()==1);
628      assert(myDataView.getOffset()==3);      assert(myData.getNoValues()==3);
629      assert(myDataView.getRank()==1);  
630      assert(myDataView.noValues()==3);      assert(myData.getDataAtOffset(offset+0)==2);
631      assert(myDataView.getShape().size()==1);      assert(myData.getDataAtOffset(offset+1)==3);
632      assert(myDataView(0)==2);      assert(myData.getDataAtOffset(offset+2)==4);
     assert(myDataView(1)==3);  
     assert(myDataView(2)==4);  
633    
634      sampleData=myData.getSampleDataByTag(1);      sampleData=myData.getSampleDataByTag(1);
635      for (int i=0; i<myDataView.noValues(); i++) {      for (int i=0; i<myData.getNoValues(); i++) {
636        assert(sampleData[i]==i+2);        assert(sampleData[i]==i+2);
637      }      }
638    
# Line 621  void DataTestCase::testDataTagged() { Line 642  void DataTestCase::testDataTagged() {
642    
643      cout << "\tCreate a DataTagged object via tag() method." << endl;      cout << "\tCreate a DataTagged object via tag() method." << endl;
644    
645      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
646      viewShape.push_back(2);      viewShape.push_back(2);
647      viewShape.push_back(3);      viewShape.push_back(3);
648      Data myData(1.3,viewShape,FunctionSpace(),false);      Data myData(1.3,viewShape,FunctionSpace(),false);
649      myData.tag();      myData.tag();
650    
     //cout << myData.toString() << endl;  
   
651      assert(!myData.isEmpty());      assert(!myData.isEmpty());
652      assert(myData.isTagged());      assert(myData.isTagged());
653      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
# Line 636  void DataTestCase::testDataTagged() { Line 655  void DataTestCase::testDataTagged() {
655      assert(myData.getLength()==6);      assert(myData.getLength()==6);
656    
657      // check default value      // check default value
658      DataArrayView myDataView = myData.getPointDataView();      assert(!myData.isEmpty());
659      assert(!myDataView.isEmpty());      assert(myData.getDataPointRank()==2);
660      assert(myDataView.getOffset()==0);      assert(myData.getNoValues()==6);
661      assert(myDataView.getRank()==2);      assert(myData.getDataPointShape().size()==2);
662      assert(myDataView.noValues()==6);      assert(getRef(myData,0,0)==1.3);
663      assert(myDataView.getShape().size()==2);      assert(getRef(myData,0,1)==1.3);
664      assert(myDataView(0,0)==1.3);      assert(getRef(myData,0,2)==1.3);
665      assert(myDataView(0,1)==1.3);      assert(getRef(myData,1,0)==1.3);
666      assert(myDataView(0,2)==1.3);      assert(getRef(myData,1,1)==1.3);
667      assert(myDataView(1,0)==1.3);      assert(getRef(myData,1,2)==1.3);
     assert(myDataView(1,1)==1.3);  
     assert(myDataView(1,2)==1.3);  
668    
669      // check value for data-point (0,0).      // check value for data-point (0,0).
670      myDataView = myData.getDataPoint(0,0);  //     myDataView = myData.getDataPoint(0,0);
671      assert(!myDataView.isEmpty());      assert(!myData.isEmpty());
672      assert(myDataView.getOffset()==0);  //     assert(myDataView.getOffset()==0);
673      assert(myDataView.getRank()==2);      assert(myData.getDataPointRank()==2);
674      assert(myDataView.noValues()==6);      assert(myData.getNoValues()==6);
675      assert(myDataView.getShape().size()==2);      assert(myData.getDataPointShape().size()==2);
676      assert(myDataView(0,0)==1.3);      assert(getRef(myData,0,0)==1.3);
677      assert(myDataView(0,1)==1.3);      assert(getRef(myData,0,1)==1.3);
678      assert(myDataView(0,2)==1.3);      assert(getRef(myData,0,2)==1.3);
679      assert(myDataView(1,0)==1.3);      assert(getRef(myData,1,0)==1.3);
680      assert(myDataView(1,1)==1.3);      assert(getRef(myData,1,1)==1.3);
681      assert(myDataView(1,2)==1.3);      assert(getRef(myData,1,2)==1.3);
682    
683    }    }
684    
# Line 674  void DataTestCase::testDataTaggedExcepti Line 691  void DataTestCase::testDataTaggedExcepti
691    cout << "\tTest DataTagged exceptions." << endl;    cout << "\tTest DataTagged exceptions." << endl;
692    
693    Data myData;    Data myData;
   DataArrayView myView;  
694    
695    try {    try {
696        myData.getSampleDataByTag(0);;        myData.getSampleDataByTag(0);;
697        assert(false);        assert(false);
698    }    }
699    catch (EsysException& e) {    catch (EsysException&) {
700        //cout << e.what() << endl;        //cout << e.what() << endl;
701        assert(true);        assert(true);
702    }    }
703    
704    try {    try {
705        myData.setTaggedValueFromCPP(0,myView);;        myData.setTaggedValueFromCPP(0,DataTypes::ShapeType(), DataTypes::ValueType());;
706        assert(false);        assert(false);
707    }    }
708    catch (EsysException& e) {    catch (EsysException&) {
709        //cout << e.what() << endl;        //cout << e.what() << endl;
710        assert(true);        assert(true);
711    }    }
# Line 700  void DataTestCase::testConstructors() { Line 716  void DataTestCase::testConstructors() {
716    
717    cout << endl;    cout << endl;
718    
719    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
720    {    {
721      cout << "\tCreate an Empty Data object" << endl;      cout << "\tCreate an Empty Data object" << endl;
722      Data temp(1.3,viewShape,FunctionSpace(),false);      Data temp(1.3,viewShape,FunctionSpace(),false);
# Line 713  void DataTestCase::testConstructors() { Line 729  void DataTestCase::testConstructors() {
729    }    }
730  }  }
731    
732  void DataTestCase::testOperations() {  
733    void DataTestCase::testOperations()
734    {
735    
736    cout << endl;    cout << endl;
737    
738    // define the shape for the DataArrayView test data    // define the shape for the test data
739    DataArrayView::ShapeType shape;    DataTypes::ShapeType shape;
740    shape.push_back(2);    shape.push_back(2);
741    shape.push_back(3);    shape.push_back(3);
742    
743    // allocate the data for the DataArrayView    // allocate the data
744    DataArrayView::ValueType data(DataArrayView::noValues(shape),0);    DataTypes::ValueType data(DataTypes::noValues(shape),0);
   
   // construct DataArrayView  
   DataArrayView dataView(data,shape);  
745    
746    // assign values to the data    // assign values to the data
747    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
748      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
749        dataView(i,j)=dataView.index(i,j);        data[getRelIndex(shape,i,j)]=getRelIndex(shape,i,j);
750      }      }
751    }    }
752    
753    Data baseEx(dataView,FunctionSpace(),true);  
754    Data baseCon(dataView,FunctionSpace(),false);  
755    Data baseTag(dataView,FunctionSpace(),false);    Data dats[]={Data(data,shape,FunctionSpace(),false),
756            Data(data,shape,FunctionSpace(),false),
757            Data(data,shape,FunctionSpace(),true),
758            Data(data,shape,FunctionSpace(),false),
759            Data(data,shape,FunctionSpace(),false),
760            Data(data,shape,FunctionSpace(),true)};
761      const int NUMDATS=6;
762      const int LAZY=3;     // where do the lazy objects start?
763    
764    //   Data baseEx(data,shape,FunctionSpace(),true);
765    //   Data baseCon(data,shape,FunctionSpace(),false);
766    //   Data baseTag(data,shape,FunctionSpace(),false);
767      Data& baseCon=dats[0];
768      Data& baseTag=dats[1];
769      Data& baseEx=dats[2];
770    baseTag.tag();    baseTag.tag();
771      dats[4].tag();
772      dats[3].delaySelf();
773      dats[4].delaySelf();
774      dats[5].delaySelf();
775    
776    assert(baseEx.isExpanded());    assert(baseEx.isExpanded());
777    assert(baseCon.isConstant());    assert(baseCon.isConstant());
778    assert(baseTag.isTagged());    assert(baseTag.isTagged());
779    
780    Data resultEx;    Data results[NUMDATS];
781    Data resultCon;  //   Data& resultEx=results[0];
782    Data resultTag;  //   Data& resultCon=results[1];
783    //   Data& resultTag=results[2];
784    
785      // create 0 <= smalldata <= 1 for testing trig functions
786    
787      DataTypes::ValueType smalldata(DataTypes::noValues(shape),0);
788    
789      // assign values to the data
790      for (int i=0;i<shape[0];i++) {
791        for (int j=0;j<shape[1];j++) {
792          smalldata[getRelIndex(shape,i,j)]=(i==0 && j==0)?0:1.0/(getRelIndex(shape,i,j)+1);
793        }
794      }
795      Data sdats[]={Data(smalldata,shape,FunctionSpace(),false),
796            Data(smalldata,shape,FunctionSpace(),false),
797            Data(smalldata,shape,FunctionSpace(),true),
798            Data(smalldata,shape,FunctionSpace(),false),
799            Data(smalldata,shape,FunctionSpace(),false),
800            Data(smalldata,shape,FunctionSpace(),true)};
801      sdats[1].tag();
802      sdats[4].tag();
803      sdats[3].delaySelf();
804      sdats[4].delaySelf();
805      sdats[5].delaySelf();
806    
807    
808    
809    // test unary operations    // test unary operations
810    
811    double tmp;    double tmp;
812    cout << "\tTest Data::pow." << endl;    cout << "\tTest Data::pow." << endl;
813    Data power(3.0,shape,FunctionSpace(),true);    Data power(3.0,shape,FunctionSpace(),true);
814    resultEx.copy(baseEx.powD(power));    for (int z=0;z<NUMDATS;++z)
815    resultCon.copy(baseCon.powD(power));    {
816    resultTag.copy(baseTag.powD(power));      results[z].copy(dats[z].powD(power));
817        if (z>=LAZY)
818        {
819        assert(results[z].isLazy());
820        }
821      }
822    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
823      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
824        tmp=pow(dataView.index(i,j),3.0);        tmp=pow((double)data[getRelIndex(shape,i,j)],(double)3.0);
825        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
826        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
827        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
828          }
829      }      }
830    }    }
831    
832    cout << "\tTest Data::sin." << endl;    cout << "\tTest Data::sin." << endl;
833    resultEx.copy(baseEx.sin());    for (int z=0;z<NUMDATS;++z)
834    resultCon.copy(baseCon.sin());    {
835    resultTag.copy(baseTag.sin());      results[z].copy(dats[z].sin());
836        if (z>=LAZY)
837        {
838        assert(results[z].isLazy());
839        }
840      }
841    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
842      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
843        tmp=sin((double)dataView.index(i,j));        tmp=sin((double)data[getRelIndex(shape,i,j)]);
844        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
845        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
846        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
847          }
848      }      }
849    }    }
850    
851    cout << "\tTest Data::cos." << endl;    cout << "\tTest Data::cos." << endl;
852    resultEx.copy(baseEx.cos());    for (int z=0;z<NUMDATS;++z)
853    resultCon.copy(baseCon.cos());    {
854    resultTag.copy(baseTag.cos());      results[z].copy(dats[z].cos());
855        if (z>=LAZY)
856        {
857        assert(results[z].isLazy());
858        }
859      }
860    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
861      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
862        tmp=cos((double)dataView.index(i,j));        tmp=cos((double)data[getRelIndex(shape,i,j)]);
863        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
864        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
865        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
866          }
867      }      }
868    }    }
869    
870    cout << "\tTest Data::tan." << endl;    cout << "\tTest Data::tan." << endl;
871    resultEx.copy(baseEx.tan());    for (int z=0;z<NUMDATS;++z)
872    resultCon.copy(baseCon.tan());    {
873    resultTag.copy(baseTag.tan());      results[z].copy(dats[z].tan());
874        if (z>=LAZY)
875        {
876        assert(results[z].isLazy());
877        }
878      }
879    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
880      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
881        tmp=tan((double)dataView.index(i,j));        tmp=tan((double)data[getRelIndex(shape,i,j)]);
882        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
883        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
884        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
885          }
886      }      }
887    }    }
888    
889    cout << "\tTest Data::asin." << endl;    cout << "\tTest Data::asin." << endl;
890    resultEx.copy(baseEx.asin());    for (int z=0;z<NUMDATS;++z)
891    resultCon.copy(baseCon.asin());    {
892    resultTag.copy(baseTag.asin());      results[z].copy(sdats[z].asin());
893    assert(true);      if (z>=LAZY)
894        {
895        assert(results[z].isLazy());
896        }
897      }
898      for (int i=0;i<shape[0];i++) {
899        for (int j=0;j<shape[1];j++) {
900          tmp=asin((double)smalldata[getRelIndex(shape,i,j)]);
901          for (int z=0;z<NUMDATS;++z)
902          {
903        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
904          }
905        }
906      }
907    
908    cout << "\tTest Data::acos." << endl;    cout << "\tTest Data::acos." << endl;
909    resultEx.copy(baseEx.acos());    for (int z=0;z<NUMDATS;++z)
910    resultCon.copy(baseCon.acos());    {
911    resultTag.copy(baseTag.acos());      results[z].copy(sdats[z].acos());
912    assert(true);      if (z>=LAZY)
913        {
914        assert(results[z].isLazy());
915        }
916      }
917      for (int i=0;i<shape[0];i++) {
918        for (int j=0;j<shape[1];j++) {
919          tmp=acos((double)smalldata[getRelIndex(shape,i,j)]);
920          for (int z=0;z<NUMDATS;++z)
921          {
922        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
923          }
924        }
925      }
926    
927    cout << "\tTest Data::atan." << endl;    cout << "\tTest Data::atan." << endl;
928    resultEx.copy(baseEx.atan());    for (int z=0;z<NUMDATS;++z)
929    resultCon.copy(baseCon.atan());    {
930    resultTag.copy(baseTag.atan());      results[z].copy(sdats[z].atan());
931        if (z>=LAZY)
932        {
933        assert(results[z].isLazy());
934        }
935      }
936    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
937      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
938        tmp=atan((double)dataView.index(i,j));        tmp=atan((double)smalldata[getRelIndex(shape,i,j)]);
939        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
940        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
941        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
942          }
943      }      }
944    }    }
945    
946    cout << "\tTest Data::sinh." << endl;    cout << "\tTest Data::sinh." << endl;
947    resultEx.copy(baseEx.sinh());    for (int z=0;z<NUMDATS;++z)
948    resultCon.copy(baseCon.sinh());    {
949    resultTag.copy(baseTag.sinh());      results[z].copy(dats[z].sinh());
950        if (z>=LAZY)
951        {
952        assert(results[z].isLazy());
953        }
954      }
955    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
956      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
957        tmp=sinh((double)dataView.index(i,j));        tmp=sinh((double)data[getRelIndex(shape,i,j)]);
958        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
959        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
960        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
961          }
962      }      }
963    }    }
964    
965    cout << "\tTest Data::cosh." << endl;    cout << "\tTest Data::cosh." << endl;
966    resultEx.copy(baseEx.cosh());    for (int z=0;z<NUMDATS;++z)
967    resultCon.copy(baseCon.cosh());    {
968    resultTag.copy(baseTag.cosh());      results[z].copy(dats[z].cosh());
969        if (z>=LAZY)
970        {
971        assert(results[z].isLazy());
972        }
973      }
974    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
975      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
976        tmp=cosh((double)dataView.index(i,j));        tmp=cosh((double)data[getRelIndex(shape,i,j)]);
977        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
978        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
979        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
980          }
981      }      }
982    }    }
983    
984    cout << "\tTest Data::tanh." << endl;    cout << "\tTest Data::tanh." << endl;
985    resultEx.copy(baseEx.tanh());    for (int z=0;z<NUMDATS;++z)
986    resultCon.copy(baseCon.tanh());    {
987    resultTag.copy(baseTag.tanh());      results[z].copy(dats[z].tanh());
988        if (z>=LAZY)
989        {
990        assert(results[z].isLazy());
991        }
992      }
993    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
994      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
995        tmp=tanh((double)dataView.index(i,j));        tmp=tanh((double)data[getRelIndex(shape,i,j)]);
996        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
997        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
998        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
999          }
1000      }      }
1001    }    }
1002    
1003      // rather than accomodate the different windows operations directly I'll just use inverse functions
1004    cout << "\tTest Data::asinh." << endl;    cout << "\tTest Data::asinh." << endl;
1005    resultEx.copy(baseEx.asinh());    for (int z=0;z<NUMDATS;++z)
1006    resultCon.copy(baseCon.asinh());    {
1007    resultTag.copy(baseTag.asinh());      results[z].copy(dats[z].asinh().sinh());
1008    assert(true);      if (z>=LAZY)
1009        {
1010        assert(results[z].isLazy());
1011        }
1012      }
1013      for (int i=0;i<shape[0];i++) {
1014        for (int j=0;j<shape[1];j++) {
1015          tmp=data[getRelIndex(shape,i,j)];
1016          for (int z=0;z<NUMDATS;++z)
1017          {
1018        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1019          }
1020        }
1021      }
1022    
1023    cout << "\tTest Data::acosh." << endl;    cout << "\tTest Data::acosh." << endl;
1024    resultEx.copy(baseEx.acosh());    for (int z=0;z<NUMDATS;++z)
1025    resultCon.copy(baseCon.acosh());    {
1026    resultTag.copy(baseTag.acosh());      results[z].copy(dats[z].acosh().cosh());
1027    assert(true);      if (z>=LAZY)
1028        {
1029        assert(results[z].isLazy());
1030        }
1031      }
1032      for (int i=0;i<shape[0];i++) {
1033        for (int j=0;j<shape[1];j++) {
1034          if (i==0 && j==0) break;
1035          tmp=data[getRelIndex(shape,i,j)];
1036          for (int z=0;z<NUMDATS;++z)
1037          {
1038        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1039          }
1040        }
1041      }
1042    
1043    cout << "\tTest Data::atanh." << endl;    cout << "\tTest Data::atanh." << endl;
1044    resultEx.copy(baseEx.atanh());    for (int z=0;z<NUMDATS;++z)
1045    resultCon.copy(baseCon.atanh());    {
1046    resultTag.copy(baseTag.atanh());      results[z].copy(dats[z].tanh().atanh());        // if these are the other way around the results are
1047    assert(true);      if (z>=LAZY)                    // undefined
1048        {
1049        assert(results[z].isLazy());
1050        }
1051      }
1052      for (int i=0;i<shape[0];i++) {
1053        for (int j=0;j<shape[1];j++) {
1054          tmp=data[getRelIndex(shape,i,j)];
1055          for (int z=0;z<NUMDATS;++z)
1056          {
1057        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1058          }
1059        }
1060      }
1061    
1062    cout << "\tTest Data::log." << endl;    cout << "\tTest Data::log." << endl;
1063    resultEx.copy(baseEx.log());    for (int z=0;z<NUMDATS;++z)
1064    resultCon.copy(baseCon.log());    {
1065    resultTag.copy(baseTag.log());      results[z].copy(dats[z].log());
1066    assert(true);      if (z>=LAZY)
1067        {
1068        assert(results[z].isLazy());
1069        }
1070      }
1071      for (int i=0;i<shape[0];i++) {
1072        for (int j=0;j<shape[1];j++) {
1073          if (i==0 && j==0) break;
1074          tmp=log((double)data[getRelIndex(shape,i,j)]);
1075          for (int z=0;z<NUMDATS;++z)
1076          {
1077        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1078          }
1079        }
1080      }
1081    
1082      cout << "\tTest Data::log10." << endl;
1083      for (int z=0;z<NUMDATS;++z)
1084      {
1085        results[z].copy(dats[z].log10());
1086        if (z>=LAZY)
1087        {
1088        assert(results[z].isLazy());
1089        }
1090      }
1091      for (int i=0;i<shape[0];i++) {
1092        for (int j=0;j<shape[1];j++) {
1093          if (i==0 && j==0) break;
1094          tmp=log10((double)data[getRelIndex(shape,i,j)]);
1095          for (int z=0;z<NUMDATS;++z)
1096          {
1097        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1098          }
1099        }
1100      }
1101    #ifndef _WIN32
1102      cout << "\tTest Data::erf." << endl;
1103      for (int z=0;z<NUMDATS;++z)
1104      {
1105        results[z].copy(dats[z].erf());
1106        if (z>=LAZY)
1107        {
1108        assert(results[z].isLazy());
1109        }
1110      }
1111      for (int i=0;i<shape[0];i++) {
1112        for (int j=0;j<shape[1];j++) {
1113          if (i==0 && j==0) break;
1114          tmp=erf((double)data[getRelIndex(shape,i,j)]);
1115          for (int z=0;z<NUMDATS;++z)
1116          {
1117        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1118          }
1119        }
1120      }
1121    #endif
1122    
1123    
1124    cout << "\tTest Data::abs." << endl;    cout << "\tTest Data::abs." << endl;
1125    resultEx.copy(baseEx.abs());    for (int z=0;z<NUMDATS;++z)
1126    resultCon.copy(baseCon.abs());    {
1127    resultTag.copy(baseTag.abs());      results[z].copy(dats[z].abs());
1128        if (z>=LAZY)
1129        {
1130        assert(results[z].isLazy());
1131        }
1132      }
1133    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1134      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
1135        tmp=abs((double)dataView.index(i,j));        tmp=abs((double)data[getRelIndex(shape,i,j)]);
1136        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
1137        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
1138        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1139          }
1140      }      }
1141    }    }
1142    
1143    cout << "\tTest Data::sign." << endl;    cout << "\tTest Data::sign (positive)." << endl;
1144    resultEx.copy(baseEx.sign());    for (int z=0;z<NUMDATS;++z)
1145    resultCon.copy(baseCon.sign());    {
1146    resultTag.copy(baseTag.sign());      results[z].copy(dats[z].sign());
1147    assert(true);      if (z>=LAZY)
1148        {
1149        assert(results[z].isLazy());
1150        }
1151      }
1152      for (int i=0;i<shape[0];i++) {
1153        for (int j=0;j<shape[1];j++) {
1154          tmp=(i==0 && j==0)?0:1;
1155          for (int z=0;z<NUMDATS;++z)
1156          {
1157        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1158          }
1159        }
1160      }
1161    
1162      cout << "\tTest Data::sign (negative)." << endl;
1163      for (int z=0;z<NUMDATS;++z)
1164      {
1165        results[z].copy(dats[z].neg().sign());
1166        if (z>=LAZY)
1167        {
1168        assert(results[z].isLazy());
1169        }
1170      }
1171      for (int i=0;i<shape[0];i++) {
1172        for (int j=0;j<shape[1];j++) {
1173          tmp=(i==0 && j==0)?0:-1;
1174          for (int z=0;z<NUMDATS;++z)
1175          {
1176        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1177          }
1178        }
1179      }
1180    
1181    
1182    cout << "\tTest Data::exp." << endl;    cout << "\tTest Data::exp." << endl;
1183    resultEx.copy(baseEx.exp());    for (int z=0;z<NUMDATS;++z)
1184    resultCon.copy(baseCon.exp());    {
1185    resultTag.copy(baseTag.exp());      results[z].copy(dats[z].exp());
1186        if (z>=LAZY)
1187        {
1188        assert(results[z].isLazy());
1189        }
1190      }
1191    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1192      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
1193        tmp=exp((double)dataView.index(i,j));        tmp=exp((double)data[getRelIndex(shape,i,j)]);
1194        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
1195        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
1196        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1197          }
1198      }      }
1199    }    }
1200    
1201    cout << "\tTest Data::sqrt." << endl;    cout << "\tTest Data::sqrt." << endl;
1202    resultEx.copy(baseEx.sqrt());    for (int z=0;z<NUMDATS;++z)
1203    resultCon.copy(baseCon.sqrt());    {
1204    resultTag.copy(baseTag.sqrt());      results[z].copy(dats[z].sqrt());
1205        if (z>=LAZY)
1206        {
1207        assert(results[z].isLazy());
1208        }
1209      }
1210    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1211      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
1212        tmp=sqrt((double)dataView.index(i,j));        tmp=sqrt((double)data[getRelIndex(shape,i,j)]);
1213        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
1214        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
1215        assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1216          }
1217      }      }
1218    }    }
1219    
1220    cout << "\tTest Data::neg." << endl;    cout << "\tTest Data::neg." << endl;
1221    resultEx.copy(baseEx.neg());    for (int z=0;z<NUMDATS;++z)
1222    resultCon.copy(baseCon.neg());    {
1223    resultTag.copy(baseTag.neg());      results[z].copy(dats[z].neg());
1224    assert(true);      if (z>=LAZY)
1225        {
1226        assert(results[z].isLazy());
1227        }
1228      }
1229      for (int i=0;i<shape[0];i++) {
1230        for (int j=0;j<shape[1];j++) {
1231          tmp=-data[getRelIndex(shape,i,j)];
1232          for (int z=0;z<NUMDATS;++z)
1233          {
1234        assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1235          }
1236        }
1237      }
1238    
1239    cout << "\tTest Data::pos." << endl;    cout << "\tTest Data::pos." << endl;
1240    resultEx.copy(baseEx.pos());    for (int z=0;z<NUMDATS;++z)
1241    resultCon.copy(baseCon.pos());    {
1242    resultTag.copy(baseTag.pos());      results[z].copy(dats[z].pos());
1243        if (z>=LAZY)
1244        {
1245        assert(results[z].isLazy());
1246        }
1247      }
1248    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1249      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
1250        assert(std::abs(resultEx.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));        for (int z=0;z<NUMDATS;++z)
1251        assert(std::abs(resultCon.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));        {
1252        assert(std::abs(resultTag.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));      assert(std::abs(getRef(results[z],i,j) - getRelIndex(shape,i,j)) <= REL_TOL*std::abs(data[getRelIndex(shape,i,j)]));
1253          }
1254      }      }
1255    }    }
1256    
1257    // test reduction operations    // test reduction operations
1258    
1259    cout << "\tTest Data::Lsup." << endl;    cout << "\tTest Data::Lsup." << endl;
1260    assert(std::abs(baseEx.Lsup() - 5) <= REL_TOL*5);    for (int z=0;z<NUMDATS;++z)
1261    assert(std::abs(baseCon.Lsup() - 5) <= REL_TOL*5);    {
1262    assert(std::abs(baseTag.Lsup() - 5) <= REL_TOL*5);      assert(std::abs(dats[z].Lsup() - 5) <= REL_TOL*5);
1263      }
1264    
1265    cout << "\tTest Data::sup." << endl;    cout << "\tTest Data::sup." << endl;
1266    assert(std::abs(baseEx.sup() - 5) <= REL_TOL*5);    for (int z=0;z<NUMDATS;++z)
1267    assert(std::abs(baseCon.sup() - 5) <= REL_TOL*5);    {
1268    assert(std::abs(baseTag.sup() - 5) <= REL_TOL*5);      assert(std::abs(dats[z].sup() - 5) <= REL_TOL*5);
1269      }
1270    
1271    cout << "\tTest Data::inf." << endl;    cout << "\tTest Data::inf." << endl;
1272    assert(std::abs(baseEx.inf() - 0) <= REL_TOL*0);    for (int z=0;z<NUMDATS;++z)
1273    assert(std::abs(baseCon.inf() - 0) <= REL_TOL*0);    {
1274    assert(std::abs(baseTag.inf() - 0) <= REL_TOL*0);      assert(std::abs(dats[z].inf() - 0) <= REL_TOL*0);
1275      }
1276    
1277    // test data-point reduction operations    // test data-point reduction operations
1278    
1279    cout << "\tTest Data::minval." << endl;    cout << "\tTest Data::minval." << endl;
1280    resultEx.copy(baseEx.minval());    for (int z=0;z<NUMDATS;++z)
1281    resultCon.copy(baseCon.minval());    {
1282    resultTag.copy(baseTag.minval());      results[z].copy(dats[z].minval());
1283    assert(std::abs(resultEx.getPointDataView()() - 0) <= REL_TOL*0);    }
1284    assert(std::abs(resultCon.getPointDataView()() - 0) <= REL_TOL*0);    for (int z=0;z<NUMDATS;++z)
1285    assert(std::abs(resultTag.getPointDataView()() - 0) <= REL_TOL*0);    {
1286        assert(std::abs(results[z].getDataAtOffset(0) - 0) <= REL_TOL*0);
1287      }
1288      
1289    
1290    cout << "\tTest Data::maxval." << endl;    cout << "\tTest Data::maxval." << endl;
1291    resultEx.copy(baseEx.maxval());    for (int z=0;z<NUMDATS;++z)
1292    resultCon.copy(baseCon.maxval());    {
1293    resultTag.copy(baseTag.maxval());      results[z].copy(dats[z].maxval());
1294    assert(std::abs(resultEx.getPointDataView()() - 5) <= REL_TOL*5);    }
1295    assert(std::abs(resultCon.getPointDataView()() - 5) <= REL_TOL*5);    for (int z=0;z<NUMDATS;++z)
1296    assert(std::abs(resultTag.getPointDataView()() - 5) <= REL_TOL*5);    {
1297        assert(std::abs(results[z].getDataAtOffset(0) - 5) <= REL_TOL*5);
1298      }
1299    
1300    }
1301    
1302    
1303    // Here we test the binary operators in complex expressions
1304    void DataTestCase::testBinary()
1305    {
1306    
1307      cout << endl;
1308    
1309      // define the shape for the test data
1310      DataTypes::ShapeType shape;
1311      shape.push_back(2);
1312      shape.push_back(3);
1313    
1314      // allocate the data
1315      DataTypes::ValueType data(DataTypes::noValues(shape),0);
1316    
1317      // assign values to the data
1318      for (int i=0;i<shape[0];i++) {
1319        for (int j=0;j<shape[1];j++) {
1320          data[getRelIndex(shape,i,j)]=getRelIndex(shape,i,j)+2;    // so we get no zeros
1321        }
1322      }
1323    
1324    
1325      Data one(1.0,DataTypes::scalarShape,FunctionSpace());
1326      Data two(2.0,DataTypes::scalarShape,FunctionSpace());
1327      Data dats[]={Data(data,shape,FunctionSpace(),false),
1328            Data(data,shape,FunctionSpace(),false),
1329            Data(data,shape,FunctionSpace(),true),
1330            Data(data,shape,FunctionSpace(),false),
1331            Data(data,shape,FunctionSpace(),false),
1332            Data(data,shape,FunctionSpace(),true)};
1333      dats[1].tag();
1334      dats[4].tag();
1335      const int NUMDATS=6;
1336      const int LAZY=3;
1337      dats[3].delaySelf();
1338      dats[4].delaySelf();
1339      dats[5].delaySelf();
1340      for (int z=0;z<NUMDATS;++z)
1341      {
1342        Data& a=dats[z];
1343        Data r1=(((a+a)/two)+a-a)*one;  // scalar/*, matrix+-
1344        Data r2=(((a*a)/a+one)-one);    // scalar+-, matrix*/
1345        Data r3=(a.powD(two)/a.powD(one)); // scalar power
1346        Data r4=a.powD(a);      // matrix power
1347        if (z>LAZY)
1348        {
1349          assert(r1.isLazy() && r2.isLazy() && r3.isLazy() && r4.isLazy());
1350        }
1351        for (int i=0;i<DataTypes::noValues(shape);++i)
1352        {
1353          assert(std::abs(r1.getDataAtOffset(i)-data[i]) <= REL_TOL*data[i]);
1354          assert(std::abs(r2.getDataAtOffset(i)-data[i]) <= REL_TOL*data[i]);
1355          assert(std::abs(r3.getDataAtOffset(i)-data[i]) <= REL_TOL*data[i]);
1356          assert(std::abs(r4.getDataAtOffset(i)-pow(data[i],i)) <=REL_TOL*pow(data[i],i));
1357        }
1358      }
1359  }  }
1360    
1361    
# Line 1002  void DataTestCase::testMemAlloc() { Line 1368  void DataTestCase::testMemAlloc() {
1368    
1369    Data *testData;    Data *testData;
1370    for (int i=0; i<1000; i++) {    for (int i=0; i<1000; i++) {
1371      testData = new Data(0.0, DataArrayView::ShapeType(), FunctionSpace(), true);      testData = new Data(0.0, DataTypes::ShapeType(), FunctionSpace(), true);
1372      delete testData;      delete testData;
1373    }    }
1374    
1375    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
1376    viewShape.push_back(10);    viewShape.push_back(10);
1377    viewShape.push_back(10);    viewShape.push_back(10);
1378    viewShape.push_back(10);    viewShape.push_back(10);
# Line 1026  TestSuite* DataTestCase::suite () Line 1392  TestSuite* DataTestCase::suite ()
1392    //    //
1393    // create the suite of tests to perform.    // create the suite of tests to perform.
1394    TestSuite *testSuite = new TestSuite ("DataTestCase");    TestSuite *testSuite = new TestSuite ("DataTestCase");
1395      testSuite->addTest (new TestCaller< DataTestCase>("testCopying",&DataTestCase::testCopying));
1396    testSuite->addTest (new TestCaller< DataTestCase>("testAll",&DataTestCase::testAll));    testSuite->addTest (new TestCaller< DataTestCase>("testSome",&DataTestCase::testSome));
   testSuite->addTest (new TestCaller< DataTestCase>("testMore",&DataTestCase::testMore));  
1397    testSuite->addTest (new TestCaller< DataTestCase>("testDataConstant",&DataTestCase::testDataConstant));    testSuite->addTest (new TestCaller< DataTestCase>("testDataConstant",&DataTestCase::testDataConstant));
1398    testSuite->addTest (new TestCaller< DataTestCase>("testDataTagged",&DataTestCase::testDataTagged));    testSuite->addTest (new TestCaller< DataTestCase>("testDataTagged",&DataTestCase::testDataTagged));
1399    testSuite->addTest (new TestCaller< DataTestCase>("testDataTaggedExceptions",&DataTestCase::testDataTaggedExceptions));    testSuite->addTest (new TestCaller< DataTestCase>("testDataTaggedExceptions",&DataTestCase::testDataTaggedExceptions));
# Line 1037  TestSuite* DataTestCase::suite () Line 1402  TestSuite* DataTestCase::suite ()
1402    testSuite->addTest (new TestCaller< DataTestCase>("testOperations",&DataTestCase::testOperations));    testSuite->addTest (new TestCaller< DataTestCase>("testOperations",&DataTestCase::testOperations));
1403    //testSuite->addTest (new TestCaller< DataTestCase>("testRefValue",&DataTestCase::testRefValue));    //testSuite->addTest (new TestCaller< DataTestCase>("testRefValue",&DataTestCase::testRefValue));
1404    testSuite->addTest (new TestCaller< DataTestCase>("testMemAlloc",&DataTestCase::testMemAlloc));    testSuite->addTest (new TestCaller< DataTestCase>("testMemAlloc",&DataTestCase::testMemAlloc));
1405      testSuite->addTest (new TestCaller< DataTestCase>("Resolving",&DataTestCase::testResolveType));
1406    
1407    return testSuite;    return testSuite;
1408  }  }

Legend:
Removed from v.1026  
changed lines
  Added in v.2037

  ViewVC Help
Powered by ViewVC 1.1.26