Merge pull request #118 from SciML/revert

Revert previous accidental push to master

Author: Tokazama

src/ArrayInterface.jl

@@ -4,7 +4,6 @@ using IfElse
 using Requires
 using LinearAlgebra
 using SparseArrays
-using Base.Cartesian
 
 using Base: @pure, @propagate_inbounds, tail, OneTo, LogicalIndex, Slice, ReinterpretArray
 

src/dimensions.jl

@@ -39,7 +39,9 @@ from_parent_dims(::Type{<:SubArray{T,N,A,I}}) where {T,N,A,I} = _from_sub_dims(A
     end
     out
 end
-from_parent_dims(::Type{<:PermutedDimsArray{T,N,<:Any,I}}) where {T,N,I} = static(Val(I))
+function from_parent_dims(::Type{<:PermutedDimsArray{T,N,<:Any,I}}) where {T,N,I}
+    return _val_to_static(Val(I))
+end
 
 """
     to_parent_dims(::Type{T}) -> Bool
@@ -49,7 +51,7 @@ Returns the mapping from child dimensions to parent dimensions.
 to_parent_dims(x) = to_parent_dims(typeof(x))
 to_parent_dims(::Type{T}) where {T} = nstatic(Val(ndims(T)))
 to_parent_dims(::Type{T}) where {T<:Union{Transpose,Adjoint}} = (StaticInt(2), One())
-to_parent_dims(::Type{<:PermutedDimsArray{T,N,I}}) where {T,N,I} = static(Val(I))
+to_parent_dims(::Type{<:PermutedDimsArray{T,N,I}}) where {T,N,I} = _val_to_static(Val(I))
 to_parent_dims(::Type{<:SubArray{T,N,A,I}}) where {T,N,A,I} = _to_sub_dims(A, I)
 @generated function _to_sub_dims(::Type{A}, ::Type{I}) where {A,N,I<:Tuple{Vararg{Any,N}}}
     out = Expr(:tuple)
@@ -77,35 +79,18 @@ function has_dimnames(::Type{T}) where {T}
     end
 end
 
-# this takes the place of dimension names that aren't defined
-const SUnderscore = StaticSymbol(:_)
-
 """
-    dimnames(::Type{T}) -> Tuple{Vararg{StaticSymbol}}
-    dimnames(::Type{T}, dim) -> StaticSymbol
+    dimnames(::Type{T}) -> Tuple{Vararg{Symbol}}
+    dimnames(::Type{T}, d) -> Symbol
 
 Return the names of the dimensions for `x`.
 """
 @inline dimnames(x) = dimnames(typeof(x))
-@inline dimnames(x, dim::Int) = dimnames(typeof(x), dim)
-@inline dimnames(x, dim::StaticInt) = dimnames(typeof(x), dim)
-@inline function dimnames(::Type{T}, ::StaticInt{dim}) where {T,dim}
-    if ndims(T) < dim
-        return SUnderscore
-    else
-        return getfield(dimnames(T), dim)
-    end
-end
-@inline function dimnames(::Type{T}, dim::Int) where {T}
-    if ndims(T) < dim
-        return SUnderscore
-    else
-        return getfield(dimnames(T), dim)
-    end
-end
+@inline dimnames(x, i::Integer) = dimnames(typeof(x), i)
+@inline dimnames(::Type{T}, d::Integer) where {T} = getfield(dimnames(T), to_dims(T, d))
 @inline function dimnames(::Type{T}) where {T}
     if parent_type(T) <: T
-        return ntuple(_ -> SUnderscore, Val(ndims(T)))
+        return ntuple(i -> :_, Val(ndims(T)))
     else
         return dimnames(parent_type(T))
     end
@@ -116,15 +101,15 @@ end
 # inserting the Val here seems to help inferability; I got a test failure without it.
 function _transpose_dimnames(::Val{S}) where {S}
     if length(S) == 1
-        (SUnderscore, first(S))
+        (:_, first(S))
     elseif length(S) == 2
         (last(S), first(S))
     else
         throw("Can't transpose $S of dim $(length(S)).")
     end
 end
 @inline _transpose_dimnames(x::Tuple{Symbol,Symbol}) = (last(x), first(x))
-@inline _transpose_dimnames(x::Tuple{Symbol}) = (SUnderscore, first(x))
+@inline _transpose_dimnames(x::Tuple{Symbol}) = (:_, first(x))
 
 @inline function dimnames(::Type{T}) where {I,T<:PermutedDimsArray{<:Any,<:Any,I}}
     return map(i -> dimnames(parent_type(T), i), I)
@@ -138,7 +123,7 @@ end
     for i in 1:length(I)
         if I[i] > 0
             if nl < i
-                push!(e.args, :(ArrayInterface.SUnderscore))
+                push!(e.args, QuoteNode(:_))
             else
                 push!(e.args, QuoteNode(L[i]))
             end
@@ -147,108 +132,58 @@ end
     return e
 end
 
-_to_int(x::Integer) = Int(x)
-_to_int(x::StaticInt) = x
-
-function no_dimname_error(@nospecialize(x), @nospecialize(dim))
-    throw(ArgumentError("($(repr(dim))) does not correspond to any dimension of ($(x))"))
-end
-
 """
-    to_dims(::Type{T}, dim) -> Integer
+    to_dims(x[, d])
 
 This returns the dimension(s) of `x` corresponding to `d`.
 """
-to_dims(x, dim) = to_dims(typeof(x), dim)
-to_dims(::Type{T}, dim::Integer) where {T} = _to_int(dim)
-to_dims(::Type{T}, dim::Colon) where {T} = dim
-function to_dims(::Type{T}, dim::StaticSymbol) where {T}
-    i = find_first_eq(dim, dimnames(T))
-    i === nothing && no_dimname_error(T, dim)
+to_dims(x, d) = to_dims(dimnames(x), d)
+to_dims(x::Tuple{Vararg{Symbol}}, d::Integer) = Int(d)
+to_dims(x::Tuple{Vararg{Symbol}}, d::Colon) = d   # `:` is the default for most methods that take `dims`
+@inline to_dims(x::Tuple{Vararg{Symbol}}, d::Tuple) = map(i -> to_dims(x, i), d)
+@inline function to_dims(x::Tuple{Vararg{Symbol}}, d::Symbol)::Int
+    i = _sym_to_dim(x, d)
+    if i === 0
+        throw(ArgumentError("Specified name ($(repr(d))) does not match any dimension name ($(x))"))
+    end
     return i
 end
-@inline function to_dims(::Type{T}, dim::Symbol) where {T}
-    i = find_first_eq(dim, Symbol.(dimnames(T)))
-    i === nothing && no_dimname_error(T, dim)
-    return i
+Base.@pure function _sym_to_dim(x::Tuple{Vararg{Symbol,N}}, sym::Symbol) where {N}
+    for i in 1:N
+        getfield(x, i) === sym && return i
+    end
+    return 0
 end
-#=
-    return i
-    i = 1
-    out = 0
-    for s in dimnames(T)
-        if Symbol(s) === dim
-            out = i
-            break
-        else
-            i += i
+
+"""
+    tuple_issubset
+
+A version of `issubset` sepecifically for `Tuple`s of `Symbol`s, that is `@pure`.
+This helps it get optimised out of existance. It is less of an abuse of `@pure` than
+most of the stuff for making `NamedTuples` work.
+"""
+Base.@pure function tuple_issubset(
+    lhs::Tuple{Vararg{Symbol,N}}, rhs::Tuple{Vararg{Symbol,M}}
+) where {N,M}
+    N <= M || return false
+    for a in lhs
+        found = false
+        for b in rhs
+            found |= a === b
         end
+        found || return false
     end
-    if out === 0
-        no_dimname_error(T, dim)
-    end
-    return out
+    return true
 end
-=#
 
-to_dims(::Type{T}, dims::Tuple) where {T} = map(i -> to_dims(T, i), dims)
-#=
-    order_named_inds(names, namedtuple)
-    order_named_inds(names, subnames, inds)
+"""
+    order_named_inds(Val(names); kwargs...)
+    order_named_inds(Val(names), namedtuple)
 
 Returns the tuple of index values for an array with `names`, when indexed by keywords.
 Any dimensions not fixed are given as `:`, to make a slice.
 An error is thrown if any keywords are used which do not occur in `nda`'s names.
-
-
-1. parse into static dimnension names and key words.
-2. find each dimnames in key words
-3. if nothing is found use Colon()
-4. if (ndims - ncolon) === nkwargs then all were found, else error
-=#
-order_named_inds(x::Tuple, ::NamedTuple{(),Tuple{}}) = ()
-function order_named_inds(x::Tuple, nd::NamedTuple{L}) where {L}
-    return order_named_inds(x, static(Val(L)), Tuple(nd))
-end
-function order_named_inds(x::Tuple{Vararg{Any,N}}, nd::Tuple, inds::Tuple) where {N}
-    out = eachop(((x, nd, inds), i) -> order_named_inds(x, nd, inds, i), (x, nd, inds), nstatic(Val(N)))
-    _order_named_inds_check(out, length(nd))
-    return out
-end
-function order_named_inds(x::Tuple, nd::Tuple, inds::Tuple, ::StaticInt{dim}) where {dim}
-    index = find_first_eq(getfield(x, dim), nd)
-    if index === nothing
-        return Colon()
-    else
-        return @inbounds(inds[index])
-    end
-end
-
-ncolon(x::Tuple{Colon,Vararg}, n::Int) = ncolon(tail(x), n + 1)
-ncolon(x::Tuple{Any,Vararg}, n::Int) = ncolon(tail(x), n)
-ncolon(x::Tuple{Colon}, n::Int) = n + 1
-ncolon(x::Tuple{Any}, n::Int) = n
-function _order_named_inds_check(inds::Tuple{Vararg{Any,N}}, nkwargs::Int) where {N}
-    if (N - ncolon(inds, 0)) !== nkwargs
-        error("Not all keywords matched dimension names.")
-    end
-    return nothing
-end
-
-
-#=
-name_to_idx(name::StaticSymbol, kwargs::Tuple, inds::Tuple, )
-name_to_idx(name::StaticSymbol, kwargs::Tuple, inds::Tuple) = _name_to_index(find_first_eq(), inds)
-_name_to_index(::Zero, ::Tuple) = Colon()
-_name_to_index(::StaticInt{N}, inds::Tuple) where {N} = getfield(inds, N)
-
-#    return permute(inds, static_find_all_in(nd, x))
-_colon_or_inds(inds::Tuple, ::Zero) = :
-_colon_or_inds(inds::Tuple, ::StaticInt{I}) where {I} = getfield(inds, I)
-
-n_i -> _colon_or_inds(inds, find_first_eq(n_i, x))
-# FIXME this needs to insert a colon on missing names
-
+"""
 @inline function order_named_inds(val::Val{L}; kwargs...) where {L}
     if isempty(kwargs)
         return ()
@@ -268,8 +203,6 @@ end
     end
     return Expr(:tuple, exs...)
 end
-=#
-
 @generated function _perm_tuple(::Type{T}, ::Val{P}) where {T,P}
     out = Expr(:curly, :Tuple)
     for p in P
@@ -378,6 +311,8 @@ end
     Expr(:block, Expr(:meta, :inline), out)
 end
 
+
+
 """
   size(A)
 
@@ -395,7 +330,12 @@ julia> ArrayInterface.size(A)
 @inline size(A) = Base.size(A)
 @inline size(A, d::Integer) = size(A)[Int(d)]
 @inline size(A, d) = Base.size(A, to_dims(A, d))
-@inline size(x::VecAdjTrans) = (One(), static_length(x))
+@inline function size(x::LinearAlgebra.Adjoint{T,V}) where {T,V<:AbstractVector{T}}
+    return (One(), static_length(x))
+end
+@inline function size(x::LinearAlgebra.Transpose{T,V}) where {T,V<:AbstractVector{T}}
+    return (One(), static_length(x))
+end
 
 function size(B::S) where {N,NP,T,A<:AbstractArray{T,NP},I,S<:SubArray{T,N,A,I}}
     return _size(size(parent(B)), B.indices, map(static_length, B.indices))

src/indexing.jl

@@ -432,7 +432,7 @@ Changing indexing based on a given argument from `args` should be done through
 @propagate_inbounds getindex(A, args...) = unsafe_getindex(A, to_indices(A, args))
 @propagate_inbounds function getindex(A; kwargs...)
     if has_dimnames(A)
-        return A[order_named_inds(dimnames(A), kwargs.data)...]
+        return A[order_named_inds(Val(dimnames(A)); kwargs...)...]
     else
         return unsafe_getindex(A, to_indices(A, ()); kwargs...)
     end
@@ -548,7 +548,7 @@ Store the given values at the given key or index within a collection.
 end
 @propagate_inbounds function setindex!(A, val; kwargs...)
     if has_dimnames(A)
-        A[order_named_inds(dimnames(A), kwargs.data)...] = val
+        A[order_named_inds(Val(dimnames(A)); kwargs...)...] = val
     else
         return unsafe_setindex!(A, val, to_indices(A, ()); kwargs...)
     end