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

Legend:
Removed from v.1811  
changed lines
  Added in v.2005

  ViewVC Help
Powered by ViewVC 1.1.26