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

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

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

trunk/escript/test/Data/DataTestCase.cpp revision 538 by jgs, Mon Feb 20 03:43:25 2006 UTC trunk/escript/test/DataTestCase.cpp revision 1026 by phornby, Tue Mar 13 08:25:00 2007 UTC
# Line 12  Line 12 
12   *                                                                           *   *                                                                           *
13   *****************************************************************************   *****************************************************************************
14  */  */
15    #include <iostream>
16    #if (defined _WIN32) && (defined __INTEL_COMPILER)
17    #include <mathimf.h>
18    #else
19    #include <math.h>
20    #endif
21    
22  #include "DataTestCase.h"  #include "DataTestCase.h"
23    
24  #include "FunctionSpace.h"  #include "escript/FunctionSpace.h"
25  #include "EsysException.h"  #include "esysUtils/EsysException.h"
26    
27  #include "Data.h"  #include "escript/Data.h"
28    
 #include <iostream>  
 #include <math.h>  
29    
30  using namespace std;  using namespace std;
31  using namespace CppUnitTest;  using namespace CppUnitTest;
# Line 219  void DataTestCase::testSlicing() { Line 223  void DataTestCase::testSlicing() {
223      cout << "\tTest set-slicing DataTagged" << endl;      cout << "\tTest set-slicing DataTagged" << endl;
224    
225      //      //
226      // create a DataTagged with a scalar default value only      // create a source DataTagged with a scalar default value only
227    
228      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
229      Data source(10.0,viewShape,FunctionSpace(),false);      Data source(10.0,viewShape,FunctionSpace(),false);
230      source.tag();      source.tag();
231    
232      //cout << source.toString() << endl;      //cout << "source:\n" << source.toString() << endl;
233    
234      //      //
235      // create a DataTagged with a rank 2 default value only      // create a target DataTagged with a rank 2 default value only
236    
237      viewShape.push_back(2);      viewShape.push_back(2);
238      viewShape.push_back(3);      viewShape.push_back(3);
239      Data target(1.3,viewShape,FunctionSpace(),false);      Data target(1.3,viewShape,FunctionSpace(),false);
240      target.tag();      target.tag();
241    
242      //cout << target.toString() << endl;      //cout << "target:\n" << target.toString() << endl;
243    
244      //      //
245      // set a slice in target from source      // set a slice in target from source
# Line 246  void DataTestCase::testSlicing() { Line 250  void DataTestCase::testSlicing() {
250    
251      target.setSlice(source,region);      target.setSlice(source,region);
252    
253      //cout << target.toString() << endl;      //cout << "target:\n" << target.toString() << endl;
254    
255      assert(target.isTagged());      assert(target.isTagged());
256      assert(target.getDataPointRank()==2);      assert(target.getDataPointRank()==2);
# Line 258  void DataTestCase::testSlicing() { Line 262  void DataTestCase::testSlicing() {
262      assert(target.getDataPoint(0,0)(1,2)==1.3);      assert(target.getDataPoint(0,0)(1,2)==1.3);
263    
264      //      //
265      // add a value for tag "1"      // add a value for tag "1" to target
266    
267      DataArrayView::ValueType viewData(6);      DataArrayView::ValueType viewData(6);
268      for (int i=0;i<viewData.size();i++) {      for (int i=0;i<viewData.size();i++) {
# Line 268  void DataTestCase::testSlicing() { Line 272  void DataTestCase::testSlicing() {
272    
273      target.setTaggedValueFromCPP(1, dataView);      target.setTaggedValueFromCPP(1, dataView);
274    
275        //cout << "target:\n" << target.toString() << endl;
276    
277      //      //
278      // set a slice in target from source      // set a slice in target from source
279    
# Line 277  void DataTestCase::testSlicing() { Line 283  void DataTestCase::testSlicing() {
283    
284      target.setSlice(source,region);      target.setSlice(source,region);
285    
286      //cout << target.toString() << endl;      //cout << "target:\n" << target.toString() << endl;
287    
288      assert(target.isTagged());      assert(target.isTagged());
289      assert(target.getDataPointRank()==2);      assert(target.getDataPointRank()==2);
# Line 288  void DataTestCase::testSlicing() { Line 294  void DataTestCase::testSlicing() {
294      assert(target.getDataPoint(0,0)(1,1)==3);      assert(target.getDataPoint(0,0)(1,1)==3);
295      assert(target.getDataPoint(0,0)(1,2)==5);      assert(target.getDataPoint(0,0)(1,2)==5);
296    
297        //
298        // add a value for tag "2" to source
299    
300        DataArrayView::ShapeType viewShape2;
301        DataArrayView::ValueType viewData2(1);
302        viewData2[0]=6;
303        DataArrayView dataView2(viewData2,viewShape2);
304    
305        source.setTaggedValueFromCPP(2, dataView2);
306    
307        //cout << "source:\n" << source.toString() << endl;
308    
309        //
310        // set a slice in target from source
311    
312        region.clear();
313        region.push_back(DataArrayView::RegionType::value_type(0,0));
314        region.push_back(DataArrayView::RegionType::value_type(1,1));
315    
316        target.setSlice(source,region);
317    
318        //cout << "target:\n" << target.toString() << endl;
319    
320        assert(target.isTagged());
321        assert(target.getDataPointRank()==2);
322    
323        // use a non-existant tag so we get a pointer to the default value
324        // ie: the first element in the data array
325        DataAbstract::ValueType::value_type* targetData=target.getSampleDataByTag(9);
326        for (int i=0; i<target.getLength(); i++) {
327          assert(targetData[i]>=0);
328        }
329        assert(targetData[0]==1.3);
330        assert(targetData[1]==1.3);
331        assert(targetData[2]==10);
332        assert(targetData[3]==10);
333        assert(targetData[4]==1.3);
334        assert(targetData[5]==1.3);
335        assert(targetData[6]==0);
336        assert(targetData[7]==1);
337        assert(targetData[8]==10);
338        assert(targetData[9]==3);
339        assert(targetData[10]==4);
340        assert(targetData[11]==5);
341        assert(targetData[12]==1.3);
342        assert(targetData[13]==1.3);
343        assert(targetData[14]==6);
344        assert(targetData[15]==10);
345        assert(targetData[16]==1.3);
346        assert(targetData[17]==1.3);
347    
348    }    }
349    
350    {    {
# Line 470  void DataTestCase::testDataTagged() { Line 527  void DataTestCase::testDataTagged() {
527    
528    cout << endl;    cout << endl;
529    
530    cout << "\tCreate a DataTagged object with a default value only." << endl;    {
531    
532    DataTagged::TagListType keys;      cout << "\tCreate a DataTagged object with a default value only." << endl;
533    
534    DataTagged::ValueListType values;      DataTagged::TagListType keys;
535    
536    DataArrayView::ShapeType viewShape;      DataTagged::ValueListType values;
537    viewShape.push_back(3);  
538        DataArrayView::ShapeType viewShape;
539        viewShape.push_back(3);
540    
541        DataArrayView::ValueType viewData(3);
542        for (int i=0;i<viewShape[0];i++) {
543          viewData[i]=i;
544        }
545        DataArrayView defaultValue(viewData,viewShape);
546    
547        bool expanded=false;
548      
549        Data myData(keys,values,defaultValue,FunctionSpace(),expanded);
550    
551        // cout << myData.toString() << endl;
552    
553        assert(!myData.isEmpty());
554        assert(myData.isTagged());
555        assert(myData.getTagNumber(0)==1);
556        assert(myData.getDataPointRank()==1);
557        assert(myData.getLength()==3);
558    
559        DataArrayView myDataView = myData.getPointDataView();
560        assert(!myDataView.isEmpty());
561        assert(myDataView.getOffset()==0);
562        assert(myDataView.getRank()==1);
563        assert(myDataView.noValues()==3);
564        assert(myDataView.getShape().size()==1);
565        assert(myDataView(0)==0.0);
566        assert(myDataView(1)==1.0);
567        assert(myDataView(2)==2.0);
568    
569        myDataView = myData.getDataPoint(0,0);
570        assert(!myDataView.isEmpty());
571        assert(myDataView.getOffset()==0);
572        assert(myDataView.getRank()==1);
573        assert(myDataView.noValues()==3);
574        assert(myDataView.getShape().size()==1);
575        assert(myDataView(0)==0.0);
576        assert(myDataView(1)==1.0);
577        assert(myDataView(2)==2.0);
578    
579        double* sampleData=myData.getSampleData(0);
580        for (int i=0; i<myDataView.noValues(); i++) {
581          assert(sampleData[i]==i);
582        }
583        // use a non-existent tag so we get a pointer to
584        // the first element of the data array
585        sampleData=myData.getSampleDataByTag(9);
586        for (int i=0; i<myData.getLength(); i++) {
587          assert(sampleData[i]==i);
588        }
589    
590        cout << "\tTest setting of a tag and associated value." << endl;
591    
592        // value for tag "1"
593        DataArray eTwo(defaultValue);
594        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
595          eTwo.getView()(i)=i+2.0;
596        }
597    
598        myData.setTaggedValueFromCPP(1,eTwo.getView());
599    
600        assert(myData.getLength()==6);
601    
602        myDataView = myData.getDataPoint(0,0);
603        assert(myDataView==eTwo.getView());
604        assert(!myDataView.isEmpty());
605        assert(myDataView.getOffset()==3);
606        assert(myDataView.getRank()==1);
607        assert(myDataView.noValues()==3);
608        assert(myDataView.getShape().size()==1);
609        assert(myDataView(0)==2);
610        assert(myDataView(1)==3);
611        assert(myDataView(2)==4);
612    
613        sampleData=myData.getSampleDataByTag(1);
614        for (int i=0; i<myDataView.noValues(); i++) {
615          assert(sampleData[i]==i+2);
616        }
617    
   DataArrayView::ValueType viewData(3);  
   for (int i=0;i<viewShape[0];i++) {  
     viewData[i]=i;  
618    }    }
   DataArrayView defaultValue(viewData,viewShape);  
619    
620    bool expanded=false;    {
621    
622        cout << "\tCreate a DataTagged object via tag() method." << endl;
623    
624        DataArrayView::ShapeType viewShape;
625        viewShape.push_back(2);
626        viewShape.push_back(3);
627        Data myData(1.3,viewShape,FunctionSpace(),false);
628        myData.tag();
629    
630    Data myData(keys,values,defaultValue,FunctionSpace(),expanded);      //cout << myData.toString() << endl;
631    
632    // cout << myData.toString() << endl;      assert(!myData.isEmpty());
633        assert(myData.isTagged());
634        assert(myData.getTagNumber(0)==1);
635        assert(myData.getDataPointRank()==2);
636        assert(myData.getLength()==6);
637    
638        // check default value
639        DataArrayView myDataView = myData.getPointDataView();
640        assert(!myDataView.isEmpty());
641        assert(myDataView.getOffset()==0);
642        assert(myDataView.getRank()==2);
643        assert(myDataView.noValues()==6);
644        assert(myDataView.getShape().size()==2);
645        assert(myDataView(0,0)==1.3);
646        assert(myDataView(0,1)==1.3);
647        assert(myDataView(0,2)==1.3);
648        assert(myDataView(1,0)==1.3);
649        assert(myDataView(1,1)==1.3);
650        assert(myDataView(1,2)==1.3);
651    
652        // check value for data-point (0,0).
653        myDataView = myData.getDataPoint(0,0);
654        assert(!myDataView.isEmpty());
655        assert(myDataView.getOffset()==0);
656        assert(myDataView.getRank()==2);
657        assert(myDataView.noValues()==6);
658        assert(myDataView.getShape().size()==2);
659        assert(myDataView(0,0)==1.3);
660        assert(myDataView(0,1)==1.3);
661        assert(myDataView(0,2)==1.3);
662        assert(myDataView(1,0)==1.3);
663        assert(myDataView(1,1)==1.3);
664        assert(myDataView(1,2)==1.3);
665    
   assert(!myData.isEmpty());  
   assert(myData.isTagged());  
   assert(myData.getTagNumber(0)==1);  
   assert(myData.getDataPointRank()==1);  
   assert(myData.getLength()==3);  
   
   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);  
   
   double* sampleData=myData.getSampleData(0);  
   for (int i=0; i<myDataView.noValues(); i++) {  
     assert(sampleData[i]==i);  
   }  
   // use a non-existent tag so we get a pointer to  
   // the first element of the data array  
   sampleData=myData.getSampleDataByTag(9);  
   for (int i=0; i<myData.getLength(); i++) {  
     assert(sampleData[i]==i);  
   }  
   
   cout << "\tTest setting of a tag and associated value." << endl;  
   
   // value for tag "1"  
   DataArray eTwo(defaultValue);  
   for (int i=0;i<eTwo.getView().getShape()[0];i++) {  
     eTwo.getView()(i)=i+2.0;  
   }  
   
   myData.setTaggedValueFromCPP(1,eTwo.getView());  
   
   assert(myData.getLength()==6);  
   
   myDataView = myData.getDataPoint(0,0);  
   assert(myDataView==eTwo.getView());  
   assert(!myDataView.isEmpty());  
   assert(myDataView.getOffset()==3);  
   assert(myDataView.getRank()==1);  
   assert(myDataView.noValues()==3);  
   assert(myDataView.getShape().size()==1);  
   assert(myDataView(0)==2);  
   assert(myDataView(1)==3);  
   assert(myDataView(2)==4);  
   
   sampleData=myData.getSampleDataByTag(1);  
   for (int i=0; i<myDataView.noValues(); i++) {  
     assert(sampleData[i]==i+2);  
666    }    }
667    
668  }  }
# Line 626  void DataTestCase::testOperations() { Line 735  void DataTestCase::testOperations() {
735      }      }
736    }    }
737    
738    Data base(dataView);    Data baseEx(dataView,FunctionSpace(),true);
739      Data baseCon(dataView,FunctionSpace(),false);
740      Data baseTag(dataView,FunctionSpace(),false);
741      baseTag.tag();
742    
743      assert(baseEx.isExpanded());
744      assert(baseCon.isConstant());
745      assert(baseTag.isTagged());
746    
747      Data resultEx;
748      Data resultCon;
749      Data resultTag;
750    
751    // test unary operations    // test unary operations
752    
753      double tmp;
754    cout << "\tTest Data::pow." << endl;    cout << "\tTest Data::pow." << endl;
755    Data power(3.0,shape,FunctionSpace(),true);    Data power(3.0,shape,FunctionSpace(),true);
756    Data result(base.powD(power));    resultEx.copy(baseEx.powD(power));
757      resultCon.copy(baseCon.powD(power));
758      resultTag.copy(baseTag.powD(power));
759    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
760      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
761        assert(result.getPointDataView()(i,j) == pow(dataView.index(i,j),3.0));        tmp=pow(dataView.index(i,j),3.0);
762          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
763          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
764          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
765      }      }
766    }    }
767    
768    cout << "\tTest Data::sin." << endl;    cout << "\tTest Data::sin." << endl;
769    result.copy(base.sin());    resultEx.copy(baseEx.sin());
770    assert(true);    resultCon.copy(baseCon.sin());
771      resultTag.copy(baseTag.sin());
772      for (int i=0;i<shape[0];i++) {
773        for (int j=0;j<shape[1];j++) {
774          tmp=sin((double)dataView.index(i,j));
775          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
776          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
777          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
778        }
779      }
780    
781    cout << "\tTest Data::cos." << endl;    cout << "\tTest Data::cos." << endl;
782    result.copy(base.cos());    resultEx.copy(baseEx.cos());
783    assert(true);    resultCon.copy(baseCon.cos());
784      resultTag.copy(baseTag.cos());
785      for (int i=0;i<shape[0];i++) {
786        for (int j=0;j<shape[1];j++) {
787          tmp=cos((double)dataView.index(i,j));
788          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
789          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
790          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
791        }
792      }
793    
794    cout << "\tTest Data::tan." << endl;    cout << "\tTest Data::tan." << endl;
795    result.copy(base.tan());    resultEx.copy(baseEx.tan());
796    assert(true);    resultCon.copy(baseCon.tan());
797      resultTag.copy(baseTag.tan());
798      for (int i=0;i<shape[0];i++) {
799        for (int j=0;j<shape[1];j++) {
800          tmp=tan((double)dataView.index(i,j));
801          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
802          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
803          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
804        }
805      }
806    
807    cout << "\tTest Data::asin." << endl;    cout << "\tTest Data::asin." << endl;
808    result.copy(base.asin());    resultEx.copy(baseEx.asin());
809      resultCon.copy(baseCon.asin());
810      resultTag.copy(baseTag.asin());
811    assert(true);    assert(true);
812    
813    cout << "\tTest Data::acos." << endl;    cout << "\tTest Data::acos." << endl;
814    result.copy(base.acos());    resultEx.copy(baseEx.acos());
815      resultCon.copy(baseCon.acos());
816      resultTag.copy(baseTag.acos());
817    assert(true);    assert(true);
818    
819    cout << "\tTest Data::atan." << endl;    cout << "\tTest Data::atan." << endl;
820    result.copy(base.atan());    resultEx.copy(baseEx.atan());
821    assert(true);    resultCon.copy(baseCon.atan());
822      resultTag.copy(baseTag.atan());
823      for (int i=0;i<shape[0];i++) {
824        for (int j=0;j<shape[1];j++) {
825          tmp=atan((double)dataView.index(i,j));
826          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
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));
829        }
830      }
831    
832    cout << "\tTest Data::sinh." << endl;    cout << "\tTest Data::sinh." << endl;
833    result.copy(base.sinh());    resultEx.copy(baseEx.sinh());
834    assert(true);    resultCon.copy(baseCon.sinh());
835      resultTag.copy(baseTag.sinh());
836      for (int i=0;i<shape[0];i++) {
837        for (int j=0;j<shape[1];j++) {
838          tmp=sinh((double)dataView.index(i,j));
839          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
840          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
841          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
842        }
843      }
844    
845    cout << "\tTest Data::cosh." << endl;    cout << "\tTest Data::cosh." << endl;
846    result.copy(base.cosh());    resultEx.copy(baseEx.cosh());
847    assert(true);    resultCon.copy(baseCon.cosh());
848      resultTag.copy(baseTag.cosh());
849      for (int i=0;i<shape[0];i++) {
850        for (int j=0;j<shape[1];j++) {
851          tmp=cosh((double)dataView.index(i,j));
852          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
853          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
854          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
855        }
856      }
857    
858    cout << "\tTest Data::tanh." << endl;    cout << "\tTest Data::tanh." << endl;
859    result.copy(base.tanh());    resultEx.copy(baseEx.tanh());
860    assert(true);    resultCon.copy(baseCon.tanh());
861      resultTag.copy(baseTag.tanh());
862      for (int i=0;i<shape[0];i++) {
863        for (int j=0;j<shape[1];j++) {
864          tmp=tanh((double)dataView.index(i,j));
865          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
866          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
867          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
868        }
869      }
870    
871    cout << "\tTest Data::asinh." << endl;    cout << "\tTest Data::asinh." << endl;
872    result.copy(base.asinh());    resultEx.copy(baseEx.asinh());
873      resultCon.copy(baseCon.asinh());
874      resultTag.copy(baseTag.asinh());
875    assert(true);    assert(true);
876    
877    cout << "\tTest Data::acosh." << endl;    cout << "\tTest Data::acosh." << endl;
878    result.copy(base.acosh());    resultEx.copy(baseEx.acosh());
879      resultCon.copy(baseCon.acosh());
880      resultTag.copy(baseTag.acosh());
881    assert(true);    assert(true);
882    
883    cout << "\tTest Data::atanh." << endl;    cout << "\tTest Data::atanh." << endl;
884    result.copy(base.atanh());    resultEx.copy(baseEx.atanh());
885      resultCon.copy(baseCon.atanh());
886      resultTag.copy(baseTag.atanh());
887    assert(true);    assert(true);
888    
889    cout << "\tTest Data::log." << endl;    cout << "\tTest Data::log." << endl;
890    result.copy(base.log());    resultEx.copy(baseEx.log());
891      resultCon.copy(baseCon.log());
892      resultTag.copy(baseTag.log());
893    assert(true);    assert(true);
894    
   //cout << "\tTest Data::ln." << endl;  
   //result.copy(base.ln());  
   //assert(true);  
   
895    cout << "\tTest Data::abs." << endl;    cout << "\tTest Data::abs." << endl;
896    result.copy(base.abs());    resultEx.copy(baseEx.abs());
897    assert(true);    resultCon.copy(baseCon.abs());
898      resultTag.copy(baseTag.abs());
899      for (int i=0;i<shape[0];i++) {
900        for (int j=0;j<shape[1];j++) {
901          tmp=abs((double)dataView.index(i,j));
902          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
903          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
904          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
905        }
906      }
907    
908    cout << "\tTest Data::sign." << endl;    cout << "\tTest Data::sign." << endl;
909    result.copy(base.sign());    resultEx.copy(baseEx.sign());
910      resultCon.copy(baseCon.sign());
911      resultTag.copy(baseTag.sign());
912    assert(true);    assert(true);
913    
914    cout << "\tTest Data::exp." << endl;    cout << "\tTest Data::exp." << endl;
915    result.copy(base.exp());    resultEx.copy(baseEx.exp());
916    assert(true);    resultCon.copy(baseCon.exp());
917      resultTag.copy(baseTag.exp());
918      for (int i=0;i<shape[0];i++) {
919        for (int j=0;j<shape[1];j++) {
920          tmp=exp((double)dataView.index(i,j));
921          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
922          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
923          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
924        }
925      }
926    
927    cout << "\tTest Data::sqrt." << endl;    cout << "\tTest Data::sqrt." << endl;
928    result.copy(base.sqrt());    resultEx.copy(baseEx.sqrt());
929    assert(true);    resultCon.copy(baseCon.sqrt());
930      resultTag.copy(baseTag.sqrt());
931      for (int i=0;i<shape[0];i++) {
932        for (int j=0;j<shape[1];j++) {
933          tmp=sqrt((double)dataView.index(i,j));
934          assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
935          assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
936          assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
937        }
938      }
939    
940    cout << "\tTest Data::neg." << endl;    cout << "\tTest Data::neg." << endl;
941    result.copy(base.neg());    resultEx.copy(baseEx.neg());
942      resultCon.copy(baseCon.neg());
943      resultTag.copy(baseTag.neg());
944    assert(true);    assert(true);
945    
946    cout << "\tTest Data::pos." << endl;    cout << "\tTest Data::pos." << endl;
947    result.copy(base.pos());    resultEx.copy(baseEx.pos());
948      resultCon.copy(baseCon.pos());
949      resultTag.copy(baseTag.pos());
950    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
951      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
952        assert(result.getPointDataView()(i,j) == dataView.index(i,j));        assert(std::abs(resultEx.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
953          assert(std::abs(resultCon.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
954          assert(std::abs(resultTag.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
955      }      }
956    }    }
957    
958    // test reduction operations    // test reduction operations
959    
960    cout << "\tTest Data::Lsup." << endl;    cout << "\tTest Data::Lsup." << endl;
961    assert(base.Lsup() == 5);    assert(std::abs(baseEx.Lsup() - 5) <= REL_TOL*5);
962      assert(std::abs(baseCon.Lsup() - 5) <= REL_TOL*5);
963      assert(std::abs(baseTag.Lsup() - 5) <= REL_TOL*5);
964    
965    cout << "\tTest Data::sup." << endl;    cout << "\tTest Data::sup." << endl;
966    assert(base.sup() == 5);    assert(std::abs(baseEx.sup() - 5) <= REL_TOL*5);
967      assert(std::abs(baseCon.sup() - 5) <= REL_TOL*5);
968      assert(std::abs(baseTag.sup() - 5) <= REL_TOL*5);
969    
970    cout << "\tTest Data::inf." << endl;    cout << "\tTest Data::inf." << endl;
971    assert(base.inf() == 0);    assert(std::abs(baseEx.inf() - 0) <= REL_TOL*0);
972      assert(std::abs(baseCon.inf() - 0) <= REL_TOL*0);
973      assert(std::abs(baseTag.inf() - 0) <= REL_TOL*0);
974    
975    // test data-point reduction operations    // test data-point reduction operations
976    
977    cout << "\tTest Data::minval." << endl;    cout << "\tTest Data::minval." << endl;
978    result.copy(base.minval());    resultEx.copy(baseEx.minval());
979    assert(result.getPointDataView()() == 0);    resultCon.copy(baseCon.minval());
980      resultTag.copy(baseTag.minval());
981      assert(std::abs(resultEx.getPointDataView()() - 0) <= REL_TOL*0);
982      assert(std::abs(resultCon.getPointDataView()() - 0) <= REL_TOL*0);
983      assert(std::abs(resultTag.getPointDataView()() - 0) <= REL_TOL*0);
984    
985    cout << "\tTest Data::maxval." << endl;    cout << "\tTest Data::maxval." << endl;
986    result.copy(base.maxval());    resultEx.copy(baseEx.maxval());
987    assert(result.getPointDataView()() == 5);    resultCon.copy(baseCon.maxval());
988      resultTag.copy(baseTag.maxval());
989    //cout << "\tTest Data::length." << endl;    assert(std::abs(resultEx.getPointDataView()() - 5) <= REL_TOL*5);
990    //result.copy(base.length());    assert(std::abs(resultCon.getPointDataView()() - 5) <= REL_TOL*5);
991    //assert(pow(result.getPointDataView()(),2.0) == 55);    assert(std::abs(resultTag.getPointDataView()() - 5) <= REL_TOL*5);
   
   cout << "\tTest Data::trace." << endl;  
   result.copy(base.trace());  
   assert(result.getPointDataView()() == 15);  
   
   //result.copy(base.transpose(0));  
   //assert(true);  
992    
993  }  }
994    
 void DataTestCase::testRefValue() {  
   
   //  
   // Note - this test can't be run as boost::python::numeric::array  
   // objects can only be created and used from within a python thread!  
   //  
   
   cout << endl;  
   
   cout << "\tTest Data object RefValue methods." << endl;  
   
   // Create three Data object - DataExpanded, DataConstant and DataEmpty  
   DataArrayView::ShapeType viewShape;  
   viewShape.push_back(3);  
   DataArrayView::ValueType viewData(3);  
   for (int i=0;i<viewShape[0];++i) {  
     viewData[i]=i;  
   }  
   DataArrayView myView(viewData,viewShape);  
   
   bool expanded=true;  
   
   Data expandedData(myView,FunctionSpace(),expanded);  
   Data constantData(myView);  
   Data emptyData;  
   
   assert(expandedData.isExpanded());  
   assert(constantData.isConstant());  
   assert(emptyData.isEmpty());  
   
   // Check assertions are thrown for RefValue methods on DataEmpty  
   
   int ref = 0;  
   boost::python::numeric::array num_array(1.0);  
   
   try {  
       emptyData.getRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   try {  
       emptyData.setRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   
   // Check assertions are thrown for RefValue methods on DataConstant  
   try {  
       constantData.getRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   try {  
       constantData.setRefValue(ref,num_array);  
       assert(false);  
   }  
   catch (EsysException& e) {  
       assert(true);  
   }  
   
   // Check calls to RefValue methods on DataExpanded  
   expandedData.getRefValue(ref,num_array);  
   expandedData.setRefValue(ref,num_array);  
   
 }  
995    
996  void DataTestCase::testMemAlloc() {  void DataTestCase::testMemAlloc() {
997    

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

  ViewVC Help
Powered by ViewVC 1.1.26