void dynd::parse_json(nd::array &out, const char *json_begin, const char *json_end, const eval::eval_context *ectx) { try { const char *begin = json_begin, *end = json_end; ndt::type tp = out.get_type(); ::parse_json(tp, out.get_ndo_meta(), out.get_readwrite_originptr(), begin, end, ectx); begin = skip_whitespace(begin, end); if (begin != end) { throw json_parse_error(begin, "unexpected trailing JSON text", tp); } } catch (const json_parse_error& e) { stringstream ss; string line_prev, line_cur; int line, column; get_error_line_column(json_begin, json_end, e.get_position(), line_prev, line_cur, line, column); ss << "Error parsing JSON at line " << line << ", column " << column << "\n"; if (e.get_type().get_type_id() != uninitialized_type_id) { ss << "DType: " << e.get_type() << "\n"; } ss << "Message: " << e.get_message() << "\n"; print_json_parse_error_marker(ss, line_prev, line_cur, line, column); throw runtime_error(ss.str()); } }
static void linspace_specialization(double start, double stop, intptr_t count, nd::array& result) { intptr_t stride = result.get_strides()[0]; char *dst = result.get_readwrite_originptr(); for (intptr_t i = 0; i < count; ++i, dst += stride) { double val = ((count - i - 1) * start + i * stop) / double(count - 1); *reinterpret_cast<double *>(dst) = val; } }
static void linspace_specialization(float start, float stop, intptr_t count, nd::array& result) { intptr_t stride = result.get_strides()[0]; char *dst = result.get_readwrite_originptr(); for (intptr_t i = 0; i < count; ++i, dst += stride) { double val = ((count - i - 1) * double(start) + i * double(stop)) / double(count - 1); *reinterpret_cast<float *>(dst) = static_cast<float>(val); } }
static void linspace_specialization(dynd_complex<double> start, dynd_complex<double> stop, intptr_t count, nd::array& result) { intptr_t stride = result.get_strides()[0]; char *dst = result.get_readwrite_originptr(); for (intptr_t i = 0; i < count; ++i, dst += stride) { dynd_complex<double> val = (double(count - i - 1) * dynd_complex<double>(start) + double(i) * dynd_complex<double>(stop)) / double(count - 1); *reinterpret_cast<dynd_complex<double> *>(dst) = val; } }
// Constructor which creates the output based on the input's broadcast shape array_iter(const ndt::type& op0_dtype, nd::array& out_op0, const nd::array& op1, const nd::array& op2, const nd::array& op3) { create_broadcast_result(op0_dtype, op1, op2, op3, out_op0, m_iter_ndim[0], m_itershape); nd::array ops[4] = {out_op0, op1, op2, op3}; m_array_tp[0] = out_op0.get_type(); m_array_tp[1] = op1.get_type(); m_array_tp[2] = op2.get_type(); m_array_tp[3] = op3.get_type(); m_itersize = 1; m_iter_ndim[1] = m_array_tp[1].get_ndim(); m_iter_ndim[2] = m_array_tp[2].get_ndim(); m_iter_ndim[3] = m_array_tp[3].get_ndim(); // Allocate and initialize the iterdata if (m_iter_ndim[0] != 0) { m_iterindex.init(m_iter_ndim[0]); memset(m_iterindex.get(), 0, sizeof(intptr_t) * m_iter_ndim[0]); // The destination iterdata size_t iterdata_size = m_array_tp[0].get_iterdata_size(m_iter_ndim[0]); m_iterdata[0] = reinterpret_cast<iterdata_common *>(malloc(iterdata_size)); if (!m_iterdata[0]) { throw std::bad_alloc(); } m_metadata[0] = out_op0.get_ndo_meta(); m_array_tp[0].iterdata_construct(m_iterdata[0], &m_metadata[0], m_iter_ndim[0], m_itershape.get(), m_uniform_tp[0]); m_data[0] = m_iterdata[0]->reset(m_iterdata[0], out_op0.get_readwrite_originptr(), m_iter_ndim[0]); // The op iterdata for (int i = 1; i < 4; ++i) { iterdata_size = m_array_tp[i].get_broadcasted_iterdata_size(m_iter_ndim[i]); m_iterdata[i] = reinterpret_cast<iterdata_common *>(malloc(iterdata_size)); if (!m_iterdata[i]) { throw std::bad_alloc(); } m_metadata[i] = ops[i].get_ndo_meta(); m_array_tp[i].broadcasted_iterdata_construct(m_iterdata[i], &m_metadata[i], m_iter_ndim[i], m_itershape.get() + (m_iter_ndim[0] - m_iter_ndim[i]), m_uniform_tp[i]); m_data[i] = m_iterdata[i]->reset(m_iterdata[i], ops[i].get_ndo()->m_data_pointer, m_iter_ndim[0]); } for (size_t i = 0, i_end = m_iter_ndim[0]; i != i_end; ++i) { m_itersize *= m_itershape[i]; } } else { for (size_t i = 0; i < 4; ++i) { m_iterdata[i] = NULL; m_uniform_tp[i] = m_array_tp[i]; m_data[i] = ops[i].get_ndo()->m_data_pointer; m_metadata[i] = ops[i].get_ndo_meta(); } } }
/** * Given a buffer array of type "strided * T" which was * created by nd::empty, resets it so it can be used * as a buffer again. * * NOTE: If the array is not of type "strided * T" and default * initialized by nd::empty, undefined behavior will result. * */ inline void reset_strided_buffer_array(const nd::array& buf) { const ndt::type &buf_tp = buf.get_type(); base_type_members::flags_type flags = buf_tp.extended()->get_flags(); if (flags & (type_flag_blockref | type_flag_zeroinit | type_flag_destructor)) { char *buf_arrmeta = buf.get_ndo()->get_arrmeta(); char *buf_data = buf.get_readwrite_originptr(); buf_tp.extended()->arrmeta_reset_buffers(buf.get_ndo()->get_arrmeta()); strided_dim_type_arrmeta *am = reinterpret_cast<strided_dim_type_arrmeta *>(buf_arrmeta); if (flags & type_flag_destructor) { buf_tp.extended()->data_destruct(buf_arrmeta, buf_data); } memset(buf_data, 0, am->dim_size * am->stride); } }
array_iter(const nd::array& op0) { init(op0.get_type(), op0.get_ndo_meta(), op0.get_readwrite_originptr()); }