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

Annotation of /branches/arrayview_from_1695_trunk/escript/test/DataArrayViewTestCase.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 682 - (hide annotations)
Mon Mar 27 02:43:09 2006 UTC (13 years, 5 months ago) by robwdcock
Original Path: trunk/escript/test/DataArrayViewTestCase.cpp
File size: 63608 byte(s)
+ NEW BUILD SYSTEM

This commit contains the new build system with cross-platform support.
Most things work are before though you can have more control.

ENVIRONMENT settings have changed:
+ You no longer require LD_LIBRARY_PATH or PYTHONPATH to point to the
esysroot for building and testing performed via scons
+ ACcESS altix users: It is recommended you change your modules to load
the latest intel compiler and other libraries required by boost to match
the setup in svn (you can override). The correct modules are as follows

module load intel_cc.9.0.026
export
MODULEPATH=${MODULEPATH}:/data/raid2/toolspp4/modulefiles/gcc-3.3.6
module load boost/1.33.0/python-2.4.1
module load python/2.4.1
module load numarray/1.3.3


1 jgs 82 /*
2     *****************************************************************************
3     * *
4     * COPYRIGHT ACcESS - All Rights Reserved *
5     * *
6     * This software is the property of ACcESS. No part of this code *
7     * may be copied in any form or by any means without the expressed written *
8     * consent of ACcESS. Copying, use or modification of this software *
9     * by any unauthorised person is illegal unless that person has a software *
10     * license agreement with ACcESS. *
11     * *
12     *****************************************************************************
13     */
14 robwdcock 670 #include "escript/DataArray.h"
15     #include "escript/DataArrayView.h"
16     #include "escript/DataAlgorithm.h"
17 robwdcock 638 #include "esysUtils/EsysException.h"
18 jgs 82
19 jgs 113 #include "DataArrayViewTestCase.h"
20    
21 jgs 82 #include <iostream>
22    
23     using namespace CppUnitTest;
24     using namespace esysUtils;
25     using namespace escript;
26     using namespace std;
27    
28     void DataArrayViewTestCase::setUp() {
29     //
30     // This is called before each test is run
31    
32     }
33    
34     void DataArrayViewTestCase::tearDown() {
35     //
36     // This is called after each test has been run
37    
38     }
39    
40 jgs 108 void DataArrayViewTestCase::testResultSliceShape() {
41 jgs 82
42     cout << endl;
43 jgs 108 cout << "\tTest getResultSliceShape method." << endl;
44 jgs 82
45 jgs 108 DataArrayView::RegionType region;
46     DataArrayView::ShapeType resultShape;
47    
48     region.push_back(DataArrayView::RegionType::value_type(1,5));
49     resultShape.push_back(4);
50     assert(DataArrayView::getResultSliceShape(region)==resultShape);
51    
52     region.push_back(DataArrayView::RegionType::value_type(2,5));
53     resultShape.push_back(3);
54     assert(DataArrayView::getResultSliceShape(region)==resultShape);
55    
56     region.push_back(DataArrayView::RegionType::value_type(3,9));
57     resultShape.push_back(6);
58     assert(DataArrayView::getResultSliceShape(region)==resultShape);
59    
60     region.push_back(DataArrayView::RegionType::value_type(1,7));
61     resultShape.push_back(6);
62     assert(DataArrayView::getResultSliceShape(region)==resultShape);
63    
64     }
65    
66     void DataArrayViewTestCase::testSlicing() {
67    
68 jgs 82 {
69 jgs 108 cout << endl;
70     cout << "\tSlice a scalar to a scalar.";
71    
72     // Define slice region.
73 jgs 82 DataArrayView::RegionType region;
74 jgs 108
75     // Define shape of views.
76     DataArrayView::ShapeType sourceShape;
77    
78     // Create source and target views.
79     DataArray source(sourceShape,2.0);
80     DataArrayView sourceView=source.getView();
81    
82     DataArray target;
83     DataArrayView targetView=target.getView();
84    
85     // Copy source view to target view.
86     targetView.copySlice(sourceView,region);
87    
88     // Check results of copy.
89     assert(sourceView==targetView);
90 jgs 82 }
91    
92     {
93 jgs 108 cout << endl;
94     cout << "\tSlice a scalar from a scalar.";
95    
96     // Define slice region.
97 jgs 82 DataArrayView::RegionType region;
98 jgs 108
99     // Define shape of views.
100 jgs 82 DataArrayView::ShapeType sourceShape;
101 jgs 108
102     // Create source and target views.
103 jgs 82 DataArray source(sourceShape,2.0);
104 jgs 108 DataArrayView sourceView=source.getView();
105    
106 jgs 82 DataArray target;
107 jgs 108 DataArrayView targetView=target.getView();
108    
109     // Copy source view to target view.
110     targetView.copySliceFrom(sourceView,region);
111    
112     // Check results of copy.
113     assert(sourceView==targetView);
114 jgs 82 }
115    
116     {
117 jgs 108 cout << endl;
118     cout << "\tSlice a 1 dimensional slice to a 1 dimensional array.";
119    
120     // Define slice region.
121 jgs 82 DataArrayView::RegionType region;
122     region.push_back(DataArrayView::RegionType::value_type(2,4));
123 jgs 108
124     // Define shapes of views.
125 jgs 82 DataArrayView::ShapeType sourceShape;
126     sourceShape.push_back(6);
127 jgs 108 DataArrayView::ShapeType targetShape = DataArrayView::getResultSliceShape(region);
128    
129     // Create source and target views.
130 jgs 82 DataArray source(sourceShape);
131 jgs 108 DataArrayView sourceView=source.getView();
132     for (int i=0;i<sourceShape[0];i++) {
133     sourceView(i)=i;
134 jgs 82 }
135 jgs 108
136     DataArray target(targetShape);
137     DataArrayView targetView=target.getView();
138    
139     // Copy source view to target view.
140     targetView.copySlice(sourceView,region);
141    
142     // Check results of copy.
143     for (int i=region[0].first;i<region[0].second;i++) {
144     assert(sourceView(i)==
145     targetView(i-region[0].first));
146 jgs 82 }
147     }
148    
149     {
150 jgs 108 cout << endl;
151     cout << "\tSlice a 1 dimensional slice to a scalar.";
152    
153     // Define slice region.
154 jgs 82 DataArrayView::RegionType region;
155 jgs 108 region.push_back(DataArrayView::RegionType::value_type(2,3));
156    
157     // Define shapes of views.
158     DataArrayView::ShapeType sourceShape;
159     sourceShape.push_back(6);
160     DataArrayView::ShapeType targetShape;
161    
162     // Create source and target views.
163     DataArray source(sourceShape);
164     DataArrayView sourceView=source.getView();
165     for (int i=0;i<sourceShape[0];i++) {
166     sourceView(i)=i;
167     }
168    
169     DataArray target(targetShape);
170     DataArrayView targetView=target.getView();
171    
172     // Copy source view to target view.
173     targetView.copySlice(sourceView,region);
174    
175     // Check results of copy.
176     for (int i=region[0].first;i<region[0].second;i++) {
177     assert(sourceView(i)==
178     targetView());
179     }
180     }
181    
182     {
183     cout << endl;
184     cout << "\tSlice a 1 dimensional slice from a 1 dimensional array.";
185    
186     // Define slice region.
187     DataArrayView::RegionType region;
188 jgs 82 region.push_back(DataArrayView::RegionType::value_type(2,4));
189 jgs 108
190     // Define shapes of views.
191     DataArrayView::ShapeType sourceShape = DataArrayView::getResultSliceShape(region);
192     DataArrayView::ShapeType targetShape;
193     targetShape.push_back(6);
194    
195     // Create source and target views.
196     DataArray source(sourceShape);
197     DataArrayView sourceView=source.getView();
198     for (int i=0;i<sourceShape[0];i++) {
199     sourceView(i)=i;
200     }
201    
202     DataArray target(targetShape);
203     DataArrayView targetView=target.getView();
204    
205     // Copy source view to target view.
206     targetView.copySliceFrom(sourceView,region);
207    
208     // Check results of copy.
209     for (int i=region[0].first;i<region[0].second;i++) {
210     assert(sourceView(i-region[0].first)==
211     targetView(i));
212     }
213     }
214    
215     {
216     cout << endl;
217     cout << "\tSlice a 1 dimensional slice from a scalar.";
218    
219     // Define slice region.
220     DataArrayView::RegionType region;
221     region.push_back(DataArrayView::RegionType::value_type(2,4));
222    
223     // Define shapes of views.
224     DataArrayView::ShapeType sourceShape;
225     DataArrayView::ShapeType targetShape;
226     targetShape.push_back(6);
227    
228     // Create source and target views.
229     DataArray source(sourceShape);
230     DataArrayView sourceView=source.getView();
231     sourceView()=5;
232    
233     DataArray target(targetShape);
234     DataArrayView targetView=target.getView();
235    
236     // Copy source view to target view.
237     targetView.copySliceFrom(sourceView,region);
238    
239     // Check results of copy.
240     for (int i=region[0].first;i<region[0].second;i++) {
241     assert(sourceView()==
242     targetView(i));
243     }
244     }
245    
246     {
247     cout << endl;
248     cout << "\tSlice a 2 dimensional slice to a 2 dimensional array.";
249    
250     // Define slice region.
251     DataArrayView::RegionType region;
252     region.push_back(DataArrayView::RegionType::value_type(2,4));
253 jgs 82 region.push_back(DataArrayView::RegionType::value_type(0,2));
254 jgs 108
255     // Define shapes of views.
256 jgs 82 DataArrayView::ShapeType sourceShape;
257     sourceShape.push_back(6);
258     sourceShape.push_back(3);
259 jgs 108 DataArrayView::ShapeType targetShape = DataArrayView::getResultSliceShape(region);
260    
261     // Create source and target views.
262 jgs 82 DataArray source(sourceShape);
263 jgs 108 DataArrayView sourceView=source.getView();
264 jgs 82 int val=0;
265 jgs 108 for (int i=0;i<sourceShape[0];i++) {
266     for (int j=0;j<sourceShape[1];j++) {
267     sourceView(i,j)=val++;
268 jgs 82 }
269     }
270 jgs 108
271     DataArray target(targetShape);
272     DataArrayView targetView=target.getView();
273    
274     // Copy source view to target view.
275     targetView.copySlice(sourceView,region);
276    
277     // Check results of copy.
278     for (int i=region[0].first;i<region[0].second;i++) {
279     for (int j=region[1].first;j<region[1].second;j++) {
280     assert(sourceView(i,j)==
281     targetView(i-region[0].first,j-region[1].first));
282 jgs 82 }
283     }
284     }
285    
286 jgs 108 {
287     cout << endl;
288     cout << "\tSlice a 2 dimensional slice to a 1 dimensional array.";
289    
290     // Define slice region.
291     DataArrayView::RegionType region;
292     region.push_back(DataArrayView::RegionType::value_type(0,3));
293     region.push_back(DataArrayView::RegionType::value_type(1,2));
294    
295     // Define shapes of views.
296     DataArrayView::ShapeType sourceShape;
297     sourceShape.push_back(3);
298     sourceShape.push_back(6);
299     DataArrayView::ShapeType targetShape;
300     targetShape.push_back(3);
301    
302     // Create source and target views.
303     DataArray source(sourceShape);
304     DataArrayView sourceView=source.getView();
305     int val=0;
306     for (int i=0;i<sourceShape[0];i++) {
307     for (int j=0;j<sourceShape[1];j++) {
308     sourceView(i,j)=val++;
309     }
310     }
311    
312     DataArray target(targetShape);
313     DataArrayView targetView=target.getView();
314    
315     // Copy source view to target view.
316     targetView.copySlice(sourceView,region);
317    
318     // Check results of copy.
319     for (int i=region[0].first;i<region[0].second;i++) {
320     for (int j=region[1].first;j<region[1].second;j++) {
321     assert(sourceView(i,j)==
322     targetView(i-region[0].first));
323     }
324     }
325     }
326    
327     {
328     cout << endl;
329     cout << "\tSlice a 2 dimensional slice to a scalar.";
330    
331     // Define slice region.
332     DataArrayView::RegionType region;
333     region.push_back(DataArrayView::RegionType::value_type(2,3));
334     region.push_back(DataArrayView::RegionType::value_type(1,2));
335    
336     // Define shapes of views.
337     DataArrayView::ShapeType sourceShape;
338     sourceShape.push_back(3);
339     sourceShape.push_back(6);
340     DataArrayView::ShapeType targetShape;
341    
342     // Create source and target views.
343     DataArray source(sourceShape);
344     DataArrayView sourceView=source.getView();
345     int val=0;
346     for (int i=0;i<sourceShape[0];i++) {
347     for (int j=0;j<sourceShape[1];j++) {
348     sourceView(i,j)=val++;
349     }
350     }
351    
352     DataArray target(targetShape);
353     DataArrayView targetView=target.getView();
354    
355     // Copy source view to target view.
356     targetView.copySlice(sourceView,region);
357     // Check results of copy.
358     for (int i=region[0].first;i<region[0].second;i++) {
359     for (int j=region[1].first;j<region[1].second;j++) {
360     assert(sourceView(i,j)==
361     targetView());
362     }
363     }
364     }
365    
366     {
367     cout << endl;
368     cout << "\tSlice a 2 dimensional slice from a 2 dimensional array.";
369    
370     // Define slice region.
371     DataArrayView::RegionType region;
372     region.push_back(DataArrayView::RegionType::value_type(2,4));
373     region.push_back(DataArrayView::RegionType::value_type(0,2));
374    
375     // Define shapes of views.
376     DataArrayView::ShapeType sourceShape = DataArrayView::getResultSliceShape(region);
377     DataArrayView::ShapeType targetShape;
378     targetShape.push_back(6);
379     targetShape.push_back(3);
380    
381     // Create source and target views.
382     DataArray source(sourceShape);
383     DataArrayView sourceView=source.getView();
384     int val=0;
385     for (int i=0;i<sourceShape[0];i++) {
386     for (int j=0;j<sourceShape[1];j++) {
387     sourceView(i,j)=val++;
388     }
389     }
390    
391     DataArray target(targetShape);
392     DataArrayView targetView=target.getView();
393    
394     // Copy source view to target view.
395     targetView.copySliceFrom(sourceView,region);
396    
397     // Check results of copy.
398     for (int i=region[0].first;i<region[0].second;i++) {
399     for (int j=region[1].first;j<region[1].second;j++) {
400     assert(sourceView(i-region[0].first,j-region[1].first)==
401     targetView(i,j));
402     }
403     }
404     }
405    
406     {
407     cout << endl;
408     cout << "\tSlice a 2 dimensional slice from a scalar.";
409    
410     // Define slice region.
411     DataArrayView::RegionType region;
412     region.push_back(DataArrayView::RegionType::value_type(2,4));
413     region.push_back(DataArrayView::RegionType::value_type(0,2));
414    
415     // Define shapes of views.
416     DataArrayView::ShapeType sourceShape;
417     DataArrayView::ShapeType targetShape;
418     targetShape.push_back(6);
419     targetShape.push_back(3);
420    
421     // Create source and target views.
422     DataArray source(sourceShape);
423     DataArrayView sourceView=source.getView();
424     sourceView()=5;
425    
426     DataArray target(targetShape);
427     DataArrayView targetView=target.getView();
428    
429     // Copy source view to target view.
430     targetView.copySliceFrom(sourceView,region);
431    
432     // Check results of copy.
433     for (int i=region[0].first;i<region[0].second;i++) {
434     for (int j=region[1].first;j<region[1].second;j++) {
435     assert(sourceView()==
436     targetView(i,j));
437     }
438     }
439     }
440    
441     {
442     cout << endl;
443     cout << "\tSlice a 3 dimensional slice to a 3 dimensional array.";
444    
445     // Define slice region.
446     DataArrayView::RegionType region;
447     region.push_back(DataArrayView::RegionType::value_type(2,4));
448     region.push_back(DataArrayView::RegionType::value_type(0,2));
449     region.push_back(DataArrayView::RegionType::value_type(5,9));
450    
451     // Define shapes of views.
452     DataArrayView::ShapeType sourceShape;
453     sourceShape.push_back(6);
454     sourceShape.push_back(3);
455     sourceShape.push_back(13);
456     DataArrayView::ShapeType targetShape = DataArrayView::getResultSliceShape(region);
457    
458     // Create source and target views.
459     DataArray source(sourceShape);
460     DataArrayView sourceView=source.getView();
461     int val=0;
462     for (int i=0;i<sourceShape[0];i++) {
463     for (int j=0;j<sourceShape[1];j++) {
464     for (int k=0;k<sourceShape[2];k++) {
465     sourceView(i,j,k)=val++;
466     }
467     }
468     }
469    
470     DataArray target(targetShape);
471     DataArrayView targetView=target.getView();
472    
473     // Copy source view to target view.
474     targetView.copySlice(sourceView,region);
475    
476     // Check results of copy.
477     for (int i=region[0].first;i<region[0].second;i++) {
478     for (int j=region[1].first;j<region[1].second;j++) {
479     for (int k=region[2].first;k<region[2].second;k++) {
480     assert(sourceView(i,j,k)==
481     targetView(i-region[0].first,j-region[1].first,k-region[2].first));
482     }
483     }
484     }
485     }
486    
487     {
488     cout << endl;
489     cout << "\tSlice a 3 dimensional slice to a 2 dimensional array.";
490    
491     // Define slice region.
492     DataArrayView::RegionType region;
493     region.push_back(DataArrayView::RegionType::value_type(2,4));
494     region.push_back(DataArrayView::RegionType::value_type(0,1));
495     region.push_back(DataArrayView::RegionType::value_type(5,9));
496    
497     // Define shapes of views.
498     DataArrayView::ShapeType sourceShape;
499     sourceShape.push_back(6);
500     sourceShape.push_back(3);
501     sourceShape.push_back(13);
502     DataArrayView::ShapeType targetShape;
503     targetShape.push_back(2);
504     targetShape.push_back(4);
505    
506     // Create source and target views.
507     DataArray source(sourceShape);
508     DataArrayView sourceView=source.getView();
509     int val=0;
510     for (int i=0;i<sourceShape[0];i++) {
511     for (int j=0;j<sourceShape[1];j++) {
512     for (int k=0;k<sourceShape[2];k++) {
513     sourceView(i,j,k)=val++;
514     }
515     }
516     }
517    
518     DataArray target(targetShape);
519     DataArrayView targetView=target.getView();
520    
521     // Copy source view to target view.
522     targetView.copySlice(sourceView,region);
523    
524     // Check results of copy.
525     for (int i=region[0].first;i<region[0].second;i++) {
526     for (int j=region[1].first;j<region[1].second;j++) {
527     for (int k=region[2].first;k<region[2].second;k++) {
528     assert(sourceView(i,j,k)==
529     targetView(i-region[0].first,k-region[2].first));
530     }
531     }
532     }
533     }
534    
535     {
536     cout << endl;
537     cout << "\tSlice a 3 dimensional slice to a 1 dimensional array.";
538    
539     // Define slice region.
540     DataArrayView::RegionType region;
541     region.push_back(DataArrayView::RegionType::value_type(3,4));
542     region.push_back(DataArrayView::RegionType::value_type(0,1));
543     region.push_back(DataArrayView::RegionType::value_type(5,9));
544    
545     // Define shapes of views.
546     DataArrayView::ShapeType sourceShape;
547     sourceShape.push_back(6);
548     sourceShape.push_back(3);
549     sourceShape.push_back(13);
550     DataArrayView::ShapeType targetShape;
551     targetShape.push_back(4);
552    
553     // Create source and target views.
554     DataArray source(sourceShape);
555     DataArrayView sourceView=source.getView();
556     int val=0;
557     for (int i=0;i<sourceShape[0];i++) {
558     for (int j=0;j<sourceShape[1];j++) {
559     for (int k=0;k<sourceShape[2];k++) {
560     sourceView(i,j,k)=val++;
561     }
562     }
563     }
564    
565     DataArray target(targetShape);
566     DataArrayView targetView=target.getView();
567    
568     // Copy source view to target view.
569     targetView.copySlice(sourceView,region);
570    
571     // Check results of copy.
572     for (int i=region[0].first;i<region[0].second;i++) {
573     for (int j=region[1].first;j<region[1].second;j++) {
574     for (int k=region[2].first;k<region[2].second;k++) {
575     assert(sourceView(i,j,k)==
576     targetView(k-region[2].first));
577     }
578     }
579     }
580     }
581    
582     {
583     cout << endl;
584     cout << "\tSlice a 3 dimensional slice to a scalar.";
585    
586     // Define slice region.
587     DataArrayView::RegionType region;
588     region.push_back(DataArrayView::RegionType::value_type(3,4));
589     region.push_back(DataArrayView::RegionType::value_type(0,1));
590     region.push_back(DataArrayView::RegionType::value_type(5,6));
591    
592     // Define shapes of views.
593     DataArrayView::ShapeType sourceShape;
594     sourceShape.push_back(6);
595     sourceShape.push_back(3);
596     sourceShape.push_back(13);
597     DataArrayView::ShapeType targetShape;
598    
599     // Create source and target views.
600     DataArray source(sourceShape);
601     DataArrayView sourceView=source.getView();
602     int val=0;
603     for (int i=0;i<sourceShape[0];i++) {
604     for (int j=0;j<sourceShape[1];j++) {
605     for (int k=0;k<sourceShape[2];k++) {
606     sourceView(i,j,k)=val++;
607     }
608     }
609     }
610    
611     DataArray target(targetShape);
612     DataArrayView targetView=target.getView();
613    
614     // Copy source view to target view.
615     targetView.copySlice(sourceView,region);
616    
617     // Check results of copy.
618     for (int i=region[0].first;i<region[0].second;i++) {
619     for (int j=region[1].first;j<region[1].second;j++) {
620     for (int k=region[2].first;k<region[2].second;k++) {
621     assert(sourceView(i,j,k)==
622     targetView());
623     }
624     }
625     }
626     }
627    
628     {
629     cout << endl;
630     cout << "\tSlice a 3 dimensional slice from a 3 dimensional array.";
631    
632     // Define slice region.
633     DataArrayView::RegionType region;
634     region.push_back(DataArrayView::RegionType::value_type(4,7));
635     region.push_back(DataArrayView::RegionType::value_type(2,5));
636     region.push_back(DataArrayView::RegionType::value_type(6,7));
637    
638     // Define shapes of views.
639     DataArrayView::ShapeType sourceShape = DataArrayView::getResultSliceShape(region);
640     DataArrayView::ShapeType targetShape;
641     targetShape.push_back(11);
642     targetShape.push_back(8);
643     targetShape.push_back(9);
644    
645     // Create source and target views.
646     DataArray source(sourceShape);
647     DataArrayView sourceView=source.getView();
648     int val=0;
649     for (int i=0;i<sourceShape[0];i++) {
650     for (int j=0;j<sourceShape[1];j++) {
651     for (int k=0;k<sourceShape[2];k++) {
652     sourceView(i,j,k)=val++;
653     }
654     }
655     }
656    
657     DataArray target(targetShape);
658     DataArrayView targetView=target.getView();
659    
660     // Copy source view to target view.
661     targetView.copySliceFrom(sourceView,region);
662    
663     // Check results of copy.
664     for (int i=region[0].first;i<region[0].second;i++) {
665     for (int j=region[1].first;j<region[1].second;j++) {
666     for (int k=region[2].first;k<region[2].second;k++) {
667     assert(sourceView(i-region[0].first,j-region[1].first,k-region[2].first)==
668     targetView(i,j,k));
669     }
670     }
671     }
672     }
673    
674     {
675     cout << endl;
676     cout << "\tSlice a 3 dimensional slice from a scalar.";
677    
678     // Define slice region.
679     DataArrayView::RegionType region;
680     region.push_back(DataArrayView::RegionType::value_type(4,7));
681     region.push_back(DataArrayView::RegionType::value_type(2,5));
682     region.push_back(DataArrayView::RegionType::value_type(6,7));
683    
684     // Define shapes of views.
685     DataArrayView::ShapeType sourceShape;
686     DataArrayView::ShapeType targetShape;
687     targetShape.push_back(11);
688     targetShape.push_back(8);
689     targetShape.push_back(9);
690    
691     // Create source and target views.
692     DataArray source(sourceShape);
693     DataArrayView sourceView=source.getView();
694     sourceView()=5;
695    
696     DataArray target(targetShape);
697     DataArrayView targetView=target.getView();
698    
699     // Copy source view to target view.
700     targetView.copySliceFrom(sourceView,region);
701    
702     // Check results of copy.
703     for (int i=region[0].first;i<region[0].second;i++) {
704     for (int j=region[1].first;j<region[1].second;j++) {
705     for (int k=region[2].first;k<region[2].second;k++) {
706     assert(sourceView()==
707     targetView(i,j,k));
708     }
709     }
710     }
711     }
712    
713     {
714     cout << endl;
715     cout << "\tSlice a 4 dimensional slice to a 4 dimensional array.";
716    
717     // Define slice region.
718     DataArrayView::RegionType region;
719     region.push_back(DataArrayView::RegionType::value_type(2,4));
720     region.push_back(DataArrayView::RegionType::value_type(0,2));
721     region.push_back(DataArrayView::RegionType::value_type(5,9));
722     region.push_back(DataArrayView::RegionType::value_type(3,5));
723    
724     // Define shapes of views.
725     DataArrayView::ShapeType sourceShape;
726     sourceShape.push_back(6);
727     sourceShape.push_back(3);
728     sourceShape.push_back(13);
729     sourceShape.push_back(9);
730     DataArrayView::ShapeType targetShape = DataArrayView::getResultSliceShape(region);
731    
732     // Create source and target views.
733     DataArray source(sourceShape);
734     DataArrayView sourceView=source.getView();
735     int val=0;
736     for (int i=0;i<sourceShape[0];i++) {
737     for (int j=0;j<sourceShape[1];j++) {
738     for (int k=0;k<sourceShape[2];k++) {
739     for (int l=0;l<sourceShape[3];l++) {
740     sourceView(i,j,k,l)=val++;
741     }
742     }
743     }
744     }
745    
746     DataArray target(targetShape);
747     DataArrayView targetView=target.getView();
748    
749     // Copy source view to target view.
750     targetView.copySlice(sourceView,region);
751    
752     // Check results of copy.
753     for (int i=region[0].first;i<region[0].second;i++) {
754     for (int j=region[1].first;j<region[1].second;j++) {
755     for (int k=region[2].first;k<region[2].second;k++) {
756     for (int l=region[3].first;l<region[3].second;l++) {
757     assert(sourceView(i,j,k,l)==
758     targetView(i-region[0].first,j-region[1].first,k-region[2].first,l-region[3].first));
759     }
760     }
761     }
762     }
763     }
764    
765     {
766     cout << endl;
767     cout << "\tSlice a 4 dimensional slice to a 3 dimensional array.";
768    
769     // Define slice region.
770     DataArrayView::RegionType region;
771     region.push_back(DataArrayView::RegionType::value_type(2,4));
772     region.push_back(DataArrayView::RegionType::value_type(0,2));
773     region.push_back(DataArrayView::RegionType::value_type(5,6));
774     region.push_back(DataArrayView::RegionType::value_type(3,5));
775    
776     // Define shapes of views.
777     DataArrayView::ShapeType sourceShape;
778     sourceShape.push_back(6);
779     sourceShape.push_back(3);
780     sourceShape.push_back(13);
781     sourceShape.push_back(9);
782     DataArrayView::ShapeType targetShape;
783     targetShape.push_back(2);
784     targetShape.push_back(2);
785     targetShape.push_back(2);
786    
787     // Create source and target views.
788     DataArray source(sourceShape);
789     DataArrayView sourceView=source.getView();
790     int val=0;
791     for (int i=0;i<sourceShape[0];i++) {
792     for (int j=0;j<sourceShape[1];j++) {
793     for (int k=0;k<sourceShape[2];k++) {
794     for (int l=0;l<sourceShape[3];l++) {
795     sourceView(i,j,k,l)=val++;
796     }
797     }
798     }
799     }
800    
801     DataArray target(targetShape);
802     DataArrayView targetView=target.getView();
803    
804     // Copy source view to target view.
805     targetView.copySlice(sourceView,region);
806    
807     // Check results of copy.
808     for (int i=region[0].first;i<region[0].second;i++) {
809     for (int j=region[1].first;j<region[1].second;j++) {
810     for (int k=region[2].first;k<region[2].second;k++) {
811     for (int l=region[3].first;l<region[3].second;l++) {
812     assert(sourceView(i,j,k,l)==
813     targetView(i-region[0].first,j-region[1].first,l-region[3].first));
814     }
815     }
816     }
817     }
818     }
819    
820     {
821     cout << endl;
822     cout << "\tSlice a 4 dimensional slice to a 2 dimensional array.";
823    
824     // Define slice region.
825     DataArrayView::RegionType region;
826     region.push_back(DataArrayView::RegionType::value_type(2,4));
827     region.push_back(DataArrayView::RegionType::value_type(0,2));
828     region.push_back(DataArrayView::RegionType::value_type(5,6));
829     region.push_back(DataArrayView::RegionType::value_type(4,5));
830    
831     // Define shapes of views.
832     DataArrayView::ShapeType sourceShape;
833     sourceShape.push_back(6);
834     sourceShape.push_back(3);
835     sourceShape.push_back(13);
836     sourceShape.push_back(9);
837     DataArrayView::ShapeType targetShape;
838     targetShape.push_back(2);
839     targetShape.push_back(2);
840    
841     // Create source and target views.
842     DataArray source(sourceShape);
843     DataArrayView sourceView=source.getView();
844     int val=0;
845     for (int i=0;i<sourceShape[0];i++) {
846     for (int j=0;j<sourceShape[1];j++) {
847     for (int k=0;k<sourceShape[2];k++) {
848     for (int l=0;l<sourceShape[3];l++) {
849     sourceView(i,j,k,l)=val++;
850     }
851     }
852     }
853     }
854    
855     DataArray target(targetShape);
856     DataArrayView targetView=target.getView();
857    
858     // Copy source view to target view.
859     targetView.copySlice(sourceView,region);
860    
861     // Check results of copy.
862     for (int i=region[0].first;i<region[0].second;i++) {
863     for (int j=region[1].first;j<region[1].second;j++) {
864     for (int k=region[2].first;k<region[2].second;k++) {
865     for (int l=region[3].first;l<region[3].second;l++) {
866     assert(sourceView(i,j,k,l)==
867     targetView(i-region[0].first,j-region[1].first));
868     }
869     }
870     }
871     }
872     }
873    
874     {
875     cout << endl;
876     cout << "\tSlice a 4 dimensional slice to a 1 dimensional array.";
877    
878     // Define slice region.
879     DataArrayView::RegionType region;
880     region.push_back(DataArrayView::RegionType::value_type(3,4));
881     region.push_back(DataArrayView::RegionType::value_type(0,2));
882     region.push_back(DataArrayView::RegionType::value_type(5,6));
883     region.push_back(DataArrayView::RegionType::value_type(4,5));
884    
885     // Define shapes of views.
886     DataArrayView::ShapeType sourceShape;
887     sourceShape.push_back(6);
888     sourceShape.push_back(3);
889     sourceShape.push_back(13);
890     sourceShape.push_back(9);
891     DataArrayView::ShapeType targetShape;
892     targetShape.push_back(2);
893    
894     // Create source and target views.
895     DataArray source(sourceShape);
896     DataArrayView sourceView=source.getView();
897     int val=0;
898     for (int i=0;i<sourceShape[0];i++) {
899     for (int j=0;j<sourceShape[1];j++) {
900     for (int k=0;k<sourceShape[2];k++) {
901     for (int l=0;l<sourceShape[3];l++) {
902     sourceView(i,j,k,l)=val++;
903     }
904     }
905     }
906     }
907    
908     DataArray target(targetShape);
909     DataArrayView targetView=target.getView();
910    
911     // Copy source view to target view.
912     targetView.copySlice(sourceView,region);
913    
914     // Check results of copy.
915     for (int i=region[0].first;i<region[0].second;i++) {
916     for (int j=region[1].first;j<region[1].second;j++) {
917     for (int k=region[2].first;k<region[2].second;k++) {
918     for (int l=region[3].first;l<region[3].second;l++) {
919     assert(sourceView(i,j,k,l)==
920     targetView(j-region[1].first));
921     }
922     }
923     }
924     }
925     }
926    
927     {
928     cout << endl;
929     cout << "\tSlice a 4 dimensional slice to a scalar.";
930    
931     // Define slice region.
932     DataArrayView::RegionType region;
933     region.push_back(DataArrayView::RegionType::value_type(3,4));
934     region.push_back(DataArrayView::RegionType::value_type(1,2));
935     region.push_back(DataArrayView::RegionType::value_type(5,6));
936     region.push_back(DataArrayView::RegionType::value_type(4,5));
937    
938     // Define shapes of views.
939     DataArrayView::ShapeType sourceShape;
940     sourceShape.push_back(6);
941     sourceShape.push_back(3);
942     sourceShape.push_back(13);
943     sourceShape.push_back(9);
944     DataArrayView::ShapeType targetShape;
945    
946     // Create source and target views.
947     DataArray source(sourceShape);
948     DataArrayView sourceView=source.getView();
949     int val=0;
950     for (int i=0;i<sourceShape[0];i++) {
951     for (int j=0;j<sourceShape[1];j++) {
952     for (int k=0;k<sourceShape[2];k++) {
953     for (int l=0;l<sourceShape[3];l++) {
954     sourceView(i,j,k,l)=val++;
955     }
956     }
957     }
958     }
959    
960     DataArray target(targetShape);
961     DataArrayView targetView=target.getView();
962    
963     // Copy source view to target view.
964     targetView.copySlice(sourceView,region);
965    
966     // Check results of copy.
967     for (int i=region[0].first;i<region[0].second;i++) {
968     for (int j=region[1].first;j<region[1].second;j++) {
969     for (int k=region[2].first;k<region[2].second;k++) {
970     for (int l=region[3].first;l<region[3].second;l++) {
971     assert(sourceView(i,j,k,l)==
972     targetView());
973     }
974     }
975     }
976     }
977     }
978    
979     {
980     cout << endl;
981     cout << "\tSlice a 4 dimensional slice from a 4 dimensional array.";
982    
983     // Define slice region.
984     DataArrayView::RegionType region;
985     region.push_back(DataArrayView::RegionType::value_type(14,37));
986     region.push_back(DataArrayView::RegionType::value_type(22,57));
987     region.push_back(DataArrayView::RegionType::value_type(63,71));
988     region.push_back(DataArrayView::RegionType::value_type(23,51));
989    
990     // Define shapes of views.
991     DataArrayView::ShapeType sourceShape = DataArrayView::getResultSliceShape(region);
992     DataArrayView::ShapeType targetShape;
993     targetShape.push_back(50);
994     targetShape.push_back(65);
995     targetShape.push_back(80);
996     targetShape.push_back(90);
997    
998     // Create source and target views.
999     DataArray source(sourceShape);
1000     DataArrayView sourceView=source.getView();
1001     int val=0;
1002     for (int i=0;i<sourceShape[0];i++) {
1003     for (int j=0;j<sourceShape[1];j++) {
1004     for (int k=0;k<sourceShape[2];k++) {
1005     for (int l=0;l<sourceShape[3];l++) {
1006     sourceView(i,j,k,l)=val++;
1007     }
1008     }
1009     }
1010     }
1011    
1012     DataArray target(targetShape);
1013     DataArrayView targetView=target.getView();
1014    
1015     // Copy source view to target view.
1016     targetView.copySliceFrom(sourceView,region);
1017    
1018     // Check results of copy.
1019     for (int i=region[0].first;i<region[0].second;i++) {
1020     for (int j=region[1].first;j<region[1].second;j++) {
1021     for (int k=region[2].first;k<region[2].second;k++) {
1022     for (int l=region[3].first;l<region[3].second;l++) {
1023     assert(sourceView(i-region[0].first,j-region[1].first,k-region[2].first,l-region[3].first)==
1024     targetView(i,j,k,l));
1025     }
1026     }
1027     }
1028     }
1029     }
1030    
1031     {
1032     cout << endl;
1033     cout << "\tSlice a 4 dimensional slice from a scalar.";
1034    
1035     // Define slice region.
1036     DataArrayView::RegionType region;
1037     region.push_back(DataArrayView::RegionType::value_type(14,37));
1038     region.push_back(DataArrayView::RegionType::value_type(22,57));
1039     region.push_back(DataArrayView::RegionType::value_type(63,71));
1040     region.push_back(DataArrayView::RegionType::value_type(23,51));
1041    
1042     // Define shapes of views.
1043     DataArrayView::ShapeType sourceShape;
1044     DataArrayView::ShapeType targetShape;
1045     targetShape.push_back(50);
1046     targetShape.push_back(65);
1047     targetShape.push_back(80);
1048     targetShape.push_back(90);
1049    
1050     // Create source and target views.
1051     DataArray source(sourceShape);
1052     DataArrayView sourceView=source.getView();
1053     sourceView()=5;
1054    
1055     DataArray target(targetShape);
1056     DataArrayView targetView=target.getView();
1057    
1058     // Copy source view to target view.
1059     targetView.copySliceFrom(sourceView,region);
1060    
1061     // Check results of copy.
1062     for (int i=region[0].first;i<region[0].second;i++) {
1063     for (int j=region[1].first;j<region[1].second;j++) {
1064     for (int k=region[2].first;k<region[2].second;k++) {
1065     for (int l=region[3].first;l<region[3].second;l++) {
1066     assert(sourceView()==
1067     targetView(i,j,k,l));
1068     }
1069     }
1070     }
1071     }
1072     }
1073    
1074     cout << endl;
1075    
1076 jgs 82 }
1077    
1078     void DataArrayViewTestCase::testShapeToString() {
1079 jgs 108
1080 jgs 82 cout << endl;
1081 jgs 108 cout << "\tTest shapeToString for a variety of shapes." << endl;
1082    
1083 jgs 82 DataArrayView::ShapeType shape;
1084     assert(DataArrayView::shapeToString(shape)=="()");
1085     shape.push_back(5);
1086     assert(DataArrayView::shapeToString(shape)=="(5)");
1087     shape.push_back(2);
1088     assert(DataArrayView::shapeToString(shape)=="(5,2)");
1089 jgs 108 shape.push_back(9);
1090     assert(DataArrayView::shapeToString(shape)=="(5,2,9)");
1091     shape.push_back(4);
1092     assert(DataArrayView::shapeToString(shape)=="(5,2,9,4)");
1093    
1094 jgs 82 }
1095    
1096     void DataArrayViewTestCase::testScalarView() {
1097 jgs 108
1098     cout << endl;
1099     cout << "\tTest functionality of scalar views." << endl;
1100    
1101     // Create a vector containing enough data for three scalars
1102 jgs 82 // and check three scalar views return the appropriate data
1103     DataArrayView::ShapeType vShape;
1104 jgs 121 DataArrayView::ValueType vData(3);
1105     vData[0]=0;
1106     vData[1]=1;
1107     vData[2]=2;
1108 jgs 108
1109     // create the three scalar views
1110     DataArrayView zView(vData,vShape,0);
1111     DataArrayView oView(vData,vShape,1);
1112     DataArrayView tView(vData,vShape,2);
1113    
1114     // check attributes of the three scalar views
1115 jgs 82 assert(zView()==0);
1116     assert(oView()==1);
1117     assert(tView()==2);
1118 jgs 108 assert(zView.noValues()==1);
1119     assert(oView.noValues()==1);
1120 jgs 82 assert(tView.noValues()==1);
1121 jgs 108 assert(zView.getRank()==0);
1122 jgs 82 assert(oView.getRank()==0);
1123 jgs 108 assert(tView.getRank()==0);
1124    
1125 jgs 82 // copy the one view to the zero view
1126     zView.copy(oView);
1127     assert(zView==oView);
1128     zView.checkShape(oView.getShape());
1129 jgs 108
1130     // create a single vector view of all the data
1131     vShape.push_back(3);
1132     DataArrayView oneVView(vData,vShape,0);
1133    
1134     // test shape mismatch functions
1135 jgs 82 if (!zView.checkShape(oneVView.getShape())) {
1136     assert(true);
1137     } else {
1138     assert(false);
1139     }
1140 jgs 108
1141     // test some unary ops
1142 jgs 82 zView.unaryOp(negate<double>());
1143     assert(zView()==-1);
1144     zView.binaryOp(oView,plus<double>());
1145     assert(zView()==0);
1146 jgs 108
1147     // test operator !=
1148 jgs 82 assert(zView!=oView);
1149 jgs 108
1150 jgs 82 }
1151    
1152     void DataArrayViewTestCase::testAll()
1153     {
1154    
1155     {
1156     cout << endl;
1157 jgs 108 cout << "\tTest empty DataArrayView.";
1158 jgs 82
1159 jgs 108 // default constructor
1160 jgs 82 DataArrayView defView;
1161    
1162 jgs 108 // check all attributes
1163     assert(defView.isEmpty());
1164 jgs 82 assert(defView.getOffset()==0);
1165 jgs 108 assert(defView.getRank()==0);
1166     assert(defView.noValues()==0);
1167 jgs 82 assert(defView.getShape().empty());
1168 jgs 108 assert(defView.checkShape(DataArrayView::ShapeType()));
1169 jgs 82 }
1170    
1171     {
1172     cout << endl;
1173 jgs 108 cout << "\tTest DataArrayView - shape (5).";
1174 jgs 82
1175 jgs 108 // define the shape for the DataArrayView
1176 jgs 82 DataArrayView::ShapeType shape;
1177     shape.push_back(5);
1178    
1179 jgs 108 // allocate the data for the DataArrayView
1180     DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
1181 jgs 82
1182 jgs 108 // constructor
1183     int offset=0;
1184 jgs 82 DataArrayView dataView(data,shape,offset);
1185    
1186 jgs 108 // check all attributes
1187     assert(!dataView.isEmpty());
1188     assert(dataView.getOffset()==0);
1189     assert(dataView.getRank()==1);
1190     assert(dataView.noValues()==5);
1191 jgs 82 assert(dataView.getShape()==shape);
1192 jgs 108 assert(dataView.checkShape(shape));
1193 jgs 82
1194 jgs 108 // assign values to the data
1195     for (int i=0;i<shape[0];i++) {
1196 jgs 82 dataView(i)=dataView.index(i);
1197 jgs 108 assert(dataView(i)==i);
1198 jgs 82 }
1199    
1200     }
1201    
1202     {
1203     cout << endl;
1204 jgs 108 cout << "\tTest DataArrayView - shape (2,3).";
1205 jgs 82
1206 jgs 108 // define the shape for the DataArrayView
1207 jgs 82 DataArrayView::ShapeType shape;
1208     shape.push_back(2);
1209     shape.push_back(3);
1210    
1211 jgs 108 // allocate the data for the DataArrayView
1212     int npoints=4;
1213     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
1214 jgs 82
1215 jgs 108 // constructor
1216 jgs 82 DataArrayView dataView(data,shape);
1217    
1218 jgs 108 // check all attributes
1219     assert(!dataView.isEmpty());
1220     assert(dataView.getOffset()==0);
1221     assert(dataView.getRank()==2);
1222     assert(dataView.noValues()==6);
1223 jgs 82 assert(dataView.getShape()==shape);
1224 jgs 108 assert(dataView.checkShape(shape));
1225 jgs 82
1226 jgs 108 // step the view along each block of this shape in the underlying data
1227     for (int p=0;p<npoints;p++) {
1228    
1229     assert(dataView.getOffset()==p*dataView.noValues());
1230    
1231     // assign values to the data
1232     for (int i=0;i<shape[0];i++) {
1233     for (int j=0;j<shape[1];j++) {
1234     dataView(i,j)=dataView.index(i,j);
1235     assert(dataView(i,j)==dataView.index(i,j));
1236     }
1237 jgs 82 }
1238 jgs 108
1239     if (p<npoints-1) {
1240     dataView.incrOffset();
1241     }
1242    
1243 jgs 82 }
1244    
1245     }
1246    
1247     {
1248     cout << endl;
1249 jgs 108 cout << "\tTest DataArrayView - shape (4,7,9).";
1250 jgs 82
1251 jgs 108 // define the shape for the DataArrayView
1252 jgs 82 DataArrayView::ShapeType shape;
1253     shape.push_back(4);
1254 jgs 108 shape.push_back(7);
1255     shape.push_back(9);
1256 jgs 82
1257 jgs 108 // allocate the data for the DataArrayView
1258     int npoints=10;
1259     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
1260 jgs 82
1261 jgs 108 // constructor
1262 jgs 82 DataArrayView dataView(data,shape);
1263    
1264 jgs 108 // check all attributes
1265     assert(!dataView.isEmpty());
1266     assert(dataView.getOffset()==0);
1267     assert(dataView.getRank()==3);
1268     assert(dataView.noValues()==252);
1269 jgs 82 assert(dataView.getShape()==shape);
1270 jgs 108 assert(dataView.checkShape(shape));
1271 jgs 82
1272 jgs 108 // step the view along each block of this shape in the underlying data
1273     for (int p=0;p<npoints;p++) {
1274    
1275     assert(dataView.getOffset()==p*dataView.noValues());
1276    
1277     // assign values to the data
1278     for (int i=0;i<shape[0];i++) {
1279     for (int j=0;j<shape[1];j++) {
1280     for (int k=0;k<shape[2];k++) {
1281     dataView(i,j,k)=dataView.index(i,j,k);
1282     assert(dataView(i,j,k)==dataView.index(i,j,k));
1283     }
1284     }
1285 jgs 82 }
1286 jgs 108
1287     if (p<npoints-1) {
1288     dataView.incrOffset();
1289     }
1290    
1291 jgs 82 }
1292    
1293     }
1294    
1295     {
1296     cout << endl;
1297 jgs 108 cout << "\tTest DataArrayView - shape (12,4,5,14).";
1298 jgs 82
1299 jgs 108 // define the shape for the DataArrayView
1300     DataArrayView::ShapeType shape;
1301     shape.push_back(12);
1302     shape.push_back(4);
1303     shape.push_back(5);
1304     shape.push_back(14);
1305 jgs 82
1306 jgs 108 // allocate the data for the DataArrayView
1307     int npoints=100;
1308     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
1309    
1310     // constructor
1311     DataArrayView dataView(data,shape);
1312    
1313     // check all attributes
1314     assert(!dataView.isEmpty());
1315     assert(dataView.getOffset()==0);
1316     assert(dataView.getRank()==4);
1317     assert(dataView.noValues()==3360);
1318     assert(dataView.getShape()==shape);
1319     assert(dataView.checkShape(shape));
1320    
1321     // step the view along each block of this shape in the underlying data
1322     for (int p=0;p<npoints;p++) {
1323    
1324     assert(dataView.getOffset()==p*dataView.noValues());
1325    
1326     // assign values to the data
1327     for (int i=0;i<shape[0];i++) {
1328     for (int j=0;j<shape[1];j++) {
1329     for (int k=0;k<shape[2];k++) {
1330     for (int l=0;l<shape[3];l++) {
1331     dataView(i,j,k,l)=dataView.index(i,j,k,l);
1332     assert(dataView(i,j,k,l)==dataView.index(i,j,k,l));
1333     }
1334     }
1335     }
1336     }
1337    
1338     if (p<npoints-1) {
1339     dataView.incrOffset();
1340     }
1341    
1342     }
1343    
1344     }
1345    
1346     {
1347     cout << endl;
1348     cout << "\tTest DataArrayView copy constructor - shape (5).";
1349    
1350     // define the shape for the DataArrayView
1351 jgs 82 DataArrayView::ShapeType shape;
1352 jgs 108 shape.push_back(5);
1353    
1354     // allocate the data for the DataArrayView
1355 jgs 82 DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
1356 jgs 108
1357     // constructor
1358 jgs 82 DataArrayView dataView(data,shape);
1359    
1360 jgs 108 // copy constructor
1361     DataArrayView dataViewCopy(dataView);
1362    
1363     // check all attributes
1364     assert(!dataViewCopy.isEmpty());
1365     assert(dataViewCopy.getOffset()==0);
1366     assert(dataViewCopy.getRank()==1);
1367     assert(dataViewCopy.noValues()==5);
1368     assert(dataViewCopy.getShape()==shape);
1369     assert(dataViewCopy.checkShape(shape));
1370    
1371     // check data
1372     assert(dataView.getData()==dataViewCopy.getData());
1373     for (int i=0;i<dataView.getData().size();i++) {
1374     assert(dataView.getData(i)==dataViewCopy.getData(i));
1375     }
1376    
1377     }
1378    
1379     {
1380     cout << endl;
1381     cout << "\tTest DataArrayView copy constructor - shape (5,6,7).";
1382    
1383     // define the shape for the DataArrayView
1384     DataArrayView::ShapeType shape;
1385     shape.push_back(5);
1386     shape.push_back(6);
1387     shape.push_back(7);
1388    
1389     // allocate the data for the DataArrayView
1390     DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
1391    
1392     // constructor
1393     DataArrayView dataView(data,shape);
1394    
1395     // copy constructor
1396     DataArrayView dataViewCopy(dataView);
1397    
1398     // check all attributes
1399     assert(!dataViewCopy.isEmpty());
1400     assert(dataViewCopy.getOffset()==0);
1401     assert(dataViewCopy.getRank()==3);
1402     assert(dataViewCopy.noValues()==210);
1403     assert(dataViewCopy.getShape()==shape);
1404     assert(dataViewCopy.checkShape(shape));
1405    
1406     // check data
1407     assert(dataView.getData()==dataViewCopy.getData());
1408     for (int i=0;i<dataView.getData().size();i++) {
1409     assert(dataView.getData(i)==dataViewCopy.getData(i));
1410     }
1411    
1412     }
1413    
1414     {
1415     cout << endl;
1416     cout << "\tTest DataArrayView copy method - shape (2,3).";
1417    
1418     // define the shape for the DataArrayViews
1419     DataArrayView::ShapeType shape;
1420     shape.push_back(2);
1421     shape.push_back(3);
1422    
1423     // allocate the data for the DataArrayViews
1424     int npoints=4;
1425     DataArrayView::ValueType data1(DataArrayView::noValues(shape)*npoints,0);
1426     DataArrayView::ValueType data2(DataArrayView::noValues(shape)*npoints,0);
1427    
1428     // construct two views
1429     DataArrayView dataView1(data1,shape);
1430     DataArrayView dataView2(data2,shape);
1431    
1432     // step the views along each block of this shape in the underlying data arrays
1433     for (int p=0;p<npoints;p++) {
1434    
1435     // assign values to the data underlying the first view
1436     for (int i=0;i<shape[0];i++) {
1437     for (int j=0;j<shape[1];j++) {
1438     dataView1(i,j)=dataView1.index(i,j);
1439     }
1440     }
1441    
1442     // copy data from the first view to the second
1443     dataView2.copy(dataView1);
1444    
1445     // check the data underlying the second view
1446     for (int i=0;i<shape[0];i++) {
1447     for (int j=0;j<shape[1];j++) {
1448     assert(dataView2(i,j)==dataView1.index(i,j));
1449     }
1450     }
1451    
1452     if (p<npoints-1) {
1453     dataView1.incrOffset();
1454     dataView2.incrOffset();
1455     }
1456    
1457     }
1458    
1459     }
1460    
1461     {
1462     cout << endl;
1463     cout << "\tTest DataArrayView copy method - shape (2,3,8,9).";
1464    
1465     // define the shape for the DataArrayViews
1466     DataArrayView::ShapeType shape;
1467     shape.push_back(2);
1468     shape.push_back(3);
1469     shape.push_back(8);
1470     shape.push_back(9);
1471    
1472     // allocate the data for the DataArrayViews
1473     int npoints=10;
1474     DataArrayView::ValueType data1(DataArrayView::noValues(shape)*npoints,0);
1475     DataArrayView::ValueType data2(DataArrayView::noValues(shape)*npoints,0);
1476    
1477     // construct two views
1478     DataArrayView dataView1(data1,shape);
1479     DataArrayView dataView2(data2,shape);
1480    
1481     // step the views along each block of this shape in the underlying data arrays
1482     for (int p=0;p<npoints;p++) {
1483    
1484     // assign values to the data underlying the first view
1485     for (int i=0;i<shape[0];i++) {
1486     for (int j=0;j<shape[1];j++) {
1487     for (int k=0;k<shape[2];k++) {
1488     for (int l=0;l<shape[3];l++) {
1489     dataView1(i,j,k,l)=dataView1.index(i,j,k,l);
1490     }
1491     }
1492     }
1493     }
1494    
1495     // copy data from the first view to the second
1496     dataView2.copy(dataView1);
1497    
1498     // check the data underlying the second view
1499     for (int i=0;i<shape[0];i++) {
1500     for (int j=0;j<shape[1];j++) {
1501     for (int k=0;k<shape[2];k++) {
1502     for (int l=0;l<shape[3];l++) {
1503     assert(dataView2(i,j,k,l)==dataView1.index(i,j,k,l));
1504     }
1505     }
1506     }
1507     }
1508    
1509     if (p<npoints-1) {
1510     dataView1.incrOffset();
1511     dataView2.incrOffset();
1512     }
1513    
1514     }
1515    
1516     }
1517    
1518     {
1519     cout << endl;
1520     cout << "\tTest DataArrayView copy with offset method - shape (2,3).";
1521    
1522     // define the shape for the DataArrayViews
1523     DataArrayView::ShapeType shape;
1524     shape.push_back(2);
1525     shape.push_back(3);
1526    
1527     // allocate the data for the DataArrayViews
1528     int npoints=4;
1529     DataArrayView::ValueType data1(DataArrayView::noValues(shape)*npoints,0);
1530     DataArrayView::ValueType data2(DataArrayView::noValues(shape)*npoints,0);
1531    
1532     // construct two views
1533     DataArrayView dataView1(data1,shape);
1534     DataArrayView dataView2(data2,shape);
1535    
1536     // assign values to the data underlying the first view
1537     for (int i=0;i<shape[0];i++) {
1538     for (int j=0;j<shape[1];j++) {
1539     dataView1(i,j)=dataView1.index(i,j);
1540     }
1541     }
1542    
1543     // copy data from the first view to the second at an offset
1544     dataView2.copy(12,dataView1,0);
1545    
1546     // check the data underlying the second view
1547     dataView2.setOffset(12);
1548     for (int i=0;i<shape[0];i++) {
1549     for (int j=0;j<shape[1];j++) {
1550     assert(dataView2(i,j)==dataView1.index(i,j));
1551     }
1552     }
1553    
1554     }
1555    
1556     {
1557     cout << endl;
1558     cout << "\tTest DataArrayView copy with value method - shape (5,8).";
1559    
1560     // define the shape for the DataArrayView
1561     DataArrayView::ShapeType shape;
1562     shape.push_back(5);
1563     shape.push_back(8);
1564    
1565     // allocate the data for the DataArrayView
1566     int npoints=4;
1567     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
1568    
1569     // construct view
1570     DataArrayView dataView(data,shape);
1571    
1572     // copy a value to the view at an offset
1573     dataView.copy(80,5);
1574    
1575     // check the data underlying the second view
1576     dataView.setOffset(80);
1577     for (int i=0;i<shape[0];i++) {
1578     for (int j=0;j<shape[1];j++) {
1579     assert(dataView(i,j)==5);
1580     }
1581     }
1582    
1583     }
1584    
1585     {
1586     cout << endl;
1587     cout << "\tTest too many indices for shape exception.";
1588    
1589     DataArrayView::ShapeType shape;
1590     DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
1591     DataArrayView dataView(data,shape);
1592    
1593 jgs 82 // Should be a scalar
1594     dataView()=1;
1595    
1596     try {
1597     dataView(1)=1;
1598     assert(false);
1599     }
1600     catch (EsysException& e) {
1601     assert(true);
1602     }
1603    
1604     try {
1605     dataView(1,1)=1;
1606     assert(false);
1607     }
1608     catch (EsysException& e) {
1609     assert(true);
1610     }
1611    
1612     try {
1613     dataView(1,1,1)=1;
1614     assert(false);
1615     }
1616     catch (EsysException& e) {
1617     assert(true);
1618     }
1619 jgs 108
1620     try {
1621     dataView(1,1,1,1)=1;
1622     assert(false);
1623     }
1624     catch (EsysException& e) {
1625     assert(true);
1626     }
1627    
1628 jgs 82 }
1629    
1630     {
1631     cout << endl;
1632 jgs 108 cout << "\tTest invalid index exception.";
1633 jgs 82
1634     DataArrayView::ShapeType shape;
1635     shape.push_back(4);
1636     DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
1637     DataArrayView dataView(data,shape);
1638    
1639     try {
1640     dataView(4000)=1;
1641     assert(false);
1642     }
1643     catch (EsysException& e) {
1644     assert(true);
1645     }
1646     }
1647    
1648     {
1649     cout << endl;
1650 jgs 108 cout << "\tTest insufficient data exception.";
1651 jgs 82
1652     DataArrayView::ShapeType shape;
1653     DataArrayView::ValueType data;
1654    
1655     try {
1656     DataArrayView dataView(data,shape);
1657     assert(false);
1658     }
1659     catch (EsysException& e) {
1660     assert(true);
1661     }
1662     }
1663    
1664 jgs 108 cout << endl;
1665    
1666     }
1667    
1668     void DataArrayViewTestCase::testMatMult()
1669     {
1670    
1671 jgs 82 {
1672     cout << endl;
1673 jgs 113 cout << "\tTest result shape." << endl;
1674 jgs 82
1675     DataArrayView::ShapeType leftShape;
1676     leftShape.push_back(1);
1677     leftShape.push_back(3);
1678     DataArrayView::ValueType leftData(DataArrayView::noValues(leftShape),0);
1679     DataArrayView leftDataView(leftData,leftShape);
1680    
1681     DataArrayView::ShapeType rightShape;
1682     rightShape.push_back(3);
1683     rightShape.push_back(2);
1684     DataArrayView::ValueType rightData(DataArrayView::noValues(rightShape),0);
1685     DataArrayView rightDataView(rightData,rightShape);
1686    
1687     DataArrayView::ShapeType resultShape=DataArrayView::determineResultShape(leftDataView,rightDataView);
1688    
1689 jgs 113 assert(resultShape.size()==2);
1690     assert(resultShape[0]==1);
1691     assert(resultShape[1]==2);
1692 jgs 82
1693     DataArrayView::ValueType resultData(DataArrayView::noValues(resultShape),0);
1694     DataArrayView resultDataView(resultData,resultShape);
1695    
1696 jgs 113 cout << "\tTest matrix multiplication.";
1697 jgs 82 double aValue=0.0;
1698 jgs 113 for (int i=0;i<leftShape[0];i++) {
1699     for (int j=0;j<leftShape[1];j++) {
1700 jgs 82 leftDataView(i,j)=++aValue;
1701     }
1702     }
1703     aValue=0.0;
1704 jgs 113 for (int i=0;i<rightShape[0];i++) {
1705     for (int j=0;j<rightShape[1];j++) {
1706 jgs 82 rightDataView(i,j)=++aValue;
1707     }
1708     }
1709    
1710     DataArrayView::matMult(leftDataView,rightDataView,resultDataView);
1711 jgs 113 }
1712 jgs 82
1713 jgs 108 cout << endl;
1714    
1715 jgs 82 }
1716    
1717 jgs 108 void DataArrayViewTestCase::testUnaryOp()
1718     {
1719    
1720     // This typedef allows function names to be cast to pointers
1721     // to unary functions of the appropriate type.
1722     typedef double (*UnaryDFunPtr)(double);
1723    
1724     {
1725     cout << endl;
1726     cout << "\tTest unaryOp on scalar DataArrayView.";
1727    
1728     // define the shape for the DataArrayView
1729     DataArrayView::ShapeType shape;
1730    
1731     // allocate the data for the DataArrayView
1732     int npoints=4;
1733     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
1734    
1735     // constructor
1736     DataArrayView dataView(data,shape);
1737    
1738 jgs 122 double tmp;
1739 jgs 108 // step the view along each data point in the underlying data
1740     for (int p=0;p<npoints;p++) {
1741    
1742     // assign values to the data point
1743     dataView()=p;
1744    
1745     // apply a unary operation to this data point
1746     dataView.unaryOp((UnaryDFunPtr)std::sin);
1747    
1748     // check the results
1749 jgs 122 tmp = std::sin((double)p);
1750     assert(dataView()==tmp);
1751 jgs 108
1752     if (p<npoints-1) {
1753     dataView.incrOffset();
1754     }
1755    
1756     }
1757    
1758     }
1759    
1760     {
1761     cout << endl;
1762     cout << "\tTest unaryOp on shape (2,3) DataArrayView.";
1763    
1764     // define the shape for the DataArrayView
1765     DataArrayView::ShapeType shape;
1766     shape.push_back(2);
1767     shape.push_back(3);
1768    
1769     // allocate the data for the DataArrayView
1770     int npoints=4;
1771     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
1772    
1773     // constructor
1774     DataArrayView dataView(data,shape);
1775    
1776     // step the view along each data point in the underlying data
1777     for (int p=0;p<npoints;p++) {
1778    
1779     // assign values to the data point
1780     for (int i=0;i<shape[0];i++) {
1781     for (int j=0;j<shape[1];j++) {
1782     dataView(i,j)=dataView.index(i,j);
1783     }
1784     }
1785    
1786     // apply a unary operation to this data point
1787     dataView.unaryOp((UnaryDFunPtr)std::sqrt);
1788    
1789     // check the results
1790     for (int i=0;i<shape[0];i++) {
1791     for (int j=0;j<shape[1];j++) {
1792     assert(dataView(i,j)==std::sqrt((double)dataView.index(i,j)));
1793     }
1794     }
1795    
1796     if (p<npoints-1) {
1797     dataView.incrOffset();
1798     }
1799    
1800     }
1801    
1802     }
1803    
1804     {
1805     cout << endl;
1806     cout << "\tTest unaryOp on shape (9,8,5,11) DataArrayView.";
1807    
1808     // define the shape for the DataArrayView
1809     DataArrayView::ShapeType shape;
1810     shape.push_back(9);
1811     shape.push_back(8);
1812     shape.push_back(5);
1813     shape.push_back(11);
1814    
1815     // allocate the data for the DataArrayView
1816     int npoints=4;
1817     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
1818    
1819     // constructor
1820     DataArrayView dataView(data,shape);
1821    
1822     // step the view along each data point in the underlying data
1823     for (int p=0;p<npoints;p++) {
1824    
1825     // assign values to the data point
1826     for (int i=0;i<shape[0];i++) {
1827     for (int j=0;j<shape[1];j++) {
1828     for (int k=0;k<shape[2];k++) {
1829     for (int l=0;l<shape[3];l++) {
1830     dataView(i,j,k,l)=dataView.index(i,j,k,l);
1831     }
1832     }
1833     }
1834     }
1835    
1836     // apply a unary operation to this data point
1837     dataView.unaryOp((UnaryDFunPtr)std::log);
1838    
1839     // check the results
1840     for (int i=0;i<shape[0];i++) {
1841     for (int j=0;j<shape[1];j++) {
1842     for (int k=0;k<shape[2];k++) {
1843     for (int l=0;l<shape[3];l++) {
1844     assert(dataView(i,j,k,l)==std::log((double)dataView.index(i,j,k,l)));
1845     }
1846     }
1847     }
1848     }
1849    
1850     if (p<npoints-1) {
1851     dataView.incrOffset();
1852     }
1853    
1854     }
1855    
1856     }
1857    
1858     cout << endl;
1859    
1860     }
1861    
1862     void DataArrayViewTestCase::testBinaryOp()
1863     {
1864    
1865     // This typedef allows function names to be cast to pointers
1866     // to binary functions of the appropriate type.
1867     typedef double (*BinaryDFunPtr)(double,double);
1868    
1869     {
1870     cout << endl;
1871 jgs 113 cout << "\tTest binaryOp on scalar DataArrayViews.";
1872 jgs 108
1873     // define the shape for the DataArrayViews
1874     DataArrayView::ShapeType shape;
1875    
1876     // allocate the data for the DataArrayViews
1877     int npoints=4;
1878     DataArrayView::ValueType data1(DataArrayView::noValues(shape)*npoints,0);
1879     DataArrayView::ValueType data2(DataArrayView::noValues(shape)*npoints,0);
1880    
1881     // constructor
1882     DataArrayView dataView1(data1,shape);
1883     DataArrayView dataView2(data2,shape);
1884    
1885     // step the views along each data point in the underlying data
1886     for (int p=0;p<npoints;p++) {
1887    
1888     // assign values to the data points
1889     dataView1()=p;
1890     dataView2()=p;
1891    
1892     // apply a binary operation to these data points
1893     dataView1.binaryOp(dataView2,plus<double>());
1894    
1895     // check the results
1896     assert(dataView1()==p+p);
1897    
1898     if (p<npoints-1) {
1899     dataView1.incrOffset();
1900     dataView2.incrOffset();
1901     }
1902    
1903     }
1904    
1905     }
1906    
1907     {
1908     cout << endl;
1909 jgs 113 cout << "\tTest binaryOp on shape (2,3) DataArrayViews.";
1910 jgs 108
1911     // define the shape for the DataArrayViews
1912     DataArrayView::ShapeType shape;
1913     shape.push_back(2);
1914     shape.push_back(3);
1915    
1916     // allocate the data for the DataArrayViews
1917     int npoints=4;
1918     DataArrayView::ValueType data1(DataArrayView::noValues(shape)*npoints,0);
1919     DataArrayView::ValueType data2(DataArrayView::noValues(shape)*npoints,0);
1920    
1921     // constructor
1922     DataArrayView dataView1(data1,shape);
1923     DataArrayView dataView2(data2,shape);
1924    
1925     // step the views along each data point in the underlying data
1926     for (int p=0;p<npoints;p++) {
1927    
1928     // assign values to the data points
1929     for (int i=0;i<shape[0];i++) {
1930     for (int j=0;j<shape[1];j++) {
1931     dataView1(i,j)=dataView1.index(i,j);
1932     dataView2(i,j)=dataView2.index(i,j);
1933     }
1934     }
1935    
1936     // apply a binary operation to these data points
1937     dataView1.binaryOp(dataView2,multiplies<double>());
1938    
1939     // check the results
1940     for (int i=0;i<shape[0];i++) {
1941     for (int j=0;j<shape[1];j++) {
1942     assert(dataView1(i,j)==dataView1.index(i,j)*dataView2.index(i,j));
1943     }
1944     }
1945    
1946     if (p<npoints-1) {
1947     dataView1.incrOffset();
1948     dataView2.incrOffset();
1949     }
1950    
1951     }
1952    
1953     }
1954    
1955     {
1956     cout << endl;
1957     cout << "\tTest binaryOp on shape (9,8,5,11) DataArrayViews.";
1958    
1959     // define the shape for the DataArrayViews
1960     DataArrayView::ShapeType shape;
1961     shape.push_back(9);
1962     shape.push_back(8);
1963     shape.push_back(5);
1964     shape.push_back(11);
1965    
1966     // allocate the data for the DataArrayViews
1967     int npoints=4;
1968     DataArrayView::ValueType data1(DataArrayView::noValues(shape)*npoints,0);
1969     DataArrayView::ValueType data2(DataArrayView::noValues(shape)*npoints,0);
1970    
1971     // constructor
1972     DataArrayView dataView1(data1,shape);
1973     DataArrayView dataView2(data2,shape);
1974    
1975     // step the views along each data point in the underlying data
1976     for (int p=0;p<npoints;p++) {
1977    
1978     // assign values to the data points
1979     for (int i=0;i<shape[0];i++) {
1980     for (int j=0;j<shape[1];j++) {
1981     for (int k=0;k<shape[2];k++) {
1982     for (int l=0;l<shape[3];l++) {
1983     dataView1(i,j,k,l)=dataView1.index(i,j,k,l);
1984     dataView2(i,j,k,l)=dataView2.index(i,j,k,l);
1985     }
1986     }
1987     }
1988     }
1989    
1990     // apply a binary operation to these data points
1991     dataView1.binaryOp(dataView2,multiplies<double>());
1992    
1993     // check the results
1994     for (int i=0;i<shape[0];i++) {
1995     for (int j=0;j<shape[1];j++) {
1996     for (int k=0;k<shape[2];k++) {
1997     for (int l=0;l<shape[3];l++) {
1998     assert(dataView1(i,j,k,l)==dataView1.index(i,j,k,l)*dataView2.index(i,j,k,l));
1999     }
2000     }
2001     }
2002     }
2003    
2004     if (p<npoints-1) {
2005     dataView1.incrOffset();
2006     dataView2.incrOffset();
2007     }
2008    
2009     }
2010    
2011     }
2012    
2013     {
2014     cout << endl;
2015 jgs 113 cout << "\tTest binaryOp on scalar DataArrayView and single value.";
2016 jgs 108
2017     // define the shape for the DataArrayView
2018     DataArrayView::ShapeType shape;
2019    
2020     // allocate the data for the DataArrayView
2021     int npoints=4;
2022     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
2023    
2024     // constructor
2025     DataArrayView dataView(data,shape);
2026    
2027     // step the view along each data point in the underlying data
2028     for (int p=0;p<npoints;p++) {
2029    
2030     // assign values to the data point
2031     dataView()=p;
2032    
2033     // apply a binary operation to this data point
2034     dataView.binaryOp(4.9,plus<double>());
2035    
2036     // check the results
2037     assert(dataView()==4.9+p);
2038    
2039     if (p<npoints-1) {
2040     dataView.incrOffset();
2041     }
2042    
2043     }
2044    
2045     }
2046    
2047     {
2048     cout << endl;
2049 jgs 113 cout << "\tTest binaryOp on shape (2,3) DataArrayView and single value.";
2050 jgs 108
2051     // define the shape for the DataArrayView
2052     DataArrayView::ShapeType shape;
2053     shape.push_back(2);
2054     shape.push_back(3);
2055    
2056     // allocate the data for the DataArrayView
2057     int npoints=4;
2058     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
2059    
2060     // constructor
2061     DataArrayView dataView(data,shape);
2062    
2063     // step the view along each data point in the underlying data
2064     for (int p=0;p<npoints;p++) {
2065    
2066     // assign values to the data point
2067     for (int i=0;i<shape[0];i++) {
2068     for (int j=0;j<shape[1];j++) {
2069     dataView(i,j)=dataView.index(i,j);
2070     }
2071     }
2072    
2073     // apply a binary operation to the data point
2074     dataView.binaryOp(5.8,multiplies<double>());
2075    
2076 jgs 122 double tmp;
2077 jgs 108 // check the results
2078     for (int i=0;i<shape[0];i++) {
2079     for (int j=0;j<shape[1];j++) {
2080 jgs 122 tmp=5.8*dataView.index(i,j);
2081     assert(dataView(i,j)==tmp);
2082 jgs 108 }
2083     }
2084    
2085     if (p<npoints-1) {
2086     dataView.incrOffset();
2087     }
2088    
2089     }
2090    
2091     }
2092    
2093     {
2094     cout << endl;
2095     cout << "\tTest binaryOp on shape (9,8,5,11) DataArrayView and single value.";
2096    
2097     // define the shape for the DataArrayView
2098     DataArrayView::ShapeType shape;
2099     shape.push_back(9);
2100     shape.push_back(8);
2101     shape.push_back(5);
2102     shape.push_back(11);
2103    
2104     // allocate the data for the DataArrayView
2105     int npoints=4;
2106     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
2107    
2108     // constructor
2109     DataArrayView dataView(data,shape);
2110    
2111     // step the view along each data point in the underlying data
2112     for (int p=0;p<npoints;p++) {
2113    
2114     // assign values to the data point
2115     for (int i=0;i<shape[0];i++) {
2116     for (int j=0;j<shape[1];j++) {
2117     for (int k=0;k<shape[2];k++) {
2118     for (int l=0;l<shape[3];l++) {
2119     dataView(i,j,k,l)=dataView.index(i,j,k,l);
2120     }
2121     }
2122     }
2123     }
2124    
2125     // apply a binary operation to the data point
2126     dataView.binaryOp(5.4,multiplies<double>());
2127    
2128 jgs 122 double tmp;
2129 jgs 108 // check the results
2130     for (int i=0;i<shape[0];i++) {
2131     for (int j=0;j<shape[1];j++) {
2132     for (int k=0;k<shape[2];k++) {
2133     for (int l=0;l<shape[3];l++) {
2134 jgs 122 tmp=5.4*dataView.index(i,j,k,l);
2135     assert(dataView(i,j,k,l)==tmp);
2136 jgs 108 }
2137     }
2138     }
2139     }
2140    
2141     if (p<npoints-1) {
2142     dataView.incrOffset();
2143     }
2144    
2145     }
2146    
2147     }
2148    
2149     cout << endl;
2150    
2151     }
2152    
2153 jgs 113 void DataArrayViewTestCase::testReductionOp()
2154     {
2155    
2156     {
2157     cout << endl;
2158     cout << "\tTest reductionOp on scalar DataArrayView.";
2159    
2160     // define the shape for the DataArrayView
2161     DataArrayView::ShapeType shape;
2162    
2163     // allocate the data for the DataArrayView
2164     int npoints=4;
2165     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
2166    
2167     // constructor
2168     DataArrayView dataView(data,shape);
2169    
2170     // step the view along each data point in the underlying data
2171     for (int p=0;p<npoints;p++) {
2172    
2173     // assign values to the data point
2174     dataView()=p;
2175    
2176     // apply a reduction operation to this data point and check the results
2177 jgs 147 FMax fmax_func;
2178     assert(dataView.reductionOp(fmax_func,numeric_limits<double>::max()*-1)==p);
2179 jgs 113
2180     if (p<npoints-1) {
2181     dataView.incrOffset();
2182     }
2183    
2184     }
2185    
2186     }
2187    
2188     {
2189     cout << endl;
2190     cout << "\tTest reductionOp on shape (2,3) DataArrayView.";
2191    
2192     // define the shape for the DataArrayView
2193     DataArrayView::ShapeType shape;
2194     shape.push_back(2);
2195     shape.push_back(3);
2196    
2197     // allocate the data for the DataArrayView
2198     int npoints=4;
2199     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
2200    
2201     // constructor
2202     DataArrayView dataView(data,shape);
2203    
2204     // step the view along each data point in the underlying data
2205     for (int p=0;p<npoints;p++) {
2206    
2207     // assign values to the data point
2208     for (int i=0;i<shape[0];i++) {
2209     for (int j=0;j<shape[1];j++) {
2210     dataView(i,j)=dataView.index(i,j);
2211     }
2212     }
2213    
2214     // apply a reduction operation to this data point and check the results
2215 jgs 147 FMin fmin_func;
2216     assert(dataView.reductionOp(fmin_func,numeric_limits<double>::max())==dataView.index(0,0));
2217 jgs 113
2218     if (p<npoints-1) {
2219     dataView.incrOffset();
2220     }
2221    
2222     }
2223    
2224     }
2225    
2226     {
2227     cout << endl;
2228     cout << "\tTest reductionOp on shape (9,8,5,11) DataArrayView.";
2229    
2230     // define the shape for the DataArrayView
2231     DataArrayView::ShapeType shape;
2232     shape.push_back(9);
2233     shape.push_back(8);
2234     shape.push_back(5);
2235     shape.push_back(11);
2236    
2237     // allocate the data for the DataArrayView
2238     int npoints=4;
2239     DataArrayView::ValueType data(DataArrayView::noValues(shape)*npoints,0);
2240    
2241     // constructor
2242     DataArrayView dataView(data,shape);
2243    
2244     // step the view along each data point in the underlying data
2245     for (int p=0;p<npoints;p++) {
2246    
2247     // assign values to the data point
2248     for (int i=0;i<shape[0];i++) {
2249     for (int j=0;j<shape[1];j++) {
2250     for (int k=0;k<shape[2];k++) {
2251     for (int l=0;l<shape[3];l++) {
2252     dataView(i,j,k,l)=dataView.index(i,j,k,l);
2253     }
2254     }
2255     }
2256     }
2257    
2258     // apply a reduction operation to this data point and check the results
2259 jgs 147 AbsMax absmax_func;
2260     assert(dataView.reductionOp(absmax_func,0)==dataView.index(8,7,4,10));
2261 jgs 113
2262     if (p<npoints-1) {
2263     dataView.incrOffset();
2264     }
2265    
2266     }
2267    
2268     }
2269    
2270     cout << endl;
2271    
2272     }
2273    
2274 jgs 82 TestSuite* DataArrayViewTestCase::suite ()
2275     {
2276     //
2277     // create the suite of tests to perform.
2278     TestSuite *testSuite = new TestSuite ("DataArrayViewTestCase");
2279    
2280     testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testAll",&DataArrayViewTestCase::testAll));
2281     testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testShapeToString",&DataArrayViewTestCase::testShapeToString));
2282     testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testScalarView",&DataArrayViewTestCase::testScalarView));
2283 jgs 108 testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testResultSliceShape",&DataArrayViewTestCase::testResultSliceShape));
2284 jgs 82 testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testSlicing",&DataArrayViewTestCase::testSlicing));
2285 jgs 108 testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testUnaryOp",&DataArrayViewTestCase::testUnaryOp));
2286     testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testBinaryOp",&DataArrayViewTestCase::testBinaryOp));
2287 jgs 113 testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testReductionOp",&DataArrayViewTestCase::testReductionOp));
2288     testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testMatMult",&DataArrayViewTestCase::testMatMult));
2289 jgs 82 return testSuite;
2290     }

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26