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());
}