Index: 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 - #include - #include - - 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 - 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 - // 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 - struct TypeMatchTester - { - static const bool Result = false; - }; - - - template - struct TypeMatchTester - { - 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 object \n" - << " =============================================================\n" - << endl; - - if (debug){ - cout << "=========================DEBUG==================================" - << endl; - cout << endl; - cout << "Starting domain test for Characterists and Interface on "; - cout << " Loc 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:: Domain_t>::Result; - reportResults(testNumber++,"Typedef Domain_t ", testStatus); - testStatus = TypeMatchTester:: Element_t>::Result - && testStatus; - reportResults(testNumber++,"Typedef Elemant_t ", testStatus); - testStatus = TypeMatchTester:: OneDomain_t>::Result - && testStatus; - reportResults(testNumber++,"Typedef OneDomain_t ", testStatus); - testStatus = !TypeMatchTester:: Element_t>::Result - && testStatus; - reportResults(testNumber++,"Typedef Domain_t ", testStatus); - testStatus = !TypeMatchTester:: Domain_t>::Result - && testStatus; - reportResults(testNumber++,"Typedef Elemant_t ", testStatus); - testStatus = !TypeMatchTester:: 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 - #include - #include - #include - #include - #include - - - 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 - 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 - struct TypeMatchTester - { - static const bool Result = false; - }; - - template - struct TypeMatchTester - { - 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 object \n" - << " ==============================================================\n" - << endl; - - if (debug){ - cout << "=========================DEBUG===================================" - << endl; - cout << endl; - cout << "Starting domain test for Constructors on NewDomain 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> >::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,int>::Type_t newdomain2; - - NewDomain2,int>::Type_t newdomain2a = - NewDomain2,int>::combine(D1,2); - - NewDomain3,Range<2>,int>::Type_t newdomain3; - NewDomain3,Range<2>,int>::Type_t newdomain3a = - NewDomain3,Range<2>,int>::combine(newdomain2a,R2,999); - - NewDomain4,Interval<2>,Loc<1>,Loc<1> >::Type_t newdomain4; - - NewDomain4,Interval<2>,Loc<1>,Loc<1> >::Type_t newdomain4a = - NewDomain4,Interval<2>,Loc<1>,Loc<1> >::combine(R2,I2,D1,D2); - - NewDomain5,Range<2>,int,Loc<4>,int>::Type_t newdomain5; - NewDomain5,Range<2>,int,Loc<4>,int>::Type_t newdomain5a = - NewDomain5,Range<2>,int,Loc<4>,int>::combine - (newdomain2a,R2,999,Loc<4>(D1,D2,newdomain2a),999); - - NewDomain6,Range<2>,int,Loc<4>,Loc<4>,int>::Type_t newdomain6; - NewDomain6,Range<2>,int,Loc<4>,Loc<4>,int>::Type_t newdomain6a = - NewDomain6,Range<2>,int,Loc<4>,Loc<4>,int>::combine - (newdomain2a,R1,99,Loc<4>(newdomain2a,newdomain2a),Loc<4> - (newdomain2a,newdomain2a),999); - - NewDomain7,Range<2>,Loc<1>,Loc<1>,Interval<2>,Interval<2>, - int>::Type_t newdomain7; - - NewDomain7,Range<2>,Loc<1>,Loc<2>,Interval<2>,Interval<2>, - Range<2> >::Type_t newdomain7a = NewDomain7,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>,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,int>::fill(newdomain2,D1,2); - testStatus = (newdomain2a ==newdomain2 ); - NewDomain6,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,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 - #include - #include - - 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 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 address@hidden, - // 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 - BrickView-Engine specialization tag. - // Engine - the "Brick-Engine" specialization. - // Engine - the "BrickView-Engine" specialization. - // NewEngine - specializations for BrickView-Engine. - // ElementProperties > - specialization for BrickEngine. - // - //----------------------------------------------------------------------------- - - #include "Pooma/Pooma.h" - #include "Engine/BrickEngine.h" - #include - #include - #include - #include - - //----------------------------------------------------------------------------- - // 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 // template class to test typedefs - struct TypeMatchTester - { - static const bool Result = false; - }; - - template // ... partial specialization - struct TypeMatchTester - { - 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::Result; - } - - { - typedef Engine3Df_t::Engine_t Try_t; - typedef Engine3Df_t::This_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef Engine3Df_t::Domain_t Try_t; - typedef Interval<3> Correct_t; - testStatus = TypeMatchTester::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::Result; - } - - { - typedef Engine3Df_t::Element_t Try_t; - typedef float Correct_t; - testStatus = TypeMatchTester::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::Result; - } - - { - typedef Engine3Df_t::Tag_t Try_t; - typedef Brick Correct_t; - testStatus = TypeMatchTester::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 > 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) 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 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 - //------------------------------------------------------------- - - ++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; ielectron() == 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(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 dupAr(ArEngine); - - diff = zero; - for (int i=Imin; i(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 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 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(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::Result; - } - - { - typedef float3DV2_t::This_t Try_t; - typedef float3DV2_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV1_t::This_t Try_t; - typedef double2DV1_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::This_t Try_t; - typedef double2DV2_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - - // Engine_t - - { - typedef float3DV1_t::Engine_t Try_t; - typedef float3DV1_t::This_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef float3DV2_t::Engine_t Try_t; - typedef float3DV2_t::This_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV1_t::Engine_t Try_t; - typedef double2DV1_t::This_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::Engine_t Try_t; - typedef double2DV2_t::This_t Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - - // Domain_t - - { - typedef float3DV1_t::Domain_t Try_t; - typedef Interval<3> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef float3DV2_t::Domain_t Try_t; - typedef Interval<3> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::Domain_t Try_t; - typedef Interval<2> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::Domain_t Try_t; - typedef Interval<2> Correct_t; - testStatus = TypeMatchTester::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::Result; - } - - { - typedef float3DV2_t::BaseDomain_t Try_t; - typedef Range<3> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV1_t::BaseDomain_t Try_t; - typedef Range<2> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::BaseDomain_t Try_t; - typedef Range<2> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - // Element_t - - { - typedef float3DV1_t::Element_t Try_t; - typedef float Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef float3DV2_t::Element_t Try_t; - typedef float Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV1_t::Element_t Try_t; - typedef double Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::Element_t Try_t; - typedef double Correct_t; - testStatus = TypeMatchTester::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::Result; - } - - { - typedef float3DV2_t::ElementRef_t Try_t; - typedef float& Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV1_t::ElementRef_t Try_t; - typedef double& Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::ElementRef_t Try_t; - typedef double& Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - // Tag_t - - { - typedef float3DV1_t::Tag_t Try_t; - typedef BrickView<3,true> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef float3DV2_t::Tag_t Try_t; - typedef BrickView<3,false> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV1_t::Tag_t Try_t; - typedef BrickView<2,true> Correct_t; - testStatus = TypeMatchTester::Result && testStatus; - } - - { - typedef double2DV2_t::Tag_t Try_t; - typedef BrickView<2,false> Correct_t; - testStatus = TypeMatchTester::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 constructor",testStatus); - - - //------------------------------------------------------- - // test 34: Range/Interval constructor, NewEngine struct - //------------------------------------------------------- - - ++testNumber; - - { - typedef NewEngine >::Type_t Try_t; - typedef Engine<3,float,BrickView<3,false> > Correct_t; - testStatus = TypeMatchTester::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 constructor - //---------------------------------------------------------- - - ++testNumber; - - // SliceRange 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, 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 constructor", - testStatus); - - - //------------------------------------------------------------- - // test 39: SliceRange constructor, NewEngine struct - //------------------------------------------------------------- - - ++testNumber; - - { - typedef NewEngine::Type_t Try_t; - typedef Engine<4,float,BrickView<6,false> > Correct_t; - testStatus = TypeMatchTester::Result; - } - - reportResults(testNumber," NewEngine struct",testStatus); - - - //-------------------------------------------------------------- - // test 40: SliceRange 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 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 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 constructor - //------------------------------------------------------------- - - ++testNumber; - - // similar to SliceRange 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, 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 constructor", - testStatus); - - - //---------------------------------------------------------------- - // test 44: SliceInterval constructor, NewEngine struct - //---------------------------------------------------------------- - - ++testNumber; - - { - typedef NewEngine::Type_t Try_t; - typedef Engine<2,float,BrickView<6,false> > Correct_t; - testStatus = TypeMatchTester::Result; - } - - reportResults(testNumber," NewEngine struct",testStatus); - - - //---------------------------------------------------------------- - // test 45: SliceInterval 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 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 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 > 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 > >::Type_t Try_t; - typedef Engine<6,int,BrickView<6,true> > Correct_t; - testStatus = TypeMatchTester::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 > 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 >::Type_t Try_t; - typedef Engine<6,int,BrickView<6,true> > Correct_t; - testStatus = TypeMatchTester::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 >::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 >::Type_t Try_t; - typedef Engine<4,float,BrickView<6,false> > Correct_t; - testStatus = TypeMatchTester::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 - - 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 - - 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 ----