implemented static map, reduce, etc, fixed #6

Author: chakravala

Project.toml

@@ -1,7 +1,7 @@
 name = "AbstractTensors"
 uuid = "a8e43f4a-99b7-5565-8bf1-0165161caaea"
 authors = ["Michael Reed"]
-version = "0.6.4"
+version = "0.6.5"
 
 [deps]
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

src/FixedVector.jl

@@ -0,0 +1,50 @@
+
+struct FixedVector{N,T} <: TupleVector{N,T}
+    v::Vector{T}
+    function FixedVector{N,T}(a::Vector) where {N,T}
+        if length(a) != N
+            throw(DimensionMismatch("Dimensions $(size(a)) don't match static size $S"))
+        end
+        new{N,T}(a)
+    end
+    function FixedVector{N,T}(::UndefInitializer) where {N,T}
+        new{N,T}(Vector{T}(undef,N))
+    end
+end
+
+@inline FixedVector{N}(a::Vector{T}) where {N,T} = FixedVector{N,T}(a)
+
+@generated function FixedVector{N,T}(x::NTuple{N,Any}) where {N,T}
+    exprs = [:(a[$i] = x[$i]) for i = 1:N]
+    return quote
+        $(Expr(:meta, :inline))
+        a = FixedVector{N,T}(undef)
+        @inbounds $(Expr(:block, exprs...))
+        return a
+    end
+end
+
+@inline FixedVector{N,T}(x::Tuple) where {N,T} = FixedVector{N,T}(x)
+@inline FixedVector{N}(x::NTuple{N,T}) where {N,T} = FixedVector{N,T}(x)
+
+# Overide some problematic default behaviour
+@inline Base.convert(::Type{SA}, sa::FixedVector) where {SA<:FixedVector} = SA(sa.v)
+@inline Base.convert(::Type{SA}, sa::SA) where {SA<:FixedVector} = sa
+
+# Back to Array (unfortunately need both convert and construct to overide other methods)
+@inline Base.Array(sa::FixedVector) = Vector(sa.v)
+@inline Base.Array{T}(sa::FixedVector{N,T}) where {N,T} = Vector{T}(sa.v)
+@inline Base.Array{T,1}(sa::FixedVector{N,T}) where {N,T} = Vector{T}(sa.v)
+
+@inline Base.convert(::Type{Array}, sa::FixedVector) = sa.v
+@inline Base.convert(::Type{Array{T}}, sa::FixedVector{N,T}) where {N,T} = sa.v
+@inline Base.convert(::Type{Array{T,1}}, sa::FixedVector{N,T}) where {N,T} = sa.v
+
+@propagate_inbounds Base.getindex(a::FixedVector, i::Int) = getindex(a.v, i)
+@propagate_inbounds Base.setindex!(a::FixedVector, v, i::Int) = setindex!(a.v, v, i)
+
+Base.dataids(sa::FixedVector) = Base.dataids(sa.v)
+
+function Base.promote_rule(::Type{<:FixedVector{N,T}}, ::Type{<:FixedVector{N,U}}) where {N,T,U}
+    FixedVector{N,promote_type(T,U)}
+end

src/SOneTo.jl

@@ -0,0 +1,59 @@
+
+struct SOneTo{n} <: AbstractUnitRange{Int} end
+
+@pure SOneTo(n::Int) = SOneTo{n}()
+function SOneTo{n}(r::AbstractUnitRange) where n
+    ((first(r) == 1) & (last(r) == n)) && return SOneTo{n}()
+
+    errmsg(r) = throw(DimensionMismatch("$r is inconsistent with SOneTo{$n}")) # avoid GC frame
+    errmsg(r)
+end
+Base.Tuple(::SOneTo{N}) where N = ntuple(identity, Val(N))
+
+@pure Base.axes(s::SOneTo) = (s,)
+@pure Base.size(s::SOneTo{n}) where n = (n,)
+@pure Base.length(s::SOneTo{n}) where n = n
+
+# The axes of a Slice'd SOneTo use the SOneTo itself
+Base.axes(S::Base.Slice{<:SOneTo}) = (S.indices,)
+Base.unsafe_indices(S::Base.Slice{<:SOneTo}) = (S.indices,)
+Base.axes1(S::Base.Slice{<:SOneTo}) = S.indices
+
+@propagate_inbounds function Base.getindex(s::SOneTo, i::Int)
+    @boundscheck checkbounds(s, i)
+    return i
+end
+@propagate_inbounds function Base.getindex(s::SOneTo, s2::SOneTo)
+    @boundscheck checkbounds(s, s2)
+    return s2
+end
+
+@pure Base.first(::SOneTo) = 1
+@pure Base.last(::SOneTo{n}) where n = n::Int
+@pure Base.iterate(::SOneTo{n}) where n = n::Int < 1 ? nothing : (1, 1)
+@pure function Base.iterate(::SOneTo{n}, s::Int) where {n}
+    if s < n::Int
+        s2 = s + 1
+        return (s2, s2)
+    else
+        return nothing
+    end
+end
+
+function Base.getproperty(::SOneTo{n}, s::Symbol) where {n}
+    if s === :start
+        return 1
+    elseif s === :stop
+        return n::Int
+    else
+        error("type SOneTo has no property $s")
+    end
+end
+
+Base.show(io::IO, ::SOneTo{n}) where {n} = print(io, "SOneTo(", n::Int, ")")
+Base.@pure function Base.checkindex(::Type{Bool}, ::SOneTo{n1}, ::SOneTo{n2}) where {n1, n2}
+    return n1::Int >= n2::Int
+end
+
+Base.promote_rule(a::Type{Base.OneTo{T}}, ::Type{SOneTo{n}}) where {T,n} =
+    Base.OneTo{promote_type(T, Int)}

src/Values.jl

@@ -0,0 +1,42 @@
+
+# SArray.jl
+
+struct Values{N,T} <: TupleVector{N,T}
+    v::NTuple{N,T}
+    Values{N,T}(x::NTuple{N,T}) where {N,T} = new{N,T}(x)
+    Values{N,T}(x::NTuple{N,Any}) where {N,T} = new{N,T}(convert_ntuple(T, x))
+end
+
+@pure @generated function (::Type{Values{N,T}})(x::Tuple) where {T, N}
+    return quote
+        @_inline_meta
+        Values{N,T}(x)
+    end
+end
+
+@inline Values(a::TupleVector{N}) where N = Values{N}(Tuple(a))
+@propagate_inbounds Base.getindex(v::Values, i::Int) = v.v[i]
+@inline Tuple(v::Values) = v.v
+Base.dataids(::Values) = ()
+
+# See #53
+Base.cconvert(::Type{Ptr{T}}, a::Values) where {T} = Base.RefValue(a)
+Base.unsafe_convert(::Type{Ptr{T}}, a::Base.RefValue{SA}) where {N,T,SA<:Values{N,T}} = Ptr{T}(Base.unsafe_convert(Ptr{Values{N,T}}, a))
+
+# SVector.jl
+
+@inline Values(x::NTuple{N,Any}) where N = Values{N}(x)
+@inline Values{N}(x::NTuple{N,T}) where {N,T} = Values{N,T}(x)
+@inline Values{N}(x::T) where {N,T<:Tuple} = Values{N,promote_tuple_eltype(T)}(x)
+
+# Some more advanced constructor-like functions
+@pure @inline Base.zeros(::Type{Values{N}}) where N = zeros(Values{N,Float64})
+@pure @inline Base.ones(::Type{Values{N}}) where N = ones(Values{N,Float64})
+
+# Converting a CartesianIndex to an SVector
+Base.convert(::Type{Values}, I::CartesianIndex) = Values(I.I)
+Base.convert(::Type{Values{N}}, I::CartesianIndex{N}) where {N} = Values{N}(I.I)
+Base.convert(::Type{Values{N,T}}, I::CartesianIndex{N}) where {N,T} = Values{N,T}(I.I)
+
+@pure Base.promote_rule(::Type{Values{N,T}}, ::Type{CartesianIndex{N}}) where {N,T} = Values{N,promote_type(T,Int)}
+

src/Variables.jl

@@ -0,0 +1,65 @@
+
+# MArray.jl
+
+mutable struct Variables{N,T} <: TupleVector{N,T}
+    v::NTuple{N,T}
+    Variables{N,T}(x::NTuple{N,T}) where {N,T} = new{N,T}(x)
+    Variables{N,T}(x::NTuple{N,Any}) where {N,T} = new{N,T}(convert_ntuple(T, x))
+    Variables{N,T}(::UndefInitializer) where {N,T} = new{N,T}()
+end
+
+@inline Variables(a::TupleVector{N}) where N = Variables{N}(Tuple(a))
+@generated function (::Type{Variables{N,T}})(x::Tuple) where {N,T}
+    return quote
+        $(Expr(:meta, :inline))
+        Variables{N,T}(x)
+    end
+end
+@generated function (::Type{Variables{N}})(x::T) where {N,T<:Tuple}
+    return quote
+        $(Expr(:meta, :inline))
+        Variables{N,promote_tuple_eltype(T)}(x)
+    end
+end
+
+@propagate_inbounds function Base.getindex(v::Variables, i::Int)
+    @boundscheck checkbounds(v,i)
+    T = eltype(v)
+    if isbitstype(T)
+        return GC.@preserve v unsafe_load(Base.unsafe_convert(Ptr{T}, pointer_from_objref(v)), i)
+    end
+    v.v[i]
+end
+@propagate_inbounds function Base.setindex!(v::Variables, val, i::Int)
+    @boundscheck checkbounds(v,i)
+    T = eltype(v)
+    if isbitstype(T)
+        GC.@preserve v unsafe_store!(Base.unsafe_convert(Ptr{T}, pointer_from_objref(v)), convert(T, val), i)
+    else
+        # This one is unsafe (#27)
+        # unsafe_store!(Base.unsafe_convert(Ptr{Ptr{Nothing}}, pointer_from_objref(v.data)), pointer_from_objref(val), i)
+        error("setindex!() with non-isbitstype eltype is not supported by TupleVectors. Consider using FixedVector.")
+    end
+    return val
+end
+
+@inline Base.Tuple(v::Variables) = v.v
+Base.dataids(ma::Variables) = (UInt(pointer(ma)),)
+
+@inline function Base.unsafe_convert(::Type{Ptr{T}}, a::Variables{N,T}) where {N,T}
+    Base.unsafe_convert(Ptr{T}, pointer_from_objref(a))
+end
+
+function Base.promote_rule(::Type{<:Variables{N,T}}, ::Type{<:Variables{N,U}}) where {N,T,U}
+    Variables{N,promote_type(T,U)}
+end
+
+# MVector.jl
+
+@inline Variables(x::NTuple{N,Any}) where N = Variables{N}(x)
+@inline Variables{N}(x::NTuple{N,T}) where {N,T} = Variables{N,T}(x)
+@inline Variables{N}(x::NTuple{N,Any}) where N = Variables{N, promote_tuple_eltype(typeof(x))}(x)
+
+# Some more advanced constructor-like functions
+@inline Base.zeros(::Type{Variables{N}}) where N = zeros(Variables{N,Float64})
+@inline Base.ones(::Type{Variables{N}}) where N = ones(Variables{N,Float64})

src/abstractvector.jl

@@ -0,0 +1,125 @@
+
+Base.axes(::TupleVector{N}) where N = _axes(Val(N))
+@pure function _axes(::Val{sizes}) where {sizes}
+    map(SOneTo, (sizes,))
+end
+Base.axes(rv::LinearAlgebra.Adjoint{<:Any,<:Values})   = (SOneTo(1), axes(rv.parent)...)
+Base.axes(rv::LinearAlgebra.Transpose{<:Any,<:Values}) = (SOneTo(1), axes(rv.parent)...)
+
+# Base.strides is intentionally not defined for SArray, see PR #658 for discussion
+Base.strides(a::Variables) = Base.size_to_strides(1, size(a)...)
+Base.strides(a::FixedVector) = strides(a.v)
+
+Base.IndexStyle(::Type{T}) where {T<:TupleVector} = IndexLinear()
+
+similar_type(::SA) where {SA<:TupleVector} = similar_type(SA,eltype(SA))
+similar_type(::Type{SA}) where {SA<:TupleVector} = similar_type(SA,eltype(SA))
+
+similar_type(::SA,::Type{T}) where {SA<:TupleVector{N},T} where N = similar_type(SA,T,Val(N))
+similar_type(::Type{SA},::Type{T}) where {SA<:TupleVector{N},T} where N = similar_type(SA,T,Val(N))
+
+similar_type(::A,n::Val) where {A<:AbstractArray} = similar_type(A,eltype(A),n)
+similar_type(::Type{A},n::Val) where {A<:AbstractArray} = similar_type(A,eltype(A),n)
+
+similar_type(::A,::Type{T},n::Val) where {A<:AbstractArray,T} = similar_type(A,T,n)
+
+# We should be able to deal with SOneTo axes
+similar_type(s::SOneTo) = similar_type(typeof(s))
+similar_type(::Type{SOneTo{n}}) where n = similar_type(SOneTo{n}, Int, Val(n))
+
+# Default types
+# Generally, use SArray
+similar_type(::Type{A},::Type{T},n::Val) where {A<:AbstractArray,T} = default_similar_type(T,n)
+default_similar_type(::Type{T},::Val{N}) where {N,T} = Values{N,T}
+
+similar_type(::Type{SA},::Type{T},n::Val) where {SA<:Variables,T} = mutable_similar_type(T,n)
+
+mutable_similar_type(::Type{T},::Val{N}) where {N,T} = Variables{N,T}
+
+similar_type(::Type{<:FixedVector},::Type{T},n::Val) where T = sizedarray_similar_type(T,n)
+# Should FixedVector also be used for normal Array?
+#similar_type(::Type{<:Array},::Type{T},n::Val) where T = sizedarray_similar_type(T,n)
+
+sizedarray_similar_type(::Type{T},::Val{N}) where {N,T} = FixedVector{N,T}
+
+Base.similar(::SA) where {SA<:TupleVector} = similar(SA,eltype(SA))
+Base.similar(::Type{SA}) where {SA<:TupleVector} = similar(SA,eltype(SA))
+
+Base.similar(::SA,::Type{T}) where {SA<:TupleVector{N},T} where N = similar(SA,T,Val(N))
+Base.similar(::Type{SA},::Type{T}) where {SA<:TupleVector{N},T} where N = similar(SA,T,Val(N))
+
+# Cases where a Val is given as the dimensions
+Base.similar(::A,n::Val) where A<:AbstractArray = similar(A,eltype(A),n)
+Base.similar(::Type{A},n::Val) where A<:AbstractArray = similar(A,eltype(A),n)
+
+Base.similar(::A,::Type{T},n::Val) where {A<:AbstractArray,T} = similar(A,T,n)
+
+# defaults to built-in mutable types
+Base.similar(::Type{A},::Type{T},n::Val) where {A<:AbstractArray,T} = mutable_similar_type(T,n)(undef)
+
+# both FixedVector and Array return FixedVector
+Base.similar(::Type{SA},::Type{T},n::Val) where {SA<:FixedVector,T} = sizedarray_similar_type(T,n)(undef)
+Base.similar(::Type{A},::Type{T},n::Val) where {A<:Array,T} = sizedarray_similar_type(T,n)(undef)
+
+# Support tuples of mixtures of `SOneTo`s alongside the normal `Integer` and `OneTo` options
+# by simply converting them to either a tuple of Ints or a Val, re-dispatching to either one
+# of the above methods (in the case of Val) or a base fallback (in the case of Ints).
+const HeterogeneousShape = Union{Integer, Base.OneTo, SOneTo}
+
+Base.similar(A::AbstractArray, ::Type{T}, shape::Tuple{HeterogeneousShape, Vararg{HeterogeneousShape}}) where {T} = similar(A, T, homogenize_shape(shape))
+Base.similar(::Type{A}, shape::Tuple{HeterogeneousShape, Vararg{HeterogeneousShape}}) where {A<:AbstractArray} = similar(A, homogenize_shape(shape))
+# Use an Array for TupleVectors if we don't have a statically-known size
+Base.similar(::Type{A}, shape::Tuple{Int, Vararg{Int}}) where {A<:TupleVector} = Array{eltype(A)}(undef, shape)
+
+homogenize_shape(::Tuple{}) = ()
+homogenize_shape(shape::Tuple{Vararg{SOneTo}}) = Val(prod(map(last, shape)))
+homogenize_shape(shape::Tuple{Vararg{HeterogeneousShape}}) = map(last, shape)
+
+
+@inline Base.copy(a::TupleVector) = typeof(a)(Tuple(a))
+@inline Base.copy(a::FixedVector) = typeof(a)(copy(a.v))
+
+@inline Base.reverse(v::Values) = typeof(v)(_reverse(v))
+
+@generated function _reverse(v::Values{N,T}) where {N,T}
+    return Expr(:tuple, (:(v[$i]) for i = N:(-1):1)...)
+end
+
+#--------------------------------------------------
+# Concatenation
+@inline Base.vcat(a::TupleVectorLike) = a
+@inline Base.vcat(a::TupleVectorLike{N}, b::TupleVectorLike{M}) where {N,M} = _vcat(Val(N), Val(M), a, b)
+@inline Base.vcat(a::TupleVectorLike, b::TupleVectorLike, c::TupleVectorLike...) = vcat(vcat(a,b), vcat(c...))
+
+@generated function _vcat(::Val{Sa}, ::Val{Sb}, a::TupleVectorLike, b::TupleVectorLike) where {Sa, Sb}
+
+    # TODO cleanup?
+    Snew = Sa + Sb
+    exprs = vcat([:(a[$i]) for i = 1:Sa],
+                 [:(b[$i]) for i = 1:Sb])
+    return quote
+        @_inline_meta
+        @inbounds return similar_type(a, promote_type(eltype(a), eltype(b)), Val($Snew))(tuple($(exprs...)))
+    end
+end
+
+#=@inline hcat(a::StaticVector) = similar_type(a, Size(Size(a)[1],1))(a)
+@inline hcat(a::StaticMatrixLike) = a
+@inline hcat(a::StaticVecOrMatLike, b::StaticVecOrMatLike) = _hcat(Size(a), Size(b), a, b)
+@inline hcat(a::StaticVecOrMatLike, b::StaticVecOrMatLike, c::StaticVecOrMatLike...) = hcat(hcat(a,b), hcat(c...))
+
+@generated function _hcat(::Size{Sa}, ::Size{Sb}, a::StaticVecOrMatLike, b::StaticVecOrMatLike) where {Sa, Sb}
+    if Sa[1] != Sb[1]
+        return :(throw(DimensionMismatch("Tried to hcat arrays of size $Sa and $Sb")))
+    end
+
+    exprs = vcat([:(a[$i]) for i = 1:prod(Sa)],
+                 [:(b[$i]) for i = 1:prod(Sb)])
+
+    Snew = (Sa[1], Size(Sa)[2] + Size(Sb)[2])
+
+    return quote
+        @_inline_meta
+        @inbounds return similar_type(a, promote_type(eltype(a), eltype(b)), Size($Snew))(tuple($(exprs...)))
+    end
+end=#