Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
C++ NumpyArray::getitem is done, setting the pattern for other classes (external C functions). The Numba and Identity extensions are not done, which would be necessary to fully set the pattern. * Start on PR7, deep __getitem__, for real this time. * Added Content::minmax_depth, which will be used by Ellipsis. * [skip ci] writing. * Slices and RawArray compile. * [skip ci] Update the README. * [skip ci] What about this link? * [skip ci] What about this link? * [skip ci] Finalized README. * Add a C++ test of RawArray so we can test this without the full cycle. * [skip ci] Have to re-think Slices. * Defined slices. * Poking around, I decided that I should learn how to do slicing on NumpyArray, not RawArray (because NumpyArray supports multiple dimensions). * To do the testing in Python, we'll need to convert all of the slice types to C++. * Don't actually raise exceptions while testing. * [skip ci] working on it. * All Slice types should be readable now. * Make syntax of test okay for Python 2.7. * Make syntax of test okay for Python 2.7 (one more instance). * Figure out what Windows uses as integer format strings. * Intentionally fail so that we can see the format string explicitly on Windows. * Should be fixed for Windows. * Another test for Windows. * It's safest to let pybind11 decide if it needs to cast. * Give NumpyArray a nice representation for common numerical types. * Started on the true getitem. * Working on chaining getitems. * [skip ci] Interaction between SliceAt and SliceStartStop is starting to work. * Most of getitem has been implemented for SliceAt and SliceStartStop. * Consolidated and cleaned up. * But don't intentionally raise an Exception. * Fix compilation issues on 32-bit Windows. * [skip ci] carry is composable. * SliceAt and SliceStartStop for no-carry and yes-carry, but there's a memory error to deal with. * Fixed memory error (running off end of array). * Fix Windows 32-bit compilation issues. * All cases are working except two or more slices. * [skip ci] working on it. * [skip ci] Got this one case, but I should think more about it. * [skip ci] Working out the logic of carrying in Python; good for depth <= 2 so far. * [skip ci] more cases working. * [skip ci] I need to rethink what 'carry' means. * [skip ci] Got it for all levels of slice2. * [skip ci] Working for some int indexes. * [skip ci] All int and slice2 cases are working. * [skip ci] Integer array indexing works, apart from iterating 'as one'. * [skip ci] Maybe the 'as one' thing is working... * [skip ci] Walking 'as one' through a slice. * [skip ci] Have to think harder about how walking 'as one' interacts with slices. * [skip ci] Stride-based getitem(slice2) works, and it seems to be simpler than the functional version. * [skip ci] Intarray composes with strided slice2. * [skip ci] Very nearly have intslice composing with slice2. * [skip ci] Trouble is, we reshape a strided array differently from a compacted array. * Start a new technique for __getitem__ and also check that Azure still works. * But don't run deliberately broken code. * [skip ci] set up to do array-first getitem * [skip ci] seems to be a good machine for array indexing * [skip ci] works for 0, 1, 2 slices * [skip ci] works for 0, 1, 2, 3 slices * [skip ci] and arrays work again * [skip ci] working for some non-trivial strides (haven't checked negative strides yet) * [skip ci] can't do uneven or negative strides with a carry; have to compact in these cases * [skip ci] working on compaction * [skip ci] correctly ingesting arrays and slicing still works; need to check compaction again * [skip ci] compaction works with the new ctypes-based __init__ * [skip ci] integers were very easy to add: good sign! * [skip ci] slice3 works * [skip ci] passing down advanced * [skip ci] working on int vs array policies * [skip ci] those policies are very complicated * [skip ci] Numpy has a strange rule for split advanced indexing that presupposes rectilinear structure and I won't support it. * [skip ci] working on making integers and arrays by broadcasting * [skip ci] Our scope will not include basic indexes between advanced indexes (Numpy's implementation relies on rectilinear structure). * [skip ci] simplify code before introducing multidimensional integer-array index * [skip ci] multidimensional integer-array indexes work * [skip ci] we get boolean-array indexing by preprocessing * [skip ci] All of the getitem_next_array cases are working. * [skip ci] Earlier work on selecting by strides converted over and it works (negative strides, non-trivial input strides, etc.). * [skip ci] same for integer * [skip ci] same for newaxis and Ellipsis * The getitem study is done; now to implement it! * Removed all getitem and SliceItem from C++. * Fix visibility warnings in MacOS (Cling is getting the wrong -fvisibility default?). * And choose the new CMP0063 policy for that. * [skip ci] save work * [skip ci] writing up theory notes * [skip ci] writing up theory notes * [skip ci] writing up theory notes * [skip ci] writing up theory notes * [skip ci] writing up theory notes * [skip ci] writing up theory notes * [skip ci] writing up theory notes * [skip ci] theory notes are done * [skip ci] theory notes are done * Rewriting all the Slices; compiles again. * Rewriting all the Slices; toslice_part has to modify the Slice in place (because it needs to flatten boolarray -> intarrays). * toslice and toslice_part compile * toslice and toslice_part are successfully linked and can be called * Reinstated Slice tests (in a way that can be permanent). * SliceArray64 uses '...' for large arrays (shows no more than 6 elements at each level). * Broadcasting works. * Includes test against the case we're giving up on. * Numpy::getitem is beginning to work: SliceAt by strides is done. * Fix 32-bit compilation. * [skip ci] working on slice bystrides * [skip ci] slices might be working * The new getitem is tested for integer and slice. * Short-circuited NumpyArray::get and NumpyArray::slice through NumpyArray::getitem, but IDs will need to be propagated through it. * Fix 32-bit Windows. * The experimental getitem became standard __getitem__. * NumpyArray::getitem_bystrides. * Fix Python 2.7. * Starting onto NumpyArray::contiguous. * [skip ci] working on contiguous * Contiguous is working. * Stub of NumpyArray::getitem_next compiles. * getitem_next null in progress * One level of getitem_next is working. * Two levels of getitem_next are working. * Add boolean mask tests and fix integer size/signed warnings. * Empty index array is not a special case. * Slices in NumpyArray::getitem_next work. * All cases in NumpyArray::getitem are covered. * Start moving functions to cpu-kernels and fix Python 2.7. * Moving more functions into cpu-kernels. * Fixed a bug in contiguous. * Moving more functions into cpu-kernels. * Finished moving functions into cpu-kernels. * Minimize '#include' scopes.
- Loading branch information
