test/DataAlgorithmAdapter/DataAlgorithmAdapterTestCase.cpp

// $Id$
/* 
 *****************************************************************************
 *                                                                           *
 *       COPYRIGHT  ACcESS  -  All Rights Reserved                           *
 *                                                                           *
 * This software is the property of ACcESS. No part of this code             *
 * may be copied in any form or by any means without the expressed written   *
 * consent of ACcESS.  Copying, use or modification of this software         *
 * by any unauthorised person is illegal unless that person has a software   *
 * license agreement with ACcESS.                                            *
 *                                                                           *
 *****************************************************************************
*/

#include "escript/Data/DataExpanded.h"
#include "escript/Data/DataArrayView.h"
#include "escript/Data/DataAlgorithm.h"
#include "DataAlgorithmAdapterTestCase.h"

#include <iostream>
#include <algorithm>
#include <math.h>
#include <limits>

using namespace CppUnitTest;
using namespace std;
using namespace escript;

void DataAlgorithmAdapterTestCase::setUp() {
  //
  // This is called before each test is run
 
}

void DataAlgorithmAdapterTestCase::tearDown() {
  //
  // This is called after each test has been run
 
}

void DataAlgorithmAdapterTestCase::testAll() {

  cout << endl;

  cout << "\tTesting FMax." << endl;

  FMax fmax;
  assert(fmax(5,6)==6);
  assert(fmax(5,-6)==5);
  assert(fmax(0,0)==0);
  assert(fmax(15,-96)==15);

  DataAlgorithmAdapter<FMax> sup(numeric_limits<double>::max()*-1);
  sup.resetResult();
  sup(-1);
  sup(-2);
  sup(-14);
  sup(3);
  assert(sup.getResult()==3);

  cout << "\tTesting AbsMax." << endl;

  AbsMax absmax;
  assert(absmax(5,6)==6);
  assert(absmax(5,-6)==6);
  assert(absmax(0,0)==0);
  assert(absmax(15,-96)==96);

  DataAlgorithmAdapter<AbsMax> Lsup(0);
  Lsup.resetResult();
  Lsup(-2);
  Lsup(2);
  Lsup(5);
  Lsup(-10);
  assert(Lsup.getResult()==10);

  cout << "\tTesting FMin." << endl;

  FMin fmin;
  assert(fmin(5,6)==5);
  assert(fmin(5,-6)==-6);
  assert(fmin(0,0)==0);
  assert(fmin(15,-96)==-96);

  DataAlgorithmAdapter<FMin> inf(numeric_limits<double>::max());
  inf.resetResult();
  inf(1);
  inf(12);
  inf(2);
  inf(99);
  assert(inf.getResult()==1);

  cout << "\tTesting Length." << endl;

  Length lngth;
  assert(lngth(5,6)==std::sqrt(61.0));
  assert(lngth(5,-6)==std::sqrt(61.0));
  assert(lngth(0,0)==std::sqrt(0.0));
  assert(lngth(15,-96)==std::sqrt(9441.0));

  DataAlgorithmAdapter<Length> length(0);
  length.resetResult();
  length(2);
  length(4);
  length(6);
  length(8);
  assert(length.getResult()==std::sqrt(120.0));
  length.resetResult();
  length(1.5);
  length(2.5);
  length(3.5);
  length(4.5);
  assert(length.getResult()==std::sqrt(41.0));

  cout << "\tTesting Trace." << endl;

  Trace trce;
  assert(trce(5,6)==11);
  assert(trce(5,-6)==-1);
  assert(trce(0,0)==0);
  assert(trce(15,-96)==-81);

  DataAlgorithmAdapter<Trace> trace(0);
  trace.resetResult();
  trace(1);
  trace(2);
  trace(3);
  trace(4);
  trace(5);
  assert(trace.getResult()==15);
  trace.resetResult();
  trace(1.5);
  trace(2.5);
  trace(3.5);
  trace(4.5);
  trace(5.5);
  assert(trace.getResult()==17.5);

}

void DataAlgorithmAdapterTestCase::testAlgorithm() {

  {
    cout << endl;
    cout << "\tTest algorithm on Data objects with a single data-point.";

    // define the shape for the DataArrayView
    DataArrayView::ShapeType shape;
    shape.push_back(2);
    shape.push_back(3);

    // allocate the data for the DataArrayView
    DataArrayView::ValueType dataArray(DataArrayView::noValues(shape),0);

    // construct DataArrayView
    DataArrayView dataView(dataArray,shape);

    // assign values to the data point
    for (int i=0;i<shape[0];i++) {
      for (int j=0;j<shape[1];j++) {
        dataView(i,j)=dataView.index(i,j);
      }
    }

    // create a few Data objects from the created DataArrayView
    DataExpanded dataExp(dataView,FunctionSpace());
    DataConstant dataCon(dataView,FunctionSpace());
    DataTagged   dataTag(dataCon);

    // test algorithm on DataExpanded
    FMin fmin_func;
    assert(escript::algorithm(dataExp,fmin_func,numeric_limits<double>::max())==0);
    FMax fmax_func;
    assert(escript::algorithm(dataExp,fmax_func,numeric_limits<double>::max()*-1)==5);

    // test algorithm on DataTagged
    assert(escript::algorithm(dataTag,fmin_func,numeric_limits<double>::max())==0);
    assert(escript::algorithm(dataTag,fmax_func,numeric_limits<double>::max()*-1)==5);

    // test algorithm on DataConstant
    assert(escript::algorithm(dataCon,fmin_func,numeric_limits<double>::max())==0);
    assert(escript::algorithm(dataCon,fmax_func,numeric_limits<double>::max()*-1)==5);

  }

  cout << endl;

}

void DataAlgorithmAdapterTestCase::testDpAlgorithm() {

  {
    cout << endl;
    cout << "\tTest dp_algorithm on Data objects with a single data-point.";

    // define the shapes for the DataArrayViews
    DataArrayView::ShapeType shape;
    shape.push_back(2);
    shape.push_back(3);
    DataArrayView::ShapeType shape2;

    // allocate the data for the DataArrayViews
    DataArrayView::ValueType dataArray(DataArrayView::noValues(shape),0);
    DataArrayView::ValueType dataArray2(DataArrayView::noValues(shape2),0);

    // construct DataArrayViews
    DataArrayView dataView(dataArray,shape);
    DataArrayView dataView2(dataArray2,shape2);

    // assign values to the data point
    for (int i=0;i<shape[0];i++) {
      for (int j=0;j<shape[1];j++) {
        dataView(i,j)=dataView.index(i,j);
      }
    }

    // create a few Data objects from the created DataArrayViews
    DataExpanded dataExp(dataView,FunctionSpace());
    DataConstant dataCon(dataView,FunctionSpace());
    DataTagged   dataTag(dataCon);

    // and create Data objects to receive the results of the dp_algorithm calls
    DataExpanded dataExp2(dataView2,FunctionSpace());
    DataConstant dataCon2(dataView2,FunctionSpace());
    DataTagged   dataTag2(dataCon2);

    // test dp_algorithm on DataExpanded
    FMin fmin_func;
    escript::dp_algorithm(dataExp,dataExp2,fmin_func,numeric_limits<double>::max());
    assert(dataExp2.getDataPoint(0,0)()==0);
    FMax fmax_func;
    escript::dp_algorithm(dataExp,dataExp2,fmax_func,numeric_limits<double>::max()*-1);
    assert(dataExp2.getDataPoint(0,0)()==5);

    // test dp_algorithm on DataTagged
    escript::dp_algorithm(dataTag,dataTag2,fmin_func,numeric_limits<double>::max());
    assert(dataTag2.getDataPoint(0,0)()==0);
    escript::dp_algorithm(dataTag,dataTag2,fmax_func,numeric_limits<double>::max()*-1);
    assert(dataTag2.getDataPoint(0,0)()==5);

    // test dp_algorithm on DataConstant
    escript::dp_algorithm(dataCon,dataCon2,fmin_func,numeric_limits<double>::max());
    assert(dataCon2.getDataPoint(0,0)()==0);
    escript::dp_algorithm(dataCon,dataCon2,fmax_func,numeric_limits<double>::max()*-1);
    assert(dataCon2.getDataPoint(0,0)()==5);

  }

  cout << endl;

}

TestSuite* DataAlgorithmAdapterTestCase::suite ()
{
  //
  // create the suite of tests to perform.
  TestSuite *testSuite = new TestSuite ("DataAlgorithmAdapterTestCase");

  testSuite->addTest (new TestCaller< DataAlgorithmAdapterTestCase>("testAll",&DataAlgorithmAdapterTestCase::testAll));
  testSuite->addTest (new TestCaller<DataAlgorithmAdapterTestCase>("testAlgorithm",&DataAlgorithmAdapterTestCase::testAlgorithm));
  testSuite->addTest (new TestCaller<DataAlgorithmAdapterTestCase>("testDpAlgorithm",&DataAlgorithmAdapterTestCase::testDpAlgorithm));
  return testSuite;
}

1	jgs	102	// $Id$
2	jgs	82	/*
3			*****************************************************************************
4			* *
5			* COPYRIGHT ACcESS - All Rights Reserved *
6			* *
7			* This software is the property of ACcESS. No part of this code *
8			* may be copied in any form or by any means without the expressed written *
9			* consent of ACcESS. Copying, use or modification of this software *
10			* by any unauthorised person is illegal unless that person has a software *
11			* license agreement with ACcESS. *
12			* *
13			*****************************************************************************
14			*/
15	jgs	113
16			#include "escript/Data/DataExpanded.h"
17			#include "escript/Data/DataArrayView.h"
18	jgs	82	#include "escript/Data/DataAlgorithm.h"
19			#include "DataAlgorithmAdapterTestCase.h"
20
21			#include <iostream>
22			#include <algorithm>
23			#include <math.h>
24			#include <limits>
25
26			using namespace CppUnitTest;
27			using namespace std;
28			using namespace escript;
29
30			void DataAlgorithmAdapterTestCase::setUp() {
31			//
32			// This is called before each test is run
33
34			}
35
36			void DataAlgorithmAdapterTestCase::tearDown() {
37			//
38			// This is called after each test has been run
39
40			}
41
42			void DataAlgorithmAdapterTestCase::testAll() {
43	jgs	102
44	jgs	82	cout << endl;
45	jgs	102
46	jgs	108	cout << "\tTesting FMax." << endl;
47	jgs	106
48	jgs	108	FMax fmax;
49			assert(fmax(5,6)==6);
50			assert(fmax(5,-6)==5);
51			assert(fmax(0,0)==0);
52			assert(fmax(15,-96)==15);
53
54			DataAlgorithmAdapter<FMax> sup(numeric_limits<double>::max()*-1);
55	jgs	106	sup.resetResult();
56	jgs	108	sup(-1);
57			sup(-2);
58			sup(-14);
59	jgs	106	sup(3);
60	jgs	108	assert(sup.getResult()==3);
61	jgs	102
62			cout << "\tTesting AbsMax." << endl;
63	jgs	108
64			AbsMax absmax;
65			assert(absmax(5,6)==6);
66			assert(absmax(5,-6)==6);
67			assert(absmax(0,0)==0);
68			assert(absmax(15,-96)==96);
69
70	jgs	102	DataAlgorithmAdapter<AbsMax> Lsup(0);
71	jgs	106	Lsup.resetResult();
72	jgs	82	Lsup(-2);
73			Lsup(2);
74			Lsup(5);
75	jgs	102	Lsup(-10);
76			assert(Lsup.getResult()==10);
77
78			cout << "\tTesting FMin." << endl;
79	jgs	108
80			FMin fmin;
81			assert(fmin(5,6)==5);
82			assert(fmin(5,-6)==-6);
83			assert(fmin(0,0)==0);
84			assert(fmin(15,-96)==-96);
85
86	jgs	82	DataAlgorithmAdapter<FMin> inf(numeric_limits<double>::max());
87	jgs	106	inf.resetResult();
88	jgs	82	inf(1);
89	jgs	102	inf(12);
90	jgs	82	inf(2);
91	jgs	102	inf(99);
92			assert(inf.getResult()==1);
93
94	jgs	106	cout << "\tTesting Length." << endl;
95	jgs	108
96			Length lngth;
97			assert(lngth(5,6)==std::sqrt(61.0));
98			assert(lngth(5,-6)==std::sqrt(61.0));
99			assert(lngth(0,0)==std::sqrt(0.0));
100			assert(lngth(15,-96)==std::sqrt(9441.0));
101
102	jgs	106	DataAlgorithmAdapter<Length> length(0);
103			length.resetResult();
104			length(2);
105			length(4);
106			length(6);
107			length(8);
108			assert(length.getResult()==std::sqrt(120.0));
109			length.resetResult();
110			length(1.5);
111			length(2.5);
112			length(3.5);
113			length(4.5);
114			assert(length.getResult()==std::sqrt(41.0));
115	jgs	102
116	jgs	106	cout << "\tTesting Trace." << endl;
117	jgs	108
118			Trace trce;
119			assert(trce(5,6)==11);
120			assert(trce(5,-6)==-1);
121			assert(trce(0,0)==0);
122			assert(trce(15,-96)==-81);
123
124	jgs	106	DataAlgorithmAdapter<Trace> trace(0);
125			trace.resetResult();
126			trace(1);
127			trace(2);
128			trace(3);
129			trace(4);
130			trace(5);
131			assert(trace.getResult()==15);
132			trace.resetResult();
133			trace(1.5);
134			trace(2.5);
135			trace(3.5);
136			trace(4.5);
137			trace(5.5);
138			assert(trace.getResult()==17.5);
139
140	jgs	82	}
141
142	jgs	113	void DataAlgorithmAdapterTestCase::testAlgorithm() {
143
144			{
145			cout << endl;
146			cout << "\tTest algorithm on Data objects with a single data-point.";
147
148			// define the shape for the DataArrayView
149			DataArrayView::ShapeType shape;
150			shape.push_back(2);
151			shape.push_back(3);
152
153			// allocate the data for the DataArrayView
154			DataArrayView::ValueType dataArray(DataArrayView::noValues(shape),0);
155
156			// construct DataArrayView
157			DataArrayView dataView(dataArray,shape);
158
159			// assign values to the data point
160			for (int i=0;i<shape[0];i++) {
161			for (int j=0;j<shape[1];j++) {
162			dataView(i,j)=dataView.index(i,j);
163			}
164			}
165
166			// create a few Data objects from the created DataArrayView
167			DataExpanded dataExp(dataView,FunctionSpace());
168			DataConstant dataCon(dataView,FunctionSpace());
169			DataTagged dataTag(dataCon);
170
171			// test algorithm on DataExpanded
172	jgs	147	FMin fmin_func;
173			assert(escript::algorithm(dataExp,fmin_func,numeric_limits<double>::max())==0);
174			FMax fmax_func;
175			assert(escript::algorithm(dataExp,fmax_func,numeric_limits<double>::max()*-1)==5);
176	jgs	113
177			// test algorithm on DataTagged
178	jgs	147	assert(escript::algorithm(dataTag,fmin_func,numeric_limits<double>::max())==0);
179			assert(escript::algorithm(dataTag,fmax_func,numeric_limits<double>::max()*-1)==5);
180	jgs	113
181			// test algorithm on DataConstant
182	jgs	147	assert(escript::algorithm(dataCon,fmin_func,numeric_limits<double>::max())==0);
183			assert(escript::algorithm(dataCon,fmax_func,numeric_limits<double>::max()*-1)==5);
184	jgs	113
185			}
186
187			cout << endl;
188
189			}
190
191			void DataAlgorithmAdapterTestCase::testDpAlgorithm() {
192
193			{
194			cout << endl;
195			cout << "\tTest dp_algorithm on Data objects with a single data-point.";
196
197			// define the shapes for the DataArrayViews
198			DataArrayView::ShapeType shape;
199			shape.push_back(2);
200			shape.push_back(3);
201			DataArrayView::ShapeType shape2;
202
203			// allocate the data for the DataArrayViews
204			DataArrayView::ValueType dataArray(DataArrayView::noValues(shape),0);
205			DataArrayView::ValueType dataArray2(DataArrayView::noValues(shape2),0);
206
207			// construct DataArrayViews
208			DataArrayView dataView(dataArray,shape);
209			DataArrayView dataView2(dataArray2,shape2);
210
211			// assign values to the data point
212			for (int i=0;i<shape[0];i++) {
213			for (int j=0;j<shape[1];j++) {
214			dataView(i,j)=dataView.index(i,j);
215			}
216			}
217
218			// create a few Data objects from the created DataArrayViews
219			DataExpanded dataExp(dataView,FunctionSpace());
220			DataConstant dataCon(dataView,FunctionSpace());
221			DataTagged dataTag(dataCon);
222
223			// and create Data objects to receive the results of the dp_algorithm calls
224			DataExpanded dataExp2(dataView2,FunctionSpace());
225			DataConstant dataCon2(dataView2,FunctionSpace());
226			DataTagged dataTag2(dataCon2);
227
228			// test dp_algorithm on DataExpanded
229	jgs	147	FMin fmin_func;
230			escript::dp_algorithm(dataExp,dataExp2,fmin_func,numeric_limits<double>::max());
231	jgs	113	assert(dataExp2.getDataPoint(0,0)()==0);
232	jgs	147	FMax fmax_func;
233			escript::dp_algorithm(dataExp,dataExp2,fmax_func,numeric_limits<double>::max()*-1);
234	jgs	113	assert(dataExp2.getDataPoint(0,0)()==5);
235
236			// test dp_algorithm on DataTagged
237	jgs	147	escript::dp_algorithm(dataTag,dataTag2,fmin_func,numeric_limits<double>::max());
238	jgs	113	assert(dataTag2.getDataPoint(0,0)()==0);
239	jgs	147	escript::dp_algorithm(dataTag,dataTag2,fmax_func,numeric_limits<double>::max()*-1);
240	jgs	113	assert(dataTag2.getDataPoint(0,0)()==5);
241
242			// test dp_algorithm on DataConstant
243	jgs	147	escript::dp_algorithm(dataCon,dataCon2,fmin_func,numeric_limits<double>::max());
244	jgs	113	assert(dataCon2.getDataPoint(0,0)()==0);
245	jgs	147	escript::dp_algorithm(dataCon,dataCon2,fmax_func,numeric_limits<double>::max()*-1);
246	jgs	113	assert(dataCon2.getDataPoint(0,0)()==5);
247
248			}
249
250			cout << endl;
251
252			}
253
254	jgs	82	TestSuite* DataAlgorithmAdapterTestCase::suite ()
255			{
256			//
257			// create the suite of tests to perform.
258			TestSuite *testSuite = new TestSuite ("DataAlgorithmAdapterTestCase");
259
260			testSuite->addTest (new TestCaller< DataAlgorithmAdapterTestCase>("testAll",&DataAlgorithmAdapterTestCase::testAll));
261	jgs	113	testSuite->addTest (new TestCaller<DataAlgorithmAdapterTestCase>("testAlgorithm",&DataAlgorithmAdapterTestCase::testAlgorithm));
262			testSuite->addTest (new TestCaller<DataAlgorithmAdapterTestCase>("testDpAlgorithm",&DataAlgorithmAdapterTestCase::testDpAlgorithm));
263	jgs	82	return testSuite;
264			}
265
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision