af_err af_medfilt(af_array *out, const af_array in, const dim_t wind_length, const dim_t wind_width, const af_border_type edge_pad) { try { ARG_ASSERT(2, (wind_length==wind_width)); ARG_ASSERT(2, (wind_length>0)); ARG_ASSERT(3, (wind_width>0)); ARG_ASSERT(4, (edge_pad>=AF_PAD_ZERO && edge_pad<=AF_PAD_SYM)); ArrayInfo info = getInfo(in); af::dim4 dims = info.dims(); dim_t input_ndims = dims.ndims(); DIM_ASSERT(1, (input_ndims >= 2)); if (wind_length==1) { *out = retain(in); } else { af_array output; af_dtype type = info.getType(); switch(type) { case f32: output = medfilt<float >(in, wind_length, wind_width, edge_pad); break; case f64: output = medfilt<double>(in, wind_length, wind_width, edge_pad); break; case b8 : output = medfilt<char >(in, wind_length, wind_width, edge_pad); break; case s32: output = medfilt<int >(in, wind_length, wind_width, edge_pad); break; case u32: output = medfilt<uint >(in, wind_length, wind_width, edge_pad); break; case u8 : output = medfilt<uchar >(in, wind_length, wind_width, edge_pad); break; default : TYPE_ERROR(1, type); } std::swap(*out, output); } } CATCHALL; return AF_SUCCESS; }
af_err af_assign(af_array *out, const af_array lhs, const unsigned ndims, const af_seq *index, const af_array rhs) { try { ARG_ASSERT(0, (lhs!=0)); ARG_ASSERT(1, (ndims>0)); ARG_ASSERT(3, (rhs!=0)); for(dim_type i=0; i<(dim_type)ndims; ++i) { ARG_ASSERT(2, (index[i].step>=0)); } af_array res; if (*out != lhs) AF_CHECK(af_copy_array(&res, lhs)); else res = weakCopy(lhs); try { if (lhs != rhs) { ArrayInfo oInfo = getInfo(lhs); af_dtype oType = oInfo.getType(); switch(oType) { case c64: assign<cdouble, true >(res, ndims, index, rhs); break; case c32: assign<cfloat , true >(res, ndims, index, rhs); break; case f64: assign<double , false>(res, ndims, index, rhs); break; case f32: assign<float , false>(res, ndims, index, rhs); break; case s32: assign<int , false>(res, ndims, index, rhs); break; case u32: assign<uint , false>(res, ndims, index, rhs); break; case u8 : assign<uchar , false>(res, ndims, index, rhs); break; case b8 : assign<char , false>(res, ndims, index, rhs); break; default : TYPE_ERROR(1, oType); break; } } } catch(...) { if (*out != lhs) { AF_CHECK(af_destroy_array(res)); } throw; } std::swap(*out, res); } CATCHALL; return AF_SUCCESS; }
af_err af_rotate(af_array *out, const af_array in, const float theta, const bool crop, const af_interp_type method) { try { unsigned odims0 = 0, odims1 = 0; ArrayInfo info = getInfo(in); af::dim4 idims = info.dims(); if(!crop) { odims0 = idims[0] * fabs(std::cos(theta)) + idims[1] * fabs(std::sin(theta)); odims1 = idims[1] * fabs(std::cos(theta)) + idims[0] * fabs(std::sin(theta)); } else { odims0 = idims[0]; odims1 = idims[1]; } af_dtype itype = info.getType(); ARG_ASSERT(3, method == AF_INTERP_NEAREST || method == AF_INTERP_BILINEAR || method == AF_INTERP_LOWER); DIM_ASSERT(1, idims.elements() > 0); af::dim4 odims(odims0, odims1, idims[2], idims[3]); af_array output = 0; switch(itype) { case f32: output = rotate<float >(in, theta, odims, method); break; case f64: output = rotate<double >(in, theta, odims, method); break; case c32: output = rotate<cfloat >(in, theta, odims, method); break; case c64: output = rotate<cdouble>(in, theta, odims, method); break; case s32: output = rotate<int >(in, theta, odims, method); break; case u32: output = rotate<uint >(in, theta, odims, method); break; case s64: output = rotate<intl >(in, theta, odims, method); break; case u64: output = rotate<uintl >(in, theta, odims, method); break; case u8: output = rotate<uchar >(in, theta, odims, method); break; case b8: output = rotate<uchar >(in, theta, odims, method); break; default: TYPE_ERROR(1, itype); } std::swap(*out,output); } CATCHALL return AF_SUCCESS; }
af_err af_assign_seq(af_array *out, const af_array lhs, const unsigned ndims, const af_seq *index, const af_array rhs) { try { ARG_ASSERT(0, (lhs!=0)); ARG_ASSERT(1, (ndims>0)); ARG_ASSERT(3, (rhs!=0)); for(dim_t i=0; i<(dim_t)ndims; ++i) { ARG_ASSERT(2, (index[i].step>=0)); } af_array res; if (*out != lhs) AF_CHECK(af_copy_array(&res, lhs)); else res = retain(lhs); try { if (lhs != rhs) { ArrayInfo oInfo = getInfo(lhs); af_dtype oType = oInfo.getType(); switch(oType) { case c64: assign_helper<cdouble>(getWritableArray<cdouble>(res), ndims, index, rhs); break; case c32: assign_helper<cfloat >(getWritableArray<cfloat >(res), ndims, index, rhs); break; case f64: assign_helper<double >(getWritableArray<double >(res), ndims, index, rhs); break; case f32: assign_helper<float >(getWritableArray<float >(res), ndims, index, rhs); break; case s32: assign_helper<int >(getWritableArray<int >(res), ndims, index, rhs); break; case u32: assign_helper<uint >(getWritableArray<uint >(res), ndims, index, rhs); break; case s64: assign_helper<intl >(getWritableArray<intl >(res), ndims, index, rhs); break; case u64: assign_helper<uintl >(getWritableArray<uintl >(res), ndims, index, rhs); break; case u8 : assign_helper<uchar >(getWritableArray<uchar >(res), ndims, index, rhs); break; case b8 : assign_helper<char >(getWritableArray<char >(res), ndims, index, rhs); break; default : TYPE_ERROR(1, oType); break; } } } catch(...) { af_release_array(res); throw; } std::swap(*out, res); } CATCHALL; return AF_SUCCESS; }
af_err af_histogram(af_array *out, const af_array in, const unsigned nbins, const double minval, const double maxval) { try { ArrayInfo info = getInfo(in); af_dtype type = info.getType(); af_array output; switch(type) { case f32: output = histogram<float , uint>(in, nbins, minval, maxval, info.isLinear()); break; case f64: output = histogram<double, uint>(in, nbins, minval, maxval, info.isLinear()); break; case b8 : output = histogram<char , uint>(in, nbins, minval, maxval, info.isLinear()); break; case s32: output = histogram<int , uint>(in, nbins, minval, maxval, info.isLinear()); break; case u32: output = histogram<uint , uint>(in, nbins, minval, maxval, info.isLinear()); break; case s16: output = histogram<short , uint>(in, nbins, minval, maxval, info.isLinear()); break; case u16: output = histogram<ushort, uint>(in, nbins, minval, maxval, info.isLinear()); break; case s64: output = histogram<intl , uint>(in, nbins, minval, maxval, info.isLinear()); break; case u64: output = histogram<uintl , uint>(in, nbins, minval, maxval, info.isLinear()); break; case u8 : output = histogram<uchar , uint>(in, nbins, minval, maxval, info.isLinear()); break; default : TYPE_ERROR(1, type); } std::swap(*out,output); } CATCHALL; return AF_SUCCESS; }
static void print(af_array arr) { const ArrayInfo info = getInfo(arr); T *data = new T[info.elements()]; af_array arrT; AF_CHECK(af_reorder(&arrT, arr, 1, 0, 2, 3)); //FIXME: Use alternative function to avoid copies if possible AF_CHECK(af_get_data_ptr(data, arrT)); const ArrayInfo infoT = getInfo(arrT); AF_CHECK(af_destroy_array(arrT)); std::ios_base::fmtflags backup = std::cout.flags(); std::cout << "[" << info.dims() << "]\n"; #ifndef NDEBUG std::cout <<" Offsets: ["<<info.offsets()<<"]"<<std::endl; std::cout <<" Strides: ["<<info.strides()<<"]"<<std::endl; #endif printer(std::cout, data, infoT, infoT.ndims() - 1); delete[] data; std::cout.flags(backup); }
void sort_by_key_tmplt(af_array *okey, af_array *oval, const af_array ikey, const af_array ival, const unsigned dim, const bool isAscending) { ArrayInfo info = getInfo(ival); af_dtype vtype = info.getType(); switch(vtype) { case f32: sort_by_key<Tk, float >(okey, oval, ikey, ival, dim, isAscending); break; case f64: sort_by_key<Tk, double >(okey, oval, ikey, ival, dim, isAscending); break; case s32: sort_by_key<Tk, int >(okey, oval, ikey, ival, dim, isAscending); break; case u32: sort_by_key<Tk, uint >(okey, oval, ikey, ival, dim, isAscending); break; case u8: sort_by_key<Tk, uchar >(okey, oval, ikey, ival, dim, isAscending); break; case b8: sort_by_key<Tk, char >(okey, oval, ikey, ival, dim, isAscending); break; default: TYPE_ERROR(1, vtype); } return; }
static af_array lookup(const af_array &in, const af_array &idx, const unsigned dim) { ArrayInfo inInfo = getInfo(in); af_dtype inType = inInfo.getType(); switch(inType) { case f32: return getHandle(lookup<float , idx_t > (getArray<float >(in), getArray<idx_t>(idx), dim)); case c32: return getHandle(lookup<cfloat , idx_t > (getArray<cfloat >(in), getArray<idx_t>(idx), dim)); case f64: return getHandle(lookup<double , idx_t > (getArray<double >(in), getArray<idx_t>(idx), dim)); case c64: return getHandle(lookup<cdouble , idx_t > (getArray<cdouble >(in), getArray<idx_t>(idx), dim)); case s32: return getHandle(lookup<int , idx_t > (getArray<int >(in), getArray<idx_t>(idx), dim)); case u32: return getHandle(lookup<unsigned, idx_t > (getArray<unsigned>(in), getArray<idx_t>(idx), dim)); case u8: return getHandle(lookup<uchar , idx_t > (getArray<uchar >(in), getArray<idx_t>(idx), dim)); case b8: return getHandle(lookup<char , idx_t > (getArray<char >(in), getArray<idx_t>(idx), dim)); default : TYPE_ERROR(1, inType); } }
af_err af_print_array(af_array arr) { try { ArrayInfo info = getInfo(arr); af_dtype type = info.getType(); switch(type) { case f32: print<float>(arr); break; case c32: print<cfloat>(arr); break; case f64: print<double>(arr); break; case c64: print<cdouble>(arr); break; case b8: print<char>(arr); break; case s32: print<int>(arr); break; case u32: print<unsigned>(arr); break; case u8: print<uchar>(arr); break; case s64: print<intl>(arr); break; case u64: print<uintl>(arr); break; default: TYPE_ERROR(1, type); } } CATCHALL; return AF_SUCCESS; }
af_err af_release_array(af_array arr) { try { int dev = getActiveDeviceId(); ArrayInfo info = getInfo(arr, false, false); af_dtype type = info.getType(); if(info.isSparse()) { switch(type) { case f32: releaseSparseHandle<float >(arr); break; case f64: releaseSparseHandle<double >(arr); break; case c32: releaseSparseHandle<cfloat >(arr); break; case c64: releaseSparseHandle<cdouble>(arr); break; default : TYPE_ERROR(0, type); } } else { setDevice(info.getDevId()); switch(type) { case f32: releaseHandle<float >(arr); break; case c32: releaseHandle<cfloat >(arr); break; case f64: releaseHandle<double >(arr); break; case c64: releaseHandle<cdouble >(arr); break; case b8: releaseHandle<char >(arr); break; case s32: releaseHandle<int >(arr); break; case u32: releaseHandle<uint >(arr); break; case u8: releaseHandle<uchar >(arr); break; case s64: releaseHandle<intl >(arr); break; case u64: releaseHandle<uintl >(arr); break; case s16: releaseHandle<short >(arr); break; case u16: releaseHandle<ushort >(arr); break; default: TYPE_ERROR(0, type); } setDevice(dev); } } CATCHALL return AF_SUCCESS; }
af_err af_reorder(af_array *out, const af_array in, const af::dim4 &rdims) { try { ArrayInfo info = getInfo(in); af_dtype type = info.getType(); DIM_ASSERT(1, info.elements() > 0); // Check that dimensions are not repeated int allDims[] = {0, 1, 2, 3}; for(int i = 0; i < 3; i++) { DIM_ASSERT(i + 2, rdims[i] == allDims[rdims[i]]); allDims[rdims[i]] = -1; } // If reorder is a (batched) transpose, then call transpose if(info.dims()[3] == 1) { if(rdims[0] == 1 && rdims[1] == 0 && rdims[2] == 2 && rdims[3] == 3) { return af_transpose(out, in); } } af_array output; switch(type) { case f32: output = reorder<float >(in, rdims); break; case c32: output = reorder<cfloat >(in, rdims); break; case f64: output = reorder<double >(in, rdims); break; case c64: output = reorder<cdouble>(in, rdims); break; case b8: output = reorder<char >(in, rdims); break; case s32: output = reorder<int >(in, rdims); break; case u32: output = reorder<uint >(in, rdims); break; case u8: output = reorder<uchar >(in, rdims); break; case s8: output = reorder<char >(in, rdims); break; default: TYPE_ERROR(1, type); } std::swap(*out,output); } CATCHALL; return AF_SUCCESS; }
af_err af_dot( af_array *out, const af_array lhs, const af_array rhs, const af_mat_prop optLhs, const af_mat_prop optRhs) { using namespace detail; try { ArrayInfo lhsInfo = getInfo(lhs); ArrayInfo rhsInfo = getInfo(rhs); if (optLhs != AF_MAT_NONE && optLhs != AF_MAT_CONJ) { AF_ERROR("Using this property is not yet supported in dot", AF_ERR_NOT_SUPPORTED); } if (optRhs != AF_MAT_NONE && optRhs != AF_MAT_CONJ) { AF_ERROR("Using this property is not yet supported in dot", AF_ERR_NOT_SUPPORTED); } DIM_ASSERT(1, lhsInfo.dims()[0] == rhsInfo.dims()[0]); af_dtype lhs_type = lhsInfo.getType(); af_dtype rhs_type = rhsInfo.getType(); if(lhsInfo.ndims() == 0) { return af_retain_array(out, lhs); } if (lhsInfo.ndims() > 1 || rhsInfo.ndims() > 1) { AF_ERROR("dot can not be used in batch mode", AF_ERR_BATCH); } TYPE_ASSERT(lhs_type == rhs_type); af_array output = 0; switch(lhs_type) { case f32: output = dot<float >(lhs, rhs, optLhs, optRhs); break; case c32: output = dot<cfloat >(lhs, rhs, optLhs, optRhs); break; case f64: output = dot<double >(lhs, rhs, optLhs, optRhs); break; case c64: output = dot<cdouble>(lhs, rhs, optLhs, optRhs); break; default: TYPE_ERROR(1, lhs_type); } std::swap(*out, output); } CATCHALL return AF_SUCCESS; }
af_err af_matmul( af_array *out, const af_array lhs, const af_array rhs, const af_mat_prop optLhs, const af_mat_prop optRhs) { using namespace detail; try { ArrayInfo lhsInfo = getInfo(lhs); ArrayInfo rhsInfo = getInfo(rhs); af_dtype lhs_type = lhsInfo.getType(); af_dtype rhs_type = rhsInfo.getType(); if (!(optLhs == AF_MAT_NONE || optLhs == AF_MAT_TRANS || optLhs == AF_MAT_CTRANS)) { AF_ERROR("Using this property is not yet supported in matmul", AF_ERR_NOT_SUPPORTED); } if (!(optRhs == AF_MAT_NONE || optRhs == AF_MAT_TRANS || optRhs == AF_MAT_CTRANS)) { AF_ERROR("Using this property is not yet supported in matmul", AF_ERR_NOT_SUPPORTED); } if (lhsInfo.ndims() > 2 || rhsInfo.ndims() > 2) { AF_ERROR("matmul can not be used in batch mode", AF_ERR_BATCH); } TYPE_ASSERT(lhs_type == rhs_type); af_array output = 0; int aColDim = (optLhs == AF_MAT_NONE) ? 1 : 0; int bRowDim = (optRhs == AF_MAT_NONE) ? 0 : 1; DIM_ASSERT(1, lhsInfo.dims()[aColDim] == rhsInfo.dims()[bRowDim]); switch(lhs_type) { case f32: output = matmul<float >(lhs, rhs, optLhs, optRhs); break; case c32: output = matmul<cfloat >(lhs, rhs, optLhs, optRhs); break; case f64: output = matmul<double >(lhs, rhs, optLhs, optRhs); break; case c64: output = matmul<cdouble>(lhs, rhs, optLhs, optRhs); break; default: TYPE_ERROR(1, lhs_type); } std::swap(*out, output); } CATCHALL return AF_SUCCESS; }
af_err sort_by_key_tmplt(af_array *okey, af_array *oval, const af_array ikey, const af_array ival, const unsigned dim, const bool dir) { try { ArrayInfo info = getInfo(ival); af_dtype vtype = info.getType(); switch(vtype) { case f32: sort_by_key<Tk, float >(okey, oval, ikey, ival, dim, dir); break; case f64: sort_by_key<Tk, double >(okey, oval, ikey, ival, dim, dir); break; case s32: sort_by_key<Tk, int >(okey, oval, ikey, ival, dim, dir); break; case u32: sort_by_key<Tk, uint >(okey, oval, ikey, ival, dim, dir); break; case u8: sort_by_key<Tk, uchar >(okey, oval, ikey, ival, dim, dir); break; // case s8: sort_by_key<Tk, char >(okey, oval, ikey, ival, dim, dir); break; default: TYPE_ERROR(1, vtype); } } CATCHALL; return AF_SUCCESS; }
af_err af_sort_by_key(af_array *out_keys, af_array *out_values, const af_array keys, const af_array values, const unsigned dim, const bool isAscending) { try { ArrayInfo info = getInfo(keys); af_dtype type = info.getType(); ArrayInfo vinfo = getInfo(values); DIM_ASSERT(3, info.elements() > 0); DIM_ASSERT(4, info.dims() == vinfo.dims()); // Only Dim 0 supported ARG_ASSERT(5, dim == 0); af_array oKey; af_array oVal; switch(type) { case f32: sort_by_key_tmplt<float >(&oKey, &oVal, keys, values, dim, isAscending); break; case f64: sort_by_key_tmplt<double >(&oKey, &oVal, keys, values, dim, isAscending); break; case s32: sort_by_key_tmplt<int >(&oKey, &oVal, keys, values, dim, isAscending); break; case u32: sort_by_key_tmplt<uint >(&oKey, &oVal, keys, values, dim, isAscending); break; case u8: sort_by_key_tmplt<uchar >(&oKey, &oVal, keys, values, dim, isAscending); break; case b8: sort_by_key_tmplt<char >(&oKey, &oVal, keys, values, dim, isAscending); break; default: TYPE_ERROR(1, type); } std::swap(*out_keys , oKey); std::swap(*out_values , oVal); } CATCHALL; return AF_SUCCESS; }
fg::Plot3* setup_plot3(const af_array P, fg::PlotType ptype, fg::MarkerType mtype) { Array<T> pIn = getArray<T>(P); ArrayInfo Pinfo = getInfo(P); af::dim4 P_dims = Pinfo.dims(); DIM_ASSERT(0, Pinfo.ndims() == 1 || Pinfo.ndims() == 2); DIM_ASSERT(0, (P_dims[0] == 3 || P_dims[1] == 3) || (Pinfo.isVector() && P_dims[0]%3 == 0)); if(Pinfo.isVector()){ dim4 rdims(P_dims.elements()/3, 3, 1, 1); pIn.modDims(rdims); P_dims = pIn.dims(); } if(P_dims[1] == 3){ pIn = transpose(pIn, false); } T max[3], min[3]; copyData(max, reduce<af_max_t, T, T>(pIn, 1)); copyData(min, reduce<af_min_t, T, T>(pIn, 1)); ForgeManager& fgMngr = ForgeManager::getInstance(); fg::Plot3* plot3 = fgMngr.getPlot3(P_dims.elements()/3, getGLType<T>(), ptype, mtype); plot3->setColor(1.0, 0.0, 0.0); plot3->setAxesLimits(max[0], min[0], max[1], min[1], max[2], min[2]); plot3->setAxesTitles("X Axis", "Y Axis", "Z Axis"); copy_plot3<T>(pIn, plot3); return plot3; }
af_err af_corrcoef(double *realVal, double *imagVal, const af_array X, const af_array Y) { try { ArrayInfo xInfo = getInfo(X); ArrayInfo yInfo = getInfo(Y); dim4 xDims = xInfo.dims(); dim4 yDims = yInfo.dims(); af_dtype xType = xInfo.getType(); af_dtype yType = yInfo.getType(); ARG_ASSERT(2, (xType==yType)); ARG_ASSERT(2, (xDims.ndims()==yDims.ndims())); for (dim_t i=0; i<xDims.ndims(); ++i) ARG_ASSERT(2, (xDims[i]==yDims[i])); switch(xType) { case f64: *realVal = corrcoef<double, double>(X, Y); break; case f32: *realVal = corrcoef<float , float >(X, Y); break; case s32: *realVal = corrcoef<int , float >(X, Y); break; case u32: *realVal = corrcoef<uint , float >(X, Y); break; case s64: *realVal = corrcoef<intl , double>(X, Y); break; case u64: *realVal = corrcoef<uintl , double>(X, Y); break; case s16: *realVal = corrcoef<short , float >(X, Y); break; case u16: *realVal = corrcoef<ushort, float >(X, Y); break; case u8: *realVal = corrcoef<uchar , float >(X, Y); break; case b8: *realVal = corrcoef<char , float >(X, Y); break; default : TYPE_ERROR(1, xType); } } CATCHALL; return AF_SUCCESS; }
af_err af_draw_hist(const af_window wind, const af_array X, const double minval, const double maxval, const af_cell* const props) { #if defined(WITH_GRAPHICS) if(wind==0) { std::cerr<<"Not a valid window"<<std::endl; return AF_SUCCESS; } try { ArrayInfo Xinfo = getInfo(X); af_dtype Xtype = Xinfo.getType(); ARG_ASSERT(0, Xinfo.isVector()); fg::Window* window = reinterpret_cast<fg::Window*>(wind); window->makeCurrent(); fg::Histogram* hist = NULL; switch(Xtype) { case f32: hist = setup_histogram<float >(X, minval, maxval); break; case s32: hist = setup_histogram<int >(X, minval, maxval); break; case u32: hist = setup_histogram<uint >(X, minval, maxval); break; case s16: hist = setup_histogram<short >(X, minval, maxval); break; case u16: hist = setup_histogram<ushort >(X, minval, maxval); break; case u8 : hist = setup_histogram<uchar >(X, minval, maxval); break; default: TYPE_ERROR(1, Xtype); } if (props->col>-1 && props->row>-1) window->draw(props->col, props->row, *hist, props->title); else window->draw(*hist); } CATCHALL; return AF_SUCCESS; #else return AF_ERR_NO_GFX; #endif }
af_err af_gloh(af_features* feat, af_array* desc, const af_array in, const unsigned n_layers, const float contrast_thr, const float edge_thr, const float init_sigma, const bool double_input, const float img_scale, const float feature_ratio) { try { #ifdef AF_BUILD_NONFREE_SIFT ArrayInfo info = getInfo(in); af::dim4 dims = info.dims(); ARG_ASSERT(2, (dims[0] >= 15 && dims[1] >= 15 && dims[2] == 1 && dims[3] == 1)); ARG_ASSERT(3, n_layers > 0); ARG_ASSERT(4, contrast_thr > 0.0f); ARG_ASSERT(5, edge_thr >= 1.0f); ARG_ASSERT(6, init_sigma > 0.5f); ARG_ASSERT(8, img_scale > 0.0f); ARG_ASSERT(9, feature_ratio > 0.0f); dim_t in_ndims = dims.ndims(); DIM_ASSERT(1, (in_ndims <= 3 && in_ndims >= 2)); af_array tmp_desc; af_dtype type = info.getType(); switch(type) { case f32: sift<float , float >(*feat, tmp_desc, in, n_layers, contrast_thr, edge_thr, init_sigma, double_input, img_scale, feature_ratio, true); break; case f64: sift<double, double>(*feat, tmp_desc, in, n_layers, contrast_thr, edge_thr, init_sigma, double_input, img_scale, feature_ratio, true); break; default : TYPE_ERROR(1, type); } std::swap(*desc, tmp_desc); #else AF_ERROR("ArrayFire was not built with nonfree support, GLOH disabled\n", AF_ERR_NONFREE); #endif } CATCHALL; return AF_SUCCESS; }
static af_err af_arith_real(af_array *out, const af_array lhs, const af_array rhs, const bool batchMode) { try { ArrayInfo linfo = getInfo(lhs); ArrayInfo rinfo = getInfo(rhs); dim4 odims = getOutDims(linfo.dims(), rinfo.dims(), batchMode); const af_dtype otype = implicit(linfo.getType(), rinfo.getType()); af_array res; switch (otype) { case f32: res = arithOp<float , op>(lhs, rhs, odims); break; case f64: res = arithOp<double , op>(lhs, rhs, odims); break; case s32: res = arithOp<int , op>(lhs, rhs, odims); break; case u32: res = arithOp<uint , op>(lhs, rhs, odims); break; case u8 : res = arithOp<uchar , op>(lhs, rhs, odims); break; case b8 : res = arithOp<char , op>(lhs, rhs, odims); break; case s64: res = arithOp<intl , op>(lhs, rhs, odims); break; case u64: res = arithOp<uintl , op>(lhs, rhs, odims); break; case s16: res = arithOp<short , op>(lhs, rhs, odims); break; case u16: res = arithOp<ushort , op>(lhs, rhs, odims); break; default: TYPE_ERROR(0, otype); } std::swap(*out, res); } CATCHALL; return AF_SUCCESS; }
af_err af_unwrap(af_array *out, const af_array in, const dim_t wx, const dim_t wy, const dim_t sx, const dim_t sy, const dim_t px, const dim_t py, const bool is_column) { try { ArrayInfo info = getInfo(in); af_dtype type = info.getType(); af::dim4 idims = info.dims(); ARG_ASSERT(2, wx > 0 && wx <= idims[0] + px); ARG_ASSERT(3, wy > 0 && wy <= idims[1] + py); ARG_ASSERT(4, sx > 0); ARG_ASSERT(5, sy > 0); ARG_ASSERT(6, px >= 0 && px < wx); ARG_ASSERT(7, py >= 0 && py < wy); af_array output; switch(type) { case f32: output = unwrap<float >(in, wx, wy, sx, sy, px, py, is_column); break; case f64: output = unwrap<double >(in, wx, wy, sx, sy, px, py, is_column); break; case c32: output = unwrap<cfloat >(in, wx, wy, sx, sy, px, py, is_column); break; case c64: output = unwrap<cdouble>(in, wx, wy, sx, sy, px, py, is_column); break; case s32: output = unwrap<int >(in, wx, wy, sx, sy, px, py, is_column); break; case u32: output = unwrap<uint >(in, wx, wy, sx, sy, px, py, is_column); break; case s64: output = unwrap<intl >(in, wx, wy, sx, sy, px, py, is_column); break; case u64: output = unwrap<uintl >(in, wx, wy, sx, sy, px, py, is_column); break; case s16: output = unwrap<short >(in, wx, wy, sx, sy, px, py, is_column); break; case u16: output = unwrap<ushort >(in, wx, wy, sx, sy, px, py, is_column); break; case u8: output = unwrap<uchar >(in, wx, wy, sx, sy, px, py, is_column); break; case b8: output = unwrap<char >(in, wx, wy, sx, sy, px, py, is_column); break; default: TYPE_ERROR(1, type); } std::swap(*out,output); } CATCHALL; return AF_SUCCESS; }
bool isFreqDomain(const af_array &signal, const af_array filter, af_conv_domain domain) { if (domain == AF_CONV_FREQ) return true; if (domain != AF_CONV_AUTO) return false; ArrayInfo sInfo = getInfo(signal); ArrayInfo fInfo = getInfo(filter); dim4 sdims = sInfo.dims(); dim4 fdims = fInfo.dims(); if (identifyBatchKind<baseDim>(sdims, fdims) == CONVOLVE_BATCH_DIFF) return true; int kbatch = 1; for(int i = 3; i >= baseDim; i--) { kbatch *= fdims[i]; } if (kbatch >= 10) return true; if (baseDim == 1) { if (fdims[0] > 128) return true; } if (baseDim == 2) { // maximum supported size in 2D domain if (fdims[0] > 17 || fdims[1] > 17) return true; // Maximum supported non square size if (fdims[0] != fdims[1] && fdims[0] > 5) return true; } if (baseDim == 3) { if (fdims[0] > 5 || fdims[1] > 5 || fdims[2] > 5) return true; } return false; }
static void printer(ostream &out, const T* ptr, const ArrayInfo &info, unsigned dim) { dim_type stride = info.strides()[dim]; dim_type d = info.dims()[dim]; ToNum<T> toNum; if(dim == 0) { for(dim_type i = 0, j = 0; i < d; i++, j+=stride) { out<< std::fixed << std::setw(10) << std::setprecision(4) << toNum(ptr[j]) << " "; } out << endl; } else { for(dim_type i = 0; i < d; i++) { printer(out, ptr, info, dim - 1); ptr += stride; } out << endl; } }
af_err af_index(af_array *result, const af_array in, const unsigned ndims, const af_seq* index) { af_array out; try { ArrayInfo iInfo = getInfo(in); if (ndims == 1 && ndims != (dim_t)iInfo.ndims()) { af_array tmp_in; AF_CHECK(af_flat(&tmp_in, in)); AF_CHECK(af_index(result, tmp_in, ndims, index)); AF_CHECK(af_release_array(tmp_in)); return AF_SUCCESS; } af_dtype in_type = iInfo.getType(); switch(in_type) { case f32: indexArray<float> (out, in, ndims, index); break; case c32: indexArray<cfloat> (out, in, ndims, index); break; case f64: indexArray<double> (out, in, ndims, index); break; case c64: indexArray<cdouble> (out, in, ndims, index); break; case b8: indexArray<char> (out, in, ndims, index); break; case s32: indexArray<int> (out, in, ndims, index); break; case u32: indexArray<unsigned>(out, in, ndims, index); break; case s16: indexArray<short> (out, in, ndims, index); break; case u16: indexArray<ushort> (out, in, ndims, index); break; case s64: indexArray<intl> (out, in, ndims, index); break; case u64: indexArray<uintl> (out, in, ndims, index); break; case u8: indexArray<uchar> (out, in, ndims, index); break; default: TYPE_ERROR(1, in_type); } } CATCHALL swap(*result, out); return AF_SUCCESS; }
af_err af_print_array_gen(const char *exp, const af_array arr, const int precision) { try { ARG_ASSERT(0, exp != NULL); ArrayInfo info = getInfo(arr); af_dtype type = info.getType(); switch(type) { case f32: print<float >(exp, arr, precision); break; case c32: print<cfloat >(exp, arr, precision); break; case f64: print<double >(exp, arr, precision); break; case c64: print<cdouble >(exp, arr, precision); break; case b8: print<char >(exp, arr, precision); break; case s32: print<int >(exp, arr, precision); break; case u32: print<unsigned>(exp, arr, precision); break; case u8: print<uchar >(exp, arr, precision); break; case s64: print<intl >(exp, arr, precision); break; case u64: print<uintl >(exp, arr, precision); break; default: TYPE_ERROR(1, type); } } CATCHALL; return AF_SUCCESS; }
af_err af_sort_index(af_array *out, af_array *indices, const af_array in, const unsigned dim, const bool isAscending) { try { ArrayInfo info = getInfo(in); af_dtype type = info.getType(); if(info.elements() <= 0) { dim_t my_dims[] = {0, 0, 0, 0}; AF_CHECK(af_create_handle(out, AF_MAX_DIMS, my_dims, type)); AF_CHECK(af_create_handle(indices, AF_MAX_DIMS, my_dims, type)); return AF_SUCCESS; } af_array val; af_array idx; switch(type) { case f32: sort_index<float >(&val, &idx, in, dim, isAscending); break; case f64: sort_index<double >(&val, &idx, in, dim, isAscending); break; case s32: sort_index<int >(&val, &idx, in, dim, isAscending); break; case u32: sort_index<uint >(&val, &idx, in, dim, isAscending); break; case s16: sort_index<short >(&val, &idx, in, dim, isAscending); break; case u16: sort_index<ushort >(&val, &idx, in, dim, isAscending); break; case s64: sort_index<intl >(&val, &idx, in, dim, isAscending); break; case u64: sort_index<uintl >(&val, &idx, in, dim, isAscending); break; case u8: sort_index<uchar >(&val, &idx, in, dim, isAscending); break; case b8: sort_index<char >(&val, &idx, in, dim, isAscending); break; default: TYPE_ERROR(1, type); } std::swap(*out , val); std::swap(*indices, idx); } CATCHALL; return AF_SUCCESS; }
static af_err reduce_common(af_array *out, const af_array in, const int dim) { try { ARG_ASSERT(2, dim >= 0); ARG_ASSERT(2, dim < 4); const ArrayInfo in_info = getInfo(in); if (dim >= (int)in_info.ndims()) { *out = weakCopy(in); return AF_SUCCESS; } af_dtype type = in_info.getType(); af_array res; switch(type) { case f32: res = reduce<op, float , float >(in, dim); break; case f64: res = reduce<op, double , double >(in, dim); break; case c32: res = reduce<op, cfloat , cfloat >(in, dim); break; case c64: res = reduce<op, cdouble, cdouble>(in, dim); break; case u32: res = reduce<op, uint , uint >(in, dim); break; case s32: res = reduce<op, int , int >(in, dim); break; case b8: res = reduce<op, uchar , uchar >(in, dim); break; case u8: res = reduce<op, uchar , uchar >(in, dim); break; case s8: res = reduce<op, char , char >(in, dim); break; default: TYPE_ERROR(1, type); } std::swap(*out, res); } CATCHALL; return AF_SUCCESS; }
static af_err reduce_promote(af_array *out, const af_array in, const int dim) { try { ARG_ASSERT(2, dim >= 0); ARG_ASSERT(2, dim < 4); const ArrayInfo in_info = getInfo(in); if (dim >= (int)in_info.ndims()) { *out = weakCopy(in); return AF_SUCCESS; } af_dtype type = in_info.getType(); af_array res; switch(type) { case f32: res = reduce<op, float , float >(in, dim); break; case f64: res = reduce<op, double , double >(in, dim); break; case c32: res = reduce<op, cfloat , cfloat >(in, dim); break; case c64: res = reduce<op, cdouble, cdouble>(in, dim); break; case u32: res = reduce<op, uint , uint >(in, dim); break; case s32: res = reduce<op, int , int >(in, dim); break; case u8: res = reduce<op, uchar , uint >(in, dim); break; case s8: res = reduce<op, char , int >(in, dim); break; // Make sure you are adding only "1" for every non zero value, even if op == af_add_t case b8: res = reduce<af_notzero_t, uchar , uint >(in, dim); break; default: TYPE_ERROR(1, type); } std::swap(*out, res); } CATCHALL; return AF_SUCCESS; }
af_err af_diff2(af_array *out, const af_array in, const int dim) { try { ARG_ASSERT(2, ((dim >= 0) && (dim < 4))); ArrayInfo info = getInfo(in); af_dtype type = info.getType(); af::dim4 in_dims = info.dims(); DIM_ASSERT(1, in_dims[dim] >= 3); af_array output; switch(type) { case f32: output = diff2<float >(in,dim); break; case c32: output = diff2<cfloat >(in,dim); break; case f64: output = diff2<double >(in,dim); break; case c64: output = diff2<cdouble>(in,dim); break; case b8: output = diff2<char >(in,dim); break; case s32: output = diff2<int >(in,dim); break; case u32: output = diff2<uint >(in,dim); break; case s64: output = diff2<intl >(in,dim); break; case u64: output = diff2<uintl >(in,dim); break; case s16: output = diff2<short >(in,dim); break; case u16: output = diff2<ushort >(in,dim); break; case u8: output = diff2<uchar >(in,dim); break; default: TYPE_ERROR(1, type); } std::swap(*out,output); } CATCHALL; return AF_SUCCESS; }
af_err convert(af_array* out, const af_array in, const float r, const float g, const float b) { try { ArrayInfo info = getInfo(in); af_dtype iType = info.getType(); af::dim4 inputDims = info.dims(); ARG_ASSERT(1, (inputDims.ndims()>=2)); if (isRGB2GRAY) ARG_ASSERT(1, (inputDims[2]==3)); af_array output = 0; switch(iType) { case f64: output = convert<double, double, isRGB2GRAY>(in, r, g, b); break; case f32: output = convert<float , float , isRGB2GRAY>(in, r, g, b); break; case u32: output = convert<uint , float , isRGB2GRAY>(in, r, g, b); break; case s32: output = convert<int , float , isRGB2GRAY>(in, r, g, b); break; case u8: output = convert<uchar , float , isRGB2GRAY>(in, r, g, b); break; default: TYPE_ERROR(1, iType); break; } std::swap(*out, output); } CATCHALL; return AF_SUCCESS; }