Add array slicing LinearOperator

[bwohlberg]

Add a LinearOperator that select part of an input array via array slicing/indexing.

Is Slice the best choice of name for this operator? Perhaps Index or Select?

[codecov]

Codecov Report

Merging #162 (1632456) into main (e68cda4) will increase coverage by 0.06%.
The diff coverage is 94.52%.

@@            Coverage Diff             @@
##             main     #162      +/-   ##
==========================================
+ Coverage   92.14%   92.20%   +0.06%     
==========================================
  Files          48       48              
  Lines        3298     3350      +52     
==========================================
+ Hits         3039     3089      +50     
- Misses        259      261       +2     

Flag	Coverage Δ
unittests	92.20% <94.52%> (+0.06%)	⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files	Coverage Δ
scico/util.py	92.97% <92.85%> (-0.16%)	⬇️
scico/blockarray.py	91.20% <93.33%> (+0.36%)	⬆️
scico/linop/__init__.py	100.00% <100.00%> (ø)
scico/linop/_linop.py	97.97% <100.00%> (+0.20%)	⬆️
scico/typing.py	100.00% <100.00%> (ø)

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update e68cda4...1632456. Read the comment docs.

[Michael-T-McCann]

or block array, I wonder? I think you could use one of these to select a block from a block array, but probably not use one to select a block and index within the block, if I'm reading the docs correctly.

(not saying we should add the functionality, but maybe just address this in the docstring)

[bwohlberg]

I think that would be worth adding. Let's discuss details.

[bwohlberg]

The syntax is already established (first axis indexes the block), but this is not supported due to limitations of the relevant BlockArray code:

scico/scico/blockarray.py

Lines 799 to 807 in 445412e

	def __getitem__(self, idx: Union[int, Ellipsis]) -> JaxArray:
	if isinstance(idx, slice):
	raise TypeError(f"Slicing not supported on block index")
	if idx == Ellipsis:
	return reshape(self._data, self.shape)
	if idx < 0:
	idx = self.num_blocks + idx
	return reshape(self._data[self.bndpos[idx] : self.bndpos[idx + 1]], self.shape[idx])

As you can see, only int or Ellipsis indexing expressions are allowed, and there is no support for concatenated indexing of block and block content. It's not clear how difficult it would be to remove the former constraint (one complication would be that indexing could return another BlockArray rather than a JaxArray), but I think it would be straightforward to add support for the latter.

[bwohlberg]

Added support for more general indexing of BlockArray, and documented BlockArray support by Slice.

[Michael-T-McCann]

Possible alternative: remove SliceTestObj and slicetestobj, replace line 586 with
x = snp.zeros((4, 5, 6, 7), dtype=dtype), parametrize over dtype.

My eyes glaze over when I see fixtures, and what is it gaining us here? Perhaps it caches x?

[bwohlberg]

I feel the same way. The approach here is a direct copy of the tests for the Sum operator. No arguments on simplifying the new tests, but it would seem to make sense to simplify the ones for Sum at the same time?

[Michael-T-McCann]

Agreed. I made an issue for fixing it, let's leave it as is for this PR.