GitHub Viewer
/*******************************************************
* 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
using af::array;
using af::constant;
using af::dim4;
using std::vector;
TEST(BasicTests, constant1000x1000) {
static const int ndims = 2;
static const int dim_size = 1000;
dim_t d[ndims] = {dim_size, dim_size};
double valA = 3.9;
af_array a;
ASSERT_SUCCESS(af_constant(&a, valA, ndims, d, f32));
vector h_a(dim_size * dim_size, 100);
ASSERT_SUCCESS(af_get_data_ptr((void **)&h_a[0], a));
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) { ASSERT_FLOAT_EQ(valA, h_a[i]); }
ASSERT_SUCCESS(af_release_array(a));
}
TEST(BasicTests, constant10x10) {
static const int ndims = 2;
static const int dim_size = 10;
dim_t d[2] = {dim_size, dim_size};
double valA = 3.9;
af_array a;
ASSERT_SUCCESS(af_constant(&a, valA, ndims, d, f32));
vector h_a(dim_size * dim_size, 0);
ASSERT_SUCCESS(af_get_data_ptr((void **)&h_a[0], a));
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) { ASSERT_FLOAT_EQ(valA, h_a[i]); }
ASSERT_SUCCESS(af_release_array(a));
}
TEST(BasicTests, constant100x100) {
static const int ndims = 2;
static const int dim_size = 100;
dim_t d[2] = {dim_size, dim_size};
double valA = 4.9;
af_array a;
ASSERT_SUCCESS(af_constant(&a, valA, ndims, d, f32));
vector h_a(dim_size * dim_size, 0);
ASSERT_SUCCESS(af_get_data_ptr((void **)&h_a[0], a));
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) { ASSERT_FLOAT_EQ(valA, h_a[i]); }
ASSERT_SUCCESS(af_release_array(a));
}
// TODO: Test All The Types \o/
TEST(BasicTests, AdditionSameType) {
SUPPORTED_TYPE_CHECK(double);
static const int ndims = 2;
static const int dim_size = 100;
dim_t d[ndims] = {dim_size, dim_size};
double valA = 3.9;
double valB = 5.7;
double valCf = valA + valB;
af_array af32, bf32, cf32;
af_array af64, bf64, cf64;
ASSERT_SUCCESS(af_constant(&af32, valA, ndims, d, f32));
ASSERT_SUCCESS(af_constant(&af64, valA, ndims, d, f64));
ASSERT_SUCCESS(af_constant(&bf32, valB, ndims, d, f32));
ASSERT_SUCCESS(af_constant(&bf64, valB, ndims, d, f64));
ASSERT_SUCCESS(af_add(&cf32, af32, bf32, false));
ASSERT_SUCCESS(af_add(&cf64, af64, bf64, false));
vector h_cf32(dim_size * dim_size);
vector h_cf64(dim_size * dim_size);
ASSERT_SUCCESS(af_get_data_ptr((void **)&h_cf32[0], cf32));
ASSERT_SUCCESS(af_get_data_ptr((void **)&h_cf64[0], cf64));
double err = 0;
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) {
float df = h_cf32[i] - (valCf);
ASSERT_FLOAT_EQ(valCf, h_cf32[i]);
ASSERT_FLOAT_EQ(valCf, h_cf64[i]);
err = err + df * df;
}
ASSERT_NEAR(0.0f, err, 1e-8);
ASSERT_SUCCESS(af_release_array(af32));
ASSERT_SUCCESS(af_release_array(af64));
ASSERT_SUCCESS(af_release_array(bf32));
ASSERT_SUCCESS(af_release_array(bf64));
ASSERT_SUCCESS(af_release_array(cf32));
ASSERT_SUCCESS(af_release_array(cf64));
}
TEST(BasicTests, Additionf64f64) {
SUPPORTED_TYPE_CHECK(double);
static const int ndims = 2;
static const int dim_size = 100;
dim_t d[ndims] = {dim_size, dim_size};
double valA = 3.9;
double valB = 5.7;
double valC = valA + valB;
af_array a, b, c;
ASSERT_SUCCESS(af_constant(&a, valA, ndims, d, f64));
ASSERT_SUCCESS(af_constant(&b, valB, ndims, d, f64));
ASSERT_SUCCESS(af_add(&c, a, b, false));
vector h_c(dim_size * dim_size, 0);
ASSERT_SUCCESS(af_get_data_ptr((void **)&h_c[0], c));
double err = 0;
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) {
double df = h_c[i] - (valC);
ASSERT_FLOAT_EQ(valA + valB, h_c[i]);
err = err + df * df;
}
ASSERT_NEAR(0.0f, err, 1e-8);
ASSERT_SUCCESS(af_release_array(a));
ASSERT_SUCCESS(af_release_array(b));
ASSERT_SUCCESS(af_release_array(c));
}
TEST(BasicTests, Additionf32f64) {
SUPPORTED_TYPE_CHECK(double);
static const int ndims = 2;
static const int dim_size = 100;
dim_t d[ndims] = {dim_size, dim_size};
double valA = 3.9;
double valB = 5.7;
double valC = valA + valB;
af_array a, b, c;
ASSERT_SUCCESS(af_constant(&a, valA, ndims, d, f32));
ASSERT_SUCCESS(af_constant(&b, valB, ndims, d, f64));
ASSERT_SUCCESS(af_add(&c, a, b, false));
vector h_c(dim_size * dim_size);
ASSERT_SUCCESS(af_get_data_ptr((void **)&h_c[0], c));
double err = 0;
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) {
double df = h_c[i] - (valC);
ASSERT_FLOAT_EQ(valA + valB, h_c[i]);
err = err + df * df;
}
ASSERT_NEAR(0.0f, err, 1e-8);
ASSERT_SUCCESS(af_release_array(a));
ASSERT_SUCCESS(af_release_array(b));
ASSERT_SUCCESS(af_release_array(c));
}
TEST(BasicArrayTests, constant10x10) {
dim_t dim_size = 10;
double valA = 3.14;
array a = constant(valA, dim_size, dim_size, f32);
vector h_a(dim_size * dim_size, 0);
a.host(&h_a.front());
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) { ASSERT_FLOAT_EQ(valA, h_a[i]); }
}
////////////////////////////////////// CPP Tests
/////////////////////////////////////
using af::dim4;
TEST(BasicTests, constant100x100_CPP) {
static const int dim_size = 100;
dim_t d[2] = {dim_size, dim_size};
double valA = 4.9;
dim4 dims(d[0], d[1]);
array a = constant(valA, dims);
vector h_a(dim_size * dim_size, 0);
a.host((void **)&h_a[0]);
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) { ASSERT_FLOAT_EQ(valA, h_a[i]); }
}
// TODO: Test All The Types \o/
TEST(BasicTests, AdditionSameType_CPP) {
SUPPORTED_TYPE_CHECK(double);
static const int dim_size = 100;
dim_t d[2] = {dim_size, dim_size};
dim4 dims(d[0], d[1]);
double valA = 3.9;
double valB = 5.7;
double valCf = valA + valB;
array a32 = constant(valA, dims, f32);
array b32 = constant(valB, dims, f32);
array c32 = a32 + b32;
array a64 = constant(valA, dims, f64);
array b64 = constant(valB, dims, f64);
array c64 = a64 + b64;
vector h_cf32(dim_size * dim_size);
vector h_cf64(dim_size * dim_size);
c32.host((void **)&h_cf32[0]);
c64.host((void **)&h_cf64[0]);
double err = 0;
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) {
float df = h_cf32[i] - (valCf);
ASSERT_FLOAT_EQ(valCf, h_cf32[i]);
ASSERT_FLOAT_EQ(valCf, h_cf64[i]);
err = err + df * df;
}
ASSERT_NEAR(0.0f, err, 1e-8);
}
TEST(BasicTests, Additionf32f64_CPP) {
SUPPORTED_TYPE_CHECK(double);
static const int dim_size = 100;
dim_t d[2] = {dim_size, dim_size};
dim4 dims(d[0], d[1]);
double valA = 3.9;
double valB = 5.7;
double valC = valA + valB;
array a = constant(valA, dims);
array b = constant(valB, dims, f64);
array c = a + b;
vector h_c(dim_size * dim_size);
c.host((void **)&h_c[0]);
double err = 0;
size_t elements = dim_size * dim_size;
for (size_t i = 0; i < elements; i++) {
double df = h_c[i] - (valC);
ASSERT_FLOAT_EQ(valA + valB, h_c[i]);
err = err + df * df;
}
ASSERT_NEAR(0.0f, err, 1e-8);
}
TEST(Assert, TestEqualsCpp) {
array gold = constant(1, 10, 10);
array out = constant(1, 10, 10);
// Testing this macro
// ASSERT_ARRAYS_EQ(gold, out);
ASSERT_TRUE(assertArrayEq("gold", "out", gold, out));
}
TEST(Assert, TestEqualsC) {
af_array gold = 0;
af_array out = 0;
dim_t dims[] = {10, 10, 1, 1};
af_constant(&gold, 1.0, 4, dims, f32);
af_constant(&out, 1.0, 4, dims, f32);
// Testing this macro
// ASSERT_ARRAYS_EQ(gold, out);
ASSERT_TRUE(assertArrayEq("gold", "out", gold, out));
ASSERT_SUCCESS(af_release_array(out));
ASSERT_SUCCESS(af_release_array(gold));
}
TEST(Assert, TestEqualsDiffTypes) {
SUPPORTED_TYPE_CHECK(double);
array gold = constant(1, 10, 10, f64);
array out = constant(1, 10, 10);
// Testing this macro
// ASSERT_ARRAYS_EQ(gold, out);
ASSERT_FALSE(assertArrayEq("gold", "out", gold, out));
}
TEST(Assert, TestEqualsDiffSizes) {
array gold = constant(1, 10, 9);
array out = constant(1, 10, 10);
// Testing this macro
// ASSERT_ARRAYS_EQ(gold, out);
ASSERT_FALSE(assertArrayEq("gold", "out", gold, out));
}
TEST(Assert, TestEqualsDiffValue) {
array gold = constant(1, 3, 3);
array out = gold;
out(2, 2) = 2;
// Testing this macro
// ASSERT_ARRAYS_EQ(gold, out);
ASSERT_FALSE(assertArrayEq("gold", "out", gold, out));
}
TEST(Assert, TestEqualsDiffComplexValue) {
array gold = constant(af::cfloat(3.1f, 3.1f), 3, 3, c32);
array out = gold;
out(2, 2) = 2.2;
// Testing this macro
// ASSERT_ARRAYS_EQ(gold, out);
ASSERT_FALSE(assertArrayEq("gold", "out", gold, out));
}
TEST(Assert, TestVectorEquals) {
array out = constant(3.1f, 3, 3);
vector gold(out.elements());
dim4 goldDims(3, 3);
fill(gold.begin(), gold.end(), 3.1f);
// Testing this macro
// ASSERT_VEC_ARRAY_EQ(gold, goldDims, out);
ASSERT_TRUE(assertArrayEq("gold", "goldDims", "out", gold, goldDims, out));
}
TEST(Assert, TestVectorDiffVecType) {
array out = constant(3.1f, 3, 3);
vector gold(out.elements());
dim4 goldDims(3, 3);
fill(gold.begin(), gold.end(), 3.1f);
// Testing this macro
// ASSERT_VEC_ARRAY_EQ(gold, goldDims, out);
ASSERT_FALSE(assertArrayEq("gold", "goldDims", "out", gold, goldDims, out));
}
TEST(Assert, TestVectorDiffGoldSizeDims) {
array out = constant(3.1f, 3, 3);
vector gold(3 * 3);
dim4 goldDims(3, 2);
fill(gold.begin(), gold.end(), 3.1f);
// Testing this macro
// ASSERT_VEC_ARRAY_EQ(gold, goldDims, out);
ASSERT_FALSE(assertArrayEq("gold", "goldDims", "out", gold, goldDims, out));
}
TEST(Assert, TestVectorDiffOutSizeGoldSize) {
array out = constant(3.1f, 3, 3);
vector gold(3 * 2);
dim4 goldDims(3, 2);
fill(gold.begin(), gold.end(), 3.1f);
// Testing this macro
// ASSERT_VEC_ARRAY_EQ(gold, goldDims, out);
ASSERT_FALSE(assertArrayEq("gold", "goldDims", "out", gold, goldDims, out));
}
TEST(Assert, TestVectorDiffDim4) {
array out = constant(3.1f, 3, 3);
vector gold(out.elements());
dim4 goldDims(3, 2);
fill(gold.begin(), gold.end(), 3.1f);
// Testing this macro
// ASSERT_VEC_ARRAY_EQ(gold, goldDims, out);
ASSERT_FALSE(assertArrayEq("gold", "goldDims", "out", gold, goldDims, out));
}
TEST(Assert, TestVectorDiffVecSize) {
array out = constant(3.1f, 3, 3);
vector gold(out.elements() - 1);
dim4 goldDims(3, 3);
fill(gold.begin(), gold.end(), 3.1f);
// Testing this macro
// ASSERT_VEC_ARRAY_EQ(gold, goldDims, out);
ASSERT_FALSE(assertArrayEq("gold", "goldDims", "out", gold, goldDims, out));
}
TEST(Assert, TestArraysNearC) {
af_array gold = 0;
af_array out = 0;
dim_t dims[] = {10, 10, 1, 1};
af_constant(&gold, 2.2345f, 4, dims, f32);
af_constant(&out, 2.2346f, 4, dims, f32);
float maxDiff = 0.001f;
// Testing this macro
// ASSERT_ARRAYS_NEAR(gold, out, maxDiff);
ASSERT_TRUE(assertArrayNear("gold", "out", "maxDiff", gold, out, maxDiff));
ASSERT_SUCCESS(af_release_array(out));
ASSERT_SUCCESS(af_release_array(gold));
}
TEST(Assert, TestVecArrayNearC) {
vector gold(3 * 3);
fill(gold.begin(), gold.end(), 2.2345f);
dim4 goldDims(3, 3);
af_array out = 0;
dim_t dims[] = {3, 3, 1, 1};
af_constant(&out, 2.2346f, 4, dims, f32);
float maxDiff = 0.001f;
// Testing this macro
// ASSERT_VEC_ARRAY_NEAR(gold, goldDims, out, maxDiff);
ASSERT_TRUE(assertArrayNear("gold", "goldDims", "out", "maxDiff", gold,
goldDims, out, maxDiff));
ASSERT_SUCCESS(af_release_array(out));
}
TEST(Assert, TestArraysNearWithinThresh) {
array gold = constant(2.2345f, 3, 3);
array out = gold;
out(2, 2) += 0.0001f;
float maxDiff = 0.001f;
// Testing this macro
// ASSERT_ARRAYS_NEAR(gold, out, maxDiff);
ASSERT_TRUE(assertArrayNear("gold", "out", "maxDiff", gold, out, maxDiff));
}
TEST(Assert, TestArraysNearExceedThresh) {
array gold = constant(2.2345f, 3, 3);
array out = gold;
out(2, 2) += 0.002f;
float maxDiff = 0.001f;
// Testing this macro
// ASSERT_ARRAYS_NEAR(gold, out, maxDiff);
ASSERT_FALSE(assertArrayNear("gold", "out", "maxDiff", gold, out, maxDiff));
}
TEST(Assert, TestVecArrayNearWithinThresh) {
vector gold(3 * 3);
fill(gold.begin(), gold.end(), 2.2345f);
dim4 goldDims(3, 3);
array out = constant(2.2345f, goldDims);
out(2, 2) += 0.0001f;
float maxDiff = 0.001f;
// Testing this macro
// ASSERT_VEC_ARRAY_NEAR(gold, goldDims, out, maxDiff);
ASSERT_TRUE(assertArrayNear("gold", "goldDims", "out", "maxAbsDiff", gold,
goldDims, out, maxDiff));
}
TEST(Assert, TestVecArrayNearExceedThresh) {
vector gold(3 * 3);
fill(gold.begin(), gold.end(), 2.2345f);
dim4 goldDims(3, 3);
array out = constant(2.2345f, goldDims);
out(2, 2) += 0.002f;
float maxDiff = 0.001f;
// Testing this macro
// ASSERT_VEC_ARRAY_NEAR(gold, goldDims, out, maxDiff);
ASSERT_FALSE(assertArrayNear("gold", "goldDims", "out", "maxAbsDiff", gold,
goldDims, out, maxDiff));
}