/*******************************************************

* 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 <gtest/gtest.h>

#include <testHelpers.hpp>

#include <af/arith.h>

#include <af/array.h>

#include <af/data.h>

#include <af/device.h>

#include <af/random.h>

#include <cfenv>

#include <cmath>

using namespace std;

using namespace af;

const int num = 10000;

#define add(left, right) (left) + (right)

#define sub(left, right) (left) - (right)

#define mul(left, right) (left) * (right)

#define div(left, right) (left) / (right)

typedef std::complex<float> complex_float;

typedef std::complex<double> complex_double;

template<typename T>

T mod(T a, T b) {

return std::fmod(a, b);

}

af::array randgen(const int num, dtype ty) {

af::array tmp = round(1 + 2 * af::randu(num, f32)).as(ty);

tmp.eval();

return tmp;

}

#define MY_ASSERT_NEAR(aa, bb, cc) ASSERT_NEAR(abs(aa), abs(bb), (cc))

#define BINARY_TESTS(Ta, Tb, Tc, func) \

TEST(BinaryTests, Test_##func##_##Ta##_##Tb) { \

SUPPORTED_TYPE_CHECK(Ta); \

SUPPORTED_TYPE_CHECK(Tb); \

SUPPORTED_TYPE_CHECK(Tc); \

\

af_dtype ta = (af_dtype)dtype_traits<Ta>::af_type; \

af_dtype tb = (af_dtype)dtype_traits<Tb>::af_type; \

af::array a = randgen(num, ta); \

af::array b = randgen(num, tb); \

af::array c = func(a, b); \

Ta *h_a = a.host<Ta>(); \

Tb *h_b = b.host<Tb>(); \

Tc *h_c = c.host<Tc>(); \

for (int i = 0; i < num; i++) \

ASSERT_EQ(h_c[i], func(h_a[i], h_b[i])) \

<< "for values: " << h_a[i] << "," << h_b[i] << endl; \

af_free_host(h_a); \

af_free_host(h_b); \

af_free_host(h_c); \

} \

\

TEST(BinaryTests, Test_##func##_##Ta##_##Tb##_left) { \

SUPPORTED_TYPE_CHECK(Ta); \

SUPPORTED_TYPE_CHECK(Tb); \

\

af_dtype ta = (af_dtype)dtype_traits<Ta>::af_type; \

af::array a = randgen(num, ta); \

Tb h_b = 3.0; \

af::array c = func(a, h_b); \

Ta *h_a = a.host<Ta>(); \

Ta *h_c = c.host<Ta>(); \

for (int i = 0; i < num; i++) \

ASSERT_EQ(h_c[i], func(h_a[i], h_b)) \

<< "for values: " << h_a[i] << "," << h_b << endl; \

af_free_host(h_a); \

af_free_host(h_c); \

} \

\

TEST(BinaryTests, Test_##func##_##Ta##_##Tb##_right) { \

SUPPORTED_TYPE_CHECK(Ta); \

SUPPORTED_TYPE_CHECK(Tb); \

\

af_dtype tb = (af_dtype)dtype_traits<Tb>::af_type; \

Ta h_a = 5.0; \

af::array b = randgen(num, tb); \

af::array c = func(h_a, b); \

Tb *h_b = b.host<Tb>(); \

Tb *h_c = c.host<Tb>(); \

for (int i = 0; i < num; i++) \

ASSERT_EQ(h_c[i], func(h_a, h_b[i])) \

<< "for values: " << h_a << "," << h_b[i] << endl; \

af_free_host(h_b); \

af_free_host(h_c); \

}

#define BINARY_TESTS_NEAR_GENERAL(Ta, Tb, Tc, Td, Te, func, err) \

TEST(BinaryTestsFloating, Test_##func##_##Ta##_##Tb) { \

SUPPORTED_TYPE_CHECK(Ta); \

SUPPORTED_TYPE_CHECK(Tb); \

SUPPORTED_TYPE_CHECK(Tc); \

\

af_dtype ta = (af_dtype)dtype_traits<Ta>::af_type; \

af_dtype tb = (af_dtype)dtype_traits<Tb>::af_type; \

af::array a = randgen(num, ta); \

af::array b = randgen(num, tb); \

af::array c = func(a, b); \

Ta *h_a = a.host<Ta>(); \

Tb *h_b = b.host<Tb>(); \

Tc *h_c = c.host<Tc>(); \

for (int i = 0; i < num; i++) \

MY_ASSERT_NEAR(h_c[i], func(h_a[i], h_b[i]), (err)) \

<< "for values: " << h_a[i] << "," << h_b[i] << endl; \

af_free_host(h_a); \

af_free_host(h_b); \

af_free_host(h_c); \

} \

\

TEST(BinaryTestsFloating, Test_##func##_##Ta##_##Tb##_left) { \

SUPPORTED_TYPE_CHECK(Ta); \

SUPPORTED_TYPE_CHECK(Tb); \

\

af_dtype ta = (af_dtype)dtype_traits<Ta>::af_type; \

af::array a = randgen(num, ta); \

Tb h_b = 0.3; \

af::array c = func(a, h_b); \

Ta *h_a = a.host<Ta>(); \

Td *h_d = c.host<Td>(); \

for (int i = 0; i < num; i++) \

MY_ASSERT_NEAR(h_d[i], func(h_a[i], h_b), err) \

<< "for values: " << h_a[i] << "," << h_b << endl; \

af_free_host(h_a); \

af_free_host(h_d); \

} \

\

TEST(BinaryTestsFloating, Test_##func##_##Ta##_##Tb##_right) { \

SUPPORTED_TYPE_CHECK(Ta); \

SUPPORTED_TYPE_CHECK(Tb); \

SUPPORTED_TYPE_CHECK(Tc); \

\

af_dtype tb = (af_dtype)dtype_traits<Tb>::af_type; \

Ta h_a = 0.3; \

af::array b = randgen(num, tb); \

af::array c = func(h_a, b); \

Tb *h_b = b.host<Tb>(); \

Te *h_e = c.host<Te>(); \

for (int i = 0; i < num; i++) \

MY_ASSERT_NEAR(h_e[i], func(h_a, h_b[i]), err) \

<< "for values: " << h_a << "," << h_b[i] << endl; \

af_free_host(h_b); \

af_free_host(h_e); \

}

#define BINARY_TESTS_NEAR(Ta, Tb, Tc, func, err) \

BINARY_TESTS_NEAR_GENERAL(Ta, Tb, Tc, Ta, Tc, func, err)

#define BINARY_TESTS_FLOAT(func) BINARY_TESTS(float, float, float, func)

#define BINARY_TESTS_DOUBLE(func) BINARY_TESTS(double, double, double, func)

#define BINARY_TESTS_CFLOAT(func) BINARY_TESTS(cfloat, cfloat, cfloat, func)

#define BINARY_TESTS_CDOUBLE(func) BINARY_TESTS(cdouble, cdouble, cdouble, func)

#define BINARY_TESTS_INT(func) BINARY_TESTS(int, int, int, func)

#define BINARY_TESTS_UINT(func) BINARY_TESTS(uint, uint, uint, func)

#define BINARY_TESTS_INTL(func) BINARY_TESTS(intl, intl, intl, func)

#define BINARY_TESTS_UINTL(func) BINARY_TESTS(uintl, uintl, uintl, func)

#define BINARY_TESTS_NEAR_FLOAT(func) \

BINARY_TESTS_NEAR(float, float, float, func, 1e-5)

#define BINARY_TESTS_NEAR_DOUBLE(func) \

BINARY_TESTS_NEAR(double, double, double, func, 1e-10)

BINARY_TESTS_FLOAT(add)

BINARY_TESTS_FLOAT(sub)

BINARY_TESTS_FLOAT(mul)

BINARY_TESTS_NEAR(float, float, float, div, 1e-3) // FIXME

BINARY_TESTS_FLOAT(min)

BINARY_TESTS_FLOAT(max)

BINARY_TESTS_NEAR(float, float, float, mod, 1e-5) // FIXME

BINARY_TESTS_DOUBLE(add)

BINARY_TESTS_DOUBLE(sub)

BINARY_TESTS_DOUBLE(mul)

BINARY_TESTS_DOUBLE(div)

BINARY_TESTS_DOUBLE(min)

BINARY_TESTS_DOUBLE(max)

BINARY_TESTS_DOUBLE(mod)

BINARY_TESTS_NEAR_FLOAT(atan2)

BINARY_TESTS_NEAR_FLOAT(pow)

BINARY_TESTS_NEAR_FLOAT(hypot)

BINARY_TESTS_NEAR_DOUBLE(atan2)

BINARY_TESTS_NEAR_DOUBLE(pow)

BINARY_TESTS_NEAR_DOUBLE(hypot)

BINARY_TESTS_INT(add)

BINARY_TESTS_INT(sub)

BINARY_TESTS_INT(mul)

BINARY_TESTS_UINT(add)

BINARY_TESTS_UINT(sub)

BINARY_TESTS_UINT(mul)

BINARY_TESTS_INTL(add)

BINARY_TESTS_INTL(sub)

BINARY_TESTS_INTL(mul)

BINARY_TESTS_UINTL(add)

BINARY_TESTS_UINTL(sub)

BINARY_TESTS_UINTL(mul)

BINARY_TESTS_CFLOAT(add)

BINARY_TESTS_CFLOAT(sub)

BINARY_TESTS_CDOUBLE(add)

BINARY_TESTS_CDOUBLE(sub)

// Mixed types

BINARY_TESTS_NEAR(float, double, double, add, 1e-5)

BINARY_TESTS_NEAR(float, double, double, sub, 1e-5)

BINARY_TESTS_NEAR(float, double, double, mul, 1e-5)

BINARY_TESTS_NEAR(float, double, double, div, 1e-5)

BINARY_TESTS_NEAR(cfloat, cdouble, cdouble, add, 1e-5)

BINARY_TESTS_NEAR(cfloat, cdouble, cdouble, sub, 1e-5)

BINARY_TESTS_NEAR(cfloat, cdouble, cdouble, mul, 1e-5)

BINARY_TESTS_NEAR(cfloat, cdouble, cdouble, div, 1e-5)

BINARY_TESTS_NEAR_GENERAL(float, cfloat, cfloat, cfloat, cfloat, add, 1e-5)

BINARY_TESTS_NEAR_GENERAL(float, cfloat, cfloat, cfloat, cfloat, sub, 1e-5)

BINARY_TESTS_NEAR_GENERAL(float, cfloat, cfloat, cfloat, cfloat, mul, 1e-5)

BINARY_TESTS_NEAR_GENERAL(float, cfloat, cfloat, cfloat, cfloat, div, 1e-5)

BINARY_TESTS_NEAR_GENERAL(double, cfloat, cdouble, cdouble, cfloat, add, 1e-5)

BINARY_TESTS_NEAR_GENERAL(double, cfloat, cdouble, cdouble, cfloat, sub, 1e-5)

BINARY_TESTS_NEAR_GENERAL(double, cfloat, cdouble, cdouble, cfloat, mul, 1e-5)

BINARY_TESTS_NEAR_GENERAL(double, cfloat, cdouble, cdouble, cfloat, div, 1e-5)

BINARY_TESTS_NEAR_GENERAL(cfloat, double, cdouble, cfloat, cdouble, add, 1e-5)

BINARY_TESTS_NEAR_GENERAL(cfloat, double, cdouble, cfloat, cdouble, sub, 1e-5)

BINARY_TESTS_NEAR_GENERAL(cfloat, double, cdouble, cfloat, cdouble, mul, 1e-5)

BINARY_TESTS_NEAR_GENERAL(cfloat, double, cdouble, cfloat, cdouble, div, 1e-5)

#define BITOP(func, T, op) \

TEST(BinaryTests, Test_##func##_##T) { \

af_dtype ty = (af_dtype)dtype_traits<T>::af_type; \

const T vala = 4095; \

const T valb = 3; \

const T valc = vala op valb; \

const int num = 10; \

af::array a = af::constant(vala, num, ty); \

af::array b = af::constant(valb, num, ty); \

af::array c = a op b; \

T *h_a = a.host<T>(); \

T *h_b = b.host<T>(); \

T *h_c = c.host<T>(); \

for (int i = 0; i < num; i++) \

ASSERT_EQ(h_c[i], valc) \

<< "for values: " << h_a[i] << "," << h_b[i] << endl; \

af_free_host(h_a); \

af_free_host(h_b); \

af_free_host(h_c); \

}

BITOP(bitor, int, |)

BITOP(bitand, int, &)

BITOP(bitxor, int, ^)

BITOP(bitshiftl, int, <<)

BITOP(bitshiftr, int, >>)

BITOP(bitor, uint, |)

BITOP(bitand, uint, &)

BITOP(bitxor, uint, ^)

BITOP(bitshiftl, uint, <<)

BITOP(bitshiftr, uint, >>)

BITOP(bitor, intl, |)

BITOP(bitand, intl, &)

BITOP(bitxor, intl, ^)

BITOP(bitshiftl, intl, <<)

BITOP(bitshiftr, intl, >>)

BITOP(bitor, uintl, |)

BITOP(bitand, uintl, &)

BITOP(bitxor, uintl, ^)

BITOP(bitshiftl, uintl, <<)

BITOP(bitshiftr, uintl, >>)

TEST(BinaryTests, Test_pow_cfloat_float) {

af::array a = randgen(num, c32);

af::array b = randgen(num, f32);

af::array c = af::pow(a, b);

complex_float *h_a = (complex_float *)a.host<cfloat>();

float *h_b = b.host<float>();

complex_float *h_c = (complex_float *)c.host<cfloat>();

for (int i = 0; i < num; i++) {

complex_float res = std::pow(h_a[i], h_b[i]);

ASSERT_NEAR(real(h_c[i]), real(res), 1E-5)

<< "for real values of: " << h_a[i] << "," << h_b[i] << endl;

ASSERT_NEAR(imag(h_c[i]), imag(res), 1E-5)

<< "for imag values of: " << h_a[i] << "," << h_b[i] << endl;

}

af_free_host(h_a);

af_free_host(h_b);

af_free_host(h_c);

}

TEST(BinaryTests, Test_pow_cdouble_cdouble) {

SUPPORTED_TYPE_CHECK(cdouble);

af::array a = randgen(num, c64);

af::array b = randgen(num, c64);

af::array c = af::pow(a, b);

complex_double *h_a = (complex_double *)a.host<cdouble>();

complex_double *h_b = (complex_double *)b.host<cdouble>();

complex_double *h_c = (complex_double *)c.host<cdouble>();

for (int i = 0; i < num; i++) {

complex_double res = std::pow(h_a[i], h_b[i]);

ASSERT_NEAR(real(h_c[i]), real(res), 1E-10)

<< "for real values of: " << h_a[i] << "," << h_b[i] << endl;

ASSERT_NEAR(imag(h_c[i]), imag(res), 1E-10)

<< "for imag values of: " << h_a[i] << "," << h_b[i] << endl;

}

af_free_host(h_a);

af_free_host(h_b);

af_free_host(h_c);

}

TEST(BinaryTests, ISSUE_1762) {

af::array zero = af::constant(0, 5, f32);

af::array result = af::pow(zero, 2);

vector<complex_float> hres(result.elements());

result.host(&hres[0]);

for (int i = 0; i < 5; i++) {

ASSERT_EQ(real(hres[i]), 0);

ASSERT_EQ(imag(hres[i]), 0);

}

}

template<typename T>

class PowPrecisionTest : public ::testing::TestWithParam<T> {};

#define DEF_TEST(Sx, T) \

using PowPrecisionTest##Sx = PowPrecisionTest<T>; \

TEST_P(PowPrecisionTest##Sx, Issue2304) { \

T param = GetParam(); \

auto dtype = (af_dtype)dtype_traits<T>::af_type; \

af::array A = af::constant(param, 1, dtype); \

af::array B = af::pow(A, 2); \

vector<T> hres(1, 0); \

B.host(&hres[0]); \

std::fesetround(FE_TONEAREST); \

T gold = (T)std::rint(std::pow((double)param, 2.0)); \

ASSERT_EQ(hres[0], gold); \

}

DEF_TEST(ULong, unsigned long long)

DEF_TEST(Long, long long)

DEF_TEST(UInt, unsigned int)

DEF_TEST(Int, int)

DEF_TEST(UShort, unsigned short)

DEF_TEST(Short, short)

DEF_TEST(UChar, unsigned char)

#undef DEF_TEST

INSTANTIATE_TEST_CASE_P(PositiveValues, PowPrecisionTestULong,

testing::Range<unsigned long long>(1, 1e7, 1e6));

INSTANTIATE_TEST_CASE_P(PositiveValues, PowPrecisionTestLong,

testing::Range<long long>(1, 1e7, 1e6));

INSTANTIATE_TEST_CASE_P(PositiveValues, PowPrecisionTestUInt,

testing::Range<unsigned int>(1, 65000, 15e3));

INSTANTIATE_TEST_CASE_P(PositiveValues, PowPrecisionTestInt,

testing::Range<int>(1, 46340, 10e3));

INSTANTIATE_TEST_CASE_P(PositiveValues, PowPrecisionTestUShort,

testing::Range<unsigned short>(1, 255, 100));

INSTANTIATE_TEST_CASE_P(PositiveValues, PowPrecisionTestShort,

testing::Range<short>(1, 180, 50));

INSTANTIATE_TEST_CASE_P(PositiveValues, PowPrecisionTestUChar,

testing::Range<unsigned char>(1, 12, 5));

INSTANTIATE_TEST_CASE_P(NegativeValues, PowPrecisionTestLong,

testing::Range<long long>(-1e7, 0, 1e6));

INSTANTIATE_TEST_CASE_P(NegativeValues, PowPrecisionTestInt,

testing::Range<int>(-46340, 0, 10e3));

INSTANTIATE_TEST_CASE_P(NegativeValues, PowPrecisionTestShort,

testing::Range<short>(-180, 0, 50));

struct result_type_param {

af_dtype result_;

af_dtype lhs_;

af_dtype rhs_;

result_type_param(af_dtype type) : result_(type), lhs_(type), rhs_(type) {}

result_type_param(af_dtype result, af_dtype lhs, af_dtype rhs)

: result_(result), lhs_(lhs), rhs_(rhs) {}

};

ostream &operator<<(ostream &os, const result_type_param &p) {

os << "{lhs_ = " << p.lhs_ << " rhs_ = " << p.rhs_

<< " result_ = " << p.result_ << "}";

return os;

}

class ResultType : public testing::TestWithParam<result_type_param> {

protected:

af::array lhs;

af::array rhs;

af_dtype gold;

bool skip;

void SetUp() {

result_type_param params = GetParam();

gold = params.result_;

skip = false;

if (noHalfTests(params.result_) || noHalfTests(params.lhs_) ||

noHalfTests(params.rhs_)) {

skip = true;

return;

}

lhs = af::array(10, params.lhs_);

rhs = af::array(10, params.rhs_);

}

};

std::string print_types(

const ::testing::TestParamInfo<ResultType::ParamType> info) {

stringstream ss;

ss << "lhs_" << info.param.lhs_ << "_rhs_" << info.param.rhs_ << "_result_"

<< info.param.result_;

return ss.str();

}

INSTANTIATE_TEST_CASE_P(

SameTypes, ResultType,

// clang-format off

::testing::Values(result_type_param(f32),

result_type_param(f64),

result_type_param(c32),

result_type_param(c64),

result_type_param(b8),

result_type_param(s32),

result_type_param(u32),

result_type_param(u8),

result_type_param(s64),

result_type_param(u64),

result_type_param(s16),

result_type_param(u16),

result_type_param(f16)),

// clang-format on

print_types);

INSTANTIATE_TEST_CASE_P(

Float, ResultType,

// clang-format off

::testing::Values(result_type_param(f32),

result_type_param(f64, f64, f32),

result_type_param(c32, c32, f32),

result_type_param(c64, c64, f32),

result_type_param(f32, b8, f32),

result_type_param(f32, s32, f32),

result_type_param(f32, u32, f32),

result_type_param(f32, u8, f32),

result_type_param(f32, s64, f32),

result_type_param(f32, u64, f32),

result_type_param(f32, s16, f32),

result_type_param(f32, u16, f32),

result_type_param(f32, f16, f32)),

// clang-format on

print_types);

INSTANTIATE_TEST_CASE_P(

Double, ResultType,

::testing::Values(

// clang-format off

result_type_param(f64, f32, f64),

result_type_param(f64, f64, f64),

result_type_param(c64, c32, f64),

result_type_param(c64, c64, f64),

result_type_param(f64, b8, f64),

result_type_param(f64, s32, f64),

result_type_param(f64, u32, f64),

result_type_param(f64, u8, f64),

result_type_param(f64, s64, f64),

result_type_param(f64, u64, f64),

result_type_param(f64, s16, f64),

result_type_param(f64, u16, f64),

result_type_param(f64, f16, f64)),

// clang-format on

print_types);

// clang-format off

TEST_P(ResultType, Addition) {

if (skip) return;

ASSERT_EQ(gold, (lhs + rhs).type());

}

TEST_P(ResultType, Subtraction) {

if (skip) return;

ASSERT_EQ(gold, (lhs - rhs).type());

}

TEST_P(ResultType, Multiplication) {

if (skip) return;

ASSERT_EQ(gold, (lhs * rhs).type());

}

TEST_P(ResultType, Division) {

if (skip) return;

ASSERT_EQ(gold, (lhs / rhs).type());

}

// clang-format on

template<typename T>

class ResultTypeScalar : public ::testing::Test {

protected:

T scalar;

void SetUp() { scalar = T(1); }

};

typedef ::testing::Types<float, double, unsigned int, int, short,

unsigned short, char, unsigned char, half_float::half>

TestTypes;

TYPED_TEST_CASE(ResultTypeScalar, TestTypes);

TYPED_TEST(ResultTypeScalar, HalfAddition) {

SUPPORTED_TYPE_CHECK(half_float::half);

ASSERT_EQ(f16, (af::array(10, f16) + this->scalar).type());

}

TYPED_TEST(ResultTypeScalar, HalfSubtraction) {

SUPPORTED_TYPE_CHECK(half_float::half);

ASSERT_EQ(f16, (af::array(10, f16) - this->scalar).type());

}

TYPED_TEST(ResultTypeScalar, HalfMultiplication) {

SUPPORTED_TYPE_CHECK(half_float::half);

ASSERT_EQ(f16, (af::array(10, f16) * this->scalar).type());

}

TYPED_TEST(ResultTypeScalar, HalfDivision) {

SUPPORTED_TYPE_CHECK(half_float::half);

ASSERT_EQ(f16, (af::array(10, f16) / this->scalar).type());

}

TYPED_TEST(ResultTypeScalar, FloatAddition) {

ASSERT_EQ(f32, (af::array(10, f32) + this->scalar).type());

}

TYPED_TEST(ResultTypeScalar, FloatSubtraction) {

ASSERT_EQ(f32, (af::array(10, f32) - this->scalar).type());

}

TYPED_TEST(ResultTypeScalar, FloatMultiplication) {

ASSERT_EQ(f32, (af::array(10, f32) * this->scalar).type());

}

TYPED_TEST(ResultTypeScalar, FloatDivision) {

ASSERT_EQ(f32, (af::array(10, f32) / this->scalar).type());

}