test/DataArrayView/DataArrayViewTestCase.cpp

/* 
 *****************************************************************************
 *                                                                           *
 *       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/DataArrayView.h"
#include "escript/Data/DataArray.h"
#include "DataArrayViewTestCase.h"
#include "esysUtils/EsysException.h"

#include <iostream>

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

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

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

void DataArrayViewTestCase::testSlicing() {

  // Test some arbitrary slicing

  cout << endl;

  {
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(1,5));
    DataArrayView::ShapeType resultShape;
    resultShape.push_back(4);
    assert(DataArrayView::getResultSliceShape(region)==resultShape);
    region.push_back(DataArrayView::RegionType::value_type(2,5));
    resultShape.push_back(3);
    assert(DataArrayView::getResultSliceShape(region)==resultShape);
  }

  {
    // Say an empty region can select a scalar
    DataArrayView::RegionType region;
    DataArrayView::ShapeType sourceShape;
    DataArray source(sourceShape,2.0);
    DataArray target;
    target.getView().copySlice(source.getView(),region);
    assert(source.getView()==target.getView());
  }

  {
    // try a slice from a 1 dimensional array
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(2,4));
    DataArrayView::ShapeType sourceShape;
    sourceShape.push_back(6);
    DataArray source(sourceShape);
    for (int i=0;i<sourceShape[0];++i) {
      source.getView()(i)=i;
    }
    DataArray target(DataArrayView::getResultSliceShape(region));
    target.getView().copySlice(source.getView(),region);
    for (int i=region[0].first;i<region[0].second;++i) {
      assert(source.getView()(i)==target.getView()(i-2));
    }
  }

  {
    // try a slice from a 2 dimensional array
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(2,4));
    region.push_back(DataArrayView::RegionType::value_type(0,2));
    DataArrayView::ShapeType sourceShape;
    sourceShape.push_back(6);
    sourceShape.push_back(3);
    DataArray source(sourceShape);
    int val=0;
    for (int i=0;i<sourceShape[0];++i) {
      for (int j=0;j<sourceShape[1];++j) {
    source.getView()(i,j)=val++;
      }
    }
    DataArray target(DataArrayView::getResultSliceShape(region));
    target.getView().copySlice(source.getView(),region);
    for (int i=region[0].first;i<region[0].second;++i) {
      for (int j=region[1].first;j<region[1].second;++j) {
    assert(source.getView()(i,j)==target.getView()(i-2,j));
      }
    }
  }

}

void DataArrayViewTestCase::testShapeToString() {
  cout << endl;
  DataArrayView::ShapeType shape;
  assert(DataArrayView::shapeToString(shape)=="()");
  shape.push_back(5);
  assert(DataArrayView::shapeToString(shape)=="(5)");
  shape.push_back(2);
  assert(DataArrayView::shapeToString(shape)=="(5,2)");
}

void DataArrayViewTestCase::testScalarView() {
  //
  // Create a vector containing data for three scalars
  // and check three scalar views return the appropriate data
  DataArrayView::ShapeType vShape;
  DataArrayView::ValueType vData;
  vData.push_back(0);
  vData.push_back(1);
  vData.push_back(2);
  int sZero=0;
  int sOne=1;
  int sTwo=2;
  DataArrayView zView(vData,vShape,sZero);
  DataArrayView oView(vData,vShape,sOne);
  DataArrayView tView(vData,vShape,sTwo);
  vShape.push_back(3);
  DataArrayView oneVView(vData,vShape,0);
  assert(zView()==0);
  assert(oView()==1);
  assert(tView()==2);
  assert(tView.noValues()==1);
  assert(oView.getRank()==0);
  //
  // copy the one view to the zero view
  zView.copy(oView);
  assert(zView==oView);
  zView.checkShape(oView.getShape());
  cout << endl << "\tTest shape mismatch functions." << endl;
  if (!zView.checkShape(oneVView.getShape())) {
    //cout << zView.createShapeErrorMessage("Error - Shape mismatch.", oneVView.getShape()) << endl;
    assert(true);
  } else {
    assert(false);
  }
  zView.unaryOp(negate<double>());
  assert(zView()==-1);
  zView.binaryOp(oView,plus<double>());
  assert(zView()==0);
  //
  // test view.operator!=
  assert(zView!=oView);
}

void DataArrayViewTestCase::testAll()
{

  {
    cout << endl;

    cout << "\tTest empty DataArrayView." << endl;

    DataArrayView defView;

    assert(defView.getOffset()==0);
    assert(defView.getShape().empty());
    assert(defView.noValues()==0);
    assert(defView.getRank()==0);
  }

  {
    cout << endl;

    // define the shape for the data array view
    cout << "\tTest shape (5):" << endl;
    DataArrayView::ShapeType shape;
    shape.push_back(5);
    int offset=5;

    // allocate the space external to the DataArrayView
    DataArrayView::ValueType data(DataArrayView::noValues(shape)+offset,0);

    // test constructor
    cout << "\tTest DataArrayView constructor." << endl;
    DataArrayView dataView(data,shape,offset);

    // test shape set correctly
    cout << "\tTest getShape." << endl;
    assert(dataView.getShape()==shape);

    // Assign values to the data
    cout << "\tAssign values via () operator." << endl;
    for (int i=0;i<shape[0];++i) {
      //cout << i << ":" << dataView.index(i) << endl;
      dataView(i)=dataView.index(i);
      assert(dataView(i)==dataView.index(i));
    }

    // test operator==
    cout << "\tTest == operator." << endl;
    assert(dataView==dataView);
  }

  {
    cout << endl;

    // define the shape for the data array view
    cout << "\tTest shape (2,3):" << endl;
    DataArrayView::ShapeType shape;
    shape.push_back(2);
    shape.push_back(3);

    // allocate the space external to the DataArrayView
    DataArrayView::ValueType data(DataArrayView::noValues(shape),0);

    // test constructor
    cout << "\tTest DataArrayView constructor." << endl;
    DataArrayView dataView(data,shape);

    // test shape set correctly
    cout << "\tTest getShape." << endl;
    assert(dataView.getShape()==shape);

    // Assign values to the data
    cout << "\tAssign values via () operator." << endl;
    for (int i=0;i<shape[0];++i) {
      for (int j=0;j<shape[1];++j) {
        //cout << i << "," << j << ":" << dataView.index(i,j) << endl;
    dataView(i,j)=dataView.index(i,j);
    assert(dataView(i,j)==dataView.index(i,j));
      }
    }

    // test operator==
    cout << "\tTest == operator." << endl;
    assert(dataView==dataView);
  }

  {
    cout << endl;

    // define the shape for the data array view
    cout << "\tTest shape (2,3,4):" << endl;
    DataArrayView::ShapeType shape;
    shape.push_back(2);
    shape.push_back(3);
    shape.push_back(4);

    // allocate the space external to the DataArrayView
    DataArrayView::ValueType data(DataArrayView::noValues(shape),0);

    // test constructor
    cout << "\tTest DataArrayView constructor." << endl;
    DataArrayView dataView(data,shape);

    // test shape set correctly
    cout << "\tTest getShape." << endl;
    assert(dataView.getShape()==shape);

    // Assign values to the data
    cout << "\tAssign values via () operator." << endl;
    for (int i=0;i<shape[0];++i) {
      for (int j=0;j<shape[1];++j) {
    for (int k=0;k<shape[2];++k) {
          //cout << i << "," << j << "," << k << ":" << dataView.index(i,j,k) << endl;
      dataView(i,j,k)=dataView.index(i,j,k);
          assert(dataView(i,j,k)==dataView.index(i,j,k));
    }
      }
    }

    // test operator==
    cout << "\tTest == operator." << endl;
    assert(dataView==dataView);
  }

#if defined DOASSERT 
  {
    cout << endl;

    cout << "\tTest too many indices for rank of array exception." << endl;

    DataArrayView::ShapeType shape;
    DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
    DataArrayView dataView(data,shape);

    // Should be a scalar
    dataView()=1;

    try {
      dataView(1)=1;
      assert(false);
    }
    catch (EsysException& e) {
      //cout << "\t" << e.what() << endl;
      assert(true);
    }

    try {
      dataView(1,1)=1;
      assert(false);
    }
    catch (EsysException& e) {
      //cout << "\t" << e.what() << endl;
      assert(true);
    }

    try {
      dataView(1,1,1)=1;
      assert(false);
    }
    catch (EsysException& e) {
      //cout << "\t" << e.what() << endl;
      assert(true);
    }
  }

  {
    cout << endl;

    cout << "\tTest invalid index exception." << endl;

    DataArrayView::ShapeType shape;
    shape.push_back(4);
    DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
    DataArrayView dataView(data,shape);

    try {
      dataView(4000)=1;
      assert(false);
    }
    catch (EsysException& e) {
      //cout << "\t" << e.what() << endl;
      assert(true);
    }
  }

#endif

  {
    cout << endl;

    cout << "\tTest insufficient data exception." << endl;

    DataArrayView::ShapeType shape;
    DataArrayView::ValueType data;

    try {
      DataArrayView dataView(data,shape);
      assert(false);
    }
    catch (EsysException& e) {
      //cout << "\t" << e.what() << endl;
      assert(true);
    }
  }

  {
    cout << endl;

    cout << "\tTest matrix multiplication." << endl;

    DataArrayView::ShapeType leftShape;
    leftShape.push_back(1);
    leftShape.push_back(3);
    DataArrayView::ValueType leftData(DataArrayView::noValues(leftShape),0);
    DataArrayView leftDataView(leftData,leftShape);

    DataArrayView::ShapeType rightShape;
    rightShape.push_back(3);
    rightShape.push_back(2);
    DataArrayView::ValueType rightData(DataArrayView::noValues(rightShape),0);
    DataArrayView rightDataView(rightData,rightShape);

    DataArrayView::ShapeType resultShape=DataArrayView::determineResultShape(leftDataView,rightDataView);

    for (int i=0;i<resultShape.size();++i) {
      cout << "\tDimension: " << i << " size: " << resultShape[i] << endl;
    }

    DataArrayView::ValueType resultData(DataArrayView::noValues(resultShape),0);
    DataArrayView resultDataView(resultData,resultShape);
  
    cout << "\tTest result shape." << endl;

    assert(resultShape.size()==2);
    assert(resultShape[0]==1);
    assert(resultShape[1]==2);

    // Assign some values
    cout << "\tAssign values." << endl;
    double aValue=0.0;
    for (int i=0;i<leftShape[0];++i) {
      for (int j=0;j<leftShape[1];++j) {
    leftDataView(i,j)=++aValue;
      }
    }
    aValue=0.0;
    for (int i=0;i<rightShape[0];++i) {
      for (int j=0;j<rightShape[1];++j) {
    rightDataView(i,j)=++aValue;
      }
    }

    cout << "\tDo matrix multiplication." << endl;
    DataArrayView::matMult(leftDataView,rightDataView,resultDataView);

    cout << "\tCheck result." << endl;
    //need to hand build result matrix and compare with generated result here.

    /*
    cout << "Create a vector." << endl;
    DataArray v;
    DataArray::ShapeType vShape;
    vShape.push_back(3);
    v.setShape(vShape);
    double aValue=0.0;
    for (int i=0;i<vShape[0];++i) {
      v(i)=++aValue;
    }

    cout << "Create a matrix." << endl;
    DataArray mat;
    DataArray::ShapeType mShape;
    mShape.push_back(3);
    mShape.push_back(2);
    mat.setShape(mShape);
    aValue=0.0;
    for (int i=0;i<mShape[0];++i) {
      for (int j=0;j<mShape[1];++j) {
    mat(i,j)=++aValue;
      }
    }

    // [1,2,3] x |1, 2| = [22,28]
    //           |3, 4|
    //           |5, 6|

    cout << "Test multiplication of matrix and vector." << endl;
    DataArray result=DataArray::matMult(v,mat);
    assert(fabs(result(0) - 22) < 0.1);
    assert(fabs(result(1) - 28) < 0.1);
    */
  }  

}

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

  testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testAll",&DataArrayViewTestCase::testAll));
  testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testShapeToString",&DataArrayViewTestCase::testShapeToString));
  testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testScalarView",&DataArrayViewTestCase::testScalarView));
  testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testSlicing",&DataArrayViewTestCase::testSlicing));
  return testSuite;
}

1	/*
2	*****************************************************************************
3	* *
4	* COPYRIGHT ACcESS - All Rights Reserved *
5	* *
6	* This software is the property of ACcESS. No part of this code *
7	* may be copied in any form or by any means without the expressed written *
8	* consent of ACcESS. Copying, use or modification of this software *
9	* by any unauthorised person is illegal unless that person has a software *
10	* license agreement with ACcESS. *
11	* *
12	*****************************************************************************
13	*/
14	#include "escript/Data/DataArrayView.h"
15	#include "escript/Data/DataArray.h"
16	#include "DataArrayViewTestCase.h"
17	#include "esysUtils/EsysException.h"
18
19	#include <iostream>
20
21	using namespace CppUnitTest;
22	using namespace esysUtils;
23	using namespace escript;
24	using namespace std;
25
26	void DataArrayViewTestCase::setUp() {
27	//
28	// This is called before each test is run
29
30	}
31
32	void DataArrayViewTestCase::tearDown() {
33	//
34	// This is called after each test has been run
35
36	}
37
38	void DataArrayViewTestCase::testSlicing() {
39
40	// Test some arbitrary slicing
41
42	cout << endl;
43
44	{
45	DataArrayView::RegionType region;
46	region.push_back(DataArrayView::RegionType::value_type(1,5));
47	DataArrayView::ShapeType resultShape;
48	resultShape.push_back(4);
49	assert(DataArrayView::getResultSliceShape(region)==resultShape);
50	region.push_back(DataArrayView::RegionType::value_type(2,5));
51	resultShape.push_back(3);
52	assert(DataArrayView::getResultSliceShape(region)==resultShape);
53	}
54
55	{
56	// Say an empty region can select a scalar
57	DataArrayView::RegionType region;
58	DataArrayView::ShapeType sourceShape;
59	DataArray source(sourceShape,2.0);
60	DataArray target;
61	target.getView().copySlice(source.getView(),region);
62	assert(source.getView()==target.getView());
63	}
64
65	{
66	// try a slice from a 1 dimensional array
67	DataArrayView::RegionType region;
68	region.push_back(DataArrayView::RegionType::value_type(2,4));
69	DataArrayView::ShapeType sourceShape;
70	sourceShape.push_back(6);
71	DataArray source(sourceShape);
72	for (int i=0;i<sourceShape[0];++i) {
73	source.getView()(i)=i;
74	}
75	DataArray target(DataArrayView::getResultSliceShape(region));
76	target.getView().copySlice(source.getView(),region);
77	for (int i=region[0].first;i<region[0].second;++i) {
78	assert(source.getView()(i)==target.getView()(i-2));
79	}
80	}
81
82	{
83	// try a slice from a 2 dimensional array
84	DataArrayView::RegionType region;
85	region.push_back(DataArrayView::RegionType::value_type(2,4));
86	region.push_back(DataArrayView::RegionType::value_type(0,2));
87	DataArrayView::ShapeType sourceShape;
88	sourceShape.push_back(6);
89	sourceShape.push_back(3);
90	DataArray source(sourceShape);
91	int val=0;
92	for (int i=0;i<sourceShape[0];++i) {
93	for (int j=0;j<sourceShape[1];++j) {
94	source.getView()(i,j)=val++;
95	}
96	}
97	DataArray target(DataArrayView::getResultSliceShape(region));
98	target.getView().copySlice(source.getView(),region);
99	for (int i=region[0].first;i<region[0].second;++i) {
100	for (int j=region[1].first;j<region[1].second;++j) {
101	assert(source.getView()(i,j)==target.getView()(i-2,j));
102	}
103	}
104	}
105
106	}
107
108	void DataArrayViewTestCase::testShapeToString() {
109	cout << endl;
110	DataArrayView::ShapeType shape;
111	assert(DataArrayView::shapeToString(shape)=="()");
112	shape.push_back(5);
113	assert(DataArrayView::shapeToString(shape)=="(5)");
114	shape.push_back(2);
115	assert(DataArrayView::shapeToString(shape)=="(5,2)");
116	}
117
118	void DataArrayViewTestCase::testScalarView() {
119	//
120	// Create a vector containing data for three scalars
121	// and check three scalar views return the appropriate data
122	DataArrayView::ShapeType vShape;
123	DataArrayView::ValueType vData;
124	vData.push_back(0);
125	vData.push_back(1);
126	vData.push_back(2);
127	int sZero=0;
128	int sOne=1;
129	int sTwo=2;
130	DataArrayView zView(vData,vShape,sZero);
131	DataArrayView oView(vData,vShape,sOne);
132	DataArrayView tView(vData,vShape,sTwo);
133	vShape.push_back(3);
134	DataArrayView oneVView(vData,vShape,0);
135	assert(zView()==0);
136	assert(oView()==1);
137	assert(tView()==2);
138	assert(tView.noValues()==1);
139	assert(oView.getRank()==0);
140	//
141	// copy the one view to the zero view
142	zView.copy(oView);
143	assert(zView==oView);
144	zView.checkShape(oView.getShape());
145	cout << endl << "\tTest shape mismatch functions." << endl;
146	if (!zView.checkShape(oneVView.getShape())) {
147	//cout << zView.createShapeErrorMessage("Error - Shape mismatch.", oneVView.getShape()) << endl;
148	assert(true);
149	} else {
150	assert(false);
151	}
152	zView.unaryOp(negate<double>());
153	assert(zView()==-1);
154	zView.binaryOp(oView,plus<double>());
155	assert(zView()==0);
156	//
157	// test view.operator!=
158	assert(zView!=oView);
159	}
160
161	void DataArrayViewTestCase::testAll()
162	{
163
164	{
165	cout << endl;
166
167	cout << "\tTest empty DataArrayView." << endl;
168
169	DataArrayView defView;
170
171	assert(defView.getOffset()==0);
172	assert(defView.getShape().empty());
173	assert(defView.noValues()==0);
174	assert(defView.getRank()==0);
175	}
176
177	{
178	cout << endl;
179
180	// define the shape for the data array view
181	cout << "\tTest shape (5):" << endl;
182	DataArrayView::ShapeType shape;
183	shape.push_back(5);
184	int offset=5;
185
186	// allocate the space external to the DataArrayView
187	DataArrayView::ValueType data(DataArrayView::noValues(shape)+offset,0);
188
189	// test constructor
190	cout << "\tTest DataArrayView constructor." << endl;
191	DataArrayView dataView(data,shape,offset);
192
193	// test shape set correctly
194	cout << "\tTest getShape." << endl;
195	assert(dataView.getShape()==shape);
196
197	// Assign values to the data
198	cout << "\tAssign values via () operator." << endl;
199	for (int i=0;i<shape[0];++i) {
200	//cout << i << ":" << dataView.index(i) << endl;
201	dataView(i)=dataView.index(i);
202	assert(dataView(i)==dataView.index(i));
203	}
204
205	// test operator==
206	cout << "\tTest == operator." << endl;
207	assert(dataView==dataView);
208	}
209
210	{
211	cout << endl;
212
213	// define the shape for the data array view
214	cout << "\tTest shape (2,3):" << endl;
215	DataArrayView::ShapeType shape;
216	shape.push_back(2);
217	shape.push_back(3);
218
219	// allocate the space external to the DataArrayView
220	DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
221
222	// test constructor
223	cout << "\tTest DataArrayView constructor." << endl;
224	DataArrayView dataView(data,shape);
225
226	// test shape set correctly
227	cout << "\tTest getShape." << endl;
228	assert(dataView.getShape()==shape);
229
230	// Assign values to the data
231	cout << "\tAssign values via () operator." << endl;
232	for (int i=0;i<shape[0];++i) {
233	for (int j=0;j<shape[1];++j) {
234	//cout << i << "," << j << ":" << dataView.index(i,j) << endl;
235	dataView(i,j)=dataView.index(i,j);
236	assert(dataView(i,j)==dataView.index(i,j));
237	}
238	}
239
240	// test operator==
241	cout << "\tTest == operator." << endl;
242	assert(dataView==dataView);
243	}
244
245	{
246	cout << endl;
247
248	// define the shape for the data array view
249	cout << "\tTest shape (2,3,4):" << endl;
250	DataArrayView::ShapeType shape;
251	shape.push_back(2);
252	shape.push_back(3);
253	shape.push_back(4);
254
255	// allocate the space external to the DataArrayView
256	DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
257
258	// test constructor
259	cout << "\tTest DataArrayView constructor." << endl;
260	DataArrayView dataView(data,shape);
261
262	// test shape set correctly
263	cout << "\tTest getShape." << endl;
264	assert(dataView.getShape()==shape);
265
266	// Assign values to the data
267	cout << "\tAssign values via () operator." << endl;
268	for (int i=0;i<shape[0];++i) {
269	for (int j=0;j<shape[1];++j) {
270	for (int k=0;k<shape[2];++k) {
271	//cout << i << "," << j << "," << k << ":" << dataView.index(i,j,k) << endl;
272	dataView(i,j,k)=dataView.index(i,j,k);
273	assert(dataView(i,j,k)==dataView.index(i,j,k));
274	}
275	}
276	}
277
278	// test operator==
279	cout << "\tTest == operator." << endl;
280	assert(dataView==dataView);
281	}
282
283	#if defined DOASSERT
284	{
285	cout << endl;
286
287	cout << "\tTest too many indices for rank of array exception." << endl;
288
289	DataArrayView::ShapeType shape;
290	DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
291	DataArrayView dataView(data,shape);
292
293	// Should be a scalar
294	dataView()=1;
295
296	try {
297	dataView(1)=1;
298	assert(false);
299	}
300	catch (EsysException& e) {
301	//cout << "\t" << e.what() << endl;
302	assert(true);
303	}
304
305	try {
306	dataView(1,1)=1;
307	assert(false);
308	}
309	catch (EsysException& e) {
310	//cout << "\t" << e.what() << endl;
311	assert(true);
312	}
313
314	try {
315	dataView(1,1,1)=1;
316	assert(false);
317	}
318	catch (EsysException& e) {
319	//cout << "\t" << e.what() << endl;
320	assert(true);
321	}
322	}
323
324	{
325	cout << endl;
326
327	cout << "\tTest invalid index exception." << endl;
328
329	DataArrayView::ShapeType shape;
330	shape.push_back(4);
331	DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
332	DataArrayView dataView(data,shape);
333
334	try {
335	dataView(4000)=1;
336	assert(false);
337	}
338	catch (EsysException& e) {
339	//cout << "\t" << e.what() << endl;
340	assert(true);
341	}
342	}
343
344	#endif
345
346	{
347	cout << endl;
348
349	cout << "\tTest insufficient data exception." << endl;
350
351	DataArrayView::ShapeType shape;
352	DataArrayView::ValueType data;
353
354	try {
355	DataArrayView dataView(data,shape);
356	assert(false);
357	}
358	catch (EsysException& e) {
359	//cout << "\t" << e.what() << endl;
360	assert(true);
361	}
362	}
363
364	{
365	cout << endl;
366
367	cout << "\tTest matrix multiplication." << endl;
368
369	DataArrayView::ShapeType leftShape;
370	leftShape.push_back(1);
371	leftShape.push_back(3);
372	DataArrayView::ValueType leftData(DataArrayView::noValues(leftShape),0);
373	DataArrayView leftDataView(leftData,leftShape);
374
375	DataArrayView::ShapeType rightShape;
376	rightShape.push_back(3);
377	rightShape.push_back(2);
378	DataArrayView::ValueType rightData(DataArrayView::noValues(rightShape),0);
379	DataArrayView rightDataView(rightData,rightShape);
380
381	DataArrayView::ShapeType resultShape=DataArrayView::determineResultShape(leftDataView,rightDataView);
382
383	for (int i=0;i<resultShape.size();++i) {
384	cout << "\tDimension: " << i << " size: " << resultShape[i] << endl;
385	}
386
387	DataArrayView::ValueType resultData(DataArrayView::noValues(resultShape),0);
388	DataArrayView resultDataView(resultData,resultShape);
389
390	cout << "\tTest result shape." << endl;
391
392	assert(resultShape.size()==2);
393	assert(resultShape[0]==1);
394	assert(resultShape[1]==2);
395
396	// Assign some values
397	cout << "\tAssign values." << endl;
398	double aValue=0.0;
399	for (int i=0;i<leftShape[0];++i) {
400	for (int j=0;j<leftShape[1];++j) {
401	leftDataView(i,j)=++aValue;
402	}
403	}
404	aValue=0.0;
405	for (int i=0;i<rightShape[0];++i) {
406	for (int j=0;j<rightShape[1];++j) {
407	rightDataView(i,j)=++aValue;
408	}
409	}
410
411	cout << "\tDo matrix multiplication." << endl;
412	DataArrayView::matMult(leftDataView,rightDataView,resultDataView);
413
414	cout << "\tCheck result." << endl;
415	//need to hand build result matrix and compare with generated result here.
416
417	/*
418	cout << "Create a vector." << endl;
419	DataArray v;
420	DataArray::ShapeType vShape;
421	vShape.push_back(3);
422	v.setShape(vShape);
423	double aValue=0.0;
424	for (int i=0;i<vShape[0];++i) {
425	v(i)=++aValue;
426	}
427
428	cout << "Create a matrix." << endl;
429	DataArray mat;
430	DataArray::ShapeType mShape;
431	mShape.push_back(3);
432	mShape.push_back(2);
433	mat.setShape(mShape);
434	aValue=0.0;
435	for (int i=0;i<mShape[0];++i) {
436	for (int j=0;j<mShape[1];++j) {
437	mat(i,j)=++aValue;
438	}
439	}
440
441	// [1,2,3] x \|1, 2\| = [22,28]
442	// \|3, 4\|
443	// \|5, 6\|
444
445	cout << "Test multiplication of matrix and vector." << endl;
446	DataArray result=DataArray::matMult(v,mat);
447	assert(fabs(result(0) - 22) < 0.1);
448	assert(fabs(result(1) - 28) < 0.1);
449	*/
450	}
451
452	}
453
454	TestSuite* DataArrayViewTestCase::suite ()
455	{
456	//
457	// create the suite of tests to perform.
458	TestSuite *testSuite = new TestSuite ("DataArrayViewTestCase");
459
460	testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testAll",&DataArrayViewTestCase::testAll));
461	testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testShapeToString",&DataArrayViewTestCase::testShapeToString));
462	testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testScalarView",&DataArrayViewTestCase::testScalarView));
463	testSuite->addTest (new TestCaller< DataArrayViewTestCase>("testSlicing",&DataArrayViewTestCase::testSlicing));
464	return testSuite;
465	}
466
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision