/[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 2005 by jfenwick, Mon Nov 10 01:21:39 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      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 set-slicing DataTagged" << endl;      {
288        if (delayed)
289      //      {
290      // create a source DataTagged with a scalar default value only        Data* temp=dats[k];
291          dats[k]=new Data(dats[k]->delay());   // coz delay returns an object not a pointer
292      DataArrayView::ShapeType viewShape;        delete temp;
293      Data source(10.0,viewShape,FunctionSpace(),false);        temp=src[k];
294      source.tag();        src[k]=new Data(src[k]->delay());
295          delete temp;
296      //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;  
297      }      }
298      DataArrayView dataView(viewData,viewShape);    }
299      for (int k=0;k<NUMDATS;++k)
300      target.setTaggedValueFromCPP(1, dataView);    {
301        cout << "\t\tTest set-slicing " << strs[k] << endl;
302      //cout << "target:\n" << target.toString() << endl;      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      //    //
314      // set a slice in target from source    // add a value for tag "1" to target
315    
316      region.clear();    DataTypes::ValueType viewData(6);
317      region.push_back(DataArrayView::RegionType::value_type(0,0));    for (int i=0;i<viewData.size();i++) {
318      region.push_back(DataArrayView::RegionType::value_type(1,1));      viewData[i]=i;
319      }
320    
321      target.setSlice(source,region);    Data target(1.3,viewShape,FunctionSpace(),false);
322      target.tag();
323      target.setTaggedValueFromCPP(1, viewShape, viewData);
324    
325      //cout << "target:\n" << target.toString() << endl;      //cout << "target:\n" << target.toString() << endl;
326    
     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);  
   
327      //      //
328      // 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);  
329    
330      //cout << "source:\n" << source.toString() << endl;    DataTypes::RegionType region;
331      region.push_back(DataTypes::RegionType::value_type(0,0));
332      region.push_back(DataTypes::RegionType::value_type(1,1));
333    
334      target.setSlice(*src[1],region);
335    
336      assert(target.isTagged());
337      assert(target.getDataPointRank()==2);
338      assert(getRef(target,0,0,0,0)==0);
339      assert(getRef(target,0,0,0,1)==src[1]->getDataPoint(0,0));
340      assert(getRef(target,0,0,0,2)==4);
341      assert(getRef(target,0,0,1,0)==1);
342      assert(getRef(target,0,0,1,1)==3);
343      assert(getRef(target,0,0,1,2)==5);
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(DataArrayView::RegionType::value_type(0,0));    DataTypes::ValueType viewData2(1);
350      region.push_back(DataArrayView::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;  
   
     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);  
   
   }  
387    
388      for (int k=0;k<NUMDATS;++k)
389    {    {
390        delete dats[k];
391      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;  
392    }    }
   DataArrayView myView(viewData,viewShape);  
393    
394    bool expanded=true;   }
   Data exData(myView,FunctionSpace(),expanded);  
   Data cData(myView);  
   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    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
421    viewShape.push_back(3);    viewShape.push_back(3);
422    DataArrayView::ValueType viewData(3);    DataTypes::ValueType viewData(3);
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(myView,FunctionSpace(),expanded);    Data exData(viewData,viewShape,FunctionSpace(),expanded);
429    Data cData(myView);    Data cData(viewData,viewShape);
430    Data result;    Data result;
431    
432    assert(exData.isExpanded());    assert(exData.isExpanded());
# Line 484  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    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
541    viewShape.push_back(2);    viewShape.push_back(2);
542    viewShape.push_back(3);    viewShape.push_back(3);
543    viewShape.push_back(4);    viewShape.push_back(4);
544    DataArrayView::ValueType viewData(2*3*4);    DataTypes::ValueType viewData(2*3*4);
545    for (int i=0;i<DataArrayView::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(myView);    Data left(viewData,viewShape);
550    Data right(myView);    Data right(viewData,viewShape);
551    Data result;    Data result;
552    
553    cout << "\tTest some basic operations" << endl;    cout << "\tTest some basic operations" << endl;
# Line 531  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    
580      DataTagged::TagListType keys;      DataTypes::ShapeType viewShape;
   
     DataTagged::ValueListType values;  
   
     DataArrayView::ShapeType viewShape;  
581      viewShape.push_back(3);      viewShape.push_back(3);
582    
583      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
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      }      }
587      DataArrayView defaultValue(viewData,viewShape);      int arr[1]={1};     // iso c++ does not like empty arrays
588        DataTagged* dt=new DataTagged(FunctionSpace(),viewShape,arr,viewData);
589      bool expanded=false;      Data myData(dt);
     
     Data myData(keys,values,defaultValue,FunctionSpace(),expanded);  
   
     // cout << myData.toString() << endl;  
590    
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);
594      assert(myData.getDataPointRank()==1);      assert(myData.getDataPointRank()==1);
595      assert(myData.getLength()==3);      assert(myData.getLength()==3);
596        
597      DataArrayView myDataView = myData.getPointDataView();      assert(myData.getNoValues()==3);
598      assert(!myDataView.isEmpty());      assert(myData.getDataAtOffset(0)==0.0);
599      assert(myDataView.getOffset()==0);      assert(myData.getDataAtOffset(1)==1.0);
600      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);  
601    
602      double* sampleData=myData.getSampleData(0);      double* sampleData=myData.getSampleData(0);
603      for (int i=0; i<myDataView.noValues(); i++) {      for (int i=0; i<myData.getNoValues(); i++) {
604        assert(sampleData[i]==i);        assert(sampleData[i]==i);
605      }      }
606      // 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 613  void DataTestCase::testDataTagged() {
613      cout << "\tTest setting of a tag and associated value." << endl;      cout << "\tTest setting of a tag and associated value." << endl;
614    
615      // value for tag "1"      // value for tag "1"
616      DataArray eTwo(defaultValue);      DataTypes::ValueType eTwoData(viewData);
617      for (int i=0;i<eTwo.getView().getShape()[0];i++) {   //   DataArrayView eTwoView(eTwoData, viewShape);
618        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
619          eTwoData[i]=i+2.0;
620      }      }
621    
622      myData.setTaggedValueFromCPP(1,eTwo.getView());      myData.setTaggedValueFromCPP(1,viewShape, eTwoData);
623    
624      assert(myData.getLength()==6);      assert(myData.getLength()==6);
625    
626      myDataView = myData.getDataPoint(0,0);      int offset=myData.getDataOffset(0,0);
627      assert(myDataView==eTwo.getView());      assert(offset==3);
628      assert(!myDataView.isEmpty());      assert(myData.getDataPointRank()==1);
629      assert(myDataView.getOffset()==3);      assert(myData.getNoValues()==3);
630      assert(myDataView.getRank()==1);  
631      assert(myDataView.noValues()==3);      assert(myData.getDataAtOffset(offset+0)==2);
632      assert(myDataView.getShape().size()==1);      assert(myData.getDataAtOffset(offset+1)==3);
633      assert(myDataView(0)==2);      assert(myData.getDataAtOffset(offset+2)==4);
     assert(myDataView(1)==3);  
     assert(myDataView(2)==4);  
634    
635      sampleData=myData.getSampleDataByTag(1);      sampleData=myData.getSampleDataByTag(1);
636      for (int i=0; i<myDataView.noValues(); i++) {      for (int i=0; i<myData.getNoValues(); i++) {
637        assert(sampleData[i]==i+2);        assert(sampleData[i]==i+2);
638      }      }
639    
# Line 621  void DataTestCase::testDataTagged() { Line 643  void DataTestCase::testDataTagged() {
643    
644      cout << "\tCreate a DataTagged object via tag() method." << endl;      cout << "\tCreate a DataTagged object via tag() method." << endl;
645    
646      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
647      viewShape.push_back(2);      viewShape.push_back(2);
648      viewShape.push_back(3);      viewShape.push_back(3);
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 636  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
659      DataArrayView myDataView = myData.getPointDataView();      assert(!myData.isEmpty());
660      assert(!myDataView.isEmpty());      assert(myData.getDataPointRank()==2);
661      assert(myDataView.getOffset()==0);      assert(myData.getNoValues()==6);
662      assert(myDataView.getRank()==2);      assert(myData.getDataPointShape().size()==2);
663      assert(myDataView.noValues()==6);      assert(getRef(myData,0,0)==1.3);
664      assert(myDataView.getShape().size()==2);      assert(getRef(myData,0,1)==1.3);
665      assert(myDataView(0,0)==1.3);      assert(getRef(myData,0,2)==1.3);
666      assert(myDataView(0,1)==1.3);      assert(getRef(myData,1,0)==1.3);
667      assert(myDataView(0,2)==1.3);      assert(getRef(myData,1,1)==1.3);
668      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);  
669    
670      // check value for data-point (0,0).      // check value for data-point (0,0).
671      myDataView = myData.getDataPoint(0,0);  //     myDataView = myData.getDataPoint(0,0);
672      assert(!myDataView.isEmpty());      assert(!myData.isEmpty());
673      assert(myDataView.getOffset()==0);  //     assert(myDataView.getOffset()==0);
674      assert(myDataView.getRank()==2);      assert(myData.getDataPointRank()==2);
675      assert(myDataView.noValues()==6);      assert(myData.getNoValues()==6);
676      assert(myDataView.getShape().size()==2);      assert(myData.getDataPointShape().size()==2);
677      assert(myDataView(0,0)==1.3);      assert(getRef(myData,0,0)==1.3);
678      assert(myDataView(0,1)==1.3);      assert(getRef(myData,0,1)==1.3);
679      assert(myDataView(0,2)==1.3);      assert(getRef(myData,0,2)==1.3);
680      assert(myDataView(1,0)==1.3);      assert(getRef(myData,1,0)==1.3);
681      assert(myDataView(1,1)==1.3);      assert(getRef(myData,1,1)==1.3);
682      assert(myDataView(1,2)==1.3);      assert(getRef(myData,1,2)==1.3);
683    
684    }    }
685    
# Line 674  void DataTestCase::testDataTaggedExcepti Line 692  void DataTestCase::testDataTaggedExcepti
692    cout << "\tTest DataTagged exceptions." << endl;    cout << "\tTest DataTagged exceptions." << endl;
693    
694    Data myData;    Data myData;
   DataArrayView myView;  
695    
696    try {    try {
697        myData.getSampleDataByTag(0);;        myData.getSampleDataByTag(0);;
698        assert(false);        assert(false);
699    }    }
700    catch (EsysException& e) {    catch (EsysException&) {
701        //cout << e.what() << endl;        //cout << e.what() << endl;
702        assert(true);        assert(true);
703    }    }
704    
705    try {    try {
706        myData.setTaggedValueFromCPP(0,myView);;        myData.setTaggedValueFromCPP(0,DataTypes::ShapeType(), DataTypes::ValueType());;
707        assert(false);        assert(false);
708    }    }
709    catch (EsysException& e) {    catch (EsysException&) {
710        //cout << e.what() << endl;        //cout << e.what() << endl;
711        assert(true);        assert(true);
712    }    }
# Line 700  void DataTestCase::testConstructors() { Line 717  void DataTestCase::testConstructors() {
717    
718    cout << endl;    cout << endl;
719    
720    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
721    {    {
722      cout << "\tCreate an Empty Data object" << endl;      cout << "\tCreate an Empty Data object" << endl;
723      Data temp(1.3,viewShape,FunctionSpace(),false);      Data temp(1.3,viewShape,FunctionSpace(),false);
# Line 713  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    DataArrayView::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    DataArrayView::ValueType data(DataArrayView::noValues(shape),0);    DataTypes::ValueType data(DataTypes::noValues(shape),0);
   
   // construct DataArrayView  
   DataArrayView dataView(data,shape);  
746    
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++) {
750        dataView(i,j)=dataView.index(i,j);        data[getRelIndex(shape,i,j)]=getRelIndex(shape,i,j);
751      }      }
752    }    }
753    
754    Data baseEx(dataView,FunctionSpace(),true);  
755    Data baseCon(dataView,FunctionSpace(),false);  
756    Data baseTag(dataView,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(dataView.index(i,j),3.0);        tmp=pow((double)data[getRelIndex(shape,i,j)],(double)3.0);
826        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
827        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
828        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));
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)dataView.index(i,j));        tmp=sin((double)data[getRelIndex(shape,i,j)]);
845        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
846        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
847        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));
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)dataView.index(i,j));        tmp=cos((double)data[getRelIndex(shape,i,j)]);
864        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
865        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
866        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));
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)dataView.index(i,j));        tmp=tan((double)data[getRelIndex(shape,i,j)]);
883        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
884        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
885        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));
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)dataView.index(i,j));        tmp=atan((double)smalldata[getRelIndex(shape,i,j)]);
940        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
941        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
942        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));
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)dataView.index(i,j));        tmp=sinh((double)data[getRelIndex(shape,i,j)]);
959        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
960        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
961        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));
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)dataView.index(i,j));        tmp=cosh((double)data[getRelIndex(shape,i,j)]);
978        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
979        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
980        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));
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)dataView.index(i,j));        tmp=tanh((double)data[getRelIndex(shape,i,j)]);
997        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
998        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
999        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));
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)dataView.index(i,j));        tmp=abs((double)data[getRelIndex(shape,i,j)]);
1137        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
1138        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
1139        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));
1140          }
1141      }      }
1142    }    }
1143    
1144    cout << "\tTest Data::sign." << endl;    cout << "\tTest Data::sign (positive)." << endl;
1145    resultEx.copy(baseEx.sign());    for (int z=0;z<NUMDATS;++z)
1146    resultCon.copy(baseCon.sign());    {
1147    resultTag.copy(baseTag.sign());      results[z].copy(dats[z].sign());
1148    assert(true);      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    
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)dataView.index(i,j));        tmp=exp((double)data[getRelIndex(shape,i,j)]);
1195        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
1196        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
1197        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));
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)dataView.index(i,j));        tmp=sqrt((double)data[getRelIndex(shape,i,j)]);
1214        assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));        for (int z=0;z<NUMDATS;++z)
1215        assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));        {
1216        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));
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(resultEx.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));        for (int z=0;z<NUMDATS;++z)
1252        assert(std::abs(resultCon.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));        {
1253        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)]));
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(results[z].getDataAtOffset(0) - 0) <= REL_TOL*0);
1288      }
1289      
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.getPointDataView()() - 5) <= REL_TOL*5);    }
1296    assert(std::abs(resultCon.getPointDataView()() - 5) <= REL_TOL*5);    for (int z=0;z<NUMDATS;++z)
1297    assert(std::abs(resultTag.getPointDataView()() - 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 1002  void DataTestCase::testMemAlloc() { Line 1369  void DataTestCase::testMemAlloc() {
1369    
1370    Data *testData;    Data *testData;
1371    for (int i=0; i<1000; i++) {    for (int i=0; i<1000; i++) {
1372      testData = new Data(0.0, DataArrayView::ShapeType(), FunctionSpace(), true);      testData = new Data(0.0, DataTypes::ShapeType(), FunctionSpace(), true);
1373      delete testData;      delete testData;
1374    }    }
1375    
1376    DataArrayView::ShapeType viewShape;    DataTypes::ShapeType viewShape;
1377    viewShape.push_back(10);    viewShape.push_back(10);
1378    viewShape.push_back(10);    viewShape.push_back(10);
1379    viewShape.push_back(10);    viewShape.push_back(10);
# Line 1026  TestSuite* DataTestCase::suite () Line 1393  TestSuite* DataTestCase::suite ()
1393    //    //
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));
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 1037  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.1026  
changed lines
  Added in v.2005

  ViewVC Help
Powered by ViewVC 1.1.26