/[escript]/branches/arrayview_from_1695_trunk/escript/test/DataTestCase.cpp
ViewVC logotype

Contents of /branches/arrayview_from_1695_trunk/escript/test/DataTestCase.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1721 - (show annotations)
Fri Aug 22 00:39:32 2008 UTC (14 years, 7 months ago) by jfenwick
File size: 30375 byte(s) 
Branch commit.

Fixed problems with copyFromNumArray
Removed version of setTaggedValueFromCPP() which required DataArrayView.
Updated tests.
1
2 /* $Id$ */
3
4 /*******************************************************
5 *
6 * Copyright 2003-2007 by ACceSS MNRF
7 * Copyright 2007 by University of Queensland
8 *
9 * http://esscc.uq.edu.au
10 * Primary Business: Queensland, Australia
11 * Licensed under the Open Software License version 3.0
12 * http://www.opensource.org/licenses/osl-3.0.php
13 *
14 *******************************************************/
15
16 #include <iostream>
17 #if (defined _WIN32) && (defined __INTEL_COMPILER)
18 #include <mathimf.h>
19 #else
20 #include <math.h>
21 #endif
22
23 #include "DataTestCase.h"
24
25 #include "escript/FunctionSpace.h"
26 #include "esysUtils/EsysException.h"
27
28 #include "escript/Data.h"
29
30
31 using namespace std;
32 using namespace CppUnitTest;
33 using namespace escript;
34 using namespace esysUtils;
35
36 void DataTestCase::setUp() {
37 //
38 // This is called before each test is run
39 }
40
41 void DataTestCase::tearDown() {
42 //
43 // This is called after each test has been run
44 }
45
46 void DataTestCase::testSlicing() {
47
48 cout << endl;
49
50 {
51
52 cout << "\tTest get-slicing DataConstant" << endl;
53
54 DataTypes::ShapeType viewShape;
55 viewShape.push_back(2);
56 viewShape.push_back(3);
57 Data data(1.3,viewShape,FunctionSpace(),false);
58
59 //cout << data.toString() << endl;
60
61 DataTypes::RegionType region;
62 region.push_back(DataTypes::RegionType::value_type(0,0));
63 region.push_back(DataTypes::RegionType::value_type(0,0));
64
65 Data slice1(data.getSlice(region));
66
67 //cout << slice1.toString() << endl;
68
69 assert(slice1.getDataPointRank()==0);
70 assert(slice1.getDataPoint(0,0)()==1.3);
71
72 region.clear();
73 region.push_back(DataTypes::RegionType::value_type(0,1));
74 region.push_back(DataTypes::RegionType::value_type(0,1));
75
76 Data slice2(data.getSlice(region));
77
78 //cout << slice2.toString() << endl;
79
80 assert(slice2.getDataPointRank()==2);
81 assert(slice2.getDataPoint(0,0)(0,0)==1.3);
82
83 region.clear();
84 region.push_back(DataTypes::RegionType::value_type(0,1));
85 region.push_back(DataTypes::RegionType::value_type(0,2));
86
87 Data slice3(data.getSlice(region));
88
89 //cout << slice3.toString() << endl;
90
91 assert(slice3.getDataPointRank()==2);
92 assert(slice3.getDataPoint(0,0)(0,0)==1.3);
93 assert(slice3.getDataPoint(0,0)(0,1)==1.3);
94
95 }
96
97 {
98
99 cout << "\tTest set-slicing DataConstant" << endl;
100
101 DataTypes::ShapeType viewShape;
102 Data source(10.0,viewShape,FunctionSpace(),false);
103
104 //cout << source.toString() << endl;
105
106 viewShape.push_back(2);
107 viewShape.push_back(3);
108 Data target(1.3,viewShape,FunctionSpace(),false);
109
110 //cout << target.toString() << endl;
111
112 DataTypes::RegionType region;
113 region.push_back(DataTypes::RegionType::value_type(0,0));
114 region.push_back(DataTypes::RegionType::value_type(0,0));
115
116 target.setSlice(source,region);
117
118 //cout << target.toString() << endl;
119
120 assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
121
122 }
123
124 {
125
126 cout << "\tTest get-slicing DataTagged" << endl;
127
128 //
129 // create a DataTagged with a default value only
130
131 DataTypes::ShapeType viewShape;
132 viewShape.push_back(2);
133 viewShape.push_back(3);
134 Data data(1.3,viewShape,FunctionSpace(),false);
135 data.tag();
136 data.getDataPoint(0,0)(0,0)=1.0;
137 data.getDataPoint(0,0)(1,1)=2.0;
138
139 //cout << data.toString() << endl;
140
141 //
142 // create a scalar slice
143
144 DataTypes::RegionType region;
145 region.push_back(DataTypes::RegionType::value_type(0,0));
146 region.push_back(DataTypes::RegionType::value_type(0,0));
147
148 Data slice1(data.getSlice(region));
149
150 //cout << slice1.toString() << endl;
151
152 assert(slice1.isTagged());
153 assert(slice1.getDataPointRank()==0);
154 assert(slice1.getDataPoint(0,0)()==1.0);
155
156 //
157 // create a rank 2 slice with one value
158
159 region.clear();
160 region.push_back(DataTypes::RegionType::value_type(0,1));
161 region.push_back(DataTypes::RegionType::value_type(0,1));
162
163 Data slice2(data.getSlice(region));
164
165 //cout << slice2.toString() << endl;
166
167 assert(slice2.isTagged());
168 assert(slice2.getDataPointRank()==2);
169 assert(slice2.getDataPoint(0,0)(0,0)==1.0);
170
171 //
172 // create a rank 2 slice with four values
173
174 region.clear();
175 region.push_back(DataTypes::RegionType::value_type(0,2));
176 region.push_back(DataTypes::RegionType::value_type(0,2));
177
178 Data slice3(data.getSlice(region));
179
180 //cout << slice3.toString() << endl;
181
182 assert(slice3.isTagged());
183 assert(slice3.getDataPointRank()==2);
184 assert(slice3.getDataPoint(0,0)(0,0)==1.0);
185 assert(slice3.getDataPoint(0,0)(0,1)==1.3);
186 assert(slice3.getDataPoint(0,0)(1,0)==1.3);
187 assert(slice3.getDataPoint(0,0)(1,1)==2.0);
188
189 //
190 // add a value for tag "1"
191
192 DataTypes::ValueType viewData(6);
193 for (int i=0;i<viewData.size();i++) {
194 viewData[i]=i;
195 }
196 // DataArrayView dataView(viewData,viewShape);
197
198 // data.setTaggedValueFromCPP(1, dataView);
199 data.setTaggedValueFromCPP(1, viewShape, viewData);
200
201
202 //
203 // create a full slice
204
205 region.clear();
206 region.push_back(DataTypes::RegionType::value_type(0,2));
207 region.push_back(DataTypes::RegionType::value_type(0,3));
208
209 Data slice4(data.getSlice(region));
210
211 //cout << slice4.toString() << endl;
212
213 assert(slice4.isTagged());
214 assert(slice4.getDataPointRank()==2);
215 assert(slice4.getDataPoint(0,0)(0,0)==0);
216 assert(slice4.getDataPoint(0,0)(0,1)==2);
217 assert(slice4.getDataPoint(0,0)(0,2)==4);
218 assert(slice4.getDataPoint(0,0)(1,0)==1);
219 assert(slice4.getDataPoint(0,0)(1,1)==3);
220 assert(slice4.getDataPoint(0,0)(1,2)==5);
221
222 }
223
224 {
225
226 cout << "\tTest set-slicing DataTagged" << endl;
227
228 //
229 // create a source DataTagged with a scalar default value only
230
231 DataTypes::ShapeType viewShape;
232 Data source(10.0,viewShape,FunctionSpace(),false);
233 source.tag();
234
235 //cout << "source:\n" << source.toString() << endl;
236
237 //
238 // create a target DataTagged with a rank 2 default value only
239
240 viewShape.push_back(2);
241 viewShape.push_back(3);
242 Data target(1.3,viewShape,FunctionSpace(),false);
243 target.tag();
244
245 //cout << "target:\n" << target.toString() << endl;
246
247 //
248 // set a slice in target from source
249
250 DataTypes::RegionType region;
251 region.push_back(DataTypes::RegionType::value_type(1,1));
252 region.push_back(DataTypes::RegionType::value_type(1,1));
253
254 target.setSlice(source,region);
255
256 //cout << "target:\n" << target.toString() << endl;
257
258 assert(target.isTagged());
259 assert(target.getDataPointRank()==2);
260 assert(target.getDataPoint(0,0)(0,0)==1.3);
261 assert(target.getDataPoint(0,0)(0,1)==1.3);
262 assert(target.getDataPoint(0,0)(0,2)==1.3);
263 assert(target.getDataPoint(0,0)(1,0)==1.3);
264 assert(target.getDataPoint(0,0)(1,1)==source.getDataPoint(0,0)());
265 assert(target.getDataPoint(0,0)(1,2)==1.3);
266
267 //
268 // add a value for tag "1" to target
269
270 DataTypes::ValueType viewData(6);
271 for (int i=0;i<viewData.size();i++) {
272 viewData[i]=i;
273 }
274 // DataArrayView dataView(viewData,viewShape);
275 //
276 // target.setTaggedValueFromCPP(1, dataView);
277 target.setTaggedValueFromCPP(1, viewShape, viewData);
278
279 //cout << "target:\n" << target.toString() << endl;
280
281 //
282 // set a slice in target from source
283
284 region.clear();
285 region.push_back(DataTypes::RegionType::value_type(0,0));
286 region.push_back(DataTypes::RegionType::value_type(1,1));
287
288 target.setSlice(source,region);
289
290 //cout << "target:\n" << target.toString() << endl;
291
292 assert(target.isTagged());
293 assert(target.getDataPointRank()==2);
294 assert(target.getDataPoint(0,0)(0,0)==0);
295 assert(target.getDataPoint(0,0)(0,1)==source.getDataPoint(0,0)());
296 assert(target.getDataPoint(0,0)(0,2)==4);
297 assert(target.getDataPoint(0,0)(1,0)==1);
298 assert(target.getDataPoint(0,0)(1,1)==3);
299 assert(target.getDataPoint(0,0)(1,2)==5);
300
301 //
302 // add a value for tag "2" to source
303
304 DataTypes::ShapeType viewShape2;
305 DataTypes::ValueType viewData2(1);
306 viewData2[0]=6;
307 // DataArrayView dataView2(viewData2,viewShape2);
308 //
309 // source.setTaggedValueFromCPP(2, dataView2);
310 source.setTaggedValueFromCPP(2, viewShape2, viewData2);
311
312 //cout << "source:\n" << source.toString() << endl;
313
314 //
315 // set a slice in target from source
316
317 region.clear();
318 region.push_back(DataTypes::RegionType::value_type(0,0));
319 region.push_back(DataTypes::RegionType::value_type(1,1));
320
321 target.setSlice(source,region);
322
323 //cout << "target:\n" << target.toString() << endl;
324
325 assert(target.isTagged());
326 assert(target.getDataPointRank()==2);
327
328 // use a non-existant tag so we get a pointer to the default value
329 // ie: the first element in the data array
330 DataAbstract::ValueType::value_type* targetData=target.getSampleDataByTag(9);
331 for (int i=0; i<target.getLength(); i++) {
332 assert(targetData[i]>=0);
333 }
334 assert(targetData[0]==1.3);
335 assert(targetData[1]==1.3);
336 assert(targetData[2]==10);
337 assert(targetData[3]==10);
338 assert(targetData[4]==1.3);
339 assert(targetData[5]==1.3);
340 assert(targetData[6]==0);
341 assert(targetData[7]==1);
342 assert(targetData[8]==10);
343 assert(targetData[9]==3);
344 assert(targetData[10]==4);
345 assert(targetData[11]==5);
346 assert(targetData[12]==1.3);
347 assert(targetData[13]==1.3);
348 assert(targetData[14]==6);
349 assert(targetData[15]==10);
350 assert(targetData[16]==1.3);
351 assert(targetData[17]==1.3);
352
353 }
354
355 {
356
357 cout << "\tTest get-slicing DataExpanded" << endl;
358
359 DataTypes::ShapeType viewShape;
360 viewShape.push_back(2);
361 viewShape.push_back(3);
362 Data temp(1.3,viewShape,FunctionSpace(),true);
363
364 temp.getDataPoint(0,0)(0,0)=0.0;
365 temp.getDataPoint(0,0)(1,1)=1.0;
366
367 DataTypes::RegionType region;
368 region.push_back(DataTypes::RegionType::value_type(0,0));
369 region.push_back(DataTypes::RegionType::value_type(0,0));
370
371 Data slice(temp.getSlice(region));
372
373 assert(slice.getDataPointRank()==0);
374 assert(slice.getDataPoint(0,0)()==0.0);
375
376 region.clear();
377 region.push_back(DataTypes::RegionType::value_type(0,1));
378 region.push_back(DataTypes::RegionType::value_type(0,1));
379
380 slice=temp.getSlice(region);
381
382 assert(slice.getDataPointRank()==2);
383 assert(slice.getDataPoint(0,0)(0,0)==0.0);
384
385 region.clear();
386 region.push_back(DataTypes::RegionType::value_type(0,2));
387 region.push_back(DataTypes::RegionType::value_type(0,2));
388
389 slice=temp.getSlice(region);
390
391 assert(slice.getDataPoint(0,0)(0,0)==0.0);
392 assert(slice.getDataPoint(0,0)(1,1)==1.0);
393
394 }
395
396 {
397
398 cout << "\tTest set-slicing DataExpanded" << endl;
399
400 DataTypes::ShapeType viewShape;
401 Data source(10.0,viewShape,FunctionSpace(),true);
402
403 viewShape.push_back(2);
404 viewShape.push_back(3);
405 Data target(1.3,viewShape,FunctionSpace(),true);
406
407 DataTypes::RegionType region;
408 region.push_back(DataTypes::RegionType::value_type(0,0));
409 region.push_back(DataTypes::RegionType::value_type(0,0));
410
411 target.setSlice(source,region);
412
413 assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
414
415 }
416
417 }
418
419 void DataTestCase::testAll() {
420
421 cout << endl;
422
423 cout << "\tCreate a Data object from a DataArrayView" << endl;
424
425 DataTypes::ShapeType viewShape;
426 viewShape.push_back(3);
427 DataTypes::ValueType viewData(3);
428 for (int i=0;i<viewShape[0];++i) {
429 viewData[i]=i;
430 }
431 DataArrayView myView(viewData,viewShape);
432
433 bool expanded=true;
434 Data exData(myView,FunctionSpace(),expanded);
435 Data cData(myView);
436 Data result;
437
438 assert(exData.isExpanded());
439 assert(cData.isConstant());
440 assert(result.isEmpty());
441
442 cout << "\tTest some basic operations" << endl;
443 result=exData*cData;
444 assert(result.isExpanded());
445
446 }
447
448 void DataTestCase::testMore() {
449
450 cout << endl;
451
452 cout << "\tCreate a Data object from a DataArrayView" << endl;
453
454 DataTypes::ShapeType viewShape;
455 viewShape.push_back(3);
456 DataTypes::ValueType viewData(3);
457 for (int i=0;i<viewShape[0];++i) {
458 viewData[i]=i;
459 }
460 DataArrayView myView(viewData,viewShape);
461
462 bool expanded=true;
463 Data exData(myView,FunctionSpace(),expanded);
464 Data cData(myView);
465 Data result;
466
467 assert(exData.isExpanded());
468 assert(cData.isConstant());
469 assert(result.isEmpty());
470
471 cout << "\tTest some basic operations" << endl;
472 result=exData*cData;
473 assert(result.isExpanded());
474
475 assert(result.Lsup()==4);
476 assert(result.sup()==4);
477 assert(result.inf()==0);
478
479 result=exData+cData;
480 result=exData-cData;
481 result=exData/cData;
482
483 cout << "\tExercise wherePositive method" << endl;
484 assert(!exData.wherePositive().isEmpty());
485
486 cout << "\tExercise copyWithMask method" << endl;
487 exData.copyWithMask(result, exData.wherePositive());
488 assert(!exData.wherePositive().isEmpty());
489
490 }
491
492 void DataTestCase::testDataConstant() {
493
494 cout << endl;
495
496 cout << "\tCreate a DataConstant object from a DataArrayView" << endl;
497
498 DataTypes::ShapeType viewShape;
499 viewShape.push_back(2);
500 viewShape.push_back(3);
501 viewShape.push_back(4);
502 DataTypes::ValueType viewData(2*3*4);
503 for (int i=0;i<DataTypes::noValues(viewShape);++i) {
504 viewData[i]=i;
505 }
506 DataArrayView myView(viewData,viewShape);
507
508 Data left(myView);
509 Data right(myView);
510 Data result;
511
512 cout << "\tTest some basic operations" << endl;
513
514 result=left-right;
515
516 assert(left.isConstant());
517 assert(right.isConstant());
518 assert(result.isConstant());
519
520 result=left+right;
521
522 assert(left.isConstant());
523 assert(right.isConstant());
524 assert(result.isConstant());
525
526 assert(!result.isExpanded());
527 assert(!result.isTagged());
528
529 }
530
531 void DataTestCase::testDataTagged() {
532
533 cout << endl;
534
535 {
536
537 cout << "\tCreate a DataTagged object with a default value only." << endl;
538
539 DataTagged::TagListType keys;
540
541 DataTagged::ValueListType values;
542
543 DataTypes::ShapeType viewShape;
544 viewShape.push_back(3);
545
546 DataTypes::ValueType viewData(3);
547 for (int i=0;i<viewShape[0];i++) {
548 viewData[i]=i;
549 }
550 DataArrayView defaultValue(viewData,viewShape);
551
552 bool expanded=false;
553
554 Data myData(keys,values,defaultValue,FunctionSpace(),expanded);
555
556 // cout << myData.toString() << endl;
557
558 assert(!myData.isEmpty());
559 assert(myData.isTagged());
560 assert(myData.getTagNumber(0)==1);
561 assert(myData.getDataPointRank()==1);
562 assert(myData.getLength()==3);
563
564 DataArrayView myDataView = myData.getPointDataView();
565 assert(!myDataView.isEmpty());
566 assert(myDataView.getOffset()==0);
567 assert(myDataView.getRank()==1);
568 assert(myDataView.noValues()==3);
569 assert(myDataView.getShape().size()==1);
570 assert(myDataView(0)==0.0);
571 assert(myDataView(1)==1.0);
572 assert(myDataView(2)==2.0);
573
574 myDataView = myData.getDataPoint(0,0);
575 assert(!myDataView.isEmpty());
576 assert(myDataView.getOffset()==0);
577 assert(myDataView.getRank()==1);
578 assert(myDataView.noValues()==3);
579 assert(myDataView.getShape().size()==1);
580 assert(myDataView(0)==0.0);
581 assert(myDataView(1)==1.0);
582 assert(myDataView(2)==2.0);
583
584 double* sampleData=myData.getSampleData(0);
585 for (int i=0; i<myDataView.noValues(); i++) {
586 assert(sampleData[i]==i);
587 }
588 // use a non-existent tag so we get a pointer to
589 // the first element of the data array
590 sampleData=myData.getSampleDataByTag(9);
591 for (int i=0; i<myData.getLength(); i++) {
592 assert(sampleData[i]==i);
593 }
594
595 cout << "\tTest setting of a tag and associated value." << endl;
596
597 // value for tag "1"
598 DataTypes::ValueType eTwoData(viewData);
599 DataArrayView eTwoView(eTwoData, viewShape);
600 for (int i=0;i<eTwoView.getShape()[0];i++) {
601 eTwoView(i)=i+2.0;
602 }
603
604 myData.setTaggedValueFromCPP(1,viewShape, eTwoView.getData());
605
606 assert(myData.getLength()==6);
607
608 myDataView = myData.getDataPoint(0,0);
609 assert(myDataView==eTwoView);
610 assert(!myDataView.isEmpty());
611 assert(myDataView.getOffset()==3);
612 assert(myDataView.getRank()==1);
613 assert(myDataView.noValues()==3);
614 assert(myDataView.getShape().size()==1);
615 assert(myDataView(0)==2);
616 assert(myDataView(1)==3);
617 assert(myDataView(2)==4);
618
619 sampleData=myData.getSampleDataByTag(1);
620 for (int i=0; i<myDataView.noValues(); i++) {
621 assert(sampleData[i]==i+2);
622 }
623
624 }
625
626 {
627
628 cout << "\tCreate a DataTagged object via tag() method." << endl;
629
630 DataTypes::ShapeType viewShape;
631 viewShape.push_back(2);
632 viewShape.push_back(3);
633 Data myData(1.3,viewShape,FunctionSpace(),false);
634 myData.tag();
635
636 //cout << myData.toString() << endl;
637
638 assert(!myData.isEmpty());
639 assert(myData.isTagged());
640 assert(myData.getTagNumber(0)==1);
641 assert(myData.getDataPointRank()==2);
642 assert(myData.getLength()==6);
643
644 // check default value
645 DataArrayView myDataView = myData.getPointDataView();
646 assert(!myDataView.isEmpty());
647 assert(myDataView.getOffset()==0);
648 assert(myDataView.getRank()==2);
649 assert(myDataView.noValues()==6);
650 assert(myDataView.getShape().size()==2);
651 assert(myDataView(0,0)==1.3);
652 assert(myDataView(0,1)==1.3);
653 assert(myDataView(0,2)==1.3);
654 assert(myDataView(1,0)==1.3);
655 assert(myDataView(1,1)==1.3);
656 assert(myDataView(1,2)==1.3);
657
658 // check value for data-point (0,0).
659 myDataView = myData.getDataPoint(0,0);
660 assert(!myDataView.isEmpty());
661 assert(myDataView.getOffset()==0);
662 assert(myDataView.getRank()==2);
663 assert(myDataView.noValues()==6);
664 assert(myDataView.getShape().size()==2);
665 assert(myDataView(0,0)==1.3);
666 assert(myDataView(0,1)==1.3);
667 assert(myDataView(0,2)==1.3);
668 assert(myDataView(1,0)==1.3);
669 assert(myDataView(1,1)==1.3);
670 assert(myDataView(1,2)==1.3);
671
672 }
673
674 }
675
676 void DataTestCase::testDataTaggedExceptions() {
677
678 cout << endl;
679
680 cout << "\tTest DataTagged exceptions." << endl;
681
682 Data myData;
683 DataArrayView myView;
684
685 try {
686 myData.getSampleDataByTag(0);;
687 assert(false);
688 }
689 catch (EsysException&) {
690 //cout << e.what() << endl;
691 assert(true);
692 }
693
694 try {
695 myData.setTaggedValueFromCPP(0,DataTypes::ShapeType(), DataTypes::ValueType());;
696 assert(false);
697 }
698 catch (EsysException&) {
699 //cout << e.what() << endl;
700 assert(true);
701 }
702
703 }
704
705 void DataTestCase::testConstructors() {
706
707 cout << endl;
708
709 DataTypes::ShapeType viewShape;
710 {
711 cout << "\tCreate an Empty Data object" << endl;
712 Data temp(1.3,viewShape,FunctionSpace(),false);
713 }
714 {
715 cout << "\tCreate a rank 2 Data object" << endl;
716 viewShape.push_back(2);
717 viewShape.push_back(3);
718 Data temp(1.3,viewShape,FunctionSpace(),false);
719 }
720 }
721
722 void DataTestCase::testOperations() {
723
724 cout << endl;
725
726 // define the shape for the DataArrayView test data
727 DataTypes::ShapeType shape;
728 shape.push_back(2);
729 shape.push_back(3);
730
731 // allocate the data for the DataArrayView
732 DataTypes::ValueType data(DataTypes::noValues(shape),0);
733
734 // construct DataArrayView
735 DataArrayView dataView(data,shape);
736
737 // assign values to the data
738 for (int i=0;i<shape[0];i++) {
739 for (int j=0;j<shape[1];j++) {
740 dataView(i,j)=dataView.index(i,j);
741 }
742 }
743
744 Data baseEx(dataView,FunctionSpace(),true);
745 Data baseCon(dataView,FunctionSpace(),false);
746 Data baseTag(dataView,FunctionSpace(),false);
747 baseTag.tag();
748
749 assert(baseEx.isExpanded());
750 assert(baseCon.isConstant());
751 assert(baseTag.isTagged());
752
753 Data resultEx;
754 Data resultCon;
755 Data resultTag;
756
757 // test unary operations
758
759 double tmp;
760 cout << "\tTest Data::pow." << endl;
761 Data power(3.0,shape,FunctionSpace(),true);
762 resultEx.copy(baseEx.powD(power));
763 resultCon.copy(baseCon.powD(power));
764 resultTag.copy(baseTag.powD(power));
765 for (int i=0;i<shape[0];i++) {
766 for (int j=0;j<shape[1];j++) {
767 tmp=pow((double)dataView.index(i,j),(double)3.0);
768 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
769 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
770 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
771 }
772 }
773
774 cout << "\tTest Data::sin." << endl;
775 resultEx.copy(baseEx.sin());
776 resultCon.copy(baseCon.sin());
777 resultTag.copy(baseTag.sin());
778 for (int i=0;i<shape[0];i++) {
779 for (int j=0;j<shape[1];j++) {
780 tmp=sin((double)dataView.index(i,j));
781 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
782 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
783 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
784 }
785 }
786
787 cout << "\tTest Data::cos." << endl;
788 resultEx.copy(baseEx.cos());
789 resultCon.copy(baseCon.cos());
790 resultTag.copy(baseTag.cos());
791 for (int i=0;i<shape[0];i++) {
792 for (int j=0;j<shape[1];j++) {
793 tmp=cos((double)dataView.index(i,j));
794 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
795 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
796 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
797 }
798 }
799
800 cout << "\tTest Data::tan." << endl;
801 resultEx.copy(baseEx.tan());
802 resultCon.copy(baseCon.tan());
803 resultTag.copy(baseTag.tan());
804 for (int i=0;i<shape[0];i++) {
805 for (int j=0;j<shape[1];j++) {
806 tmp=tan((double)dataView.index(i,j));
807 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
808 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
809 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
810 }
811 }
812
813 cout << "\tTest Data::asin." << endl;
814 resultEx.copy(baseEx.asin());
815 resultCon.copy(baseCon.asin());
816 resultTag.copy(baseTag.asin());
817 assert(true);
818
819 cout << "\tTest Data::acos." << endl;
820 resultEx.copy(baseEx.acos());
821 resultCon.copy(baseCon.acos());
822 resultTag.copy(baseTag.acos());
823 assert(true);
824
825 cout << "\tTest Data::atan." << endl;
826 resultEx.copy(baseEx.atan());
827 resultCon.copy(baseCon.atan());
828 resultTag.copy(baseTag.atan());
829 for (int i=0;i<shape[0];i++) {
830 for (int j=0;j<shape[1];j++) {
831 tmp=atan((double)dataView.index(i,j));
832 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
833 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
834 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
835 }
836 }
837
838 cout << "\tTest Data::sinh." << endl;
839 resultEx.copy(baseEx.sinh());
840 resultCon.copy(baseCon.sinh());
841 resultTag.copy(baseTag.sinh());
842 for (int i=0;i<shape[0];i++) {
843 for (int j=0;j<shape[1];j++) {
844 tmp=sinh((double)dataView.index(i,j));
845 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
846 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
847 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
848 }
849 }
850
851 cout << "\tTest Data::cosh." << endl;
852 resultEx.copy(baseEx.cosh());
853 resultCon.copy(baseCon.cosh());
854 resultTag.copy(baseTag.cosh());
855 for (int i=0;i<shape[0];i++) {
856 for (int j=0;j<shape[1];j++) {
857 tmp=cosh((double)dataView.index(i,j));
858 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
859 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
860 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
861 }
862 }
863
864 cout << "\tTest Data::tanh." << endl;
865 resultEx.copy(baseEx.tanh());
866 resultCon.copy(baseCon.tanh());
867 resultTag.copy(baseTag.tanh());
868 for (int i=0;i<shape[0];i++) {
869 for (int j=0;j<shape[1];j++) {
870 tmp=tanh((double)dataView.index(i,j));
871 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
872 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
873 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
874 }
875 }
876
877 cout << "\tTest Data::asinh." << endl;
878 resultEx.copy(baseEx.asinh());
879 resultCon.copy(baseCon.asinh());
880 resultTag.copy(baseTag.asinh());
881 assert(true);
882
883 cout << "\tTest Data::acosh." << endl;
884 resultEx.copy(baseEx.acosh());
885 resultCon.copy(baseCon.acosh());
886 resultTag.copy(baseTag.acosh());
887 assert(true);
888
889 cout << "\tTest Data::atanh." << endl;
890 resultEx.copy(baseEx.atanh());
891 resultCon.copy(baseCon.atanh());
892 resultTag.copy(baseTag.atanh());
893 assert(true);
894
895 cout << "\tTest Data::log." << endl;
896 resultEx.copy(baseEx.log());
897 resultCon.copy(baseCon.log());
898 resultTag.copy(baseTag.log());
899 assert(true);
900
901 cout << "\tTest Data::abs." << endl;
902 resultEx.copy(baseEx.abs());
903 resultCon.copy(baseCon.abs());
904 resultTag.copy(baseTag.abs());
905 for (int i=0;i<shape[0];i++) {
906 for (int j=0;j<shape[1];j++) {
907 tmp=abs((double)dataView.index(i,j));
908 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
909 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
910 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
911 }
912 }
913
914 cout << "\tTest Data::sign." << endl;
915 resultEx.copy(baseEx.sign());
916 resultCon.copy(baseCon.sign());
917 resultTag.copy(baseTag.sign());
918 assert(true);
919
920 cout << "\tTest Data::exp." << endl;
921 resultEx.copy(baseEx.exp());
922 resultCon.copy(baseCon.exp());
923 resultTag.copy(baseTag.exp());
924 for (int i=0;i<shape[0];i++) {
925 for (int j=0;j<shape[1];j++) {
926 tmp=exp((double)dataView.index(i,j));
927 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
928 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
929 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
930 }
931 }
932
933 cout << "\tTest Data::sqrt." << endl;
934 resultEx.copy(baseEx.sqrt());
935 resultCon.copy(baseCon.sqrt());
936 resultTag.copy(baseTag.sqrt());
937 for (int i=0;i<shape[0];i++) {
938 for (int j=0;j<shape[1];j++) {
939 tmp=sqrt((double)dataView.index(i,j));
940 assert(std::abs(resultEx.getPointDataView()(i,j) - tmp) <= REL_TOL*std::abs(tmp));
941 assert(std::abs(resultCon.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
942 assert(std::abs(resultTag.getPointDataView()(i,j)- tmp) <= REL_TOL*std::abs(tmp));
943 }
944 }
945
946 cout << "\tTest Data::neg." << endl;
947 resultEx.copy(baseEx.neg());
948 resultCon.copy(baseCon.neg());
949 resultTag.copy(baseTag.neg());
950 assert(true);
951
952 cout << "\tTest Data::pos." << endl;
953 resultEx.copy(baseEx.pos());
954 resultCon.copy(baseCon.pos());
955 resultTag.copy(baseTag.pos());
956 for (int i=0;i<shape[0];i++) {
957 for (int j=0;j<shape[1];j++) {
958 assert(std::abs(resultEx.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
959 assert(std::abs(resultCon.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
960 assert(std::abs(resultTag.getPointDataView()(i,j) - dataView.index(i,j)) <= REL_TOL*std::abs(dataView.index(i,j)));
961 }
962 }
963
964 // test reduction operations
965
966 cout << "\tTest Data::Lsup." << endl;
967 assert(std::abs(baseEx.Lsup() - 5) <= REL_TOL*5);
968 assert(std::abs(baseCon.Lsup() - 5) <= REL_TOL*5);
969 assert(std::abs(baseTag.Lsup() - 5) <= REL_TOL*5);
970
971 cout << "\tTest Data::sup." << endl;
972 assert(std::abs(baseEx.sup() - 5) <= REL_TOL*5);
973 assert(std::abs(baseCon.sup() - 5) <= REL_TOL*5);
974 assert(std::abs(baseTag.sup() - 5) <= REL_TOL*5);
975
976 cout << "\tTest Data::inf." << endl;
977 assert(std::abs(baseEx.inf() - 0) <= REL_TOL*0);
978 assert(std::abs(baseCon.inf() - 0) <= REL_TOL*0);
979 assert(std::abs(baseTag.inf() - 0) <= REL_TOL*0);
980
981 // test data-point reduction operations
982
983 cout << "\tTest Data::minval." << endl;
984 resultEx.copy(baseEx.minval());
985 resultCon.copy(baseCon.minval());
986 resultTag.copy(baseTag.minval());
987 assert(std::abs(resultEx.getPointDataView()() - 0) <= REL_TOL*0);
988 assert(std::abs(resultCon.getPointDataView()() - 0) <= REL_TOL*0);
989 assert(std::abs(resultTag.getPointDataView()() - 0) <= REL_TOL*0);
990
991 cout << "\tTest Data::maxval." << endl;
992 resultEx.copy(baseEx.maxval());
993 resultCon.copy(baseCon.maxval());
994 resultTag.copy(baseTag.maxval());
995 assert(std::abs(resultEx.getPointDataView()() - 5) <= REL_TOL*5);
996 assert(std::abs(resultCon.getPointDataView()() - 5) <= REL_TOL*5);
997 assert(std::abs(resultTag.getPointDataView()() - 5) <= REL_TOL*5);
998
999 }
1000
1001
1002 void DataTestCase::testMemAlloc() {
1003
1004 //
1005 // Simple little sanity check for the memory allocator
1006
1007 cout << endl;
1008
1009 Data *testData;
1010 for (int i=0; i<1000; i++) {
1011 testData = new Data(0.0, DataTypes::ShapeType(), FunctionSpace(), true);
1012 delete testData;
1013 }
1014
1015 DataTypes::ShapeType viewShape;
1016 viewShape.push_back(10);
1017 viewShape.push_back(10);
1018 viewShape.push_back(10);
1019
1020 Data *testData2;
1021 Data *testData3 = new Data(0.0, viewShape, FunctionSpace(), true);
1022 for (int i=0; i<1000; i++) {
1023 testData2 = new Data(0.0, viewShape, FunctionSpace(), true);
1024 delete testData2;
1025 }
1026 delete testData3;
1027
1028 }
1029
1030 TestSuite* DataTestCase::suite ()
1031 {
1032 //
1033 // create the suite of tests to perform.
1034 TestSuite *testSuite = new TestSuite ("DataTestCase");
1035
1036 testSuite->addTest (new TestCaller< DataTestCase>("testAll",&DataTestCase::testAll));
1037 testSuite->addTest (new TestCaller< DataTestCase>("testMore",&DataTestCase::testMore));
1038 testSuite->addTest (new TestCaller< DataTestCase>("testDataConstant",&DataTestCase::testDataConstant));
1039 testSuite->addTest (new TestCaller< DataTestCase>("testDataTagged",&DataTestCase::testDataTagged));
1040 testSuite->addTest (new TestCaller< DataTestCase>("testDataTaggedExceptions",&DataTestCase::testDataTaggedExceptions));
1041 testSuite->addTest (new TestCaller< DataTestCase>("testConstructors",&DataTestCase::testConstructors));
1042 testSuite->addTest (new TestCaller< DataTestCase>("testSlicing",&DataTestCase::testSlicing));
1043 testSuite->addTest (new TestCaller< DataTestCase>("testOperations",&DataTestCase::testOperations));
1044 //testSuite->addTest (new TestCaller< DataTestCase>("testRefValue",&DataTestCase::testRefValue));
1045 testSuite->addTest (new TestCaller< DataTestCase>("testMemAlloc",&DataTestCase::testMemAlloc));
1046
1047 return testSuite;
1048 }

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision
  ViewVC Help
Powered by ViewVC 1.1.26