/*******************************************************
* Copyright (c) 2014, ArrayFire
* All rights reserved.
*
* This file is distributed under 3-clause BSD license.
* The complete license agreement can be obtained at:
* http://arrayfire.com/licenses/BSD-3-Clause
********************************************************/
#include
#include
#include
#include
#include
#include
#include
#include
using af::array;
using af::cdouble;
using af::cfloat;
using af::constant;
using af::dim4;
using af::dtype_traits;
using af::end;
using af::exception;
using af::randu;
using af::seq;
using af::span;
using std::cout;
using std::endl;
using std::string;
using std::vector;
template
class ArrayAssign : public ::testing::Test {
public:
virtual void SetUp() {
subMat1D.push_back(af_make_seq(5, 20, 1));
subMat2D.push_back(af_make_seq(1, 2, 1));
subMat2D.push_back(af_make_seq(1, 2, 1));
subMat3D.push_back(af_make_seq(3, 4, 1));
subMat3D.push_back(af_make_seq(0, 1, 1));
subMat3D.push_back(af_make_seq(1, 2, 1));
subMat4D.push_back(af_make_seq(3, 4, 1));
subMat4D.push_back(af_make_seq(0, 1, 1));
subMat4D.push_back(af_make_seq(0, 1, 1));
subMat4D.push_back(af_make_seq(1, 2, 1));
subMat1D_to_2D.push_back(af_make_seq(1, 2, 1));
subMat1D_to_2D.push_back(af_make_seq(1, 1, 1));
subMat1D_to_3D.push_back(af_make_seq(5, 20, 1));
subMat1D_to_3D.push_back(af_make_seq(1, 1, 1));
subMat1D_to_3D.push_back(af_make_seq(2, 2, 1));
subMat2D_to_3D.push_back(af_make_seq(3, 4, 1));
subMat2D_to_3D.push_back(af_make_seq(0, 1, 1));
subMat2D_to_3D.push_back(af_make_seq(1, 1, 1));
subMat1D_to_4D.push_back(af_make_seq(3, 4, 1));
subMat1D_to_4D.push_back(af_make_seq(0, 0, 1));
subMat1D_to_4D.push_back(af_make_seq(0, 0, 1));
subMat1D_to_4D.push_back(af_make_seq(1, 1, 1));
subMat2D_to_4D.push_back(af_make_seq(3, 4, 1));
subMat2D_to_4D.push_back(af_make_seq(0, 1, 1));
subMat2D_to_4D.push_back(af_make_seq(0, 0, 1));
subMat2D_to_4D.push_back(af_make_seq(1, 1, 1));
subMat3D_to_4D.push_back(af_make_seq(3, 4, 1));
subMat3D_to_4D.push_back(af_make_seq(0, 1, 1));
subMat3D_to_4D.push_back(af_make_seq(0, 1, 1));
subMat3D_to_4D.push_back(af_make_seq(1, 1, 1));
}
vector subMat1D;
vector subMat2D;
vector subMat1D_to_2D;
vector subMat3D;
vector subMat1D_to_3D;
vector subMat2D_to_3D;
vector subMat4D;
vector subMat1D_to_4D;
vector subMat2D_to_4D;
vector subMat3D_to_4D;
};
// create a list of types to be tested
typedef ::testing::Types
TestTypes;
// register the type list
TYPED_TEST_SUITE(ArrayAssign, TestTypes);
template
void assignTest(string pTestFile, const vector *seqv) {
SUPPORTED_TYPE_CHECK(inType);
SUPPORTED_TYPE_CHECK(outType);
vector numDims;
vector in;
vector tests;
readTests(pTestFile, numDims, in, tests);
dim4 dims0 = numDims[0];
dim4 dims1 = numDims[1];
af_array lhsArray = 0;
af_array rhsArray = 0;
af_array outArray = 0;
ASSERT_SUCCESS(af_create_array(&rhsArray, &(in[0].front()), dims0.ndims(),
dims0.get(),
(af_dtype)dtype_traits::af_type));
ASSERT_SUCCESS(af_create_array(&lhsArray, &(in[1].front()), dims1.ndims(),
dims1.get(),
(af_dtype)dtype_traits::af_type));
ASSERT_SUCCESS(af_assign_seq(&outArray, lhsArray, seqv->size(),
&seqv->front(), rhsArray));
outType *outData = new outType[dims1.elements()];
ASSERT_SUCCESS(af_get_data_ptr((void *)outData, outArray));
vector currGoldBar = tests[0];
size_t nElems = currGoldBar.size();
for (size_t elIter = 0; elIter < nElems; ++elIter) {
ASSERT_EQ(currGoldBar[elIter], outData[elIter])
subMat4D);
}
TYPED_TEST(ArrayAssign, Vector2Matrix) {
assignTest(string(TEST_DIR "/assign/1d_to_2d.test"),
&(this->subMat1D_to_2D));
}
TYPED_TEST(ArrayAssign, Vector2MatrixCPP) {
assignTestCPP(string(TEST_DIR "/assign/1d_to_2d.test"),
this->subMat1D_to_2D);
}
TYPED_TEST(ArrayAssign, Vector2Cube) {
assignTest(string(TEST_DIR "/assign/1d_to_3d.test"),
&(this->subMat1D_to_3D));
}
TYPED_TEST(ArrayAssign, Vector2CubeCPP) {
assignTestCPP(string(TEST_DIR "/assign/1d_to_3d.test"),
this->subMat1D_to_3D);
}
TYPED_TEST(ArrayAssign, Matrix2Cube) {
assignTest(string(TEST_DIR "/assign/2d_to_3d.test"),
&(this->subMat2D_to_3D));
}
TYPED_TEST(ArrayAssign, Matrix2CubeCPP) {
assignTestCPP(string(TEST_DIR "/assign/2d_to_3d.test"),
this->subMat2D_to_3D);
}
TYPED_TEST(ArrayAssign, Vector2HyperCube) {
assignTest(string(TEST_DIR "/assign/1d_to_4d.test"),
&(this->subMat1D_to_4D));
}
TYPED_TEST(ArrayAssign, Vector2HyperCubeCPP) {
assignTestCPP(string(TEST_DIR "/assign/1d_to_4d.test"),
this->subMat1D_to_4D);
}
TYPED_TEST(ArrayAssign, Matrix2HyperCube) {
assignTest(string(TEST_DIR "/assign/2d_to_4d.test"),
&(this->subMat2D_to_4D));
}
TYPED_TEST(ArrayAssign, Matrix2HyperCubeCPP) {
assignTestCPP(string(TEST_DIR "/assign/2d_to_4d.test"),
this->subMat2D_to_4D);
}
TYPED_TEST(ArrayAssign, Cube2HyperCube) {
assignTest(string(TEST_DIR "/assign/3d_to_4d.test"),
&(this->subMat3D_to_4D));
}
TYPED_TEST(ArrayAssign, Cube2HyperCubeCPP) {
assignTestCPP(string(TEST_DIR "/assign/3d_to_4d.test"),
this->subMat3D_to_4D);
}
template
void assignScalarCPP(string pTestFile, const vector &seqv) {
SUPPORTED_TYPE_CHECK(T);
try {
vector numDims;
vector in;
vector tests;
readTests(pTestFile, numDims, in, tests);
dim4 dims1 = numDims[1];
T a = in[0][0];
array b(dims1, &(in[1].front()));
switch (seqv.size()) {
case 1: b(seqv[0]) = a; break;
case 2: b(seqv[0], seqv[1]) = a; break;
case 3: b(seqv[0], seqv[1], seqv[2]) = a; break;
case 4: b(seqv[0], seqv[1], seqv[2], seqv[3]) = a; break;
default: assert(1 != 1 && "Does not compute");
}
T *outData = new T[dims1.elements()];
b.host(outData);
vector currGoldBar = tests[0];
size_t nElems = currGoldBar.size();
for (size_t elIter = 0; elIter < nElems; ++elIter) {
if (currGoldBar[elIter] != outData[elIter]) {
switch (seqv.size()) {
case 1: printf("b(seqv[0]) = a\n"); break;
case 2: printf("b(seqv[0],seqv[1]) = a\n"); break;
case 3: printf("b(seqv[0],seqv[1], seqv[2]) = a\n"); break;
case 4:
printf("b(seqv[0],seqv[1], seqv[2], seqv[3]) = a\n");
break;
default: assert(1 != 1 && "Does not compute");
}
cout