Array<T>::Array(dim4 dims, const T * const in_data):
ArrayInfo(getActiveDeviceId(), dims, dim4(0,0,0,0), calcStrides(dims), (af_dtype)dtype_traits<T>::af_type),
data(memAlloc<T>(dims.elements()), memFree<T>), data_dims(dims),
node(), ready(true), offset(0), owner(true)
{
std::copy(in_data, in_data + dims.elements(), data.get());
}
Array<T> convolve2(Array<T> const& signal, Array<accT> const& c_filter, Array<accT> const& r_filter)
{
const dim4 cfDims = c_filter.dims();
const dim4 rfDims = r_filter.dims();
const dim_t cfLen= cfDims.elements();
const dim_t rfLen= rfDims.elements();
const dim4 sDims = signal.dims();
dim4 tDims = sDims;
dim4 oDims = sDims;
if (expand) {
tDims[0] += cfLen - 1;
oDims[0] += cfLen - 1;
oDims[1] += rfLen - 1;
}
Array<T> temp= createEmptyArray<T>(tDims);
Array<T> out = createEmptyArray<T>(oDims);
kernel::convolve2<T, accT, 0, expand>(temp, signal, c_filter);
kernel::convolve2<T, accT, 1, expand>(out, temp, r_filter);
return out;
}
Array<T>::Array(dim4 dims, const T * const in_data, bool is_device, bool copy_device):
info(getActiveDeviceId(), dims, 0, calcStrides(dims), (af_dtype)dtype_traits<T>::af_type),
data((is_device & !copy_device) ? (T*)in_data : memAlloc<T>(dims.elements()).release(), memFree<T>), data_dims(dims),
node(bufferNodePtr<T>()), ready(true), owner(true)
{
static_assert(is_standard_layout<Array<T>>::value, "Array<T> must be a standard layout type");
static_assert(offsetof(Array<T>, info) == 0, "Array<T>::info must be the first member variable of Array<T>");
if (!is_device || copy_device) {
// Ensure the memory being written to isnt used anywhere else.
getQueue().sync();
copy(in_data, in_data + dims.elements(), data.get());
}
}
Array<T>::Array(dim4 dims)
: info(getActiveDeviceId(), dims, 0, calcStrides(dims),
(af_dtype)dtype_traits<T>::af_type)
, data(memAlloc<T>(dims.elements()).release(), memFree<T>)
, data_dims(dims)
, node(bufferNodePtr<T>())
, ready(true)
, owner(true) {}
af_err af_approx1_uniform(af_array *yo, const af_array yi,
const af_array xo, const int xdim,
const double xi_beg, const double xi_step,
const af_interp_type method, const float offGrid)
{
try {
const ArrayInfo& yi_info = getInfo(yi);
const ArrayInfo& xo_info = getInfo(xo);
const dim4 yi_dims = yi_info.dims();
const dim4 xo_dims = xo_info.dims();
ARG_ASSERT(1, yi_info.isFloating()); // Only floating and complex types
ARG_ASSERT(2, xo_info.isRealFloating()) ; // Only floating types
ARG_ASSERT(1, yi_info.isSingle() == xo_info.isSingle()); // Must have same precision
ARG_ASSERT(1, yi_info.isDouble() == xo_info.isDouble()); // Must have same precision
ARG_ASSERT(3, xdim >= 0 && xdim < 4);
// POS should either be (x, 1, 1, 1) or (1, yi_dims[1], yi_dims[2], yi_dims[3])
if (xo_dims[xdim] != xo_dims.elements()) {
for (int i = 0; i < 4; i++) {
if (xdim != i) DIM_ASSERT(2, xo_dims[i] == yi_dims[i]);
}
}
ARG_ASSERT(5, xi_step != 0);
ARG_ASSERT(6, (method == AF_INTERP_CUBIC ||
method == AF_INTERP_CUBIC_SPLINE ||
method == AF_INTERP_LINEAR ||
method == AF_INTERP_LINEAR_COSINE ||
method == AF_INTERP_LOWER ||
method == AF_INTERP_NEAREST));
if (yi_dims.ndims() == 0 || xo_dims.ndims() == 0) {
*yo = createHandle(dim4(0,0,0,0), yi_info.getType());
return AF_SUCCESS;
}
dim4 yo_dims = yi_dims;
yo_dims[xdim] = xo_dims[xdim];
if (*yo == 0) {
*yo = createHandle(yo_dims, yi_info.getType());
}
DIM_ASSERT(1, getInfo(*yo).dims() == yo_dims);
switch(yi_info.getType()) {
case f32: approx1<float , float >(yo, yi, xo, xdim,
xi_beg, xi_step,
method, offGrid); break;
case f64: approx1<double , double>(yo, yi, xo, xdim,
xi_beg, xi_step,
method, offGrid); break;
case c32: approx1<cfloat , float >(yo, yi, xo, xdim,
xi_beg, xi_step,
method, offGrid); break;
case c64: approx1<cdouble, double>(yo, yi, xo, xdim,
xi_beg, xi_step,
method, offGrid); break;
default: TYPE_ERROR(1, yi_info.getType());
}
}
CATCHALL;
return AF_SUCCESS;
}
c.host(&hc[0]);
for (int i = 0; i < num; i++) {
EXPECT_NEAR(hc[i], hb[i], 1e-7) << "at " << i;
}
}
TEST(Select, 4D)
{
dim4 dims(2, 3, 4, 2);
array cond = randu(dims) > 0.5;
array a = randu(dims);
array b = select(cond, a - a * 0.9, a);
array c = a - a * cond * 0.9;
int num = (int)dims.elements();
vector<float> hb(num);
vector<float> hc(num);
b.host(&hb[0]);
c.host(&hc[0]);
for (int i = 0; i < num; i++) {
EXPECT_NEAR(hc[i], hb[i], 1e-7) << "at " << i;
}
}
TEST(Select, Issue_1730)
{
const int n = 1000;
const int m = 200;
