UniformScaling, _broadcast_mul_mul with scalars (#75)

* _broadcast_mul_mul with scalars

* UniformScaling

* add tests

Author: dlfivefifty

Project.toml

@@ -1,7 +1,7 @@
 name = "QuasiArrays"
 uuid = "c4ea9172-b204-11e9-377d-29865faadc5c"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "0.7"
+version = "0.7.1"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

src/quasibroadcast.jl

@@ -175,9 +175,9 @@ BroadcastStyle(::Type{<:SubArray{T,N,P,I}}) where {T,N,P<:AbstractQuasiArray,I}
 
 # support (x .* D) * y
 __broadcast_mul_mul(::Val{false}, (a,B), C) = ApplyQuasiArray(*, a .* B, C)
-__broadcast_mul_mul(::Val{true}, (a,B)::Tuple{AbstractQuasiVector,AbstractQuasiMatrix}, C) = a .* (B*C)
+__broadcast_mul_mul(::Val{true}, (a,B)::Tuple{Union{AbstractQuasiVector,Number},AbstractQuasiMatrix}, C) = a .* (B*C)
 __broadcast_mul_mul(::Val{true}, (A,b)::Tuple{AbstractQuasiMatrix,AbstractQuasiVector}, C) = b .* (A*C)
-LazyArrays._broadcast_mul_mul((a,B)::Tuple{AbstractQuasiVector,AbstractQuasiMatrix}, C) = __broadcast_mul_mul(simplifiable(*, B, C), (a,B), C)
+LazyArrays._broadcast_mul_mul((a,B)::Tuple{Union{AbstractQuasiVector,Number},AbstractQuasiMatrix}, C) = __broadcast_mul_mul(simplifiable(*, B, C), (a,B), C)
 LazyArrays._broadcast_mul_mul((A,b)::Tuple{AbstractQuasiMatrix,AbstractQuasiVector}, C) = __broadcast_mul_mul(simplifiable(*, A, C), (A,b), C)
 
 

src/quasifill.jl

@@ -181,6 +181,15 @@ isone(::QuasiEye) = true
 @inline QuasiEye{T}(A::AbstractQuasiMatrix) where T = QuasiEye{T}(axes(A))
 @inline QuasiEye(A::AbstractQuasiMatrix) = QuasiEye{eltype(A)}(axes(A))
 
+quasiscaling(J, ax) = QuasiDiagonal(QuasiFill(J.λ, ax))
+
+for op in (:+, :-, :*, :/, :\)
+    @eval begin
+        $op(A::AbstractQuasiMatrix, J::UniformScaling) = $op(A, quasiscaling(J, axes(A,2)))
+        $op(J::UniformScaling, A::AbstractQuasiMatrix) = $op(quasiscaling(J, axes(A,1)), A)
+    end
+end
+
 
 #########
 #  Special matrix types

test/test_quasifill.jl

@@ -157,7 +157,7 @@ import QuasiArrays: AbstractQuasiFill
         @test A[[1,3],1] ≡ Ones{Int}(2)
         @test A[[1,3],[3,4]] ≡ Ones{Int}(2,2)
         @test_throws BoundsError A[1:26]
-        
+
         A = QuasiZeros{Int}(ax,ax)
         @test A[[1,3],1] ≡ Zeros{Int}(2)
         @test A[[1,3],[3,4]] ≡ Zeros{Int}(2,2)
@@ -297,7 +297,7 @@ import QuasiArrays: AbstractQuasiFill
         @test QuasiZeros(ax,bx) * A isa QuasiZeros
         @test B * QuasiZeros(bx,cx) isa QuasiZeros
         @test_throws DimensionMismatch B * QuasiZeros(ax, ax)
-        
+
         # Check multiplication by Adjoint vectors works as expected.
         @test QuasiArray(randn(3, 4),ax,bx)' * QuasiZeros(ax) === QuasiZeros(bx)
         @test QuasiArray(randn(4),bx)' * QuasiZeros(bx) == zero(Float64)
@@ -690,5 +690,18 @@ import QuasiArrays: AbstractQuasiFill
     @testset "Static eval" begin
         o = QuasiOnes([1,3,4])
         @test view(o,SVector(1,3)) ≡ o[SVector(1,3)] ≡ Ones((SOneTo(2),))
-    end 
+    end
+
+    @testset "UniformScaling" begin
+        A = QuasiArray(randn(3,3), 0:0.5:1,0:0.5:1)
+        @test A+2I ≈ 2I+A ≈ QuasiArray(A.parent+2I, 0:0.5:1,0:0.5:1)
+        @test A-2I ≈ -(2I-A) ≈ QuasiArray(A.parent-2I, 0:0.5:1,0:0.5:1)
+        @test A*(2I) ≈ (2I)*A ≈ 2A
+        @test A/(2I) ≈ (2I)\A ≈ A/2
+
+        B = QuasiArray(randn(3,3), 0:0.5:1,1:0.5:2)
+        @test_throws DimensionMismatch B+I
+        @test_throws DimensionMismatch I+B
+        @test B*I ≈ I*B ≈ B
+    end
 end