Replaced sin(\pi) by sinpi and corrected the constructors and some tests

Author: theogf

src/distances/sinus.jl

@@ -8,11 +8,11 @@ Distances.parameters(d::Sinus) = d.r
     @boundscheck if (length(a) != length(b)) || length(a) != length(d.r)
         throw(DimensionMismatch("Dimensions of the inputs are not matching : a = $(length(a)), b = $(length(b)), r = $(length(d.r))"))
     end
-    return sum(abs2,sin.(π.*(a-b))./d.r)
+    return sum(abs2, sinpi.(a - b) ./ d.r)
 end
 
 # For later convenience once Distances.jl open their API
-@inline Distances.eval_op(::Sinus, a::Real, b::Real, p::Real) = abs2(sin(π * (a - b)) / p)
+@inline Distances.eval_op(::Sinus, a::Real, b::Real, p::Real) = abs2(sinpi(a - b) / p)
 
 @inline (dist::Sinus)(a::AbstractArray,b::AbstractArray) = Distances._evaluate(dist, a, b)
-@inline (dist::Sinus)(a::Number,b::Number) = abs2(sin(π * (a - b)) / first(dist.r))
+@inline (dist::Sinus)(a::Number,b::Number) = abs2(sinpi(a - b) / first(dist.r))

src/kernels/periodic.jl

@@ -7,9 +7,15 @@
 """
 struct PeriodicKernel{T} <: BaseKernel
     r::Vector{T}
+    function PeriodicKernel(; r::AbstractVector{T} = ones(Float64, 1)) where {T<:Real}
+        @assert all(r .> 0)
+        new{T}(r)
+    end
 end
 
-PeriodicKernel(dims::Int) = PeriodicKernel{Float64}(ones(Float64,dims))
+PeriodicKernel(dims::Int = 1) = PeriodicKernel(Float64, dims)
+
+PeriodicKernel(T::DataType, dims::Int = 1) = PeriodicKernel(r = ones(T, dims))
 
 metric(κ::PeriodicKernel) = Sinus(κ.r)
 

test/test_flux.jl

@@ -2,20 +2,31 @@ using KernelFunctions
 using Test
 using Flux
 
+#Alphabetic order
 @testset "Params" begin
-    ν = 2.0; c = 3.0; d = 2.0; γ = 2.0; α = 2.5
+    ν = 2.0; c = 3.0; d = 2.0; γ = 2.0; α = 2.5; r = 2.0
+    ## Base kernels
     kc = ConstantKernel(c=c)
     @test all(params(kc) .== params([c]))
-    km = MaternKernel(ν=ν)
-    @test all(params(km) .== params([ν]))
-    kl = LinearKernel(c=c)
-    @test all(params(kl) .== params([c]))
+
     kge = GammaExponentialKernel(γ=γ)
     @test all(params(kge) .== params([γ]))
+
     kgr = GammaRationalQuadraticKernel(γ=γ, α=α)
     @test all(params(kgr) .== params([α], [γ]))
+
+    km = MaternKernel(ν=ν)
+    @test all(params(km) .== params([ν]))
+
+    kl = LinearKernel(c=c)
+    @test all(params(kl) .== params([c]))
+
+    kpe = PeriodicKernel(r=[r])
+    @test all(params(kpe) .== params(r))
+
     kp = PolynomialKernel(c=c, d=d)
     @test all(params(kp) .== params([d], [c]))
+
     kr = RationalQuadraticKernel(α=α)
     @test all(params(kr) .== params([α]))
 

test/test_kernels.jl

@@ -120,28 +120,28 @@ x = rand()*2; v1 = rand(3); v2 = rand(3); id = IdentityTransform()
     end
     @testset "Periodic Kernel" begin
         r = rand(3)
-        k = PeriodicKernel(r)
+        k = PeriodicKernel(r = r)
         @test kappa(k, x) ≈ exp(-0.5x)
-        @test k(v1, v2) ≈ exp(-0.5 * sum(abs2,sin.(π*(v1-v2))./r))
+        @test k(v1, v2) ≈ exp(-0.5 * sum(abs2, sinpi.(v1 - v2) ./ r))
         @test k(v1, v2) == k(v2, v1)
-        
+        @test PeriodicKernel(3)(v1, v2) == PeriodicKernel(r = ones(3))(v1, v2)
     end
     @testset "Transformed/Scaled Kernel" begin
         s = rand()
         v = rand(3)
         k = SqExponentialKernel()
-        kt = TransformedKernel(k,ScaleTransform(s))
-        ktard = TransformedKernel(k,ARDTransform(v))
-        ks = ScaledKernel(k,s)
-        @test kappa(kt,v1,v2) == kappa(transform(k,ScaleTransform(s)),v1,v2)
-        @test kappa(kt,v1,v2) == kappa(transform(k,s),v1,v2)
-        @test kappa(kt,v1,v2) == kappa(k,s*v1,s*v2)
-        @test kappa(ktard,v1,v2) == kappa(transform(k,ARDTransform(v)),v1,v2)
-        @test kappa(ktard,v1,v2) == kappa(transform(k,v),v1,v2)
-        @test kappa(ktard,v1,v2) == kappa(k,v.*v1,v.*v2)
+        kt = TransformedKernel(k, ScaleTransform(s))
+        ktard = TransformedKernel(k, ARDTransform(v))
+        ks = ScaledKernel(k, s)
+        @test kappa(kt, v1, v2) == kappa(transform(k, ScaleTransform(s)), v1, v2)
+        @test kappa(kt, v1, v2) == kappa(transform(k, s), v1, v2)
+        @test kappa(kt, v1, v2) ≈ kappa(k, s * v1, s * v2)
+        @test kappa(ktard, v1, v2) == kappa(transform(k, ARDTransform(v)), v1, v2)
+        @test kappa(ktard, v1, v2) == kappa(transform(k, v), v1, v2)
+        @test kappa(ktard, v1, v2) == kappa(k, v .* v1, v .* v2)
         @test KernelFunctions.metric(kt) == KernelFunctions.metric(k)
-        @test kappa(ks,x) == s*kappa(k,x)
-        @test kappa(ks,x) == kappa(s*k,x)
+        @test kappa(ks, x) == s * kappa(k, x)
+        @test kappa(ks, x) == kappa(s * k, x)
     end
     @testset "KernelCombinations" begin
         k1 = LinearKernel()