Corrected transform behavior as a constructor

Author: theogf

.gitignore

@@ -1,3 +1,4 @@
 *.json
+*.cov
 Manifest.toml
 coverage/

README.md

@@ -13,19 +13,19 @@ The aim is to make the API as model-agnostic as possible while still being user-
 ```julia
   X = reshape(collect(range(-3.0,3.0,length=100)),:,1)
   # Set simple scaling of the data
-  k₁ = sqexponentialkernel(1.0)
+  k₁ = SqExponentialKernel()
   K₁ = kernelmatrix(k₁,X,obsdim=1)
 
   # Set a function transformation on the data
   k₂ = TransformedKernel(Matern32Kernel(),FunctionTransform(x->sin.(x)))
   K₂ = kernelmatrix(k₂,X,obsdim=1)
 
   # Set a matrix premultiplication on the data
-  k₃ = polynomialkernel(LowRankTransform(randn(4,1)),2.0,0.0)
+  k₃ = transform(PolynomialKernel(c=2.0,d=2.0),LowRankTransform(randn(4,1)))
   K₃ = kernelmatrix(k₃,X,obsdim=1)
 
   # Add and sum kernels
-  k₄ = 0.5*SqExponentialKernel()*linearkernel(0.5) + 0.4*k₂
+  k₄ = 0.5*SqExponentialKernel()*LinearKernel(c=0.5) + 0.4*k₂
   K₄ = kernelmatrix(k₄,X,obsdim=1)
 
   plot(heatmap.([K₁,K₂,K₃,K₄],yflip=true,colorbar=false)...,layout=(2,2),title=["K₁" "K₂" "K₃" "K₄"])

src/KernelFunctions.jl

@@ -1,6 +1,7 @@
 module KernelFunctions
 
 export kernelmatrix, kernelmatrix!, kerneldiagmatrix, kerneldiagmatrix!, kappa, kernelpdmat # Main matrix functions
+export transform
 export params, duplicate, set! # Helpers
 
 export Kernel

src/generic.jl

@@ -26,7 +26,7 @@ end
 
 for k in nameof.(subtypes(BaseKernel))
     @eval begin
-        @deprecate($k(ρ::Real;args...),TransformedKernel($k(args...),ScaleTransform(ρ)))
-        @deprecate($k(ρ::AbstractVector{<:Real};args...),TransformedKernel($k(args...),ARDTransform(ρ)))
+        @deprecate($k(ρ::Real;args...),transform($k(args...),ρ))
+        @deprecate($k(ρ::AbstractVector{<:Real};args...),transform($k(args...),ρ))
     end
 end

src/kernels/transformedkernel.jl

@@ -3,6 +3,24 @@ struct TransformedKernel{Tk<:Kernel,Tr<:Transform} <: Kernel
     transform::Tr
 end
 
+"""
+```julia
+    transform(k::BaseKernel, t::Transform) (1)
+    transform(k::BaseKernel, ρ::Real) (2)
+    transform(k::BaseKernel, ρ::AbstractVector) (3)
+```
+(1) Create a TransformedKernel with transform `t` and kernel `k`
+(2) Same as (1) with a `ScaleTransform` with scale `ρ`
+(3) Same as (1) with an `ARDTransform` with scales `ρ`
+"""
+transform
+
+transform(k::BaseKernel, t::Transform) = TransformedKernel(k, t)
+
+transform(k::BaseKernel, ρ::Real) = TransformedKernel(k, ScaleTransform(ρ))
+
+transform(k::BaseKernel,ρ::AbstractVector) = TransformedKernel(k, ARDTransform(ρ))
+
 kernel(κ) = κ.kernel
 
 kappa(κ::TransformedKernel, x) = kappa(κ.kernel, x)

src/transform/transform.jl

@@ -1,13 +1,5 @@
 export Transform, IdentityTransform, ScaleTransform, ARDTransform, LowRankTransform, FunctionTransform, ChainTransform
 
-"""
-```julia
-    transform(t::Transform, X::AbstractMatrix)
-```
-Apply the transfomration `t` or `k.transform` on the input `X`
-"""
-transform
-
 include("scaletransform.jl")
 include("ardtransform.jl")
 include("lowranktransform.jl")

test/test_kernelmatrix.jl

@@ -12,7 +12,7 @@ K = [zeros(dims[1],dims[1]),zeros(dims[2],dims[2])]
 Kdiag = [zeros(dims[1]),zeros(dims[2])]
 s = rand()
 k = SqExponentialKernel()
-kt = sqexponentialkernel(s)
+kt = transform(SqExponentialKernel(),s)
 @testset "Kernel Matrix Operations" begin
     @testset "Inplace Kernel Matrix" begin
         for obsdim in [1,2]

test/test_kernels.jl

@@ -120,10 +120,17 @@ x = rand()*2; v1 = rand(3); v2 = rand(3); id = IdentityTransform()
     end
     @testset "Transformed/Scaled Kernel" begin
         s = rand()
+        v = rand(3)
         k = SqExponentialKernel()
-        kt = KernelFunctions.TransformedKernel(k,ScaleTransform(s))
-        ks = KernelFunctions.ScaledKernel(k,s)
-        @test KernelFunctions.kappa(kt,v1,v2) == KernelFunctions.kappa(KernelFunctions.transform(k,ScaleTransform(s)),v1,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)