Support ApplyArray{typeof(-)} and views of ApplyArray{typeof(±)} (#70)

* Support - just like Add

* Update add.jl

* Support views of Add/Subtract

* comment out copyto!

* restore

Author: dlfivefifty

src/lazyapplying.jl

@@ -16,6 +16,8 @@ end
 @inline Applied{Style}(f::F, args::Args) where {Style,F,Args<:Tuple} = Applied{Style,F,Args}(f, args)
 @inline Applied{Style}(A::Applied) where Style = Applied{Style}(A.f, A.args)
 
+arguments(a) = a.args
+
 @inline check_applied_axes(A::Applied) = nothing
 
 function instantiate(A::Applied{Style}) where Style

src/linalg/add.jl

@@ -6,17 +6,6 @@
 
 const Add{Factors<:Tuple} = Applied{<:Any, typeof(+), Factors}
 
-size(M::Add, p::Int) = size(M)[p]
-axes(M::Add, p::Int) = axes(M)[p]
-ndims(M::Add) = ndims(first(M.args))
-
-length(M::Add) = prod(size(M))
-size(M::Add) = length.(axes(M))
-axes(M::Add) = axes(first(M.args))
-
-
-eltype(M::Add) = promote_type(map(eltype,M.args)...)
-
 const AddArray{T,N,Factors<:Tuple} = ApplyArray{T,N,typeof(+), Factors}
 const AddVector{T,Factors<:Tuple} = AddArray{T,1,Factors}
 const AddMatrix{T,Factors<:Tuple} = AddArray{T,2,Factors}
@@ -31,8 +20,27 @@ A lazy representation of `A1 + A2 + … + AN`; i.e., a shorthand for `applied(+,
 Add(As...) = applied(+, As...)
 
 
+
+for op in (:+, :-)
+    @eval begin
+        size(M::Applied{<:Any, typeof($op)}, p::Int) = size(M)[p]
+        axes(M::Applied{<:Any, typeof($op)}, p::Int) = axes(M)[p]
+        ndims(M::Applied{<:Any, typeof($op)}) = ndims(first(M.args))
+
+        length(M::Applied{<:Any, typeof($op)}) = prod(size(M))
+        size(M::Applied{<:Any, typeof($op)}) = length.(axes(M))
+        axes(M::Applied{<:Any, typeof($op)}) = axes(first(M.args))
+
+        eltype(M::Applied{<:Any, typeof($op)}) = promote_type(map(eltype,M.args)...)
+
+        combine_mul_styles(::ApplyLayout{typeof($op)}) = IdentityMulStyle()
+    end
+end
+
+
 getindex(M::Add, k::Integer) = sum(getindex.(M.args, k))
 getindex(M::Add, k::Integer, j::Integer) = sum(getindex.(M.args, k, j))
+
 getindex(M::Add, k::CartesianIndex{1}) = M[convert(Int, k)]
 getindex(M::Add, kj::CartesianIndex{2}) = M[kj[1], kj[2]]
 
@@ -45,19 +53,44 @@ function zero!(A::AbstractArray{<:AbstractArray})
 end
 
 _fill_lmul!(β, A::AbstractArray{T}) where T = iszero(β) ? zero!(A) : lmul!(β, A)
-combine_mul_styles(::ApplyLayout{typeof(+)}) = IdentityMulStyle()
 for MulAdd_ in [MatMulMatAdd, MatMulVecAdd]
     # `MulAdd{ApplyLayout{typeof(+)}}` cannot "win" against
     # `MatMulMatAdd` and `MatMulVecAdd` hence `@eval`:
-    @eval function materialize!(M::$MulAdd_{ApplyLayout{typeof(+)}})
-        α, A, B, β, C = M.α, M.A, M.B, M.β, M.C
-        if C ≡ B
-            B = copy(B)
+    @eval begin
+        function materialize!(M::$MulAdd_{ApplyLayout{typeof(+)}})
+            α, A, B, β, C = M.α, M.A, M.B, M.β, M.C
+            if C ≡ B
+                B = copy(B)
+            end
+            _fill_lmul!(β, C)
+            for A in arguments(A)
+                C .= applied(+,applied(*,α, A,B), C)
+            end
+            C
         end
-        _fill_lmul!(β, C)
-        for A in Applied(A).args
-            C .= applied(+,applied(*,α, A,B), C)
+        function materialize!(M::$MulAdd_{ApplyLayout{typeof(-)}})
+            α, A, B, β, C = M.α, M.A, M.B, M.β, M.C
+            if C ≡ B
+                B = copy(B)
+            end
+            _fill_lmul!(β, C)
+            a1,a2 = arguments(A)
+            C .= applied(+,applied(*,α, a1,B), C)
+            C .= applied(+,applied(*,-α, a2,B), C)
+            C
         end
-        C
     end
 end
+
+
+### 
+# views
+####
+_view(a, b::Tuple) = view(a, b...)
+for op in (:+, :-)
+    @eval begin
+        subarraylayout(a::ApplyLayout{typeof($op)}, _) = a
+        arguments(a::SubArray{<:Any,N,<:ApplyArray{<:Any,N,typeof($op)}}) where N =
+            _view.(arguments(parent(a)), Ref(parentindices(a)))
+    end
+end