Refactors the test suite

test/approximations/nystrom.jl

@@ -0,0 +1,9 @@
+@testset "nystrom" begin
+    dims = [10,5]
+    X = rand(dims...)
+    k = SqExponentialKernel()
+    for obsdim in [1, 2]
+        @test kernelmatrix(k, X; obsdim=obsdim) ≈ kernelmatrix(nystrom(k, X, 1.0; obsdim=obsdim))
+        @test kernelmatrix(k, X; obsdim=obsdim) ≈ kernelmatrix(nystrom(k, X, collect(1:dims[obsdim]); obsdim=obsdim))
+    end
+end

test/distances/delta.jl

@@ -0,0 +1,10 @@
+@testset "delta" begin
+    A = rand(10,5)
+    B = rand(20,5)
+    d = KernelFunctions.Delta()
+    @test pairwise(d,A,dims=1) == Matrix(I,size(A,1),size(A,1))
+    @test pairwise(d,A,B,dims=1) == zeros(size(A,1),size(B,1))
+    @test d(1,2) == 0
+    @test d(1,1) == 1
+    @test_throws DimensionMismatch d(rand(3),rand(4))
+end

test/distances/dotproduct.jl

@@ -0,0 +1,8 @@
+@testset "dotproduct" begin
+    A = rand(10,5)
+    B = rand(20,5)
+    d = KernelFunctions.DotProduct()
+    @test diag(pairwise(d,A,dims=2)) == [dot(A[:,i],A[:,i]) for i in 1:size(A,2)]
+    @test_throws DimensionMismatch d(rand(3),rand(4))
+    @test d(3.0,2.0) == 6.0
+end

test/test_generic.jl → test/generic.jl

@@ -1,8 +1,5 @@
-using KernelFunctions
-
-k = SqExponentialKernel()
-
-@testset "Generic functions to test" begin
+@testset "generic" begin
+    k = SqExponentialKernel()
     @test length(k) == 1
     @test iterate(k) == (k,nothing)
     @test iterate(k,1) == nothing

test/kernels/constant.jl

@@ -0,0 +1,25 @@
+@testset "constant" begin
+    @testset "ZeroKernel" begin
+        k = ZeroKernel()
+        @test eltype(k) == Any
+        @test kappa(k,2.0) == 0.0
+        @test KernelFunctions.metric(ZeroKernel()) == KernelFunctions.Delta()
+    end
+    @testset "WhiteKernel" begin
+        k = WhiteKernel()
+        @test eltype(k) == Any
+        @test kappa(k,1.0) == 1.0
+        @test kappa(k,0.0) == 0.0
+        @test EyeKernel == WhiteKernel
+        @test metric(WhiteKernel()) == KernelFunctions.Delta()
+    end
+    @testset "ConstantKernel" begin
+        c = 2.0
+        k = ConstantKernel(c=c)
+        @test eltype(k) == Any
+        @test kappa(k,1.0) == c
+        @test kappa(k,0.5) == c
+        @test metric(ConstantKernel()) == KernelFunctions.Delta()
+        @test metric(ConstantKernel(c=2.0)) == KernelFunctions.Delta()
+    end
+end

test/kernels/cosine.jl

@@ -0,0 +1,14 @@
+@testset "cosine" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+
+    k = CosineKernel()
+    @test eltype(k) == Any
+    @test kappa(k, 1.0) ≈ -1.0 atol=1e-5
+    @test kappa(k, 2.0) ≈ 1.0 atol=1e-5
+    @test kappa(k, 1.5) ≈ 0.0 atol=1e-5
+    @test kappa(k,x) ≈ cospi(x) atol=1e-5
+    @test k(v1, v2) ≈ cospi(sqrt(sum(abs2.(v1-v2)))) atol=1e-5
+end

test/kernels/custom.jl

@@ -0,0 +1,24 @@
+# minimal definition of a custom kernel
+struct MyKernel <: Kernel end
+
+KernelFunctions.kappa(::MyKernel, d2::Real) = exp(-d2)
+KernelFunctions.metric(::MyKernel) = SqEuclidean()
+
+# some syntactic sugar
+(κ::MyKernel)(d::Real) = kappa(κ, d)
+(κ::MyKernel)(x::AbstractVector{<:Real}, y::AbstractVector{<:Real}) = kappa(κ, x, y)
+(κ::MyKernel)(X::AbstractMatrix{<:Real}, Y::AbstractMatrix{<:Real}; obsdim = 2) = kernelmatrix(κ, X, Y; obsdim = obsdim)
+(κ::MyKernel)(X::AbstractMatrix{<:Real}; obsdim = 2) = kernelmatrix(κ, X; obsdim = obsdim)
+
+@testset "custom" begin
+    @test kappa(MyKernel(), 3) == kappa(SqExponentialKernel(), 3)
+    @test kappa(MyKernel(), 1, 3) == kappa(SqExponentialKernel(), 1, 3)
+    @test kappa(MyKernel(), [1, 2], [3, 4]) == kappa(SqExponentialKernel(), [1, 2], [3, 4])
+    @test kernelmatrix(MyKernel(), [1 2; 3 4], [5 6; 7 8]) == kernelmatrix(SqExponentialKernel(), [1 2; 3 4], [5 6; 7 8])
+    @test kernelmatrix(MyKernel(), [1 2; 3 4]) == kernelmatrix(SqExponentialKernel(), [1 2; 3 4])
+
+    @test MyKernel()(3) == SqExponentialKernel()(3)
+    @test MyKernel()([1, 2], [3, 4]) == SqExponentialKernel()([1, 2], [3, 4])
+    @test MyKernel()([1 2; 3 4], [5 6; 7 8]) == SqExponentialKernel()([1 2; 3 4], [5 6; 7 8])
+    @test MyKernel()([1 2; 3 4]) == SqExponentialKernel()([1 2; 3 4])
+end

test/kernels/exponential.jl

@@ -0,0 +1,34 @@
+@testset "exponential" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+    @testset "SqExponentialKernel" begin
+        k = SqExponentialKernel()
+        @test kappa(k,x) ≈ exp(-x)
+        @test k(v1,v2) ≈ exp(-norm(v1-v2)^2)
+        @test kappa(SqExponentialKernel(),x) == kappa(k,x)
+        @test metric(SqExponentialKernel()) == SqEuclidean()
+    end
+    @testset "ExponentialKernel" begin
+        k = ExponentialKernel()
+        @test kappa(k,x) ≈ exp(-x)
+        @test k(v1,v2) ≈ exp(-norm(v1-v2))
+        @test kappa(ExponentialKernel(),x) == kappa(k,x)
+        @test metric(ExponentialKernel()) == Euclidean()
+    end
+    @testset "GammaExponentialKernel" begin
+        γ = 2.0
+        k = GammaExponentialKernel(γ=γ)
+        @test kappa(k,x) ≈ exp(-(x)^(γ))
+        @test k(v1,v2) ≈ exp(-norm(v1-v2)^(2γ))
+        @test kappa(GammaExponentialKernel(),x) == kappa(k,x)
+        @test GammaExponentialKernel(gamma=γ).γ == [γ]
+        @test metric(GammaExponentialKernel()) == SqEuclidean()
+        @test metric(GammaExponentialKernel(γ=2.0)) == SqEuclidean()
+
+        #Coherence :
+        @test KernelFunctions._kernel(GammaExponentialKernel(γ=1.0),v1,v2) ≈ KernelFunctions._kernel(SqExponentialKernel(),v1,v2)
+        @test KernelFunctions._kernel(GammaExponentialKernel(γ=0.5),v1,v2) ≈ KernelFunctions._kernel(ExponentialKernel(),v1,v2)
+    end
+end

test/kernels/exponentiated.jl

@@ -0,0 +1,12 @@
+@testset "exponentiated" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+
+    k = ExponentiatedKernel()
+    @test kappa(k,x) ≈ exp(x)
+    @test kappa(k,-x) ≈ exp(-x)
+    @test k(v1,v2) ≈ exp(dot(v1,v2))
+    @test metric(ExponentiatedKernel()) == KernelFunctions.DotProduct()
+end

test/kernels/kernelproduct.jl

@@ -0,0 +1,15 @@
+@testset "kernelproduct" begin
+    rng = MersenneTwister(123456)
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+
+    k1 = LinearKernel()
+    k2 = SqExponentialKernel()
+    k3 = RationalQuadraticKernel()
+
+    k = KernelProduct([k1,k2])
+    @test length(k) == 2
+    @test kappa(k,v1,v2) == kappa(k1*k2,v1,v2)
+    @test kappa(k*k,v1,v2) ≈ kappa(k,v1,v2)^2
+    @test kappa(k*k3,v1,v2) ≈ kappa(k3*k,v1,v2)
+end

test/kernels/kernelsum.jl

@@ -0,0 +1,22 @@
+@testset "kernelsum" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+
+    k1 = LinearKernel()
+    k2 = SqExponentialKernel()
+    k3 = RationalQuadraticKernel()
+    X = rand(rng, 2,2)
+
+    w = [2.0,0.5]
+    k = KernelSum([k1,k2],w)
+    ks1 = 2.0*k1
+    ks2 = 0.5*k2
+    @test length(k) == 2
+    @test kappa(k,v1,v2) == kappa(2.0*k1+0.5*k2,v1,v2)
+    @test kappa(k+k3,v1,v2) ≈ kappa(k3+k,v1,v2)
+    @test kappa(k1+k2,v1,v2) == kappa(KernelSum([k1,k2]),v1,v2)
+    @test kappa(k+ks1,v1,v2) ≈ kappa(ks1+k,v1,v2)
+    @test kappa(k+k,v1,v2) == kappa(KernelSum([k1,k2,k1,k2],vcat(w,w)),v1,v2)
+end

test/kernels/maha.jl

@@ -0,0 +1,7 @@
+@testset "maha" begin
+    P = rand(3,3)
+    k = MahalanobisKernel(P)
+    @test kappa(k,x) == exp(-x)
+    @test k(v1,v2) ≈ exp(-sqmahalanobis(v1,v2, k.P))
+    @test kappa(ExponentialKernel(),x) == kappa(k,x)
+end

test/kernels/matern.jl

@@ -0,0 +1,36 @@
+@testset "matern" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+    @testset "MaternKernel" begin
+        ν = 2.0
+        k = MaternKernel(ν=ν)
+        matern(x,ν) = 2^(1-ν)/gamma(ν)*(sqrt(2ν)*x)^ν*besselk(ν,sqrt(2ν)*x)
+        @test MaternKernel(nu=ν).ν == [ν]
+        @test kappa(k,x) ≈ matern(x,ν)
+        @test kappa(k,0.0) == 1.0
+        @test kappa(MaternKernel(ν=ν),x) == kappa(k,x)
+        @test metric(MaternKernel()) == Euclidean()
+        @test metric(MaternKernel(ν=2.0)) == Euclidean()
+    end
+    @testset "Matern32Kernel" begin
+        k = Matern32Kernel()
+        @test kappa(k,x) ≈ (1+sqrt(3)*x)exp(-sqrt(3)*x)
+        @test k(v1,v2) ≈ (1+sqrt(3)*norm(v1-v2))exp(-sqrt(3)*norm(v1-v2))
+        @test kappa(Matern32Kernel(),x) == kappa(k,x)
+        @test metric(Matern32Kernel()) == Euclidean()
+    end
+    @testset "Matern52Kernel" begin
+        k = Matern52Kernel()
+        @test kappa(k,x) ≈ (1+sqrt(5)*x+5/3*x^2)exp(-sqrt(5)*x)
+        @test k(v1,v2) ≈ (1+sqrt(5)*norm(v1-v2)+5/3*norm(v1-v2)^2)exp(-sqrt(5)*norm(v1-v2))
+        @test kappa(Matern52Kernel(),x) == kappa(k,x)
+        @test metric(Matern52Kernel()) == Euclidean()
+    end
+    @testset "Coherence Materns" begin
+        @test kappa(MaternKernel(ν=0.5),x) ≈ kappa(ExponentialKernel(),x)
+        @test kappa(MaternKernel(ν=1.5),x) ≈ kappa(Matern32Kernel(),x)
+        @test kappa(MaternKernel(ν=2.5),x) ≈ kappa(Matern52Kernel(),x)
+    end
+end

test/kernels/polynomial.jl

@@ -0,0 +1,26 @@
+@testset "polynomial" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+    c = randn(rng)
+    @testset "LinearKernel" begin
+        k = LinearKernel()
+        @test kappa(k,x) ≈ x
+        @test k(v1,v2) ≈ dot(v1,v2)
+        @test kappa(LinearKernel(),x) == kappa(k,x)
+        @test metric(LinearKernel()) == KernelFunctions.DotProduct()
+        @test metric(LinearKernel(c=2.0)) == KernelFunctions.DotProduct()
+    end
+    @testset "PolynomialKernel" begin
+        k = PolynomialKernel()
+        @test kappa(k,x) ≈ x^2
+        @test k(v1,v2) ≈ dot(v1,v2)^2
+        @test kappa(PolynomialKernel(),x) == kappa(k,x)
+        #Coherence test
+        @test kappa(PolynomialKernel(d=1.0,c=c),x) ≈ kappa(LinearKernel(c=c),x)
+        @test metric(PolynomialKernel()) == KernelFunctions.DotProduct()
+        @test metric(PolynomialKernel(d=3.0)) == KernelFunctions.DotProduct()
+        @test metric(PolynomialKernel(d=3.0,c=2.0)) == KernelFunctions.DotProduct()
+    end
+end

test/kernels/rationalquad.jl

@@ -0,0 +1,29 @@
+@testset "rationalquad" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+    @testset "RationalQuadraticKernel" begin
+        α = 2.0
+        k = RationalQuadraticKernel(α=α)
+        @test RationalQuadraticKernel(alpha=α).α == [α]
+        @test kappa(k,x) ≈ (1.0+x/2.0)^-2
+        @test k(v1,v2) ≈ (1.0+norm(v1-v2)^2/2.0)^-2
+        @test kappa(RationalQuadraticKernel(α=α),x) == kappa(k,x)
+        @test metric(RationalQuadraticKernel()) == SqEuclidean()
+        @test metric(RationalQuadraticKernel(α=2.0)) == SqEuclidean()
+    end
+    @testset "GammaRationalQuadraticKernel" begin
+        k = GammaRationalQuadraticKernel()
+        @test kappa(k,x) ≈ (1.0+x^2.0/2.0)^-2
+        @test k(v1,v2) ≈ (1.0+norm(v1-v2)^4.0/2.0)^-2
+        @test kappa(GammaRationalQuadraticKernel(),x) == kappa(k,x)
+        a = 1.0 + rand()
+        @test GammaRationalQuadraticKernel(alpha=a).α == [a]
+        #Coherence test
+        @test kappa(GammaRationalQuadraticKernel(α=a,γ=1.0),x) ≈ kappa(RationalQuadraticKernel(α=a),x)
+        @test metric(GammaRationalQuadraticKernel()) == SqEuclidean()
+        @test metric(GammaRationalQuadraticKernel(γ=2.0)) == SqEuclidean()
+        @test metric(GammaRationalQuadraticKernel(γ=2.0,α=3.0)) == SqEuclidean()
+    end
+end

test/kernels/scaledkernel.jl

@@ -0,0 +1,10 @@
+@testset "scaledkernel" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    s = rand(rng)
+
+    k = SqExponentialKernel()
+    ks = ScaledKernel(k,s)
+    @test kappa(ks,x) == s*kappa(k,x)
+    @test kappa(ks,x) == kappa(s*k,x)
+end

test/kernels/transformedkernel.jl

@@ -0,0 +1,19 @@
+@testset "transformedkernel" begin
+    rng = MersenneTwister(123456)
+    x = rand(rng)*2
+    v1 = rand(rng, 3)
+    v2 = rand(rng, 3)
+
+    s = rand(rng)
+    v = rand(rng, 3)
+    k = SqExponentialKernel()
+    kt = TransformedKernel(k,ScaleTransform(s))
+    ktard = TransformedKernel(k,ARDTransform(v))
+    @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) atol=1e-5
+    @test kappa(ktard,v1,v2) ≈ kappa(transform(k,ARDTransform(v)),v1,v2) atol=1e-5
+    @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)
+end

test/matrix/kernelkroneckermat.jl

@@ -0,0 +1,10 @@
+@testset "kernelkroneckermat" begin
+    rng = MersenneTwister(123456)
+    k = SqExponentialKernel()
+    x = range(0, 1; length=10)
+    X = vcat(collect.(Iterators.product(x,x))'...)
+
+    @test all(collect(kernelkronmat(k,collect(x),2)).≈kernelmatrix(k,X,obsdim=1))
+    @test all(collect(kernelkronmat(k,[x,x])).≈kernelmatrix(k,X,obsdim=1))
+    @test_throws AssertionError kernelkronmat(LinearKernel(),collect(x),2)
+end