AxisArray -> QuasiArray, added delta function

Author: dlfivefifty

src/ContinuumArrays.jl

@@ -1,18 +1,26 @@
 module ContinuumArrays
-include("axisarrays/AbstractAxisArrays.jl")
-using .AbstractAxisArrays
+using IntervalSets, LinearAlgebra, LazyArrays
+import Base: @_inline_meta, axes, getindex, convert, prod, *, /, \, +, -,
+                IndexStyle, IndexLinear
+import Base.Broadcast: materialize
 
+include("QuasiArrays/QuasiArrays.jl")
+using .QuasiArrays
+import .QuasiArrays: _length, checkindex, Adjoint, Transpose
+
+export Spline, LinearSpline, HeavisideSpline, DiracDelta
 
 ####
 # Interval indexing support
 ####
+struct AlephInfinity{N} <: Integer end
+
+const ℵ₁ = AlephInfinity{1}()
 
-using IntervalSets
-import .AbstractAxisArrays: _length, checkindex, Adjoint, Transpose
-import Base: @_inline_meta
 
-struct ℵ₀ <: Number end
-_length(::AbstractInterval) = ℵ₀
+_length(::AbstractInterval) = ℵ₁
+*(ℵ::AlephInfinity) = ℵ
+
 
 checkindex(::Type{Bool}, inds::AbstractInterval, i::Real) = (leftendpoint(inds) <= i) & (i <= rightendpoint(inds))
 function checkindex(::Type{Bool}, inds::AbstractInterval, I::AbstractArray)
@@ -24,4 +32,7 @@ function checkindex(::Type{Bool}, inds::AbstractInterval, I::AbstractArray)
     b
 end
 
+include("operators.jl")
+include("bases/bases.jl")
+
 end

src/axisarrays/AbstractAxisArrays.jl renamed to src/QuasiArrays/QuasiArrays.jl

@@ -1,34 +1,36 @@
-module AbstractAxisArrays
+module QuasiArrays
 using Base, LinearAlgebra, LazyArrays
 import Base: getindex, size, axes, length, ==, isequal, iterate, CartesianIndices, LinearIndices,
                 Indices, IndexStyle, getindex, setindex!, parent, vec, convert, similar, zero,
                 map, eachindex, eltype
 import Base: @_inline_meta, DimOrInd, OneTo, @_propagate_inbounds_meta, @_noinline_meta,
                 DimsInteger, error_if_canonical_getindex, @propagate_inbounds, _return_type, _default_type,
                 _maybetail, tail, _getindex, _maybe_reshape, index_ndims, _unsafe_getindex,
-                index_shape, to_shape, unsafe_length, @nloops, @ncall
+                index_shape, to_shape, unsafe_length, @nloops, @ncall, Slice
 import Base: ViewIndex, Slice, ScalarIndex, RangeIndex
 import Base: *, /, \, +, -, inv
 
+import Base.Broadcast: materialize
+
 import LinearAlgebra: transpose, adjoint, checkeltype_adjoint, checkeltype_transpose
 
 import LazyArrays: MemoryLayout, UnknownLayout
 
-export AbstractAxisArray, AbstractAxisMatrix, AbstractAxisVector, materialize
+export AbstractQuasiArray, AbstractQuasiMatrix, AbstractQuasiVector, materialize
 
-abstract type AbstractAxisArray{T,N} end
-AbstractAxisVector{T} = AbstractAxisArray{T,1}
-AbstractAxisMatrix{T} = AbstractAxisArray{T,2}
-AbstractAxisVecOrMat{T} = Union{AbstractAxisVector{T}, AbstractAxisMatrix{T}}
+abstract type AbstractQuasiArray{T,N} end
+AbstractQuasiVector{T} = AbstractQuasiArray{T,1}
+AbstractQuasiMatrix{T} = AbstractQuasiArray{T,2}
+AbstractQuasiVecOrMat{T} = Union{AbstractQuasiVector{T}, AbstractQuasiMatrix{T}}
 
 
 _length(d) = length(d)
 
-size(A::AbstractAxisArray) = _length.(axes(A))
-axes(A::AbstractAxisArray) = error("Override axes for $(typeof(A))")
+size(A::AbstractQuasiArray) = _length.(axes(A))
+axes(A::AbstractQuasiArray) = error("Override axes for $(typeof(A))")
 
 include("indices.jl")
-include("abstractaxisarray.jl")
+include("abstractquasiarray.jl")
 include("multidimensional.jl")
 include("subarray.jl")
 include("matmul.jl")