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

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

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

revision 502 by jgs, Wed Feb 8 03:57:20 2006 UTC revision 514 by jgs, Mon Feb 13 04:47:47 2006 UTC
# Line 16  Line 16 
16  #include "EsysException.h"  #include "EsysException.h"
17    
18  #include "DataTagged.h"  #include "DataTagged.h"
19    #include "DataConstant.h"
20    
21  #include "DataTaggedTestCase.h"  #include "DataTaggedTestCase.h"
22    
# Line 50  void DataTaggedTestCase::testReshape() { Line 51  void DataTaggedTestCase::testReshape() {
51    cout << endl;    cout << endl;
52    
53    {    {
54      cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;  
55      DataTagged value;      cout << "\tTest rank 1 reshape of default DataTagged." << endl;
56      value.getPointDataView()()=1.0;  
57        DataTagged myData;
58        myData.getPointDataView()()=1.0;
59    
60      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
61      shape.push_back(2);      shape.push_back(2);
62      value.reshapeDataPoint(shape);  
63      for (int i=0;i<shape[0];++i) {      myData.reshapeDataPoint(shape);
64        assert(value.getDefaultValue()(i)==1);  
65        for (int i=0;i<shape[0];i++) {
66          assert(myData.getDefaultValue()(i)==1);
67        }
68    
69        //cout << myData.toString() << endl;
70    
71        assert(myData.getNumSamples()==1);
72        assert(myData.getNumDPPSample()==1);
73    
74        assert(myData.validSamplePointNo(0));
75        assert(myData.validSampleNo(0));
76        assert(!myData.validSamplePointNo(1));
77        assert(!myData.validSampleNo(1));
78    
79        // data-point 0 has tag number 1 by default
80        assert(myData.getTagNumber(0)==1);
81    
82        assert(!myData.isCurrentTag(1));
83    
84        assert(myData.getTagLookup().size()==0);
85    
86        assert(myData.getLength()==2);
87    
88        assert(myData.getPointOffset(0,0)==0);
89    
90        DataArrayView myDataView = myData.getDataPoint(0,0);
91        assert(!myDataView.isEmpty());
92        assert(myDataView.getOffset()==0);
93        assert(myDataView.getRank()==1);
94        assert(myDataView.noValues()==2);
95        assert(myDataView.getShape().size()==1);
96        assert(myDataView(0)==1.0);
97        assert(myDataView(1)==1.0);
98    
99        // Test non-existent tag returns the default value.
100        myDataView = myData.getDataPointByTag(1);
101        assert(!myDataView.isEmpty());
102        assert(myDataView.getOffset()==0);
103        assert(myDataView.getRank()==1);
104        assert(myDataView.noValues()==2);
105        assert(myDataView.getShape().size()==1);
106        assert(myDataView(0)==1.0);
107        assert(myDataView(1)==1.0);
108    
109        myDataView = myData.getDefaultValue();
110        assert(!myDataView.isEmpty());
111        assert(myDataView.getOffset()==0);
112        assert(myDataView.getRank()==1);
113        assert(myDataView.noValues()==2);
114        assert(myDataView.getShape().size()==1);
115        assert(myDataView(0)==1.0);
116        assert(myDataView(1)==1.0);
117    
118        // use a non-existent tag so we get a pointer to
119        // the first element of the data array
120        double* sampleData=myData.getSampleDataByTag(9);
121        for (int i=0; i<myData.getLength(); i++) {
122          assert(sampleData[i]==1.0);
123      }      }
124    
125    }    }
126    
127    {    {
128      cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;  
129      DataTagged value;      cout << "\tTest rank 2 reshape of DataTagged with one tag." << endl;
130      value.getPointDataView()()=0.0;  
131      DataArray vOne(1.0);      DataTagged::TagListType keys;
132      DataArray vTwo(2.0);      keys.push_back(1);
133      value.addTaggedValue(1,vOne.getView());  
134      value.addTaggedValue(2,vTwo.getView());      DataTagged::ValueListType values;
135    
136        DataArrayView::ShapeType viewShape;
137    
138        // default value
139        DataArrayView::ValueType viewData(1);
140        viewData[0]=1.0;
141        DataArrayView myView(viewData,viewShape);
142    
143        // value for tag "1"
144        DataArray eOne(myView);
145        eOne.getView()()=2.0;
146        values.push_back(eOne.getView());
147    
148        DataTagged myData(keys,values,myView,FunctionSpace());
149    
150      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
151      shape.push_back(2);      shape.push_back(2);
152      shape.push_back(5);      shape.push_back(5);
153      value.reshapeDataPoint(shape);  
154      for (int j=0;j<shape[1];++j) {      myData.reshapeDataPoint(shape);
155        for (int i=0;i<shape[0];++i) {  
156      assert(value.getDefaultValue()(i,j)==0.0);      //cout << myData.toString() << endl;
157      assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());  
158      assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());      assert(myData.getNumSamples()==1);
159        assert(myData.getNumDPPSample()==1);
160    
161        assert(myData.validSamplePointNo(0));
162        assert(myData.validSampleNo(0));
163        assert(!myData.validSamplePointNo(1));
164        assert(!myData.validSampleNo(1));
165    
166        // data-point 0 has tag number 1 by default
167        assert(myData.getTagNumber(0)==1);
168    
169        assert(myData.isCurrentTag(1));
170    
171        assert(myData.getTagLookup().size()==1);
172    
173        assert(myData.getLength()==20);
174    
175        assert(myData.getPointOffset(0,0)==10);
176    
177        DataArrayView myDataView = myData.getDataPoint(0,0);
178        assert(!myDataView.isEmpty());
179        assert(myDataView.getOffset()==10);
180        assert(myDataView.getRank()==2);
181        assert(myDataView.noValues()==10);
182        assert(myDataView.getShape().size()==2);
183        for (int j=0;j<shape[1];j++) {
184          for (int i=0;i<shape[0];i++) {
185            assert(myDataView(i,j)==2.0);
186          }
187        }
188    
189        myDataView = myData.getDataPointByTag(1);
190        assert(!myDataView.isEmpty());
191        assert(myDataView.getOffset()==10);
192        assert(myDataView.getRank()==2);
193        assert(myDataView.noValues()==10);
194        assert(myDataView.getShape().size()==2);
195        for (int j=0;j<shape[1];j++) {
196          for (int i=0;i<shape[0];i++) {
197            assert(myDataView(i,j)==2.0);
198          }
199        }
200    
201        myDataView = myData.getDefaultValue();
202        assert(!myDataView.isEmpty());
203        assert(myDataView.getOffset()==0);
204        assert(myDataView.getRank()==2);
205        assert(myDataView.noValues()==10);
206        assert(myDataView.getShape().size()==2);
207        for (int j=0;j<shape[1];j++) {
208          for (int i=0;i<shape[0];i++) {
209            assert(myDataView(i,j)==1.0);
210          }
211        }
212    
213        // use a non-existent tag so we get a pointer to
214        // the first element of the data array
215        double* sampleData=myData.getSampleDataByTag(9);
216        for (int i=0; i<myData.getLength(); i++) {
217          if (i<10) {
218            assert(sampleData[i]==1.0);
219          } else {
220            assert(sampleData[i]==2.0);
221          }
222        }
223    
224      }
225    
226      {
227    
228        cout << "\tTest rank 3 reshape of DataTagged with three tags." << endl;
229    
230        DataTagged::TagListType keys;
231        keys.push_back(1);
232        keys.push_back(2);
233        keys.push_back(3);
234    
235        DataTagged::ValueListType values;
236    
237        DataArrayView::ShapeType viewShape;
238    
239        // default value
240        DataArrayView::ValueType viewData(1);
241        viewData[0]=0.0;
242        DataArrayView myView(viewData,viewShape);
243    
244        // value for tag "1"
245        DataArray eOne(myView);
246        eOne.getView()()=1.0;
247        values.push_back(eOne.getView());
248    
249        // value for tag "2"
250        DataArray eTwo(myView);
251        eTwo.getView()()=2.0;
252        values.push_back(eTwo.getView());
253    
254        // value for tag "3"
255        DataArray eThree(myView);
256        eThree.getView()()=3.0;
257        values.push_back(eThree.getView());
258    
259        DataTagged myData(keys,values,myView,FunctionSpace());
260    
261        DataArrayView::ShapeType shape;
262        shape.push_back(2);
263        shape.push_back(2);
264        shape.push_back(2);
265    
266        myData.reshapeDataPoint(shape);
267    
268        //cout << myData.toString() << endl;
269    
270        assert(myData.getNumSamples()==1);
271        assert(myData.getNumDPPSample()==1);
272    
273        assert(myData.validSamplePointNo(0));
274        assert(myData.validSampleNo(0));
275        assert(!myData.validSamplePointNo(1));
276        assert(!myData.validSampleNo(1));
277    
278        // data-point 0 has tag number 1 by default
279        assert(myData.getTagNumber(0)==1);
280    
281        assert(myData.isCurrentTag(1));
282        assert(myData.isCurrentTag(2));
283        assert(myData.isCurrentTag(3));
284    
285        assert(myData.getTagLookup().size()==3);
286    
287        assert(myData.getLength()==32);
288    
289        assert(myData.getPointOffset(0,0)==8);
290    
291        DataArrayView myDataView = myData.getDataPoint(0,0);
292        assert(!myDataView.isEmpty());
293        assert(myDataView.getOffset()==8);
294        assert(myDataView.getRank()==3);
295        assert(myDataView.noValues()==8);
296        assert(myDataView.getShape().size()==3);
297        for (int k=0;k<shape[2];k++) {
298          for (int j=0;j<shape[1];j++) {
299            for (int i=0;i<shape[0];i++) {
300              assert(myDataView(i,j,k)==1.0);
301            }
302          }
303        }
304    
305        myDataView = myData.getDataPointByTag(1);
306        assert(!myDataView.isEmpty());
307        assert(myDataView.getOffset()==8);
308        assert(myDataView.getRank()==3);
309        assert(myDataView.noValues()==8);
310        assert(myDataView.getShape().size()==3);
311        for (int k=0;k<shape[2];k++) {
312          for (int j=0;j<shape[1];j++) {
313            for (int i=0;i<shape[0];i++) {
314              assert(myDataView(i,j,k)==1.0);
315            }
316          }
317        }
318    
319        myDataView = myData.getDataPointByTag(2);
320        assert(!myDataView.isEmpty());
321        assert(myDataView.getOffset()==16);
322        assert(myDataView.getRank()==3);
323        assert(myDataView.noValues()==8);
324        assert(myDataView.getShape().size()==3);
325        for (int k=0;k<shape[2];k++) {
326          for (int j=0;j<shape[1];j++) {
327            for (int i=0;i<shape[0];i++) {
328              assert(myDataView(i,j,k)==2.0);
329            }
330          }
331        }
332    
333        myDataView = myData.getDataPointByTag(3);
334        assert(!myDataView.isEmpty());
335        assert(myDataView.getOffset()==24);
336        assert(myDataView.getRank()==3);
337        assert(myDataView.noValues()==8);
338        assert(myDataView.getShape().size()==3);
339        for (int k=0;k<shape[2];k++) {
340          for (int j=0;j<shape[1];j++) {
341            for (int i=0;i<shape[0];i++) {
342              assert(myDataView(i,j,k)==3.0);
343            }
344        }        }
345      }      }
346    
347        myDataView = myData.getDefaultValue();
348        assert(!myDataView.isEmpty());
349        assert(myDataView.getOffset()==0);
350        assert(myDataView.getRank()==3);
351        assert(myDataView.noValues()==8);
352        assert(myDataView.getShape().size()==3);
353        for (int k=0;k<shape[2];k++) {
354          for (int j=0;j<shape[1];j++) {
355            for (int i=0;i<shape[0];i++) {
356              assert(myDataView(i,j,k)==0.0);
357            }
358          }
359        }
360    
361        // use a non-existent tag so we get a pointer to
362        // the first element of the data array
363        double* sampleData=myData.getSampleDataByTag(9);
364        for (int i=0; i<myData.getLength(); i++) {
365          if (i<8) {
366            assert(sampleData[i]==0.0);
367          } else if ((i>=8) && (i<16)) {
368            assert(sampleData[i]==1.0);
369          } else if ((i>=16) && (i<24)) {
370            assert(sampleData[i]==2.0);
371          } else {
372            assert(sampleData[i]==3.0);
373          }
374        }
375    
376    }    }
377    
378  }  }
379    
380  void DataTaggedTestCase::testOperations() {  void DataTaggedTestCase::testOperations() {
# Line 87  void DataTaggedTestCase::testOperations( Line 382  void DataTaggedTestCase::testOperations(
382    cout << endl;    cout << endl;
383    
384    {    {
385      DataTagged left;      cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
386    
387        DataTagged myData;
388        DataTagged right;
389    
390        binaryOp(myData,right,plus<double>());
391    
392        //cout << myData.toString() << endl;
393    
394        assert(myData.getNumSamples()==1);
395        assert(myData.getNumDPPSample()==1);
396    
397        assert(myData.validSamplePointNo(0));
398        assert(myData.validSampleNo(0));
399        assert(!myData.validSamplePointNo(1));
400        assert(!myData.validSampleNo(1));
401    
402        // data-point 0 has tag number 1 by default
403        assert(myData.getTagNumber(0)==1);
404    
405        assert(!myData.isCurrentTag(1));
406    
407        assert(myData.getTagLookup().size()==0);
408    
409        assert(myData.getLength()==1);
410    
411        assert(myData.getPointOffset(0,0)==0);
412    
413        DataArrayView myDataView = myData.getDataPoint(0,0);
414        assert(!myDataView.isEmpty());
415        assert(myDataView.getOffset()==0);
416        assert(myDataView.getRank()==0);
417        assert(myDataView.noValues()==1);
418        assert(myDataView.getShape().size()==0);
419        assert(myDataView()==0.0);
420    
421        // Test non-existent tag returns the default value.
422        myDataView = myData.getDataPointByTag(1);
423        assert(!myDataView.isEmpty());
424        assert(myDataView.getOffset()==0);
425        assert(myDataView.getRank()==0);
426        assert(myDataView.noValues()==1);
427        assert(myDataView.getShape().size()==0);
428        assert(myDataView()==0.0);
429    
430        myDataView = myData.getDefaultValue();
431        assert(!myDataView.isEmpty());
432        assert(myDataView.getOffset()==0);
433        assert(myDataView.getRank()==0);
434        assert(myDataView.noValues()==1);
435        assert(myDataView.getShape().size()==0);
436        assert(myDataView()==0.0);
437    
438        // use a non-existent tag so we get a pointer to
439        // the first element of the data array
440        double* sampleData=myData.getSampleDataByTag(9);
441        for (int i=0; i<myData.getLength(); i++) {
442          assert(sampleData[i]==i);
443        }
444    
445      }
446    
447      {
448        cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
449    
450        DataArrayView::ShapeType viewShape;
451        viewShape.push_back(3);
452    
453        DataTagged::TagListType keys;
454    
455        DataTagged::ValueListType values;
456    
457        DataArrayView::ValueType viewData(3);
458        for (int i=0;i<viewShape[0];i++) {
459          viewData[i]=i;
460        }
461        DataArrayView myView(viewData,viewShape);
462    
463        DataTagged myData(keys,values,myView,FunctionSpace());
464        DataTagged right(keys,values,myView,FunctionSpace());
465    
466        binaryOp(myData,right,plus<double>());
467    
468        //cout << myData.toString() << endl;
469    
470        assert(myData.getNumSamples()==1);
471        assert(myData.getNumDPPSample()==1);
472    
473        assert(myData.validSamplePointNo(0));
474        assert(myData.validSampleNo(0));
475        assert(!myData.validSamplePointNo(1));
476        assert(!myData.validSampleNo(1));
477    
478        // data-point 0 has tag number 1 by default
479        assert(myData.getTagNumber(0)==1);
480    
481        assert(!myData.isCurrentTag(1));
482    
483        assert(myData.getTagLookup().size()==0);
484    
485        assert(myData.getLength()==3);
486    
487        assert(myData.getPointOffset(0,0)==0);
488    
489        DataArrayView myDataView = myData.getDefaultValue();
490        assert(!myDataView.isEmpty());
491        assert(myDataView.getOffset()==0);
492        assert(myDataView.getRank()==1);
493        assert(myDataView.noValues()==3);
494        assert(myDataView.getShape().size()==1);
495        assert(myDataView(0)==0);
496        assert(myDataView(1)==2);
497        assert(myDataView(2)==4);
498    
499        // use a non-existent tag so we get a pointer to
500        // the first element of the data array
501        double* sampleData=myData.getSampleDataByTag(9);
502        for (int i=0; i<myData.getLength(); i++) {
503          assert(sampleData[i]==i*2);
504        }
505    
506      }
507    
508      {
509        cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
510    
511        DataTagged myData;
512      DataTagged right;      DataTagged right;
513    
514      cout << "\tTest default DataTagged contains only a default value." << endl;      DataArray vOne(1.0);
515      binaryOp(left,right,plus<double>());      myData.addTaggedValue(1,vOne.getView());
516      assert(left.getPointDataView()()==0);      right.addTaggedValue(1,vOne.getView());
517      assert(right.getPointDataView()()==0);  
518        binaryOp(myData,right,plus<double>());
519    
520        assert(myData.getNumSamples()==1);
521        assert(myData.getNumDPPSample()==1);
522    
523        assert(myData.validSamplePointNo(0));
524        assert(myData.validSampleNo(0));
525        assert(!myData.validSamplePointNo(1));
526        assert(!myData.validSampleNo(1));
527    
528        // data-point 0 has tag number 1 by default
529        assert(myData.getTagNumber(0)==1);
530    
531        assert(myData.isCurrentTag(1));
532    
533        assert(myData.getTagLookup().size()==1);
534    
535        assert(myData.getLength()==2);
536    
537        assert(myData.getPointOffset(0,0)==1);
538    
539        // check result value for tag "1"
540        DataArrayView myDataView = myData.getDataPointByTag(1);
541        assert(!myDataView.isEmpty());
542        assert(myDataView.getOffset()==1);
543        assert(myDataView.getRank()==0);
544        assert(myDataView.noValues()==1);
545        assert(myDataView.getShape().size()==0);
546        assert(myDataView()==2.0);
547    
548        // check result for default value
549        myDataView = myData.getDefaultValue();
550        assert(!myDataView.isEmpty());
551        assert(myDataView.getOffset()==0);
552        assert(myDataView.getRank()==0);
553        assert(myDataView.noValues()==1);
554        assert(myDataView.getShape().size()==0);
555        assert(myDataView()==0.0);
556    
557        // use a non-existent tag so we get a pointer to
558        // the first element of the data array
559        double* sampleData=myData.getSampleDataByTag(9);
560        for (int i=0; i<myData.getLength(); i++) {
561          assert(sampleData[i]==i*2);
562        }
563    
564      }
565    
566      {
567        cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
568    
569        DataTagged myData;
570        DataTagged right;
571    
     cout << "\tTest binaryOp(plus)." << endl;  
572      DataArray vOne(1.0);      DataArray vOne(1.0);
573      DataArray vTwo(2.0);      DataArray vTwo(2.0);
574      right.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
575      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
576      binaryOp(left,right,plus<double>());  
577      assert(left.getPointDataView()()==0);      binaryOp(myData,right,plus<double>());
578      assert(left.getDataPointByTag(1)==vOne.getView());  
579      assert(left.getDataPointByTag(2)==vTwo.getView());      assert(myData.getNumSamples()==1);
580        assert(myData.getNumDPPSample()==1);
581      cout << "\tTest binaryOp(multiplies)." << endl;  
582      DataArray vZero(0.0);      assert(myData.validSamplePointNo(0));
583      right.setTaggedValue(1,vZero.getView());      assert(myData.validSampleNo(0));
584      right.setTaggedValue(2,vZero.getView());      assert(!myData.validSamplePointNo(1));
585      binaryOp(left,right,multiplies<double>());      assert(!myData.validSampleNo(1));
586      assert(left.getPointDataView()()==0);  
587      assert(left.getDataPointByTag(1)==vZero.getView());      // data-point 0 has tag number 1 by default
588      assert(left.getDataPointByTag(2)==vZero.getView());      assert(myData.getTagNumber(0)==1);
589    
590        assert(myData.isCurrentTag(1));
591        assert(myData.isCurrentTag(2));
592    
593        assert(myData.getTagLookup().size()==2);
594    
595        assert(myData.getLength()==3);
596    
597        assert(myData.getPointOffset(0,0)==1);
598    
599        // check result value for tag "1"
600        DataArrayView myDataView = myData.getDataPointByTag(1);
601        assert(!myDataView.isEmpty());
602        assert(myDataView.getOffset()==1);
603        assert(myDataView.getRank()==0);
604        assert(myDataView.noValues()==1);
605        assert(myDataView.getShape().size()==0);
606        assert(myDataView()==1.0);
607    
608        // check result value for tag "2"
609        myDataView = myData.getDataPointByTag(2);
610        assert(!myDataView.isEmpty());
611        assert(myDataView.getOffset()==2);
612        assert(myDataView.getRank()==0);
613        assert(myDataView.noValues()==1);
614        assert(myDataView.getShape().size()==0);
615        assert(myDataView()==2.0);
616    
617        // check result for default value
618        myDataView = myData.getDefaultValue();
619        assert(!myDataView.isEmpty());
620        assert(myDataView.getOffset()==0);
621        assert(myDataView.getRank()==0);
622        assert(myDataView.noValues()==1);
623        assert(myDataView.getShape().size()==0);
624        assert(myDataView()==0.0);
625    
626        // use a non-existent tag so we get a pointer to
627        // the first element of the data array
628        double* sampleData=myData.getSampleDataByTag(9);
629        for (int i=0; i<myData.getLength(); i++) {
630          assert(sampleData[i]==i);
631        }
632    
633      }
634    
635      {
636        cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
637    
638        DataTagged myData;
639        DataTagged right;
640    
641        DataArray vOne(1.0);
642        myData.addTaggedValue(1,vOne.getView());
643        myData.addTaggedValue(2,vOne.getView());
644        right.addTaggedValue(2,vOne.getView());
645        right.addTaggedValue(3,vOne.getView());
646    
647        binaryOp(myData,right,plus<double>());
648    
649        assert(myData.getNumSamples()==1);
650        assert(myData.getNumDPPSample()==1);
651    
652        assert(myData.validSamplePointNo(0));
653        assert(myData.validSampleNo(0));
654        assert(!myData.validSamplePointNo(1));
655        assert(!myData.validSampleNo(1));
656    
657        // data-point 0 has tag number 1 by default
658        assert(myData.getTagNumber(0)==1);
659    
660        assert(myData.isCurrentTag(1));
661        assert(myData.isCurrentTag(2));
662        assert(myData.isCurrentTag(3));
663    
664        assert(myData.getTagLookup().size()==3);
665    
666        assert(myData.getLength()==4);
667    
668        assert(myData.getPointOffset(0,0)==1);
669    
670        // check result value for tag "1"
671        DataArrayView myDataView = myData.getDataPointByTag(1);
672        assert(!myDataView.isEmpty());
673        assert(myDataView.getOffset()==1);
674        assert(myDataView.getRank()==0);
675        assert(myDataView.noValues()==1);
676        assert(myDataView.getShape().size()==0);
677        assert(myDataView()==1.0);
678    
679        // check result value for tag "2"
680        myDataView = myData.getDataPointByTag(2);
681        assert(!myDataView.isEmpty());
682        assert(myDataView.getOffset()==2);
683        assert(myDataView.getRank()==0);
684        assert(myDataView.noValues()==1);
685        assert(myDataView.getShape().size()==0);
686        assert(myDataView()==2.0);
687    
688        // check result value for tag "3"
689        myDataView = myData.getDataPointByTag(3);
690        assert(!myDataView.isEmpty());
691        assert(myDataView.getOffset()==3);
692        assert(myDataView.getRank()==0);
693        assert(myDataView.noValues()==1);
694        assert(myDataView.getShape().size()==0);
695        assert(myDataView()==1.0);
696    
697        // check result for default value
698        myDataView = myData.getDefaultValue();
699        assert(!myDataView.isEmpty());
700        assert(myDataView.getOffset()==0);
701        assert(myDataView.getRank()==0);
702        assert(myDataView.noValues()==1);
703        assert(myDataView.getShape().size()==0);
704        assert(myDataView()==0.0);
705    
706        // use a non-existent tag so we get a pointer to
707        // the first element of the data array
708        double* sampleData=myData.getSampleDataByTag(9);
709        for (int i=0; i<myData.getLength(); i++) {
710          if (i<3) {
711            assert(sampleData[i]==i);
712          } else {
713            assert(sampleData[i]==i-2);
714          }
715        }
716    
717    }    }
718    
719    {    {
720        cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
721    
722      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
723      viewShape.push_back(3);      viewShape.push_back(3);
724      DataArrayView::ValueType viewData(3);  
725      DataTagged::TagListType keys;      DataTagged::TagListType keys;
726    
727      DataTagged::ValueListType values;      DataTagged::ValueListType values;
728      for (int i=0;i<viewShape[0];++i) {  
729        DataArrayView::ValueType viewData(3);
730        for (int i=0;i<viewShape[0];i++) {
731        viewData[i]=i;        viewData[i]=i;
732      }      }
733      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
734      cout << "\tCreate tagged data with no tag values just a default." << endl;  
735      DataTagged left(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
736      DataTagged right(keys,values,myView,FunctionSpace());      DataTagged right(keys,values,myView,FunctionSpace());
737      binaryOp(left,right,minus<double>());  
738      for (int i=0;i<viewShape[0];++i) {      binaryOp(myData,right,multiplies<double>());
739        assert(left.getDefaultValue()(i)==0);  
740      }      //cout << myData.toString() << endl;
741      double mVal=10.0;  
742      for (int i=0;i<viewShape[0];++i) {      assert(myData.getNumSamples()==1);
743        viewData[i]=i*mVal;      assert(myData.getNumDPPSample()==1);
744      }  
745      cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;      assert(myData.validSamplePointNo(0));
746      binaryOp(left,myView,minus<double>());      assert(myData.validSampleNo(0));
747      for (int i=0;i<viewShape[0];++i) {      assert(!myData.validSamplePointNo(1));
748        assert(left.getDefaultValue()(i)==-(i*mVal));      assert(!myData.validSampleNo(1));
749    
750        // data-point 0 has tag number 1 by default
751        assert(myData.getTagNumber(0)==1);
752    
753        assert(!myData.isCurrentTag(1));
754    
755        assert(myData.getTagLookup().size()==0);
756    
757        assert(myData.getLength()==3);
758    
759        assert(myData.getPointOffset(0,0)==0);
760    
761        DataArrayView myDataView = myData.getDefaultValue();
762        assert(!myDataView.isEmpty());
763        assert(myDataView.getOffset()==0);
764        assert(myDataView.getRank()==1);
765        assert(myDataView.noValues()==3);
766        assert(myDataView.getShape().size()==1);
767        assert(myDataView(0)==0);
768        assert(myDataView(1)==1);
769        assert(myDataView(2)==4);
770    
771        // use a non-existent tag so we get a pointer to
772        // the first element of the data array
773        double* sampleData=myData.getSampleDataByTag(9);
774        for (int i=0; i<myData.getLength(); i++) {
775          assert(sampleData[i]==i*i);
776      }      }
777    
778    }    }
779    
780    {    {
781      cout << "\tTest unaryOp(negate) on default DataTagged." << endl;      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
782      DataTagged data;  
783      unaryOp(data,negate<double>());      DataTagged myData;
784      assert(data.getDefaultValue()()==0);      DataTagged right;
785      DataArray vOne(1);  
786      binaryOp(data,vOne.getView(),plus<double>());      DataArray vOne(1.0);
787      assert(data.getDefaultValue()()==1);      DataArray vTwo(2.0);
788      unaryOp(data,negate<double>());      myData.addTaggedValue(1,vOne.getView());
789      assert(data.getDefaultValue()()==-1);      myData.addTaggedValue(2,vOne.getView());
790        right.addTaggedValue(2,vTwo.getView());
791        right.addTaggedValue(3,vTwo.getView());
792    
793        binaryOp(myData,right,multiplies<double>());
794    
795        assert(myData.getNumSamples()==1);
796        assert(myData.getNumDPPSample()==1);
797    
798        assert(myData.validSamplePointNo(0));
799        assert(myData.validSampleNo(0));
800        assert(!myData.validSamplePointNo(1));
801        assert(!myData.validSampleNo(1));
802    
803        // data-point 0 has tag number 1 by default
804        assert(myData.getTagNumber(0)==1);
805    
806        assert(myData.isCurrentTag(1));
807        assert(myData.isCurrentTag(2));
808        assert(myData.isCurrentTag(3));
809    
810        assert(myData.getTagLookup().size()==3);
811    
812        assert(myData.getLength()==4);
813    
814        assert(myData.getPointOffset(0,0)==1);
815    
816        // check result value for tag "1"
817        DataArrayView myDataView = myData.getDataPointByTag(1);
818        assert(!myDataView.isEmpty());
819        assert(myDataView.getOffset()==1);
820        assert(myDataView.getRank()==0);
821        assert(myDataView.noValues()==1);
822        assert(myDataView.getShape().size()==0);
823        assert(myDataView()==0.0);
824    
825        // check result value for tag "2"
826        myDataView = myData.getDataPointByTag(2);
827        assert(!myDataView.isEmpty());
828        assert(myDataView.getOffset()==2);
829        assert(myDataView.getRank()==0);
830        assert(myDataView.noValues()==1);
831        assert(myDataView.getShape().size()==0);
832        assert(myDataView()==2.0);
833    
834        // check result value for tag "3"
835        myDataView = myData.getDataPointByTag(3);
836        assert(!myDataView.isEmpty());
837        assert(myDataView.getOffset()==3);
838        assert(myDataView.getRank()==0);
839        assert(myDataView.noValues()==1);
840        assert(myDataView.getShape().size()==0);
841        assert(myDataView()==0.0);
842    
843        // check result for default value
844        myDataView = myData.getDefaultValue();
845        assert(!myDataView.isEmpty());
846        assert(myDataView.getOffset()==0);
847        assert(myDataView.getRank()==0);
848        assert(myDataView.noValues()==1);
849        assert(myDataView.getShape().size()==0);
850        assert(myDataView()==0.0);
851    
852        // use a non-existent tag so we get a pointer to
853        // the first element of the data array
854        double* sampleData=myData.getSampleDataByTag(9);
855        for (int i=0; i<myData.getLength(); i++) {
856          if (i==2) {
857            assert(sampleData[i]==2);
858          } else {
859            assert(sampleData[i]==0);
860          }
861        }
862    
863      }
864    
865      {
866        cout << "\tTest unaryOp negate on default DataTagged object." << endl;
867    
868        DataTagged myData;
869    
870        unaryOp(myData,negate<double>());
871    
872        //cout << myData.toString() << endl;
873    
874        assert(myData.getNumSamples()==1);
875        assert(myData.getNumDPPSample()==1);
876    
877        assert(myData.validSamplePointNo(0));
878        assert(myData.validSampleNo(0));
879        assert(!myData.validSamplePointNo(1));
880        assert(!myData.validSampleNo(1));
881    
882        // data-point 0 has tag number 1 by default
883        assert(myData.getTagNumber(0)==1);
884    
885        assert(!myData.isCurrentTag(1));
886    
887        assert(myData.getTagLookup().size()==0);
888    
889        assert(myData.getLength()==1);
890    
891        assert(myData.getPointOffset(0,0)==0);
892    
893        DataArrayView myDataView = myData.getDataPoint(0,0);
894        assert(!myDataView.isEmpty());
895        assert(myDataView.getOffset()==0);
896        assert(myDataView.getRank()==0);
897        assert(myDataView.noValues()==1);
898        assert(myDataView.getShape().size()==0);
899        assert(myDataView()==0.0);
900    
901        // Test non-existent tag returns the default value.
902        myDataView = myData.getDataPointByTag(1);
903        assert(!myDataView.isEmpty());
904        assert(myDataView.getOffset()==0);
905        assert(myDataView.getRank()==0);
906        assert(myDataView.noValues()==1);
907        assert(myDataView.getShape().size()==0);
908        assert(myDataView()==0.0);
909    
910        myDataView = myData.getDefaultValue();
911        assert(!myDataView.isEmpty());
912        assert(myDataView.getOffset()==0);
913        assert(myDataView.getRank()==0);
914        assert(myDataView.noValues()==1);
915        assert(myDataView.getShape().size()==0);
916        assert(myDataView()==0.0);
917    
918        // use a non-existent tag so we get a pointer to
919        // the first element of the data array
920        double* sampleData=myData.getSampleDataByTag(9);
921        for (int i=0; i<myData.getLength(); i++) {
922          assert(sampleData[i]==i);
923        }
924    
925    }    }
926    
927    {    {
928      cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;      cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
929      DataArrayView::ShapeType vShape;  
930      vShape.push_back(3);      DataArrayView::ShapeType viewShape;
931      vShape.push_back(2);      viewShape.push_back(3);
932      vShape.push_back(1);  
     DataArray defData(vShape,0.0);  
     DataArrayView& defView=defData.getView();  
     DataArray tOneData(vShape,1.0);  
     DataArrayView& tOneView=tOneData.getView();  
     DataArray tTwoData(vShape,2.0);  
     DataArrayView& tTwoView=tTwoData.getView();  
     DataArray tThreeData(vShape,3.0);  
     DataArrayView& tThreeView=tThreeData.getView();  
933      DataTagged::TagListType keys;      DataTagged::TagListType keys;
934    
935      DataTagged::ValueListType values;      DataTagged::ValueListType values;
936      keys.push_back(1);  
937      keys.push_back(2);      DataArrayView::ValueType viewData(3);
938      keys.push_back(3);      for (int i=0;i<viewShape[0];i++) {
939      values.push_back(tOneView);        viewData[i]=i;
940      values.push_back(tTwoView);      }
941      values.push_back(tThreeView);      DataArrayView myView(viewData,viewShape);
942      DataTagged tData(keys,values,defView,FunctionSpace());  
943      unaryOp(tData,negate<double>());      DataTagged myData(keys,values,myView,FunctionSpace());
944      unaryOp(tData,negate<double>());  
945      assert(tData.getDataPointByTag(1)==tOneView);      unaryOp(myData,negate<double>());
946      assert(tData.getDataPointByTag(2)==tTwoView);  
947      assert(tData.getDataPointByTag(3)==tThreeView);      //cout << myData.toString() << endl;
948    
949        assert(myData.getNumSamples()==1);
950        assert(myData.getNumDPPSample()==1);
951    
952        assert(myData.validSamplePointNo(0));
953        assert(myData.validSampleNo(0));
954        assert(!myData.validSamplePointNo(1));
955        assert(!myData.validSampleNo(1));
956    
957        // data-point 0 has tag number 1 by default
958        assert(myData.getTagNumber(0)==1);
959    
960        assert(!myData.isCurrentTag(1));
961    
962        assert(myData.getTagLookup().size()==0);
963    
964        assert(myData.getLength()==3);
965    
966        assert(myData.getPointOffset(0,0)==0);
967    
968        DataArrayView myDataView = myData.getDefaultValue();
969        assert(!myDataView.isEmpty());
970        assert(myDataView.getOffset()==0);
971        assert(myDataView.getRank()==1);
972        assert(myDataView.noValues()==3);
973        assert(myDataView.getShape().size()==1);
974        assert(myDataView(0)==0);
975        assert(myDataView(1)==-1);
976        assert(myDataView(2)==-2);
977    
978        // use a non-existent tag so we get a pointer to
979        // the first element of the data array
980        double* sampleData=myData.getSampleDataByTag(9);
981        for (int i=0; i<myData.getLength(); i++) {
982          assert(sampleData[i]==0-i);
983        }
984    
985      }
986    
987      {
988        cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;
989    
990        DataTagged myData;
991    
992        DataArray vOne(1.0);
993        DataArray vTwo(2.0);
994        myData.addTaggedValue(1,vOne.getView());
995        myData.addTaggedValue(2,vTwo.getView());
996    
997        unaryOp(myData,negate<double>());
998    
999        assert(myData.getNumSamples()==1);
1000        assert(myData.getNumDPPSample()==1);
1001    
1002        assert(myData.validSamplePointNo(0));
1003        assert(myData.validSampleNo(0));
1004        assert(!myData.validSamplePointNo(1));
1005        assert(!myData.validSampleNo(1));
1006    
1007        // data-point 0 has tag number 1 by default
1008        assert(myData.getTagNumber(0)==1);
1009    
1010        assert(myData.isCurrentTag(1));
1011        assert(myData.isCurrentTag(2));
1012    
1013        assert(myData.getTagLookup().size()==2);
1014    
1015        assert(myData.getLength()==3);
1016    
1017        assert(myData.getPointOffset(0,0)==1);
1018    
1019        // check result value for tag "1"
1020        DataArrayView myDataView = myData.getDataPointByTag(1);
1021        assert(!myDataView.isEmpty());
1022        assert(myDataView.getOffset()==1);
1023        assert(myDataView.getRank()==0);
1024        assert(myDataView.noValues()==1);
1025        assert(myDataView.getShape().size()==0);
1026        assert(myDataView()==-1.0);
1027    
1028        // check result value for tag "2"
1029        myDataView = myData.getDataPointByTag(2);
1030        assert(!myDataView.isEmpty());
1031        assert(myDataView.getOffset()==2);
1032        assert(myDataView.getRank()==0);
1033        assert(myDataView.noValues()==1);
1034        assert(myDataView.getShape().size()==0);
1035        assert(myDataView()==-2.0);
1036    
1037        // check result for default value
1038        myDataView = myData.getDefaultValue();
1039        assert(!myDataView.isEmpty());
1040        assert(myDataView.getOffset()==0);
1041        assert(myDataView.getRank()==0);
1042        assert(myDataView.noValues()==1);
1043        assert(myDataView.getShape().size()==0);
1044        assert(myDataView()==0.0);
1045    
1046        // use a non-existent tag so we get a pointer to
1047        // the first element of the data array
1048        double* sampleData=myData.getSampleDataByTag(9);
1049        for (int i=0; i<myData.getLength(); i++) {
1050          assert(sampleData[i]==0-i);
1051        }
1052    
1053    }    }
1054    
1055  }  }
# Line 238  void DataTaggedTestCase::testAddTaggedVa Line 1105  void DataTaggedTestCase::testAddTaggedVa
1105      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1106      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1107    
1108        // use a non-existent tag so we get a pointer to
1109        // the first element of the data array
1110        double* sampleData=myData.getSampleDataByTag(9);
1111        for (int i=0; i<myData.getLength(); i++) {
1112          assert(sampleData[i]==0);
1113        }
1114    
1115    }    }
1116    
1117    {    {
# Line 293  void DataTaggedTestCase::testAddTaggedVa Line 1167  void DataTaggedTestCase::testAddTaggedVa
1167      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1168      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1169    
1170        // use a non-existent tag so we get a pointer to
1171        // the first element of the data array
1172        double* sampleData=myData.getSampleDataByTag(9);
1173        for (int i=0; i<myData.getLength(); i++) {
1174          assert(sampleData[i]==i);
1175        }
1176    
1177    }    }
1178    
1179    {    {
# Line 368  void DataTaggedTestCase::testAddTaggedVa Line 1249  void DataTaggedTestCase::testAddTaggedVa
1249      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1250      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1251    
1252        // use a non-existent tag so we get a pointer to
1253        // the first element of the data array
1254        double* sampleData=myData.getSampleDataByTag(9);
1255        for (int i=0; i<myData.getLength(); i++) {
1256          if (i==0) {
1257            assert(sampleData[i]==0);
1258          } else {
1259            assert(sampleData[i]==1);
1260          }
1261        }
1262    
1263    }    }
1264    
1265    {    {
# Line 451  void DataTaggedTestCase::testAddTaggedVa Line 1343  void DataTaggedTestCase::testAddTaggedVa
1343      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1344      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1345    
1346        // use a non-existent tag so we get a pointer to
1347        // the first element of the data array
1348        double* sampleData=myData.getSampleDataByTag(9);
1349        for (int i=0; i<myData.getLength(); i++) {
1350          assert(sampleData[i]==i);
1351        }
1352    
1353    }    }
1354    
1355    {    {
# Line 521  void DataTaggedTestCase::testAddTaggedVa Line 1420  void DataTaggedTestCase::testAddTaggedVa
1420      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1421      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1422    
1423        // use a non-existent tag so we get a pointer to
1424        // the first element of the data array
1425        double* sampleData=myData.getSampleDataByTag(9);
1426        for (int i=0; i<myData.getLength(); i++) {
1427          assert(sampleData[i]==i%3);
1428        }
1429    
1430    }    }
1431    
1432    {    {
# Line 546  void DataTaggedTestCase::testAddTaggedVa Line 1452  void DataTaggedTestCase::testAddTaggedVa
1452    
1453      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1454      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1455        viewData1[i]=i+1;        viewData1[i]=i+3;
1456      }      }
1457      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1458      values.push_back(myView1);      values.push_back(myView1);
# Line 571  void DataTaggedTestCase::testAddTaggedVa Line 1477  void DataTaggedTestCase::testAddTaggedVa
1477      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1478      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1479      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1480      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1481      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1482      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1483    
1484      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
1485      assert(myDataView==myView1);      assert(myDataView==myView1);
# Line 582  void DataTaggedTestCase::testAddTaggedVa Line 1488  void DataTaggedTestCase::testAddTaggedVa
1488      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1489      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1490      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1491      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1492      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1493      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1494    
1495      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
1496      assert(myDataView==myView);      assert(myDataView==myView);
# Line 597  void DataTaggedTestCase::testAddTaggedVa Line 1503  void DataTaggedTestCase::testAddTaggedVa
1503      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1504      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1505    
1506        // use a non-existent tag so we get a pointer to
1507        // the first element of the data array
1508        double* sampleData=myData.getSampleDataByTag(9);
1509        for (int i=0; i<myData.getLength(); i++) {
1510          assert(sampleData[i]==i);
1511        }
1512    
1513    }    }
1514    
1515    {    {
# Line 624  void DataTaggedTestCase::testAddTaggedVa Line 1537  void DataTaggedTestCase::testAddTaggedVa
1537    
1538      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1539      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1540        viewData1[i]=i+1;        viewData1[i]=3;
1541      }      }
1542      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1543      values.push_back(myView1);      values.push_back(myView1);
# Line 651  void DataTaggedTestCase::testAddTaggedVa Line 1564  void DataTaggedTestCase::testAddTaggedVa
1564      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1565      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1566      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1567      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1568      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1569      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1570    
1571      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
# Line 662  void DataTaggedTestCase::testAddTaggedVa Line 1575  void DataTaggedTestCase::testAddTaggedVa
1575      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1576      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1577      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1578      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1579      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1580      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1581    
1582      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 673  void DataTaggedTestCase::testAddTaggedVa Line 1586  void DataTaggedTestCase::testAddTaggedVa
1586      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1587      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1588      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1589      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1590      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1591      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1592    
1593      myDataView = myData.getDataPointByTag(3);      myDataView = myData.getDataPointByTag(3);
# Line 684  void DataTaggedTestCase::testAddTaggedVa Line 1597  void DataTaggedTestCase::testAddTaggedVa
1597      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1598      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1599      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1600      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1601      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1602      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1603    
1604      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 699  void DataTaggedTestCase::testAddTaggedVa Line 1612  void DataTaggedTestCase::testAddTaggedVa
1612      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1613      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1614    
1615        // use a non-existent tag so we get a pointer to
1616        // the first element of the data array
1617        double* sampleData=myData.getSampleDataByTag(9);
1618        for (int i=0; i<myData.getLength(); i++) {
1619          if (i<3) {
1620            assert(sampleData[i]==i);
1621          } else {
1622            assert(sampleData[i]==3);
1623          }
1624        }
1625    
1626    }    }
1627    
1628    {    {
# Line 815  void DataTaggedTestCase::testAddTaggedVa Line 1739  void DataTaggedTestCase::testAddTaggedVa
1739      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1740      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1741    
1742        // use a non-existent tag so we get a pointer to
1743        // the first element of the data array
1744        double* sampleData=myData.getSampleDataByTag(9);
1745        for (int i=0; i<myData.getLength(); i++) {
1746          if (i<3) {
1747            assert(sampleData[i]==i);
1748          } else if ((i>=3) && (i<6)) {
1749            assert(sampleData[i]==i-2);
1750          } else if ((i>=6) && (i<9)) {
1751            assert(sampleData[i]==i-4);
1752          } else  {
1753            assert(sampleData[i]==i-6);
1754          }
1755        }
1756    
1757    }    }
1758    
1759    {    {
# Line 884  void DataTaggedTestCase::testAddTaggedVa Line 1823  void DataTaggedTestCase::testAddTaggedVa
1823      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1824      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1825    
1826        // use a non-existent tag so we get a pointer to
1827        // the first element of the data array
1828        double* sampleData=myData.getSampleDataByTag(9);
1829        for (int i=0; i<myData.getLength(); i++) {
1830          if (i<3) {
1831            assert(sampleData[i]==i);
1832          } else if ((i>=3) && (i<6)) {
1833            assert(sampleData[i]==i-2);
1834          } else if ((i>=6) && (i<9)) {
1835            assert(sampleData[i]==i-4);
1836          } else if ((i>=9) && (i<12)) {
1837            assert(sampleData[i]==i-6);
1838          } else {
1839            assert(sampleData[i]==i-12);
1840          }
1841        }
1842    
1843    }    }
1844    
1845    {    {
# Line 960  void DataTaggedTestCase::testAddTaggedVa Line 1916  void DataTaggedTestCase::testAddTaggedVa
1916      assert(myDataView(1)==5);      assert(myDataView(1)==5);
1917      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1918    
1919        // use a non-existent tag so we get a pointer to
1920        // the first element of the data array
1921        double* sampleData=myData.getSampleDataByTag(9);
1922        for (int i=0; i<myData.getLength(); i++) {
1923          if (i<3) {
1924            assert(sampleData[i]==i);
1925          } else if ((i>=3) && (i<6)) {
1926            assert(sampleData[i]==i-2);
1927          } else if ((i>=6) && (i<9)) {
1928            assert(sampleData[i]==i-4);
1929          } else if ((i>=9) && (i<12)) {
1930            assert(sampleData[i]==i-6);
1931          } else {
1932            assert(sampleData[i]==i-8);
1933          }
1934        }
1935    
1936    }    }
1937    
1938    {    {
# Line 1062  void DataTaggedTestCase::testAddTaggedVa Line 2035  void DataTaggedTestCase::testAddTaggedVa
2035      assert(myDataView(1)==5);      assert(myDataView(1)==5);
2036      assert(myDataView(2)==6);      assert(myDataView(2)==6);
2037    
2038        // use a non-existent tag so we get a pointer to
2039        // the first element of the data array
2040        double* sampleData=myData.getSampleDataByTag(9);
2041        for (int i=0; i<myData.getLength(); i++) {
2042          if (i<3) {
2043            assert(sampleData[i]==i);
2044          } else if ((i>=3) && (i<6)) {
2045            assert(sampleData[i]==i-2);
2046          } else if ((i>=6) && (i<9)) {
2047            assert(sampleData[i]==i-4);
2048          } else if ((i>=9) && (i<12)) {
2049            assert(sampleData[i]==i-6);
2050          } else if ((i>=12) && (i<15)) {
2051            assert(sampleData[i]==i-8);
2052          } else if ((i>=15) && (i<18)) {
2053            assert(sampleData[i]==i-11);
2054          } else {
2055            assert(sampleData[i]==i-14);
2056          }
2057        }
2058    
2059    }    }
2060    
2061    {    {
# Line 1179  void DataTaggedTestCase::testAddTaggedVa Line 2173  void DataTaggedTestCase::testAddTaggedVa
2173      assert(myDataView(1)==7);      assert(myDataView(1)==7);
2174      assert(myDataView(2)==8);      assert(myDataView(2)==8);
2175    
2176        // use a non-existent tag so we get a pointer to
2177        // the first element of the data array
2178        double* sampleData=myData.getSampleDataByTag(9);
2179        for (int i=0; i<myData.getLength(); i++) {
2180          if (i<3) {
2181            assert(sampleData[i]==i);
2182          } else if ((i>=3) && (i<6)) {
2183            assert(sampleData[i]==i-2);
2184          } else if ((i>=6) && (i<9)) {
2185            assert(sampleData[i]==i-4);
2186          } else if ((i>=9) && (i<12)) {
2187            assert(sampleData[i]==i-6);
2188          } else if ((i>=12) && (i<15)) {
2189            assert(sampleData[i]==i-8);
2190          } else if ((i>=15) && (i<18)) {
2191            assert(sampleData[i]==i-10);
2192          } else {
2193            assert(sampleData[i]==i-12);
2194          }
2195        }
2196    
2197    }    }
2198    
2199  }  }
# Line 1255  void DataTaggedTestCase::testSetTaggedVa Line 2270  void DataTaggedTestCase::testSetTaggedVa
2270      assert(myDataView(1)==6);      assert(myDataView(1)==6);
2271      assert(myDataView(2)==7);      assert(myDataView(2)==7);
2272    
2273        // use a non-existent tag so we get a pointer to
2274        // the first element of the data array
2275        double* sampleData=myData.getSampleDataByTag(9);
2276        for (int i=0; i<myData.getLength(); i++) {
2277          if (i<3) {
2278            assert(sampleData[i]==i);
2279          } else if ((i>=3) && (i<6)) {
2280            assert(sampleData[i]==i-2);
2281          } else if ((i>=6) && (i<9)) {
2282            assert(sampleData[i]==i-1);
2283          } else {
2284            assert(sampleData[i]==i-6);
2285          }
2286        }
2287    
2288    }    }
2289    
2290  }  }
# Line 1314  void DataTaggedTestCase::testAll() { Line 2344  void DataTaggedTestCase::testAll() {
2344      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2345      assert(myDataView()==0.0);      assert(myDataView()==0.0);
2346    
2347        // use a non-existent tag so we get a pointer to
2348        // the first element of the data array
2349        double* sampleData=myData.getSampleDataByTag(9);
2350        for (int i=0; i<myData.getLength(); i++) {
2351          assert(sampleData[i]==i);
2352        }
2353        sampleData=myData.getSampleData(0);
2354        for (int i=0; i<myDataView.noValues(); i++) {
2355          assert(sampleData[i]==i);
2356        }
2357    
2358    }    }
2359    
2360    {    {
# Line 1390  void DataTaggedTestCase::testAll() { Line 2431  void DataTaggedTestCase::testAll() {
2431      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2432      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2433    
2434        // use a non-existent tag so we get a pointer to
2435        // the first element of the data array
2436        double* sampleData=myData.getSampleDataByTag(9);
2437        for (int i=0; i<myData.getLength(); i++) {
2438          assert(sampleData[i]==i);
2439        }
2440        sampleData=myData.getSampleDataByTag(0);
2441        for (int i=0; i<myDataView.noValues(); i++) {
2442          assert(sampleData[i]==i);
2443        }
2444    
2445    }    }
2446    
2447    {    {
# Line 1467  void DataTaggedTestCase::testAll() { Line 2519  void DataTaggedTestCase::testAll() {
2519      assert(myDataView(2)==3);      assert(myDataView(2)==3);
2520    
2521      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2522      myDataView = myData.getDataPointByTag(0);      myDataView = myData.getDataPointByTag(9);
2523      assert(myDataView==myView);      assert(myDataView==myView);
2524      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2525      assert(myDataView.getOffset()==0);      assert(myDataView.getOffset()==0);
# Line 1489  void DataTaggedTestCase::testAll() { Line 2541  void DataTaggedTestCase::testAll() {
2541      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2542      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2543    
2544        // use a non-existent tag so we get a pointer to
2545        // the first element of the data array
2546        double* sampleData=myData.getSampleDataByTag(9);
2547        for (int i=0; i<myData.getLength(); i++) {
2548          if (i<3) {
2549            assert(sampleData[i]==i);
2550          } else {
2551            assert(sampleData[i]==i-2);
2552          }
2553        }
2554        sampleData=myData.getSampleData(0);
2555        for (int i=0; i<myDataView.noValues(); i++) {
2556          assert(sampleData[i]==i+1);
2557        }
2558    
2559    }    }
2560    
2561    {    {
# Line 1629  void DataTaggedTestCase::testAll() { Line 2696  void DataTaggedTestCase::testAll() {
2696      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2697      assert(myDataView(2)==5);      assert(myDataView(2)==5);
2698    
2699        // use a non-existent tag so we get a pointer to
2700        // the first element of the data array
2701        double* sampleData=myData.getSampleDataByTag(9);
2702        for (int i=0; i<myData.getLength(); i++) {
2703          if (i<3) {
2704            assert(sampleData[i]==i);
2705          } else if ((i>=3) && (i<6)) {
2706            assert(sampleData[i]==i-2);
2707          } else if ((i>=6) && (i<9)) {
2708            assert(sampleData[i]==i-4);
2709          } else {
2710            assert(sampleData[i]==i-6);
2711          }
2712        }
2713        sampleData=myData.getSampleData(0);
2714        for (int i=0; i<myDataView.noValues(); i++) {
2715          assert(sampleData[i]==i+1);
2716        }
2717    
2718      }
2719    
2720    }
2721    
2722    void DataTaggedTestCase::testCopyConstructors() {
2723    
2724      cout << endl;
2725    
2726      {
2727    
2728        cout << "\tTest DataTagged copy constructor for DataTagged with multiple tags." << endl;
2729    
2730        // the one data-point has tag value "1"
2731    
2732        DataTagged::TagListType keys;
2733        keys.push_back(1);
2734        keys.push_back(2);
2735        keys.push_back(3);
2736    
2737        DataTagged::ValueListType values;
2738    
2739        DataArrayView::ShapeType viewShape;
2740        viewShape.push_back(3);
2741    
2742        // default value
2743        DataArrayView::ValueType viewData(3);
2744        for (int i=0;i<viewShape[0];i++) {
2745          viewData[i]=i;
2746        }
2747        DataArrayView myView(viewData,viewShape);
2748    
2749        // value for tag "1"
2750        DataArray eOne(myView);
2751        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2752          eOne.getView()(i)=i+1.0;
2753        }
2754        values.push_back(eOne.getView());
2755    
2756        // value for tag "2"
2757        DataArray eTwo(myView);
2758        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2759          eTwo.getView()(i)=i+2.0;
2760        }
2761        values.push_back(eTwo.getView());
2762    
2763        // value for tag "3"
2764        DataArray eThree(myView);
2765        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2766          eThree.getView()(i)=i+3.0;
2767        }
2768        values.push_back(eThree.getView());
2769    
2770        DataTagged myData(keys,values,myView,FunctionSpace());
2771    
2772        DataTagged myDataCopy(myData);
2773    
2774        //cout << myDataCopy.toString() << endl;
2775    
2776        assert(myDataCopy.getNumSamples()==1);
2777        assert(myDataCopy.getNumDPPSample()==1);
2778    
2779        assert(myDataCopy.validSamplePointNo(0));
2780        assert(myDataCopy.validSampleNo(0));
2781        assert(!myDataCopy.validSamplePointNo(1));
2782        assert(!myDataCopy.validSampleNo(1));
2783    
2784        // data-point 0 has tag number 1 by default
2785        assert(myDataCopy.getTagNumber(0)==1);
2786    
2787        assert(!myDataCopy.isCurrentTag(0));
2788        assert(myDataCopy.isCurrentTag(1));
2789        assert(myDataCopy.isCurrentTag(2));
2790        assert(myDataCopy.isCurrentTag(3));
2791    
2792        assert(myDataCopy.getTagLookup().size()==3);
2793    
2794        assert(myDataCopy.getLength()==12);
2795    
2796        assert(myDataCopy.getPointOffset(0,0)==3);
2797    
2798        DataArrayView myDataView = myDataCopy.getDataPoint(0,0);
2799        assert(myDataView==eOne.getView());
2800        assert(!myDataView.isEmpty());
2801        assert(myDataView.getOffset()==3);
2802        assert(myDataView.getRank()==1);
2803        assert(myDataView.noValues()==3);
2804        assert(myDataView.getShape().size()==1);
2805        assert(myDataView(0)==1);
2806        assert(myDataView(1)==2);
2807        assert(myDataView(2)==3);
2808    
2809        myDataView = myDataCopy.getDataPointByTag(1);
2810        assert(myDataView==eOne.getView());
2811        assert(!myDataView.isEmpty());
2812        assert(myDataView.getOffset()==3);
2813        assert(myDataView.getRank()==1);
2814        assert(myDataView.noValues()==3);
2815        assert(myDataView.getShape().size()==1);
2816        assert(myDataView(0)==1);
2817        assert(myDataView(1)==2);
2818        assert(myDataView(2)==3);
2819    
2820        // Test non-existent tag returns the default value.
2821        myDataView = myDataCopy.getDataPointByTag(0);
2822        assert(myDataView==myView);
2823        assert(!myDataView.isEmpty());
2824        assert(myDataView.getOffset()==0);
2825        assert(myDataView.getRank()==1);
2826        assert(myDataView.noValues()==3);
2827        assert(myDataView.getShape().size()==1);
2828        assert(myDataView(0)==0);
2829        assert(myDataView(1)==1);
2830        assert(myDataView(2)==2);
2831    
2832        myDataView = myDataCopy.getDefaultValue();
2833        assert(myDataView==myView);
2834        assert(!myDataView.isEmpty());
2835        assert(myDataView.getOffset()==0);
2836        assert(myDataView.getRank()==1);
2837        assert(myDataView.noValues()==3);
2838        assert(myDataView.getShape().size()==1);
2839        assert(myDataView(0)==0);
2840        assert(myDataView(1)==1);
2841        assert(myDataView(2)==2);
2842    
2843        // Test data-points held for remaining tags
2844        myDataView = myDataCopy.getDataPointByTag(2);
2845        assert(myDataView==eTwo.getView());
2846        assert(!myDataView.isEmpty());
2847        assert(myDataView.getOffset()==6);
2848        assert(myDataView.getRank()==1);
2849        assert(myDataView.noValues()==3);
2850        assert(myDataView.getShape().size()==1);
2851        assert(myDataView(0)==2);
2852        assert(myDataView(1)==3);
2853        assert(myDataView(2)==4);
2854    
2855        myDataView = myDataCopy.getDataPointByTag(3);
2856        assert(myDataView==eThree.getView());
2857        assert(!myDataView.isEmpty());
2858        assert(myDataView.getOffset()==9);
2859        assert(myDataView.getRank()==1);
2860        assert(myDataView.noValues()==3);
2861        assert(myDataView.getShape().size()==1);
2862        assert(myDataView(0)==3);
2863        assert(myDataView(1)==4);
2864        assert(myDataView(2)==5);
2865    
2866        // use a non-existent tag so we get a pointer to
2867        // the first element of the data array
2868        double* sampleData=myDataCopy.getSampleDataByTag(9);
2869        for (int i=0; i<myData.getLength(); i++) {
2870          if (i<3) {
2871            assert(sampleData[i]==i);
2872          } else if ((i>=3) && (i<6)) {
2873            assert(sampleData[i]==i-2);
2874          } else if ((i>=6) && (i<9)) {
2875            assert(sampleData[i]==i-4);
2876          } else {
2877            assert(sampleData[i]==i-6);
2878          }
2879        }
2880    
2881      }
2882    
2883      {
2884    
2885        cout << "\tTest DataTagged copy constructor for DataConstant." << endl;
2886    
2887        // Create a DataConstant
2888        DataArrayView::ShapeType shape;
2889        DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
2890        DataArrayView pointData(data,shape);
2891        pointData()=1.0;
2892        DataConstant myConstantData(pointData, FunctionSpace());
2893    
2894        // use this DataConstant to initialise a DataTagged
2895        DataTagged myData(myConstantData);
2896    
2897        //cout << myData.toString() << endl;
2898    
2899        assert(myData.getNumSamples()==1);
2900        assert(myData.getNumDPPSample()==1);
2901    
2902        assert(myData.validSamplePointNo(0));
2903        assert(myData.validSampleNo(0));
2904        assert(!myData.validSamplePointNo(1));
2905        assert(!myData.validSampleNo(1));
2906    
2907        // data-point 0 has tag number 1 by default
2908        assert(myData.getTagNumber(0)==1);
2909    
2910        assert(!myData.isCurrentTag(1));
2911    
2912        assert(myData.getTagLookup().size()==0);
2913    
2914        assert(myData.getLength()==1);
2915    
2916        assert(myData.getPointOffset(0,0)==0);
2917    
2918        DataArrayView myDataView = myData.getDataPoint(0,0);
2919        assert(!myDataView.isEmpty());
2920        assert(myDataView.getOffset()==0);
2921        assert(myDataView.getRank()==0);
2922        assert(myDataView.noValues()==1);
2923        assert(myDataView.getShape().size()==0);
2924        assert(myDataView()==1.0);
2925    
2926        // Test non-existent tag returns the default value.
2927        myDataView = myData.getDataPointByTag(1);
2928        assert(!myDataView.isEmpty());
2929        assert(myDataView.getOffset()==0);
2930        assert(myDataView.getRank()==0);
2931        assert(myDataView.noValues()==1);
2932        assert(myDataView.getShape().size()==0);
2933        assert(myDataView()==1.0);
2934    
2935        myDataView = myData.getDefaultValue();
2936        assert(!myDataView.isEmpty());
2937        assert(myDataView.getOffset()==0);
2938        assert(myDataView.getRank()==0);
2939        assert(myDataView.noValues()==1);
2940        assert(myDataView.getShape().size()==0);
2941        assert(myDataView()==1.0);
2942    
2943        // use a non-existent tag so we get a pointer to
2944        // the first element of the data array
2945        double* sampleData=myData.getSampleDataByTag(9);
2946        for (int i=0; i<myData.getLength(); i++) {
2947          assert(sampleData[i]==i+1);
2948        }
2949    
2950      }
2951    
2952    }
2953    
2954    void DataTaggedTestCase::testSlicing() {
2955    
2956      cout << endl;
2957    
2958      {
2959    
2960        cout << "\tTest slicing default DataTagged." << endl;
2961    
2962        DataTagged myData;
2963    
2964        DataArrayView::RegionType region;
2965    
2966        DataAbstract* slicedDefault = myData.getSlice(region);
2967    
2968        // cout << slicedDefault->toString() << endl;
2969    
2970        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2971    
2972        assert(myDataSliced->getTagLookup().size()==0);
2973    
2974        assert(myDataSliced->getLength()==1);
2975    
2976        DataArrayView myDataView = myDataSliced->getDefaultValue();
2977        assert(!myDataView.isEmpty());
2978        assert(myDataView.getOffset()==0);
2979        assert(myDataView.getRank()==0);
2980        assert(myDataView.noValues()==1);
2981        assert(myDataView.getShape().size()==0);
2982        assert(myDataView()==0.0);
2983    
2984      }
2985    
2986      {
2987    
2988        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
2989    
2990        DataArrayView::ShapeType viewShape;
2991        viewShape.push_back(3);
2992    
2993        DataTagged::TagListType keys;
2994    
2995        DataTagged::ValueListType values;
2996    
2997        DataArrayView::ValueType viewData(3);
2998        for (int i=0;i<viewShape[0];i++) {
2999          viewData[i]=i;
3000        }
3001        DataArrayView myView(viewData,viewShape);
3002    
3003        DataTagged myData(keys,values,myView,FunctionSpace());
3004    
3005        // full slice
3006    
3007        std::pair<int, int> region_element;
3008        region_element.first=0;
3009        region_element.second=3;
3010        DataArrayView::RegionType region;
3011        region.push_back(region_element);
3012    
3013        DataAbstract* slicedDefault = myData.getSlice(region);
3014    
3015        //cout << slicedDefault->toString() << endl;
3016    
3017        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3018    
3019        assert(myDataSliced->getTagLookup().size()==0);
3020    
3021        assert(myDataSliced->getLength()==3);
3022    
3023        DataArrayView myDataView = myDataSliced->getDefaultValue();
3024        assert(!myDataView.isEmpty());
3025        assert(myDataView.getOffset()==0);
3026        assert(myDataView.getRank()==1);
3027        assert(myDataView.noValues()==3);
3028        assert(myDataView.getShape().size()==1);
3029        assert(myDataView(0)==0.0);
3030        assert(myDataView(1)==1.0);
3031        assert(myDataView(2)==2.0);
3032    
3033        // scalar slice
3034    
3035        region.clear();
3036        region_element.first=0;
3037        region_element.second=0;
3038        region.push_back(region_element);
3039    
3040        slicedDefault = myData.getSlice(region);
3041    
3042        //cout << slicedDefault->toString() << endl;
3043    
3044        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3045    
3046        assert(myDataSliced->getTagLookup().size()==0);
3047    
3048        assert(myDataSliced->getLength()==1);
3049    
3050        myDataView = myDataSliced->getDefaultValue();
3051        assert(!myDataView.isEmpty());
3052        assert(myDataView.getOffset()==0);
3053        assert(myDataView.getRank()==0);
3054        assert(myDataView.noValues()==1);
3055        assert(myDataView.getShape().size()==0);
3056        assert(myDataView()==0.0);
3057    
3058      }
3059    
3060      {
3061    
3062        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
3063    
3064        DataArrayView::ShapeType viewShape;
3065        viewShape.push_back(3);
3066        viewShape.push_back(3);
3067        viewShape.push_back(3);
3068    
3069        DataTagged::TagListType keys;
3070    
3071        DataTagged::ValueListType values;
3072    
3073        DataArrayView::ValueType viewData(27);
3074        for (int i=0;i<viewData.size();i++) {
3075          viewData[i]=i;
3076        }
3077        DataArrayView myView(viewData,viewShape);
3078    
3079        DataTagged myData(keys,values,myView,FunctionSpace());
3080    
3081        //cout << myData.toString() << endl;
3082    
3083        // full slice
3084    
3085        std::pair<int, int> region_element;
3086        region_element.first=0;
3087        region_element.second=3;
3088        DataArrayView::RegionType region;
3089        region.push_back(region_element);
3090        region.push_back(region_element);
3091        region.push_back(region_element);
3092    
3093        DataAbstract* slicedDefault = myData.getSlice(region);
3094    
3095        //cout << slicedDefault->toString() << endl;
3096    
3097        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3098    
3099        assert(myDataSliced->getTagLookup().size()==0);
3100    
3101        assert(myDataSliced->getLength()==27);
3102    
3103        DataArrayView myDataView = myDataSliced->getDefaultValue();
3104        assert(!myDataView.isEmpty());
3105        assert(myDataView.getOffset()==0);
3106        assert(myDataView.getRank()==3);
3107        assert(myDataView.noValues()==27);
3108        assert(myDataView.getShape().size()==3);
3109    
3110        // rank 1 slice
3111    
3112        region.clear();
3113        region.push_back(region_element);
3114        region_element.second=0;
3115        region.push_back(region_element);
3116        region.push_back(region_element);
3117    
3118        slicedDefault = myData.getSlice(region);
3119    
3120        //cout << slicedDefault->toString() << endl;
3121    
3122        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3123    
3124        assert(myDataSliced->getTagLookup().size()==0);
3125    
3126        assert(myDataSliced->getLength()==3);
3127    
3128        myDataView = myDataSliced->getDefaultValue();
3129        assert(!myDataView.isEmpty());
3130        assert(myDataView.getOffset()==0);
3131        assert(myDataView.getRank()==1);
3132        assert(myDataView.noValues()==3);
3133        assert(myDataView.getShape().size()==1);
3134        assert(myDataView(0)==0.0);
3135        assert(myDataView(1)==1.0);
3136        assert(myDataView(2)==2.0);
3137    
3138        // scalar slice
3139    
3140        region.clear();
3141        region_element.first=2;
3142        region_element.second=2;
3143        region.push_back(region_element);
3144        region.push_back(region_element);
3145        region.push_back(region_element);
3146    
3147        slicedDefault = myData.getSlice(region);
3148    
3149        //cout << slicedDefault->toString() << endl;
3150    
3151        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3152    
3153        assert(myDataSliced->getTagLookup().size()==0);
3154    
3155        assert(myDataSliced->getLength()==1);
3156    
3157        myDataView = myDataSliced->getDefaultValue();
3158        assert(!myDataView.isEmpty());
3159        assert(myDataView.getOffset()==0);
3160        assert(myDataView.getRank()==0);
3161        assert(myDataView.noValues()==1);
3162        assert(myDataView.getShape().size()==0);
3163        assert(myDataView()==26);
3164    
3165    }    }
3166    
3167  }  }
# Line 1641  TestSuite* DataTaggedTestCase::suite () Line 3174  TestSuite* DataTaggedTestCase::suite ()
3174    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAll",&DataTaggedTestCase::testAll));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAll",&DataTaggedTestCase::testAll));
3175    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAddTaggedValues",&DataTaggedTestCase::testAddTaggedValues));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAddTaggedValues",&DataTaggedTestCase::testAddTaggedValues));
3176    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetTaggedValue",&DataTaggedTestCase::testSetTaggedValue));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetTaggedValue",&DataTaggedTestCase::testSetTaggedValue));
3177  //  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));
3178  //  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
3179      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
3180      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSlicing",&DataTaggedTestCase::testSlicing));
3181    return testSuite;    return testSuite;
3182  }  }

Legend:
Removed from v.502  
changed lines
  Added in v.514

  ViewVC Help
Powered by ViewVC 1.1.26