CachedArrayStyle for broadcasting with cached arrays

Author: dlfivefifty

src/cache.jl

@@ -333,7 +333,11 @@ MemoryLayout(C::Type{CachedArray{T,N,DAT,ARR}}) where {T,N,DAT,ARR} = cachedlayo
 # to take advantage of special implementations of the sub-components
 ######
 
-BroadcastStyle(::Type{<:CachedArray{<:Any,N}}) where N = LazyArrayStyle{N}()
+struct CachedArrayStyle{N} <: AbstractArrayStyle{N} end
+
+BroadcastStyle(::Type{<:AbstractCachedArray{<:Any,N}}) where N = CachedArrayStyle{N}()
+BroadcastStyle(::Type{<:SubArray{<:Any,N,<:AbstractCachedArray{<:Any,M}}}) where {N,M} = CachedArrayStyle{M}()
+
 
 broadcasted(::LazyArrayStyle, op, A::CachedArray) = CachedArray(broadcast(op, cacheddata(A)), broadcast(op, A.array))
 layout_broadcasted(::CachedLayout, _, op, A::AbstractArray, c::Number) = CachedArray(broadcast(op, cacheddata(A), c), broadcast(op, A.array, c))

src/lazybroadcasting.jl

@@ -74,10 +74,10 @@ _BroadcastArray(bc::Broadcasted) = BroadcastArray{combine_eltypes(bc.f, bc.args)
 BroadcastArray(bc::Broadcasted{S}) where S =
     _BroadcastArray(instantiate(Broadcasted{S}(bc.f, _broadcast2broadcastarray(bc.args...))))
 
-BroadcastArray(f, A, As...) = BroadcastArray(broadcasted(f, A, As...))
+BroadcastArray(f, A, As...) = BroadcastArray{combine_eltypes(f, (A,As...))}(f, A, As...)
 BroadcastArray{T}(f, A, As...) where T = BroadcastArray{T}(instantiate(broadcasted(f, A, As...)))
-BroadcastMatrix(f, A...) = BroadcastMatrix(broadcasted(f, A...))
-BroadcastVector(f, A...) = BroadcastVector(broadcasted(f, A...))
+BroadcastMatrix(f, A...) = BroadcastMatrix{combine_eltypes(f, A)}(f, A...)
+BroadcastVector(f, A...) = BroadcastVector{combine_eltypes(f, A)}(f, A...)
 
 BroadcastArray{T,N}(f, A...) where {T,N} = BroadcastArray{T,N,typeof(f),typeof(A)}(f, A)
 

test/broadcasttests.jl

@@ -449,6 +449,35 @@ using Infinities
         @test A*B ≈ Matrix(A)*Matrix(B)
         @test simplifiable(*,A,B) == Val(false) # TODO: Why False?
     end
+
+    @testset "misc tests" begin
+        bc = broadcasted(exp,[1,2,3])
+        v = BroadcastArray(exp, [1,2,3])
+        @test BroadcastArray(bc) == BroadcastVector(bc) == BroadcastVector{Float64,typeof(exp),typeof(bc.args)}(bc) ==
+            v == BroadcastVector(exp, [1,2,3]) == exp.([1,2,3])
+
+        @test Base.IndexStyle(typeof(BroadcastVector(exp, [1,2,3]))) == IndexCartesian()
+
+        bc = broadcasted(exp,[1 2; 3 4])
+        M = BroadcastArray(exp, [1 2; 3 4])
+        @test BroadcastArray(bc) == BroadcastMatrix(bc) == BroadcastMatrix{Float64,typeof(exp),typeof(bc.args)}(bc) ==
+            M == BroadcastMatrix(BroadcastMatrix(bc)) == BroadcastMatrix(exp,[1 2; 3 4]) == exp.([1 2; 3 4])
+
+        @test exp.(v') isa Adjoint{<:Any,<:BroadcastVector}
+        @test exp.(transpose(v)) isa Transpose{<:Any,<:BroadcastVector}
+        @test exp.(M') isa Adjoint{<:Any,<:BroadcastMatrix}
+        @test exp.(transpose(M)) isa Transpose{<:Any,<:BroadcastMatrix}
+
+        bc = BroadcastArray(broadcasted(+, 1:10, broadcasted(sin, 1:10)))
+        @test bc[1:10] == (1:10) .+ sin.(1:10)
+
+        bc = BroadcastArray(broadcasted(+,1:10,broadcasted(+,1,2)))
+        @test bc.args[2] == 3
+        
+        @testset "_vec_mul_arguments method" begin
+            @test_throws "MethodError: no method matching _vec_mul_arguments"  LazyArrays._vec_mul_arguments(2, [])
+        end
+    end
 end
 
 end #module

test/runtests.jl

@@ -1,6 +1,6 @@
 using Test, LinearAlgebra, LazyArrays, FillArrays, ArrayLayouts, SparseArrays
 using StaticArrays
-import LazyArrays: CachedArray, colsupport, rowsupport, LazyArrayStyle, broadcasted,
+import LazyArrays: CachedArray, colsupport, rowsupport, LazyArrayStyle, broadcasted, resizedata!,
             ApplyLayout, BroadcastLayout, AddArray, LazyLayout, PaddedLayout, PaddedRows, PaddedColumns
 import ArrayLayouts: OnesLayout
 
@@ -379,6 +379,27 @@ end
         @test a[end] ≈ prod(1 .+ (1:10_000_000).^(-2.0))
         @test LazyArrays.AccumulateAbstractVector(*, 1:5) == Accumulate(*, 1:5)
         @test LazyArrays.AccumulateAbstractVector(*, 1:5) isa LazyArrays.AccumulateAbstractVector
+
+            @testset "Broadcasted Cached" begin
+                a = Accumulate(*, 1:5)
+                b = BroadcastVector(*, 2, a);
+
+                dest = Vector{Int}(undef, 3)
+                copyto!(dest, view(b,1:3))
+
+                # lets step through the copyto! to reduce to MWE
+                bc = LazyArrays._broadcastarray2broadcasted(view(b,1:3))
+                # this is equivalent to
+                v = view(a,1:3)
+                bc = broadcasted(*, 2, v)
+
+                copyto!(dest, bc)
+
+
+                # what we want:
+                resizedata!(v, length(dest)) 
+                copyto!(dest, broadcasted(*, 2,  LazyArrays.cacheddata(v)))
+            end
     end
 end
 
@@ -441,34 +462,6 @@ end
     @test tril(A,1) isa ApplyMatrix{Float64,typeof(tril)}
 end
 
-@testset "BroadcastArray" begin
-    bc = broadcasted(exp,[1,2,3])
-    v = BroadcastArray(exp, [1,2,3])
-    @test BroadcastArray(bc) == BroadcastVector(bc) == BroadcastVector{Float64,typeof(exp),typeof(bc.args)}(bc) ==
-        v == BroadcastVector(exp, [1,2,3]) == exp.([1,2,3])
-
-    Base.IndexStyle(typeof(BroadcastVector(exp, [1,2,3]))) == IndexLinear()
-
-    bc = broadcasted(exp,[1 2; 3 4])
-    M = BroadcastArray(exp, [1 2; 3 4])
-    @test BroadcastArray(bc) == BroadcastMatrix(bc) == BroadcastMatrix{Float64,typeof(exp),typeof(bc.args)}(bc) ==
-        M == BroadcastMatrix(BroadcastMatrix(bc)) == BroadcastMatrix(exp,[1 2; 3 4]) == exp.([1 2; 3 4])
-
-    @test exp.(v') isa Adjoint{<:Any,<:BroadcastVector}
-    @test exp.(transpose(v)) isa Transpose{<:Any,<:BroadcastVector}
-    @test exp.(M') isa Adjoint{<:Any,<:BroadcastMatrix}
-    @test exp.(transpose(M)) isa Transpose{<:Any,<:BroadcastMatrix}
-
-    bc = BroadcastArray(broadcasted(+, 1:10, broadcasted(sin, 1:10)))
-    @test bc[1:10] == (1:10) .+ sin.(1:10)
-
-    bc = BroadcastArray(broadcasted(+,1:10,broadcasted(+,1,2)))
-    @test bc.args[2] == 3
-    
-    @testset "_vec_mul_arguments method" begin
-        @test_throws "MethodError: no method matching _vec_mul_arguments"  LazyArrays._vec_mul_arguments(2, [])
-    end
-end
 
 include("blocktests.jl")
 include("bandedtests.jl")