/[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 505 by jgs, Wed Feb 8 05:51:27 2006 UTC revision 506 by jgs, Thu Feb 9 06:06:02 2006 UTC
# Line 88  void DataTaggedTestCase::testOperations( Line 88  void DataTaggedTestCase::testOperations(
88    cout << endl;    cout << endl;
89    
90    {    {
91        cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
92    
93      DataTagged myData;      DataTagged myData;
94      DataTagged right;      DataTagged right;
95    
     cout << "\tTest addition of two default DataTagged objects." << endl;  
   
96      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
97    
98      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
# Line 140  void DataTaggedTestCase::testOperations( Line 140  void DataTaggedTestCase::testOperations(
140      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
141      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
142      assert(myDataView()==0.0);      assert(myDataView()==0.0);
143    
144        // use a non-existent tag so we get a pointer to
145        // the first element of the data array
146        double* sampleData=myData.getSampleDataByTag(9);
147        for (int i=0; i<myData.getLength(); i++) {
148          assert(sampleData[i]==i);
149        }
150    
151    }    }
152    
153    {    {
154        cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
155    
156        DataArrayView::ShapeType viewShape;
157        viewShape.push_back(3);
158    
159        DataTagged::TagListType keys;
160    
161        DataTagged::ValueListType values;
162    
163        DataArrayView::ValueType viewData(3);
164        for (int i=0;i<viewShape[0];i++) {
165          viewData[i]=i;
166        }
167        DataArrayView myView(viewData,viewShape);
168    
169        DataTagged myData(keys,values,myView,FunctionSpace());
170        DataTagged right(keys,values,myView,FunctionSpace());
171    
172        binaryOp(myData,right,plus<double>());
173    
174        //cout << myData.toString() << endl;
175    
176        assert(myData.getNumSamples()==1);
177        assert(myData.getNumDPPSample()==1);
178    
179        assert(myData.validSamplePointNo(0));
180        assert(myData.validSampleNo(0));
181        assert(!myData.validSamplePointNo(1));
182        assert(!myData.validSampleNo(1));
183    
184        // data-point 0 has tag number 1 by default
185        assert(myData.getTagNumber(0)==1);
186    
187        assert(!myData.isCurrentTag(1));
188    
189        assert(myData.getTagLookup().size()==0);
190    
191        assert(myData.getLength()==3);
192    
193        assert(myData.getPointOffset(0,0)==0);
194    
195        DataArrayView myDataView = myData.getDefaultValue();
196        assert(!myDataView.isEmpty());
197        assert(myDataView.getOffset()==0);
198        assert(myDataView.getRank()==1);
199        assert(myDataView.noValues()==3);
200        assert(myDataView.getShape().size()==1);
201        assert(myDataView(0)==0);
202        assert(myDataView(1)==2);
203        assert(myDataView(2)==4);
204    
205        // use a non-existent tag so we get a pointer to
206        // the first element of the data array
207        double* sampleData=myData.getSampleDataByTag(9);
208        for (int i=0; i<myData.getLength(); i++) {
209          assert(sampleData[i]==i*2);
210        }
211    
212      }
213    
214      {
215        cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
216    
217      DataTagged myData;      DataTagged myData;
218      DataTagged right;      DataTagged right;
219    
     cout << "\tTest addition of two DataTagged objects with one identical tag each." << endl;  
   
220      DataArray vOne(1.0);      DataArray vOne(1.0);
221      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
222      right.addTaggedValue(1,vOne.getView());      right.addTaggedValue(1,vOne.getView());
223    
224      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
225    
226        assert(myData.getNumSamples()==1);
227        assert(myData.getNumDPPSample()==1);
228    
229        assert(myData.validSamplePointNo(0));
230        assert(myData.validSampleNo(0));
231        assert(!myData.validSamplePointNo(1));
232        assert(!myData.validSampleNo(1));
233    
234        // data-point 0 has tag number 1 by default
235        assert(myData.getTagNumber(0)==1);
236    
237        assert(myData.isCurrentTag(1));
238    
239        assert(myData.getTagLookup().size()==1);
240    
241        assert(myData.getLength()==2);
242    
243        assert(myData.getPointOffset(0,0)==1);
244    
245      // check result value for tag "1"      // check result value for tag "1"
246      DataArrayView myDataView = myData.getDataPointByTag(1);      DataArrayView myDataView = myData.getDataPointByTag(1);
247      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
# Line 171  void DataTaggedTestCase::testOperations( Line 259  void DataTaggedTestCase::testOperations(
259      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
260      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
261      assert(myDataView()==0.0);      assert(myDataView()==0.0);
262    
263        // use a non-existent tag so we get a pointer to
264        // the first element of the data array
265        double* sampleData=myData.getSampleDataByTag(9);
266        for (int i=0; i<myData.getLength(); i++) {
267          assert(sampleData[i]==i*2);
268        }
269    
270    }    }
271    
272    {    {
273        cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
274    
275      DataTagged myData;      DataTagged myData;
276      DataTagged right;      DataTagged right;
277    
     cout << "\tTest addition of two DataTagged objects with one different tag each." << endl;  
   
278      DataArray vOne(1.0);      DataArray vOne(1.0);
279        DataArray vTwo(2.0);
280      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
281      right.addTaggedValue(2,vOne.getView());      right.addTaggedValue(2,vTwo.getView());
282    
283      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
284    
285        assert(myData.getNumSamples()==1);
286        assert(myData.getNumDPPSample()==1);
287    
288        assert(myData.validSamplePointNo(0));
289        assert(myData.validSampleNo(0));
290        assert(!myData.validSamplePointNo(1));
291        assert(!myData.validSampleNo(1));
292    
293        // data-point 0 has tag number 1 by default
294        assert(myData.getTagNumber(0)==1);
295    
296        assert(myData.isCurrentTag(1));
297        assert(myData.isCurrentTag(2));
298    
299        assert(myData.getTagLookup().size()==2);
300    
301        assert(myData.getLength()==3);
302    
303        assert(myData.getPointOffset(0,0)==1);
304    
305      // check result value for tag "1"      // check result value for tag "1"
306      DataArrayView myDataView = myData.getDataPointByTag(1);      DataArrayView myDataView = myData.getDataPointByTag(1);
307      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
# Line 201  void DataTaggedTestCase::testOperations( Line 318  void DataTaggedTestCase::testOperations(
318      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
319      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
320      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
321      assert(myDataView()==1.0);      assert(myDataView()==2.0);
322    
323      // check result for default value      // check result for default value
324      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 211  void DataTaggedTestCase::testOperations( Line 328  void DataTaggedTestCase::testOperations(
328      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
329      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
330      assert(myDataView()==0.0);      assert(myDataView()==0.0);
331    
332        // use a non-existent tag so we get a pointer to
333        // the first element of the data array
334        double* sampleData=myData.getSampleDataByTag(9);
335        for (int i=0; i<myData.getLength(); i++) {
336          assert(sampleData[i]==i);
337        }
338    
339    }    }
340    
341    {    {
342        cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
343    
344      DataTagged myData;      DataTagged myData;
345      DataTagged right;      DataTagged right;
346    
     cout << "\tTest addition of two DataTagged objects with overlapping tag sets." << endl;  
   
347      DataArray vOne(1.0);      DataArray vOne(1.0);
348      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
349      myData.addTaggedValue(2,vOne.getView());      myData.addTaggedValue(2,vOne.getView());
# Line 227  void DataTaggedTestCase::testOperations( Line 352  void DataTaggedTestCase::testOperations(
352    
353      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
354    
355        assert(myData.getNumSamples()==1);
356        assert(myData.getNumDPPSample()==1);
357    
358        assert(myData.validSamplePointNo(0));
359        assert(myData.validSampleNo(0));
360        assert(!myData.validSamplePointNo(1));
361        assert(!myData.validSampleNo(1));
362    
363        // data-point 0 has tag number 1 by default
364        assert(myData.getTagNumber(0)==1);
365    
366        assert(myData.isCurrentTag(1));
367        assert(myData.isCurrentTag(2));
368        assert(myData.isCurrentTag(3));
369    
370        assert(myData.getTagLookup().size()==3);
371    
372        assert(myData.getLength()==4);
373    
374        assert(myData.getPointOffset(0,0)==1);
375    
376      // check result value for tag "1"      // check result value for tag "1"
377      DataArrayView myDataView = myData.getDataPointByTag(1);      DataArrayView myDataView = myData.getDataPointByTag(1);
378      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
# Line 262  void DataTaggedTestCase::testOperations( Line 408  void DataTaggedTestCase::testOperations(
408      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
409      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
410      assert(myDataView()==0.0);      assert(myDataView()==0.0);
411    
412        // use a non-existent tag so we get a pointer to
413        // the first element of the data array
414        double* sampleData=myData.getSampleDataByTag(9);
415        for (int i=0; i<myData.getLength(); i++) {
416          if (i<3) {
417            assert(sampleData[i]==i);
418          }
419          if (i>=3) {
420            assert(sampleData[i]==i-2);
421          }
422        }
423    
424      }
425    
426      {
427        cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
428    
429        DataArrayView::ShapeType viewShape;
430        viewShape.push_back(3);
431    
432        DataTagged::TagListType keys;
433    
434        DataTagged::ValueListType values;
435    
436        DataArrayView::ValueType viewData(3);
437        for (int i=0;i<viewShape[0];i++) {
438          viewData[i]=i;
439        }
440        DataArrayView myView(viewData,viewShape);
441    
442        DataTagged myData(keys,values,myView,FunctionSpace());
443        DataTagged right(keys,values,myView,FunctionSpace());
444    
445        binaryOp(myData,right,multiplies<double>());
446    
447        //cout << myData.toString() << endl;
448    
449        assert(myData.getNumSamples()==1);
450        assert(myData.getNumDPPSample()==1);
451    
452        assert(myData.validSamplePointNo(0));
453        assert(myData.validSampleNo(0));
454        assert(!myData.validSamplePointNo(1));
455        assert(!myData.validSampleNo(1));
456    
457        // data-point 0 has tag number 1 by default
458        assert(myData.getTagNumber(0)==1);
459    
460        assert(!myData.isCurrentTag(1));
461    
462        assert(myData.getTagLookup().size()==0);
463    
464        assert(myData.getLength()==3);
465    
466        assert(myData.getPointOffset(0,0)==0);
467    
468        DataArrayView myDataView = myData.getDefaultValue();
469        assert(!myDataView.isEmpty());
470        assert(myDataView.getOffset()==0);
471        assert(myDataView.getRank()==1);
472        assert(myDataView.noValues()==3);
473        assert(myDataView.getShape().size()==1);
474        assert(myDataView(0)==0);
475        assert(myDataView(1)==1);
476        assert(myDataView(2)==4);
477    
478        // use a non-existent tag so we get a pointer to
479        // the first element of the data array
480        double* sampleData=myData.getSampleDataByTag(9);
481        for (int i=0; i<myData.getLength(); i++) {
482          assert(sampleData[i]==i*i);
483        }
484    
485      }
486    
487      {
488        cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
489    
490        DataTagged myData;
491        DataTagged right;
492    
493        DataArray vOne(1.0);
494        DataArray vTwo(2.0);
495        myData.addTaggedValue(1,vOne.getView());
496        myData.addTaggedValue(2,vOne.getView());
497        right.addTaggedValue(2,vTwo.getView());
498        right.addTaggedValue(3,vTwo.getView());
499    
500        binaryOp(myData,right,multiplies<double>());
501    
502        assert(myData.getNumSamples()==1);
503        assert(myData.getNumDPPSample()==1);
504    
505        assert(myData.validSamplePointNo(0));
506        assert(myData.validSampleNo(0));
507        assert(!myData.validSamplePointNo(1));
508        assert(!myData.validSampleNo(1));
509    
510        // data-point 0 has tag number 1 by default
511        assert(myData.getTagNumber(0)==1);
512    
513        assert(myData.isCurrentTag(1));
514        assert(myData.isCurrentTag(2));
515        assert(myData.isCurrentTag(3));
516    
517        assert(myData.getTagLookup().size()==3);
518    
519        assert(myData.getLength()==4);
520    
521        assert(myData.getPointOffset(0,0)==1);
522    
523        // check result value for tag "1"
524        DataArrayView myDataView = myData.getDataPointByTag(1);
525        assert(!myDataView.isEmpty());
526        assert(myDataView.getOffset()==1);
527        assert(myDataView.getRank()==0);
528        assert(myDataView.noValues()==1);
529        assert(myDataView.getShape().size()==0);
530        assert(myDataView()==0.0);
531    
532        // check result value for tag "2"
533        myDataView = myData.getDataPointByTag(2);
534        assert(!myDataView.isEmpty());
535        assert(myDataView.getOffset()==2);
536        assert(myDataView.getRank()==0);
537        assert(myDataView.noValues()==1);
538        assert(myDataView.getShape().size()==0);
539        assert(myDataView()==2.0);
540    
541        // check result value for tag "3"
542        myDataView = myData.getDataPointByTag(3);
543        assert(!myDataView.isEmpty());
544        assert(myDataView.getOffset()==3);
545        assert(myDataView.getRank()==0);
546        assert(myDataView.noValues()==1);
547        assert(myDataView.getShape().size()==0);
548        assert(myDataView()==0.0);
549    
550        // check result for default value
551        myDataView = myData.getDefaultValue();
552        assert(!myDataView.isEmpty());
553        assert(myDataView.getOffset()==0);
554        assert(myDataView.getRank()==0);
555        assert(myDataView.noValues()==1);
556        assert(myDataView.getShape().size()==0);
557        assert(myDataView()==0.0);
558    
559        // use a non-existent tag so we get a pointer to
560        // the first element of the data array
561        double* sampleData=myData.getSampleDataByTag(9);
562        for (int i=0; i<myData.getLength(); i++) {
563          if (i==2) {
564            assert(sampleData[i]==2);
565          } else {
566            assert(sampleData[i]==0);
567          }
568        }
569    
570      }
571    
572      {
573        cout << "\tTest unaryOp negate on default DataTagged object." << endl;
574    
575        DataTagged myData;
576    
577        unaryOp(myData,negate<double>());
578    
579        //cout << myData.toString() << endl;
580    
581        assert(myData.getNumSamples()==1);
582        assert(myData.getNumDPPSample()==1);
583    
584        assert(myData.validSamplePointNo(0));
585        assert(myData.validSampleNo(0));
586        assert(!myData.validSamplePointNo(1));
587        assert(!myData.validSampleNo(1));
588    
589        // data-point 0 has tag number 1 by default
590        assert(myData.getTagNumber(0)==1);
591    
592        assert(!myData.isCurrentTag(1));
593    
594        assert(myData.getTagLookup().size()==0);
595    
596        assert(myData.getLength()==1);
597    
598        assert(myData.getPointOffset(0,0)==0);
599    
600        DataArrayView myDataView = myData.getDataPoint(0,0);
601        assert(!myDataView.isEmpty());
602        assert(myDataView.getOffset()==0);
603        assert(myDataView.getRank()==0);
604        assert(myDataView.noValues()==1);
605        assert(myDataView.getShape().size()==0);
606        assert(myDataView()==0.0);
607    
608        // Test non-existent tag returns the default value.
609        myDataView = myData.getDataPointByTag(1);
610        assert(!myDataView.isEmpty());
611        assert(myDataView.getOffset()==0);
612        assert(myDataView.getRank()==0);
613        assert(myDataView.noValues()==1);
614        assert(myDataView.getShape().size()==0);
615        assert(myDataView()==0.0);
616    
617        myDataView = myData.getDefaultValue();
618        assert(!myDataView.isEmpty());
619        assert(myDataView.getOffset()==0);
620        assert(myDataView.getRank()==0);
621        assert(myDataView.noValues()==1);
622        assert(myDataView.getShape().size()==0);
623        assert(myDataView()==0.0);
624    
625        // use a non-existent tag so we get a pointer to
626        // the first element of the data array
627        double* sampleData=myData.getSampleDataByTag(9);
628        for (int i=0; i<myData.getLength(); i++) {
629          assert(sampleData[i]==i);
630        }
631    
632      }
633    
634      {
635        cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
636    
637        DataArrayView::ShapeType viewShape;
638        viewShape.push_back(3);
639    
640        DataTagged::TagListType keys;
641    
642        DataTagged::ValueListType values;
643    
644        DataArrayView::ValueType viewData(3);
645        for (int i=0;i<viewShape[0];i++) {
646          viewData[i]=i;
647        }
648        DataArrayView myView(viewData,viewShape);
649    
650        DataTagged myData(keys,values,myView,FunctionSpace());
651    
652        unaryOp(myData,negate<double>());
653    
654        //cout << myData.toString() << endl;
655    
656        assert(myData.getNumSamples()==1);
657        assert(myData.getNumDPPSample()==1);
658    
659        assert(myData.validSamplePointNo(0));
660        assert(myData.validSampleNo(0));
661        assert(!myData.validSamplePointNo(1));
662        assert(!myData.validSampleNo(1));
663    
664        // data-point 0 has tag number 1 by default
665        assert(myData.getTagNumber(0)==1);
666    
667        assert(!myData.isCurrentTag(1));
668    
669        assert(myData.getTagLookup().size()==0);
670    
671        assert(myData.getLength()==3);
672    
673        assert(myData.getPointOffset(0,0)==0);
674    
675        DataArrayView myDataView = myData.getDefaultValue();
676        assert(!myDataView.isEmpty());
677        assert(myDataView.getOffset()==0);
678        assert(myDataView.getRank()==1);
679        assert(myDataView.noValues()==3);
680        assert(myDataView.getShape().size()==1);
681        assert(myDataView(0)==0);
682        assert(myDataView(1)==-1);
683        assert(myDataView(2)==-2);
684    
685        // use a non-existent tag so we get a pointer to
686        // the first element of the data array
687        double* sampleData=myData.getSampleDataByTag(9);
688        for (int i=0; i<myData.getLength(); i++) {
689          assert(sampleData[i]==0-i);
690        }
691    
692    }    }
693    
694    {    {
695      //cout << "\tTest binaryOp(multiplies)." << endl;      cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;
696      //DataArray vZero(0.0);  
697      //right.setTaggedValue(1,vZero.getView());      DataTagged myData;
698      //right.setTaggedValue(2,vZero.getView());  
699      //binaryOp(left,right,multiplies<double>());      DataArray vOne(1.0);
700        DataArray vTwo(2.0);
701      //assert(left.getPointDataView()()==0);      myData.addTaggedValue(1,vOne.getView());
702      //assert(left.getDataPointByTag(1)==vZero.getView());      myData.addTaggedValue(2,vTwo.getView());
703      //assert(left.getDataPointByTag(2)==vZero.getView());  
704    }      unaryOp(myData,negate<double>());
705    
706    {      assert(myData.getNumSamples()==1);
707      //DataArrayView::ShapeType viewShape;      assert(myData.getNumDPPSample()==1);
708      //viewShape.push_back(3);  
709      //DataArrayView::ValueType viewData(3);      assert(myData.validSamplePointNo(0));
710      //DataTagged::TagListType keys;      assert(myData.validSampleNo(0));
711      //DataTagged::ValueListType values;      assert(!myData.validSamplePointNo(1));
712      //for (int i=0;i<viewShape[0];++i) {      assert(!myData.validSampleNo(1));
713      //  viewData[i]=i;  
714      //}      // data-point 0 has tag number 1 by default
715      //DataArrayView myView(viewData,viewShape);      assert(myData.getTagNumber(0)==1);
716      //cout << "\tCreate tagged data with no tag values just a default." << endl;  
717      //DataTagged left(keys,values,myView,FunctionSpace());      assert(myData.isCurrentTag(1));
718      //DataTagged right(keys,values,myView,FunctionSpace());      assert(myData.isCurrentTag(2));
719      //binaryOp(left,right,minus<double>());  
720      //for (int i=0;i<viewShape[0];++i) {      assert(myData.getTagLookup().size()==2);
721      //  assert(left.getDefaultValue()(i)==0);  
722      //}      assert(myData.getLength()==3);
723      //double mVal=10.0;  
724      //for (int i=0;i<viewShape[0];++i) {      assert(myData.getPointOffset(0,0)==1);
725      //  viewData[i]=i*mVal;  
726      //}      // check result value for tag "1"
727      //cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;      DataArrayView myDataView = myData.getDataPointByTag(1);
728      //binaryOp(left,myView,minus<double>());      assert(!myDataView.isEmpty());
729      //for (int i=0;i<viewShape[0];++i) {      assert(myDataView.getOffset()==1);
730      //  assert(left.getDefaultValue()(i)==-(i*mVal));      assert(myDataView.getRank()==0);
731      //}      assert(myDataView.noValues()==1);
732    }      assert(myDataView.getShape().size()==0);
733        assert(myDataView()==-1.0);
734    {  
735      //cout << "\tTest unaryOp(negate) on default DataTagged." << endl;      // check result value for tag "2"
736      //DataTagged data;      myDataView = myData.getDataPointByTag(2);
737      //unaryOp(data,negate<double>());      assert(!myDataView.isEmpty());
738      //assert(data.getDefaultValue()()==0);      assert(myDataView.getOffset()==2);
739      //DataArray vOne(1);      assert(myDataView.getRank()==0);
740      //binaryOp(data,vOne.getView(),plus<double>());      assert(myDataView.noValues()==1);
741      //assert(data.getDefaultValue()()==1);      assert(myDataView.getShape().size()==0);
742      //unaryOp(data,negate<double>());      assert(myDataView()==-2.0);
743      //assert(data.getDefaultValue()()==-1);  
744    }      // check result for default value
745        myDataView = myData.getDefaultValue();
746    {      assert(!myDataView.isEmpty());
747      //cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;      assert(myDataView.getOffset()==0);
748      //DataArrayView::ShapeType vShape;      assert(myDataView.getRank()==0);
749      //vShape.push_back(3);      assert(myDataView.noValues()==1);
750      //vShape.push_back(2);      assert(myDataView.getShape().size()==0);
751      //vShape.push_back(1);      assert(myDataView()==0.0);
752      //DataArray defData(vShape,0.0);  
753      //DataArrayView& defView=defData.getView();      // use a non-existent tag so we get a pointer to
754      //DataArray tOneData(vShape,1.0);      // the first element of the data array
755      //DataArrayView& tOneView=tOneData.getView();      double* sampleData=myData.getSampleDataByTag(9);
756      //DataArray tTwoData(vShape,2.0);      for (int i=0; i<myData.getLength(); i++) {
757      //DataArrayView& tTwoView=tTwoData.getView();        assert(sampleData[i]==0-i);
758      //DataArray tThreeData(vShape,3.0);      }
759      //DataArrayView& tThreeView=tThreeData.getView();  
     //DataTagged::TagListType keys;  
     //DataTagged::ValueListType values;  
     //keys.push_back(1);  
     //keys.push_back(2);  
     //keys.push_back(3);  
     //values.push_back(tOneView);  
     //values.push_back(tTwoView);  
     //values.push_back(tThreeView);  
     //DataTagged tData(keys,values,defView,FunctionSpace());  
     //unaryOp(tData,negate<double>());  
     //unaryOp(tData,negate<double>());  
     //assert(tData.getDataPointByTag(1)==tOneView);  
     //assert(tData.getDataPointByTag(2)==tTwoView);  
     //assert(tData.getDataPointByTag(3)==tThreeView);  
760    }    }
761    
762  }  }
# Line 399  void DataTaggedTestCase::testAddTaggedVa Line 812  void DataTaggedTestCase::testAddTaggedVa
812      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
813      assert(myDataView()==0.0);      assert(myDataView()==0.0);
814    
815        // use a non-existent tag so we get a pointer to
816        // the first element of the data array
817        double* sampleData=myData.getSampleDataByTag(9);
818        for (int i=0; i<myData.getLength(); i++) {
819          assert(sampleData[i]==0);
820        }
821    
822    }    }
823    
824    {    {
# Line 454  void DataTaggedTestCase::testAddTaggedVa Line 874  void DataTaggedTestCase::testAddTaggedVa
874      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
875      assert(myDataView()==0.0);      assert(myDataView()==0.0);
876    
877        // use a non-existent tag so we get a pointer to
878        // the first element of the data array
879        double* sampleData=myData.getSampleDataByTag(9);
880        for (int i=0; i<myData.getLength(); i++) {
881          assert(sampleData[i]==i);
882        }
883    
884    }    }
885    
886    {    {
# Line 529  void DataTaggedTestCase::testAddTaggedVa Line 956  void DataTaggedTestCase::testAddTaggedVa
956      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
957      assert(myDataView()==0.0);      assert(myDataView()==0.0);
958    
959        // use a non-existent tag so we get a pointer to
960        // the first element of the data array
961        double* sampleData=myData.getSampleDataByTag(9);
962        for (int i=0; i<myData.getLength(); i++) {
963          if (i==0) {
964            assert(sampleData[i]==0);
965          } else {
966            assert(sampleData[i]==1);
967          }
968        }
969    
970    }    }
971    
972    {    {
# Line 612  void DataTaggedTestCase::testAddTaggedVa Line 1050  void DataTaggedTestCase::testAddTaggedVa
1050      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1051      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1052    
1053        // use a non-existent tag so we get a pointer to
1054        // the first element of the data array
1055        double* sampleData=myData.getSampleDataByTag(9);
1056        for (int i=0; i<myData.getLength(); i++) {
1057          assert(sampleData[i]==i);
1058        }
1059    
1060    }    }
1061    
1062    {    {
# Line 682  void DataTaggedTestCase::testAddTaggedVa Line 1127  void DataTaggedTestCase::testAddTaggedVa
1127      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1128      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1129    
1130        // use a non-existent tag so we get a pointer to
1131        // the first element of the data array
1132        double* sampleData=myData.getSampleDataByTag(9);
1133        for (int i=0; i<myData.getLength(); i++) {
1134          assert(sampleData[i]==i%3);
1135        }
1136    
1137    }    }
1138    
1139    {    {
# Line 707  void DataTaggedTestCase::testAddTaggedVa Line 1159  void DataTaggedTestCase::testAddTaggedVa
1159    
1160      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1161      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1162        viewData1[i]=i+1;        viewData1[i]=i+3;
1163      }      }
1164      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1165      values.push_back(myView1);      values.push_back(myView1);
# Line 732  void DataTaggedTestCase::testAddTaggedVa Line 1184  void DataTaggedTestCase::testAddTaggedVa
1184      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1185      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1186      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1187      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1188      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1189      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1190    
1191      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
1192      assert(myDataView==myView1);      assert(myDataView==myView1);
# Line 743  void DataTaggedTestCase::testAddTaggedVa Line 1195  void DataTaggedTestCase::testAddTaggedVa
1195      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1196      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1197      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1198      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1199      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1200      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1201    
1202      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
1203      assert(myDataView==myView);      assert(myDataView==myView);
# Line 758  void DataTaggedTestCase::testAddTaggedVa Line 1210  void DataTaggedTestCase::testAddTaggedVa
1210      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1211      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1212    
1213        // use a non-existent tag so we get a pointer to
1214        // the first element of the data array
1215        double* sampleData=myData.getSampleDataByTag(9);
1216        for (int i=0; i<myData.getLength(); i++) {
1217          assert(sampleData[i]==i);
1218        }
1219    
1220    }    }
1221    
1222    {    {
# Line 785  void DataTaggedTestCase::testAddTaggedVa Line 1244  void DataTaggedTestCase::testAddTaggedVa
1244    
1245      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1246      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1247        viewData1[i]=i+1;        viewData1[i]=3;
1248      }      }
1249      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1250      values.push_back(myView1);      values.push_back(myView1);
# Line 812  void DataTaggedTestCase::testAddTaggedVa Line 1271  void DataTaggedTestCase::testAddTaggedVa
1271      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1272      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1273      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1274      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1275      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1276      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1277    
1278      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
# Line 823  void DataTaggedTestCase::testAddTaggedVa Line 1282  void DataTaggedTestCase::testAddTaggedVa
1282      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1283      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1284      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1285      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1286      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1287      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1288    
1289      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 834  void DataTaggedTestCase::testAddTaggedVa Line 1293  void DataTaggedTestCase::testAddTaggedVa
1293      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1294      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1295      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1296      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1297      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1298      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1299    
1300      myDataView = myData.getDataPointByTag(3);      myDataView = myData.getDataPointByTag(3);
# Line 845  void DataTaggedTestCase::testAddTaggedVa Line 1304  void DataTaggedTestCase::testAddTaggedVa
1304      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1305      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1306      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1307      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1308      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1309      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1310    
1311      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 860  void DataTaggedTestCase::testAddTaggedVa Line 1319  void DataTaggedTestCase::testAddTaggedVa
1319      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1320      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1321    
1322        // use a non-existent tag so we get a pointer to
1323        // the first element of the data array
1324        double* sampleData=myData.getSampleDataByTag(9);
1325        for (int i=0; i<myData.getLength(); i++) {
1326          if (i<3) {
1327            assert(sampleData[i]==i);
1328          } else {
1329            assert(sampleData[i]==3);
1330          }
1331        }
1332    
1333    }    }
1334    
1335    {    {
# Line 976  void DataTaggedTestCase::testAddTaggedVa Line 1446  void DataTaggedTestCase::testAddTaggedVa
1446      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1447      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1448    
1449        // use a non-existent tag so we get a pointer to
1450        // the first element of the data array
1451        double* sampleData=myData.getSampleDataByTag(9);
1452        for (int i=0; i<myData.getLength(); i++) {
1453          if (i<3) {
1454            assert(sampleData[i]==i);
1455          }
1456          if ((i>=3) && (i<6)) {
1457            assert(sampleData[i]==i-2);
1458          }
1459          if ((i>=6) && (i<9)) {
1460            assert(sampleData[i]==i-4);
1461          }
1462          if (i>=9) {
1463            assert(sampleData[i]==i-6);
1464          }
1465        }
1466    
1467    }    }
1468    
1469    {    {
# Line 1045  void DataTaggedTestCase::testAddTaggedVa Line 1533  void DataTaggedTestCase::testAddTaggedVa
1533      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1534      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1535    
1536        // use a non-existent tag so we get a pointer to
1537        // the first element of the data array
1538        double* sampleData=myData.getSampleDataByTag(9);
1539        for (int i=0; i<myData.getLength(); i++) {
1540          if (i<3) {
1541            assert(sampleData[i]==i);
1542          }
1543          if ((i>=3) && (i<6)) {
1544            assert(sampleData[i]==i-2);
1545          }
1546          if ((i>=6) && (i<9)) {
1547            assert(sampleData[i]==i-4);
1548          }
1549          if ((i>=9) && (i<12)) {
1550            assert(sampleData[i]==i-6);
1551          }
1552          if (i>=12) {
1553            assert(sampleData[i]==i-12);
1554          }
1555        }
1556    
1557    }    }
1558    
1559    {    {
# Line 1121  void DataTaggedTestCase::testAddTaggedVa Line 1630  void DataTaggedTestCase::testAddTaggedVa
1630      assert(myDataView(1)==5);      assert(myDataView(1)==5);
1631      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1632    
1633        // use a non-existent tag so we get a pointer to
1634        // the first element of the data array
1635        double* sampleData=myData.getSampleDataByTag(9);
1636        for (int i=0; i<myData.getLength(); i++) {
1637          if (i<3) {
1638            assert(sampleData[i]==i);
1639          }
1640          if ((i>=3) && (i<6)) {
1641            assert(sampleData[i]==i-2);
1642          }
1643          if ((i>=6) && (i<9)) {
1644            assert(sampleData[i]==i-4);
1645          }
1646          if ((i>=9) && (i<12)) {
1647            assert(sampleData[i]==i-6);
1648          }
1649          if (i>=12) {
1650            assert(sampleData[i]==i-8);
1651          }
1652        }
1653    
1654    }    }
1655    
1656    {    {
# Line 1223  void DataTaggedTestCase::testAddTaggedVa Line 1753  void DataTaggedTestCase::testAddTaggedVa
1753      assert(myDataView(1)==5);      assert(myDataView(1)==5);
1754      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1755    
1756        // use a non-existent tag so we get a pointer to
1757        // the first element of the data array
1758        double* sampleData=myData.getSampleDataByTag(9);
1759        for (int i=0; i<myData.getLength(); i++) {
1760          if (i<3) {
1761            assert(sampleData[i]==i);
1762          }
1763          if ((i>=3) && (i<6)) {
1764            assert(sampleData[i]==i-2);
1765          }
1766          if ((i>=6) && (i<9)) {
1767            assert(sampleData[i]==i-4);
1768          }
1769          if ((i>=9) && (i<12)) {
1770            assert(sampleData[i]==i-6);
1771          }
1772          if ((i>=12) && (i<15)) {
1773            assert(sampleData[i]==i-8);
1774          }
1775          if ((i>=15) && (i<18)) {
1776            assert(sampleData[i]==i-11);
1777          }
1778          if (i>=18) {
1779            assert(sampleData[i]==i-14);
1780          }
1781        }
1782    
1783    }    }
1784    
1785    {    {
# Line 1340  void DataTaggedTestCase::testAddTaggedVa Line 1897  void DataTaggedTestCase::testAddTaggedVa
1897      assert(myDataView(1)==7);      assert(myDataView(1)==7);
1898      assert(myDataView(2)==8);      assert(myDataView(2)==8);
1899    
1900        // use a non-existent tag so we get a pointer to
1901        // the first element of the data array
1902        double* sampleData=myData.getSampleDataByTag(9);
1903        for (int i=0; i<myData.getLength(); i++) {
1904          if (i<3) {
1905            assert(sampleData[i]==i);
1906          }
1907          if ((i>=3) && (i<6)) {
1908            assert(sampleData[i]==i-2);
1909          }
1910          if ((i>=6) && (i<9)) {
1911            assert(sampleData[i]==i-4);
1912          }
1913          if ((i>=9) && (i<12)) {
1914            assert(sampleData[i]==i-6);
1915          }
1916          if ((i>=12) && (i<15)) {
1917            assert(sampleData[i]==i-8);
1918          }
1919          if ((i>=15) && (i<18)) {
1920            assert(sampleData[i]==i-10);
1921          }
1922          if (i>=18) {
1923            assert(sampleData[i]==i-12);
1924          }
1925        }
1926    
1927    }    }
1928    
1929  }  }
# Line 1416  void DataTaggedTestCase::testSetTaggedVa Line 2000  void DataTaggedTestCase::testSetTaggedVa
2000      assert(myDataView(1)==6);      assert(myDataView(1)==6);
2001      assert(myDataView(2)==7);      assert(myDataView(2)==7);
2002    
2003        // use a non-existent tag so we get a pointer to
2004        // the first element of the data array
2005        double* sampleData=myData.getSampleDataByTag(9);
2006        for (int i=0; i<myData.getLength(); i++) {
2007          if (i<3) {
2008            assert(sampleData[i]==i);
2009          }
2010          if ((i>=3) && (i<6)) {
2011            assert(sampleData[i]==i-2);
2012          }
2013          if ((i>=6) && (i<9)) {
2014            assert(sampleData[i]==i-1);
2015          }
2016          if ((i>=9) && (i<12)) {
2017            assert(sampleData[i]==i-6);
2018          }
2019        }
2020    
2021    }    }
2022    
2023  }  }
# Line 1475  void DataTaggedTestCase::testAll() { Line 2077  void DataTaggedTestCase::testAll() {
2077      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2078      assert(myDataView()==0.0);      assert(myDataView()==0.0);
2079    
2080        // use a non-existent tag so we get a pointer to
2081        // the first element of the data array
2082        double* sampleData=myData.getSampleDataByTag(9);
2083        for (int i=0; i<myData.getLength(); i++) {
2084          assert(sampleData[i]==i);
2085        }
2086    
2087    }    }
2088    
2089    {    {
# Line 1551  void DataTaggedTestCase::testAll() { Line 2160  void DataTaggedTestCase::testAll() {
2160      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2161      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2162    
2163        // use a non-existent tag so we get a pointer to
2164        // the first element of the data array
2165        double* sampleData=myData.getSampleDataByTag(9);
2166        for (int i=0; i<myData.getLength(); i++) {
2167          assert(sampleData[i]==i);
2168        }
2169    
2170    }    }
2171    
2172    {    {
# Line 1650  void DataTaggedTestCase::testAll() { Line 2266  void DataTaggedTestCase::testAll() {
2266      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2267      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2268    
2269        // use a non-existent tag so we get a pointer to
2270        // the first element of the data array
2271        double* sampleData=myData.getSampleDataByTag(9);
2272        for (int i=0; i<myData.getLength(); i++) {
2273          if (i<3) {
2274            assert(sampleData[i]==i);
2275          }
2276          if (i>=3) {
2277            assert(sampleData[i]==i-2);
2278          }
2279        }
2280    
2281    }    }
2282    
2283    {    {
# Line 1790  void DataTaggedTestCase::testAll() { Line 2418  void DataTaggedTestCase::testAll() {
2418      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2419      assert(myDataView(2)==5);      assert(myDataView(2)==5);
2420    
2421        // use a non-existent tag so we get a pointer to
2422        // the first element of the data array
2423        double* sampleData=myData.getSampleDataByTag(9);
2424        for (int i=0; i<myData.getLength(); i++) {
2425          if (i<3) {
2426            assert(sampleData[i]==i);
2427          }
2428          if ((i>=3) && (i<6)) {
2429            assert(sampleData[i]==i-2);
2430          }
2431          if ((i>=6) && (i<9)) {
2432            assert(sampleData[i]==i-4);
2433          }
2434          if (i>=9) {
2435            assert(sampleData[i]==i-6);
2436          }
2437        }
2438    
2439    }    }
2440    
2441  }  }
# Line 1938  void DataTaggedTestCase::testCopyConstru Line 2584  void DataTaggedTestCase::testCopyConstru
2584      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2585      assert(myDataView(2)==5);      assert(myDataView(2)==5);
2586    
2587        // use a non-existent tag so we get a pointer to
2588        // the first element of the data array
2589        double* sampleData=myDataCopy.getSampleDataByTag(9);
2590        for (int i=0; i<myData.getLength(); i++) {
2591          if (i<3) {
2592            assert(sampleData[i]==i);
2593          }
2594          if ((i>=3) && (i<6)) {
2595            assert(sampleData[i]==i-2);
2596          }
2597          if ((i>=6) && (i<9)) {
2598            assert(sampleData[i]==i-4);
2599          }
2600          if (i>=9) {
2601            assert(sampleData[i]==i-6);
2602          }
2603        }
2604    
2605    }    }
2606    
2607    {    {
# Line 2000  void DataTaggedTestCase::testCopyConstru Line 2664  void DataTaggedTestCase::testCopyConstru
2664      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2665      assert(myDataView()==1.0);      assert(myDataView()==1.0);
2666    
2667        // use a non-existent tag so we get a pointer to
2668        // the first element of the data array
2669        double* sampleData=myData.getSampleDataByTag(9);
2670        for (int i=0; i<myData.getLength(); i++) {
2671          assert(sampleData[i]==i+1);
2672        }
2673    
2674    }    }
2675    
2676  }  }

Legend:
Removed from v.505  
changed lines
  Added in v.506

  ViewVC Help
Powered by ViewVC 1.1.26