Remove allocating methods on MatrixOperators

Author: albertomercurio

src/basic.jl

@@ -243,9 +243,11 @@ end
 
 # constructors
 for T in SCALINGNUMBERTYPES[2:end]
-    @eval ScaledOperator(λ::$T, L::AbstractSciMLOperator) = ScaledOperator(
-        ScalarOperator(λ),
-        L)
+    @eval function ScaledOperator(λ::$T, L::AbstractSciMLOperator)
+        T2 = Base.promote_eltype(λ, L)
+        Λ = λ isa UniformScaling ? UniformScaling(T2(λ.λ)) : T2(λ)
+        ScaledOperator(ScalarOperator(Λ), L)
+    end
 end
 
 for T in SCALINGNUMBERTYPES
@@ -276,28 +278,16 @@ for T in SCALINGNUMBERTYPES[2:end]
         isconstant(L.λ) && return ScaledOperator(α * L.λ, L.L)
         return ScaledOperator(L.λ, α * L.L) # Try to propagate the rule
     end
-    @eval function Base.:*(α::$T, L::MatrixOperator)
-        isconstant(L) && return MatrixOperator(α * L.A)
-        return ScaledOperator(α, L) # Going back to the generic case
-    end
-    @eval function Base.:*(L::MatrixOperator, α::$T)
-        isconstant(L) && return MatrixOperator(α * L.A)
-        return ScaledOperator(α, L) # Going back to the generic case
-    end
 end
 
 Base.:+(L::AbstractSciMLOperator) = L
-Base.:-(L::AbstractSciMLOperator) = ScaledOperator(-true, L)
+Base.:-(L::AbstractSciMLOperator{T}) where T = ScaledOperator(-one(T), L)
 
 # Special cases for constant scalars. These simplify the structure when applicable
 function Base.:-(L::ScaledOperator)
     isconstant(L.λ) && return ScaledOperator(-L.λ, L.L)
     return ScaledOperator(L.λ, -L.L) # Try to propagate the rule
 end
-function Base.:-(L::MatrixOperator)
-    isconstant(L) && return MatrixOperator(-L.A)
-    return ScaledOperator(-true, L) # Going back to the generic case
-end
 
 function Base.convert(::Type{AbstractMatrix}, L::ScaledOperator)
     convert(Number, L.λ) * convert(AbstractMatrix, L.L)

test/basic.jl

@@ -150,24 +150,9 @@ end
 
     # Test unary - on constant MatrixOperator (simplified to MatrixOperator)
     minusA = -A
-    @test minusA isa MatrixOperator
+    @test minusA isa ScaledOperator
     @test minusA * v ≈ -A.A * v
-    
-    # Test unary - on non-constant MatrixOperator (falls back to ScaledOperator)
-    func(A, u, p, t) = t
-    timeDepA = MatrixOperator(A.A; update_func = func)
-    minusTimeDepA = -timeDepA
-    @test minusTimeDepA isa ScaledOperator  # Can't simplify, uses generic fallback
-    
-    # Test unary - on non-constant ScaledOperator (propagates to inner operator)
-    timeDepScaled = ScalarOperator(0.0, func) * A
-    @test !isconstant(timeDepScaled)
-    minusTimeDepScaled = -timeDepScaled
-    @test minusTimeDepScaled.λ isa ScalarOperator && minusTimeDepScaled.L isa MatrixOperator # Propagates negation to inner MatrixOperator
-    
-    # Test double negation
-    @test -(-A) isa MatrixOperator
-    @test (-(-A)) * v ≈ A * v
+    @test eltype(minusA.λ) == eltype(A.A)
 end
 
 @testset "ScaledOperator" begin