Replace Vec by SVector (#61)

* Replace Vec by SVector

* BandedMatrices for bandwidths

Author: jishnub

Project.toml

@@ -1,30 +1,34 @@
 name = "ApproxFunFourier"
 uuid = "59844689-9c9d-51bf-9583-5b794ec66d30"
-version = "0.3.4"
+version = "0.3.5"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
 ApproxFunBase = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
+BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 DomainSets = "5b8099bc-c8ec-5219-889f-1d9e522a28bf"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 FastTransforms = "057dd010-8810-581a-b7be-e3fc3b93f78c"
 InfiniteArrays = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
 IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 AbstractFFTs = "0.5, 1"
-ApproxFunBase = "0.7"
+ApproxFunBase = "0.7.34"
 ApproxFunBaseTest = "0.1"
 Aqua = "0.5"
+BandedMatrices = "0.16, 0.17"
 DomainSets = "0.3, 0.4, 0.5"
 FFTW = "1.1"
 FastTransforms = "0.10, 0.11, 0.12, 0.13, 0.14"
 InfiniteArrays = "0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 0.11, 0.12"
 IntervalSets = "0.5, 0.6, 0.7"
 Reexport = "0.2, 1"
 SpecialFunctions = "0.8, 0.9, 0.10, 1.0, 2.0"
+StaticArrays = "1"
 julia = "1.6"
 
 [extras]

src/ApproxFunFourier.jl

@@ -1,81 +1,57 @@
 module ApproxFunFourier
-using Base, LinearAlgebra, Reexport, AbstractFFTs, FFTW, InfiniteArrays, FastTransforms, IntervalSets,
-            DomainSets
+using Base, LinearAlgebra, Reexport, AbstractFFTs, FFTW, InfiniteArrays,
+            FastTransforms, IntervalSets, DomainSets
 
 @reexport using ApproxFunBase
 
 import AbstractFFTs: Plan, fft, ifft
-import FFTW: plan_r2r!, fftwNumber, REDFT10, REDFT01, REDFT00, RODFT00, R2HC, HC2R,
-                r2r!, r2r,  plan_fft, plan_ifft, plan_ifft!, plan_fft!
-
-import ApproxFunBase: normalize!, flipsign, FiniteRange, Fun, MatrixFun, UnsetSpace, VFun, RowVector,
-                UnivariateSpace, AmbiguousSpace, SumSpace, SubSpace, WeightSpace, NoSpace, Space,
-                HeavisideSpace, PointSpace,
-                IntervalOrSegment, RaggedMatrix, AlmostBandedMatrix,
-                AnyDomain, ZeroSpace, ArraySpace, TrivialInterlacer, BlockInterlacer,
-                AbstractTransformPlan, TransformPlan, ITransformPlan,
-                ConcreteConversion, ConcreteMultiplication, ConcreteDerivative, ConcreteIntegral, CalculusOperator,
-                ConcreteVolterra, Volterra, VolterraWrapper,
-                MultiplicationWrapper, ConversionWrapper, DerivativeWrapper, Evaluation, EvaluationWrapper,
-                Conversion, defaultConversion, defaultcoefficients, default_Fun, Multiplication, Derivative, Integral, bandwidths,
-                ConcreteEvaluation, ConcreteDefiniteLineIntegral, ConcreteDefiniteIntegral, ConcreteIntegral,
-                DefiniteLineIntegral, DefiniteIntegral, ConcreteDefiniteIntegral, ConcreteDefiniteLineIntegral, IntegralWrapper,
-                ReverseOrientation, ReverseOrientationWrapper, ReverseWrapper, Reverse, NegateEven,
-                Dirichlet, ConcreteDirichlet, DirichletWrapper,
-                TridiagonalOperator, SubOperator, Space, @containsconstants, spacescompatible,
-                hasfasttransform, canonicalspace, domain, setdomain, prectype, domainscompatible,
-                plan_transform, plan_itransform, plan_transform!, plan_itransform!, transform, itransform, hasfasttransform,
-                CanonicalTransformPlan, ICanonicalTransformPlan,
-                Integral,
-                domainspace, rangespace,
-                union_rule, conversion_rule, maxspace_rule, conversion_type, maxspace, hasconversion, points,
-                rdirichlet, ldirichlet, lneumann, rneumann, ivp, bvp,
-                linesum, differentiate, integrate, linebilinearform, bilinearform,
-                UnsetNumber, coefficienttimes, subspace_coefficients, sumspacecoefficients, specialfunctionnormalizationpoint,
-                Segment, IntervalOrSegmentDomain, PiecewiseSegment, isambiguous, Vec, eps, isperiodic,
-                arclength, complexlength,
-                invfromcanonicalD, fromcanonical, tocanonical, fromcanonicalD, tocanonicalD, canonicaldomain, setcanonicaldomain, mappoint,
-                reverseorientation, checkpoints, evaluate, mul_coefficients, coefficients, coefficientmatrix, isconvertible,
-                clenshaw, ClenshawPlan, sineshaw,
-                toeplitz_getindex, toeplitz_axpy!, sym_toeplitz_axpy!, hankel_axpy!, ToeplitzOperator, SymToeplitzOperator, hankel_getindex,
-                SpaceOperator, ZeroOperator, InterlaceOperator,
-                interlace!, reverseeven!, negateeven!, cfstype, pad!, alternatesign!, mobius,
-                extremal_args, hesseneigvals, chebyshev_clenshaw, recA, recB, recC, roots,splitatroots,
-                chebmult_getindex, intpow, alternatingsum,
-                domaintype, diagindshift, rangetype, weight, isapproxinteger, default_Dirichlet, scal!, dotu,
-                components, promoterangespace, promotedomainspace, choosedomainspace,
-                block, blockstart, blockstop, blocklengths, isblockbanded, pointscompatible,
-                AbstractProductSpace, MultivariateFun, BivariateSpace,
-                @wrapperstructure, @wrapperspaces, @wrapper, @calculus_operator, resizedata!, slnorm, affine_setdiff,
-                complexroots, EmptyDomain, RectDomain
-
-
-import DomainSets: Domain, indomain, UnionDomain, ProductDomain, FullSpace, Point, elements, DifferenceDomain,
-            Interval, ChebyshevInterval, boundary, ∂, rightendpoint, leftendpoint,
-            dimension
-
-import Base: values, convert, getindex, setindex!, *, +, -, ==, <, <=, >, |, !, !=, eltype, iterate,
-                >=, /, ^, \, ∪, transpose, size, tail, broadcast, broadcast!, copyto!, copy, to_index, (:),
-                similar, map, vcat, hcat, hvcat, show, summary, stride, sum, cumsum, sign, imag, conj, inv,
-                complex, reverse, exp, sqrt, abs, abs2, sign, issubset, values, in, first, last, rand, intersect, setdiff,
-                isless, union, angle, join, isnan, isapprox, isempty, sort, merge, promote_rule,
-                minimum, maximum, extrema, argmax, argmin, findmax, findmin, isfinite,
-                zeros, zero, one, promote_rule, repeat, length, resize!, isinf,
-                getproperty, findfirst, unsafe_getindex, fld, cld, div, real, imag,
-                @_inline_meta, eachindex, firstindex, lastindex, keys, isreal, OneTo,
-                Array, Vector, Matrix, view, ones, @propagate_inbounds, print_array,
-                split
-
-import LinearAlgebra: BlasInt, BlasFloat, norm, ldiv!, mul!, det, eigvals, dot, cross,
-                qr, qr!, rank, isdiag, istril, istriu, issymmetric, ishermitian,
-                Tridiagonal, diagm, diagm_container, factorize, nullspace,
-                Hermitian, Symmetric, adjoint, transpose, char_uplo
-
-import InfiniteArrays: InfRanges, AbstractInfUnitRange, OneToInf
-
-import FastTransforms: ChebyshevTransformPlan, IChebyshevTransformPlan, plan_chebyshevtransform,
-                        plan_chebyshevtransform!, plan_ichebyshevtransform, plan_ichebyshevtransform!
-
+import FFTW: plan_r2r!, fftwNumber, RODFT00, R2HC, HC2R, plan_fft, plan_ifft,
+            plan_ifft!, plan_fft!
+
+import ApproxFunBase: Fun, SumSpace, SubSpace, NoSpace, IntervalOrSegment,
+            AnyDomain, AbstractTransformPlan, TransformPlan, ITransformPlan,
+            ConcreteConversion, ConcreteMultiplication, ConcreteDerivative,
+            MultiplicationWrapper, ConversionWrapper, DerivativeWrapper,
+            Evaluation, Conversion, Multiplication,
+            Derivative, ConcreteEvaluation, ConcreteIntegral,
+            DefiniteLineIntegral, DefiniteIntegral, ConcreteDefiniteIntegral,
+            ConcreteDefiniteLineIntegral, IntegralWrapper, Reverse, NegateEven,
+            ReverseOrientation, ReverseOrientationWrapper, ReverseWrapper,
+            Dirichlet, DirichletWrapper, Space, @containsconstants,
+            spacescompatible, canonicalspace, domain, setdomain, prectype,
+            domainscompatible, plan_transform, plan_itransform, plan_transform!,
+            plan_itransform!, transform, itransform, hasfasttransform, Integral,
+            domainspace, rangespace, union_rule, conversion_rule, maxspace_rule,
+            conversion_type, maxspace, hasconversion, points, rdirichlet,
+            ldirichlet, lneumann, rneumann, ivp, bvp, eps,
+            linesum, differentiate, integrate, linebilinearform, bilinearform,
+            UnsetNumber, coefficienttimes, Segment, isambiguous, isperiodic,
+            arclength, complexlength, invfromcanonicalD, fromcanonical,
+            tocanonical, fromcanonicalD, tocanonicalD, canonicaldomain,
+            setcanonicaldomain, mappoint, reverseorientation, checkpoints,
+            evaluate, mul_coefficients, coefficients, clenshaw, ClenshawPlan,
+            sineshaw, toeplitz_getindex, ToeplitzOperator, hankel_getindex,
+            SpaceOperator, ZeroOperator, InterlaceOperator, interlace!,
+            reverseeven!, negateeven!, cfstype, alternatesign!, extremal_args,
+            hesseneigvals, chebyshev_clenshaw, roots, EmptyDomain,
+            chebmult_getindex, components, affine_setdiff, complexroots
+
+import BandedMatrices: bandwidths
+
+import DomainSets: Domain, indomain, UnionDomain, Point, Interval,
+            boundary, rightendpoint, leftendpoint
+
+import Base: convert, getindex, *, +, -, ==,  /, eltype,
+            show, sum, cumsum, conj, issubset, first, last, rand, setdiff,
+            angle, isempty, zeros, one, promote_rule, real, imag
+
+import LinearAlgebra: norm, mul!
+
+using InfiniteArrays: AbstractInfUnitRange
+
+using FastTransforms: plan_chebyshevtransform, plan_ichebyshevtransform
+
+using StaticArrays: SVector
 
 export Fourier, Taylor, Hardy, CosSpace, SinSpace, Laurent, PeriodicDomain
 

src/Domains/Circle.jl

@@ -21,7 +21,7 @@ struct Circle{T,V<:Real,TT} <: PeriodicDomain{TT}
 end
 
 Circle(c::Number,r::Real,o::Bool) = Circle{typeof(c),typeof(r),Complex{typeof(r)}}(c,r,o)
-Circle(c::Vec,r::Real,o::Bool) = Circle{typeof(c),typeof(r),typeof(c)}(c,r,o)
+Circle(c::SVector,r::Real,o::Bool) = Circle{typeof(c),typeof(r),typeof(c)}(c,r,o)
 
 Circle(::Type{T1},c::T2,r::V,o::Bool) where {T1,T2,V<:Real} = Circle(convert(promote_type(T1,T2,V),c),
 															  convert(promote_type(real(T1),real(T2),V),r),o)
@@ -30,15 +30,15 @@ Circle(::Type{T1},c,r::Real) where {T1<:Number} = Circle(T1,c,r)
 Circle(c,r::Real) = Circle(c,r,true)
 Circle(r::Real) = Circle(zero(r),r)
 Circle(r::Int) = Circle(Float64,0.,r)
-Circle(a::Tuple,r::Real) = Circle(Vec(a...),r)
+Circle(a::Tuple,r::Real) = Circle(SVector(a...),r)
 
 Circle(::Type{V}) where {V<:Real} = Circle(one(V))
 Circle() = Circle(1.0)
 
 
 
 isambiguous(d::Circle{T}) where {T<:Number} = isnan(d.center) && isnan(d.radius)
-isambiguous(d::Circle{T}) where {T<:Vec} = all(isnan,d.center) && isnan(d.radius)
+isambiguous(d::Circle{T}) where {T<:SVector} = all(isnan,d.center) && isnan(d.radius)
 convert(::Type{Circle{T,V}},::AnyDomain) where {T<:Number,V<:Real} = Circle{T,V}(NaN,NaN)
 convert(::Type{IT},::AnyDomain) where {IT<:Circle} = Circle(NaN,NaN)
 
@@ -52,7 +52,7 @@ function tocanonical(d::Circle{T},ζ) where T<:Number
 	_tocanonical(reim(v))
 end
 
-function tocanonical(d::Circle{T},ζ) where T<:Vec
+function tocanonical(d::Circle{T},ζ) where T<:SVector
     v=mappoint(d,Circle((0.0,0.0),1.0),ζ)
 	_tocanonical(v)
 end
@@ -64,10 +64,10 @@ fromcanonicalD(d::Circle{T},θ) where {T<:Number} =
 	(d.orientation ? 1 : -1)*d.radius*1.0im*exp((d.orientation ? 1 : -1)*1.0im*θ)
 
 
-fromcanonical(d::Circle{T},θ::Number) where {T<:Vec} =
-	d.radius*Vec(cos((d.orientation ? 1 : -1)*θ),sin((d.orientation ? 1 : -1)*θ)) + d.center
-fromcanonicalD(d::Circle{T},θ::Number) where {T<:Vec} =
-	d.radius*(d.orientation ? 1 : -1)*Vec(-sin((d.orientation ? 1 : -1)*θ),cos((d.orientation ? 1 : -1)*θ))
+fromcanonical(d::Circle{T},θ::Number) where {T<:SVector} =
+	d.radius*SVector(cos((d.orientation ? 1 : -1)*θ),sin((d.orientation ? 1 : -1)*θ)) + d.center
+fromcanonicalD(d::Circle{T},θ::Number) where {T<:SVector} =
+	d.radius*(d.orientation ? 1 : -1)*SVector(-sin((d.orientation ? 1 : -1)*θ),cos((d.orientation ? 1 : -1)*θ))
 
 
 indomain(z,d::Circle) = norm(z-d.center) ≈ d.radius
@@ -80,11 +80,11 @@ complexlength(d::Circle) = (d.orientation ? 1 : -1)*im*arclength(d)  #TODO: why?
 
 
 
-mappoint(d1::Circle{T},d2::Circle{V},z) where {T<:Vec,V<:Number} =
+mappoint(d1::Circle{T},d2::Circle{V},z) where {T<:SVector,V<:Number} =
 	mappoint(Circle(complex(d1.center...),d1.radius),d2,z[1]+im*z[2])
 
-mappoint(d1::Circle{T},d2::Circle{V},z) where {T<:Number,V<:Vec} =
-	mappoint(Circle(Vec(d1.center...),d1.radius),d2,Vec(real(z),imag(z)))
+mappoint(d1::Circle{T},d2::Circle{V},z) where {T<:Number,V<:SVector} =
+	mappoint(Circle(SVector(d1.center...),d1.radius),d2,SVector(real(z),imag(z)))
 
 function mappoint(d1::Circle,d2::Circle,z)
    v=(z-d1.center)/d1.radius

src/Domains/Disk.jl

@@ -17,22 +17,22 @@ Disk(c::Real,r) = Disk(complex(c),r)
 Disk(c::Integer,r) = Disk(float(c),r)
 Disk(c::Complex{<:Integer},r) = Disk(float(c),r)
 
-Disk() = Disk(Vec(0.,0.),1.)
+Disk() = Disk(SVector(0.,0.),1.)
 Disk(::AnyDomain) = Disk(NaN,(NaN,NaN))
 
 const 𝔻 = Disk()
 
 isambiguous(d::Disk) = isnan(d.radius) && all(isnan,d.center)
 
-polar(r,θ) = Vec(r*cos(θ),r*sin(θ))
-ipolar(x,y) = Vec(sqrt(abs2(x)+abs2(y)), atan(y,x))
-polar(rθ::Vec) = polar(rθ...)
-ipolar(xy::Vec) = ipolar(xy...)
+polar(r,θ) = SVector(r*cos(θ),r*sin(θ))
+ipolar(x,y) = SVector(sqrt(abs2(x)+abs2(y)), atan(y,x))
+polar(rθ::SVector) = polar(rθ...)
+ipolar(xy::SVector) = ipolar(xy...)
 
-fromcanonical(D::Disk{T},xy::Vec) where {T<:Vec} = Vec((D.radius.*xy .+ D.center)...)
-tocanonical(D::Disk{T},x,y) where {T<:Vec} = Vec((xy .- D.center)./D.radius)
+fromcanonical(D::Disk{T},xy::SVector) where {T<:SVector} = SVector((D.radius.*xy .+ D.center)...)
+tocanonical(D::Disk{T},x,y) where {T<:SVector} = SVector((xy .- D.center)./D.radius)
 
-checkpoints(d::Disk) = [fromcanonical(d,Vec(.1,.2243)),fromcanonical(d,Vec(-.212423,-.3))]
+checkpoints(d::Disk) = [fromcanonical(d,SVector(.1,.2243)),fromcanonical(d,SVector(-.212423,-.3))]
 
 # function points(d::Disk,n,m,k)
 #     ptsx=0.5*(1-gaussjacobi(n,1.,0.)[1])

src/Domains/PeriodicSegment.jl

@@ -1,6 +1,3 @@
-
-
-
 export PeriodicSegment
 
 """
@@ -19,7 +16,7 @@ end
 PeriodicSegment()=PeriodicSegment{Float64}()
 PeriodicSegment(a::Int,b::Int) = PeriodicSegment(Float64(a),Float64(b)) #convenience method
 PeriodicSegment(a,b) = PeriodicSegment{promote_type(typeof(a),typeof(b))}(a,b)
-PeriodicSegment(a::Tuple,b::Tuple) = Interval(Vec(a...),Vec(b...))
+PeriodicSegment(a::Tuple,b::Tuple) = PeriodicSegment(SVector(a), SVector(b))
 
 function convert(::Type{PeriodicSegment}, d::ClosedInterval)
 	a,b = d.left,d.right
@@ -35,7 +32,9 @@ convert(::Type{PeriodicSegment{T}}, d::PeriodicSegment) where {T<:Number} = Peri
 
 isambiguous(d::PeriodicSegment) = all(isnan(leftendpoint(d))) && all(isnan(rightendpoint(d)))
 convert(::Type{PeriodicSegment{T}},::AnyDomain) where {T<:Number} = PeriodicSegment{T}(NaN,NaN)
-convert(::Type{PeriodicSegment{Vec{d,T}}},::AnyDomain) where {d,T} = PeriodicSegment(Vec(fill(NaN,d)...),Vec(fill(NaN,d)...))
+function convert(::Type{PeriodicSegment{SVector{d,T}}},::AnyDomain) where {d,T}
+    PeriodicSegment(SVector{d,T}(ntuple(x->T(NaN),d)), SVector{d,T}(ntuple(x->T(NaN),d)))
+end
 convert(::Type{PeriodicSegment{T}},::AnyDomain) where {T} = PeriodicSegment(nan(T),nan(T))
 PeriodicSegment{T}(d) where T = convert(PeriodicSegment{T}, d)
 PeriodicSegment(d) = convert(PeriodicSegment, d)
@@ -85,7 +84,7 @@ for op in (:*,:+,:-)
 end
 
 
-@eval /(d::PeriodicSegment,c::Number) = PeriodicSegment(/(leftendpoint(d),c),/(rightendpoint(d),c))
+/(d::PeriodicSegment,c::Number) = PeriodicSegment(/(leftendpoint(d),c),/(rightendpoint(d),c))
 
 +(d1::PeriodicSegment,d2::PeriodicSegment) = PeriodicSegment(d1.a+d2.a,d1.b+d2.b)
 
@@ -111,11 +110,11 @@ issubset(a::IntervalOrSegment, b::PeriodicSegment) = PeriodicSegment(endpoints(a
 
 
 boundary(d::VcatDomain{2,<:Any,(1,1),<:Tuple{<:IntervalOrSegment,<:PeriodicSegment}}) =
-    UnionDomain((PeriodicSegment(Vec(rightendpoint(factor(d,1)),leftendpoint(factor(d,2))),Vec(rightendpoint(factor(d,1)),rightendpoint(factor(d,2)))),
-        PeriodicSegment(Vec(leftendpoint(factor(d,1)),rightendpoint(factor(d,2))),Vec(leftendpoint(factor(d,1)),leftendpoint(factor(d,2))))))
+    UnionDomain((PeriodicSegment(SVector(rightendpoint(factor(d,1)),leftendpoint(factor(d,2))),SVector(rightendpoint(factor(d,1)),rightendpoint(factor(d,2)))),
+        PeriodicSegment(SVector(leftendpoint(factor(d,1)),rightendpoint(factor(d,2))),SVector(leftendpoint(factor(d,1)),leftendpoint(factor(d,2))))))
 boundary(d::VcatDomain{2,<:Any,(1,1),<:Tuple{<:PeriodicSegment,<:IntervalOrSegment}}) =
-    UnionDomain((PeriodicSegment(Vec(leftendpoint(factor(d,1)),leftendpoint(factor(d,2))),Vec(rightendpoint(factor(d,1)),leftendpoint(factor(d,2)))),
-        PeriodicSegment(Vec(rightendpoint(factor(d,1)),rightendpoint(factor(d,2))),Vec(leftendpoint(factor(d,1)),rightendpoint(factor(d,2))))))
+    UnionDomain((PeriodicSegment(SVector(leftendpoint(factor(d,1)),leftendpoint(factor(d,2))),SVector(rightendpoint(factor(d,1)),leftendpoint(factor(d,2)))),
+        PeriodicSegment(SVector(rightendpoint(factor(d,1)),rightendpoint(factor(d,2))),SVector(leftendpoint(factor(d,1)),rightendpoint(factor(d,2))))))
 boundary(d::VcatDomain{2,<:Any,(1,1),<:Tuple{<:PeriodicSegment,<:PeriodicSegment}}) = EmptyDomain()
 
 union_rule(A::SumSpace{<:Any,<:PeriodicSegment}, B::Space{<:IntervalOrSegment}) =

test/runtests.jl

@@ -1,12 +1,14 @@
 using ApproxFunFourier
 using ApproxFunBase
-using ApproxFunBase: Block, Vec, EmptyDomain, UnionDomain
+using ApproxFunBase: Block, EmptyDomain, UnionDomain
 using ApproxFunBaseTest: testspace, testtransforms, testmultiplication, testraggedbelowoperator,
                     testbandedoperator, testblockbandedoperator, testbandedblockbandedoperator,
                     testcalculus, testfunctional
 using LinearAlgebra
 using SpecialFunctions
 _factorial(n) = gamma(n+1)
+
+using StaticArrays: SVector
 using Test
 
 using Aqua
@@ -23,13 +25,20 @@ end
     @test -10.0 ∈ PeriodicLine()
     @test -10.0+im ∉ PeriodicLine()
 
-    @test ApproxFunBase.Vec(0,0.5) ∈ PeriodicSegment(ApproxFunBase.Vec(0.0,0), ApproxFunBase.Vec(0,1))
+    @test SVector(0,0.5) ∈ PeriodicSegment(SVector(0.0,0), SVector(0,1))
 
-    @test ApproxFunBase.Vec(1,0) ∈ Circle((0.,0.),1.)
+    @test SVector(1,0) ∈ Circle((0.,0.),1.)
 
     @test ∂(PeriodicSegment() × ChebyshevInterval()) isa UnionDomain
     @test ∂(ChebyshevInterval() × PeriodicSegment()) isa UnionDomain
     @test ∂(PeriodicSegment() × PeriodicSegment()) isa EmptyDomain
+
+    T = PeriodicSegment{SVector{2,Float64}}
+    @test convert(T, ApproxFunBase.AnyDomain()) isa T
+
+    a = PeriodicSegment(0,2π)
+    b = a/2
+    @test rightendpoint(a)/2 ≈ rightendpoint(b)
 end
 
 @testset "Cos/SinSpace" begin
@@ -323,11 +332,11 @@ end
 end
 
 
-@testset "Vec circle" begin
+@testset "SVector circle" begin
     d=Circle((0.,0.),1.)
     f=Fun(xy->exp(-xy[1]-2cos(xy[2])),Fourier(d),40)
     @test f(cos(0.1),sin(0.1)) ≈ exp(-cos(0.1)-2cos(sin(0.1)))
-    @test f(Vec(cos(0.1),sin(0.1))) ≈ exp(-cos(0.1)-2cos(sin(0.1)))
+    @test f(SVector(cos(0.1),sin(0.1))) ≈ exp(-cos(0.1)-2cos(sin(0.1)))
 
     f=Fun((x,y)->exp(-x-2cos(y)),Fourier(d),40)
     @test f(cos(0.1),sin(0.1)) ≈ exp(-cos(0.1)-2cos(sin(0.1)))
@@ -581,7 +590,7 @@ end
 end
 
 @testset "off domain evaluate" begin
-    g = Fun(1, PeriodicSegment(Vec(0,-1) , Vec(π,-1)))
+    g = Fun(1, PeriodicSegment(SVector(0,-1) , SVector(π,-1)))
     @test g(0.1,-1) ≈ 1
     @test g(0.1,1) ≈ 0
 end