Add broadcasting of AbstractDataFrame

docs/src/lib/indexing.md

@@ -87,6 +87,10 @@ Under construction
 The following broadcasting rules apply to `AbstractDataFrame` objects:
 * `AbstractDataFrame` behaves in broadcasting like a two-dimensional collection compatible with matrices.
 * If an `AbstractDataFrame` takes part in broadcasting then a `DataFrame` is always produced as a result.
+  In this case the requested broadcasting operation must produce exactly two dimensional object.
+  An exception is when `AbstractDataFrame` is used only as a source of broadcast assignment into an object
+  of dimensionality higher than two. In such a case this is allowed and a data frame is treated as two-dimensional
+  collection compatible with matrices.
 * If multiple `AbstractDataFrame` objects take part in broadcasting then they have to have identical column names.
 
 It is possible to assign a value to `AbstractDataFrame` and `DataFrameRow` objects using the `.=` operator.

src/other/broadcasting.jl

@@ -42,6 +42,10 @@ function getcolbc(bcf::Base.Broadcast.Broadcasted{Style}, colind) where {Style}
 end
 
 function Base.copy(bc::Base.Broadcast.Broadcasted{DataFrameStyle})
+    ndim = length(axes(bc))
+    if ndim != 2
+        throw(DimensionMismatch("cannot broadcast a data frame into $ndim dimensions"))
+    end
     bcf = Base.Broadcast.flatten(bc)
     colnames = unique([_names(df) for df in bcf.args if df isa AbstractDataFrame])
     if length(colnames) != 1
@@ -128,6 +132,29 @@ function Base.Broadcast.broadcast_unalias(dest::AbstractDataFrame, src)
     src
 end
 
+function Base.Broadcast.broadcast_unalias(dest, src::AbstractDataFrame)
+    wascopied = false
+    for (i, col) in enumerate(eachcol(src))
+        if Base.mightalias(dest, col)
+            if src isa SubDataFrame
+                if !wascopied
+                    src =SubDataFrame(copy(parent(src), copycols=false),
+                                      index(src), rows(src))
+                end
+                parentidx = parentcols(index(src), i)
+                parent(src)[parentidx] = Base.unaliascopy(parent(src)[parentidx])
+            else
+                if !wascopied
+                    src = copy(src, copycols=false)
+                end
+                src[i] = Base.unaliascopy(col)
+            end
+            wascopied = true
+        end
+    end
+    src
+end
+
 function _broadcast_unalias_helper(dest::AbstractDataFrame, scol::AbstractVector,
                                    src::AbstractDataFrame, col2::Int, wascopied::Bool)
     # col1 can be checked till col2 point as we are writing broadcasting
@@ -143,7 +170,6 @@ function _broadcast_unalias_helper(dest::AbstractDataFrame, scol::AbstractVector
                 end
                 parentidx = parentcols(index(src), col2)
                 parent(src)[parentidx] = Base.unaliascopy(parent(src)[parentidx])
-
             else
                 if !wascopied
                     src = copy(src, copycols=false)

test/broadcasting.jl

@@ -870,4 +870,65 @@ end
     @test df == DataFrame(m)
 end
 
+@testset "data frame only on left hand side broadcasting assignment" begin
+    Random.seed!(1234)
+
+    m = rand(3,4);
+    m2 = copy(m);
+    m3 = copy(m);
+    df = DataFrame(a=view(m, :, 1), b=view(m, :, 1),
+                   c=view(m, :, 1), d=view(m, :, 1), copycols=false);
+    df2 = copy(df)
+    mdf = Matrix(df)
+
+    @test m .+ df == m2 .+ df
+    @test Matrix(m .+ df) == m .+ mdf
+    @test sin.(m .+ df) .+ 1 .+ m2 == sin.(m2 .+ df) .+ 1 .+ m
+    @test Matrix(m .+ df ./ 2 .* df2) == m .+ mdf ./ 2 .* mdf
+
+    m2 .+= df .+ 1 ./ df2
+    m .+= df .+ 1 ./ df2
+    @test m2 == m
+    for col in eachcol(df)
+        @test col == m[:, 1]
+    end
+    for col in eachcol(df2)
+        @test col == m3[:, 1]
+    end
+
+    m = rand(3,4);
+    m2 = copy(m);
+    m3 = copy(m);
+    df = view(DataFrame(a=view(m, :, 1), b=view(m, :, 1),
+                        c=view(m, :, 1), d=view(m, :, 1), copycols=false),
+              [3,2,1], :)
+    df2 = copy(df)
+    mdf = Matrix(df)
+
+    @test m .+ df == m2 .+ df
+    @test Matrix(m .+ df) == m .+ mdf
+    @test sin.(m .+ df) .+ 1 .+ m2 == sin.(m2 .+ df) .+ 1 .+ m
+    @test Matrix(m .+ df ./ 2 .* df2) == m .+ mdf ./ 2 .* mdf
+
+    m2 .+= df .+ 1 ./ df2
+    m .+= df .+ 1 ./ df2
+    @test m2 == m
+    for col in eachcol(df)
+        @test col == m[3:-1:1, 1]
+    end
+    for col in eachcol(df2)
+        @test col == m3[3:-1:1, 1]
+    end
+end
+
+@testset "broadcasting with 3-dimensional object" begin
+    y = zeros(4,3,2)
+    df = DataFrame(ones(4,3))
+    @test_throws DimensionMismatch df .+ y
+    @test_throws DimensionMismatch y .+ df
+    @test_throws DimensionMismatch df .+= y
+    y .+= df
+    @test all(y .== 1)
+end
+
 end # module