Rename KernelTensorSum -> KernelIndependentSum

Author: martincornejo

docs/src/kernels.md

@@ -124,7 +124,7 @@ TransformedKernel
 ScaledKernel
 KernelSum
 KernelProduct
-KernelTensorSum
+KernelIndependentSum
 KernelTensorProduct
 NormalizedKernel
 ```

src/KernelFunctions.jl

@@ -15,7 +15,7 @@ export LinearKernel, PolynomialKernel
 export RationalKernel, RationalQuadraticKernel, GammaRationalKernel
 export PiecewisePolynomialKernel
 export PeriodicKernel, NeuralNetworkKernel
-export KernelSum, KernelProduct, KernelTensorSum, KernelTensorProduct
+export KernelSum, KernelProduct, KernelIndependentSum, KernelTensorProduct
 export TransformedKernel, ScaledKernel, NormalizedKernel
 export GibbsKernel
 export ⊕
@@ -109,7 +109,7 @@ include("kernels/normalizedkernel.jl")
 include("matrix/kernelmatrix.jl")
 include("kernels/kernelsum.jl")
 include("kernels/kernelproduct.jl")
-include("kernels/kerneltensorsum.jl")
+include("kernels/kernelindependentsum.jl")
 include("kernels/kerneltensorproduct.jl")
 include("kernels/overloads.jl")
 include("kernels/neuralkernelnetwork.jl")

src/kernels/kerneltensorsum.jl renamed to src/kernels/kernelindependentsum.jl

@@ -1,7 +1,7 @@
 """
-    KernelTensorSum
+    KernelIndependentSum
 
-Tensor sum of kernels.
+Independent sum of kernels.
 
 # Definition
 
@@ -13,42 +13,42 @@ k(x, x'; k_1, \\ldots, k_n) = \\sum_{i=1}^n k_i(x_i, x'_i).
 
 # Construction
 
-The simplest way to specify a `KernelTensorSum` is to use the `⊕` operator (can be typed by `\\oplus<tab>`).
-```jldoctest tensorproduct
+The simplest way to specify a `KernelIndependentSum` is to use the `⊕` operator (can be typed by `\\oplus<tab>`).
+```jldoctest independentsum
 julia> k1 = SqExponentialKernel(); k2 = LinearKernel(); X = rand(5, 2);
 
 julia> kernelmatrix(k1 ⊕ k2, RowVecs(X)) == kernelmatrix(k1, X[:, 1]) + kernelmatrix(k2, X[:, 2])
 true
 ```
 
-You can also specify a `KernelTensorSum` by providing kernels as individual arguments
+You can also specify a `KernelIndependentSum` by providing kernels as individual arguments
 or as an iterable data structure such as a `Tuple` or a `Vector`. Using a tuple or
-individual arguments guarantees that `KernelTensorSum` is concretely typed but might
+individual arguments guarantees that `KernelIndependentSum` is concretely typed but might
 lead to large compilation times if the number of kernels is large.
-```jldoctest tensorproduct
-julia> KernelTensorSum(k1, k2) == k1 ⊕ k2
+```jldoctest independentsum
+julia> KernelIndependentSum(k1, k2) == k1 ⊕ k2
 true
 
-julia> KernelTensorSum((k1, k2)) == k1 ⊕ k2
+julia> KernelIndependentSum((k1, k2)) == k1 ⊕ k2
 true
 
-julia> KernelTensorSum([k1, k2]) == k1 ⊕ k2
+julia> KernelIndependentSum([k1, k2]) == k1 ⊕ k2
 true
 ```
 """
-struct KernelTensorSum{K} <: Kernel
+struct KernelIndependentSum{K} <: Kernel
     kernels::K
 end
 
-function KernelTensorSum(kernel::Kernel, kernels::Kernel...)
-    return KernelTensorSum((kernel, kernels...))
+function KernelIndependentSum(kernel::Kernel, kernels::Kernel...)
+    return KernelIndependentSum((kernel, kernels...))
 end
 
-@functor KernelTensorSum
+@functor KernelIndependentSum
 
-Base.length(kernel::KernelTensorSum) = length(kernel.kernels)
+Base.length(kernel::KernelIndependentSum) = length(kernel.kernels)
 
-function (kernel::KernelTensorSum)(x, y)
+function (kernel::KernelIndependentSum)(x, y)
     if !((nx = length(x)) == (ny = length(y)) == (nkernels = length(kernel)))
         throw(
             DimensionMismatch(
@@ -59,46 +59,46 @@ function (kernel::KernelTensorSum)(x, y)
     return sum(k(xi, yi) for (k, xi, yi) in zip(kernel.kernels, x, y))
 end
 
-function validate_domain(k::KernelTensorSum, x::AbstractVector, y::AbstractVector)
+function validate_domain(k::KernelIndependentSum, x::AbstractVector, y::AbstractVector)
     return (dx = dim(x)) == (dy = dim(y)) == (nkernels = length(k)) || error(
         "number of kernels ($nkernels) and group of features (x=$dx), y=$dy) are not consistent",
     )
 end
 
-function validate_domain(k::KernelTensorSum, x::AbstractVector)
+function validate_domain(k::KernelIndependentSum, x::AbstractVector)
     return validate_domain(k, x, x)
 end
 
-function kernelmatrix(k::KernelTensorSum, x::AbstractVector)
+function kernelmatrix(k::KernelIndependentSum, x::AbstractVector)
     validate_domain(k, x)
     return mapreduce(kernelmatrix, +, k.kernels, slices(x))
 end
 
-function kernelmatrix(k::KernelTensorSum, x::AbstractVector, y::AbstractVector)
+function kernelmatrix(k::KernelIndependentSum, x::AbstractVector, y::AbstractVector)
     validate_domain(k, x, y)
     return mapreduce(kernelmatrix, +, k.kernels, slices(x), slices(y))
 end
 
-function kernelmatrix_diag(k::KernelTensorSum, x::AbstractVector)
+function kernelmatrix_diag(k::KernelIndependentSum, x::AbstractVector)
     validate_domain(k, x)
     return mapreduce(kernelmatrix_diag, +, k.kernels, slices(x))
 end
 
-function kernelmatrix_diag(k::KernelTensorSum, x::AbstractVector, y::AbstractVector)
+function kernelmatrix_diag(k::KernelIndependentSum, x::AbstractVector, y::AbstractVector)
     validate_domain(k, x, y)
     return mapreduce(kernelmatrix_diag, +, k.kernels, slices(x), slices(y))
 end
 
-function Base.:(==)(x::KernelTensorSum, y::KernelTensorSum)
+function Base.:(==)(x::KernelIndependentSum, y::KernelIndependentSum)
     return (
         length(x.kernels) == length(y.kernels) &&
         all(kx == ky for (kx, ky) in zip(x.kernels, y.kernels))
     )
 end
 
-Base.show(io::IO, kernel::KernelTensorSum) = printshifted(io, kernel, 0)
+Base.show(io::IO, kernel::KernelIndependentSum) = printshifted(io, kernel, 0)
 
-function printshifted(io::IO, kernel::KernelTensorSum, shift::Int)
+function printshifted(io::IO, kernel::KernelIndependentSum, shift::Int)
     print(io, "Tensor sum of ", length(kernel), " kernels:")
     for k in kernel.kernels
         print(io, "\n")

src/kernels/overloads.jl

@@ -4,7 +4,7 @@ for (M, op, T) in (
     (:Base, :+, :KernelSum),
     (:Base, :*, :KernelProduct),
     (:TensorCore, :tensor, :KernelTensorProduct),
-    (:KernelFunctions, :⊕, :KernelTensorSum),
+    (:KernelFunctions, :⊕, :KernelIndependentSum),
 )
     @eval begin
         $M.$op(k1::Kernel, k2::Kernel) = $T(k1, k2)

test/kernels/kerneltensorsum.jl renamed to test/kernels/kernelindependentsum.jl

@@ -8,14 +8,14 @@
     # kernels
     k1 = SqExponentialKernel()
     k2 = ExponentialKernel()
-    kernel1 = KernelTensorSum(k1, k2)
-    kernel2 = KernelTensorSum([k1, k2])
+    kernel1 = KernelIndependentSum(k1, k2)
+    kernel2 = KernelIndependentSum([k1, k2])
 
     @test kernel1 == kernel2
-    @test kernel1.kernels == (k1, k2) === KernelTensorSum((k1, k2)).kernels
+    @test kernel1.kernels == (k1, k2) === KernelIndependentSum((k1, k2)).kernels
     for (_k1, _k2) in Iterators.product(
-        (k1, KernelTensorSum((k1,)), KernelTensorSum([k1])),
-        (k2, KernelTensorSum((k2,)), KernelTensorSum([k2])),
+        (k1, KernelIndependentSum((k1,)), KernelIndependentSum([k1])),
+        (k2, KernelIndependentSum((k2,)), KernelIndependentSum([k2])),
     )
         @test kernel1 == _k1 ⊕ _k2
     end
@@ -39,21 +39,21 @@
     TestUtils.test_interface(kernel1, ColVecs{Float64})
     TestUtils.test_interface(kernel1, RowVecs{Float64})
     TestUtils.test_interface(
-        KernelTensorSum(WhiteKernel(), ConstantKernel(; c=1.1)), ColVecs{String}
+        KernelIndependentSum(WhiteKernel(), ConstantKernel(; c=1.1)), ColVecs{String}
     )
     test_ADs(
-        x -> KernelTensorSum(SqExponentialKernel(), LinearKernel(; c=exp(x[1]))),
+        x -> KernelIndependentSum(SqExponentialKernel(), LinearKernel(; c=exp(x[1]))),
         rand(1);
         dims=[2, 2],
     )
     types = [ColVecs{Float64,Matrix{Float64}}, RowVecs{Float64,Matrix{Float64}}]
     test_interface_ad_perf(2.1, StableRNG(123456), types) do c
-        KernelTensorSum(SqExponentialKernel(), LinearKernel(; c=c))
+        KernelIndependentSum(SqExponentialKernel(), LinearKernel(; c=c))
     end
-    test_params(KernelTensorSum(k1, k2), (k1, k2))
+    test_params(KernelIndependentSum(k1, k2), (k1, k2))
 
     @testset "single kernel" begin
-        kernel = KernelTensorSum(k1)
+        kernel = KernelIndependentSum(k1)
         @test length(kernel) == 1
 
         @testset "eval" begin

test/kernels/overloads.jl

@@ -5,9 +5,13 @@
     k2 = SqExponentialKernel()
     k3 = RationalQuadraticKernel()
 
-    for (op, T) in
-        ((+, KernelSum), (*, KernelProduct), (⊗, KernelTensorProduct), (⊕, KernelTensorSum))
-        if T === KernelTensorProduct || T === KernelTensorSum
+    for (op, T) in (
+        (+, KernelSum),
+        (*, KernelProduct),
+        (⊗, KernelTensorProduct),
+        (⊕, KernelIndependentSum),
+    )
+        if T === KernelTensorProduct || T === KernelIndependentSum
             v2_1 = rand(rng, 2)
             v2_2 = rand(rng, 2)
             v3_1 = rand(rng, 3)

test/runtests.jl

@@ -125,7 +125,7 @@ include("test_utils.jl")
             include("kernels/kernelproduct.jl")
             include("kernels/kernelsum.jl")
             include("kernels/kerneltensorproduct.jl")
-            include("kernels/kerneltensorsum.jl")
+            include("kernels/kernelindependentsum.jl")
             include("kernels/overloads.jl")
             include("kernels/scaledkernel.jl")
             include("kernels/transformedkernel.jl")