Corrected LowRankTransform Added TransformChain and added Tests

Author: theogf

src/transform/lowranktransform.jl

@@ -1,17 +1,12 @@
-struct LowRankTransform{T<:AbstractMatrix{<:Real}}} <: Transform
+struct LowRankTransform{T<:AbstractMatrix{<:Real}} <: Transform
     proj::T
 end
 
-function LowRankTransform(proj::M) where {M<:AbstractMatrix{<:Real}}
-    # @check_args(LowRankTransform, proj, A > zero(T), "s > 0")
-    LowRankTransform{T}(proj)
-end
-
-Base.size(tr::LowRankTransform{<:Real},i::Int) = size(tr.proj,i)
-Base.size(tr::LowRankTransform{<:Real}) = size(tr.proj)
+Base.size(tr::LowRankTransform,i::Int) = size(tr.proj,i)
+Base.size(tr::LowRankTransform) = size(tr.proj)
 
-function transform(t::LowRankTransform{<:AbstractVector{<:Real}},X::AbstractMatrix{<:Real},obsdim::Int)
-    @boundscheck if size(t,2) != size(X,!Bool(obsdim-1)+1)
+function transform(t::LowRankTransform,X::AbstractMatrix{<:Real},obsdim::Int)
+    @boundscheck if size(t,2) != size(X,1)
         throw(DimensionMismatch("The projection matrix has size $(size(t)) and cannot be used on X with dimensions $(size(X))"))
     end
     _transform(t,X,obsdim)

src/transform/transform.jl

@@ -1,22 +1,45 @@
+export Transform, ScaleTransform, LowRankTransform, FunctionTransform, TransformChain
+
+
 abstract type Transform end
 
+include("scaletransform.jl")
+include("lowranktransform.jl")
+
 struct TransformChain <: Transform
     transforms::Vector{Transform}
 end
 
+Base.length(t::TransformChain) = length(t.transforms)
+
 function TransformChain(v::AbstractVector{<:Transform})
     TransformChain(v)
 end
 
-struct InputTransform{F} <: Transform
-    f::F
+function transform(t::TransformChain,X::T,obsdim::Int=1) where {T}
+    Xtr = copy(X)
+    for tr in t.transforms
+        Xtr = transform(tr,Xtr,obsdim)
+    end
+    return Xtr
 end
 
-# function InputTransform(f::F) where {F}
-#     InputTransform{F}(f)
-# end
+Base.:∘(t₁::Transform,t₂::Transform) = TransformChain([t₂,t₁])
+Base.:∘(t::Transform,tc::TransformChain) = TransformChain(vcat(tc.transforms,t))
+Base.:∘(tc::TransformChain,t::Transform) = TransformChain(vcat(t,tc.transforms))
+
+"""
+    FunctionTransform
+
+    Take a function `f` as an argument which is going to act on the matrix as a whole.
+    Make sure that `f` is supposed to act on a matrix by eventually using broadcasting
+    For example `f(x)=sin(x)` -> `f(x)=sin.(x)`
+"""
+struct FunctionTransform{F} <: Transform
+    f::F
+end
 
-transform(t::InputTransform,x::T,obsdim::Int=1) where {T} = t.f(X)
+transform(t::FunctionTransform,X::T,obsdim::Int=1) where {T} = t.f(X)
 
 
 struct IdentityTransform <: Transform end

test/test_transform.jl

@@ -0,0 +1,31 @@
+using Test
+using KernelFunctions
+using Random: seed!
+
+seed!(42)
+
+dims = (10,5)
+X = rand(dims...)
+##
+s = 3.0
+v1 = vcat(3.0,4.0*ones(dims[2]-1))
+v2 = vcat(3.0,4.0*ones(dims[1]-1))
+t = ScaleTransform(s)
+vt1 = ScaleTransform(v1)
+vt2 = ScaleTransform(v2)
+@test all(KernelFunctions.transform(t,X).==s*X)
+@test all(KernelFunctions.transform(vt1,X,1).==v1'.*X)
+@test all(KernelFunctions.transform(vt2,X,2).==v2.*X)
+##
+P = rand(5,10)
+tp = LowRankTransform(P)
+@test all(KernelFunctions.transform(tp,X,2).==P*X)
+##
+f(x) = sin.(x)
+tf = FunctionTransform(f)
+@test all(KernelFunctions.transform(tf,X,1).==f(X))
+##
+tchain = TransformChain([t,tp,tf])
+t∘tp∘tf
+TransformChain([t,tp])
+@test all(KernelFunctions.transform(tchain,X).==f(P*(s*X)))