types::ndarray<T,N> roll(types::ndarray<T,N> const& expr, long shift)
{
while(shift<0) shift+=expr.flat_size();
shift %=expr.flat_size();
types::ndarray<T,N> out(expr.shape(), __builtin__::None);
std::copy(expr.fbegin(), expr.fend() - shift, std::copy(expr.fend() - shift, expr.fend(), out.fbegin()));
return out;
}
types::ndarray<T, N> _transpose(types::ndarray<T, N> const &a,
long const l[N])
{
auto shape = a.shape();
types::array<long, N> shp;
for (unsigned long i = 0; i < N; ++i)
shp[i] = shape[l[i]];
types::ndarray<T, N> new_array(shp, __builtin__::None);
types::array<long, N> new_strides;
new_strides[N - 1] = 1;
std::transform(new_strides.rbegin(), new_strides.rend() - 1, shp.rbegin(),
new_strides.rbegin() + 1, std::multiplies<long>());
types::array<long, N> old_strides;
old_strides[N - 1] = 1;
std::transform(old_strides.rbegin(), old_strides.rend() - 1,
shape.rbegin(), old_strides.rbegin() + 1,
std::multiplies<long>());
auto iter = a.buffer, iter_end = a.buffer + a.flat_size();
for (long i = 0; iter != iter_end; ++iter, ++i) {
long offset = 0;
for (unsigned long s = 0; s < N; s++)
offset += ((i / old_strides[l[s]]) % shape[l[s]]) * new_strides[s];
new_array.buffer[offset] = *iter;
}
return new_array;
}
types::none_type put(types::ndarray<T, N> &expr, long int ind, T const &v)
{
if (ind >= expr.flat_size() || ind < 0)
throw types::ValueError("indice out of bound");
*(expr.fbegin() + ind) = v;
return __builtin__::None;
}
types::ndarray<decltype(std::declval<T0>() + std::declval<T1>()),
types::pshape<long, long>>
outer(types::ndarray<T0, pS0> const &a, types::ndarray<T1, pS1> const &b)
{
types::ndarray<decltype(std::declval<T0>() + std::declval<T1>()),
types::pshape<long, long>>
out(types::pshape<long, long>{a.flat_size(), b.flat_size()},
__builtin__::None);
auto iter = out.fbegin();
for (auto iter_a = a.fbegin(), end_a = a.fend(); iter_a != end_a;
++iter_a) {
auto val_a = *iter_a;
iter = std::transform(b.fbegin(), b.fend(), iter,
[=](T1 val) { return val_a * val; });
}
return out;
}
types::list<types::ndarray<T, N>> split(types::ndarray<T, N> const &a,
long nb_split)
{
if (a.flat_size() % nb_split != 0)
throw types::ValueError(
"array split does not result in an equal division");
return array_split(a, nb_split);
}
decltype(std::declval<T>() + 1.) median(types::ndarray<T, N> const &arr)
{
size_t n = arr.flat_size();
T *tmp = new T[n];
std::copy(arr.buffer, arr.buffer + n, tmp);
std::sort(tmp, tmp + n);
auto out = (tmp[n / 2] + tmp[(n - 1) / 2]) / double(2);
delete[] tmp;
return out;
}
types::ndarray<T, 1> repeat(types::ndarray<T, N> const &expr, int repeats)
{
types::ndarray<T, 1> out(
types::array<long, 1>{{expr.flat_size() * repeats}},
__builtin__::None);
auto out_iter = out.fbegin();
for (auto iter = expr.fbegin(), end = expr.fend(); iter != end; ++iter)
for (int i = 0; i < repeats; ++i)
*out_iter++ = *iter;
return out;
}
types::none_type putmask(types::ndarray<T, pS> &expr, E const &mask,
F const &values)
{
auto amask = asarray(mask);
auto avalues = asarray(values);
auto iexpr = expr.fbegin();
auto n = avalues.flat_size();
for (long i = 0; i < expr.flat_size(); ++i)
if (*(amask.fbegin() + i))
*(iexpr + i) = *(avalues.fbegin() + i % n);
return __builtin__::None;
}
typename std::enable_if<types::is_numexpr_arg<F>::value,
types::none_type>::type
put(types::ndarray<T, N> &expr, F const &ind, E const &v)
{
auto vind = asarray(ind);
auto vv = asarray(v);
for (long i = 0; i < ind.flat_size(); ++i) {
auto val = *(vind.fbegin() + i);
if (val >= expr.flat_size() || val < 0)
throw types::ValueError("indice out of bound");
*(expr.fbegin() + val) = *(vv.fbegin() + i % vv.flat_size());
}
return __builtin__::None;
}
types::ndarray<T, M> reshape(types::ndarray<T, N> const &expr,
types::array<long, M> const &new_shape)
{
auto where = std::find(new_shape.begin(), new_shape.end(), -1);
if (where != new_shape.end()) {
auto auto_shape = new_shape;
auto_shape[where - new_shape.begin()] =
expr.flat_size() / std::accumulate(new_shape.begin(),
new_shape.end(), -1L,
std::multiplies<long>());
return expr.reshape(auto_shape);
} else
return expr.reshape(new_shape);
}
types::ndarray<T, M> resize(types::ndarray<T, N> const &expr,
types::array<long, M> const &new_shape)
{
auto where = std::find(new_shape.begin(), new_shape.end(), -1);
if (where != new_shape.end()) {
types::array<long, M> auto_shape(new_shape);
auto_shape[where - new_shape.begin()] =
expr.flat_size() / std::accumulate(new_shape.begin(),
new_shape.end(), -1L,
std::multiplies<long>());
return resize(expr, auto_shape);
}
types::ndarray<T, M> out(new_shape, __builtin__::None);
auto nshape = out.flat_size();
auto n = expr.flat_size();
if (n < nshape) {
auto iter = std::copy(expr.fbegin(), expr.fend(), out.fbegin());
for (long i = 1; i < nshape / n; ++i)
iter = std::copy(out.fbegin(), out.fbegin() + n, iter);
std::copy(out.fbegin(), out.fbegin() + nshape % n, iter);
} else
std::copy(expr.fbegin(), expr.fbegin() + nshape, out.fbegin());
return out;
}
types::ndarray<T, 1> resize(types::ndarray<T, N> const &expr,
long new_shape)
{
types::ndarray<T, 1> out(types::array<long, N> {{new_shape}},
__builtin__::None);
auto n = expr.flat_size();
if (n < new_shape) {
auto iter = std::copy(expr.fbegin(), expr.fend(), out.fbegin());
for (long i = 1; i < new_shape / n; ++i)
iter = std::copy(out.fbegin(), out.fbegin() + n, iter);
std::copy(out.fbegin(), out.fbegin() + new_shape % n, iter);
} else
std::copy(expr.fbegin(), expr.fbegin() + new_shape, out.fbegin());
return out;
}
types::ndarray<long, N> argsort(types::ndarray<T,N> const& a) {
size_t last_axis = a.shape[N-1];
size_t n = a.flat_size();
types::ndarray<long, N> indices(a.shape, __builtin__::None);
for(long j=0, * iter_indices = indices.buffer, *end_indices = indices.buffer + n;
iter_indices != end_indices;
iter_indices += last_axis, j+=last_axis)
{
// fill with the original indices
std::iota(iter_indices, iter_indices + last_axis, 0L);
// sort the index using the value from a
std::sort(iter_indices, iter_indices + last_axis,
[&a,j](long i1, long i2) {return *(a.fbegin() + j + i1) < *(a.fbegin() + j + i2);});
}
return indices;
}
types::ndarray<
typename std::remove_cv<typename std::remove_reference<
decltype(std::declval<T>() +
std::declval<typename utils::nested_container_value_type<
F>::type>())>::type>::type,
1>
append(types::ndarray<T, N> const &nto, F const &data)
{
types::ndarray<typename F::dtype, F::value> ndata(data);
long nsize = nto.flat_size() + ndata.flat_size();
types::ndarray<
typename std::remove_cv<typename std::remove_reference<decltype(
std::declval<T>() +
std::declval<typename utils::nested_container_value_type<
F>::type>())>::type>::type,
1> out(types::make_tuple(nsize), __builtin__::None);
auto out_back = std::copy(nto.fbegin(), nto.fend(), out.fbegin());
std::copy(ndata.fbegin(), ndata.fend(), out_back);
return out;
}
types::ndarray<T, 1> flatten(types::ndarray<T, N> const &a)
{
return {a.mem, types::array<long, 1>{{a.flat_size()}}};
}
types::str tostring(types::ndarray<T, N> const &expr)
{
return types::str(reinterpret_cast<const char *>(expr.buffer),
expr.flat_size() * sizeof(T));
}
types::ndarray<T,1> ravel(types::ndarray<T,N> const& expr)
{
return reshape(expr, types::array<long, 1>{{expr.flat_size()}});
}
T item(types::ndarray<T, N> const &expr, long i)
{
if (i < 0)
i += expr.flat_size();
return *(expr.fbegin() + i);
}
