Support SVector in PiecewiseSegment (#265)

* Support SVector in PiecewiseSegment

* Fix SplineSpace

Author: jishnub

src/Domains/PiecewiseSegment.jl

@@ -1,11 +1,10 @@
 export PiecewiseSegment
 
-struct PiecewiseSegment{T} <: Domain{T}
-    points::Vector{T}
-    PiecewiseSegment{T}(d::Vector{T}) where {T} = new{T}(d)
+struct PiecewiseSegment{T,V<:AbstractVector{T}} <: Domain{T}
+    points::V
 end
-PiecewiseSegment(d::AbstractVector) = PiecewiseSegment{eltype(d)}(collect(d))
-PiecewiseSegment(d...) = PiecewiseSegment(collect(mapreduce(eltype,promote_type,d),d))
+PiecewiseSegment{T}(d::V) where {T,V<:AbstractVector{T}} = PiecewiseSegment{T,V}(d)
+PiecewiseSegment(d...) = PiecewiseSegment(SVector{length(d), mapreduce(eltype,promote_type,d)}(d))
 
 function PiecewiseSegment(pcsin::AbstractVector{IT}) where IT<:IntervalOrSegment
     pcs=collect(pcsin)
@@ -28,13 +27,16 @@ end
 
 ==(a::PiecewiseSegment,b::PiecewiseSegment) = a.points==b.points
 
-indomain(x, d::PiecewiseSegment) = any(in.(x, components(d)))
+indomain(x, d::PiecewiseSegment) = any(Base.Fix1(in, x), components(d))
 
 
 canonicaldomain(d::PiecewiseSegment)=d
 ncomponents(d::PiecewiseSegment)=length(d.points)-1
-component(d::PiecewiseSegment,j::Integer) = Segment(d.points[j],d.points[j+1])
-components(d::PiecewiseSegment{T}) where {T} = Segment{T}[component(d,k) for k=1:ncomponents(d)]
+component(d::PiecewiseSegment{T}, j::Integer) where {T} = Segment{T}(d.points[j], d.points[j+1])
+components(d::PiecewiseSegment) = [component(d,k) for k=1:ncomponents(d)]
+function components(d::PiecewiseSegment{<:Any, <:SVector})
+    SVector(ntuple(k->component(d,k), ncomponents(d)))
+end
 
 for OP in (:arclength,:complexlength)
     @eval $OP(d::PiecewiseSegment) = mapreduce($OP,+,components(d))

src/Domains/multivariate.jl

@@ -6,11 +6,11 @@ include("ProductDomain.jl")
 const RectDomain = Union{DomainSets.FixedIntervalProduct{2}, DomainSets.Rectangle, VcatDomain{2,<:Any,(1,1),<:Tuple}}
 
 boundary(d::RectDomain) =
-    PiecewiseSegment([SVector(leftendpoint(factor(d,1)),leftendpoint(factor(d,2))),
+    PiecewiseSegment(SVector{5}(SVector(leftendpoint(factor(d,1)),leftendpoint(factor(d,2))),
                       SVector(rightendpoint(factor(d,1)),leftendpoint(factor(d,2))),
                       SVector(rightendpoint(factor(d,1)),rightendpoint(factor(d,2))),
                       SVector(leftendpoint(factor(d,1)),rightendpoint(factor(d,2))),
-                      SVector(leftendpoint(factor(d,1)),leftendpoint(factor(d,2)))])
+                      SVector(leftendpoint(factor(d,1)),leftendpoint(factor(d,2)))))
 
 
 ## Union

src/Spaces/HeavisideSpace.jl

@@ -1,15 +1,17 @@
 # SplineSpace represents a Spline, right now piecewise constant HeavisideSpace is only implemented case
-struct SplineSpace{order,T,R} <: Space{PiecewiseSegment{T},R}
-    domain::PiecewiseSegment{T}
+struct SplineSpace{order,T,R,P<:PiecewiseSegment} <: Space{P,R}
+    domain::P
 end
 
+SplineSpace{m,T,R}(d::PiecewiseSegment{T}) where {m,T,R} = SplineSpace{m,T,R,typeof(d)}(d)
+
 SplineSpace{m,T}(d::PiecewiseSegment{T}) where {m,T} = SplineSpace{m,T,real(eltype(T))}(d)
 SplineSpace{m,T}(d::AbstractVector) where {m,T} = SplineSpace{m}(PiecewiseSegment(sort(d)))
 
 SplineSpace{m}(d::PiecewiseSegment{T}) where {m,T} = SplineSpace{m,T,real(eltype(T))}(d)
 SplineSpace{m}(d::AbstractVector) where {m} = SplineSpace{m}(PiecewiseSegment(sort(d)))
 
-const HeavisideSpace{T,R} = SplineSpace{0,T,R}
+const HeavisideSpace{T,R,P<:PiecewiseSegment} = SplineSpace{0,T,R,P}
 dimension(h::SplineSpace{λ}) where {λ} = length(h.domain.points)+λ-1
 
 convert(::Type{HeavisideSpace},d::PiecewiseSegment) = HeavisideSpace{eltype(d)}(d)
@@ -105,10 +107,10 @@ end
 
 
 
-differentiate(f::Fun{SplineSpace{1,T,R}}) where {T,R} =
+differentiate(f::Fun{<:SplineSpace{1}}) =
     Fun(HeavisideSpace(space(f).domain),
         diff(pad(f.coefficients,dimension(space(f))))./diff(space(f).domain.points))
 
-integrate(f::Fun{HeavisideSpace{T,R}}) where {T,R} =
+integrate(f::Fun{<:HeavisideSpace{T,R}}) where {T,R} =
     Fun(SplineSpace{1,T,R}(space(f).domain),
         [0;cumsum(f.coefficients).*diff(space(f).domain.points)])