Remove T parameter from Kernel

Author: willtebbutt

src/KernelFunctions.jl

@@ -27,14 +27,14 @@ const defaultobs = 2
 Abstract type defining a slice-wise transformation on an input matrix
 """
 abstract type Transform end
-abstract type Kernel{T,Tr<:Transform} end
+abstract type Kernel{Tr<:Transform} end
 
 include("utils.jl")
 include("distances/dotproduct.jl")
 include("distances/delta.jl")
 include("transform/transform.jl")
-kernels = ["exponential","matern","polynomial","constant","rationalquad","exponentiated"]
-for k in kernels
+
+for k in ["exponential","matern","polynomial","constant","rationalquad","exponentiated"]
     include(joinpath("kernels",k*".jl"))
 end
 include("matrix/kernelmatrix.jl")

src/generic.jl

@@ -23,8 +23,7 @@ end
 ## Constructors for kernels without parameters
 for kernel in [:ExponentialKernel,:SqExponentialKernel,:Matern32Kernel,:Matern52Kernel,:ExponentiatedKernel]
     @eval begin
-        $kernel(ρ::T=1.0) where {T<:Real} = $kernel{T,ScaleTransform{T}}(ScaleTransform(ρ))
-        $kernel(ρ::AbstractVector{T}) where {T<:Real} = $kernel{T,ARDTransform{T,length(ρ)}}(ARDTransform(ρ))
-        $kernel(t::Tr) where {Tr<:Transform} = $kernel{eltype(t),Tr}(t)
+        $kernel(ρ::Real=1.0) = $kernel(ScaleTransform(ρ))
+        $kernel(ρ::AbstractVector{<:Real}) = $kernel(ARDTransform(ρ))
     end
 end

src/kernels/constant.jl

@@ -3,7 +3,7 @@ ZeroKernel([tr=IdentityTransform()])
 
 Create a kernel always returning zero
 """
-struct ZeroKernel{T,Tr} <: Kernel{T,Tr}
+struct ZeroKernel{T,Tr} <: Kernel{Tr}
     transform::Tr
 
     function ZeroKernel{T,Tr}(t::Tr) where {T,Tr<:Transform}
@@ -15,7 +15,7 @@ function ZeroKernel(t::Tr=IdentityTransform()) where {Tr<:Transform}
     ZeroKernel{eltype(Tr),Tr}(t)
 end
 
-@inline kappa(κ::ZeroKernel,d::T) where {T<:Real} = zero(T)
+@inline kappa(κ::ZeroKernel, d::T) where {T<:Real} = zero(T)
 
 metric(::ZeroKernel) = Delta()
 
@@ -27,7 +27,7 @@ metric(::ZeroKernel) = Delta()
 ```
 Kernel function working as an equivalent to add white noise.
 """
-struct WhiteKernel{T,Tr} <: Kernel{T,Tr}
+struct WhiteKernel{T,Tr} <: Kernel{Tr}
     transform::Tr
 
     function WhiteKernel{T,Tr}(t::Tr) where {T,Tr<:Transform}
@@ -50,26 +50,18 @@ metric(::WhiteKernel) = Delta()
 ```
 Kernel function always returning a constant value `c`
 """
-struct ConstantKernel{T,Tr,Tc<:Real} <: Kernel{T,Tr}
+struct ConstantKernel{Tr, Tc<:Real} <: Kernel{Tr}
     transform::Tr
     c::Tc
-
-    function ConstantKernel{T,Tr,Tc}(t::Tr,c::Tc) where {T,Tr<:Transform,Tc<:Real}
-        new{T,Tr,Tc}(t,c)
-    end
 end
 
 params(k::ConstantKernel) = (params(k.transform),k.c)
 opt_params(k::ConstantKernel) = (opt_params(k.transform),k.c)
 
-function ConstantKernel(c::Tc=1.0) where {Tc<:Real}
-    ConstantKernel{Float64,IdentityTransform,Tc}(IdentityTransform(),c)
-end
+ConstantKernel(c::Real=1.0) = ConstantKernel(IdentityTransform(),c)
 
-function ConstantKernel(t::Tr,c::Tc=1.0) where {Tr<:Transform,Tc<:Real}
-    ConstantKernel{eltype(Tr),Tr,Tc}(t,c)
-end
+ConstantKernel(t::Tr,c::Tc=1.0) where {Tr<:Transform,Tc<:Real} = ConstantKernel{Tr,Tc}(t,c)
 
 @inline kappa(κ::ConstantKernel,x::Real) = κ.c
 
-metric(::ConstantKernel) = Delta()
+metric(::ConstantKernel) = Delta()

src/kernels/exponential.jl

@@ -8,12 +8,8 @@ The squared exponential kernel is an isotropic Mercer kernel given by the formul
 See also [`ExponentialKernel`](@ref) for a
 related form of the kernel or [`GammaExponentialKernel`](@ref) for a generalization.
 """
-struct SqExponentialKernel{T,Tr} <: Kernel{T,Tr}
+struct SqExponentialKernel{Tr} <: Kernel{Tr}
     transform::Tr
-
-    function SqExponentialKernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
-        return new{T,Tr}(transform)
-    end
 end
 
 @inline kappa(κ::SqExponentialKernel, d²::Real) = exp(-d²)
@@ -32,12 +28,8 @@ The exponential kernel is an isotropic Mercer kernel given by the formula:
     κ(x,y) = exp(-ρ‖x-y‖)
 ```
 """
-struct ExponentialKernel{T,Tr} <: Kernel{T,Tr}
+struct ExponentialKernel{Tr} <: Kernel{Tr}
     transform::Tr
-
-    function ExponentialKernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
-        return new{T,Tr}(transform)
-    end
 end
 
 @inline kappa(κ::ExponentialKernel, d::Real) = exp(-d)
@@ -48,37 +40,34 @@ metric(::ExponentialKernel) = Euclidean()
 const LaplacianKernel = ExponentialKernel
 
 """
-`GammaExponentialKernel([ρ=1.0,[gamma=2.0]])`
+`GammaExponentialKernel([ρ=1.0, [γ=2.0]])`
 The γ-exponential kernel is an isotropic Mercer kernel given by the formula:
 ```
     κ(x,y) = exp(-ρ^(2γ)‖x-y‖^(2γ))
 ```
 """
-struct GammaExponentialKernel{T,Tr,Tᵧ<:Real} <: Kernel{T,Tr}
+struct GammaExponentialKernel{Tr, Tγ<:Real} <: Kernel{Tr}
     transform::Tr
-    γ::Tᵧ
-
-    function GammaExponentialKernel{T,Tr,Tᵧ}(transform::Tr,γ::Tᵧ) where {T,Tr<:Transform,Tᵧ<:Real}
-        return new{T,Tr,Tᵧ}(transform,γ)
+    γ::Tγ
+    function GammaExponentialKernel{Tr,Tγ}(t::Tr, γ::Tγ) where {Tr<:Transform,Tγ<:Real}
+        @check_args(GammaExponentialKernel, γ, γ >= zero(Tγ), "γ > 0")
+        return new{Tr, Tγ}(t, γ)
     end
 end
 
 params(k::GammaExponentialKernel) = (params(transform),γ)
 opt_params(k::GammaExponentialKernel) = (opt_params(transform),γ)
 
-function GammaExponentialKernel(ρ::T₁=1.0,gamma::T₂=2.0) where {T₁<:Real,T₂<:Real}
-    @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₂), "gamma > 0")
-    GammaExponentialKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),gamma)
+function GammaExponentialKernel(ρ::Real=1.0, γ::Real=2.0)
+    GammaExponentialKernel(ScaleTransform(ρ), γ)
 end
 
-function GammaExponentialKernel(ρ::AbstractVector{T₁},gamma::T₂=2.0) where {T₁<:Real,T₂<:Real}
-    @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₂), "gamma > 0")
-    GammaExponentialKernel{T₁,ARDTransform{T₁,length(ρ)},T₂}(ARDTransform(ρ),gamma)
+function GammaExponentialKernel(ρ::AbstractVector{<:Real}, γ::Real=2.0)
+    GammaExponentialKernel(ARDTransform(ρ), γ)
 end
 
-function GammaExponentialKernel(t::Tr,gamma::T₁=2.0) where {Tr<:Transform,T₁<:Real}
-    @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₁), "gamma > 0")
-    GammaExponentialKernel{eltype(Tr),Tr,T₁}(t,gamma)
+function GammaExponentialKernel(t::Tr, γ::Tγ=2.0) where {Tr<:Transform, Tγ<:Real}
+    GammaExponentialKernel{Tr, Tγ}(t, γ)
 end
 
 @inline kappa(κ::GammaExponentialKernel, d²::Real) = exp(-d²^κ.γ)

src/kernels/exponentiated.jl

@@ -5,13 +5,13 @@ The exponentiated kernel is a Mercer kernel given by:
     κ(x,y) = exp(ρ²xᵀy)
 ```
 """
-struct ExponentiatedKernel{T,Tr} <: Kernel{T,Tr}
+struct ExponentiatedKernel{Tr} <: Kernel{Tr}
     transform::Tr
 
-    function ExponentiatedKernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
-        return new{T,Tr}(transform)
-    end
+    # function ExponentiatedKernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
+    #     return new{T,Tr}(transform)
+    # end
 end
 @inline kappa(κ::ExponentiatedKernel, xᵀy::T) where {T<:Real} = exp(xᵀy)
 
-metric(::ExponentiatedKernel) = DotProduct()
+metric(::ExponentiatedKernel) = DotProduct()

src/kernels/kernelproduct.jl

@@ -10,7 +10,7 @@ kernelmatrix(k,X) == kernelmatrix(k1,X).*kernelmatrix(k2,X)
 kernelmatrix(k,X) == kernelmatrix(k1*k2,X)
 ```
 """
-struct KernelProduct{T,Tr} <: Kernel{T,Tr}
+struct KernelProduct{Tr} <: Kernel{Tr}
     kernels::Vector{Kernel}
 end
 

src/kernels/kernelsum.jl

@@ -11,18 +11,18 @@ kernelmatrix(k,X) == kernelmatrix(k1+k2,X)
 kweighted = 0.5*k1 + 2.0*k2
 ```
 """
-struct KernelSum{T,Tr} <: Kernel{T,Tr}
+struct KernelSum{Tr} <: Kernel{Tr}
     kernels::Vector{Kernel}
     weights::Vector{Real}
-    function KernelSum{T,Tr}(kernels::AbstractVector{<:Kernel},weights::AbstractVector{<:Real}) where {T,Tr}
-        new{T,Tr}(kernels,weights)
+    function KernelSum{Tr}(kernels::AbstractVector{<:Kernel},weights::AbstractVector{<:Real}) where {Tr}
+        new{Tr}(kernels,weights)
     end
 end
 
 function KernelSum(kernels::AbstractVector{<:Kernel}; weights::AbstractVector{<:Real}=ones(Float64,length(kernels)))
     @assert length(kernels)==length(weights) "Weights and kernel vector should be of the same length"
     @assert all(weights.>=0) "All weights should be positive"
-    KernelSum{eltype(kernels),Transform}(kernels,weights)
+    KernelSum{Transform}(kernels,weights)
 end
 
 params(k::KernelSum) = (k.weights,params.(k.kernels))

src/kernels/matern.jl

@@ -6,29 +6,20 @@ The matern kernel is an isotropic Mercer kernel given by the formula:
 ```
 For `ν=n+1/2, n=0,1,2,...` it can be simplified and you should instead use [`ExponentialKernel`](@ref) for `n=0`, [`Matern32Kernel`](@ref), for `n=1`, [`Matern52Kernel`](@ref) for `n=2` and [`SqExponentialKernel`](@ref) for `n=∞`.
 """
-struct MaternKernel{T,Tr,Tν<:Real} <: Kernel{T,Tr}
+struct MaternKernel{Tr<:Transform, Tν<:Real} <: Kernel{Tr}
     transform::Tr
     ν::Tν
-
-    function MaternKernel{T,Tr,Tν}(transform::Tr,ν::Tν) where {T,Tr<:Transform,Tν<:Real}
-        return new{T,Tr,Tν}(transform,ν)
+    function MaternKernel{Tr, Tν}(t::Tr, ν::Tν) where {Tr, Tν}
+        @check_args(MaternKernel, ν, ν > zero(Tν), "ν > 0")
+        return new{Tr, Tν}(t, ν)
     end
 end
 
-function MaternKernel(ρ::T₁=1.0,ν::T₂=1.5) where {T₁<:Real,T₂<:Real}
-    @check_args(MaternKernel, ν, ν > zero(T₂), "ν > 0")
-    MaternKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),ν)
-end
+MaternKernel(ρ::Real=1.0, ν::Real=1.5) = MaternKernel(ScaleTransform(ρ), ν)
 
-function MaternKernel(ρ::AbstractVector{T₁},ν::T₂=1.5) where {T₁<:Real,T₂<:Real}
-    @check_args(MaternKernel, ν, ν > zero(T₂), "ν > 0")
-    MaternKernel{T₁,ARDTransform{T₁,length(ρ)},T₂}(ARDTransform(ρ),ν)
-end
+MaternKernel(ρ::AbstractVector{<:Real},ν::Real=1.5) = MaternKernel(ARDTransform(ρ), ν)
 
-function MaternKernel(t::Tr,ν::T=1.5) where {Tr<:Transform,T<:Real}
-    @check_args(MaternKernel, ν, ν > zero(T), "ν > 0")
-    MaternKernel{eltype(t),Tr,T}(t,ν)
-end
+MaternKernel(t::Tr, ν::T=1.5) where {Tr<:Transform, T<:Real} = MaternKernel{Tr, T}(t, ν)
 
 params(k::MaternKernel) = (params(transform(k)),k.ν)
 opt_params(k::MaternKernel) = (opt_params(transform(k)),k.ν)
@@ -44,15 +35,11 @@ The matern 3/2 kernel is an isotropic Mercer kernel given by the formula:
     κ(x,y) = (1+√(3)ρ‖x-y‖)exp(-√(3)ρ‖x-y‖)
 ```
 """
-struct Matern32Kernel{T,Tr} <: Kernel{T,Tr}
+struct Matern32Kernel{Tr} <: Kernel{Tr}
     transform::Tr
-
-    function Matern32Kernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
-        return new{T,Tr}(transform)
-    end
 end
 
-@inline kappa(κ::Matern32Kernel, d::T) where {T<:Real} = (1+sqrt(3)*d)*exp(-sqrt(3)*d)
+@inline kappa(κ::Matern32Kernel, d::Real) = (1+sqrt(3)*d)*exp(-sqrt(3)*d)
 
 metric(::Matern32Kernel) = Euclidean()
 
@@ -63,14 +50,10 @@ The matern 5/2 kernel is an isotropic Mercer kernel given by the formula:
     κ(x,y) = (1+√(5)ρ‖x-y‖ + 5ρ²‖x-y‖^2/3)exp(-√(5)ρ‖x-y‖)
 ```
 """
-struct Matern52Kernel{T,Tr} <: Kernel{T,Tr}
+struct Matern52Kernel{Tr} <: Kernel{Tr}
     transform::Tr
-
-    function Matern52Kernel{T,Tr}(transform::Tr) where {T,Tr<:Transform}
-        return new{T,Tr}(transform)
-    end
 end
 
-@inline kappa(κ::Matern52Kernel, d::Real) where {T} = (1+sqrt(5)*d+5*d^2/3)*exp(-sqrt(5)*d)
+@inline kappa(κ::Matern52Kernel, d::Real) = (1+sqrt(5)*d+5*d^2/3)*exp(-sqrt(5)*d)
 
-metric(::Matern52Kernel) = Euclidean()
+metric(::Matern52Kernel) = Euclidean()

src/kernels/polynomial.jl

@@ -6,26 +6,20 @@ The linear kernel is a Mercer kernel given by
 ```
 Where `c` is a real number
 """
-struct LinearKernel{T,Tr,Tc<:Real} <: Kernel{T,Tr}
+struct LinearKernel{Tr, Tc<:Real} <: Kernel{Tr}
     transform::Tr
     c::Tc
-
-    function LinearKernel{T,Tr,Tc}(transform::Tr,c::Tc) where {T,Tr<:Transform,Tc<:Real}
-        return new{T,Tr,Tc}(transform,c)
-    end
 end
 
-function LinearKernel(ρ::T₁=1.0,c::T₂=zero(T₁)) where {T₁<:Real,T₂<:Real}
-    LinearKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),c)
+function LinearKernel(ρ::T=1.0, c::Real=zero(T)) where {T<:Real}
+    LinearKernel(ScaleTransform(ρ), c)
 end
 
-function LinearKernel(ρ::AbstractVector{T₁},c::T₂=zero(T₁)) where {T₁<:Real,T₂<:Real}
-    LinearKernel{T₁,ARDTransform{T₁,length(ρ)},T₂}(ARDTransform(ρ),c)
+function LinearKernel(ρ::AbstractVector{T}, c::Real=zero(T)) where {T<:Real}
+    LinearKernel(ARDTransform(ρ), c)
 end
 
-function LinearKernel(t::Tr,c::T=zero(Float64)) where {Tr<:Transform,T<:Real}
-    LinearKernel{eltype(t),Tr,T}(t,c)
-end
+LinearKernel(t::Transform) = LinearKernel(t, 0.0)
 
 params(k::LinearKernel) = (params(transform(k)),k.c)
 opt_params(k::LinearKernel) = (opt_params(transform(k)),k.c)
@@ -42,34 +36,31 @@ The polynomial kernel is a Mercer kernel given by
 ```
 Where `c` is a real number, and `d` is a shape parameter bigger than 1
 """
-struct PolynomialKernel{T,Tr,Tc<:Real,Td<:Real} <: Kernel{T,Tr}
+struct PolynomialKernel{Tr,Tc<:Real,Td<:Real} <: Kernel{Tr}
     transform::Tr
-    c::Tc
     d::Td
-
-    function PolynomialKernel{T,Tr,Tc,Td}(transform::Tr,c::Tc,d::Td) where {T,Tr<:Transform,Tc<:Real,Td<:Real}
-        return new{T,Tr,Tc,Td}(transform,c,d)
+    c::Tc
+    function PolynomialKernel{Tr, Tc, Td}(transform::Tr, d::Td, c::Tc) where {Tr<:Transform, Td<:Real, Tc<:Real}
+        @check_args(PolynomialKernel, d, d >= one(Td), "d >= 1")
+        return new{Tr, Td, Tc}(transform,d, c)
     end
 end
 
-function PolynomialKernel(ρ::T₁=1.0,d::T₂=2.0,c::T₃=zero(T₁)) where {T₁<:Real,T₂<:Real,T₃<:Real}
-    @check_args(PolynomialKernel, d, d >= one(T₁), "d >= 1")
-    PolynomialKernel{T₁,ScaleTransform{T₁},T₂,T₃}(ScaleTransform(ρ),c,d)
+function PolynomialKernel(ρ::Real=1.0, d::Td=2.0, c::Real=zero(Td)) where {Td<:Real}
+    PolynomialKernel(ScaleTransform(ρ), d, c)
 end
 
-function PolynomialKernel(ρ::AbstractVector{T₁},d::T₂=2.0,c::T₃=zero(T₁)) where {T₁<:Real,T₂<:Real,T₃<:Real}
-    @check_args(PolynomialKernel, d, d >= one(T₂), "d >= 1")
-    PolynomialKernel{T₁,ARDTransform{T₁,length(ρ)},T₂,T₃}(ARDTransform(ρ),c,d)
+function PolynomialKernel(ρ::AbstractVector{T}, d::Real=2.0, c::Real=zero(T₁)) where {T<:Real}
+    PolynomialKernel(ARDTransform(ρ), d, c)
 end
 
-function PolynomialKernel(t::Tr,d::T₁=2.0,c::T₂=zero(eltype(T₁))) where {Tr<:Transform,T₁<:Real,T₂<:Real}
-    @check_args(PolynomialKernel, d, d >= one(T₁), "d >= 1")
-    PolynomialKernel{eltype(Tr),Tr,T₁,T₂}(t,c,d)
+function PolynomialKernel(t::Tr, d::Td=2.0, c::Tc=zero(eltype(Td))) where {Tr<:Transform, Td<:Real, Tc<:Real}
+    PolynomialKernel{Tr, Tc, Td}(t, d, c)
 end
 
 params(k::PolynomialKernel) = (params(transform(k)),k.d,k.c)
 opt_params(k::PolynomialKernel) = (opt_params(transform(k)),k.d,k.c)
 
 @inline kappa(κ::PolynomialKernel, xᵀy::T) where {T<:Real} = (xᵀy + κ.c)^(κ.d)
 
-metric(::PolynomialKernel) = DotProduct()
+metric(::PolynomialKernel) = DotProduct()