Pointed out where tests are needed

Author: theogf

src/generic.jl

@@ -1,15 +1,15 @@
 @inline metric(κ::Kernel) = κ.metric
 
 ## Allows to iterate over kernels
-Base.length(::Kernel) = 1
+Base.length(::Kernel) = 1 #TODO Add test
 
-Base.iterate(k::Kernel) = (k,nothing)
-Base.iterate(k::Kernel, ::Any) = nothing
+Base.iterate(k::Kernel) = (k,nothing) #TODO Add test
+Base.iterate(k::Kernel, ::Any) = nothing #TODO Add test
 
 ### Syntactic sugar for creating matrices and using kernel functions
 for k in [:ExponentialKernel,:SqExponentialKernel,:GammaExponentialKernel,:MaternKernel,:Matern32Kernel,:Matern52Kernel,:LinearKernel,:PolynomialKernel,:ExponentiatedKernel,:ZeroKernel,:WhiteKernel,:ConstantKernel,:RationalQuadraticKernel,:GammaRationalQuadraticKernel]
     @eval begin
-        @inline (κ::$k)(d::Real) = kappa(κ,d)
+        @inline (κ::$k)(d::Real) = kappa(κ,d) #TODO Add test
         @inline (κ::$k)(x::AbstractVector{<:Real},y::AbstractVector{<:Real}) = kappa(κ,evaluate(κ.metric,transform(κ,x),transform(κ,y)))
         @inline (κ::$k)(X::AbstractMatrix{T},Y::AbstractMatrix{T};obsdim::Integer=defaultobs) where {T} = kernelmatrix(κ,X,Y,obsdim=obsdim)
         @inline (κ::$k)(X::AbstractMatrix{T};obsdim::Integer=defaultobs) where {T} = kernelmatrix(κ,X,obsdim=obsdim)

src/kernels/constant.jl

@@ -1,5 +1,5 @@
 """
-    ZeroKernel()
+    ZeroKernel([tr=IdentityTransform()])
 
     Create a kernel that always return a zero kernel matrix
 
@@ -19,7 +19,7 @@ end
 @inline kappa(κ::ZeroKernel,d::T) where {T<:Real} = zero(T)
 
 """
-    WhiteKernel()
+    WhiteKernel([tr=IdentityTransform()])
 
 ```
     κ(x,y) = δ(x,y)
@@ -41,7 +41,7 @@ end
 @inline kappa(κ::WhiteKernel,δₓₓ::Real) = δₓₓ
 
 """
-    ConstantKernel([c=1.0])
+    ConstantKernel([tr=IdentityTransform(),[c=1.0]])
 
 ```
     κ(x,y) = c

src/kernels/exponential.jl

@@ -55,19 +55,6 @@ The γ-exponential kernel is an isotropic Mercer kernel given by the formula:
 ```
     κ(x,y) = exp(-‖x-y‖^2γ)
 ```
-
-# Examples
-
-```jldoctest; setup = :(using KernelFunctions)
-julia> GammaExponentialKernel()
-GammaExponentialKernel{Float64,Float64,Float64}(1.0,2.0)
-
-julia> GammaExponentialKernel(2.0f0,3.0)
-GammaExponentialKernel{Float32,Float32,Float64}(2.0,3.0)
-
-julia> GammaExponentialKernel([2.0,3.0],2f0)
-GammaExponentialKernel{Float64,Array{Float64},Float32}([2.0,3.0],2.0)
-```
 """
 struct GammaExponentialKernel{T,Tr,Tᵧ<:Real} <: Kernel{T,Tr}
     transform::Tr

src/kernels/exponentiated.jl

@@ -1,5 +1,5 @@
 """
-    ExponentiatedKernel([α=1])
+    ExponentiatedKernel([ρ=1])
 
     The exponentiated kernel is a Mercer kernel given by:
 

src/kernels/kernelproduct.jl

@@ -1,3 +1,11 @@
+"""
+    KernelProduct(kernels::Array{Kernel})
+Create a multiplication of kernels.
+One can also use the operator `*`
+```
+    kernelmatrix(SqExponentialKernel()*LinearKernel(),X) == kernelmatrix(SqExponentialKernel(),X).*kernelmatrix(LinearKernel(),X)
+```
+"""
 struct KernelProduct{T,Tr} <: Kernel{T,Tr}
     kernels::Vector{Kernel}
 end
@@ -7,14 +15,15 @@ function KernelProduct(kernels::AbstractVector{<:Kernel})
 end
 
 Base.:*(k1::Kernel,k2::Kernel) = KernelProduct([k1,k2])
+Base.:*(k1::KernelProduct,k2::KernelProduct) = KernelProduct(vcat(k1.kernels,k2.kernels)) #TODO Add test
 Base.:*(k::Kernel,kp::KernelProduct) = KernelProduct(vcat(k,kp.kernels))
 Base.:*(kp::KernelProduct,k::Kernel) = KernelProduct(vcat(kp.kernels,k))
 
 Base.length(k::KernelProduct) = length(k.kernels)
-metric(k::KernelProduct) = getmetric.(k.kernels)
-transform(k::KernelProduct) = transform.(k.kernels)
-transform(k::KernelProduct,x::AbstractVecOrMat) = transform.(k.kernels,[x])
-transform(k::KernelProduct,x::AbstractVecOrMat,obsdim::Int) = transform.(k.kernels,[x],obsdim)
+metric(k::KernelProduct) = getmetric.(k.kernels) #TODO Add test
+transform(k::KernelProduct) = transform.(k.kernels) #TODO Add test
+transform(k::KernelProduct,x::AbstractVecOrMat) = transform.(k.kernels,[x]) #TODO Add test
+transform(k::KernelProduct,x::AbstractVecOrMat,obsdim::Int) = transform.(k.kernels,[x],obsdim) #TODO Add test
 
 hadamard(x,y) = x.*y
 
@@ -36,6 +45,6 @@ end
 function kerneldiagmatrix(
     κ::KernelProduct,
     X::AbstractMatrix;
-    obsdim::Int=defaultobs)
+    obsdim::Int=defaultobs) #TODO Add test
     reduce(hadamard,kerneldiagmatrix(κ.kernels[i],X,obsdim=obsdim) for i in 1:length(κ))
 end

src/kernels/kernelsum.jl

@@ -1,3 +1,11 @@
+"""
+    KernelSum(kernels::Array{Kernel};weights::Array{Real}=ones(length(kernels)))
+Create a positive weighted sum of kernels.
+One can also use the operator `+`
+```
+    kernelmatrix(SqExponentialKernel()+LinearKernel(),X) == kernelmatrix(SqExponentialKernel(),X).+kernelmatrix(LinearKernel(),X)
+```
+"""
 struct KernelSum{T,Tr} <: Kernel{T,Tr}
     kernels::Vector{Kernel}
     weights::Vector{Real}
@@ -14,8 +22,11 @@ function KernelSum(kernels::AbstractVector{<:Kernel}; weights::AbstractVector{<:
 end
 
 Base.:+(k1::Kernel,k2::Kernel) = KernelSum([k1,k2],weights=[1.0,1.0])
+Base.:+(k1::KernelSum,k2::KernelSum) = KernelSum(vcat(k1.kernels,k2.kernels),weights=vcat(k1.weights,k2.weights))
 Base.:+(k::Kernel,ks::KernelSum) = KernelSum(vcat(k,ks.kernels),weights=vcat(1.0,ks.weights))
 Base.:+(ks::KernelSum,k::Kernel) = KernelSum(vcat(ks.kernels,k),weights=vcat(ks.weights,1.0))
+Base.:*(w::Real,k::Kernel) = KernelSum([k],[w]) #TODO add tests
+
 
 Base.length(k::KernelSum) = length(k.kernels)
 metric(k::KernelSum) = metric.(k.kernels)

src/kernels/matern.jl

@@ -38,7 +38,7 @@ end
 @inline kappa(κ::MaternKernel, d::Real) = iszero(d) ? one(d) : exp((1.0-κ.ν)*logtwo-lgamma(κ.ν) + κ.ν*log(sqrt(2κ.ν)*d)+log(besselk(κ.ν,sqrt(2κ.ν)*d)))
 
 """
-    Matern32Kernel(ρ=1.0)
+    Matern32Kernel([ρ=1.0])
 
 The matern 3/2 kernel is an isotropic Mercer kernel given by the formula:
 
@@ -59,7 +59,7 @@ end
 @inline kappa(κ::Matern32Kernel, d::T) where {T<:Real} = (1+sqrt(3)*d)*exp(-sqrt(3)*d)
 
 """
-    Matern52Kernel(ρ=1.0)
+    Matern52Kernel([ρ=1.0])
 
 The matern 5/2 kernel is an isotropic Mercer kernel given by the formula:
 

src/transform/lowranktransform.jl

@@ -12,15 +12,16 @@ struct LowRankTransform{T<:AbstractMatrix{<:Real}} <: Transform
 end
 
 Base.size(tr::LowRankTransform,i::Int) = size(tr.proj,i)
-Base.size(tr::LowRankTransform) = size(tr.proj)
+Base.size(tr::LowRankTransform) = size(tr.proj) #  TODO Add test
 
 function transform(t::LowRankTransform,X::AbstractMatrix{<:Real},obsdim::Int=defaultobs)
     @boundscheck size(t,2) != size(X,feature_dim(obsdim)) ?
         throw(DimensionMismatch("The projection matrix has size $(size(t)) and cannot be used on X with dimensions $(size(X))")) : nothing
     @inbounds _transform(t,X,obsdim)
 end
-function transform(t::LowRankTransform,x::AbstractVector{<:Real})
-    @assert size(t,2) == length(x) "Vector has wrong dimensions"
+
+function transform(t::LowRankTransform,x::AbstractVector{<:Real},obsdim::Int=defaultobs) #TODO Add test
+    @assert size(t,2) == length(x) "Vector has wrong dimensions $(length(x)) compared to projection matrix"
     t.proj*X
 end
 

src/transform/scaletransform.jl

@@ -18,7 +18,7 @@ function ScaleTransform(s::T=1.0) where {T<:Real}
     ScaleTransform{T}(s)
 end
 
-function ScaleTransform(s::T,dims::Integer) where {T<:Real}
+function ScaleTransform(s::T,dims::Integer) where {T<:Real} # TODO Add test
     @check_args(ScaleTransform, s, s > zero(T), "s > 0")
     ScaleTransform{Vector{T}}(fill(s,dims))
 end
@@ -28,12 +28,12 @@ function ScaleTransform(s::A) where {A<:AbstractVector{<:Real}}
     ScaleTransform{A}(s)
 end
 
-dim(str::ScaleTransform{<:Real}) = 1
+dim(str::ScaleTransform{<:Real}) = 1 #TODO Add test
 dim(str::ScaleTransform{<:AbstractVector{<:Real}}) = length(str.s)
 
 function transform(t::ScaleTransform{<:AbstractVector{<:Real}},X::AbstractMatrix{<:Real},obsdim::Int)
     @boundscheck if dim(t) != size(X,!Bool(obsdim-1)+1)
-        throw(DimensionMismatch("Array has size $(size(X,!Bool(obsdim-1)+1)) on dimension $(!Bool(obsdim-1)+1)) which does not match the length of the scale transform length , $(dim(t))."))
+        throw(DimensionMismatch("Array has size $(size(X,!Bool(obsdim-1)+1)) on dimension $(!Bool(obsdim-1)+1)) which does not match the length of the scale transform length , $(dim(t)).")) #TODO Add test
     end
     _transform(t,X,obsdim)
 end

src/transform/transform.jl

@@ -22,7 +22,7 @@ struct ChainTransform <: Transform
     transforms::Vector{Transform}
 end
 
-Base.length(t::ChainTransform) = length(t.transforms)
+Base.length(t::ChainTransform) = length(t.transforms) #TODO Add test
 
 function ChainTransform(v::AbstractVector{<:Transform})
     ChainTransform(v)
@@ -37,7 +37,7 @@ function transform(t::ChainTransform,X::T,obsdim::Int=defaultobs) where {T}
 end
 
 Base.:∘(t₁::Transform,t₂::Transform) = ChainTransform([t₂,t₁])
-Base.:∘(t::Transform,tc::ChainTransform) = ChainTransform(vcat(tc.transforms,t))
+Base.:∘(t::Transform,tc::ChainTransform) = ChainTransform(vcat(tc.transforms,t)) #TODO add test
 Base.:∘(tc::ChainTransform,t::Transform) = ChainTransform(vcat(t,tc.transforms))
 """
     IdentityTransform
@@ -46,7 +46,7 @@ Base.:∘(tc::ChainTransform,t::Transform) = ChainTransform(vcat(t,tc.transforms
 """
 struct IdentityTransform <: Transform end
 
-transform(t::IdentityTransform,x::AbstractArray,obsdim::Int=defaultobs) = x
+transform(t::IdentityTransform,x::AbstractArray,obsdim::Int=defaultobs) = x #TODO add test
 
 ### TODO Maybe defining adjoints could help but so far it's not working