static Array<T> diff(const Array<T> &in, const int dim)
{
const af::dim4 iDims = in.dims();
af::dim4 oDims = iDims;
oDims[dim] -= (isDiff2 + 1);
if(iDims.elements() == 0 || oDims.elements() == 0) {
throw std::runtime_error("Elements are 0");
}
Array<T> out = createEmptyArray<T>(oDims);
switch (dim) {
case (0): kernel::diff<T, 0, isDiff2>(out, in, in.ndims());
break;
case (1): kernel::diff<T, 1, isDiff2>(out, in, in.ndims());
break;
case (2): kernel::diff<T, 2, isDiff2>(out, in, in.ndims());
break;
case (3): kernel::diff<T, 3, isDiff2>(out, in, in.ndims());
break;
}
return out;
}
void ireduce(Array<T> &out, Array<uint> &loc,
const Array<T> &in, const int dim)
{
dim4 odims = in.dims();
odims[dim] = 1;
switch (in.ndims()) {
case 1:
ireduce_dim<op, T, 1>()(out.get(), out.strides(), out.dims(),
loc.get(),
in.get(), in.strides(), in.dims(), dim);
break;
case 2:
ireduce_dim<op, T, 2>()(out.get(), out.strides(), out.dims(),
loc.get(),
in.get(), in.strides(), in.dims(), dim);
break;
case 3:
ireduce_dim<op, T, 3>()(out.get(), out.strides(), out.dims(),
loc.get(),
in.get(), in.strides(), in.dims(), dim);
break;
case 4:
ireduce_dim<op, T, 4>()(out.get(), out.strides(), out.dims(),
loc.get(),
in.get(), in.strides(), in.dims(), dim);
break;
}
}
Array<To> scan(const Array<Ti>& in, const int dim)
{
dim4 dims = in.dims();
Array<To> out = createValueArray<To>(dims, 0);
switch (in.ndims()) {
case 1:
scan_dim<op, Ti, To, 1>()(out.get(), out.strides(), out.dims(),
in.get(), in.strides(), in.dims(), dim);
break;
case 2:
scan_dim<op, Ti, To, 2>()(out.get(), out.strides(), out.dims(),
in.get(), in.strides(), in.dims(), dim);
break;
case 3:
scan_dim<op, Ti, To, 3>()(out.get(), out.strides(), out.dims(),
in.get(), in.strides(), in.dims(), dim);
break;
case 4:
scan_dim<op, Ti, To, 4>()(out.get(), out.strides(), out.dims(),
in.get(), in.strides(), in.dims(), dim);
break;
}
return out;
}
Array<To> scan(const Array<Ti>& in, const int dim)
{
dim4 dims = in.dims();
Array<To> out = createEmptyArray<To>(dims);
in.eval();
switch (in.ndims()) {
case 1:
kernel::scan_dim<op, Ti, To, 1> func1;
getQueue().enqueue(func1, out, 0, in, 0, dim);
break;
case 2:
kernel::scan_dim<op, Ti, To, 2> func2;
getQueue().enqueue(func2, out, 0, in, 0, dim);
break;
case 3:
kernel::scan_dim<op, Ti, To, 3> func3;
getQueue().enqueue(func3, out, 0, in, 0, dim);
break;
case 4:
kernel::scan_dim<op, Ti, To, 4> func4;
getQueue().enqueue(func4, out, 0, in, 0, dim);
break;
}
return out;
}
void copyData(T *to, const Array<T> &from)
{
if(from.isOwner()) {
// FIXME: Check for errors / exceptions
memcpy(to, from.get(), from.elements()*sizeof(T));
} else {
stridedCopy<T>(to, from.get(), from.dims(), from.strides(), from.ndims() - 1);
}
}
Array<T> iir(const Array<T> &b, const Array<T> &a, const Array<T> &x)
{
try {
AF_BATCH_KIND type = x.ndims() == 1 ? AF_BATCH_NONE : AF_BATCH_SAME;
if (x.ndims() != b.ndims()) {
type = (x.ndims() < b.ndims()) ? AF_BATCH_RHS : AF_BATCH_LHS;
}
// Extract the first N elements
Array<T> c = convolve<T, T, 1, true>(x, b, type);
dim4 cdims = c.dims();
cdims[0] = x.dims()[0];
c.resetDims(cdims);
int num_a = a.dims()[0];
if (num_a == 1) return c;
dim4 ydims = c.dims();
Array<T> y = createEmptyArray<T>(ydims);
if (a.ndims() > 1) {
kernel::iir<T, true>(y, c, a);
} else {
kernel::iir<T, false>(y, c, a);
}
return y;
} catch (cl::Error &err) {
CL_TO_AF_ERROR(err);
}
}
static
void assign(Array<Tout> &out, const unsigned &ndims, const af_seq *index, const Array<Tin> &in_)
{
dim4 const outDs = out.dims();
dim4 const iDims = in_.dims();
DIM_ASSERT(0, (outDs.ndims()>=iDims.ndims()));
DIM_ASSERT(0, (outDs.ndims()>=(dim_t)ndims));
out.eval();
vector<af_seq> index_(index, index+ndims);
dim4 oDims = toDims(index_, outDs);
bool is_vector = true;
for (int i = 0; is_vector && i < (int)oDims.ndims() - 1; i++) {
is_vector &= oDims[i] == 1;
}
is_vector &= in_.isVector() || in_.isScalar();
for (dim_t i = ndims; i < (int)in_.ndims(); i++) {
oDims[i] = 1;
}
if (is_vector) {
if (oDims.elements() != (dim_t)in_.elements() &&
in_.elements() != 1) {
AF_ERROR("Size mismatch between input and output", AF_ERR_SIZE);
}
// If both out and in are vectors of equal elements, reshape in to out dims
Array<Tin> in = in_.elements() == 1 ? tile(in_, oDims) : modDims(in_, oDims);
Array<Tout> dst = createSubArray<Tout>(out, index_, false);
copyArray<Tin , Tout>(dst, in);
} else {
for (int i = 0; i < 4; i++) {
if (oDims[i] != iDims[i]) {
AF_ERROR("Size mismatch between input and output", AF_ERR_SIZE);
}
}
Array<Tout> dst = createSubArray<Tout>(out, index_, false);
copyArray<Tin , Tout>(dst, in_);
}
}
Array<To> reduce(const Array<Ti> &in, const int dim)
{
dim4 odims = in.dims();
odims[dim] = 1;
Array<To> out = createEmptyArray<To>(odims);
static reduce_dim_func<op, Ti, To> reduce_funcs[4] = { reduce_dim<op, Ti, To, 1>()
, reduce_dim<op, Ti, To, 2>()
, reduce_dim<op, Ti, To, 3>()
, reduce_dim<op, Ti, To, 4>()};
reduce_funcs[in.ndims() - 1](out.get(), out.strides(), out.dims(),
in.get(), in.strides(), in.dims(), dim);
return out;
}
Array<To> reduce(const Array<Ti> &in, const int dim, bool change_nan,
double nanval) {
dim4 odims = in.dims();
odims[dim] = 1;
in.eval();
Array<To> out = createEmptyArray<To>(odims);
static const reduce_dim_func<op, Ti, To> reduce_funcs[4] = {
kernel::reduce_dim<op, Ti, To, 1>(),
kernel::reduce_dim<op, Ti, To, 2>(),
kernel::reduce_dim<op, Ti, To, 3>(),
kernel::reduce_dim<op, Ti, To, 4>()};
getQueue().enqueue(reduce_funcs[in.ndims() - 1], out, 0, in, 0, dim,
change_nan, nanval);
return out;
}
static void assign(Array<Tout>& out, const vector<af_seq> seqs,
const Array<Tin>& in) {
size_t ndims = seqs.size();
const dim4& outDs = out.dims();
const dim4& iDims = in.dims();
if (iDims.elements() == 0) return;
out.eval();
dim4 oDims = toDims(seqs, outDs);
bool isVec = true;
for (int i = 0; isVec && i < (int)oDims.ndims() - 1; i++) {
isVec &= oDims[i] == 1;
}
isVec &= in.isVector() || in.isScalar();
for (dim_t i = ndims; i < (int)in.ndims(); i++) { oDims[i] = 1; }
if (isVec) {
if (oDims.elements() != (dim_t)in.elements() && in.elements() != 1) {
AF_ERROR("Size mismatch between input and output", AF_ERR_SIZE);
}
// If both out and in are vectors of equal elements,
// reshape in to out dims
Array<Tin> in_ =
in.elements() == 1 ? tile(in, oDims) : modDims(in, oDims);
auto dst = createSubArray<Tout>(out, seqs, false);
copyArray<Tin, Tout>(dst, in_);
} else {
for (int i = 0; i < AF_MAX_DIMS; i++) {
if (oDims[i] != iDims[i])
AF_ERROR("Size mismatch between input and output", AF_ERR_SIZE);
}
Array<Tout> dst = createSubArray<Tout>(out, seqs, false);
copyArray<Tin, Tout>(dst, in);
}
}
void select_scalar(Array<T> &out, const Array<char> &cond, const Array<T> &a, const double &b)
{
kernel::select_scalar<T, flip>(out, cond, a, b, out.ndims());
}
void select(Array<T> &out, const Array<char> &cond, const Array<T> &a, const Array<T> &b)
{
kernel::select<T>(out, cond, a, b, out.ndims());
}
CHECK(a0.ndims() == 1);
CHECK(a0.size() == make_array(0));
CHECK(a0.strides() == make_array(1));
CHECK(a0.raw_ptr() == nullptr);
CHECK(empty(a0));
CHECK(byteSize(a0) == 0);
}
TEST_CASE("DeclareArrayWithSize", "Array")
{
Array<int> a1(5);
CHECK(a1.itemSize() == sizeof(int));
CHECK(a1.length() == 5);
CHECK(a1.ndims() == 1);
CHECK(a1.size(0) == 5);
CHECK(a1.stride(0) == 1);
CHECK(a1.raw_ptr() != nullptr);
CHECK_FALSE(empty(a1));
CHECK(byteSize(a1) == 5 * sizeof(int));
Array<float, 2> a2(2, 3);
CHECK(a2.itemSize() == sizeof(float));
CHECK(a2.length() == 2 * 3);
CHECK(a2.ndims() == 2);
CHECK(a2.size(0) == 2);
CHECK(a2.size(1) == 3);
CHECK(a2.stride(0) == 1);