A \ ( c .* B) == c .* (A\B) (#101)

* A \ ( c .* B) == c .* (A\B)

* add tests

* Update runtests.jl

* InfniteArrays v0.11

* Update runtests.jl

* Update runtests.jl

Project.toml

@@ -1,6 +1,6 @@
 name = "ContinuumArrays"
 uuid = "7ae1f121-cc2c-504b-ac30-9b923412ae5c"
-version = "0.8.1"
+version = "0.8.2"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

src/ContinuumArrays.jl

@@ -13,7 +13,7 @@ import LinearAlgebra: pinv, dot, norm2
 import BandedMatrices: AbstractBandedLayout, _BandedMatrix
 import BlockArrays: block, blockindex, unblock, blockedrange, _BlockedUnitRange, _BlockArray
 import FillArrays: AbstractFill, getindex_value, SquareEye
-import ArrayLayouts: mul
+import ArrayLayouts: mul, ZerosLayout, ScalarLayout
 import QuasiArrays: cardinality, checkindex, QuasiAdjoint, QuasiTranspose, Inclusion, SubQuasiArray,
                     QuasiDiagonal, MulQuasiArray, MulQuasiMatrix, MulQuasiVector, QuasiMatMulMat,
                     ApplyQuasiArray, ApplyQuasiMatrix, LazyQuasiArrayApplyStyle, AbstractQuasiArrayApplyStyle, AbstractQuasiLazyLayout,

src/bases/bases.jl

@@ -115,6 +115,13 @@ end
     A \ ab
 end
 
+function _broadcast_mul_ldiv(::Tuple{ScalarLayout,Any}, A, B)
+    a,b = arguments(B)
+    a * (A \ b)
+end
+
+_broadcast_mul_ldiv(::Tuple{ScalarLayout,AbstractBasisLayout}, A, B) =
+    _broadcast_mul_ldiv((ScalarLayout(),UnknownLayout()), A, B)
 _broadcast_mul_ldiv(_, A, B) = copy(Ldiv{typeof(MemoryLayout(A)),UnknownLayout}(A,B))
 
 copy(L::Ldiv{<:AbstractBasisLayout,BroadcastLayout{typeof(*)}}) = _broadcast_mul_ldiv(map(MemoryLayout,arguments(L.B)), L.A, L.B)
@@ -200,14 +207,15 @@ function _factorize(::MappedBasisLayout, L)
     MappedFactorization(factorize(view(P,:,jr)), invmap(parentindices(L)[1]))
 end
 
-transform_ldiv(A, B, _) = factorize(A) \ B
+transform_ldiv(A::AbstractQuasiArray{T}, B::AbstractQuasiArray{V}, _) where {T,V} = factorize(convert(AbstractQuasiArray{promote_type(T,V)}, A)) \ B
 transform_ldiv(A, B) = transform_ldiv(A, B, size(A))
 
 copy(L::Ldiv{<:AbstractBasisLayout}) = transform_ldiv(L.A, L.B)
 # TODO: redesign to use simplifiable(\, A, B)
 copy(L::Ldiv{<:AbstractBasisLayout,ApplyLayout{typeof(*)},<:Any,<:AbstractQuasiVector}) = transform_ldiv(L.A, L.B)
 copy(L::Ldiv{<:AbstractBasisLayout,ApplyLayout{typeof(*)}}) = copy(Ldiv{UnknownLayout,ApplyLayout{typeof(*)}}(L.A, L.B))
 copy(L::Ldiv{<:AbstractBasisLayout,<:AbstractLazyLayout}) = transform_ldiv(L.A, L.B)
+copy(L::Ldiv{<:AbstractBasisLayout,ZerosLayout}) = Zeros{eltype(L)}(axes(L)...)
 
 struct WeightedFactorization{T, WW, FAC<:Factorization{T}} <: Factorization{T}
     w::WW

test/runtests.jl

@@ -334,6 +334,8 @@ end
             x = axes(L,1)
             @test L[0.123,:]'* (L \ exp.(x)) ≈ exp(0.123) atol=1E-9
             @test L[0.123,2:end-1]'* (L[:,2:end-1] \ exp.(x)) ≈ exp(0.123) atol=1E-9
+
+            @test L \ zeros(x) ≡ Zeros(10_000)
         end
     end
 
@@ -470,6 +472,11 @@ end
     @test_throws BoundsError K[Inclusion(0..0.5), Inclusion(0..0.5)][1,1]
 end
 
+@testset "A \\ ( c .* B) == c .* (A\\B) #101" begin
+    L = LinearSpline(0:5)
+    @test L \ (2L) == 2(L\L)
+end
+
 """
 This is a simple implementation of Chebyshev for testing. Use ClassicalOrthogonalPolynomials
 for the real implementation.