Method sliced_array

cpp/nd/impl/sliced_array.hpp:169–235

public:
    explicit sliced_array(nd::array arr, icm::slice_vector_t<I> slices_vec)
        : a_(std::move(arr))
    {
        ASSERT(!a_.is_dynamic());
        std::vector<int64_t> new_shape;
        auto shape = a_.shape();

        if (shape.size() < slices_vec.size()) {
            throw nd::shape_dimensions_do_not_match(shape.size(), slices_vec.size());
        }

        while (slices_vec.size() < shape.size()) {
            slices_vec.push_back(icm::slice_t<I>::all());
        }

        new_shape.resize(shape.size());
        slices_.resize(shape.size());

        bool should_reverse = false;

        for (size_t i = 0; i < shape.size(); ++i) {
            auto& s = slices_vec[i];
            auto step = s.is_index() ? 1 : s.step();
            if (step == 0) {
                throw nd::invalid_operation("slice step cannot be zero");
            }

            I start = s.is_start_known() ? s.start() : ((step > 0) ? 0 : (shape[i] - 1));
            if (start < 0) {
                start += shape[i];
            }
            int64_t dim = 0;
            // hundle the following cases with the if statement:
            // >>> x
            // array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
            // >>> x[-100::-1]
            // array([], dtype=int64)
            // >>> x[100::1]
            // array([], dtype=int64)
            // >>> x[100::-1]
            // array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
            // >>> x[-100::1]
            // array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
            if (std::abs(start - shape[i]) < shape[i] || ((start * step) <= 0)) {
                start = std::max(std::min(start, static_cast<I>(shape[i] - 1)), static_cast<I>(0));

                auto stop = (!s.is_index() && s.is_known()) ? s.stop() : ((step > 0) ? shape[i] : (-shape[i] - 1));
                if (stop < 0) {
                    stop = shape[i] + stop;
                } else {
                    stop = std::min(stop, shape[i]);
                }

                if (step < 0) {
                    should_reverse = true;
                }
                dim = std::ceil((stop - start) / static_cast<float>(step));
            }