Norms for CachedVector, vector views of Hcat are ApplyLayout{typeof(vcat)} (#81)

* Add norm for cache, support vector hcats

* Actually its a ApplyLayout{typeof(vcat)}

* Update runtests.jl

* Hcat simple broadcast

* Add `@inline`

* ambiguity fixes

* Add more tests, simplify overrides

* v0.14.7

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "LazyArrays"
 uuid = "5078a376-72f3-5289-bfd5-ec5146d43c02"
-version = "0.14.6"
+version = "0.14.7"
 
 
 [deps]

src/cache.jl

@@ -199,20 +199,23 @@ broadcasted(::LazyArrayStyle, op, c::Ref, A::CachedArray) =
     CachedArray(broadcast(op, c, paddeddata(A)), broadcast(op, c, A.array)) 
 
 
-function broadcasted(::LazyArrayStyle, op, A::CachedVector, B::AbstractVector)
+function cache_broadcast(op, A::CachedVector, B)
     dat = paddeddata(A)
     n = length(dat)
     m = length(B)
     CachedArray(broadcast(op, dat, view(B,1:n)), broadcast(op, A.array, B))
 end
 
-function broadcasted(::LazyArrayStyle, op, A::AbstractVector, B::CachedVector)
+function cache_broadcast(op, A, B::CachedVector)
     dat = paddeddata(B)
     n = length(dat)
     m = length(A)
     CachedArray(broadcast(op, view(A,1:n), dat), broadcast(op, A, B.array))
 end
 
+broadcasted(::LazyArrayStyle, op, A::CachedVector, B::AbstractVector) = cache_broadcast(op, A, B)
+broadcasted(::LazyArrayStyle, op, A::AbstractVector, B::CachedVector) = cache_broadcast(op, A, B)
+
 function broadcasted(::LazyArrayStyle, op, A::CachedVector, B::CachedVector)
     n = max(A.datasize[1],B.datasize[1])
     resizedata!(A,n)
@@ -222,3 +225,11 @@ function broadcasted(::LazyArrayStyle, op, A::CachedVector, B::CachedVector)
     CachedArray(broadcast(op, Adat, Bdat), broadcast(op, A.array, B.array))
 end
 
+###
+# norm
+###
+
+norm1(a::CachedVector) = norm(paddeddata(a),1) + norm(@view(a.array[a.datasize[1]+1:end]),1)
+norm2(a::CachedVector) = sqrt(norm(paddeddata(a),2)^2 + norm(@view(a.array[a.datasize[1]+1:end]),2)^2)
+normInf(a::CachedVector) = max(norm(paddeddata(a),Inf), norm(@view(a.array[a.datasize[1]+1:end]),Inf))
+normp(a::CachedVector, p) = (norm(paddeddata(a),2)^p + norm(@view(a.array[a.datasize[1]+1:end]),2)^p)^inv(p)

src/lazyapplying.jl

@@ -26,7 +26,7 @@ arguments(a::AbstractArray) = arguments(MemoryLayout(typeof(a)), a)
 
 @inline check_applied_axes(A::Applied) = nothing
 
-function instantiate(A::Applied{Style}) where Style
+@inline function instantiate(A::Applied{Style}) where Style
     check_applied_axes(A)
     Applied{Style}(A.f, map(instantiate, A.args))
 end
@@ -45,28 +45,28 @@ end
 @inline apply(f, args...) = materialize(applied(f, args...))
 @inline apply!(f, args...) = materialize!(applied(f, args...))
 
-materialize(A::Applied) = copy(instantiate(A))
-materializeargs(A::Applied) = applied(A.f, materialize.(A.args)...)
+@inline materialize(A::Applied) = copy(instantiate(A))
+@inline materializeargs(A::Applied) = applied(A.f, materialize.(A.args)...)
 
 # the following materialzes the args and calls materialize again, unless it hasn't
 # changed in which case it falls back to the default
-_default_materialize(A::App, ::App) where App = A.f(A.args...)
-_default_materialize(A, _) = materialize(A)
+@inline _default_materialize(A::App, ::App) where App = A.f(A.args...)
+@inline _default_materialize(A, _) = materialize(A)
 # copy(A::Applied{DefaultApplyStyle}) = A.f(A.args...)
-copy(A::Applied) = _default_materialize(materializeargs(A), A)
+@inline copy(A::Applied) = _default_materialize(materializeargs(A), A)
 
 @inline copyto!(dest, M::Applied) = copyto!(dest, materialize(M))
 @inline copyto!(dest::AbstractArray, M::Applied) = copyto!(dest, materialize(M))
 
-broadcastable(M::Applied) = M
+@inline broadcastable(M::Applied) = M
 
 
 
 similar(M::Applied{<:AbstractArrayApplyStyle}, ::Type{T}, axes) where {T,N} = Array{T}(undef, length.(axes))
 similar(M::Applied{<:AbstractArrayApplyStyle}, ::Type{T}) where T = similar(M, T, axes(M))
 similar(M::Applied) = similar(M, eltype(M))
 
-axes(A::Applied, j) = axes(A)[j]
+@inline axes(A::Applied, j) = axes(A)[j]
 
 struct ApplyArrayBroadcastStyle{N} <: Broadcast.AbstractArrayStyle{N} end
 ApplyArrayBroadcastStyle{N}(::Val{N}) where N = ApplyArrayBroadcastStyle{N}()

src/lazyconcat.jl

@@ -289,14 +289,18 @@ BroadcastStyle(::Type{<:Hcat{<:Any}}) where N = LazyArrayStyle{2}()
 broadcasted(::LazyArrayStyle, op, A::Vcat) =
     Vcat(broadcast(x -> broadcast(op, x), A.args)...)
 
-broadcasted(::LazyArrayStyle, op, A::Vcat, c::Number) =
-    Vcat(broadcast((x,y) -> broadcast(op, x, y), A.args, c)...)
-broadcasted(::LazyArrayStyle, op, c::Number, A::Vcat) =
-    Vcat(broadcast((x,y) -> broadcast(op, x, y), c, A.args)...)
-broadcasted(::LazyArrayStyle, op, A::Vcat, c::Ref) =
-    Vcat(broadcast((x,y) -> broadcast(op, x, Ref(y)), A.args, c)...)
-broadcasted(::LazyArrayStyle, op, c::Ref, A::Vcat) =
-    Vcat(broadcast((x,y) -> broadcast(op, Ref(x), y), c, A.args)...)    
+for Cat in (:Vcat, :Hcat)    
+    @eval begin
+        broadcasted(::LazyArrayStyle, op, A::$Cat, c::Number) =
+            $Cat(broadcast((x,y) -> broadcast(op, x, y), A.args, c)...)
+        broadcasted(::LazyArrayStyle, op, c::Number, A::$Cat) =
+            $Cat(broadcast((x,y) -> broadcast(op, x, y), c, A.args)...)
+        broadcasted(::LazyArrayStyle, op, A::$Cat, c::Ref) =
+            $Cat(broadcast((x,y) -> broadcast(op, x, Ref(y)), A.args, c)...)
+        broadcasted(::LazyArrayStyle, op, c::Ref, A::$Cat) =
+            $Cat(broadcast((x,y) -> broadcast(op, Ref(x), y), c, A.args)...)    
+    end
+end
 
 
 # determine indices of components of a vcat
@@ -314,7 +318,7 @@ function broadcasted(::LazyArrayStyle, op, A::Vcat{<:Any,1}, B::AbstractVector)
     B_arrays = _vcat_getindex_eval(B,kr...)    # evaluate B at same chunks as A
     ApplyVector(vcat, broadcast((a,b) -> broadcast(op,a,b), A.args, B_arrays)...)
 end
-
+ 
 function broadcasted(::LazyArrayStyle, op, A::AbstractVector, B::Vcat{<:Any,1})
     kr = _vcat_axes(axes.(B.args)...)
     A_arrays = _vcat_getindex_eval(A,kr...)
@@ -325,6 +329,14 @@ end
 broadcasted(::LazyArrayStyle, op, A::Vcat{<:Any,1}, B::Vcat{<:Any,1}) =
     Broadcasted{LazyArrayStyle}(op, (A, B))
 
+# ambiguities
+broadcasted(::LazyArrayStyle, op, A::Vcat{<:Any,1}, B::CachedVector) = cache_broadcast(op, A, B)
+broadcasted(::LazyArrayStyle, op, A::CachedVector, B::Vcat{<:Any,1}) = cache_broadcast(op, A, B)
+
+broadcasted(::LazyArrayStyle{1}, ::typeof(*), a::Vcat{<:Any,1}, b::Zeros{<:Any,1})=
+    broadcast(DefaultArrayStyle{1}(), *, a, b)
+
+
 
 function +(A::Vcat, B::Vcat)
     size(A) == size(B) || throw(DimensionMismatch("dimensions must match."))
@@ -477,7 +489,7 @@ function materialize!(M::MatMulVecAdd{ApplyLayout{typeof(hcat)},ApplyLayout{type
  ####
 
 
- most(a) = reverse(tail(reverse(a)))
+most(a) = reverse(tail(reverse(a)))
 colsupport(M::Vcat, j) = first(colsupport(first(M.args),j)):(size(Vcat(most(M.args)...),1)+last(colsupport(last(M.args),j)))
 
 
@@ -556,6 +568,8 @@ end
 
 sublayout(::ApplyLayout{typeof(vcat)}, _) = ApplyLayout{typeof(vcat)}()
 sublayout(::ApplyLayout{typeof(hcat)}, _) = ApplyLayout{typeof(hcat)}()
+# a row-slice of an Hcat is equivalent to a Vcat
+sublayout(::ApplyLayout{typeof(hcat)}, ::Type{<:Tuple{Number,AbstractVector}}) = ApplyLayout{typeof(vcat)}()
 
 arguments(::ApplyLayout{typeof(vcat)}, V::SubArray{<:Any,2,<:Any,<:Tuple{<:Slice,<:Any}}) = 
     view.(arguments(parent(V)), Ref(:), Ref(parentindices(V)[2]))
@@ -575,14 +589,17 @@ _view_vcat(a::Number, kr) = Fill(a,length(kr))
 _view_vcat(a::Number, kr, jr) = Fill(a,length(kr), length(jr))
 _view_vcat(a, kr...) = view(a, kr...)
 
-function arguments(::ApplyLayout{typeof(vcat)}, V::SubArray{<:Any,1})
-    A = parent(V)
+function _vcat_sub_arguments(::ApplyLayout{typeof(vcat)}, A, V)
     kr = parentindices(V)[1]
     sz = size.(arguments(A),1)
     skr = intersect.(_argsindices(sz), Ref(kr))
     skr2 = broadcast((a,b) -> a .- b .+ 1, skr, _vcat_firstinds(sz))
     _view_vcat.(arguments(A), skr2)
 end
+_vcat_sub_arguments(::ApplyLayout{typeof(hcat)}, A, V) = arguments(ApplyLayout{typeof(hcat)}(), V)
+
+_vcat_sub_arguments(A, V) = _vcat_sub_arguments(MemoryLayout(typeof(A)), A, V)
+arguments(::ApplyLayout{typeof(vcat)}, V::SubArray{<:Any,1}) = _vcat_sub_arguments(parent(V), V)
 
 function arguments(::ApplyLayout{typeof(vcat)}, V::SubArray{<:Any,2})
     A = parent(V)
@@ -596,7 +613,7 @@ end
 _view_hcat(a::Number, kr, jr) = Fill(a,length(kr),length(jr))
 _view_hcat(a, kr, jr) = view(a, kr, jr)
 
-function arguments(::ApplyLayout{typeof(hcat)}, V::SubArray{<:Any,2})
+function arguments(::ApplyLayout{typeof(hcat)}, V::SubArray)
     A = parent(V)
     kr,jr = parentindices(V)
     sz = size.(arguments(A),2)
@@ -628,6 +645,7 @@ function sub_materialize(::ApplyLayout{typeof(hcat)}, V)
     end
     ret
 end
+
 # temporarily allocate. In the future, we add a loop over arguments
 materialize!(M::MatMulMatAdd{<:AbstractColumnMajor,<:ApplyLayout{typeof(vcat)}}) = 
     materialize!(MulAdd(M.α,M.A,Array(M.B),M.β,M.C))

test/concattests.jl

@@ -1,6 +1,6 @@
 using LazyArrays, FillArrays, LinearAlgebra, StaticArrays, Test
 import LazyArrays: MemoryLayout, DenseColumnMajor, PaddedLayout, materialize!, 
-                    MulAdd, Applied, ApplyLayout, arguments, DefaultApplyStyle
+                    MulAdd, Applied, ApplyLayout, arguments, DefaultApplyStyle, sub_materialize
 
 @testset "concat" begin
     @testset "Vcat" begin
@@ -303,7 +303,7 @@ import LazyArrays: MemoryLayout, DenseColumnMajor, PaddedLayout, materialize!,
         @test materialize!(MulAdd(1.1,A,B,2.2,[5.0 6; 7 8])) ≈ 1.1*Matrix(A)*Matrix(B)+2.2*[5.0 6; 7 8]
     end
 
-    @testset "broadcast Vcat" begin
+    @testset "broadcast" begin
         x = Vcat(1:2, [1,1,1,1,1], 3)
         y = 1:8
         f = (x,y) -> cos(x*y)
@@ -328,6 +328,13 @@ import LazyArrays: MemoryLayout, DenseColumnMajor, PaddedLayout, materialize!,
         @test Vcat(1, Ones(5))  + Vcat(2, Fill(2.0,5)) ≡ Vcat(3, Fill(3.0,5))
         @test Vcat(SVector(1,2,3), Ones(5))  + Vcat(SVector(4,5,6), Fill(2.0,5)) ≡
             Vcat(SVector(5,7,9), Fill(3.0,5))
+
+        H = Hcat(1, zeros(1,10))            
+        @test H/2 isa Hcat
+        @test 2\H isa Hcat
+        @test H./Ref(2) isa Hcat
+        @test Ref(2).\H isa Hcat
+        @test H/2  == H./Ref(2) == 2\H == Ref(2) .\ H == [1/2 zeros(1,10)]
     end
 
     @testset "maximum/minimum Vcat" begin
@@ -400,5 +407,10 @@ import LazyArrays: MemoryLayout, DenseColumnMajor, PaddedLayout, materialize!,
         @test MemoryLayout(typeof(V)) isa ApplyLayout{typeof(hcat)}
         VERSION ≥ v"1.1" && @inferred(arguments(V))
         @test arguments(V)[1] == reshape(3:5,3,1)
+
+        v = view(A,2,1:5)
+        @test MemoryLayout(typeof(v)) isa ApplyLayout{typeof(vcat)}
+        @test arguments(v) == ([2], zeros(4))
+        @test A[2,1:5] == copy(v) == sub_materialize(v)
     end
 end

test/runtests.jl

@@ -244,6 +244,18 @@ end
         @test isempty(v[4:0])
         v = CachedArray([1,2,3],Fill{Int}(1,1000))
         @test v[3:100] == [3; ones(97)]
+        @test norm(v) == norm(Array(v)) == norm(v,2)
+        @test norm(v,1) == norm(Array(v),1)
+        @test norm(v,Inf) == norm(Array(v),Inf)
+        @test norm(v,3) == norm(Array(v),3)
+    end
+
+    @testset "ambiguity broadcast" begin
+        c = cache(1:100)
+        v = Vcat([1,2,3],0:96)
+        z = Zeros(100)
+        @test v .+ c == c .+ v == Array(c) + Array(v)
+        @test z .+ c == c .+ z == Array(c)
     end
 end