Renamed Matern3_2 and Matern5_2 and added k(X,Y)

Author: theogf

src/KernelFunctions.jl

@@ -1,7 +1,7 @@
 module KernelFunctions
 
 export kernelmatrix, kernelmatrix!, kappa
-export Kernel, SquaredExponentialKernel, MaternKernel, Matern3_2Kernel, Matern5_2Kernel
+export Kernel, SquaredExponentialKernel, MaternKernel, Matern32Kernel, Matern52Kernel
 
 export Transform, ScaleTransform
 
@@ -15,7 +15,6 @@ abstract type Kernel{T,Tr} end
 
 include("zygote_rules.jl")
 include("utils.jl")
-include("common.jl")
 include("transform/transform.jl")
 include("kernelmatrix.jl")
 
@@ -24,4 +23,7 @@ for k in kernels
     include(joinpath("kernels",k*".jl"))
 end
 
+include("generic.jl")
+
+
 end

src/generic.jl

@@ -1,11 +1,15 @@
 
 @inline metric(κ::Kernel) = κ.metric
-@inline (κ::K)(d::Real) where {K<:Kernel} = kappa(κ,d)
-
+kernels =
+for k in [:SquaredExponentialKernel,:MaternKernel,:Matern32Kernel,:Matern52Kernel]
+    eval(quote
+        @inline (κ::$k)(d::Real) = kappa(κ,d)
+        @inline (κ::$k)(x::AbstractVector{T},y::AbstractVector{T}) where {T} = kernel(κ,evaluate(κ.(metric),x,y))
+        @inline (κ::$k)(x::AbstractMatrix{T},y::AbstractMatrix{T},obsdim::Integer=defaultobs) where {T} = kernelmatrix(κ,x,y,obsdim=obsdim)
+    end)
+end
 ### Transform generics
 
 @inline transform(κ::Kernel) = κ.transform
 @inline transform(κ::Kernel,x::AbstractVecOrMat) = transform(κ.transform,x)
 @inline transform(κ::Kernel,x::AbstractVecOrMat,obsdim::Int) = transform(κ.transform,x,obsdim)
-
-@inline (κ::Kernel)(x::AbstractVector{<:Real},y::AbstractVector{<:Real}) = kernel(κ,evaluate(κ.(metric),x,y))

src/kernels/matern.jl

@@ -37,9 +37,11 @@ function MaternKernel(ρ::T₁=1.0,ν::T₂=1.5) where {T₁<:Real,T₂<:Real}
     if ν == 0.5
         ExponentialKernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
     elseif ν == 1.5
-        Matern3_2Kernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
+        Matern32Kernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
     elseif ν == 2.5
-        Matern5_2Kernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
+        Matern52Kernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
+    elseif ν == Inf
+        SquaredExponentialKernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
     else
         MaternKernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ),ν)
     end
@@ -50,9 +52,11 @@ function MaternKernel(ρ::A,ν::T=1.5) where {A<:AbstractVector{<:Real},T<:Real}
     if ν == 0.5
         ExponentialKernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
     elseif ν == 1.5
-        Matern3_2Kernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
+        Matern32Kernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
     elseif ν == 2.5
-        Matern5_2Kernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
+        Matern52Kernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
+    elseif ν == Inf
+        SquaredExponentialKernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
     else
         MaternKernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ),ν)
     end
@@ -61,35 +65,61 @@ end
 function MaternKernel(t::T₁,ν::T₂=1.5) where {T₁<:Transform,T₂<:Real}
     @check_args(MaternKernel, ν, ν > zero(T₂), "ν > 0")
     if ν == 0.5
-        ExponentialKernel{eltype(t),T₁}(ScaleTransform(ρ))
+        ExponentialKernel{eltype(t),T₁}(t)
     elseif ν == 1.5
-        Matern3_2Kernel{eltype(t),T₁}(ScaleTransform(ρ))
+        Matern32Kernel{eltype(t),T₁}(t)
     elseif ν == 2.5
-        Matern5_2Kernel{eltype(t),T₁}(ScaleTransform(ρ))
+        Matern52Kernel{eltype(t),T₁}(t)
+    elseif ν == Inf
+        SquaredExponentialKernel{eltype(t),T₁}(t)
     else
-        MaternKernel{eltype(t),T₁}(ScaleTransform(ρ),ν)
+        MaternKernel{eltype(t),T₁}(t,ν)
     end
 end
 
 @inline kappa(κ::MaternKernel, d::Real) where {T} = exp((1.0-κ.ν)*logtwo - lgamma(κ.ν) - κ.ν*log(sqrt(2κ.ν)*d))*besselk(κ.ν,sqrt(2κ.ν)*d)
 
 
-struct Matern3_2Kernel{T,Tr<:Transform} <: Kernel{T,Tr}
+struct Matern32Kernel{T,Tr<:Transform} <: Kernel{T,Tr}
     transform::Tr
     metric::SemiMetric
-    function Matern3_2Kernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
+    function Matern32Kernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
         return new{T,Tr}(transform,Euclidean())
     end
 end
 
-@inline kappa(κ::Matern3_2Kernel, d::T) where {T<:Real} = (1+sqrt(3)*d)*exp(-sqrt(3)*d)
+function Matern32Kernel(ρ::T) where {T<:Real}
+    Matern32Kernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
+end
+
+function Matern32Kernel(ρ::A) where {A<:AbstractVector{<:Real}}
+    Matern32Kernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
+end
+
+function Matern32Kernel(t::Transform)
+    Matern52Kernel{eltype(A),ScaleTransform{A}}(t)
+end
+
+@inline kappa(κ::Matern32Kernel, d::T) where {T<:Real} = (1+sqrt(3)*d)*exp(-sqrt(3)*d)
 
-struct Matern5_2Kernel{T,Tr<:Transform} <: Kernel{T,Tr}
+struct Matern52Kernel{T,Tr<:Transform} <: Kernel{T,Tr}
     transform::Tr
     metric::SemiMetric
-    function Matern5_2Kernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
+    function Matern52Kernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
         return new{T,Tr}(transform,Euclidean())
     end
 end
 
-@inline kappa(κ::Matern5_2Kernel, d::Real) where {T} = (1+sqrt(5)*d+5*d^2/3)*exp(-sqrt(5)*d)
+function Matern52Kernel(ρ::T) where {T<:Real}
+    Matern52Kernel{T₁,ScaleTransform{T₁}}(ScaleTransform(ρ))
+end
+
+function Matern52Kernel(ρ::A) where {A<:AbstractVector{<:Real}}
+    Matern52Kernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
+end
+
+function Matern52Kernel(t::Transform)
+    Matern52Kernel{eltype(A),ScaleTransform{A}}(t)
+end
+
+@inline kappa(κ::Matern52Kernel, d::Real) where {T} = (1+sqrt(5)*d+5*d^2/3)*exp(-sqrt(5)*d)

test/constructors.jl

@@ -10,3 +10,15 @@ vl = [l,l]
     @test KernelFunctions.transform(SquaredExponentialKernel(l)) == ScaleTransform(l)
     @test KernelFunctions.transform(SquaredExponentialKernel(vl)) == ScaleTransform(vl)
 end
+
+@testset "MaternKernel" begin
+    @test KernelFunctions.metric(MaternKernel(l)) == Euclidean()
+    @test KernelFunctions.metric(MaternKernel(l,1.5)) == Euclidean()
+    @test KernelFunctions.metric(MaternKernel(l,2.5)) == Euclidean()
+    @test KernelFunctions.transform(MaternKernel(l)) == ScaleTransform(l)
+    @test KernelFunctions.transform(MaternKernel(vl)) == ScaleTransform(vl)
+    @test isa(MaternKernel(),Matern32Kernel)
+    @test isa(MaternKernel(1.0,1.0),MaternKernel)
+    @test isa(MaternKernel(1.0,1.5),Matern32Kernel)
+    @test isa(MaternKernel(1.0,2.5),Matern52Kernel)
+end