Move out OPs, add README

Author: dlfivefifty

Project.toml

@@ -6,8 +6,6 @@ BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 ContinuumArrays = "7ae1f121-cc2c-504b-ac30-9b923412ae5c"
 DomainSets = "5b8099bc-c8ec-5219-889f-1d9e522a28bf"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
-InfiniteArrays = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
-InfiniteLinearAlgebra = "cde9dba0-b1de-11e9-2c62-0bab9446c55c"
 IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
 LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -17,7 +15,6 @@ QuasiArrays = "c4ea9172-b204-11e9-377d-29865faadc5c"
 BandedMatrices = "0.11"
 DomainSets = "0.1"
 FillArrays = "0.7"
-InfiniteArrays = "0.2"
 IntervalSets = "0.3.1"
 LazyArrays = "0.11"
 julia = "1.0"

README.md

@@ -1,2 +1,101 @@
 # ContinuumArrays.jl
-A package for representing continuum arrays
+A package for representing quasi arrays with continuous dimensions
+
+
+A quasi array as implemented in [QuasiArrays.jl](https://github.com/JuliaApproximation/QuasiArrays.jl) is a 
+generalization of an array that allows non-integer indexing via general axes. This package adds support for
+infinite-dimensional axes, including continuous intervals. Thus it plays the same role as [InfiniteArrays.jl](https://github.com/JuliaArrays/InfiniteArrays.jl) does for standard arrays but now for quasi arrays. 
+
+A simple example is the identity function on the interval `0..1`. This can be created using `Inclusion(d)`,
+which returns `x` if `x in d` is true, otherwise throws an error:
+```julia
+julia> using ContinuumArrays, IntervalSets
+
+julia> x = Inclusion(0..1.0)
+Inclusion(0.0..1.0)
+
+julia> size(x) # uncountable (aleph-1)
+(ℵ₁,)
+
+julia> axes(x) # axis is itself
+(Inclusion(0.0..1.0),)
+
+julia> x[0.1] # returns the input
+0.1
+
+julia> x[1.1] # throws an error
+ERROR: BoundsError: attempt to access Inclusion(0.0..1.0)
+  at index [1.1]
+Stacktrace:
+ [1] throw_boundserror(::Inclusion{Float64,Interval{:closed,:closed,Float64}}, ::Tuple{Float64}) at ./abstractarray.jl:538
+ [2] checkbounds at /Users/solver/Projects/QuasiArrays.jl/src/abstractquasiarray.jl:287 [inlined]
+ [3] getindex(::Inclusion{Float64,Interval{:closed,:closed,Float64}}, ::Float64) at /Users/solver/Projects/QuasiArrays.jl/src/indices.jl:158
+ [4] top-level scope at REPL[14]:1
+```
+
+An important usage is representing bases and function approximation, and this package contains
+a basic implementation of linear splines and heaviside functions. For example, we can construct splines
+with evenly spaced nodes via:
+```julia
+julia> L = LinearSpline(0:0.2:1);
+
+julia> size(L) # uncountable (alepha-1) by 11
+(ℵ₁, 6)
+
+julia> axes(L) # The interval 0.0..1.0 by 1:6. 
+(Inclusion(0.0..1.0), Base.OneTo(6))
+
+julia> L[[0.15,0.25,0.45],1:6] # can index like an array
+3×6 Array{Float64,2}:
+ 0.25  0.75  0.0   0.0   0.0  0.0
+ 0.0   0.75  0.25  0.0   0.0  0.0
+ 0.0   0.0   0.75  0.25  0.0  0.0
+```
+Functions in this basis are represented by a lazy multiplication by a basis
+and a vector of coefficients:
+```julia
+julia> f = L*[1,2,3,4,5,6]
+QuasiArrays.ApplyQuasiArray{Float64,1,typeof(*),Tuple{Spline{1,Float64},Array{Int64,1}}}(*, (Spline{1,Float64}([0.0, 0.2, 0.4, 0.6, 0.8, 1.0]), [1, 2, 3, 4, 5, 6]))
+
+julia> axes(f)
+(Inclusion(0.0..1.0),)
+
+julia> f[0.1]
+1.5
+```
+
+Creating a finite element method is possible using standard array terminology. 
+We always take the Lebesgue inner product associated with an axes, so in this
+case the mass matrix is just `L'L`. Combined with a derivative operator allows
+us to form the weak Laplacian.
+```julia
+julia> B = L[:,2:end-1]; # drop boundary terms to impose zero Dirichlet
+
+julia> Δ = (D*B)'D*B # weak Laplacian
+4×4 BandedMatrices.BandedMatrix{Float64,Array{Float64,2},Base.OneTo{Int64}}:
+ 10.0  -5.0    ⋅     ⋅ 
+ -5.0  10.0  -5.0    ⋅ 
+   ⋅   -5.0  10.0  -5.0
+   ⋅     ⋅   -5.0  10.0
+
+julia> B'f # right-hand side
+4-element Array{Float64,1}:
+ 0.4
+ 0.6
+ 0.8
+ 1.0
+
+ julia> c = Δ \ B'f # coefficients of Poisson
+4-element Array{Float64,1}:
+ 0.24               
+ 0.4                
+ 0.43999999999999995
+ 0.3199999999999999 
+
+julia> u = B*c; # expand in basis
+
+julia> u[0.1] # evaluate at 0.1
+0.12
+```
+
+

src/ContinuumArrays.jl

@@ -1,8 +1,8 @@
 module ContinuumArrays
-using IntervalSets, LinearAlgebra, LazyArrays, FillArrays, BandedMatrices, InfiniteArrays, DomainSets, InfiniteLinearAlgebra, QuasiArrays
+using IntervalSets, LinearAlgebra, LazyArrays, FillArrays, BandedMatrices, DomainSets, QuasiArrays
 import Base: @_inline_meta, axes, getindex, convert, prod, *, /, \, +, -,
                 IndexStyle, IndexLinear, ==, OneTo, tail, similar, copyto!, copy,
-                first, last
+                first, last, show
 import Base.Broadcast: materialize, BroadcastStyle
 import LazyArrays: MemoryLayout, Applied, ApplyStyle, flatten, _flatten, colsupport, adjointlayout, LdivApplyStyle
 import LinearAlgebra: pinv
@@ -14,10 +14,7 @@ import QuasiArrays: cardinality, checkindex, QuasiAdjoint, QuasiTranspose, Inclu
                     ApplyQuasiArray, ApplyQuasiMatrix, LazyQuasiArrayApplyStyle, AbstractQuasiArrayApplyStyle,
                     LazyQuasiArray, LazyQuasiVector, LazyQuasiMatrix, LazyLayout, LazyQuasiArrayStyle
 
-export Spline, LinearSpline, HeavisideSpline, DiracDelta, Derivative, 
-            Jacobi, Legendre, Chebyshev, Ultraspherical,
-            JacobiWeight, ChebyshevWeight, UltrasphericalWeight,
-            fullmaterialize
+export Spline, LinearSpline, HeavisideSpline, DiracDelta, Derivative, fullmaterialize, ℵ₁, Inclusion
 
 ####
 # Interval indexing support
@@ -29,6 +26,9 @@ struct AlephInfinity{N} <: Integer end
 
 const ℵ₁ = AlephInfinity{1}()
 
+show(io::IO, F::AlephInfinity{1}) where N =
+    print(io, "ℵ₁")
+
 
 const QMul2{A,B} = Mul{<:AbstractQuasiArrayApplyStyle, <:Tuple{A,B}}
 const QMul3{A,B,C} = Mul{<:AbstractQuasiArrayApplyStyle, <:Tuple{A,B,C}}

src/bases/bases.jl

@@ -23,6 +23,3 @@ end
 
 
 include("splines.jl")
-include("orthogonalpolynomials.jl")
-include("jacobi.jl")
-include("ultraspherical.jl")