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

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

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

revision 504 by jgs, Wed Feb 8 05:51:27 2006 UTC revision 510 by jgs, Fri Feb 10 04:00:50 2006 UTC
# Line 51  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 88  void DataTaggedTestCase::testOperations( Line 382  void DataTaggedTestCase::testOperations(
382    cout << endl;    cout << endl;
383    
384    {    {
385        cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
386    
387      DataTagged myData;      DataTagged myData;
388      DataTagged right;      DataTagged right;
389    
     cout << "\tTest addition of two default DataTagged objects." << endl;  
   
390      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
391    
392      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
# Line 140  void DataTaggedTestCase::testOperations( Line 434  void DataTaggedTestCase::testOperations(
434      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
435      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
436      assert(myDataView()==0.0);      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;      DataTagged myData;
512      DataTagged right;      DataTagged right;
513    
     cout << "\tTest addition of two DataTagged objects with one identical tag each." << endl;  
   
514      DataArray vOne(1.0);      DataArray vOne(1.0);
515      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
516      right.addTaggedValue(1,vOne.getView());      right.addTaggedValue(1,vOne.getView());
517    
518      binaryOp(myData,right,plus<double>());      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"      // check result value for tag "1"
540      DataArrayView myDataView = myData.getDataPointByTag(1);      DataArrayView myDataView = myData.getDataPointByTag(1);
541      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
# Line 171  void DataTaggedTestCase::testOperations( Line 553  void DataTaggedTestCase::testOperations(
553      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
554      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
555      assert(myDataView()==0.0);      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;      DataTagged myData;
570      DataTagged right;      DataTagged right;
571    
     cout << "\tTest addition of two DataTagged objects with one different tag each." << endl;  
   
572      DataArray vOne(1.0);      DataArray vOne(1.0);
573        DataArray vTwo(2.0);
574      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
575      right.addTaggedValue(2,vOne.getView());      right.addTaggedValue(2,vTwo.getView());
576    
577      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
578    
579        assert(myData.getNumSamples()==1);
580        assert(myData.getNumDPPSample()==1);
581    
582        assert(myData.validSamplePointNo(0));
583        assert(myData.validSampleNo(0));
584        assert(!myData.validSamplePointNo(1));
585        assert(!myData.validSampleNo(1));
586    
587        // data-point 0 has tag number 1 by default
588        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"      // check result value for tag "1"
600      DataArrayView myDataView = myData.getDataPointByTag(1);      DataArrayView myDataView = myData.getDataPointByTag(1);
601      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
# Line 201  void DataTaggedTestCase::testOperations( Line 612  void DataTaggedTestCase::testOperations(
612      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
613      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
614      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
615      assert(myDataView()==1.0);      assert(myDataView()==2.0);
616    
617      // check result for default value      // check result for default value
618      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 211  void DataTaggedTestCase::testOperations( Line 622  void DataTaggedTestCase::testOperations(
622      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
623      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
624      assert(myDataView()==0.0);      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;      DataTagged myData;
639      DataTagged right;      DataTagged right;
640    
     cout << "\tTest addition of two DataTagged objects with overlapping tag sets." << endl;  
   
641      DataArray vOne(1.0);      DataArray vOne(1.0);
642      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
643      myData.addTaggedValue(2,vOne.getView());      myData.addTaggedValue(2,vOne.getView());
# Line 227  void DataTaggedTestCase::testOperations( Line 646  void DataTaggedTestCase::testOperations(
646    
647      binaryOp(myData,right,plus<double>());      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"      // check result value for tag "1"
671      DataArrayView myDataView = myData.getDataPointByTag(1);      DataArrayView myDataView = myData.getDataPointByTag(1);
672      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
# Line 262  void DataTaggedTestCase::testOperations( Line 702  void DataTaggedTestCase::testOperations(
702      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
703      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
704      assert(myDataView()==0.0);      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;
723        viewShape.push_back(3);
724    
725        DataTagged::TagListType keys;
726    
727        DataTagged::ValueListType values;
728    
729        DataArrayView::ValueType viewData(3);
730        for (int i=0;i<viewShape[0];i++) {
731          viewData[i]=i;
732        }
733        DataArrayView myView(viewData,viewShape);
734    
735        DataTagged myData(keys,values,myView,FunctionSpace());
736        DataTagged right(keys,values,myView,FunctionSpace());
737    
738        binaryOp(myData,right,multiplies<double>());
739    
740        //cout << myData.toString() << endl;
741    
742        assert(myData.getNumSamples()==1);
743        assert(myData.getNumDPPSample()==1);
744    
745        assert(myData.validSamplePointNo(0));
746        assert(myData.validSampleNo(0));
747        assert(!myData.validSamplePointNo(1));
748        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 binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
782    
783        DataTagged myData;
784        DataTagged right;
785    
786        DataArray vOne(1.0);
787        DataArray vTwo(2.0);
788        myData.addTaggedValue(1,vOne.getView());
789        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 binaryOp(multiplies)." << endl;      cout << "\tTest unaryOp negate on default DataTagged object." << endl;
867      //DataArray vZero(0.0);  
868      //right.setTaggedValue(1,vZero.getView());      DataTagged myData;
869      //right.setTaggedValue(2,vZero.getView());  
870      //binaryOp(left,right,multiplies<double>());      unaryOp(myData,negate<double>());
871    
872      //assert(left.getPointDataView()()==0);      //cout << myData.toString() << endl;
873      //assert(left.getDataPointByTag(1)==vZero.getView());  
874      //assert(left.getDataPointByTag(2)==vZero.getView());      assert(myData.getNumSamples()==1);
875    }      assert(myData.getNumDPPSample()==1);
876    
877    {      assert(myData.validSamplePointNo(0));
878      //DataArrayView::ShapeType viewShape;      assert(myData.validSampleNo(0));
879      //viewShape.push_back(3);      assert(!myData.validSamplePointNo(1));
880      //DataArrayView::ValueType viewData(3);      assert(!myData.validSampleNo(1));
881      //DataTagged::TagListType keys;  
882      //DataTagged::ValueListType values;      // data-point 0 has tag number 1 by default
883      //for (int i=0;i<viewShape[0];++i) {      assert(myData.getTagNumber(0)==1);
884      //  viewData[i]=i;  
885      //}      assert(!myData.isCurrentTag(1));
886      //DataArrayView myView(viewData,viewShape);  
887      //cout << "\tCreate tagged data with no tag values just a default." << endl;      assert(myData.getTagLookup().size()==0);
888      //DataTagged left(keys,values,myView,FunctionSpace());  
889      //DataTagged right(keys,values,myView,FunctionSpace());      assert(myData.getLength()==1);
890      //binaryOp(left,right,minus<double>());  
891      //for (int i=0;i<viewShape[0];++i) {      assert(myData.getPointOffset(0,0)==0);
892      //  assert(left.getDefaultValue()(i)==0);  
893      //}      DataArrayView myDataView = myData.getDataPoint(0,0);
894      //double mVal=10.0;      assert(!myDataView.isEmpty());
895      //for (int i=0;i<viewShape[0];++i) {      assert(myDataView.getOffset()==0);
896      //  viewData[i]=i*mVal;      assert(myDataView.getRank()==0);
897      //}      assert(myDataView.noValues()==1);
898      //cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;      assert(myDataView.getShape().size()==0);
899      //binaryOp(left,myView,minus<double>());      assert(myDataView()==0.0);
900      //for (int i=0;i<viewShape[0];++i) {  
901      //  assert(left.getDefaultValue()(i)==-(i*mVal));      // 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      //cout << "\tTest unaryOp(negate) on default DataTagged." << endl;      assert(myDataView.noValues()==1);
907      //DataTagged data;      assert(myDataView.getShape().size()==0);
908      //unaryOp(data,negate<double>());      assert(myDataView()==0.0);
909      //assert(data.getDefaultValue()()==0);  
910      //DataArray vOne(1);      myDataView = myData.getDefaultValue();
911      //binaryOp(data,vOne.getView(),plus<double>());      assert(!myDataView.isEmpty());
912      //assert(data.getDefaultValue()()==1);      assert(myDataView.getOffset()==0);
913      //unaryOp(data,negate<double>());      assert(myDataView.getRank()==0);
914      //assert(data.getDefaultValue()()==-1);      assert(myDataView.noValues()==1);
915    }      assert(myDataView.getShape().size()==0);
916        assert(myDataView()==0.0);
917    {  
918      //cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;      // use a non-existent tag so we get a pointer to
919      //DataArrayView::ShapeType vShape;      // the first element of the data array
920      //vShape.push_back(3);      double* sampleData=myData.getSampleDataByTag(9);
921      //vShape.push_back(2);      for (int i=0; i<myData.getLength(); i++) {
922      //vShape.push_back(1);        assert(sampleData[i]==i);
923      //DataArray defData(vShape,0.0);      }
924      //DataArrayView& defView=defData.getView();  
925      //DataArray tOneData(vShape,1.0);    }
926      //DataArrayView& tOneView=tOneData.getView();  
927      //DataArray tTwoData(vShape,2.0);    {
928      //DataArrayView& tTwoView=tTwoData.getView();      cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
929      //DataArray tThreeData(vShape,3.0);  
930      //DataArrayView& tThreeView=tThreeData.getView();      DataArrayView::ShapeType viewShape;
931      //DataTagged::TagListType keys;      viewShape.push_back(3);
932      //DataTagged::ValueListType values;  
933      //keys.push_back(1);      DataTagged::TagListType keys;
934      //keys.push_back(2);  
935      //keys.push_back(3);      DataTagged::ValueListType values;
936      //values.push_back(tOneView);  
937      //values.push_back(tTwoView);      DataArrayView::ValueType viewData(3);
938      //values.push_back(tThreeView);      for (int i=0;i<viewShape[0];i++) {
939      //DataTagged tData(keys,values,defView,FunctionSpace());        viewData[i]=i;
940      //unaryOp(tData,negate<double>());      }
941      //unaryOp(tData,negate<double>());      DataArrayView myView(viewData,viewShape);
942      //assert(tData.getDataPointByTag(1)==tOneView);  
943      //assert(tData.getDataPointByTag(2)==tTwoView);      DataTagged myData(keys,values,myView,FunctionSpace());
944      //assert(tData.getDataPointByTag(3)==tThreeView);  
945        unaryOp(myData,negate<double>());
946    
947        //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 399  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 454  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 529  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 612  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 682  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 707  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 732  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 743  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 758  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 785  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 812  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 823  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 834  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 845  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 860  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 976  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 1045  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 1121  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 1223  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 1340  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 1416  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 1475  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 1551  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 1628  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 1650  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 1790  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  }  }
# Line 1938  void DataTaggedTestCase::testCopyConstru Line 2863  void DataTaggedTestCase::testCopyConstru
2863      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2864      assert(myDataView(2)==5);      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    {    {
# Line 2000  void DataTaggedTestCase::testCopyConstru Line 2940  void DataTaggedTestCase::testCopyConstru
2940      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2941      assert(myDataView()==1.0);      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  }  }
# Line 2014  TestSuite* DataTaggedTestCase::suite () Line 2961  TestSuite* DataTaggedTestCase::suite ()
2961    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetTaggedValue",&DataTaggedTestCase::testSetTaggedValue));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetTaggedValue",&DataTaggedTestCase::testSetTaggedValue));
2962    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));
2963    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
2964  //  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
2965    return testSuite;    return testSuite;
2966  }  }

Legend:
Removed from v.504  
changed lines
  Added in v.510

  ViewVC Help
Powered by ViewVC 1.1.26