improve interoperability with arrays, cleanups

Author: daanhb

Project.toml

@@ -1,6 +1,6 @@
 name = "GridArrays"
 uuid = "356ae075-8bc9-5ef9-a342-46c9ba26438c"
-version = "0.1.16"
+version = "0.2.0"
 
 [deps]
 CompositeTypes = "b152e2b5-7a66-4b01-a709-34e65c35f657"
@@ -14,7 +14,7 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
 CompositeTypes = "0.1.3"
-DomainSets = "0.5.14,0.6"
+DomainSets = "0.6.2"
 FastGaussQuadrature = "0.4,0.5"
 FillArrays = "0.13"
 GaussQuadrature = "0.5.7"

src/GridArrays.jl

@@ -7,11 +7,6 @@ using CompositeTypes, CompositeTypes.Display
 
 using DomainSets: endpoints
 
-@deprecate AbstractSubGrid SubGrid
-@deprecate MaskedSubGrid MaskedGrid
-@deprecate mapping forward_map
-@deprecate mapped_grid map_grid
-
 ## List of imports
 
 import Base:
@@ -32,7 +27,7 @@ import CompositeTypes:
         iscomposite, component, components, ncomponents
 
 import DomainSets:
-        factors, factor, nfactors,
+        factors,
         ×, cross,
         dimension, prectype, numtype,
         minimum, maximum,
@@ -61,7 +56,7 @@ export ProductGrid, productgrid,
 export subindices, supergrid, issubindex, similar_subgrid
 
 # from generic/mapped.jl
-export MappedGrid, map_grid, apply_map
+export MappedGrid, map_grid
 
 # from subgrid/subgrid.jl
 export subgrid, mask, ProductSubGrid

src/applications/gauss.jl

@@ -195,29 +195,19 @@ gaussjacobi(n::Int, α::T, β::T) where T = gaussjacobi(T, n, α, β)
 
 
 covering(::ChebyshevTNodes{T}) where T = ChebyshevInterval{T}()
-name(g::ChebyshevTNodes) = "ChebyshevT nodes"
-
-name(g::ChebyshevExtremae) = "Chebyshev extremae"
 covering(::ChebyshevExtremae{T}) where T = ChebyshevInterval{T}()
-
-name(g::ChebyshevUNodes) = "ChebyshevU nodes"
 covering(::ChebyshevUNodes{T}) where T = ChebyshevInterval{T}()
-
-name(g::LegendreNodes) = "Legendre nodes"
 covering(::LegendreNodes{T}) where T = ChebyshevInterval{T}()
 LegendreNodes{T}(n::Int) where T = gausslegendre(T, n)[1]
 
-name(g::LaguerreNodes) = "Laguerre nodes α=$(g.α)"
 covering(::LaguerreNodes{T}) where T = HalfLine{T}()
 similargrid(grid::LaguerreNodes, T, n::Int) = LaguerreNodes{T}(n, T(grid.α))
 LaguerreNodes(n::Int, α::T) where T = gausslaguerre(T, n, α)[1]
 LaguerreNodes{T}(n::Int, α::T) where T = gausslaguerre(T, n, α)[1]
 
-name(g::HermiteNodes) = "Hermite nodes"
 covering(::HermiteNodes{T}) where T = DomainSets.FullSpace{T}()
 HermiteNodes{T}(n::Int) where T = gausshermite(T, n)[1]
 
-name(g::JacobiNodes) = "Jacobi nodes α=$(g.α), β=$(g.β)"
 covering(::JacobiNodes{T}) where T = ChebyshevInterval{T}()
 similargrid(grid::JacobiNodes, T, n::Int) = JacobiNodes{T}(n, T(grid.α), T(grid.β))
 JacobiNodes{T}(n::Int, α::T, β::T) where T = gaussjacobi(T, n, α, β)[1]

src/generic/grid.jl

@@ -7,7 +7,12 @@ Grids are arrays of points.
 abstract type AbstractGrid{T,N} <: AbstractArray{T,N}
 end
 
-const AbstractGrid1d{T <: Real} = AbstractGrid{T,1}
+const AbstractGridVector{T} = AbstractGrid{T,1}
+const AbstractGrid1d{T <: Number} = AbstractGrid{T,1}
+
+const GridLike{T,N} = Union{AbstractGrid{T,N},AbstractArray{T,N}}
+const Grid1dLike{T<:Number,N} = Union{AbstractGridVector{T},AbstractVector{T}}
+
 
 prectype(::Type{G}) where {G<:AbstractGrid} = prectype(eltype(G))
 numtype(::Type{G}) where {G<:AbstractGrid} = numtype(eltype(G))
@@ -25,8 +30,6 @@ end
     unsafe_grid_getindex(grid, i...)
 end
 
-@deprecate support(grid::AbstractGrid) covering(grid) false
-
 convert(::Type{AbstractGrid{T}}, grid::AbstractGrid{T,N}) where {T,N} = grid
 convert(::Type{AbstractGrid{T}}, grid::AbstractGrid{S,N}) where {S,T,N} = similargrid(grid, S, size(grid))
 

src/generic/mapped.jl

@@ -24,18 +24,14 @@ end
 
 (→)(g::AbstractGrid1d, d::AbstractInterval) = rescale(g, infimum(d), supremum(d))
 
-map_grid(grid::AbstractGrid, map) = (@warn "Interchange arguments of map_grid here"; map_grid(map, grid))
-map_grid(map, grid::AbstractGrid) = map_grid1(map, grid)
-map_grid1(map, grid::AbstractGrid) = map_grid2(map, grid)
+map_grid(map, grid::GridLike) = map_grid1(map, grid)
+map_grid1(map, grid) = map_grid2(map, grid)
 map_grid2(map, grid) = MappedGrid(map, grid)
 
 # some simplifications
 map_grid1(map, g::AbstractMappedGrid) = map_grid(map∘forward_map(g), supergrid(g))
 map_grid2(map::IdentityMap, grid) = grid
 
-# Convenience function, similar to apply_map for Dictionary's
-apply_map(grid::AbstractGrid, map::AbstractMap) = map_grid(map, grid)
-
 forward_map(g::AbstractGrid, x...) = forward_map(g)(x...)
 inverse_map(g::AbstractGrid, x...) = inverse_map(g)(x...)
 

src/generic/product.jl

@@ -7,10 +7,10 @@ size(g::ProductGrid) = map(length, g.grids)
 size(g::ProductGrid, j::Int) = length(g.grids[j])
 
 ProductGrid(grids...) = VcatGrid(grids...)
-ProductGrid(grids::AbstractGrid1d...) = FlatProductGrid(grids...)
+ProductGrid(grids::Grid1dLike...) = FlatProductGrid(grids...)
 
 ProductGrid{T}(grids...) where {N,S,T <: SVector{N,S}} = VcatGrid{N,S}(grids...)
-ProductGrid{T}(grids::AbstractGrid1d...) where {N,S,T <: SVector{N,S}} =
+ProductGrid{T}(grids::Grid1dLike...) where {N,S,T <: SVector{N,S}} =
 	FlatProductGrid{N,S}(grids...)
 
 similargrid(grid::ProductGrid, ::Type{T}, dims...) where T = error()#ProductGrid([similargrid(g, eltype(T), dims[i]) for (i,g) in enumerate(components(grid))]...)
@@ -46,19 +46,21 @@ canonicalgrid(g::ProductGrid) = ProductGrid(map(canonicalgrid, components(g)))
 mapto_canonical(g::ProductGrid) = ProductMap(map(mapto_canonical, components(g)))
 mapfrom_canonical(g::ProductGrid) = ProductMap(map(mapfrom_canonical, components(g)))
 
+# Pretty printing
 Display.combinationsymbol(d::ProductGrid) = Display.Times()
 Display.displaystencil(d::ProductGrid) = composite_displaystencil(d)
 Base.show(io::IO, mime::MIME"text/plain", d::ProductGrid) = composite_show(io, mime, d)
 Base.show(io::IO, d::ProductGrid) = composite_show_compact(io, d)
 
+
 "A `FlatProductGrid` is a product grid of `N` 1-D grids."
 struct FlatProductGrid{N,T,GG} <: ProductGrid{SVector{N,T},N}
 	grids	::	GG
 end
 
-FlatProductGrid(grids::Vararg{AbstractGrid,N}) where {N} =
+FlatProductGrid(grids::Vararg{Any,N}) where {N} =
 	FlatProductGrid{N}(grids...)
-function FlatProductGrid{N}(grids::Vararg{AbstractGrid,N}) where {N}
+function FlatProductGrid{N}(grids::Vararg{Any,N}) where {N}
 	T = mapreduce(numtype, promote_type, grids)
 	FlatProductGrid{N,T}(grids...)
 end

src/subgrid/indexed.jl

@@ -10,20 +10,18 @@ struct IndexSubGrid{G,I,T,N} <: SubGrid{T,N}
 	subindices :: I
 	domain 	   :: Domain
 
-	function IndexSubGrid{G,I,T,N}(supergrid::AbstractGrid{T,N}, subindices, domain=Interval(first(supergrid), last(supergrid))) where {G,I,T,N}
+	function IndexSubGrid{G,I,T,N}(supergrid::AbstractArray{T,N}, subindices, domain=Interval(first(supergrid), last(supergrid))) where {G,I,T,N}
 		@assert length(subindices) <= length(supergrid)
 		new(supergrid, subindices, domain)
 	end
 end
 
-IndexSubGrid(grid::AbstractGrid{T,N}, I, domain=Interval(first(grid), last(grid))) where {T,N} =
+IndexSubGrid(grid::AbstractArray{T,N}, I, domain=Interval(first(grid), last(grid))) where {T,N} =
     IndexSubGrid{typeof(grid),typeof(I),T,N}(grid, I, domain)
 
-name(g::IndexSubGrid) = "Index-based subgrid"
-
 subindices(g::IndexSubGrid) = g.subindices
 
-similar_subgrid(g::IndexSubGrid, g2::AbstractGrid) = IndexSubGrid(g2, subindices(g))
+similar_subgrid(g::IndexSubGrid, g2::AbstractArray) = IndexSubGrid(g2, subindices(g))
 
 length(g::IndexSubGrid) = length(subindices(g))
 
@@ -46,11 +44,7 @@ end
 
 covering(g::IndexSubGrid) = g.domain
 
-
-
 # Check whether element grid[i] (of the underlying grid) is in the indexed subgrid.
 issubindex(i, g::IndexSubGrid) = in(i, subindices(g))
 
-# getindex(grid::AbstractGrid, i::Range) = IndexSubGrid(grid, i)
-
 getindex(grid::AbstractGrid, i::AbstractArray{Int}) = IndexSubGrid(grid, i)

src/subgrid/masked.jl

@@ -4,43 +4,44 @@
 
 
 """
-    struct MaskedGrid{G,M,I,T} <: SubGrid{T,1}
+    struct MaskedGrid{T,GRID,MASK,I,D} <: SubGrid{T,1}
 
 A MaskedGrid is a subgrid of another grid that is defined by a mask.
 The mask is true or false for each point in the supergrid. The set of points
 for which it is true make up the MaskedGrid.
 """
-struct MaskedGrid{G,M,I,D<:Domain,T} <: SubGrid{T,1}
-    supergrid   ::	G
-    mask	    ::	M
+struct MaskedGrid{T,GRID,MASK,I,D} <: SubGrid{T,1}
+    supergrid   ::	GRID
+    mask	    ::	MASK
     indices     ::  Vector{I}
     M           ::	Int				# Total number of points in the mask
     domain      ::  D
 
-    MaskedGrid{G,M,I,D,T}(supergrid::AbstractGrid{T}, mask, indices, domain) where {G,M,I,D,T} =
+    MaskedGrid{T,GRID,MASK,I,D}(supergrid::AbstractArray{T}, mask, indices, domain) where {T,GRID,MASK,I,D} =
         new(supergrid, mask, indices, sum(mask), domain)
 end
 # TODO: In MaskedGrid, perhaps we should not be storing pointers to the points of the underlying grid, but
 # rather the points themselves. In that case we wouldn't need to specialize on the type of grid (parameter G can go).
 
 
+MaskedGrid(supergrid::AbstractArray{T}, mask, indices, domain) where T =
+	MaskedGrid{T}(supergrid, mask, indices, domain)
 
-function MaskedGrid(supergrid::AbstractGrid{T}, mask, indices, domain) where {T}
+function MaskedGrid{T}(supergrid, mask, indices, domain) where T
 	@assert size(supergrid) == size(mask)
-
-	MaskedGrid{typeof(supergrid),typeof(mask),eltype(indices),typeof(domain),T}(supergrid, mask, indices, domain)
+	MaskedGrid{T,typeof(supergrid),typeof(mask),eltype(indices),typeof(domain)}(supergrid, mask, indices, domain)
 end
 
 # These are for the assignment to indices in the function below.
 convert(::Type{NTuple{N,Int}},i::CartesianIndex{N}) where {N} = ntuple(k->i[k],N)
 
-MaskedGrid(supergrid::AbstractGrid, domain::Domain) =
+MaskedGrid(supergrid::AbstractArray, domain::Domain) =
 	MaskedGrid(supergrid, in.(supergrid, Ref(domain)), domain)
 
 # MaskedGrid(maskedgrid::MaskedGrid, domain::Domain) =
 #     MaskedGrid(supergrid(maskedgrid), mask(maskedgrid) .& in.(supergrid(maskedgrid), domain))
 
-MaskedGrid(supergrid::AbstractGrid, mask, domain) =
+MaskedGrid(supergrid::AbstractArray, mask, domain) =
     MaskedGrid(supergrid, mask, subindices(supergrid, mask), domain)
 
 function subindices(supergrid, mask::BitArray)
@@ -64,7 +65,7 @@ covering(g::MaskedGrid) = g.domain
 
 subindices(g::MaskedGrid) = g.indices
 
-similar_subgrid(g::MaskedGrid, g2::AbstractGrid) = MaskedGrid(g2, g.mask, g.indices)
+similar_subgrid(g::MaskedGrid, g2::AbstractArray) = MaskedGrid(g2, g.mask, g.indices)
 
 
 # Check whether element grid[i] (of the underlying grid) is in the masked grid.
@@ -77,6 +78,4 @@ getindex(g::AbstractGrid, idx::BitArray) = MaskedGrid(g, idx, covering(g))
 function subgrid(grid::MaskedGrid, domain::Domain)
     submask = in.(supergrid(grid), Ref(domain))
     MaskedGrid(supergrid(grid), submask .& mask(grid), domain)
-    # points = grid.points[mask]
-    # ScatteredGrid(points)
 end

src/subgrid/product.jl

@@ -8,7 +8,7 @@ const ProductSubGrid = FlatProductGrid{N,T,<:NTuple{N,GRID}} where {N,T} where {
 # 	R
 # end
 
-function tensorproductbitarray(vectors::Vararg{<:Union{BitVector,Vector{Bool}}, N}) where N
+function tensorproductbitarray(vectors::Vararg{Union{BitVector,Vector{Bool}}, N}) where N
 	R = falses(map(length, vectors))
 	@inbounds for i in CartesianIndices(size(R))
 		t = true

src/subgrid/subgrid.jl

@@ -1,8 +1,6 @@
 
 """
-    abstract type SubGrid{T,N} <: AbstractGrid{T,N} end
-
-A subgrid of an underlying grid.
+Supertype of lazy subgrids of a grid.
 """
 abstract type SubGrid{T,N} <: SimpleLazyGrid{T,N} end
 
@@ -14,7 +12,7 @@ include("product.jl")
 include("boundary.jl")
 
 
-subgrid(grid::AbstractGrid, domain::Domain) = MaskedGrid(grid, domain)
+subgrid(grid::AbstractArray, domain::Domain) = MaskedGrid(grid, domain)
 
 function subgrid(grid::AbstractEquispacedGrid, domain::AbstractInterval)
     a = infimum(domain)
@@ -27,12 +25,12 @@ function subgrid(grid::AbstractEquispacedGrid, domain::AbstractInterval)
     IndexSubGrid(grid, idx_a:idx_b, domain)
 end
 
-function subgrid(grid::ScatteredGrid, domain::Domain)
-    mask = in.(grid, Ref(domain))
-    points = grid.points[mask]
-    ScatteredGrid(points, domain)
-end
-
+# function subgrid(grid::ScatteredGrid, domain::Domain)
+#     mask = in.(grid, Ref(domain))
+#     points = grid.points[mask]
+#     ScatteredGrid(points, domain)
+# end
+#
 function subgrid(grid::ProductGrid, domain::ProductDomain)
     if ncomponents(grid) == ncomponents(domain)
         productgrid(map(subgrid, components(grid), components(domain))...)