Patch: Remove 'test' Directory
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Patch: Remove 'test' Directory
- To: pooma-dev@xxxxxxxxxxxxxxxxxxxxxx
- Subject: Patch: Remove 'test' Directory
- From: Jeffrey Oldham <oldham@xxxxxxxxxxxxxxxx>
- Date: Thu, 4 Oct 2001 18:36:23 -0700
This patch removes the four tests in the Pooma 'test' directory. It
is unclear whether these files actually exist. They do in some places
and not in others. In either case, they have now disappeared.
2001-10-04 Jeffrey D. Oldham <oldham@xxxxxxxxxxxxxxxx>
* Domain/Loc/Characteristics/LocCharacteristics.cpp: Remove this
stale file.
* Domain/NewDomain/Constructors/NewDomainConstructor.cpp: Likewise.
* Domain/Range/Constructors/RangeConstructor.cpp: Likewise.
* Domain/Range/Constructors/makefile: Likewise.
* Engine/BrickEngine/BrickEngine/BrickEngineTest.cpp: Likewise.
Nothing to test.
Applied to mainline.
Approved by Jim Crotinger
Thanks,
Jeffrey D. Oldham
oldham@xxxxxxxxxxxxxxxxIndex: Domain/Loc/Characteristics/LocCharacteristics.cpp
===================================================================
RCS file: LocCharacteristics.cpp
diff -N LocCharacteristics.cpp
*** /tmp/cvsm6VP8z Thu Oct 4 12:11:21 2001
--- /dev/null Fri Mar 23 21:37:44 2001
***************
*** 1,315 ****
- // -*- C++ -*-
- //--------------------------------------------------------------------
-
- // Loc Characteristics Component Test Code
- //--------------------------------------------------------------------
-
- #include "Pooma/Pooma.h"
- #include "Domain/Loc.h"
- #include <iostream.h>
- #include <string.h>
- #include <iomanip.h>
-
- void reportResults(int n, char *test, bool testStatus)
- {
- char* statusString = "passed";
- if(!testStatus) statusString = "failed";
- cout << " Test " << setw(3) << n << ", "
- << setw(10) << test << ": " << statusString << "\n";
- }
-
-
-
- void uncaughtErrorReport(const char *what, int n)
- {
- cerr << "\nAck! Caught assertion during test # " << n << ":" << endl\
- ;
- cerr << what << endl;
- }
-
- template<class T>
- Loc<1> testElement(const T &dom, int no) {
- //get the nth element of dom, and store it in a separte variable
- // T::OneDomain_t singleElem = dom[no];
- Loc<1> singleElem = dom[no];
- return singleElem;
- }
-
- // template<class T>
- // void testDom(const T &dom) {
- // //get the dom, and store it in a separte variable
- // T::Domain_t singleDomain = dom;
- // cout << "Domain " << singleDomain << endl;
- // //return singleDomain;
- // }
-
-
- template <class T1, class T2>
- struct TypeMatchTester
- {
- static const bool Result = false;
- };
-
-
- template <class T>
- struct TypeMatchTester<T,T>
- {
- static const bool Result = true;
- };
-
-
- typedef Loc<1>::Domain_t DTest_t;
- typedef Loc<1>::Element_t ETest_t;
- typedef Loc<1>::OneDomain_t ODTest_t;
-
-
- main(int argc, char *argv[]) {
-
- Pooma::initialize( argc, argv );
-
- int debug = 0;
- int testNumber = 0;
- bool testStatus;
-
- if ((argc > 1) && (!strcmp(argv[1],"-d"))) debug = 1;
- cout << "\n"
- << " =============================================================\n"
- << " Domain test for Characterists and Interface on Loc<N> object \n"
- << " =============================================================\n"
- << endl;
-
- if (debug){
- cout << "=========================DEBUG=================================="
- << endl;
- cout << endl;
- cout << "Starting domain test for Characterists and Interface on ";
- cout << " Loc<N> object" << endl;
- cout << "Loc objects represent a single point." << endl;
- cout << endl;
- cout << "first() : the single point in the Loc object" << endl;
- cout << "last() : same as first" << endl;
- cout << "stride() : this is always 1 " << endl;
- cout << "min() : same as first" << endl;
- cout << "max() : same as first" << endl;
- cout << "length() : this is always 1 " << endl;
- cout << "size() : total volume size of the domain, should " ;
- cout << "always be one "<< endl;
- cout << "empty() :this should always be false " << endl;
- cout << "dimensions : the number N " << endl;
- cout << "loopAware : this should be 0 " << endl;
- cout << "singleValued : this should be 1 " << endl;
- cout << "unitStride : this should be 1 " << endl;
- cout << endl;
- }
-
- Loc<4>Empty;
- Loc<1> n1i(-1);
- Loc<2> n2i(-1,-2);
- Loc<3> n3i(-1,-2,-3);
- Loc<4> n4i(-1,-2,-3,-4);
- Loc<5> n5i(-1,-2,-3,-4,-5);
- Loc<6> n6i(-1,-2,-3,-4,-5,-6);
-
-
- Loc<1> a1i(1);
- Loc<2> a2i(1,2);
- Loc<2> a2ia(1);
- Loc<3> a3i(1,2,3);
- Loc<3> a3ia(1,2);
- Loc<4> a4i(1,2,3,4);
- Loc<4> a4ia(1,2,3);
- Loc<5> a5i(a3i,a2i);
- Loc<5> a5ia(1,2,3,4);
- Loc<6> a6i(1,2,3,4,5,6);
- Loc<6> a6ia(1,2,3,4);
-
- //Can not use floating point values for endpoints.
- // Loc<1> f1i(1.1);
-
- //If you leave a empty endpoint it will not be intialized to zero but
- //will have random values.
- //Loc<2>(1) will give you the 001:*** where * is any random value
-
- cout << endl;
-
-
- Loc<1> a1 = Loc<1>(1);
- //Loc<1> b1(Loc<1>());
- Loc<2> b2(a1,Loc<1>(2));
- Loc<3> b3(b2,Loc<1>(3));
- Loc<4> b4(b3,Loc<1>(4));
- Loc<5> b5(b4,Loc<1>(5));
- Loc<6> b6(b5,Loc<1>(6));
- Loc<6> b6a(b3,b2,Loc<1>(6));
-
- //OneDomain_t ODT = b2[0];
- //Domain_t DT = b5;
- if (debug){
-
- cout << endl;
-
- cout << " a5i = " << a5i << endl;
- cout << " a5i[0].length() = " << a5i[0].length() << endl;
- cout << " a5i[1].length() = " << a5i[1].length() << endl;
- cout << " a5i[2].length() = " << a5i[2].length() << endl;
- cout << " a5i[3].length() = " << a5i[3].length() << endl;
- cout << " a5i[4].length() = " << a5i[4].length() << endl;
-
- cout << " a5i[0].first() = " << a5i[0].first() << endl;
- cout << " a5i[1].first() = " << a5i[1].first() << endl;
- cout << " a5i[2].first() = " << a5i[2].first() << endl;
- cout << " a5i[3].first() = " << a5i[3].first() << endl;
- cout << " a5i[4].first() = " << a5i[4].first() << endl;
-
- cout << " a5i[0].last() = " << a5i[0].last() << endl;
- cout << " a5i[1].last() = " << a5i[1].last() << endl;
- cout << " a5i[2].last() = " << a5i[2].last() << endl;
- cout << " a5i[3].last() = " << a5i[3].last() << endl;
- cout << " a5i[4].last() = " << a5i[4].last() << endl;
-
- cout << " a5i[0].stride() = " << a5i[0].stride() << endl;
- cout << " a5i[1].stride() = " << a5i[1].stride() << endl;
- cout << " a5i[2].stride() = " << a5i[2].stride() << endl;
- cout << " a5i[3].stride() = " << a5i[3].stride() << endl;
- cout << " a5i[4].stride() = " << a5i[4].stride() << endl;
-
- cout << " a5i[0].min() = " << a5i[0].min() << endl;
- cout << " a5i[1].min() = " << a5i[1].min() << endl;
- cout << " a5i[2].min() = " << a5i[2].min() << endl;
- cout << " a5i[3].min() = " << a5i[3].min() << endl;
- cout << " a5i[4].min() = " << a5i[4].min() << endl;
-
- cout << " a5i[0].max() = " << a5i[0].max() << endl;
- cout << " a5i[1].max() = " << a5i[1].max() << endl;
- cout << " a5i[2].max() = " << a5i[2].max() << endl;
- cout << " a5i[3].max() = " << a5i[3].max() << endl;
- cout << " a5i[4].max() = " << a5i[4].max() << endl;
-
- cout << " a5i.dimensions() = " << a5i.dimensions << endl;
- //cout << " a5i.loopAware() = " << a5i.loopAware() << endl;
- //cout << " a5i.singleValued()= " << a5i.singleValued() << endl;
- //cout << " a5i.unitStride() = " << a5i.unitStride() << endl;
-
- cout << endl;
-
- cout << " after a1 = 1 : a1 = " << a1 << endl;
- cout << " 2D multiple Loc<2> b2(a1,Loc<1>(2)) = " << b2 << endl;
- cout << " 3D multiple Loc<3> b3(b2,Loc<1>(3)) = " << endl;
- cout << " " << b3 << endl;
- cout << " 4D multiple Loc<4> b4(b3,Loc<1>(4)) = " << endl;
- cout << " " << b4 << endl;
- cout << " 5D multiple Loc<5> b5(b4,Loc<1>(5)) = " << endl;
- cout << " " << b5 << endl;
- cout << " 6D multiple Loc<6> b6(b5,Loc<1>(6)) = " << endl;
- cout << " " << b6 << endl;
- cout << " 6D multiple Loc<6> b6a(b3,b2,Loc<1>(6))= " << endl;
- cout << " " << b6a << endl;
- cout << " 6D multiple Loc<6> b6a(b3,b2,Loc<1>(6)).size = "
- << b6a.size() << endl;
- cout << " 6D multiple Loc<6> b6a(b3,b2,Loc<1>(6)).size = " <<
- b6a.empty() << endl;
- // cout << " OneDomain = " << OneDomain << endl;
- cout << " Empty = " << Empty << endl;
- cout << " Empty.size = " << Empty.size() << endl;
- cout << " Empty.empty = " << Empty.empty() << endl;
-
-
- cout << "=========================END DEBUG============================="
- << endl;
- cout << endl;
- }
- try {
- testStatus = (b6a.dimensions == 6);
- testStatus = (b5.dimensions == 5) && testStatus;
- testStatus = (b4.dimensions == 4) && testStatus;
- testStatus = (b3.dimensions == 3) && testStatus;
- testStatus = (b2.dimensions == 2) && testStatus;
- reportResults(testNumber++,"Loc<>.dimensions ",testStatus);
- testStatus = (b6a[0].stride() == b6a.size()) && testStatus;
- testStatus = (b5[0].stride() == b5.size()) && testStatus;
- testStatus = (b4[0].stride() == b4.size()) && testStatus;
- reportResults(testNumber++,"Loc<>.size ",testStatus);
- testStatus = (Empty.empty() == 0);
- testStatus = (b6a.empty() == 0) && testStatus;
- reportResults(testNumber++,"Loc<>.empty ",testStatus);
- testStatus = a5i[0].stride();
- testStatus = a5i[1].stride() && testStatus;
- testStatus = a5i[2].stride() && testStatus;
- testStatus = a5i[3].stride() && testStatus;
- testStatus = a5i[4].stride() && testStatus;
- reportResults(testNumber++,"Loc<>.stride ",testStatus);
- testStatus = (b6a[0].first() == b6a[0].last());
- testStatus = (b6a[1].first() == b6a[1].last()) && testStatus;
- testStatus = (b6a[2].first() == b6a[2].last()) && testStatus;
- testStatus = (b6a[3].first() == b6a[3].last()) && testStatus;
- testStatus = (b6a[4].first() == b6a[4].last()) && testStatus;
- testStatus = (b6a[5].first() == b6a[5].last()) && testStatus;
- reportResults(testNumber++,"Loc<>.first/last ",testStatus);
- testStatus = (b5[0].first() == b5[0].min());
- testStatus = (b5[1].first() == b5[1].min()) && testStatus;
- testStatus = (b5[2].first() == b5[2].min()) && testStatus;
- testStatus = (b5[3].first() == b5[3].min()) && testStatus;
- testStatus = (b5[4].first() == b5[4].min()) && testStatus;
- reportResults(testNumber++,"Loc<>.first/min ",testStatus);
- testStatus = (b4[0].first() == b4[0].max());
- testStatus = (b4[1].first() == b4[1].max()) && testStatus;
- testStatus = (b4[2].first() == b4[2].max()) && testStatus;
- testStatus = (b4[3].first() == b4[3].max()) && testStatus;
- reportResults(testNumber++,"Loc<>.first/max ",testStatus);
- testStatus = (b3[0].stride() == b3[0].length());
- testStatus =(b3[1].stride() == b3[1].length()) && testStatus;
- testStatus =(b3[2].stride() == b3[2].length()) && testStatus;
- reportResults(testNumber++,"Loc<>.length ",testStatus);
- testStatus = (!b6a.loopAware);
- testStatus = (!b5.loopAware) && testStatus;
- testStatus = (!b4.loopAware) && testStatus;
- testStatus = (!b3.loopAware) && testStatus;
- testStatus = (!b2.loopAware) && testStatus;
- reportResults(testNumber++,"Loc<>.loopAware ",testStatus);
- testStatus = (b6a.singleValued);
- testStatus = (b5.singleValued) && testStatus;
- testStatus = (b4.singleValued) && testStatus;
- testStatus = (b3.singleValued) && testStatus;
- testStatus = (b2.singleValued) && testStatus;
- reportResults(testNumber++,"Loc<>.singleValued ",testStatus);
- testStatus = (b6a.unitStride);
- testStatus = (b5.unitStride) && testStatus;
- testStatus = (b4.unitStride) && testStatus;
- testStatus = (b3.unitStride) && testStatus;
- testStatus = (b2.unitStride) && testStatus ;
- reportResults(testNumber++,"Loc<>.unitStride ",testStatus);
- testStatus = TypeMatchTester<DTest_t,Loc<1>:: Domain_t>::Result;
- reportResults(testNumber++,"Typedef Domain_t ", testStatus);
- testStatus = TypeMatchTester<ETest_t,Loc<1>:: Element_t>::Result
- && testStatus;
- reportResults(testNumber++,"Typedef Elemant_t ", testStatus);
- testStatus = TypeMatchTester<ODTest_t,Loc<1>:: OneDomain_t>::Result
- && testStatus;
- reportResults(testNumber++,"Typedef OneDomain_t ", testStatus);
- testStatus = !TypeMatchTester<DTest_t,Loc<1>:: Element_t>::Result
- && testStatus;
- reportResults(testNumber++,"Typedef Domain_t ", testStatus);
- testStatus = !TypeMatchTester<ETest_t,Loc<1>:: Domain_t>::Result
- && testStatus;
- reportResults(testNumber++,"Typedef Elemant_t ", testStatus);
- testStatus = !TypeMatchTester<ODTest_t,Loc<1>:: Element_t>::Result
- && testStatus;
- reportResults(testNumber++,"Typedef OneDomain_t ", testStatus);
- testStatus = (a1i == testElement(a4i[0],0));
- testStatus = (b6a[5] == testElement(a6i[5],5)) && testStatus;
- testStatus = (b6a[4] == testElement(b4[1],1)) && testStatus;
- testStatus = (b6a[4] != testElement(b4[2],2)) && testStatus;
- reportResults(testNumber++,"OneDomain ",testStatus);
- }
-
- catch (const char *err)
- { uncaughtErrorReport(err,testNumber); }
- catch(const Pooma::Assertion &err)
- {uncaughtErrorReport(err.what(),testNumber); }
- catch(...)
- { cerr << "Unknown exception!" << endl; }
- cout << endl;
-
- Pooma::finalize();
- }
-
--- 0 ----
Index: Domain/NewDomain/Constructors/NewDomainConstructor.cpp
===================================================================
RCS file: NewDomainConstructor.cpp
diff -N NewDomainConstructor.cpp
*** /tmp/cvsHWUAsL Thu Oct 4 12:11:21 2001
--- /dev/null Fri Mar 23 21:37:44 2001
***************
*** 1,224 ****
- // -*- C++ -*-
- //---------------------------------------------------------------------
-
- // NewDomainConstructor Component Test Code
- //---------------------------------------------------------------------
-
- #include <Domain/Loc.h>
- #include <Domain/Interval.h>
- #include <Domain/Range.h>
- #include <iostream.h>
- #include <string.h>
- #include <iomanip.h>
-
-
- void reportResults(int n, char *test, bool testStatus)
- {
- char* statusString = "passed";
- if(!testStatus) statusString = "failed";
- cout << " Test " << setw(3) << n << ", "
- << setw(10) << test << ": " << statusString << "\n";
- }
-
- void uncaughtErrorReport(const char *what, int n)
- {
- cerr << "\nAck! Caught assertion during test # " << n << ":" << endl;
- cerr << what << endl;
- }
-
- template<class T>
- Interval<1> testElement(const T &dom, int no) {
- //get the nth element of dom, and store it in a separte variable
- T::OneDomain_t singleElem = dom[no];
- return singleElem;
- }
-
- template <class T1, class T2>
- struct TypeMatchTester
- {
- static const bool Result = false;
- };
-
- template <class T>
- struct TypeMatchTester<T,T>
- {
- static const bool Result = true;
- };
-
- //typedef NewDomain<>::Type_t TTest_t;
- //typedef NewDomain<>::FullType_t FTest_t;
- //typedef NewDomain<>::SliceType_t STest_t;
-
-
- main(int argc, char *argv[]) {
-
- int debug = 0;
- int testNumber = 0;
- bool testStatus;
-
- if ((argc > 1) && (!strcmp(argv[1],"-d"))) debug = 1;
- cout << "\n"
- << " ==============================================================\n"
- << " Domain test for Constructors on NewDomain<N> object \n"
- << " ==============================================================\n"
- << endl;
-
- if (debug){
- cout << "=========================DEBUG==================================="
- << endl;
- cout << endl;
- cout << "Starting domain test for Constructors on NewDomain<N> object"
- << endl;
- cout << "A set of simple structs which tell how to combine." << endl;
- cout << endl;
- cout << " different Domain object together. TThey are named " << endl;
- cout << "NewDomain1 - NewDoamin7 and are templated on from 1 .. 7 "
- << endl;
- cout << "different domain types. If you have a domain as the last "
- << endl;
- cout << "argrment you must have a space between this argument and the"
- << endl;
- cout << "last >,NewDomain2<Loc<1>,Loc<1> >::Type_t newdomain2; "
- << endl;
- }
- cout << endl;
- Loc<1> D1(1);
- Loc<1> D2(2);
- Range<2> R1(Interval<1>(5,10),Interval<1>(-1,100));
- Range<2> R2(Range<1>(5,10,5),Range<1>(-100,100,20));
- Interval<2> I1(Interval<1>(20,40),Interval<1>(-50,10));
- Interval<2> I2(Interval<1>(20,40),Loc<1>(-99));
- Range<2> R(Range<1>(1,1,1),999);
- NewDomain2<Loc<1>,int>::Type_t newdomain2;
-
- NewDomain2<Loc<1>,int>::Type_t newdomain2a =
- NewDomain2<Loc<1>,int>::combine(D1,2);
-
- NewDomain3<Loc<2>,Range<2>,int>::Type_t newdomain3;
- NewDomain3<Loc<2>,Range<2>,int>::Type_t newdomain3a =
- NewDomain3<Loc<2>,Range<2>,int>::combine(newdomain2a,R2,999);
-
- NewDomain4<Range<2>,Interval<2>,Loc<1>,Loc<1> >::Type_t newdomain4;
-
- NewDomain4<Range<2>,Interval<2>,Loc<1>,Loc<1> >::Type_t newdomain4a =
- NewDomain4<Range<2>,Interval<2>,Loc<1>,Loc<1> >::combine(R2,I2,D1,D2);
-
- NewDomain5<Loc<2>,Range<2>,int,Loc<4>,int>::Type_t newdomain5;
- NewDomain5<Loc<2>,Range<2>,int,Loc<4>,int>::Type_t newdomain5a =
- NewDomain5<Loc<2>,Range<2>,int,Loc<4>,int>::combine
- (newdomain2a,R2,999,Loc<4>(D1,D2,newdomain2a),999);
-
- NewDomain6<Loc<2>,Range<2>,int,Loc<4>,Loc<4>,int>::Type_t newdomain6;
- NewDomain6<Loc<2>,Range<2>,int,Loc<4>,Loc<4>,int>::Type_t newdomain6a =
- NewDomain6<Loc<2>,Range<2>,int,Loc<4>,Loc<4>,int>::combine
- (newdomain2a,R1,99,Loc<4>(newdomain2a,newdomain2a),Loc<4>
- (newdomain2a,newdomain2a),999);
-
- NewDomain7<Range<2>,Range<2>,Loc<1>,Loc<1>,Interval<2>,Interval<2>,
- int>::Type_t newdomain7;
-
- NewDomain7<Range<2>,Range<2>,Loc<1>,Loc<2>,Interval<2>,Interval<2>,
- Range<2> >::Type_t newdomain7a = NewDomain7<Range<2>,Range<2>,Loc<1>,
- Loc<2>,Interval<2>,Interval<2>,Range<2> >::combine(R1,R2,D1,newdomain2a,
- I1,I2,R2);
-
-
- if (debug){
- cout << "================================================================"
- << endl;
- cout << endl;
- cout << " NewDomain7<Range<2>,Range<2>,Loc<1>,Loc<2>,Interval<2>, Interval<2>,int>::combine(R1,R2,D1,newdomain2a,I1,I2,999) " << newdomain7a << endl;
- cout << " R1 " << R1 << endl;
- cout << " R2 " << R2 << endl;
- cout << " D1 " << D1 << endl;
- cout << " newdomain2a " << newdomain2a << endl;
- cout << " I1 " << I1 << endl;
- cout << " I2 " << I2 << endl;
- cout << " newdomain2 " << newdomain2 << endl;
- cout << " newdomain2a " << newdomain2a << endl;
- cout << " newdomain3 " << newdomain3 << endl;
- cout << " newdomain3a " << newdomain3a << endl;
- cout << " newdomain4 " << newdomain4 << endl;
- cout << " newdomain4a " << newdomain4a << endl;
- cout << " newdomain5 " << newdomain5 << endl;
- cout << " newdomain5a \n" << " " << newdomain5a << endl;
- cout << " newdomain6 \n " << " " << newdomain6 << endl;
- cout << " newdomain6a \n " << " " << newdomain6a << endl;
- cout << " newdomain7 \n " << " " << newdomain7 << endl;
- cout << " newdomain7a \n " << " " << newdomain7a << endl;
- cout << " newdomain2.dimensions " << newdomain2.dimensions << endl;
- cout << " newdomain3.dimensions " << newdomain3.dimensions << endl;
- cout << " newdomain4.dimensions " << newdomain4.dimensions << endl;
- cout << " newdomain5.dimensions " << newdomain5.dimensions << endl;
- cout << " newdomain6.dimensions " << newdomain6.dimensions << endl;
- cout << " newdomain7.dimensions " << newdomain7.dimensions << endl;
- cout << " newdomain2a.dimensions " << newdomain2a.dimensions << endl;
- cout << " newdomain3a.dimensions " << newdomain3a.dimensions << endl;
- cout << " newdomain4a.dimensions " << newdomain4a.dimensions << endl;
- cout << " newdomain5a.dimensions " << newdomain5a.dimensions << endl;
- cout << " newdomain6a.dimensions " << newdomain6a.dimensions << endl;
- cout << " newdomain7a.dimensions " << newdomain7a.dimensions << endl;
- cout << endl;
- cout << "================================================================" << endl;
- }
- cout << "Testing NewDomain<*> constructors methods:" << endl;
- cout << "----------------------------------------------------------" << endl;
- try {
-
- //----------------------------------------------------------------------
- // Test NewDomain Construtor
- //----------------------------------------------------------------------
-
- testStatus = (newdomain2.dimensions == 2);
- testStatus = (newdomain3.dimensions == 5) && testStatus;
- testStatus = (newdomain4.dimensions == 6) && testStatus;
- testStatus = (newdomain5.dimensions == 10) && testStatus;
- testStatus = (newdomain6.dimensions == 14) && testStatus;
- testStatus = (newdomain7.dimensions == 11) && testStatus;
- testStatus = (newdomain7a.dimensions == 13) && testStatus;
- reportResults(testNumber++,"Empty Construtor ",testStatus);
-
- //----------------------------------------------------------------------
- // Test Combine Construtor
- //----------------------------------------------------------------------
- testStatus = (newdomain2a[1] == 2 );
- testStatus = (newdomain3a[2] == R2[0]) && testStatus;
- testStatus = (newdomain4a[5] == Loc<1>(2)) && testStatus ;
- testStatus = (newdomain5a[4] == Loc<1>(999))&& testStatus ;
- testStatus = (newdomain6a[12] == D2) && testStatus;
- //testStatus = (newdomain7a[11] == Range<1>(-100,100,20)) && testStatus;
- reportResults(testNumber++,"Combine Construtor ",testStatus);
-
- //----------------------------------------------------------------------
- // Test Fill Construtor
- //----------------------------------------------------------------------
- NewDomain2<Loc<1>,int>::fill(newdomain2,D1,2);
- testStatus = (newdomain2a ==newdomain2 );
- NewDomain6<Loc<2>,Range<2>,int,Loc<4>,Loc<4>,int>::fill
- ( newdomain6,newdomain2a,R1,99,Loc<4>(newdomain2a,newdomain2a),Loc<4>
- (newdomain2a,newdomain2a),999);
- testStatus = (newdomain6a ==newdomain6 ) && testStatus;
- NewDomain5<Loc<2>,Range<2>,int,Loc<4>,int>::fill(
- newdomain5,newdomain2a,R2,999,Loc<4>(D1,D2,newdomain2a),999);
- testStatus = (newdomain5a == newdomain5) && testStatus ;
- reportResults(testNumber++,"Fill Construtor ",testStatus);
- } // end try
-
- catch (const char *err)
- { uncaughtErrorReport(err,testNumber); }
- catch(const Pooma::Assertion &err)
- {uncaughtErrorReport(err.what(),testNumber); }
- catch(...)
- { cerr << "Unknow exception!" << endl; }
- cout << endl;
-
-
- }
-
-
-
-
-
-
-
-
--- 0 ----
Index: Domain/Range/Constructors/RangeConstructor.cpp
===================================================================
RCS file: RangeConstructor.cpp
diff -N RangeConstructor.cpp
*** /tmp/cvspsACMW Thu Oct 4 12:11:21 2001
--- /dev/null Fri Mar 23 21:37:44 2001
***************
*** 1,217 ****
- // -*- C++ -*-
- //--------------------------------------------------------------------
-
- // Range Constructor Component Test Code
- //--------------------------------------------------------------------
-
- // include files
-
- #include "Pooma/Pooma.h"
- #include "Domain/Loc.h"
- #include "Domain/Range.h"
- #include "Domain/Interval.h"
- #include <iostream.h>
- #include <string.h>
- #include <iomanip.h>
-
- void reportResults(int n, char *test, bool testStatus)
- {
- char* statusString = "passed";
- if(!testStatus) statusString = "failed";
- cout << " Test " << setw(3) << n << ", "
- << setw(10) << test << ": " << statusString << "\n";
- }
-
- void uncaughtErrorReport(const char *what, int n)
- {
- cerr << "\nAck! Caught assertion during test # " << n << ":" << endl;
- cerr << what << endl;
- }
-
-
- main(int argc, char *argv[]) {
-
- Pooma::initialize( argc, argv );
-
- int debug = 0;
- int testNumber = 0;
- bool testStatus;
-
- if ((argc > 1) && (!strcmp(argv[1],"-d"))) debug = 1;
-
-
- cout << "\n"
- << " ==============================================================\n"
- << " Domain test for Constructors on Range<N> object \n"
- << " ==============================================================\n"
- << endl;
-
- if (debug){
- cout << "=========================DEBUG==================================="
- << endl;
- cout << "Range represents a sequence of integers [a,a+s,... b], with "
- << endl;
- cout << "endpoints a and b, and stride s. Each dimension is independent"
- << endl;
- cout << "of the other. The endpoints may be positive or negative." << endl;
- cout << endl;
- cout << "If you construct a Range with 2 dimensions [Range<2> a2i]" << endl;
- cout << "and only give it one value [Range<2> a2ia(1))] the second dimension" << endl;
- cout << "value will not be intitalized to 0 but will have ramdom junk. I"
- << endl;
- cout << "have not come up with a way to do a pass/fail on the feature."
- << endl;
- cout << "Float and Double values are truncated." << endl;
- }
-
- Range<1> a1(1);
- Range<1> a2(-3);
- Range<1> a3(3);
- Range<1> a4(4);
- Range<1> a5(-5);
- Range<1> a6(6);
-
- Range<1> a1i(1);
- Range<1> a1ia(1,5);
- Range<1> a1ib(0,5);
- Range<1> a1ic(0,6,2);
- Range<1> a1id(2,8,-3);
- Range<1> a1ie(0,10,2);
- Range<1> a1if(1,1001,100);
-
-
-
- if (debug){
- cout << "Range<1> Length Constructor for test."<< endl;
- cout << " 1D default Range<1> a1(1) " << a1 << endl;
- cout << " 1D default Range<1> a2(-3) " << a2 << endl;
- cout << " 1D default Range<1> a3(3) " << a3 << endl;
- cout << " 1D default Range<1> a4(4) " << a4 << endl;
- cout << " 1D default Range<1> a5(-5) " << a5 << endl;
- cout << " 1D default Range<1> a6(6) " << a6 << endl;
- cout << " 1D default Range<1> a1i(1) " << a1i << endl;
- cout << " 1D default Range<1> a1ia(1,5) " << a1ia << endl;
- cout << " 1D default Range<1> a1ib(0,5) " << a1ib << endl;
- cout << " 1D default Range<1> a1ic(0,6,2) " << a1ic << endl;
- cout << " 1D default Range<1> a1id(2,8,-3) " << a1id << endl;
- cout << " 1D default Range<1> a1ie(0,10,2) " << a1ie << endl;
- cout << " 1D default Range<1> a1if(1,1001,100) " << a1if << endl;
- cout << endl;
- }
-
- Range<1> n1(-100);
- Range<2> n2(Range<1>(-100,100,10),Range<1>(100,-100,10));
- Range<3> n3(n2,a1);
-
- Range<1> b1(a1if);
- Range<2> b2(b1,a1);
- Range<3> b3(b2,a3);
- Range<4> b4(b3,a4);
- Range<5> b5(b4,Range<1>(1,5));
- Range<6> b6(b5,a6);
-
- Loc<1> L1;
- L1 = 3;
- Interval<1> I1(1,5);
- Interval<2> I2(Interval<1>(0,200),I1);
- Range<2> RL2(L1,b1);
- Range<3> RL3(RL2,L1);
- Range<4> RL4(RL3,I1);
- Range<5> RL5(I2,RL3);
-
- Loc<1> NL1;
- NL1 = -3;
- Interval<1> NI1(-1,5);
- Interval<1> NI1a(-10,-5);
- Interval<2> NI2(NI1,NI1a);
- Range<2> NRL2(NI1,Interval<1>(-6,0));
- Range<3> NRL3(NRL2,NI1a);
- Range<5> NRL5(NL1,NRL2,NI1a);
- double D2 = 234.877;
- float F1 = 123.5464;
- Interval<1> FI1(-1,F1);
- Interval<1> DI2(-100,D2);
- Interval<3> DI3(FI1,Interval<2>(FI1,DI2));
-
- Range<6> FDR6(DI3,NI1a, DI2);
-
- if (debug){
- cout << " 1D default Range<1> b1(a1if) " << b1 << endl;
- cout << " 2D default Range<2> b2(b1,a1) " << b2 << endl;
- cout << " 3D default Range<3> b3(b2,a3) " << b3 << endl;
- cout << " 4D default Range<4> b4(b3,a4) " << endl;
- cout << " " << b4 << endl;
- cout << " 5D default Range<5> b5(b4,Range<1>(1,5)) " << endl;
- cout << " " << b5 << endl;
- cout << " 6D default Range<6> b6(b5,a6) " << endl;
- cout << " " << b6 << endl;
- cout << " 1D Negative Range<1> n1(-100) " << n1 << endl;
- cout << " 2D Negative Range<2> n2(Range<1>(-100,100,10)," << endl;
- cout << " Range<1>(100,-100,10)) " << n2 << endl;
- cout << " 3D Negative Range<3> n3(n2,a1) " << endl;
- cout << " " << n3 << endl;
-
- cout << " 2D Mixed object Range<2> RL2(Loc<1> L1,Range<2>b1 " << endl;
- cout << " " << RL2 << endl;
- cout << " 3D Mixed object Range<3> RL3(RL1,L1) " << endl;
- cout << " " << RL3 << endl;
- cout << " 4D Mixed object Range<4> RL4(RL3,I1) = " << endl;
- cout << " " << RL4 << endl;
- cout << " 5D Mixed object Range<5> RL5(I2,RL3) " << endl;
- cout << " " << RL5 << endl;
- cout << " 2D Mixed object Negative Range<2> NRL2(NI1,Interval<1>(-6,0)) "<< endl;
- cout << " " << NRL2 << endl;
- cout << " 3D Mixed object Negative Range<3> NRL3(NRL2,NI1a) " << endl;
- cout << " " << NRL3 << endl;
- cout << " 5D Mixed object Negative Range<5> NRL5(NL1,NRL2,NI1a) "
- << endl;
- cout << " " << NRL5 << endl;
- cout << " 6D Mixed object DF Range<6> FDR6(DI3,NI1a, DI2) "
- << endl;
- cout << " " << FDR6 << endl;
- cout << "=========================END DEBUG============================"
- << endl;
- cout << endl;
- }
- try {
- testStatus = (a3 == Range<1>(3));
- testStatus = (a1ic == Range<1>(0,6,2)) && testStatus;
- testStatus = (a1ie == Range<1>(0,10,2)) && testStatus;
- reportResults(testNumber++,"Default Construtor ",testStatus);
- testStatus = (n1[0] == Range<1>(-100)) && testStatus;
- testStatus = (n2[1] == Range<1>(100,-100,10)) && testStatus ;
- testStatus = (n3[1] ==Range<1>(100,-100,10))&& testStatus ;
- reportResults(testNumber++,"Negative Construtor ",testStatus);
- testStatus = (b1 == a1if) && testStatus ;
- testStatus = (b2[0] == b1) && testStatus;
- testStatus = (b3[2] == a3) && testStatus;
- testStatus = (b4[3] == a4 ) && testStatus;
- testStatus = (b5[4] == a1ia) && testStatus;
- testStatus = (b6[5] == a6) && testStatus;
- reportResults(testNumber++,"Multiple Construtor ",testStatus);
- testStatus = (RL2[0] == L1) && testStatus;
- testStatus = (RL3[2] == L1) && testStatus;
- reportResults(testNumber++,"Mixed Loc Constructor ",testStatus);
- testStatus = (RL4[3] == I1) && testStatus;
- testStatus = (RL5[1] == I1) && testStatus;
- reportResults(testNumber++,"Mixed Intergal Constructor ",testStatus);
- testStatus = (NRL2[0] == NI1) && testStatus;
- testStatus = (NRL3[2] == NI1a) && testStatus;
- reportResults(testNumber++,"Mixed Intergal Negative Constructor",testStatus);
- testStatus = (NRL5[0] == NL1) && testStatus;
- reportResults(testNumber++,"Mixed Loc Negative Constructor ",testStatus);
- testStatus = (FDR6[0] == FI1) && testStatus;
- reportResults(testNumber++,"Mixed Float/Double Constructor ",testStatus);
- }
-
- catch (const char *err)
- { uncaughtErrorReport(err,testNumber); }
- catch(const Pooma::Assertion &err)
- {uncaughtErrorReport(err.what(),testNumber); }
- catch(...)
- { cerr << "Unknown exception!" << endl; }
- cout << endl;
-
- Pooma::finalize();
- }
-
--- 0 ----
Index: Domain/Range/Constructors/makefile
===================================================================
RCS file: makefile
diff -N makefile
*** /tmp/cvsbALR67 Thu Oct 4 12:11:21 2001
--- /dev/null Fri Mar 23 21:37:44 2001
***************
*** 1,11 ****
- # Generated by mm.pl: Mon Mar 9 13:58:39 MST 1998
- # This file is user-editable
-
- PROJECT_ROOT = $(shell cd ../../../..; pwd)
- include $(PROJECT_ROOT)/config/head.mk
-
- default:: $(ODIR)/RangeConstructor
-
- $(ODIR)/RangeConstructor: $(ODIR)/RangeConstructor.o
- $(LinkToSuite)
- include $(SHARED_ROOT)/tail.mk
--- 0 ----
Index: Engine/BrickEngine/BrickEngine/BrickEngineTest.cpp
===================================================================
RCS file: BrickEngineTest.cpp
diff -N BrickEngineTest.cpp
*** /tmp/cvsVvudrj Thu Oct 4 12:11:21 2001
--- /dev/null Fri Mar 23 21:37:44 2001
***************
*** 1,3319 ****
- // ACL:license
- // ----------------------------------------------------------------------
- // This software and ancillary information (herein called "SOFTWARE")
- // called POOMA (Parallel Object-Oriented Methods and Applications) is
- // made available under the terms described here. The SOFTWARE has been
- // approved for release with associated LA-CC Number LA-CC-98-65.
- //
- // Unless otherwise indicated, this SOFTWARE has been authored by an
- // employee or employees of the University of California, operator of the
- // Los Alamos National Laboratory under Contract No. W-7405-ENG-36 with
- // the U.S. Department of Energy. The U.S. Government has rights to use,
- // reproduce, and distribute this SOFTWARE, and to allow others to do so.
- // The public may copy and use this SOFTWARE, FOR NONCOMMERCIAL USE ONLY,
- // without charge, provided that this Notice and any statement of
- // authorship are reproduced on all copies. Neither the Government nor
- // the University makes any warranty, express or implied, or assumes any
- // liability or responsibility for the use of this SOFTWARE.
- //
- // If SOFTWARE is modified to produce derivative works, such modified
- // SOFTWARE should be clearly marked, so as not to confuse it with the
- // version available from LANL.
- //
- // For more information about POOMA, send e-mail to pooma@xxxxxxxxxxxx,
- // or visit the POOMA web page at http://www.acl.lanl.gov/pooma/.
- // ----------------------------------------------------------------------
- // ACL:license
-
- //-----------------------------------------------------------------------------
- // The POOMA Framework
- //
- // This program was prepared by the Regents of the University of California
- // at Los Alamos National Laboratory (the University) under Contract No.
- // W-7405-ENG-36 with the U.S. Department of Energy (DOE). The University has
- // certain rights in the program pursuant to the contract and the program
- // should not be copied or distributed outside your organization. All rights
- // in the program are reserved by the DOE and the University. Neither the U.S.
- // Government nor the University makes any warranty, express or implied, or
- // assumes any liability or responsibility for the use of this software
- //
- // Visit http://www.acl.lanl.gov/POOMA for more details
- //
- //-----------------------------------------------------------------------------
- // Engine Component Test Code
- //-----------------------------------------------------------------------------
- //
- // Classes:
- // Brick - Brick-Engine specialization tag.
- // BrickView<int,bool> - BrickView-Engine specialization tag.
- // Engine<Dim,T,Brick> - the "Brick-Engine" specialization.
- // Engine<Dim,T,BrickView> - the "BrickView-Engine" specialization.
- // NewEngine<Engine,SubDomain> - specializations for BrickView-Engine.
- // ElementProperties<Engine
- // <Dim, T, Brick> > - specialization for BrickEngine.
- //
- //-----------------------------------------------------------------------------
-
- #include "Pooma/Pooma.h"
- #include "Engine/BrickEngine.h"
- #include <iostream.h>
- #include <iomanip.h>
- #include <math.h>
- #include <stdio.h>
-
- //-----------------------------------------------------------------------------
- // Simple particle class providing non-standard type for testing
- // BrickEngine constructors. As specified in the Engine SRS, Atom
- // provides the minimal required copy constructor and assignment operator.
- //-----------------------------------------------------------------------------
-
- class Atom
- {
- public:
-
- //============================================================
- // Constructors, Destructor, Assignment...
- //============================================================
-
- // default construtor is required by RefCountedBlockPtr, which is
- // used by Engine, so we supply this...
-
- Atom()
- {
- N_m = 0;
- Z_m = 0;
- mass_m = 0.0;
- }
-
- Atom(int N, int Z, double mass)
- {
- N_m = N;
- Z_m = Z;
- mass_m = mass;
- }
-
- Atom(const Atom &model)
- {
- N_m = model.N_m;
- Z_m = model.Z_m;
- mass_m = model.mass_m;
- }
-
- Atom & operator=(const Atom &model)
- {
- if (&model == this) return *this;
- N_m = model.N_m;
- Z_m = model.Z_m;
- mass_m = model.mass_m;
- return *this;
- }
-
- ~Atom() { }
-
- //============================================================
- // Accessors and Mutators
- //============================================================
-
- int electron() { return N_m; }
- int nuclear() { return Z_m; }
- double amu() { return mass_m; }
-
- // Atom& makeOwnCopy() { return *this; }
-
- private:
-
- int N_m;
- int Z_m;
- double mass_m;
-
- };
-
-
- //-----------------------------------------------------------------------------
- // Two generic functions (reportResults and uncaughtErrorReport) and
- // two classes (TypeMatchTester and its partial specialization)
- // to facilitate testing...
- //-----------------------------------------------------------------------------
-
- int reportResults(int n, char *test, bool testStatus)
- {
- char* statusString = "passed";
- if(!testStatus) statusString = "failed";
- cout << " Test " << setw(3) << n << ", "
- << setw(46) << test << ": " << statusString << "\n";
- return 0;
- }
-
- void uncaughtErrorReport(const char *what, int n)
- {
- cerr << "\nAck! Caught assertion during test # " << n << ":" << endl;
- cerr << what << endl;
- }
-
- template <class T1, class T2> // template class to test typedefs
- struct TypeMatchTester
- {
- static const bool Result = false;
- };
-
- template <class T> // ... partial specialization
- struct TypeMatchTester<T,T>
- {
- static const bool Result = true;
- };
-
- //-----------------------------------------------------------------------------
- // Wrappers for high-resolution ACLTIMER library C timers
- //-----------------------------------------------------------------------------
-
- extern "C"
- {
- void dclock_init();
- double dclock();
- }
-
-
- //-----------------------------------------------------------------------------
- // Main test program
- //-----------------------------------------------------------------------------
-
- main(int argc, char* argv[]) {
-
- Pooma::initialize(argc,argv);
-
- int testNumber;
- bool testStatus;
- float percent;
- float trueData;
- float testData;
- double timeStart;
- double timeEnd;
- double fast;
- double slow;
- double diff;
- double c = 2.99792458e+8;
-
- float Ry = 13.605698;
- float zero = 0.0;
-
- cout << "\n"
- << " ============================================================="
- << "=====\n"
- << " Engine Capability; BrickEngine package; BrickEngine component "
- << "test\n"
- << " ============================================================="
- << "=====\n" << endl;
-
- testNumber = 0;
-
- try {
-
- // *************************** BrickEngine *****************************
-
- cout << "\n BrickEngine" << endl;
- cout << " -----------\n" << endl;
-
- typedef Engine<3,float,Brick> Engine3Df_t;
- typedef Engine<2,double,Brick> Engine2Dd_t;
- typedef Engine<4,double,Brick> Engine4Dd_t;
- typedef Engine<6,int,Brick> Engine6Di_t;
- typedef Engine<6,float,Brick> Engine6Df_t;
- typedef Engine<7,int,Brick> Engine7Di_t;
-
-
- //---------------------------------------------------------------
- // test 1: BrickEngine required POOMA typedefs properly exported?
- //---------------------------------------------------------------
-
- ++testNumber;
-
- // construct a 3D Cartesian domain [0...10] x [4...14] x [-5...+5]
- // and associated BrickEngine
-
- Interval<3> cube2(Interval<1>(0,10), Interval<1>(4,14), Interval<1>(-5,5));
- Engine3Df_t floatBrick(cube2);
-
- // assign floating-point elements to cube2 Domain
-
- for(int i = 0; i < 11; i++)
- for(int j = 4; j < 15; j++)
- for(int k = -5; k < 6; k++)
- floatBrick(Loc<3>(i,j,k)) = Ry*(i+j+k);
-
- {
- typedef Engine3Df_t::This_t Try_t;
- typedef Engine3Df_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- {
- typedef Engine3Df_t::Engine_t Try_t;
- typedef Engine3Df_t::This_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef Engine3Df_t::Domain_t Try_t;
- typedef Interval<3> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- reportResults(testNumber,"exported typedefs This_t, Engine_t, Domain_t",
- testStatus);
-
-
- //-----------------------------------------------------------
- // test 2: additional required POOMA typedefs for BrickEngine
- //-----------------------------------------------------------
-
- ++testNumber;
-
- {
- typedef Engine3Df_t::Base_t Try_t;
- typedef Range<3> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- {
- typedef Engine3Df_t::Element_t Try_t;
- typedef float Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- reportResults(testNumber,"exported typedefs BaseDomain_t, Element_t",
- testStatus);
-
-
- //-----------------------------------------------------------
- // test 3: still more required POOMA typedefs for BrickEngine
- //-----------------------------------------------------------
-
- ++testNumber;
-
- {
- typedef Engine3Df_t::ElementRef_t Try_t;
- typedef float& Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- {
- typedef Engine3Df_t::Tag_t Try_t;
- typedef Brick Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- reportResults(testNumber,"exported typedefs ElementRef_t, Tag_t",
- testStatus);
-
-
- //-------------------------------------------------------
- // test 4: BrickEngine default constructor, standard type
- //-------------------------------------------------------
-
- ++testNumber;
-
- // use default constructor and BrickEngine assignment operator
-
- Engine3Df_t defaultBrick;
- defaultBrick = floatBrick;
-
- // check that defaultBrick now points to the same data as floatBrick
-
- for(int i = 0; i < 11; i++)
- for(int j = 4; j < 15; j++)
- for(int k = -5; k < 6; k++) {
- trueData = floatBrick.read(Loc<3>(i,j,k));
- testData = defaultBrick.read(Loc<3>(i,j,k));
- testStatus = (testData == trueData) && testStatus;
- testStatus = (trueData == Ry*(i+j+k)) && testStatus;
- trueData = floatBrick.read(i,j,k);
- testData = defaultBrick.read(i,j,k);
- testStatus = (testData == trueData) && testStatus;
- testStatus = (trueData == Ry*(i+j+k)) && testStatus;
- }
-
- reportResults(testNumber,"default constructor & assignment operator",
- testStatus);
-
-
- //-------------------------------------------------------------
- // test 5: BrickEngine Interval constructor, strides() accessor
- //-------------------------------------------------------------
-
- ++testNumber;
-
- Interval<1> x(-17,2);
- Interval<1> y(5,29);
- Interval<1> z(-36,-2);
- Interval<1> t(1);
- Interval<4> spaceTime(x,y,z,t);
-
- Engine4Dd_t lightCone(spaceTime);
- const int *STstrides = lightCone.strides();
- int nomStrides[7];
-
- // stride of the first dimension in the Interval should always be 1
- // (Interval stride() accessor)
-
- nomStrides[0] = spaceTime[0].stride();
- testStatus = (STstrides[0] == nomStrides[0]);
-
- // strides() array for a BrickEngine should return actual strides
- // of the full Interval (BrickEngine strides() accessor).
-
- for(int i = 1; i < 4; i++) {
- nomStrides[i] = spaceTime[i-1].last() - spaceTime[i-1].first() + 1;
- nomStrides[i] = nomStrides[i] * nomStrides[i-1];
- testStatus = (STstrides[i] == nomStrides[i]) && testStatus;
- }
-
- // set data values; incidentally test some Interval accessors
-
- int imin = x.first();
- int imax = x.last();
- int jmin = y.first();
- int jmax = y.last();
- int kmin = z.first();
- int kmax = z.last();
-
- for(int i = imin; i < imax+1; i++)
- for(int j = jmin; j < jmax+1; j++)
- for(int k = kmin; k < kmax+1; k++)
- lightCone(Loc<4>(i,j,k,0)) = c*((i-j)*3 +k);
-
- // verify data values
-
- for(int i = -17; i < 3; i++)
- for(int j = 5; j < 30; j++)
- for(int k = -36; k < -1; k++) {
- testData = lightCone.read(Loc<4>(i,j,k,0));
- trueData = c* ((i-j)*3 +k);
- testStatus = (testData == trueData) && testStatus;
- }
-
- reportResults(testNumber,"Interval constructor; strides accessor",
- testStatus);
-
-
- //----------------------------------------------------
- // test 6: BrickEngine copy constructor, standard type
- //----------------------------------------------------
-
- ++testNumber;
- Engine4Dd_t transporter(lightCone);
-
- diff = zero;
- for(int i = -17; i < 3; i++)
- for(int j = 5; j < 30; j++)
- for(int k = -36; k < -1; k++)
- diff += fabs(lightCone.read(Loc<4>(i,j,k,0)) - transporter.read(i,j,k,0));
-
- testStatus = (diff == zero);
- reportResults(testNumber,"copy constructor",
- testStatus);
-
-
- //------------------------------------------
- // test 7: BrickEngine constructor via model
- //------------------------------------------
-
- ++testNumber;
- Engine4Dd_t scotty(spaceTime,c);
-
- diff = zero;
- for(int i = -17; i < 3; i++)
- for(int j = 5; j < 30; j++)
- for(int k = -36; k < -1; k++)
- diff += fabs(scotty.read(Loc<4>(i,j,k,0)) - c);
-
- testStatus = (diff == zero);
- reportResults(testNumber,"constructor via model",testStatus);
-
-
- //------------------------------------------------------
- // test 8: BrickEngine constructor via foreign data (1D)
- //------------------------------------------------------
-
- ++testNumber;
-
- // 1D test
-
- double* B = new double[10];
- for (int i = 0; i<10; i++)
- B[i] = i*2.3;
-
- Interval<1> line(-2,7);
- Engine<1,double,Brick> french(B,line);
-
- diff = zero;
- for(int i = -2; i < 8; i++)
- diff += fabs(french.read(i) - (i+2)*2.3);
-
- testStatus = (diff == zero);
- reportResults(testNumber,"constructor via 1D foreign data",testStatus);
-
-
- //-----------------------------------------------------------
- // test 9: BrickEngine constructor via foreign data (2D & 3D)
- //-----------------------------------------------------------
-
- ++testNumber;
-
- // 2D test on 2 x 10 Interval
-
- float* C = new float[20];
- for (int i = 0; i<2; i++)
- for ( int j = 0; j < 10; j++)
- C[i*10+j] = (i*2.2+j*3.1);
-
- Interval<2> box(Interval<1>(0,1), Interval<1>(0,9));
- Engine<2,float,Brick> norwegian(C,box);
-
-
- // (i,j) loop order is reversed here to emphasize the fact that
- // POOMA II Engines index according to Fortran order (left-most index
- // varies fastest, etc.). Note C-style indexing of array C.
-
- diff = zero;
- for ( int j = 0; j < 10; j++)
- for( int i = 0; i < 2; i++)
- diff += fabs(norwegian.read(i,j) - C[i+2*j]);
-
- testStatus = (diff == zero);
-
-
- // 3D test on 4 x 3 x 2 Interval (zero-based)
-
- float* G = new float[24];
- Interval<3> cubic(Interval<1>(0,3), Interval<1>(0,2), Interval<1>(0,1));
- Engine<3,float,Brick> dutch(G,cubic);
-
- for (int i = 0; i<4; i++)
- for (int j = 0; j<3; j++)
- for (int k = 0; k<2; k++) {
- int ind = i*6 + j*2 + k;
- G[ind] = 2.2*i + 3.1*j + 1.4*k;
- }
-
- diff = zero;
- for(int k = 0; k < 2; k++)
- for(int j = 0; j < 3; j++)
- for(int i = 0; i < 4; i++) {
- int ind = k*12 + j*4 + i;
- diff += fabs(dutch.read(i,j,k) - G[ind]);
- }
-
- testStatus = (diff == zero) && testStatus;
-
-
- // 3D test on 11 x 11 x 11 Interval (non-zero-based)
-
- float* A = new float[1331];
- for (int i = 0; i<11; i++)
- for (int j = 0; j<11; j++)
- for (int k = 0; k<11; k++) {
- int ind = i*121 + j*11 + k;
- A[ind] = 2.2*i + 3.1*j + 1.4*k;
- }
-
- Engine3Df_t italian(A,cube2);
-
- diff = zero;
- for(int k = -5; k < 6; k++)
- for(int j = 4; j < 15; j++)
- for(int i = 0; i < 11; i++) {
- int ind = (k+5)*121 + (j-4)*11 + i;
- diff += fabs(italian.read(i,j,k) - A[ind]);
- }
-
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber,"constructor via 2D/3D foreign data",
- testStatus);
-
-
- //-------------------------------------------------
- // test 10: BrickEngine constructor via Node object
- //-------------------------------------------------
-
- ++testNumber;
-
- // Construct a simple Node with affinity = -1, Interval Domain,
- // context = local ID = global ID = 0.
-
- Interval<1> point(4,12);
- Interval<6> star(point,point,point,point,point,point);
- Node<Interval<6> > k(-1,star,0,0,0);
- Engine6Di_t BZone(k);
- Engine6Di_t BZone2(star,17);
- BZone = BZone2;
-
- diff = zero;
- for(int i = 4; i < 13; i++)
- for(int j = 4; j < 13; j++)
- for(int k = 4; k < 13; k++)
- for(int l = 4; l < 13; l++)
- for(int m = 4; m < 13; m++)
- for(int n = 4; n < 13; n++)
- diff += abs(BZone.read(i,j,k,l,m,n) - 17);
-
- testStatus = (diff == zero);
- reportResults(testNumber,"constructor via Node object", testStatus);
-
-
- //-----------------------------------------
- // test 11: BrickEngine assignment operator
- //-----------------------------------------
-
- ++testNumber;
-
- Engine4Dd_t geordi;
- geordi = scotty;
-
- diff = zero;
- for(int i = -17; i < 2; i++)
- for(int j = 5; j < 29; j++)
- for(int k = -36; k < -2; k++)
- diff += fabs(geordi.read(i,j,k,0) - c);
-
- testStatus = (diff == zero);
- reportResults(testNumber,"assignment operator",testStatus);
-
-
- //---------------------------------------------------
- // test 12: BrickEngine read(int) accessors, dims 1-7
- //---------------------------------------------------
-
- ++testNumber;
-
- // POOMA II supports Domains with dim <= 7
-
- Interval<1> I0(-3,3);
- Interval<1> J0(6,12);
- Interval<1> I1(I0);
- Engine<1,float,Brick> xxx1(I1,Ry);
-
- Interval<2> I2(I1,J0);
- Engine<2,float,Brick> xxx2(I2,Ry*2);
-
- Interval<3> I3(I2,I0);
- Engine<3,float,Brick> xxx3(I3,Ry*3);
-
- Interval<4> I4(I3,J0);
- Engine<4,float,Brick> xxx4(I4,Ry*4);
-
- Interval<5> I5(I4,I0);
- Engine<5,float,Brick> xxx5(I5,Ry*5);
-
- Interval<6> I6(I5,J0);
- Engine<6,float,Brick> xxx6(I6,Ry*6);
-
- Interval<7> I7(I6,I0);
- Engine<7,float,Brick> xxx7(I7,Ry*7);
-
- diff = zero;
- for(int i = -3; i < 3; i++) {
- diff += fabs(xxx1.read(i) - Ry);
- for(int j = 6; j < 12; j++) {
- diff += fabs(xxx2.read(i,j) - Ry*2);
- for(int k = -3; k < 3; k++) {
- diff += fabs(xxx3.read(i,j,k) - Ry*3);
- for(int l = 6; l < 12; l++) {
- diff += fabs(xxx4.read(i,j,k,l) - Ry*4);
- for(int m = -3; m < 3; m++) {
- diff += fabs(xxx5.read(i,j,k,l,m) - Ry*5);
- for(int n = 6; n < 12; n++) {
- diff += fabs(xxx6.read(i,j,k,l,m,n) - Ry*6);
- for(int p = -3; p < 3; p++) {
- diff += fabs(xxx7.read(i,j,k,l,m,n,p) - Ry*7);
- }
- }
- }
- }
- }
- }
- }
-
- testStatus = (diff == zero);
- reportResults(testNumber,"int read element accessors, dims 1-7",
- testStatus);
-
-
- //--------------------------------------------------------
- // test 13: BrickEngine read(Loc<Dim>) accessors, dims 1-7
- //--------------------------------------------------------
-
- ++testNumber;
-
- diff = zero;
- for(int i = -3; i < 3; i++) {
- diff += fabs(xxx1.read(Loc<1>(i)) - Ry);
- for(int j = 6; j < 12; j++) {
- diff += fabs(xxx2.read(Loc<2>(i,j)) - Ry*2);
- for(int k = -3; k < 3; k++) {
- diff += fabs(xxx3.read(Loc<3>(i,j,k)) - Ry*3);
- for(int l = 6; l < 12; l++) {
- diff += fabs(xxx4.read(Loc<4>(i,j,k,l)) - Ry*4);
- for(int m = -3; m < 3; m++) {
- diff += fabs(xxx5.read(Loc<5>(i,j,k,l,m)) - Ry*5);
- for(int n = 6; n < 12; n++) {
- diff += fabs(xxx6.read(Loc<6>(i,j,k,l,m,n)) - Ry*6);
- for(int p = -3; p < 3; p++) {
- diff += fabs(xxx7.read(Loc<7>(i,j,k,l,m,n,p)) - Ry*7);
- }
- }
- }
- }
- }
- }
- }
-
- testStatus = (diff == zero);
- reportResults(testNumber,"Loc<Dim> read element accessors, dims 1-7",
- testStatus);
-
-
- //------------------------------------------------------------
- // test 14: BrickEngine operator() element accessors, dims 1-7
- //------------------------------------------------------------
-
- ++testNumber;
-
- diff = zero;
- for(int i = -3; i < 3; i++) {
- diff += fabs(xxx1(i) - Ry);
- for(int j = 6; j < 12; j++) {
- diff += fabs(xxx2(i,j) - Ry*2);
- for(int k = -3; k < 3; k++) {
- diff += fabs(xxx3(i,j,k) - Ry*3);
- for(int l = 6; l < 12; l++) {
- diff += fabs(xxx4(i,j,k,l) - Ry*4);
- for(int m = -3; m < 3; m++) {
- diff += fabs(xxx5(i,j,k,l,m) - Ry*5);
- for(int n = 6; n < 12; n++) {
- diff += fabs(xxx6(i,j,k,l,m,n) - Ry*6);
- for(int p = -3; p < 3; p++) {
- diff += fabs(xxx7(i,j,k,l,m,n,p) - Ry*7);
- }
- }
- }
- }
- }
- }
- }
-
- testStatus = (diff == zero);
- reportResults(testNumber,"operator() element accessors, dims 1-7",
- testStatus);
-
- /*******************************************************************************
-
- // this test requires the implementation of an appropriate
- // PAssert to catch and report the dimension violation, at
- // which point it can be un-commented.
-
- // Upon un-commenting, remove the increment of testNumber immediately
- // following this test. The increment is needed to keep the test
- // numbers the same as the test labels.
-
- //-----------------------------------------------------------
- // test 15: BrickEngine underlying Domain dimension violation
- //-----------------------------------------------------------
-
- ++testNumber;
-
- try {
- Interval<8> I8(I7,I0);
- Engine<8,float,Brick> xxx8(I8,Ry*8);
- diff = xxx8.read(0,0,0,0,0,0,0,0) - pi*8;
- throw reportResults(testNumber,"underlying Domain dimension violation",false);
- }
- catch(const Pooma::Assertion &) {reportResults(testNumber,
- "underlying Domain dimension violation",true);}
-
- // the real work is done by 'throw' inside try block; this prevents
- // falling-through to outer 'try' block, and generation of
- // "unknown exception" message.
-
- catch(...) { }
-
- *******************************************************************************/
- ++testNumber; // remove upon activating test 15.
-
- //-------------------------------------------------------------
- // test 16: performance of element access via ints vs. Loc<Dim>
- //-------------------------------------------------------------
-
- ++testNumber;
-
- // initialize hi-resolution timer
-
- dclock_init();
-
- char* str1 = new char[43];
- int l = 0;
-
- for(int i = -17; i < 2; i++)
- for(int j = 5; j < 29; j++)
- for(int k = -36; k < -2; k++)
- lightCone(Loc<4>(i,j,k,l)) = Ry+i+j+k;
-
- timeStart = dclock();
- for(int i = -17; i < 2; i++)
- for(int j = 5; j < 29; j++)
- for(int k = -36; k < -2; k++)
- testData = lightCone.read(i,j,k,l);
-
- timeEnd = dclock();
- fast = timeEnd - timeStart;
-
- timeStart = dclock();
- for(int i = -17; i < 2; i++)
- for(int j = 5; j < 29; j++)
- for(int k = -36; k < -2; k++)
- testData = lightCone.read(Loc<4>(i,j,k,l));
-
- timeEnd = dclock();
- slow = timeEnd - timeStart;
-
- percent = (slow - fast) * 100.0/slow;
- sprintf(str1,"%34s%3.1f%1s",
- "int/Loc elt access; relative perf = ",percent,"%");
- testStatus = (fast < slow);
- reportResults(testNumber,str1,testStatus);
- delete str1;
-
-
- //---------------------------------------
- // test 17: BrickEngine domain() accessor
- //---------------------------------------
-
- ++testNumber;
- Interval<3> d1 = floatBrick.domain();
- testStatus = (d1[0].first() == cube2[0].first()) &&
- (d1[0].last() == cube2[0].last()) &&
- (d1[0].length() == cube2[0].length()) &&
- (d1[1].first() == cube2[1].first()) &&
- (d1[1].last() == cube2[1].last()) &&
- (d1[1].length() == cube2[1].length()) &&
- (d1[2].first() == cube2[2].first()) &&
- (d1[2].last() == cube2[2].last()) &&
- (d1[2].length() == cube2[2].length());
-
- Interval<4> d2 = lightCone.domain();
- testStatus = (d2[0].first() == spaceTime[0].first()) &&
- (d2[0].last() == spaceTime[0].last()) &&
- (d2[0].length() == spaceTime[0].length()) &&
- (d2[1].first() == spaceTime[1].first()) &&
- (d2[1].last() == spaceTime[1].last()) &&
- (d2[1].length() == spaceTime[1].length()) &&
- (d2[2].first() == spaceTime[2].first()) &&
- (d2[2].last() == spaceTime[2].last()) &&
- (d2[2].length() == spaceTime[2].length()) &&
- (d2[3].first() == spaceTime[3].first()) &&
- (d2[3].last() == spaceTime[3].last()) &&
- (d2[3].length() == spaceTime[3].length()) && testStatus;
-
- Interval<7> d3 = xxx7.domain();
- testStatus = (d3[0].first() == I7[0].first()) &&
- (d3[0].last() == I7[0].last()) &&
- (d3[0].length() == I7[0].length()) &&
- (d3[6].first() == I7[6].first()) &&
- (d3[6].last() == I7[6].last()) &&
- (d3[6].length() == I7[6].length()) && testStatus;
-
- reportResults(testNumber,"domain() accessor",testStatus);
-
-
- //-------------------------------------------
- // test 18: BrickEngine baseDomain() accessor
- //-------------------------------------------
-
- ++testNumber;
-
- // baseDomain should be identical to Domain for BrickEngine,
- // since no subsetting has occurred. That is, baseDomain
- // simply returns the Interval Domain of the Engine,
- // re-cast as a Range.
-
- Range<3> d4 = italian.baseDomain();
- testStatus = (d4[0].first() == cube2[0].first()) &&
- (d4[0].last() == cube2[0].last()) &&
- (d4[0].length() == cube2[0].length()) &&
- (d4[1].first() == cube2[1].first()) &&
- (d4[1].last() == cube2[1].last()) &&
- (d4[1].length() == cube2[1].length()) &&
- (d4[2].first() == cube2[2].first()) &&
- (d4[2].last() == cube2[2].last()) &&
- (d4[2].length() == cube2[2].length());
-
- Range<4> d5 = transporter.baseDomain();
- testStatus = (d5[0].first() == spaceTime[0].first()) &&
- (d5[0].last() == spaceTime[0].last()) &&
- (d5[0].length() == spaceTime[0].length()) &&
- (d5[1].first() == spaceTime[1].first()) &&
- (d5[1].last() == spaceTime[1].last()) &&
- (d5[1].length() == spaceTime[1].length()) &&
- (d5[2].first() == spaceTime[2].first()) &&
- (d5[2].last() == spaceTime[2].last()) &&
- (d5[2].length() == spaceTime[2].length()) &&
- (d5[3].first() == spaceTime[3].first()) &&
- (d5[3].last() == spaceTime[3].last()) &&
- (d5[3].length() == spaceTime[3].length()) && testStatus;
-
- Range<5> d6 = xxx5.baseDomain();
- testStatus = (d6[2].first() == I5[2].first()) &&
- (d6[2].last() == I5[2].last()) &&
- (d6[2].length() == I5[2].length()) &&
- (d6[4].first() == I5[4].first()) &&
- (d6[4].last() == I5[4].last()) &&
- (d6[4].length() == I5[4].length()) && testStatus;
-
- reportResults(testNumber,"baseDomain() accessor",testStatus);
-
-
- //--------------------------------------------
- // test 19: BrickEngine makeOwnCopy() function
- //--------------------------------------------
-
- ++testNumber;
- geordi(-12,0,32,0) = Ry;
- diff = (geordi(-12,0,32,0) - scotty(-12,0,32,0));
- testStatus = (diff == zero);
-
- diff = (geordi(1,28,-30,0) - c);
- testStatus = (diff == zero) && testStatus;
-
- geordi.makeOwnCopy();
- geordi(-12,0,32,0) = Ry*2;
- diff = (geordi(-12,0,32,0) - 2*scotty(-12,0,32,0));
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber,"makeOwnCopy() function",testStatus);
-
-
- //-------------------------------------------------------------------
- // test 20: BrickEngine Interval constructor, strides(); non-std type
- //-------------------------------------------------------------------
-
- ++testNumber;
-
- // construct a 6 x 7 Interval IJ, and put a different particle at each
- // location in the Range. Incidentally test some features of
- // Intervals. Note that BrickEngine requires a unit-stride Domain.
-
- Interval<2> IJ(Interval<1>(0,5), Interval<1>(-6,0));
- int IJsize = IJ.size();
- const int IJmax = 42;
- testStatus = (IJsize == IJmax);
-
- int Imin = IJ[0].first();
- int Imax = IJ[0].last();
- int Istr = IJ[0].stride();
- int Ilen = IJ[0].length();
- testStatus = (Imin == 0) && (Imax == 5) && testStatus;
- testStatus = (Istr == 1) && (Ilen == 6) && testStatus;
-
- int Jmin = IJ[1].first();
- int Jmax = IJ[1].last();
- int Jstr = IJ[1].stride();
- int Jlen = IJ[1].length();
- testStatus = (Jmin == -6) && (Jmax == 0) && testStatus;
- testStatus = (Jstr == 1) && (Jlen == 7) && testStatus;
-
- // construct 42 distinct Atoms and store them in the array Ar[IJsize]
-
- int NEl;
- int NChg;
- double Mass;
- int knt = 0;
-
- Atom* Ar[IJmax];
- for (int i=Imin; i<Imax+1; i=i+Istr)
- for (int j=Jmin; j<Jmax+1; j=j+Jstr) {
- NEl = abs(i+j)+5;
- NChg = NEl*2;
- Mass = NChg*2.22;
- Ar[knt] = new Atom(NEl,NChg,Mass);
- testStatus = (Ar[knt]->electron() == NEl) && testStatus;
- knt++;
- }
-
- testStatus = (knt == IJsize) && testStatus;
-
- // construct a 2D BrickEngine to manage the Ar Atoms over the IJ Range
-
- Engine<2,Atom,Brick> ArEngine(IJ);
-
- diff = zero;
- knt = 0;
-
- for (int i=Imin; i<Imax+1; i=i+Istr)
- for (int j=Jmin; j<Jmax+1; j=j+Jstr) {
- ArEngine(Loc<2>(i,j)) = *(Ar[knt]);
- diff += fabsf(ArEngine.read(i,j).amu() - (abs(i+j)+5)*4.44 );
- knt++;
- }
-
- testStatus = (diff == zero) && testStatus;
-
- // test BrickEngine strides() accessor. Should return
- // actual strides of underlying 2D Interval
-
- STstrides = ArEngine.strides();
- nomStrides[0] = 1;
- nomStrides[1] = Imax-Imin+1;
- testStatus = (STstrides[0] == nomStrides[0]) && testStatus;
- testStatus = (STstrides[1] == nomStrides[1]) && testStatus;
-
- reportResults(testNumber,"Interval constr/strides(); non-std type",
- testStatus);
-
-
- //------------------------------------------------------------
- // test 21: BrickEngine default constructor, non-standard type
- //------------------------------------------------------------
-
- ++testNumber;
- Engine<2,Atom,Brick> defaultAr;
- defaultAr = ArEngine;
-
- for (int i=Imin; i<Imax+1; i=i+Istr)
- for (int j=Jmin; j<Jmax+1; j=j+Jstr)
- diff += abs(defaultAr.read(i,j).nuclear() - (abs(i+j)+5)*2 );
-
- testStatus = (diff == zero);
- reportResults(testNumber,"default constructor/assign; non-std type",
- testStatus);
-
-
- //---------------------------------------------------------
- // test 22: BrickEngine copy constructor, non-standard type
- //---------------------------------------------------------
-
- ++testNumber;
- Engine<2,Atom,Brick> dupAr(ArEngine);
-
- diff = zero;
- for (int i=Imin; i<Imax+1; i=i+Istr)
- for (int j=Jmin; j<Jmax+1; j=j+Jstr) {
- diff += abs(dupAr.read(Loc<2>(i,j)).nuclear() - (abs(i+j)+5)*2 );
- knt++;
- }
-
- testStatus = (diff == zero);
- reportResults(testNumber,"copy constructor; non-std type",
- testStatus);
-
-
- //--------------------------------------------------------------
- // test 23: BrickEngine constructor via model, non-standard type
- //--------------------------------------------------------------
-
- ++testNumber;
- Interval<3> IJK(IJ,Interval<1>(2,14));
- Engine<3,Atom,Brick> ArToo(IJK,*(Ar[30]));
-
- Imin = IJK[0].first();
- Imax = IJK[0].last();
- Jmin = IJK[1].first();
- Jmax = IJK[1].last();
- int Kmin = IJK[2].first();
- int Kmax = IJK[2].last();
-
- diff = zero;
- for (int i=Imin; i<Imax+1; i++)
- for (int j=Jmin; j<Jmax+1; j++)
- for (int k=Kmin; k<Kmax+1; k++)
- diff += fabs(ArToo.read(i,j,k).amu() - (double)5*4.44);
-
- testStatus = (diff == zero);
- reportResults(testNumber,"constructor via model; non-std type",
- testStatus);
-
-
- //---------------------------------------------------------------------
- // test 24: BrickEngine constructor via foreign data (1D), non-std type
- //---------------------------------------------------------------------
-
- ++testNumber;
-
- Atom H[17];
- knt = 0;
- for (int i = 0; i<17; i++) {
- NEl = (int)Ry*i;
- NChg = NEl*2;
- Mass = NChg+4-i;
- Atom Htemp(NEl,NChg,Mass);
- H[knt] = Htemp;
- testStatus = (H[knt].amu() == Mass) && testStatus;
- knt++;
- }
-
- Interval<1> Balmer(3,19);
- Engine<1,Atom,Brick> jovian(H,Balmer);
-
- diff = zero;
- for(int i = 3; i < 20; i++) {
- diff += abs( jovian.read(Loc<1>(i)).electron() - (int)Ry*(i-3) );
- diff += fabs( jovian.read(i).amu() - ((int)Ry*(i-3)*2-i+7) );
- }
-
- testStatus = (diff == zero) && testStatus;
- reportResults(testNumber,"constructor via 1D foreign data; non-std type",
- testStatus);
-
-
- //---------------------------------------------------------------
- // test 25: BrickEngine constructor via Node object, non-std type
- //---------------------------------------------------------------
-
- ++testNumber;
-
- Engine<6,Atom,Brick> Energy(k);
- Engine<6,Atom,Brick> Energy2(star,H[16]);
- Energy = Energy2;
-
- diff = zero;
- for(int i = 4; i < 13; i++)
- for(int j = 4; j < 13; j++)
- for(int k = 4; k < 13; k++)
- for(int l = 4; l < 13; l++)
- for(int m = 4; m < 13; m++)
- for(int n = 4; n < 13; n++)
- diff += abs( Energy.read(i,j,k,l,m,n).nuclear() - ((int)Ry)*16*2 );
-
- testStatus = (diff == zero);
- reportResults(testNumber,"constructor via Node object; non-std type",
- testStatus);
-
-
- //-------------------------------------------------------
- // test 26: BrickEngine assignment operator, non-std type
- //-------------------------------------------------------
-
- ++testNumber;
- Engine<3,Atom,Brick> Ne;
- Ne = ArToo;
-
- diff = zero;
- for (int i=Imin; i<Imax+1; i++)
- for (int j=Jmin; j<Jmax+1; j++)
- for (int k=Kmin; k<Kmax+1; k++)
- diff += fabs(Ne.read(i,j,k).nuclear() - 10.0);
-
- testStatus = (diff == zero);
- reportResults(testNumber,"assignment operator; non-std type",
- testStatus);
-
-
- //-----------------------------------------------------
- // test 27: BrickEngine domain() accessor, non-std type
- //-----------------------------------------------------
-
- ++testNumber;
-
- Interval<1> d7 = jovian.domain();
- testStatus = (d7[0].first() == Balmer.first()) &&
- (d7[0].last() == Balmer.last()) &&
- (d7[0].length() == Balmer.length());
-
- Interval<2> d8 = ArEngine.domain();
- testStatus = (d8[0].first() == IJ[0].first()) &&
- (d8[0].last() == IJ[0].last()) &&
- (d8[0].length() == IJ[0].length()) &&
- (d8[1].first() == IJ[1].first()) &&
- (d8[1].last() == IJ[1].last()) &&
- (d8[1].length() == IJ[1].length()) && testStatus;
-
- Interval<6> d9 = Energy.domain();
- testStatus = (d9[3].first() == star[3].first()) &&
- (d9[3].last() == star[3].last()) &&
- (d9[3].length() == star[3].length()) &&
- (d9[5].first() == star[5].first()) &&
- (d9[5].last() == star[5].last()) &&
- (d9[5].length() == star[5].length()) && testStatus;
-
- reportResults(testNumber,"domain() accessor; non-std type",
- testStatus);
-
-
- //---------------------------------------------------------
- // test 28: BrickEngine baseDomain() accessor, non-std type
- //---------------------------------------------------------
-
- ++testNumber;
-
- // Again, baseDomain should be identical to Domain for BrickEngine,
- // since no subsetting has occurred.
-
- Range<2> d10 = dupAr.domain();
- testStatus = (d10[0].first() == IJ[0].first()) &&
- (d10[0].last() == IJ[0].last()) &&
- (d10[0].length() == IJ[0].length()) &&
- (d10[1].first() == IJ[1].first()) &&
- (d10[1].last() == IJ[1].last()) &&
- (d10[1].length() == IJ[1].length());
-
- Range<3> d11 = ArToo.domain();
- testStatus = (d11[0].first() == IJK[0].first()) &&
- (d11[0].last() == IJK[0].last()) &&
- (d11[0].length() == IJK[0].length()) &&
- (d11[1].first() == IJK[1].first()) &&
- (d11[1].last() == IJK[1].last()) &&
- (d11[1].length() == IJK[1].length()) && testStatus;
-
-
- Range<6> d12 = Energy.domain();
- testStatus = (d12[3].first() == star[3].first()) &&
- (d12[3].last() == star[3].last()) &&
- (d12[3].length() == star[3].length()) &&
- (d12[5].first() == star[5].first()) &&
- (d12[5].last() == star[5].last()) &&
- (d12[5].length() == star[5].length()) && testStatus;
-
- reportResults(testNumber,"baseDomain() accessor; non-std type",
- testStatus);
-
-
- //----------------------------------------------------------
- // test 29: BrickEngine makeOwnCopy() function, non-std type
- //----------------------------------------------------------
-
- ++testNumber;
- Ne.makeOwnCopy();
- Atom NeTemp(7.1,7.2,7.3);
- Ne(3,-4,9) = NeTemp;
-
- diff = zero;
- for (int i=Imin; i<Imax+1; i++)
- for (int j=Jmin; j<Jmax+1; j++)
- for (int k=Kmin; k<Kmax+1; k++) {
- if(i==3 && j==-4 && k==9)
- diff = fabs(Ne(3,-4,9).amu() - 7.3) + fabs(ArToo(3,-4,9).amu() - 5*4.44);
- else
- diff += fabs(Ne(Loc<3>(i,j,k)).amu() - ArToo.read(i,j,k).amu());
- }
-
- testStatus = (diff == zero);
- reportResults(testNumber,"makeOwnCopy() function; non-std type",
- testStatus);
-
-
-
- // ************************* BrickViewEngine ****************************
-
- cout << "\n\n BrickViewEngine" << endl;
- cout << " ---------------\n" << endl;
-
- typedef Engine<2,float,BrickView<6,false> > float2DV2_t;
- typedef Engine<3,float,BrickView<3,true> > float3DV1_t;
- typedef Engine<3,float,BrickView<3,false> > float3DV2_t;
- typedef Engine<4,float,BrickView<6,false> > float4DV3_t;
- typedef Engine<2,double,BrickView<2,true> > double2DV1_t;
- typedef Engine<2,double,BrickView<2,false> > double2DV2_t;
- typedef Engine<6,int,BrickView<6,true> > int6DV1_t;
- typedef Engine<7,int,BrickView<7,false> > int7DV2_t;
-
-
-
- //--------------------------------------------------------------------
- // test 30: BrickViewEngine required POOMA typedefs properly exported?
- //--------------------------------------------------------------------
-
- ++testNumber;
-
- // first construct stride-1 and non-stride-1 Views of 3D cube and
- // 2D square-based Engines
-
- Interval<1> line1(7,16);
- Interval<1> line2(-1,4);
- Interval<1> line3(11,16);
- Interval<1> line4(-4,5);
- Range<1> line5(0,6,2);
- Range<1> line6(-1,5,3);
- Range<1> line7(7,15,4);
-
- Interval<2> square(line,line1); // 10x10 Interval
- Interval<3> cube(line,line4,line1); // 10x10x10 Interval
-
- // square1 and rectangle2 are associated with Boolean 'true' in
- // BrickView, since both of these 2D Ranges have a (unit-stride)
- // Interval, line2, as their first Range component. Note that
- // this is true for rectangle2 even though its second Range component,
- // line7, has non-unit stride (4). By contrast, rectangle1 is
- // associated with Boolean 'false' in BrickView, since its first
- // Range component, line5, has stride 2.
-
- Interval<2> square1(line2,line3); // 6x6 "T" subset of square
- Range<2> rectangle1(line5,line3); // 4x6 "F" subset of square
- Range<2> rectangle2(line2,line7); // 6x3 "T" subset of square
-
- Interval<3> cube1(line2,line2,line3); // 6x6x6 "T" subset of cube
- Range<3> box1(line5,line6,line7); // 4x3x3 "F" subset of cube
- Range<3> box2(line2,line6,line7); // 6x3x3 "T" subset of cube
-
- Engine2Dd_t Q(square);
- Engine3Df_t R(cube);
-
- double2DV1_t BV1(Q,square1);
- double2DV2_t BV2(Q,rectangle1);
- double2DV2_t BV3(Q,rectangle2);
-
- float3DV1_t BV4(R,cube1);
- float3DV2_t BV5(R,box1);
- float3DV2_t BV6(R,box2);
-
- // populate Q with data
-
- Imin = line.first();
- Ilen = line.length();
- Imax = Imin + Ilen;
- Jmin = line1.first();
- Jmax = line1.last() + 1;
- Jlen = Jmax - Jmin;
-
- for (int i = Imin; i < Imax; i++)
- for (int j = Jmin; j < Jmax; j++)
- Q(i,j) = (i+Ry)*j + 1.1;
-
- // populate R with data
-
- int Klen;
-
- Imin = cube[0].first();
- Ilen = cube[0].length();
- Imax = Imin + Ilen;
- Jmin = cube[1].first();
- Jmax = cube[1].last() + 1;
- Jlen = Jmax - Jmin;
- Kmin = cube[2].first();
- Kmax = cube[2].last() + 1;
- Klen = Kmax - Kmin;
-
- for (int i = Imin; i < Imax; i++)
- for (int j = Jmin; j < Jmax; j++)
- for (int k = Kmin; k < Kmax; k++)
- R(i,j,k) = i*1.1 + j*2.2 + k*3.3;
-
-
- // now start testing various typedefs using the above BrickViewEngines
-
- // This_t
-
- {
- typedef float3DV1_t::This_t Try_t;
- typedef float3DV1_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- {
- typedef float3DV2_t::This_t Try_t;
- typedef float3DV2_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV1_t::This_t Try_t;
- typedef double2DV1_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::This_t Try_t;
- typedef double2DV2_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
-
- // Engine_t
-
- {
- typedef float3DV1_t::Engine_t Try_t;
- typedef float3DV1_t::This_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef float3DV2_t::Engine_t Try_t;
- typedef float3DV2_t::This_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV1_t::Engine_t Try_t;
- typedef double2DV1_t::This_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::Engine_t Try_t;
- typedef double2DV2_t::This_t Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
-
- // Domain_t
-
- {
- typedef float3DV1_t::Domain_t Try_t;
- typedef Interval<3> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef float3DV2_t::Domain_t Try_t;
- typedef Interval<3> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::Domain_t Try_t;
- typedef Interval<2> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::Domain_t Try_t;
- typedef Interval<2> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- reportResults(testNumber,"exported typedefs This_t, Engine_t, Domain_t",
- testStatus);
-
-
- //----------------------------------------------------------------
- // test 31: additional required POOMA typedefs for BrickViewEngine
- //----------------------------------------------------------------
-
- ++testNumber;
-
- // BaseDomain_t
-
- {
- typedef float3DV1_t::BaseDomain_t Try_t;
- typedef Range<3> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- {
- typedef float3DV2_t::BaseDomain_t Try_t;
- typedef Range<3> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV1_t::BaseDomain_t Try_t;
- typedef Range<2> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::BaseDomain_t Try_t;
- typedef Range<2> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- // Element_t
-
- {
- typedef float3DV1_t::Element_t Try_t;
- typedef float Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef float3DV2_t::Element_t Try_t;
- typedef float Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV1_t::Element_t Try_t;
- typedef double Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::Element_t Try_t;
- typedef double Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- reportResults(testNumber,"exported typedefs BaseDomain_t, Element_t",
- testStatus);
-
-
- //----------------------------------------------------------------
- // test 32: still more required POOMA typedefs for BrickViewEngine
- //----------------------------------------------------------------
-
- ++testNumber;
-
- // ElementRef_t
-
- {
- typedef float3DV1_t::ElementRef_t Try_t;
- typedef float& Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- {
- typedef float3DV2_t::ElementRef_t Try_t;
- typedef float& Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV1_t::ElementRef_t Try_t;
- typedef double& Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::ElementRef_t Try_t;
- typedef double& Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- // Tag_t
-
- {
- typedef float3DV1_t::Tag_t Try_t;
- typedef BrickView<3,true> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef float3DV2_t::Tag_t Try_t;
- typedef BrickView<3,false> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV1_t::Tag_t Try_t;
- typedef BrickView<2,true> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- {
- typedef double2DV2_t::Tag_t Try_t;
- typedef BrickView<2,false> Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result && testStatus;
- }
-
- reportResults(testNumber,"exported typedefs ElementRef_t, Tag_t",
- testStatus);
-
-
- //----------------------------------------------------
- // test 33: BrickViewEngine Range/Interval constructor
- //----------------------------------------------------
-
- ++testNumber;
-
- //-------------
- // square tests
- //-------------
-
- // BV1...
-
- Imin = square1[0].first();
- Jmin = square1[1].first();
- Ilen = square1[0].length();
- Jlen = square1[1].length();
- Istr = square1[0].stride();
- Jstr = square1[1].stride();
-
- diff = zero;
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- diff += Q.read(Iind,Jind) - BV1(Loc<2>(i,j));
- }
- testStatus = (diff == zero);
-
- // BV2...
-
- Imin = rectangle1[0].first();
- Jmin = rectangle1[1].first();
- Ilen = rectangle1[0].length();
- Jlen = rectangle1[1].length();
- Istr = rectangle1[0].stride();
- Jstr = rectangle1[1].stride();
-
- diff = zero;
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- diff += Q.read(Iind,Jind) - BV2(Loc<2>(i,j));
- }
- testStatus = (diff == zero) && testStatus;
-
- // BV3...
-
- Imin = rectangle2[0].first();
- Jmin = rectangle2[1].first();
- Ilen = rectangle2[0].length();
- Jlen = rectangle2[1].length();
- Istr = rectangle2[0].stride();
- Jstr = rectangle2[1].stride();
-
- diff = zero;
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- diff += Q.read(Iind,Jind) - BV3(Loc<2>(i,j));
- }
- testStatus = (diff == zero) && testStatus;
-
-
- //-----------
- // cube tests
- //-----------
-
- // BV4...
-
- int Kstr;
-
- Imin = cube1[0].first();
- Jmin = cube1[1].first();
- Kmin = cube1[2].first();
- Ilen = cube1[0].length();
- Jlen = cube1[1].length();
- Klen = cube1[2].length();
- Istr = cube1[0].stride();
- Jstr = cube1[1].stride();
- Kstr = cube1[2].stride();
-
- diff = zero;
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++)
- for (int k = 0; k < Klen; k++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- int Kind = Kmin + k*Kstr;
- diff += R.read(Iind,Jind,Kind) - BV4(Loc<3>(i,j,k));
- }
- testStatus = (diff == zero) && testStatus;
-
- // BV5...
-
- Imin = box1[0].first();
- Jmin = box1[1].first();
- Kmin = box1[2].first();
- Ilen = box1[0].length();
- Jlen = box1[1].length();
- Klen = box1[2].length();
- Istr = box1[0].stride();
- Jstr = box1[1].stride();
- Kstr = box1[2].stride();
-
- diff = zero;
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++)
- for (int k = 0; k < Klen; k++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- int Kind = Kmin + k*Kstr;
- diff += R.read(Iind,Jind,Kind) - BV5(Loc<3>(i,j,k));
- }
-
- testStatus = (diff == zero) && testStatus;
-
- // BV6...
-
- Imin = box2[0].first();
- Jmin = box2[1].first();
- Kmin = box2[2].first();
- Ilen = box2[0].length();
- Jlen = box2[1].length();
- Klen = box2[2].length();
- Istr = box2[0].stride();
- Jstr = box2[1].stride();
- Kstr = box2[2].stride();
-
- diff = zero;
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++)
- for (int k = 0; k < Klen; k++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- int Kind = Kmin + k*Kstr;
- diff += R(Iind,Jind,Kind) - BV6(i,j,k);
- }
-
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber,"Range<Dim> constructor",testStatus);
-
-
- //-------------------------------------------------------
- // test 34: Range/Interval constructor, NewEngine struct
- //-------------------------------------------------------
-
- ++testNumber;
-
- {
- typedef NewEngine<Engine3Df_t,Range<3> >::Type_t Try_t;
- typedef Engine<3,float,BrickView<3,false> > Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //-------------------------------------------------------
- // test 35: Range/Interval constructor, domain() accessor
- //-------------------------------------------------------
-
- ++testNumber;
-
- // 3D, UnitStride = F
-
- float3DV2_t BV7(BV5);
-
- // the Domain returned by this accessor is always an Interval, because
- // the View is, by definition, stride-1 in all dimensions, with first-index
- // = 0 in all dimensions. Thus, box4 should = box3, since these are stride-1
- // Intervals describing the identical View, but box3 is not = box1; box1 is the
- // not-necessarily-stride-1 Range corresponding to box3, and its indices are
- // expressed in terms of the parent Domain [cube]'s indices.
-
- Interval<3> box3 = BV5.domain();
- Interval<3> box4 = BV7.domain();
-
- testStatus = (box4[0].first() == box3[0].first()) &&
- (box4[0].last() == box3[0].last()) &&
- (box4[0].length() == box3[0].length()) &&
- (box4[1].first() == box3[1].first()) &&
- (box4[1].last() == box3[1].last()) &&
- (box4[1].length() == box3[1].length()) &&
- (box4[2].first() == box3[2].first()) &&
- (box4[2].last() == box3[2].last()) &&
- (box4[2].length() == box3[2].length());
-
- // 2D, UnitStride = T
-
- double2DV1_t BV8(BV1);
- Interval<2> square2 = BV8.domain();
-
- // even though BV1's Domain (square1) is already Interval<2>, still
- // need to compute its domain() which will be offset to start with index 0.
-
- Interval<2> square3 = BV1.domain();
-
- testStatus = (square2[0].first() == square3[0].first()) &&
- (square2[0].last() == square3[0].last()) &&
- (square2[0].length() == square3[0].length()) &&
- (square2[1].first() == square3[1].first()) &&
- (square2[1].last() == square3[1].last()) &&
- (square2[1].length() == square3[1].length()) && testStatus;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //-----------------------------------------------------------
- // test 36: Range/Interval constructor, baseDomain() accessor
- //-----------------------------------------------------------
-
- ++testNumber;
-
- // 3D, UnitStride = F
-
- Range<3> cube3 = BV7.baseDomain();
-
- testStatus = (cube3[0].first() == box1[0].first()) &&
- (cube3[0].last() == box1[0].last()) &&
- (cube3[0].length() == box1[0].length()) &&
- (cube3[1].first() == box1[1].first()) &&
- (cube3[1].last() == box1[1].last()) &&
- (cube3[1].length() == box1[1].length()) &&
- (cube3[2].first() == box1[2].first()) &&
- (cube3[2].last() == box1[2].last()) &&
- (cube3[2].length() == box1[2].length());
-
- // 2D, UnitStride = T
-
- Range<2> box5 = BV8.baseDomain();
-
- testStatus = (box5[0].first() == square1[0].first()) &&
- (box5[0].last() == square1[0].last()) &&
- (box5[0].length() == square1[0].length()) &&
- (box5[1].first() == square1[1].first()) &&
- (box5[1].last() == square1[1].last()) &&
- (box5[1].length() == square1[1].length()) && testStatus;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //--------------------------------------------------------
- // test 37: Range/Interval constructor, strides() accessor
- //--------------------------------------------------------
-
- ++testNumber;
-
- // tests that second-guess the implementation, to illustrate
- // the meaning of the BrickViewEngine strides() accessor
- // (just this once)...
-
- // 3D, UnitStride = F
-
- const int *NT = BV7.strides();
-
- testStatus = true;
- for(int i = 0; i < 3; i++) {
- nomStrides[i] = R.strides()[i] * box1[i].stride();
- testStatus = (NT[i] == nomStrides[i]) && testStatus;
- }
-
- // 2D, UnitStride = T
-
- NT = BV8.strides();
-
- for(int i = 0; i < 2; i++) {
- nomStrides[i] = Q.strides()[i] * square1[i].stride();
- testStatus = (NT[i] == nomStrides[i]) && testStatus;
- }
-
-
- // the 'real' tests, illustrating how the BrickView strides()
- // accessor makes it possible to sequentially identify the subset
- // indices from the parent Domain.
-
- // 3D, UnitStride = F
-
- // create linear-indexing array RR
-
- Imin = R.domain()[0].first(); Imax = R.domain()[0].last();
- Jmin = R.domain()[1].first(); Jmax = R.domain()[1].last();
- Kmin = R.domain()[2].first(); Kmax = R.domain()[2].last();
-
- int sizeRR = R.domain()[0].length()*R.domain()[1].length()*R.domain()[2].length();
- float* RR = new float[sizeRR];
-
- for (int k = Kmin; k < Kmax+1; k++)
- for (int j = Jmin; j < Jmax+1; j++)
- for (int i = Imin; i < Imax+1; i++) {
- int in = (i-Imin); int jn = (j-Jmin); int kn = (k-Kmin);
- int ind = kn*R.domain()[1].length()*R.domain()[2].length() +
- jn*R.domain()[1].length() + in;
- RR[ind] = R(i,j,k);
- }
-
- // verify that using strides() to index into the linear version of
- // BrickEngine R gives the same result as BrickView BV7 with its
- // unit strides.
-
- NT = BV7.strides();
-
- Imax = BV7.domain()[0].last();
- Jmax = BV7.domain()[1].last();
- Kmax = BV7.domain()[2].last();
-
- // compute differences between parent and subdomain first-index
-
- int deltI = BV7.baseDomain()[0].first() - R.domain()[0].first();
- int deltJ = BV7.baseDomain()[1].first() - R.domain()[1].first();
- int deltK = BV7.baseDomain()[2].first() - R.domain()[2].first();
-
- // compute linear-indexing offset
-
- int off = deltK*R.domain()[1].length()*R.domain()[2].length() +
- deltJ*R.domain()[1].length() + deltI;
-
- diff = zero;
- for (int k = 0; k < Kmax+1; k++)
- for (int j = 0; j < Jmax+1; j++)
- for (int i = 0; i < Imax+1; i++) {
- int ind = i*NT[0] + j*NT[1] + k*NT[2] + off;
- diff += fabs(RR[ind] - BV7(i,j,k));
- }
-
- testStatus = (diff == zero) && testStatus;
-
-
- // 2D, UnitStride=T
-
- // create linear-indexing array QQ
-
- Imin = Q.domain()[0].first(); Imax = Q.domain()[0].last();
- Jmin = Q.domain()[1].first(); Jmax = Q.domain()[1].last();
-
- int sizeQQ = Q.domain()[0].length()*Q.domain()[1].length();
- float* QQ = new float[sizeQQ];
-
- for (int j = Jmin; j < Jmax+1; j++)
- for (int i = Imin; i < Imax+1; i++) {
- int in = (i-Imin); int jn = (j-Jmin);
- int ind = jn*Q.domain()[1].length() + in;
- QQ[ind] = Q(i,j);
- }
-
-
- // verify that using strides() to index into the linear version of
- // BrickEngine Q gives the same result as BrickView BV8 with its unit
- // strides (if the different starting points for the indexing underlying
- // the two Engines) is properly accounted for).
-
- NT = BV8.strides();
-
- Imax = BV8.domain()[0].last();
- Jmax = BV8.domain()[1].last();
-
- // compute differences between parent and subdomain first-index
-
- deltI = BV8.baseDomain()[0].first() - Q.domain()[0].first();
- deltJ = BV8.baseDomain()[1].first() - Q.domain()[1].first();
-
- // compute linear-indexing offset
-
- off = deltJ*Q.domain()[1].length() + deltI;
-
- diff = zero;
- for (int j = 0; j < Jmax+1; j++)
- for (int i = 0; i < Imax+1; i++) {
- int ind = i*NT[0] + j*NT[1] + off;
- diff += fabs(QQ[ind] - BV8(i,j));
- }
-
- testStatus = (diff == zero) && testStatus;
-
-
- // extra test for 3D, UnitStride = F (different Engine, just for fun)
-
- // parent domain
-
- Interval<1> U1(4,10); // length 7
- Interval<1> U2(0,4); // length 5
- Interval<1> U3(-2,0); // length 3
- Interval<3> D(U1,U2,U3);
- Engine3Df_t S(D);
-
- int sizeS2 = U1.length()*U2.length()*U3.length();
- float *S2 = new float[sizeS2];
-
- Imin = U1.first(); Imax = U1.last();
- Jmin = U2.first(); Jmax = U2.last();
- Kmin = U3.first(); Kmax = U3.last();
-
- // linearly-indexed version of BrickEngine to illustrate use of strides()
-
- for (int k = Kmin; k < Kmax+1; k++)
- for (int j = Jmin; j < Jmax+1; j++)
- for (int i = Imin; i < Imax+1; i++) {
- int in = (i-Imin); int jn = (j-Jmin); int kn = (k-Kmin);
- S(i,j,k) = in*1.1 + jn*2.2 + kn*3.3;
- int ind = kn*U1.length()*U2.length() + jn*U1.length() + in;
- S2[ind] = S(i,j,k);
- }
-
- // sub-domain
-
- Range<1> V1(4,10,2); // length 4
- Range<1> V2(0,4,2); // length 3
- Range<1> V3(-2,0,2); // length 2
-
- Range<3> F(V1,V2,V3);
- float3DV2_t BV9(S,F);
-
- NT = BV9.strides();
-
- // this 'check' once again second-guesses the implementation
- // (ok, this is _really_ the last time!)
-
- testStatus = true;
- for(int i = 0; i < 3; i++) {
- nomStrides[i] = S.strides()[i] * F[i].stride();
- testStatus = (NT[i] == nomStrides[i]) && testStatus;
- }
-
- // true check: verify that using strides() to index into the linear version
- // of BrickEngine S gives the same result as BrickView BV9 with unit strides.
-
- Imax = BV9.domain()[0].last();
- Jmax = BV9.domain()[1].last();
- Kmax = BV9.domain()[2].last();
-
- // compute differences between parent and subdomain first-index
-
- deltI = BV9.baseDomain()[0].first() - S.domain()[0].first();
- deltJ = BV9.baseDomain()[1].first() - S.domain()[1].first();
- deltK = BV9.baseDomain()[2].first() - S.domain()[2].first();
-
- // compute linear-indexing offset
-
- off = deltK*S.domain()[1].length()*S.domain()[2].length() +
- deltJ*S.domain()[1].length() + deltI;
-
- diff = zero;
- for (int k = 0; k < Kmax+1; k++)
- for (int j = 0; j < Jmax+1; j++)
- for (int i = 0; i < Imax+1; i++) {
- int ind = i*NT[0] + j*NT[1] + k*NT[2] + off;
- diff += fabs(S2[ind] - BV9(i,j,k));
- }
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //----------------------------------------------------------
- // test 38: BrickViewEngine SliceRange<Dim2,Dim> constructor
- //----------------------------------------------------------
-
- ++testNumber;
-
- // SliceRange<Dim2,Dim> is a Domain which stores a total
- // Domain (of dimension Dim2) and a slice Domain (of dimension
- // Dim < Dim2). Although in general both Domains in a SliceRange
- // can be Range objects, here the Dim2 Domain must be an Interval
- // since it corresponds to the Domain of a BrickEngine. The
- // Dim Range is the one actually used in the constructor; the
- // Dim2 Range is implicitly known through the BrickEngine.
-
- // construct the parent Interval/Engine for the SliceRange/View
-
- Interval<6> IA6(I0,IJK,J0,Balmer);
- Engine6Df_t B1(IA6);
-
- // get 6D Interval limits
-
- imin = I0.first();
- imax = I0.last();
- jmin = IJK[0].first();
- jmax = IJK[0].last();
- kmin = IJK[1].first();
- kmax = IJK[1].last();
- int lmin = IJK[2].first();
- int lmax = IJK[2].last();
- int mmin = J0.first();
- int mmax = J0.last();
- int nmin = Balmer.first();
- int nmax = Balmer.last();
-
- // assign BrickEngine values
-
- for(int i = imin; i < imax+1; i++)
- for(int j = jmin; j < jmax+1; j++)
- for(int k = kmin; k < kmax+1; k++)
- for(int l = lmin; l < lmax+1; l++)
- for(int m = mmin; m < mmax+1; m++)
- for(int n = nmin; n < nmax+1; n++)
- B1(i,j,k,l,m,n) = i*1.1 + j*2.2 + k*3.3 + l*4.4 + m*5.5 + n*6.6;
-
- // define typedefs for the SliceRange
-
- typedef NewDomain5<Loc<1>, int, AllDomain<2>, Interval<1>, Range<1> > ND1_t;
- typedef ND1_t::SliceType_t ST1_t;
-
- // construct the SliceRange, making sure that it is a true subset of
- // parent Interval IA6
-
- ST1_t SR6;
-
- int ll = -2;
- Loc<1> L1(ll); // subset of I0
- int ii = 5; // subset of I
- AllDomain<2> A2; // subset of JK part of IJK (wildcard)
- Interval<1> JJ0(7,10); // subset of J0
- Range<1> B0(3,15,3); // subset of Balmer
-
- ND1_t::fillSlice(SR6,IA6,L1,ii,A2,JJ0,B0);
-
- // finally, construct a BrickViewEngine based on SliceRange6
-
- testStatus = (SR6.sliceDimensions == 4);
- float4DV3_t BV10(B1,SR6);
-
- // check values
-
- int Lmin; int Llen; int Lstr;
- Range<6> d14 = BV10.baseDomain();
-
- Imin = d14[2].first();
- Jmin = d14[3].first();
- Kmin = d14[4].first();
- Lmin = d14[5].first();
- Ilen = d14[2].length();
- Jlen = d14[3].length();
- Klen = d14[4].length();
- Llen = d14[5].length();
- Istr = d14[2].stride();
- Jstr = d14[3].stride();
- Kstr = d14[4].stride();
- Lstr = d14[5].stride();
-
- diff = zero;
- for(int i = 0; i < Ilen; i++)
- for(int j = 0; j < Jlen; j++)
- for(int k = 0; k < Klen; k++)
- for(int l = 0; l < Llen; l++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- int Kind = Kmin + k*Kstr;
- int Lind = Lmin + l*Lstr;
- diff += fabs(B1(ll,ii,Iind,Jind,Kind,Lind) - BV10(i,j,k,l));
- }
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber,"SliceRange<Dim2,Dim> constructor",
- testStatus);
-
-
- //-------------------------------------------------------------
- // test 39: SliceRange<Dim2,Dim> constructor, NewEngine struct
- //-------------------------------------------------------------
-
- ++testNumber;
-
- {
- typedef NewEngine<Engine6Df_t,ST1_t>::Type_t Try_t;
- typedef Engine<4,float,BrickView<6,false> > Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //--------------------------------------------------------------
- // test 40: SliceRange<Dim2,Dim> constructor, domain() accessor
- //--------------------------------------------------------------
-
- ++testNumber;
-
- Interval<4> d13 = BV10.domain();
-
- testStatus = (d13[0].first() == 0) &&
- (d13[0].last() == 6) &&
- (d13[0].length() == 7) &&
- (d13[1].first() == 0) &&
- (d13[1].last() == 12) &&
- (d13[1].length() == 13) &&
- (d13[2].first() == 0) &&
- (d13[2].last() == 3) &&
- (d13[2].length() == 4) &&
- (d13[3].first() == 0) &&
- (d13[3].last() == 4) &&
- (d13[3].length() == 5);
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //-----------------------------------------------------------------
- // test 41: SliceRange<Dim2,Dim> constructor, baseDomain() accessor
- //-----------------------------------------------------------------
-
- ++testNumber;
-
- testStatus = (d14[0].first() == -2) &&
- (d14[0].last() == -2) &&
- (d14[0].length() == 1) &&
- (d14[1].first() == 5) &&
- (d14[1].last() == 5) &&
- (d14[1].length() == 1) &&
- (d14[2].first() == -6) &&
- (d14[2].last() == 0) &&
- (d14[2].length() == 7) &&
- (d14[3].first() == 2) &&
- (d14[3].last() == 14) &&
- (d14[3].length() == 13) &&
- (d14[4].first() == 7) &&
- (d14[4].last() == 10) &&
- (d14[4].length() == 4) &&
- (d14[5].first() == 3) &&
- (d14[5].last() == 15) &&
- (d14[5].length() == 5);
-
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //--------------------------------------------------------------
- // test 42: SliceRange<Dim2,Dim> constructor, strides() accessor
- //--------------------------------------------------------------
-
- ++testNumber;
-
- // create linear-indexing array BB1
-
- int Lmax; int Mmin; int Mmax; int Nmin; int Nmax;
- Imin = B1.domain()[0].first(); Imax = B1.domain()[0].last();
- Jmin = B1.domain()[1].first(); Jmax = B1.domain()[1].last();
- Kmin = B1.domain()[2].first(); Kmax = B1.domain()[2].last();
- Lmin = B1.domain()[3].first(); Lmax = B1.domain()[3].last();
- Mmin = B1.domain()[4].first(); Mmax = B1.domain()[4].last();
- Nmin = B1.domain()[5].first(); Nmax = B1.domain()[5].last();
-
- int sizeBB1 = B1.domain()[0].length()*B1.domain()[1].length()*B1.domain()[2].length() *
- B1.domain()[3].length()*B1.domain()[4].length()*B1.domain()[5].length();
- float* BB1 = new float[sizeBB1];
-
- int b10 = B1.domain()[0].length();
- int b11 = B1.domain()[1].length();
- int b12 = B1.domain()[2].length();
- int b13 = B1.domain()[3].length();
- int b14 = B1.domain()[4].length();
-
- for (int n = Nmin; n < Nmax+1; n++)
- for (int m = Mmin; m < Mmax+1; m++)
- for (int l = Lmin; l < Lmax+1; l++)
- for (int k = Kmin; k < Kmax+1; k++)
- for (int j = Jmin; j < Jmax+1; j++)
- for (int i = Imin; i < Imax+1; i++) {
- int in = (i-Imin); int jn = (j-Jmin); int kn = (k-Kmin);
- int ln = (l-Lmin); int mn = (m-Mmin); int nn = (n-Nmin);
- int ind = nn*b10*b11*b12*b13*b14 + mn*b10*b11*b12*b13 +
- ln*b10*b11*b12 + kn*b10*b11 + jn*b10 + in;
- BB1[ind] = B1(i,j,k,l,m,n);
- }
-
- NT = BV10.strides();
-
- Imax = BV10.domain()[0].last();
- Jmax = BV10.domain()[1].last();
- Kmax = BV10.domain()[2].last();
- Lmax = BV10.domain()[3].last();
-
- // compute differences between parent and subdomain first-index
-
- deltI = BV10.baseDomain()[0].first() - B1.domain()[0].first();
- deltJ = BV10.baseDomain()[1].first() - B1.domain()[1].first();
- deltK = BV10.baseDomain()[2].first() - B1.domain()[2].first();
- int deltL = BV10.baseDomain()[3].first() - B1.domain()[3].first();
- int deltM = BV10.baseDomain()[4].first() - B1.domain()[4].first();
- int deltN = BV10.baseDomain()[5].first() - B1.domain()[5].first();
-
- // compute linear-indexing offset
-
- off = deltN*b10*b11*b12*b13*b14 + deltM*b10*b11*b12*b13 +
- deltL*b10*b11*b12 + deltK*b10*b11 + deltJ*b10 + deltI;
-
- diff = zero;
- for (int l = 0; l < Lmax+1; l++)
- for (int k = 0; k < Kmax+1; k++)
- for (int j = 0; j < Jmax+1; j++)
- for (int i = 0; i < Imax+1; i++) {
- int ind = i*NT[0] + j*NT[1] + k*NT[2] + l*NT[3] + off;
- diff += fabs(BB1[ind] - BV10(i,j,k,l));
- }
-
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-------------------------------------------------------------
- // test 43: BrickViewEngine SliceInterval<Dim2,Dim> constructor
- //-------------------------------------------------------------
-
- ++testNumber;
-
- // similar to SliceRange<Dim2,Dim> constructor, but now the 1D
- // subDomains comprising the Slice must all be Intervals.
- //
- // test using B1 again, but this time take 2D slice instead of 4D.
-
- typedef NewDomain4<AllDomain<1>, Loc<3>, Interval<1>, Loc<1> > ND2_t;
- typedef ND2_t::SliceType_t ST2_t;
-
- ST2_t SI6;
- AllDomain<1> A1; // subset of I0
- Loc<3> L3(2,-4,12); // subset of IJK
- L1 = 18; // subset of Balmer
-
- ND2_t::fillSlice(SI6,IA6,A1,L3,JJ0,L1);
- testStatus = (SI6.sliceDimensions == 2);
-
- float2DV2_t BV12(B1,SI6);
- Interval<6> d15 = BV12.baseDomain();
-
- Imin = d15[0].first();
- Jmin = d15[4].first();
- Ilen = d15[0].length();
- Jlen = d15[4].length();
- Istr = d15[0].stride();
- Jstr = d15[4].stride();
-
- diff = zero;
- for(int i = 0; i < Ilen; i++)
- for(int j = 0; j < Jlen; j++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- diff += fabs(B1(Iind,2,-4,12,Jind,18) - BV12(i,j));
- }
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber,"SliceInterval<Dim2,Dim> constructor",
- testStatus);
-
-
- //----------------------------------------------------------------
- // test 44: SliceInterval<Dim2,Dim> constructor, NewEngine struct
- //----------------------------------------------------------------
-
- ++testNumber;
-
- {
- typedef NewEngine<Engine6Df_t,ST2_t>::Type_t Try_t;
- typedef Engine<2,float,BrickView<6,false> > Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //----------------------------------------------------------------
- // test 45: SliceInterval<Dim2,Dim> constructor, domain() accessor
- //----------------------------------------------------------------
-
- ++testNumber;
-
- Interval<2> d16 = BV12.domain();
- testStatus = (d16[0].first() == 0) &&
- (d16[0].last() == 6) &&
- (d16[0].length() == 7) &&
- (d16[1].first() == 0) &&
- (d16[1].last() == 3) &&
- (d16[1].length() == 4);
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //--------------------------------------------------------------------
- // test 46: SliceInterval<Dim2,Dim> constructor, baseDomain() accessor
- //--------------------------------------------------------------------
-
- ++testNumber;
-
- testStatus = (d15[0].first() == -3) &&
- (d15[0].last() == 3) &&
- (d15[0].length() == 7) &&
- (d15[1].first() == 2) &&
- (d15[1].last() == 2) &&
- (d15[1].length() == 1) &&
- (d15[2].first() == -4) &&
- (d15[2].last() == -4) &&
- (d15[2].length() == 1) &&
- (d15[3].first() == 12) &&
- (d15[3].last() == 12) &&
- (d15[3].length() == 1) &&
- (d15[4].first() == 7) &&
- (d15[4].last() == 10) &&
- (d15[4].length() == 4) &&
- (d15[5].first() == 18) &&
- (d15[5].last() == 18) &&
- (d15[5].length() == 1);
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //-----------------------------------------------------------------
- // test 47: SliceInterval<Dim2,Dim> constructor, strides() accessor
- //-----------------------------------------------------------------
-
- ++testNumber;
-
- NT = BV12.strides();
-
- Imax = BV12.domain()[0].last();
- Jmax = BV12.domain()[1].last();
-
- deltI = BV12.baseDomain()[0].first() - B1.domain()[0].first();
- deltJ = BV12.baseDomain()[1].first() - B1.domain()[1].first();
- deltK = BV12.baseDomain()[2].first() - B1.domain()[2].first();
- deltL = BV12.baseDomain()[3].first() - B1.domain()[3].first();
- deltM = BV12.baseDomain()[4].first() - B1.domain()[4].first();
- deltN = BV12.baseDomain()[5].first() - B1.domain()[5].first();
-
- off = deltN*b10*b11*b12*b13*b14 + deltM*b10*b11*b12*b13 +
- deltL*b10*b11*b12 + deltK*b10*b11 + deltJ*b10 + deltI;
-
- diff = zero;
- for (int j = 0; j < Jmax+1; j++)
- for (int i = 0; i < Imax+1; i++) {
- int ind = i*NT[0] + j*NT[1] + off;
- diff += fabs(BB1[ind] - BV12(i,j));
- }
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //------------------------------------------
- // test 48: BrickViewEngine Node constructor
- //------------------------------------------
-
- ++testNumber;
-
- // use simple Node as in test #10, built on Interval<6>
- // subset of star.
-
- Loc<5> gamma(5,11,4,8,12);
- Interval<6> symm(gamma,Interval<1>(5,9));
- Node<Interval<6> > kpt(-1,symm,0,0,0);
-
- // assign more interesting data to BZone than simple constant
-
- for(int i = 4; i < 13; i++)
- for(int j = 4; j < 13; j++)
- for(int k = 4; k < 13; k++)
- for(int l = 4; l < 13; l++)
- for(int m = 4; m < 13; m++)
- for(int n = 4; n < 13; n++)
- BZone(i,j,k,l,m,n) = i*2 + j*3 + k*4 + (l+m)*5 - n;
-
- int6DV1_t BV14(BZone,kpt);
-
- Interval<6> d17 = BV14.baseDomain();
-
- Imin = d17[5].first();
- Ilen = d17[5].length();
- Istr = d17[5].stride();
-
- diff = zero;
- for(int i = 0; i < 5; i++) {
- int Iind = Imin + i*Istr;
- diff += abs(BZone(5,11,4,8,12,Iind) - BV14.read(0,0,0,0,0,i));
- }
-
- testStatus = (diff == zero);
-
- reportResults(testNumber,"Node constructor",testStatus);
-
-
- //---------------------------------------------
- // test 49: Node constructor, NewEngine struct
- //---------------------------------------------
-
- ++testNumber;
-
- {
- typedef NewEngine<Engine6Di_t, Node<Interval<6> > >::Type_t Try_t;
- typedef Engine<6,int,BrickView<6,true> > Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //---------------------------------------------
- // test 50: Node constructor, domain() accessor
- //---------------------------------------------
-
- ++testNumber;
-
- Interval<6> d18 = BV14.domain();
- testStatus = (d18[0].first() == 0) &&
- (d18[0].last() == 0) &&
- (d18[0].length() == 1) &&
- (d18[1].first() == 0) &&
- (d18[1].last() == 0) &&
- (d18[1].length() == 1) &&
- (d18[2].first() == 0) &&
- (d18[2].last() == 0) &&
- (d18[2].length() == 1) &&
- (d18[3].first() == 0) &&
- (d18[3].last() == 0) &&
- (d18[3].length() == 1) &&
- (d18[4].first() == 0) &&
- (d18[4].last() == 0) &&
- (d18[4].length() == 1) &&
- (d18[5].first() == 0) &&
- (d18[5].last() == 4) &&
- (d18[5].length() == 5);
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //-------------------------------------------------
- // test 51: Node constructor, baseDomain() accessor
- //-------------------------------------------------
-
- ++testNumber;
- testStatus = (d17[0].first() == 5) &&
- (d17[0].last() == 5) &&
- (d17[0].length() == 1) &&
- (d17[1].first() == 11) &&
- (d17[1].last() == 11) &&
- (d17[1].length() == 1) &&
- (d17[2].first() == 4) &&
- (d17[2].last() == 4) &&
- (d17[2].length() == 1) &&
- (d17[3].first() == 8) &&
- (d17[3].last() == 8) &&
- (d17[3].length() == 1) &&
- (d17[4].first() == 12) &&
- (d17[4].last() == 12) &&
- (d17[4].length() == 1) &&
- (d17[5].first() == 5) &&
- (d17[5].last() == 9) &&
- (d17[5].length() == 5);
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //----------------------------------------------
- // test 52: Node constructor, strides() accessor
- //----------------------------------------------
-
- ++testNumber;
-
- Imin = BZone.domain()[0].first(); Imax = BZone.domain()[0].last();
- Jmin = BZone.domain()[1].first(); Jmax = BZone.domain()[1].last();
- Kmin = BZone.domain()[2].first(); Kmax = BZone.domain()[2].last();
- Lmin = BZone.domain()[3].first(); Lmax = BZone.domain()[3].last();
- Mmin = BZone.domain()[4].first(); Mmax = BZone.domain()[4].last();
- Nmin = BZone.domain()[5].first(); Nmax = BZone.domain()[5].last();
-
- int sizeBZ2 = BZone.domain()[0].length()*BZone.domain()[1].length()*BZone.domain()[2].length() *
- BZone.domain()[3].length()*BZone.domain()[4].length()*BZone.domain()[5].length();
- float* BZ2 = new float[sizeBZ2];
-
- b10 = BZone.domain()[0].length();
- b11 = BZone.domain()[1].length();
- b12 = BZone.domain()[2].length();
- b13 = BZone.domain()[3].length();
- b14 = BZone.domain()[4].length();
-
- for (int n = Nmin; n < Nmax+1; n++)
- for (int m = Mmin; m < Mmax+1; m++)
- for (int l = Lmin; l < Lmax+1; l++)
- for (int k = Kmin; k < Kmax+1; k++)
- for (int j = Jmin; j < Jmax+1; j++)
- for (int i = Imin; i < Imax+1; i++) {
- int in = (i-Imin); int jn = (j-Jmin); int kn = (k-Kmin);
- int ln = (l-Lmin); int mn = (m-Mmin); int nn = (n-Nmin);
- int ind = nn*b10*b11*b12*b13*b14 + mn*b10*b11*b12*b13 +
- ln*b10*b11*b12 + kn*b10*b11 + jn*b10 + in;
- BZ2[ind] = BZone(i,j,k,l,m,n);
- }
-
- NT = BV14.strides();
- Imax = BV14.domain()[5].last();
-
- deltI = BV14.baseDomain()[0].first() - BZone.domain()[0].first();
- deltJ = BV14.baseDomain()[1].first() - BZone.domain()[1].first();
- deltK = BV14.baseDomain()[2].first() - BZone.domain()[2].first();
- deltL = BV14.baseDomain()[3].first() - BZone.domain()[3].first();
- deltM = BV14.baseDomain()[4].first() - BZone.domain()[4].first();
- deltN = BV14.baseDomain()[5].first() - BZone.domain()[5].first();
-
- off = deltN*b10*b11*b12*b13*b14 + deltM*b10*b11*b12*b13 +
- deltL*b10*b11*b12 + deltK*b10*b11 + deltJ*b10 + deltI;
-
- diff = zero;
- for (int i = 0; i < Imax+1; i++) {
- int ind = i*NT[5] + off;
- diff += fabs(BZ2[ind] - BV14(0,0,0,0,0,i));
- }
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-------------------------------------------
- // test 53: BrickViewEngine INode constructor
- //-------------------------------------------
-
- ++testNumber;
-
- // construct an INode from a Node
-
- Loc<1> alpha(10);
- Loc<3> beta(12,5,7);
- Interval<6> symmer(alpha,Interval<1>(10,12),point,beta);
- Node<Interval<6> > gvec(-1,symmer,0,0,0);
- INode<6> IN1(gvec);
- int6DV1_t BV16(BZone,IN1);
-
- Interval<6> d19 = BV16.baseDomain();
-
- Imin = d19[1].first();
- Ilen = d19[1].length();
- Istr = d19[1].stride();
-
- Jmin = d19[2].first();
- Jlen = d19[2].length();
- Jstr = d19[2].stride();
-
- diff = zero;
- for(int i = 0; i < Ilen+1; i++)
- for(int j = 0; j < Jlen+1; j++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- diff += abs(BZone.read(10,Iind,Jind,12,5,7) - BV16(0,i,j,0,0,0));
- }
- testStatus = (diff == zero);
-
- reportResults(testNumber,"INode constructor",testStatus);
-
-
- //---------------------------------------------
- // test 54: INode constructor, NewEngine struct
- //---------------------------------------------
-
- ++testNumber;
-
- {
- typedef NewEngine<Engine6Di_t, INode<6> >::Type_t Try_t;
- typedef Engine<6,int,BrickView<6,true> > Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //----------------------------------------------
- // test 55: INode constructor, domain() accessor
- //----------------------------------------------
-
- ++testNumber;
-
- Interval<6> d20 = BV16.domain();
- testStatus = (d20[0].first() == 0) &&
- (d20[0].last() == 0) &&
- (d20[0].length() == 1) &&
- (d20[1].first() == 0) &&
- (d20[1].last() == 2) &&
- (d20[1].length() == 3) &&
- (d20[2].first() == 0) &&
- (d20[2].last() == 8) &&
- (d20[2].length() == 9) &&
- (d20[3].first() == 0) &&
- (d20[3].last() == 0) &&
- (d20[3].length() == 1) &&
- (d20[4].first() == 0) &&
- (d20[4].last() == 0) &&
- (d20[4].length() == 1) &&
- (d20[5].first() == 0) &&
- (d20[5].last() == 0) &&
- (d20[5].length() == 1);
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //--------------------------------------------------
- // test 56: INode constructor, baseDomain() accessor
- //--------------------------------------------------
-
- ++testNumber;
-
- testStatus = (d19[0].first() == 10) &&
- (d19[0].last() == 10) &&
- (d19[0].length() == 1) &&
- (d19[1].first() == 10) &&
- (d19[1].last() == 12) &&
- (d19[1].length() == 3) &&
- (d19[2].first() == 4) &&
- (d19[2].last() == 12) &&
- (d19[2].length() == 9) &&
- (d19[3].first() == 12) &&
- (d19[3].last() == 12) &&
- (d19[3].length() == 1) &&
- (d19[4].first() == 5) &&
- (d19[4].last() == 5) &&
- (d19[4].length() == 1) &&
- (d19[5].first() == 7) &&
- (d19[5].last() == 7) &&
- (d19[5].length() == 1);
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //-----------------------------------------------
- // test 57: INode constructor, strides() accessor
- //-----------------------------------------------
-
- ++testNumber;
-
- NT = BV16.strides();
- Imax = BV16.domain()[1].last();
- Jmax = BV16.domain()[2].last();
-
- deltI = BV16.baseDomain()[0].first() - BZone.domain()[0].first();
- deltJ = BV16.baseDomain()[1].first() - BZone.domain()[1].first();
- deltK = BV16.baseDomain()[2].first() - BZone.domain()[2].first();
- deltL = BV16.baseDomain()[3].first() - BZone.domain()[3].first();
- deltM = BV16.baseDomain()[4].first() - BZone.domain()[4].first();
- deltN = BV16.baseDomain()[5].first() - BZone.domain()[5].first();
-
- // b10...b14 are the same as for Node, since the underlying BZone
- // BrickEngine is the same
-
- off = deltN*b10*b11*b12*b13*b14 + deltM*b10*b11*b12*b13 +
- deltL*b10*b11*b12 + deltK*b10*b11 + deltJ*b10 + deltI;
-
- diff = zero;
- for (int j = 0; j < Jmax+1; j++)
- for (int i = 0; i < Imax+1; i++) {
- int ind = i*NT[1] + j*NT[2] + off;
- diff += fabs(BZ2[ind] - BV16(0,i,j,0,0,0));
- }
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-----------------------------------------------------
- // test 58: BrickViewEngine BrickView/Range constructor
- //-----------------------------------------------------
-
- ++testNumber;
-
- // note: the nominally distinct case of BrickView/Interval
- // is not tested here.
-
- // Use the domain and subdomain of test #37 as the
- // starting point here. This is not the most general
- // test since the parent Engine Dim2 and subdomain Dim
- // happen to be equal here.
-
- Range<1> V4(4,6,2);
- Loc<1> L2(-2);
- Range<3> FF(V4,V2,L2);
-
- typedef NewEngine<float3DV2_t,Range<3> >::Type_t BVT1_t;
- BVT1_t BV21(BV9,FF);
-
- Range<3> d21 = BV21.baseDomain();
-
- Imin = d21[0].first();
- Jmin = d21[1].first();
- Kmin = d21[2].first();
- Ilen = d21[0].length();
- Jlen = d21[1].length();
- Klen = d21[2].length();
- Istr = d21[0].stride();
- Jstr = d21[1].stride();
- Kstr = d21[2].stride();
-
- diff = zero;
- for(int i = 0; i < Ilen; i++)
- for(int j = 0; j < Jlen; j++)
- for(int k = 0; k < Klen; k++) {
- int Iind = Imin + i*Istr;
- int Jind = Jmin + j*Jstr;
- int Kind = Kmin + k*Kstr;
- diff += fabs(S(Iind,Jind,Kind) - BV21(i,j,k));
- }
- testStatus = (diff == zero) && testStatus;
-
- reportResults(testNumber,"BrickView/Range constructor",
- testStatus);
-
-
- //-------------------------------------------------------
- // test 59: BrickView/Range constructor, NewEngine struct
- //-------------------------------------------------------
-
- ++testNumber;
-
- // test NewEngine for general case where Dim != Dim2
-
- {
- typedef NewEngine<float4DV3_t,Range<4> >::Type_t Try_t;
- typedef Engine<4,float,BrickView<6,false> > Correct_t;
- testStatus = TypeMatchTester<Try_t,Correct_t>::Result;
- }
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //--------------------------------------------------------
- // test 60: BrickView/Range constructor, domain() accessor
- //--------------------------------------------------------
-
- /*
- =====================================================================
- gam 12/8/98
- tests 60 and 61 inactivated following swh's comments of 12/7/98:
-
- I've looked at the BrickEngineTest and it doesn't look correct.
-
- Susan makes an engine called S with the domain
-
- [4:10:1][0:4:1][-2:0:1]
-
- since this is a Brick, this is also the baseDomain. She then makes a view
- called BV9 using the range
-
- [4:10:2][0:4:2][-2:0:2].
-
- So far, so good. BV9 has the domain (remember that views are Zero-based and
- unit stride)
-
- [0:3:1][0:2:1][0:1:1]
-
- and the base domain is the same as the range that formed it. Then, she tries
- to take a view of BV9, called BV21, using the range
-
- [4:6:2][0:4:2][-2:-2:1]
-
- This is bad since this range is outside the domain of BV9. Any test using
- BC21 is suspect, though a few miraculously pass.
-
- =====================================================================
-
- ++testNumber;
-
- Range<3> d22 = BV21.domain();
- testStatus = (d22[0].first() == 0) &&
- (d22[0].last() == 1) &&
- (d22[0].length() == 2) &&
- (d22[1].first() == 0) &&
- (d22[1].last() == 2) &&
- (d22[1].length() == 3) &&
- (d22[2].first() == 0) &&
- (d22[2].last() == 0) &&
- (d22[2].length() == 1);
-
- reportResults(testNumber," domain() accessor",testStatus);
-
- //------------------------------------------------------------
- // test 61: BrickView/Range constructor, baseDomain() accessor
- //------------------------------------------------------------
-
- ++testNumber;
-
- // the baseDomain is the domain with respect to the original
- // Brick's Domain. Here, the original Brick is S (see
- // test #37) which has a Domain [4:10:1,0:4:1,-2:0:1].
- // The values returned by baseDomain should therefore lie
- // within these limits.
- //
- // The baseDomain is computed in BrickEngine.h as follows:
- //
- // baseDomain_m[dt] = Range<1>(
- // base[dt].first() + domain[d0].first() * base[dt].stride(),
- // base[dt].first() + domain[d0].last() * base[dt].stride(),
- // domain[d0].stride() * base[dt].stride());
- //
- // base <--> the BrickViewEngines's base, in this example,
- // BV9.baseDomain() = [4:10:2,0:4:2,-2:0:2].
- //
- // domain <--> the Domain of the Range constructor argument, in this
- // example, FF.domain() = = [4:6:2,0:4:2,-2:-2:1].
- //
- // The above code therefore computes the baseDomain() for
- // the new BrickView as follows:
- //
- // 1st Dim: 4 + 4*2, 4 + 6*2, 2*2
- // 2nd Dim: 0 + 0*2, 0 + 4*2, 2*2
- // 3rd Dim: -2 + -2*2, -2 + -2*2, 1*2
- //
- // i.e., d21 = [12:16:4,0:8:4,-6:-6:2].
- //
- // Note that this says that the baseDomain of the View of a BrickView of
- // a Brick lies outside the baseDomain of the original Brick.
- //
- // Thus, either the implementation is incorrect, or else the interpretation
- // of this constructor used here is wrong, and thus not apparent from
- // the .h file alone. In that case, it should be carefully explained,
- // with examples, in the user documentation. It is likely that this
- // issue will be duplicated in all BrickViews constructed from another
- // BrickView and a Domain (eg., BrickView/SliceRange below).
-
- testStatus = (d21[0].first() == 4) &&
- (d21[0].last() == 6) &&
- (d21[0].length() == 2) &&
- (d21[1].first() == 0) &&
- (d21[1].last() == 4) &&
- (d21[1].length() == 3) &&
- (d21[2].first() == -2) &&
- (d21[2].last() == -2) &&
- (d21[2].length() == 1);
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
- =====================================================================
- gam: end of inactivated portion 12/8/98
- */
-
- /*---------- outlines for remaining constructor sub-tests -------------
-
- //---------------------------------------------------------
- // test 62: BrickView/Range constructor, strides() accessor
- //---------------------------------------------------------
-
- ++testNumber;
-
- // this test cannot be implemented until test #61 is resolved.
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //----------------------------------------------------------
- // test 63: BrickViewEngine BrickView/SliceRange constructor
- //----------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"BrickView/SliceRange constructor",
- testStatus);
-
-
- //------------------------------------------------------------
- // test 64: BrickView/SliceRange constructor, NewEngine struct
- //------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //-------------------------------------------------------------
- // test 65: BrickView/SliceRange constructor, domain() accessor
- //-------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //-----------------------------------------------------------------
- // test 66: BrickView/SliceRange constructor, baseDomain() accessor
- //-----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //--------------------------------------------------------------
- // test 67: BrickView/SliceRange constructor, strides() accessor
- //--------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-------------------------------------------------------------
- // test 68: BrickViewEngine BrickView/SliceInterval constructor
- //-------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"BrickView/SliceInterval constructor",
- testStatus);
-
-
- //---------------------------------------------------------------
- // test 69: BrickView/SliceInterval constructor, NewEngine struct
- //---------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //----------------------------------------------------------------
- // test 70: BrickView/SliceInterval constructor, domain() accessor
- //----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //--------------------------------------------------------------------
- // test 71: BrickView/SliceInterval constructor, baseDomain() accessor
- //--------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //-----------------------------------------------------------------
- // test 72: BrickView/SliceInterval constructor, strides() accessor
- //-----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-----------------------------------------------------
- // test 73: BrickViewEngine BrickView/Inode constructor
- //-----------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"BrickView/Inode constructor",
- testStatus);
-
-
- //-------------------------------------------------------
- // test 74: BrickView/Inode constructor, NewEngine struct
- //-------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //--------------------------------------------------------
- // test 75: BrickView/INode constructor, domain() accessor
- //--------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //------------------------------------------------------------
- // test 76: BrickView/INode constructor, baseDomain() accessor
- //------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //---------------------------------------------------------
- // test 77: BrickView/Inode constructor, strides() accessor
- //---------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-------------------------------------------------------------
- // test 78: BrickViewEngine MultiPatch/INode constructor
- //-------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"MultiPatch/Inode constructor",
- testStatus);
-
-
- //---------------------------------------------------------------
- // test 79: MultiPatch/Inode constructor, NewEngine struct
- //---------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //----------------------------------------------------------------
- // test 80: MultiPatch/INode constructor, domain() accessor
- //----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //--------------------------------------------------------------------
- // test 81: MultiPatch/INode constructor, baseDomain() accessor
- //--------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //-----------------------------------------------------------------
- // test 82: MultiPatch/Inode constructor, strides() accessor
- //-----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //------------------------------------------------------------
- // test 83: BrickViewEngine MultiPatch/Node constructor
- //------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"MultiPatch/Node constructor",
- testStatus);
-
-
- //--------------------------------------------------------------
- // test 84: MultiPatch/Node constructor, NewEngine struct
- //--------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //---------------------------------------------------------------
- // test 85: MultiPatch/Node constructor, domain() accessor
- //---------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //-------------------------------------------------------------------
- // test 86: MultiPatch/Node constructor, baseDomain() accessor
- //-------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //----------------------------------------------------------------
- // test 87: MultiPatch/Node constructor, strides() accessor
- //----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-----------------------------------------------------------------
- // test 88: BrickViewEngine MultiPatchView/INode constructor
- //-----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"MultiPatchView/Inode constructor",
- testStatus);
-
-
- //-------------------------------------------------------------------
- // test 89: MultiPatchVIew/Inode constructor, NewEngine struct
- //-------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //--------------------------------------------------------------------
- // test 90: MultiPatchView/INode constructor, domain() accessor
- //--------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //------------------------------------------------------------------------
- // test 91: MultiPatchView/INode constructor, baseDomain() accessor
- //------------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //---------------------------------------------------------------------
- // test 92: MultiPatchView/INode constructor, strides() accessor
- //---------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //----------------------------------------------------------------
- // test 93: BrickViewEngine MultiPatchView/Node constructor
- //----------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"MultiPatchView/Node constructor",
- testStatus);
-
-
- //------------------------------------------------------------------
- // test 94: MultiPatchVIew/Node constructor, NewEngine struct
- //------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //-------------------------------------------------------------------
- // test 95: MultiPatchView/Node constructor, domain() accessor
- //-------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //-----------------------------------------------------------------------
- // test 96: MultiPatchView/Node constructor, baseDomain() accessor
- //-----------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //--------------------------------------------------------------------
- // test 97: MultiPatchView/Node constructor, strides() accessor
- //--------------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- //-------------------------------------------------------
- // test 98: BrickViewEngine CompressibleBrick constructor
- //-------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber,"CompressibleBrick constructor",
- testStatus);
-
-
- //---------------------------------------------------------
- // test 99: CompressibleBrick constructor, NewEngine struct
- //---------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," NewEngine struct",testStatus);
-
-
- //-----------------------------------------------------------
- // test 100: CompressibleBrick constructor, domain() accessor
- //-----------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," domain() accessor",testStatus);
-
-
- //---------------------------------------------------------------
- // test 101: CompressibleBrick constructor, baseDomain() accessor
- //---------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," baseDomain() accessor",testStatus);
-
-
- //------------------------------------------------------------
- // test 102: CompressibleBrick constructor, strides() accessor
- //------------------------------------------------------------
-
- ++testNumber;
-
- reportResults(testNumber," strides() accessor",testStatus);
-
-
- ---------------- end templates for remaining constructors -------------*/
-
-
- //------------------------------------------------------------------------
- // test 103: BrickViewEngine copy constructor (all BrickView constructors)
- //------------------------------------------------------------------------
-
- ++testNumber;
-
- // Range/Interval
-
- Ilen = box3[0].length();
- Jlen = box3[1].length();
- Klen = box3[2].length();
-
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++)
- for (int k = 0; k < Klen; k++)
- diff += fabs(BV5.read(i,j,k) - BV7(Loc<3>(i,j,k)));
- testStatus = (diff == zero);
-
- Ilen = square2[0].length();
- Jlen = square2[1].length();
-
- for (int i = 0; i < Ilen; i++)
- for (int j = 0; j < Jlen; j++)
- diff += fabs(BV8(i,j) - BV1(i,j));
- testStatus = (diff == zero) && testStatus;
-
-
- // SliceRange<Dim2,Dim>
-
- float4DV3_t BV11(BV10);
-
- Ilen = d13[0].length();
- Jlen = d13[1].length();
- Klen = d13[2].length();
- Llen = d13[3].length();
-
- diff = zero;
- for(int i = 0; i < Ilen; i++)
- for(int j = 0; j < Jlen; j++)
- for(int k = 0; k < Klen; k++)
- for(int l = 0; l < Llen; l++)
- diff += fabs(BV10(i,j,k,l) - BV11(i,j,k,l));
- testStatus = (diff == zero) && testStatus;
-
-
- // SliceInterval<Dim2,Dim>
-
- float2DV2_t BV13(BV12);
- Ilen = d15[0].length();
- Jlen = d15[1].length();
-
- diff = zero;
- for(int i = 0; i < Ilen; i++)
- for(int j = 0; j < Jlen; j++)
- diff += fabs(BV13(i,j) - BV12(i,j));
- testStatus = (diff == zero) && testStatus;
-
-
- // Node
-
- int6DV1_t BV15(BV14);
- Ilen = d18[5].length();
-
- diff = zero;
- for(int i = 0; i < Ilen; i++)
- diff += abs(BV15.read(0,0,0,0,0,i) - BV14(Loc<6>(0,0,0,0,0,i)));
- testStatus = (diff == zero) && testStatus;
-
-
- // INode
-
- int6DV1_t BV17(BV16);
- Ilen = d20[0].length();
- Jlen = d20[1].length();
-
- diff = zero;
- for(int i = 0; i < Ilen; i++)
- for(int j = 0; j < Jlen; j++)
- diff += abs(BV17.read(0,i,j,0,0,0) - BV16(Loc<6>(0,i,j,0,0,0)));
- testStatus = (diff == zero) && testStatus;
-
-
- // --- add tests for additional constructors (corresponding to
- // --- tests 62-102) here.
-
- reportResults(testNumber,"copy constructor (all BrickView constructors)",
- testStatus);
-
- }
- catch(const char *err)
- { uncaughtErrorReport(err,testNumber); }
- catch(const Pooma::Assertion &err)
- { uncaughtErrorReport(err.what(),testNumber); }
- catch(...)
- { cerr << "Unknown exception!" << endl; }
-
- cout << "\n" << endl;
- }
-
--- 0 ----