Merge pull request #18 from mcabbott/range

Simplify by not allowing gather operations, nor indexing by ranges

Author: mcabbott

docs/src/basics.md

@@ -278,7 +278,7 @@ julia> C' == @cast _[j,i] := C[i,j]'
 true
 ```
 
-## Arrays of indices or functions
+## Arrays of functions
 
 Besides arrays of numbers (and arrays of arrays) you can also broadcast an array of functions,
 which is done by calling `Core._apply(f, xs...) = f(xs...)`: 
@@ -298,18 +298,6 @@ begin
 end
 ```
 
-You can also index one array using another, this example is just `view(M, :, ind)`:
-
-```jldoctest mylabel
-julia> ind = [1,1,2,2,4];
-
-julia> @cast _[i,j] := M[i,ind[j]]
-3×5 view(::Array{Int64,2}, :, [1, 1, 2, 2, 4]) with eltype Int64:
- 1  1  4  4  10
- 2  2  5  5  11
- 3  3  6  6  12
-```
-
 ## Repeated indices
 
 The only situation in which repeated indices are allowed is when they either 

docs/src/index.md

@@ -14,13 +14,14 @@ Version 0.2 was a re-write, see the [release notes](https://github.com/mcabbott/
 Version 0.4 has significant changes:
 - Broadcasting options and index ranges are now written `@cast @avx A[i,j] := B[i⊗j] (i ∈ 1:3)` instead of `@cast A[i,j] := B[i⊗j] i:3, axv` (using [LoopVectorization.jl](https://github.com/JuliaSIMD/LoopVectorization.jl) for the broadcast, and supplying the range of `i`).
 - To return an array without naming it, write an underscore `@cast _[i] := ...` rather than omitting it entirely.
+- Some fairly obscure features have been removed for simplicity: Indexing by an array `@cast A[i,k] := B[i,J[k]]` and by a range `@cast C[i] := f(D[1:3, i])` will no longer work.
+- Some dimension checks are inserted by default; previously the option `assert` did this.
 - It uses [LazyStack.jl](https://github.com/mcabbott/LazyStack.jl) to combine handles slices, simplifying earlier code. This is lazier by default, write `@cast A[i,k] := log(B[k][i]) lazy=false` (with a new keyword option) to glue into an `Array` before broadcasting.
-- It uses [TransmuteDims.jl](https://github.com/mcabbott/TransmuteDims.jl) to handle all permutations & many reshapes. This is lazier by default -- the earlier code sometimes copied to avoid reshaping a `PermutedDimsArray`. This isn't always faster, and can be disabled by `lazy=false`.
-- It inserts some dimension checks by default, previously the option `assert` did this.
+- It uses [TransmuteDims.jl](https://github.com/mcabbott/TransmuteDims.jl) to handle all permutations & many reshapes. This is lazier by default -- the earlier code sometimes copied to avoid reshaping a `PermutedDimsArray`. This isn't always faster, though, and can be disabled by `lazy=false`.
 
 ## Pages
 
-1. Use of `@cast` for broadcasting, and slicing
-2. `@reduce` and `@matmul`, for summing over some directions
-3. Options: StaticArrays, LazyArrays, Strided, LoopVectorization
-4. Docstrings, for all details.
+1. Use of `@cast` for broadcasting, dealing with arrays of arrays, and generalising `mapslices`
+2. `@reduce` and `@matmul`, for taking the sum (or the `maximum`, etc) over some dimensions
+3. Options: broadcasting with Strided.jl, LoopVectorization.jl, LazyArrays.jl, and slicing with StaticArrays.jl
+4. Docstrings, which list the complete set of possibilities.

src/macro.jl

@@ -36,8 +36,6 @@ Understands the following things:
 * `M[i,i]` means `diag(M)[i]`, but only for matrices: `N[i,i,k]` is an error.
 * `P[i,i']` is normalised to `P[i,i′]` with unicode \\prime.
 * `R[i,-j,k]` means roughly `reverse(R, dims=2)`, and `Q[i,~j,k]` similar with `shuffle`.
-* `S[i,T[j,k]]` is the 3-tensor `S[:,T]` created by indexing a matrix `S` with `T`,
-  where these integers are `all(1 .<= T .<= size(S,2))`.
 
 The left and right hand sides must have all the same indices,
 and the only repeated index allowed is `M[i,i]`, which is a diagonal not a trace.
@@ -254,15 +252,15 @@ function standardise(ex, store::NamedTuple, call::CallInfo; LHS=false)
         A = Asym
     end
 
-    # Constant indices A[i,3], A[i,_], A[i,$c], and also A[i,3:5]
+    # Constant indices A[i,3], A[i,_], A[i,$c]
     if isempty(ijk)
         # empty indices do not count as constant - this fixes some issues with 0d CuArrays
-    elseif all(isCorR, ijk)
+    elseif all(isconstant, ijk)
         needview!(ijk)                                         # replace _ with 1, if any
         Asym = maybepush(:( $A[$(ijk...)] ), store, :allconst) # protect from later processing
         return Asym                                            # and nothing more to do here
-    elseif any(isCorR, ijk)
-        ijcolon = map(i -> isCorR(i) ? i : (:), ijk)
+    elseif any(isconstant, ijk)
+        ijcolon = map(i -> isconstant(i) ? i : (:), ijk)
         if needview!(ijcolon)
             A = :( view($A, $(ijcolon...)) ) # TODO lazy_0?
         else
@@ -271,7 +269,6 @@ function standardise(ex, store::NamedTuple, call::CallInfo; LHS=false)
             A = :( TensorCast.transmute($A, $perm) )
         end
         ijk = filter(!isconstant, ijk)              # remove actual constants from list,
-        ijk = map(i -> isrange(i) ? :(:) : i, ijk)  # but for A[i,3:5] replace with : symbol, for slicing
     end
 
     # Slicing operations A[i,:,j], and A[i,3:5] after the above treatment
@@ -292,31 +289,7 @@ function standardise(ex, store::NamedTuple, call::CallInfo; LHS=false)
 
     # Nested indices A[i,j,B[k,l,m],n] or worse A[i,B[j,k],C[i,j]]
     if any(i -> @capture(i, B_[klm__]), ijk)
-        newijk, beecolon = [], [] # for simple case
-        # listB, listijk = [], []
-        for i in ijk
-            if @capture(i, B_[klm__])
-                append!(newijk, klm)
-                push!(beecolon, B)
-                # push!(listijk, klm)
-                # push!(listB, B)
-            else
-                push!(newijk, i)
-                push!(beecolon, (:))
-            end
-        end
-        if allunique(newijk) # then we are in simple case
-            ijk = newijk
-            A = :( view($A, $(beecolon...)) )
-        else
-            throw(MacroError("can't handle this indexing yet, sorry", call))
-            # LHS && error("can't do this indexing on LHS sorry")
-            # A = maybepush(A, store, :preget)
-            # target = guesstarget(??)
-            # Bs = [ targetcast(B, target, store, call) for B in listB ]
-            # Aex = getindex.(Ref(A), i)
-            # A = maybepush(Aex, store, :getindex)
-        end
+        throw(MacroError("indexing one array by another is not supported, sorry", call))
     end
 
     # Diagonal extraction A[i,i]
@@ -890,7 +863,7 @@ function indexparse(A, ijk::Vector, store=nothing, call=nothing; save=false)
 
     for (d,i) in enumerate(ijk)
 
-        if iscolon(i) || isrange(i)
+        if iscolon(i)
             if i isa QuoteNode && A != :_
                 str = "fixed size in $A[" * join(ijk, ", ") * "]" # DimensionMismatch("fixed size in M[i, \$(QuoteNode(5))]: size(M, 2) == 5") TODO print more nicely
                 push!(store.mustassert, :( size($A,$d)==$(i.value) || throw(ArgumentError($str))) )
@@ -977,7 +950,6 @@ function innerparse(firstA, ijk, store::NamedTuple, call::CallInfo; save=false)
     innerflat = []
     for (d,i) in enumerate(ijk)
         iscolon(i) && throw(MacroError("can't have a colon in inner index!", call))
-        isrange(i) && @capture(i, alpha_Int:omega_)  && throw(MacroError("can't have a range in inner index!", call)) # this is an imperfect check, must not be triggered by @cast R2[j]{i:3} := M[i,j]  which is another kind of range!
         istensor(i) && throw(MacroError("can't tensor product inner indices", call))
         (@capture(i, -j_) || @capture(i, ~j_)) && throw(MacroError("can't reverse or shuffle along inner indices", call))
 
@@ -1204,11 +1176,6 @@ isindexing(ex::Expr) = @capture(x, A_[ijk__])
 
 isCorI(i) = isconstant(i) || isindexing(ii)
 
-isrange(ex::Expr) = @capture(ex, alpha_:omega_) # this may be a terrible idea
-isrange(i) = false
-
-isCorR(i) = isconstant(i) || isrange(i) # ranges are treated a bit like constants!
-
 istensor(n::Int) = false
 istensor(s::Symbol) = false
 function istensor(ex::Expr)
@@ -1285,8 +1252,8 @@ function needview!(ij::Vector)
         elseif ij[k] isa Expr && ij[k].head == :($)
             ij[k] = ij[k].args[1]
             out = true
-        elseif ij[k] isa Expr && @capture(ij[k], alpha_:omega_) # i.e. isrange(ij[k])
-            out = true
+        # elseif ij[k] isa Expr && @capture(ij[k], alpha_:omega_) # i.e. isrange(ij[k])
+        #     out = true
         else
             error("this should never happen! needview! got ", ij[k])
         end
@@ -1412,7 +1379,6 @@ function newoutput(ex, canon, parsed, store::NamedTuple, call::CallInfo)
     isempty(parsed.reversed) || throw(MacroError("can't reverse along indices on LHS right now", call))
     isempty(parsed.shuffled) || throw(MacroError("can't shuffle along on LHS right now", call))
     any(iscolon, parsed.outer) && throw(MacroError("can't have colons on the LHS right now", call))
-    any(isrange, parsed.outer) && throw(MacroError("can't have ranges on the LHS right now", call))
 
     # Is there a reduction?
     if :reduce in call.flags

test/two.jl

@@ -69,43 +69,6 @@ end
     @cast C[i] := B[i].scal
     @test C == 1:3
 
-end
-@testset "int/bool indexing" begin
-
-    ind = [1,2,1,2]
-    M = rand(1:99, 3,4)
-
-    N1 = M[1,ind]
-    @cast N2[i] := M[1,ind[i]]
-    @test N1 == N2
-
-    N3 = M[ind,ind]
-    @cast N4[i,j] := M[ind[i],ind[j]]
-    @test N3 == N4
-
-    bool = ind .== 1
-    B1 = M[:,bool]
-    @cast B2[i,j] := M[i,bool[j]]
-    @test B1 == B2
-
-    V1 = M[CartesianIndex.(ind, ind)]
-    # @cast V2[i] := M[ind[i],ind[i]]
-
-end
-@testset "indexing with a range" begin
-
-    M = rand(1:99, 3,4)
-
-    # ranges are treated first like constants, then like colons:
-    @cast C1[i,j] := identity(M[i, 1:2])[j]
-    R1 = 1:2
-    @cast C2[i,j] := M[i, R1[j]] # explicit inner indexing
-    @test C1 == C2 == M[:, 1:2]
-
-    β = 2
-    @cast C3[i,j] := identity(M[i, 1:β])[j]
-    @test C3 == C1
-
 end
 @testset "in-place += and *=" begin