Currently in progress on the branch slicer.

maybe 106445222 assertions is a bit overkill.

Could we reduce the size/dimensionality of this test case?

Thanks for sharing this branch @timspainNERSC. This will be super helpful.

I had a quick look and maybe I missed it. Is it possible to get the elements from a 1D slice back as a array/vector? possibly a std::array would be most sensible for my use case.

maybe 106445222 assertions is a bit overkill.

Could we reduce the size/dimensionality of this test case?

nextsimdg/core/test/Slice_test.cpp

Lines 137 to 149 in 5216f7b

	Slice elements8d {{{2, 6}, {4, 9}, {6, 12}, {8, 15}, {10, 18}, {12, 21}, {14, 24}, {16, 27}}};
	std::vector<size_t> ni = { 7, 12, 13, 16, 30, 30, 30, 30};
	Slice::SliceIter iter8d(elements8d, ni);
	count = 0;
	const size_t expt = 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4;
	while (!iter8d.isEnd()) {
	auto loc = Indexer::deIndexer(ni, iter8d.index());
	for (size_t dim = 0; dim < ni.size(); ++dim) {
	REQUIRE(loc[dim] >= elements8d.bounds[dim].start);
	REQUIRE(loc[dim] < elements8d.bounds[dim].stop);
	}
	++iter8d;
	++count;

😒
I do want a test that examines a high dimensionality array, but I can arrange the test so that there are fewer assertions. I GUESS.

Thanks for sharing this branch @timspainNERSC. This will be super helpful.

I had a quick look and maybe I missed it. Is it possible to get the elements from a 1D slice back as a array/vector? possibly a std::array would be most sensible for my use case.

Next on the TODO list. I should write that i the issue 🤔

maybe 106445222 assertions is a bit overkill.

Could we reduce the size/dimensionality of this test case?

nextsimdg/core/test/Slice_test.cpp

Lines 137 to 149 in 5216f7b

	Slice elements8d {{{2, 6}, {4, 9}, {6, 12}, {8, 15}, {10, 18}, {12, 21}, {14, 24}, {16, 27}}};
	std::vector<size_t> ni = { 7, 12, 13, 16, 30, 30, 30, 30};
	Slice::SliceIter iter8d(elements8d, ni);
	count = 0;
	const size_t expt = 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4;
	while (!iter8d.isEnd()) {
	auto loc = Indexer::deIndexer(ni, iter8d.index());
	for (size_t dim = 0; dim < ni.size(); ++dim) {
	REQUIRE(loc[dim] >= elements8d.bounds[dim].start);
	REQUIRE(loc[dim] < elements8d.bounds[dim].stop);
	}
	++iter8d;
	++count;

😒 I do want a test that examines a high dimensionality array, but I can arrange the test so that there are fewer assertions. I GUESS.

${\textsf{\color{lightblue}[doctest]}}$ doctest version is "2.4.11"
$${\textsf{\color{lightblue}[doctest]}}$$ run with "--help" for options
$${\textsf{\color{dandelion}===============================================================================}}$$
$${\textsf{\color{lightblue}[doctest]}}$$ test cases: 4 | $${\textsf{\color{green} 4 passed}}$$ | $${\textsf{\color{black}0 failed}}$$ | $${\textsf{\color{black}0 skipped}}$$
$${\textsf{\color{lightblue}[doctest] }}$$ assertions: 423 | $${\textsf{\color{green}423 passed}}$$ | $${\textsf{\color{black}0 failed}}$$ |
$${\textsf{\color{lightblue}[doctest]}}$$ Status: $${\textsf{\color{green}SUCCESS!}}$$

but also

             if (!message.empty()) goto end8d;

😎

How numpy behaves with a range of positive, 0, negative and absent indices. The test array a has 12 elements, where the value at each index is equal to the index.

Step = 1 (or absent)

step = 0

Causes an exception to be thrown.

Step = -1

|step| > 1

Larger step sizes behave as expected, stepping the defined number of values from the same start index.