Nested broadcast (#46)

* overload copy

* Update lazyquasiarrays.jl

* Simplify broadcast

* LazyArrays v0.18

* Increase coverage

* Update test_quasibroadcast.jl

Author: dlfivefifty

Project.toml

@@ -1,7 +1,7 @@
 name = "QuasiArrays"
 uuid = "c4ea9172-b204-11e9-377d-29865faadc5c"
 authors = ["Sheehan Olver <solver@mac.com>"]
-version = "0.3.2"
+version = "0.3.3"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
@@ -10,7 +10,7 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
 ArrayLayouts = "0.4.3"
-LazyArrays = "0.17"
+LazyArrays = "0.17, 0.18"
 julia = "1.5"
 
 [extras]

src/inv.jl

@@ -54,4 +54,4 @@ pinv(A::PInvQuasiMatrix) = first(A.args)
 inv(A::QuasiMatrix) = QuasiArray(inv(A.parent), reverse(A.axes))
 
 _factorize(_, A) = error("Overload for $(typeof(A))")
-factorize(A::AbstractQuasiArray) = _factorize(MemoryLayout(typeof(A)), A)
+factorize(A::AbstractQuasiArray) = _factorize(MemoryLayout(A), A)

src/lazyquasiarrays.jl

@@ -68,7 +68,7 @@ copy(A::ApplyQuasiArray) = A # immutable arrays don't need to copy
 @propagate_inbounds _getindex(::Type{IND}, A::ApplyQuasiArray, I::IND) where {M,IND} =
     Applied(A)[I...]
 
-MemoryLayout(M::Type{ApplyQuasiArray{T,N,F,Args}}) where {T,N,F,Args} = 
+MemoryLayout(M::Type{ApplyQuasiArray{T,N,F,Args}}) where {T,N,F,Args} =
     applylayout(F, tuple_type_memorylayouts(Args)...)
 
 copy(A::Applied{LazyQuasiArrayApplyStyle}) = ApplyQuasiArray(A)
@@ -103,14 +103,16 @@ BroadcastQuasiArray{T,N}(bc::Broadcasted{Style,Axes,F,Args}) where {T,N,Style,Ax
 BroadcastQuasiArray{T}(bc::Broadcasted{<:Union{Nothing,BroadcastStyle},<:Tuple{Vararg{Any,N}},<:Any,<:Tuple}) where {T,N} =
     BroadcastQuasiArray{T,N}(bc)
 
-_broadcast2broadcastarray(a::Broadcasted{<:LazyQuasiArrayStyle}, b...) = tuple(BroadcastQuasiArray(a), b...)
+_broadcast2broadcastarray(a::Broadcasted{<:LazyQuasiArrayStyle}, b...) = tuple(BroadcastQuasiArray(a), _broadcast2broadcastarray(b...)...)
 
 _BroadcastQuasiArray(bc::Broadcasted) = BroadcastQuasiArray{combine_eltypes(bc.f, bc.args)}(bc)
 BroadcastQuasiArray(bc::Broadcasted{S}) where S =
     _BroadcastQuasiArray(instantiate(Broadcasted{S}(bc.f, _broadcast2broadcastarray(bc.args...))))
 BroadcastQuasiArray(b::BroadcastQuasiArray) = b
 BroadcastQuasiArray(f, A, As...) = BroadcastQuasiArray(broadcasted(f, A, As...))
 
+@inline BroadcastQuasiArray(A::AbstractQuasiArray) = BroadcastQuasiArray(call(A), arguments(A)...)
+
 broadcasted(A::BroadcastQuasiArray) = instantiate(broadcasted(A.f, A.args...))
 
 axes(A::BroadcastQuasiArray) = axes(broadcasted(A))
@@ -129,23 +131,16 @@ copy(A::BroadcastQuasiArray) = A # BroadcastQuasiArray are immutable
     A[kj.I...]
 
 
-@propagate_inbounds _broadcast_getindex_range(A::Union{Ref,AbstractQuasiArray{<:Any,0},Number}, I) = A # Scalar-likes can just ignore all indices
-# Everything else falls back to dynamically dropping broadcasted indices based upon its axes
-@propagate_inbounds _broadcast_getindex_range(A, I) = A[I]
-
-getindex(B::BroadcastQuasiArray{<:Any,1}, kr::AbstractVector{<:Number}) =
-    BroadcastArray(B.f, map(a -> _broadcast_getindex_range(a,kr), B.args)...)
-
 copy(bc::Broadcasted{<:LazyQuasiArrayStyle}) = BroadcastQuasiArray(bc)
 
 
 BroadcastStyle(::Type{<:LazyQuasiArray{<:Any,N}}) where N = LazyQuasiArrayStyle{N}()
 
-MemoryLayout(M::Type{BroadcastQuasiArray{T,N,F,Args}}) where {T,N,F,Args} = 
+MemoryLayout(M::Type{BroadcastQuasiArray{T,N,F,Args}}) where {T,N,F,Args} =
     broadcastlayout(F, tuple_type_memorylayouts(Args)...)
 
 arguments(b::BroadcastLayout, V::SubQuasiArray) = LazyArrays._broadcast_sub_arguments(V)
-
+call(b::BroadcastLayout, a::SubQuasiArray) = call(b, parent(a))
 
 
 ###
@@ -155,7 +150,7 @@ arguments(b::BroadcastLayout, V::SubQuasiArray) = LazyArrays._broadcast_sub_argu
 # a .* (B * C) flattens to (a .* B) * C
 __broadcast_mul_arguments(a, B, C...) = (a .* B, C...)
 _broadcast_mul_arguments(a, B) = __broadcast_mul_arguments(a, _mul_arguments(B)...)
-_mul_arguments(A::BroadcastQuasiMatrix{<:Any,typeof(*),<:Tuple{AbstractQuasiVector,AbstractQuasiMatrix}}) = 
+_mul_arguments(A::BroadcastQuasiMatrix{<:Any,typeof(*),<:Tuple{AbstractQuasiVector,AbstractQuasiMatrix}}) =
     _broadcast_mul_arguments(A.args...)
 
 ndims(M::Applied{LazyQuasiArrayApplyStyle,typeof(*)}) = ndims(last(M.args))
@@ -186,4 +181,4 @@ function *(App::ApplyQuasiMatrix{<:Any,typeof(^),<:Tuple{<:AbstractQuasiMatrix{T
     p < 0 && return ApplyQuasiMatrix(^,inv(A),-p)*b
     p == 0 && return copy(b)
     return A*(ApplyQuasiMatrix(^,A,p-1)*b)
-end
+end

src/quasibroadcast.jl

@@ -117,6 +117,7 @@ Base.@propagate_inbounds newindex(arg, I::QuasiCartesianIndex) = QuasiCartesianI
 end
 
 Base.@propagate_inbounds Base.getindex(bc::Broadcasted{<:AbstractQuasiArrayStyle}, i1::Number, I::Number...) = bc[QuasiCartesianIndex(i1, I...)]
+Base.@propagate_inbounds Base.getindex(bc::Broadcasted{<:AbstractQuasiArrayStyle}, i1::Integer, i2::Integer, I::Integer...) = bc[QuasiCartesianIndex(i1, i2, I...)]
 Base.@propagate_inbounds Base.getindex(bc::Broadcasted{<:AbstractQuasiArrayStyle}) = bc[QuasiCartesianIndex()]
 
 @inline Base.checkbounds(bc::Broadcasted{<:AbstractQuasiArrayStyle}, I::Number) =

test/test_quasibroadcast.jl

@@ -1,6 +1,6 @@
 # This file is based on a part of Julia. License is MIT: https://julialang.org/license
 
-using QuasiArrays, Test
+using QuasiArrays, LazyArrays, Test
 import Base: OneTo, Slice
 import Base.Broadcast: check_broadcast_axes, newindex, broadcasted, broadcastable, Broadcasted, DefaultArrayStyle, BroadcastStyle
 import QuasiArrays: QuasiCartesianIndex, QuasiCartesianIndices, DefaultQuasiArrayStyle, SubQuasiArray
@@ -120,7 +120,6 @@ import QuasiArrays: QuasiCartesianIndex, QuasiCartesianIndices, DefaultQuasiArra
         a = QuasiVector(randn(6), 0:0.5:2.5)
         b = BroadcastQuasiArray(exp, a)
         @test b[0.5] == exp(a[0.5])
-        @test b[0.5:0.5:1.0] isa QuasiArrays.BroadcastArray
         @test b[0.5:0.5:1.0] == b[[0.5,1.0]] == exp.(a[0.5:0.5:1.0]) 
 
         A = QuasiArray(randn(6,6), (0:0.5:2.5,0:0.5:2.5))
@@ -143,6 +142,16 @@ import QuasiArrays: QuasiCartesianIndex, QuasiCartesianIndices, DefaultQuasiArra
             x = Inclusion([0.0,2.0])
             @test BroadcastQuasiArray(exp,x)[QuasiCartesianIndex(2.0)] == exp(2.0)
         end
+
+        @testset "subview" begin
+            v = view(b,0.0:0.5:1.0)
+            c = BroadcastArray(v)
+            @test c == b[0.0:0.5:1.0]
+
+            w = view(b,Inclusion(0.0:0.5:1.0))
+            d = BroadcastQuasiArray(w)
+            @test d == b[Inclusion(0.0:0.5:1.0)]
+        end
     end
 
     @testset "SubQuasi Broadcast" begin

test/test_quasilazy.jl

@@ -95,4 +95,11 @@ Base.getindex(A::MyQuasiLazyMatrix, x::Float64, y::Float64) = A.A[x,y]
         @test A^2.5 * b ≈ Ap*b
         @test A^2.5 * B ≈ Ap*B
     end
+    @testset "Broadcast" begin
+        A = MyQuasiLazyMatrix(QuasiArray(rand(3,3),(0:0.5:1,0:0.5:1)))
+        @test exp.(A) isa BroadcastQuasiArray
+        @test exp.(A) == exp.(A.A)
+        @test exp.(exp.(A) .+ 1) isa BroadcastQuasiArray
+        @test exp.(exp.(A) .+ 1) == exp.(exp.(A.A) .+ 1)
+    end
 end