cleaning

Author: vpuri3

src/LinearSolve.jl

@@ -6,13 +6,11 @@ end
 using ArrayInterfaceCore
 using RecursiveFactorization
 using Base: cache_dependencies, Bool
-import Base: eltype, adjoint, inv
 using LinearAlgebra
-using IterativeSolvers: Identity
 using SparseArrays
-using SciMLBase: AbstractLinearAlgorithm, DiffEqIdentity
-using SciMLOperators: AbstractSciMLOperator, IdentityOperator,
-                      InvertedOperator, ComposedOperator
+using SciMLBase: AbstractLinearAlgorithm
+using SciMLOperators
+using SciMLOperators: AbstractSciMLOperator, IdentityOperator
 using Setfield
 using UnPack
 using SuiteSparse
@@ -22,7 +20,6 @@ using FastLapackInterface
 using DocStringExtensions
 import GPUArraysCore
 import Preferences
-import SciMLOperators: issquare
 
 # wrap
 import Krylov
@@ -45,11 +42,12 @@ needs_concrete_A(alg::AbstractKrylovSubspaceMethod) = false
 needs_concrete_A(alg::AbstractSolveFunction) = false
 
 # Util
+
 _isidentity_struct(A) = false
 _isidentity_struct(λ::Number) = isone(λ)
 _isidentity_struct(A::UniformScaling) = isone(A.λ)
 _isidentity_struct(::IterativeSolvers.Identity) = true
-_isidentity_struct(::SciMLBase.IdentityOperator) = true
+_isidentity_struct(::SciMLOperators.IdentityOperator) = true
 _isidentity_struct(::SciMLBase.DiffEqIdentity) = true
 
 # Code

src/common.jl

@@ -1,12 +1,9 @@
 struct OperatorAssumptions{issq} end
-# TODO - in defaultalg selection, OperatorAssumptions{nothing} behaves
-#        exactly like OperatorAssumptions{true}. So let's remove the option to
-#        put in nothing.
 function OperatorAssumptions(issquare = nothing)
     issq = something(_unwrap_val(issquare), Nothing)
     OperatorAssumptions{issq}()
 end
-issquare(::OperatorAssumptions{issq}) where {issq} = issq
+SciMLOperators.issquare(::OperatorAssumptions{issq}) where {issq} = issq
 
 struct LinearCache{TA, Tb, Tu, Tp, Talg, Tc, Tl, Tr, Ttol, issq}
     A::TA
@@ -28,7 +25,6 @@ end
 """
 $(SIGNATURES)
 """
-# TODO - this should modify OperatorAssumption??
 function set_A(cache::LinearCache, A)
     @set! cache.A = A
     @set! cache.isfresh = true

src/factorization.jl

@@ -381,8 +381,6 @@ struct DiagonalFactorization <: AbstractFactorization end
 
 function init_cacheval(alg::DiagonalFactorization, A, b, u, Pl, Pr, maxiters::Int,
                        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
-    # TODO - DiagonalFactorization should preinvert, and mul!
-    #Diagonal(inv.(A.diag))
     nothing
 end
 

src/preconditioners.jl

@@ -1,11 +1,4 @@
 # Tooling Preconditioners
-#
-# TODO - update Preconditioner docs
-# TODO - replace ComposePreconditoner with ComposedOperator after
-#        ComposePreconditioner is deprecated in OrdinaryDiffEq
-
-#const ComposePreconditioner = ComposedOperator
-#@deprecate ComposePreconditioner ComposedOperator
 
 struct ComposePreconditioner{Ti, To}
     inner::Ti
@@ -27,6 +20,3 @@ function LinearAlgebra.ldiv!(y, A::ComposePreconditioner, x)
     ldiv!(y, inner, x)
     ldiv!(outer, y)
 end
-
-#const InvPreconditioner = InvertedOperator
-#@deprecate InvPreconditioner InvertedOperator

test/basictests.jl

@@ -1,4 +1,5 @@
 using LinearSolve, LinearAlgebra, SparseArrays, MultiFloats, ForwardDiff
+using SciMLOperators
 using Test
 import Random
 
@@ -271,17 +272,14 @@ end
 
     @testset "Preconditioners" begin
         @testset "Vector Diagonal Preconditioner" begin
-            using SciMLOperators
 
             x = rand(n, n)
             y = rand(n, n)
 
             s = rand(n)
-            Pl = Diagonal(s)
-            Pr = Diagonal(s)
-            Pr = LinearSolve.InvertedOperator(MatrixOperator(Pr))
+            Pl = Diagonal(s) |> MatrixOperator
+            Pr = Diagonal(s) |> MatrixOperator |> inv
             Pr = cache_operator(Pr, x)
-            #@test Pr == (@test_deprecated LinearSolve.InvPreconditioner(Diagonal(s)))
 
             mul!(y, Pl, x)
             @test y ≈ s .* x