void stdevDimIndexTest(string pFileName, dim_t dim=-1)
{
typedef typename sdOutType<T>::type outType;
if (noDoubleTests<T>()) return;
if (noDoubleTests<outType>()) return;
vector<dim4> numDims;
vector<vector<int> > in;
vector<vector<float> > tests;
readTestsFromFile<int,float>(pFileName, numDims, in, tests);
dim4 dims = numDims[0];
vector<T> input(in[0].begin(), in[0].end());
array a(dims, &(input.front()));
array b = a(seq(2,6), seq(1,7));
array c = stdev(b, dim);
vector<outType> currGoldBar(tests[0].begin(), tests[0].end());
size_t nElems = currGoldBar.size();
vector<outType> outData(nElems);
c.host((void*)outData.data());
for (size_t elIter=0; elIter<nElems; ++elIter) {
ASSERT_NEAR(::real(currGoldBar[elIter]), ::real(outData[elIter]), 1.0e-3)<< "at: " << elIter<< endl;
ASSERT_NEAR(::imag(currGoldBar[elIter]), ::imag(outData[elIter]), 1.0e-3)<< "at: " << elIter<< endl;
}
}
TEST(JIT, NonLinearBuffers2)
{
array a = randu(100, 310);
array b = randu(10, 10);
for (int i = 0; i < 300; i++) {
b += a(seq(10), seq(i, i+9)) * randu(10, 10);
}
b.eval();
}
TEST(JIT, CPP_common_node)
{
array r = seq(-3, 3, 0.5);
int n = r.dims(0);
array x = tile(r, 1, r.dims(0));
array y = tile(r.T(), r.dims(0), 1);
x.eval();
y.eval();
vector<float> hx(x.elements());
vector<float> hy(y.elements());
vector<float> hr(r.elements());
x.host(&hx[0]);
y.host(&hy[0]);
r.host(&hr[0]);
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
ASSERT_EQ(hx[j * n + i], hr[i]);
ASSERT_EQ(hy[j * n + i], hr[j]);
}
}
}
TEST(Accum, MaxDim)
{
const size_t largeDim = 65535 * 32 + 1;
//first dimension kernel tests
array input = constant(0, 2, largeDim, 2, 2);
input(span, seq(0, 9999), span, span) = 1;
array gold_first = constant(0, 2, largeDim, 2, 2);
gold_first(span, seq(0, 9999), span, span) = range(2, 10000, 2, 2) + 1;
array output_first = accum(input, 0);
ASSERT_ARRAYS_EQ(gold_first, output_first);
input = constant(0, 2, 2, 2, largeDim);
input(span, span, span, seq(0, 9999)) = 1;
gold_first = constant(0, 2, 2, 2, largeDim);
gold_first(span, span, span, seq(0, 9999)) = range(2, 2, 2, 10000) + 1;
output_first = accum(input, 0);
ASSERT_ARRAYS_EQ(gold_first, output_first);
//other dimension kernel tests
input = constant(0, 2, largeDim, 2, 2);
input(span, seq(0, 9999), span, span) = 1;
array gold_dim = constant(10000, 2, largeDim, 2, 2);
gold_dim(span, seq(0, 9999), span, span) = range(dim4(2, 10000, 2, 2), 1) + 1;
array output_dim = accum(input, 1);
ASSERT_ARRAYS_EQ(gold_dim, output_dim);
input = constant(0, 2, 2, 2, largeDim);
input(span, span, span, seq(0, 9999)) = 1;
gold_dim = constant(0, 2, 2, 2, largeDim);
gold_dim(span, span, span, seq(0, 9999)) = range(dim4(2, 2, 2, 10000), 1) + 1;
output_dim = accum(input, 1);
ASSERT_ARRAYS_EQ(gold_dim, output_dim);
}
TEST(Select, NaN)
{
dim4 dims(1000, 1250);
dtype ty = f32;
array a = randu(dims, ty);
a(seq(a.dims(0) / 2), span, span, span) = NaN;
float b = 0;
array c = select(isNaN(a), b, a);
int num = (int)a.elements();
vector<float> ha(num);
vector<float> hc(num);
a.host(&ha[0]);
c.host(&hc[0]);
for (int i = 0; i < num; i++) {
ASSERT_FLOAT_EQ(hc[i], std::isnan(ha[i]) ? b : ha[i]);
}
}
void fftconvolveTestLarge(int sDim, int fDim, int sBatch, int fBatch, bool expand)
{
if (noDoubleTests<T>()) return;
using af::dim4;
using af::seq;
using af::array;
int outDim = sDim + fDim - 1;
int fftDim = (int)pow(2, ceil(log2(outDim)));
int sd[4], fd[4];
for (int k = 0; k < 4; k++) {
if (k < baseDim) {
sd[k] = sDim;
fd[k] = fDim;
}
else if (k == baseDim) {
sd[k] = sBatch;
fd[k] = fBatch;
}
else {
sd[k] = 1;
fd[k] = 1;
}
}
const dim4 signalDims(sd[0], sd[1], sd[2], sd[3]);
const dim4 filterDims(fd[0], fd[1], fd[2], fd[3]);
array signal = randu(signalDims, (af_dtype) af::dtype_traits<T>::af_type);
array filter = randu(filterDims, (af_dtype) af::dtype_traits<T>::af_type);
array out = fftConvolve(signal, filter, expand ? AF_CONV_EXPAND : AF_CONV_DEFAULT);
array gold;
switch(baseDim) {
case 1:
gold = real(af::ifft(af::fft(signal, fftDim) * af::fft(filter, fftDim)));
break;
case 2:
gold = real(af::ifft2(af::fft2(signal, fftDim, fftDim) * af::fft2(filter, fftDim, fftDim)));
break;
case 3:
gold = real(af::ifft3(af::fft3(signal, fftDim, fftDim, fftDim) * af::fft3(filter, fftDim, fftDim, fftDim)));
break;
default:
ASSERT_LT(baseDim, 4);
}
int cropMin = 0, cropMax = 0;
if (expand) {
cropMin = 0;
cropMax = outDim - 1;
}
else {
cropMin = fDim/2;
cropMax = outDim - fDim/2 - 1;
}
switch(baseDim) {
case 1:
gold = gold(seq(cropMin, cropMax));
break;
case 2:
gold = gold(seq(cropMin, cropMax), seq(cropMin, cropMax));
break;
case 3:
gold = gold(seq(cropMin, cropMax), seq(cropMin, cropMax), seq(cropMin, cropMax));
break;
}
size_t outElems = out.elements();
size_t goldElems = gold.elements();
ASSERT_EQ(goldElems, outElems);
T *goldData = new T[goldElems];
gold.host(goldData);
T *outData = new T[outElems];
out.host(outData);
for (size_t elIter=0; elIter<outElems; ++elIter) {
ASSERT_NEAR(goldData[elIter], outData[elIter], 5e-2) << "at: " << elIter << std::endl;
}
delete[] goldData;
delete[] outData;
}
