add InvertedIndices

Author: Michael Abbott

Project.toml

@@ -6,6 +6,7 @@ version = "0.0.1"
 [deps]
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
+InvertedIndices = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
 LazyStack = "1fad7336-0346-5a1a-a56f-a06ba010965b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 NamedDims = "356022a1-0364-5f58-8944-0da4b18d706f"
@@ -17,6 +18,7 @@ Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 BenchmarkTools = "0.5"
 Compat = "3.1"
 IntervalSets = "0.3, 0.4"
+InvertedIndices = "1.0"
 LazyStack = "0.0.7"
 NamedDims = "0.2.20"
 OffsetArrays = "0.10, 0.11, 1.0"

README.md

@@ -48,14 +48,14 @@ There are also a numer of special selectors, which work like this:
 |-----------------|------------------|-------------------------|---------|
 | one nearest     | `B[time = 3]`    | `B(time = Near(17.0))`  | vector  |
 | all in a range  | `B[2:5, :]`      | `B(Interval(14,25), :)` | matrix  |
-| all matching    | `B[3:end, 3:3]`  | `B(>(17), ==(33))`      | matrix  |
+| all matching    | `B[3:end, Not(3)]` | `B(>(17), !=(33))`      | matrix  |
 | mixture         | `A[1, 2, end]`   | `A(:left, Index[2], Index[end])` | scalar |
 | non-scalar      | `B[iter=[1, 3]]` | `B(iter=[31, 33])`      | matrix  |
 
 Here `Interval(13,18)` can also be written `13..18`, it's from [IntervalSets.jl](https://github.com/JuliaMath/IntervalSets.jl). 
 Any functions can be used to select keys, including lambdas: `B(time = t -> 0<t<17)`. 
 You may give just one `::Base.Fix2` function 
-(such as `<=(18)` or `!=(20)`) provided its argument type matches the keys of one dimension.
+(such as `<=(18)` or `==(20)`) provided its argument type matches the keys of one dimension.
 An interval or a function always selects via `findall`, 
 i.e. it does not drop a dimension, even if there is exactly one match. 
 
@@ -76,17 +76,18 @@ see [PR#5](https://github.com/mcabbott/AxisKeys.jl/pull/5) for an attempt.)
 KeyedArray(rand(Int8, 2,10), ([:a, :b], 10:10:100)) # AbstractArray, Tuple{AbstractVector, ...}
 ```
 
-A nested pair with names can be constructed with keywords, 
-and (apart from a few bugs) this should work the same in either order:
+A nested pair with names can be constructed with keywords for names,
+and (apart from a few bugs) everything should work the same way in either order:
 
 ```julia
 KeyedArray(rand(Int8, 2,10), row=[:a, :b], col=10:10:100)     # KeyedArray(NamedDimsArray(...))
 NamedDimsArray(rand(Int8, 2,10), row=[:a, :b], col=10:10:100) # NamedDimsArray(KeyedArray(...))
 ```
 
 The function `wrapdims` does a bit more checking and fixing, but is not type-stable. 
-It will adjust the length of key vectors if it can, and their indexing if needed to match the array. 
-The order of wrappers produced is controlled by `AxisKeys.nameouter()=false`.
+It will adjust the length of ranges of keys if it can, 
+and will fix indexing offsets if needed to match the array. 
+The resulting order of wrappers is controlled by `AxisKeys.nameouter()=false`.
 
 ```julia
 wrapdims(rand(Int8, 10), alpha='a':'z') 
@@ -100,14 +101,11 @@ axiskeys(ans,1) # 10:10:100 with indices 0:9
 
 As usual `axes(A)` returns (a tuple of vectors of) indices, 
 and `axiskeys(A)` returns (a tuple of vectors of) keys.
-If the array has names, then `dimnames(A)` returns them, 
-and functions like `axes(A, name)` give just one.
+If the array has names, then `dimnames(A)` returns them.
+These functions work like `size(A, d) = size(A, name)` to get just one.
 
 Many functions should work, for example:
 
-* Reductions like `sum(A; dims=:channel)` can use dimension names. 
-  Likewise `prod`, `mean` etc., and `dropdims`.
-
 * Broadcasting `log.(A)` and `map(log, A)`, as well as comprehensions 
   `[log(x) for x in A]` should all work. 
 
@@ -116,21 +114,28 @@ Many functions should work, for example:
 * Concatenation `hcat(B, B .+ 100)` works. 
   Note that the keys along the glued direction may not be unique afterwards.
 
+* Reductions like `sum(A; dims=:channel)` can use dimension names. 
+  Likewise `prod`, `mean` etc., and `dropdims`.
+
 * Some linear algebra functions like `*` and `\` will work. 
 
 * Getproperty returns the key vector, to allow things like
-  `for (i,t) in enumerate(A.time); fun(A[i], t); ...`.
+  `for (i,t) in enumerate(A.time); fun(val = A[i,:], time = t); ...`.
 
 * Vectors support `push!(V, val)`, which will try to extend the key vector. 
   There is also a method `push!(V, key => val)` which pushes in a new key. 
 
 To allow for this limited mutability, `V.keys isa Ref` for vectors, 
 while `A.keys isa Tuple` for matrices & higher. But `axiskeys(A)` always returns a tuple.
 
-* [LazyStack](https://github.com/mcabbott/LazyStack.jl)`.stack` is now hooked up.
-  Stacks of named tuples like `stack((a=i, b=i^2) for i=1:5)` create axis keys.
+* Named tuples can be converted to and from keyed vectors,
+  with `collect(keys(nt)) == Symbol.(axiskeys(V),1)`
+
+* [LazyStack](https://github.com/mcabbott/LazyStack.jl)`.stack` understands names and keys.
+  Stacks of named tuples like `stack((a=i, b=i^2) for i=1:5)` create a matrix with `[:a, :b]`.
 
-* [NamedPlus](https://github.com/mcabbott/NamedPlus.jl) has a macro: `@named [n^pow for n=1:10, pow=0:2:4]` has names & keys.
+* [NamedPlus](https://github.com/mcabbott/NamedPlus.jl) has a macro which works on comprehensions:
+  `@named [n^pow for n=1:10, pow=0:2:4]` has names and keys.
 
 ### Absent
 

src/AxisKeys.jl

@@ -10,7 +10,7 @@ include("wrap.jl")
 export wrapdims
 
 include("selectors.jl")
-export Near, Index, Interval
+export Near, Index, Interval, Not
 
 include("functions.jl")
 

src/selectors.jl

@@ -1,4 +1,6 @@
 
+using InvertedIndices # needs only Base.to_indices in struct.jl to work
+
 using IntervalSets
 
 findindex(s::Interval, r::AbstractVector) = findall(i -> i in s, r)
@@ -55,7 +57,7 @@ struct Index{T} <: Selector{T}
     ind::T
 end
 
-Base.show(io::IO, s::Index{T}) where {T} = print(io, "Index(",s.ind, ")")
+Base.show(io::IO, s::Index{T}) where {T} = print(io, "Index[",s.ind, "]")
 
 Base.getindex(::Type{Index}, i) = Index(i)
 

src/struct.jl

@@ -71,7 +71,9 @@ for (bget, rget, cpy) in [(:getindex, :keys_getindex, :copy), (:view, :keys_view
             @inbounds Base.$bget(parent(A), I)
         end
 
-        @inline @propagate_inbounds function Base.$bget(A::KeyedArray, I...)
+        @inline @propagate_inbounds function Base.$bget(A::KeyedArray, Iraw...)
+            I = Base.to_indices(A, Iraw) # allows InvertedIndices.jl
+
             @boundscheck checkbounds(parent(A), I...)
             data = @inbounds Base.$bget(parent(A), I...)
 
@@ -128,13 +130,15 @@ see `Nearest` and `Index`.
 
 @inline function getkey(A, args...)
     if length(args) == ndims(A)
-        inds = map(findindex, args, axiskeys(A))
+        inds_raw = map(findindex, args, axiskeys(A))
+        inds = Base.to_indices(A, inds_raw)
         @boundscheck checkbounds(A, inds...)
         return @inbounds get_or_view(A, inds...)
 
     elseif length(args) > ndims(A) && all(args[ndims(A)+1:end] .== (:)) # trailing colons
         args_nd = args[1:ndims(A)]
-        inds = map(findindex, args_nd, axiskeys(A))
+        inds_raw = map(findindex, args_nd, axiskeys(A))
+        inds = Base.to_indices(A, inds_raw)
         @boundscheck checkbounds(A, inds...)
         if inds isa NTuple{<:Any, Int}
             return @inbounds view(keyless(A), inds...) # zero-dim view of underlying

test/_packages.jl

@@ -1,5 +1,5 @@
 using Test, AxisKeys
-using OffsetArrays, UniqueVectors, Tables, LazyStack, Dates
+using OffsetArrays, UniqueVectors, Tables, LazyStack, Dates, InvertedIndices
 
 @testset "offset" begin
 
@@ -66,4 +66,14 @@ end
     # But steps of Year(1) don't work, https://github.com/JuliaLang/julia/issues/35203
 
 end
+@testset "inverted" begin
 
+    K = wrapdims(rand(4,5))
+    @test K[:, Not(4)] == K[:, vcat(1:3, 5)] == K(:, !=(4))
+    @test K[Not(1,4), :] == K[2:3, :] == K(r -> 2<=r<=3, :)
+
+    N = wrapdims(rand(Int8, 2,3,4), a=[:one, :two], b='α':'γ', c=31:34)
+    @test N[b=Not(2)] == N[:,[1,3],:] == N(b=!=('β')) == N(:,['α','γ'],:)
+    @test N[c=Not(2,4)] == N(c=Index[Not(2,4)])
+
+end