Add 'Compose' transform (#243)

Author: eliascarv

docs/src/transforms.md

@@ -224,6 +224,12 @@ Closure
 Remainder
 ```
 
+## Compose
+
+```@docs
+Compose
+```
+
 ## ALR
 
 ```@docs

src/TableTransforms.jl

@@ -86,6 +86,7 @@ export
   ProjectionPursuit,
   Closure,
   Remainder,
+  Compose,
   ALR,
   CLR,
   ILR,

src/transforms.jl

@@ -293,6 +293,7 @@ include("transforms/eigenanalysis.jl")
 include("transforms/projectionpursuit.jl")
 include("transforms/closure.jl")
 include("transforms/remainder.jl")
+include("transforms/compose.jl")
 include("transforms/logratio.jl")
 include("transforms/rowtable.jl")
 include("transforms/coltable.jl")

src/transforms/compose.jl

@@ -0,0 +1,70 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+    Compose(; as=:CODA)
+
+Converts all columns of the table into parts of a composition
+in a new column named `as`, using the `CoDa.compose` function.
+
+    Compose(col₁, col₂, ..., colₙ; as=:CODA)
+    Compose([col₁, col₂, ..., colₙ]; as=:CODA)
+    Compose((col₁, col₂, ..., colₙ); as=:CODA)
+
+Converts the selected columns `col₁`, `col₂`, ..., `colₙ` into parts of a composition.
+
+    Compose(regex; as=:CODA)
+
+Converts the columns that match with `regex` into parts of a composition.
+
+# Examples
+
+```julia
+Compose(as=:comp)
+Compose([2, 3, 5])
+Compose([:b, :c, :e])
+Compose(("b", "c", "e"))
+Compose(r"[bce]", as="COMP")
+```
+"""
+struct Compose{S<:ColumnSelector} <: StatelessFeatureTransform
+  selector::S
+  as::Symbol
+end
+
+Compose(selector::ColumnSelector; as=:CODA) = Compose(selector, Symbol(as))
+
+Compose(; kwargs...) = Compose(AllSelector(); kwargs...)
+Compose(cols; kwargs...) = Compose(selector(cols); kwargs...)
+Compose(cols::C...; kwargs...) where {C<:Column} = Compose(selector(cols); kwargs...)
+
+isrevertible(::Type{<:Compose}) = true
+
+function applyfeat(transform::Compose, feat, prep)
+  cols = Tables.columns(feat)
+  names = Tables.columnnames(cols)
+  snames = transform.selector(names)
+  as = transform.as
+
+  newfeat = compose(feat, snames; as)
+
+  newfeat, (names, snames, as)
+end
+
+function revertfeat(::Compose, newfeat, fcache)
+  cols = Tables.columns(newfeat)
+  names, snames, as = fcache
+
+  coda = Tables.getcolumn(cols, as)
+  columns = map(names) do name
+    if name ∈ snames
+      Tables.getcolumn(coda, name)
+    else
+      Tables.getcolumn(cols, name)
+    end
+  end
+
+  𝒯 = (; zip(names, columns)...)
+  𝒯 |> Tables.materializer(newfeat)
+end

test/shows.jl

@@ -399,6 +399,21 @@
     └─ total = nothing"""
   end
 
+  @testset "Compose" begin
+    T = Compose(:a, :b, :c)
+
+    # compact mode
+    iostr = sprint(show, T)
+    @test iostr == "Compose([:a, :b, :c], :CODA)"
+
+    # full mode
+    iostr = sprint(show, MIME("text/plain"), T)
+    @test iostr == """
+    Compose transform
+    ├─ selector = [:a, :b, :c]
+    └─ as = :CODA"""
+  end
+
   @testset "RowTable" begin
     T = RowTable()
 

test/transforms.jl

@@ -28,6 +28,7 @@ transformfiles = [
   "projectionpursuit.jl",
   "closure.jl",
   "remainder.jl",
+  "compose.jl",
   "logratio.jl",
   "rowtable.jl",
   "coltable.jl",

test/transforms/compose.jl

@@ -0,0 +1,56 @@
+@testset "Compose" begin
+  @test isrevertible(Compose())
+
+  a = rand(10)
+  b = rand(10)
+  c = rand(10)
+  t = Table(; a, b, c)
+
+  T = Compose()
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:CODA,)
+  @test n.CODA isa CoDaArray
+  @test n.CODA == CoDaArray(t)
+  tₒ = revert(T, n, c)
+  @test tₒ == t
+
+  T = Compose(as=:comp)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:comp,)
+  @test n.comp isa CoDaArray
+  @test n.comp == CoDaArray(t)
+  tₒ = revert(T, n, c)
+  @test tₒ == t
+
+  T = Compose(1, 2)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:c, :CODA)
+  @test n.CODA isa CoDaArray
+  @test n.CODA == CoDaArray((a=t.a, b=t.b))
+  tₒ = revert(T, n, c)
+  @test tₒ == t
+
+  T = Compose([:a, :c])
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:b, :CODA)
+  @test n.CODA isa CoDaArray
+  @test n.CODA == CoDaArray((a=t.a, c=t.c))
+  tₒ = revert(T, n, c)
+  @test tₒ == t
+
+  T = Compose(("b", "c"))
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:a, :CODA)
+  @test n.CODA isa CoDaArray
+  @test n.CODA == CoDaArray((b=t.b, c=t.c))
+  tₒ = revert(T, n, c)
+  @test tₒ == t
+
+  T = Compose(r"[ab]", as="COMP")
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:c, :COMP)
+  @test n.COMP isa CoDaArray
+  @test n.COMP == CoDaArray((a=t.a, b=t.b))
+  tₒ = revert(T, n, c)
+  @test tₒ == t
+end