sciml / linearsolve.jl

LinearSolve.jl: High-Performance Unified Interface for Linear Solvers in Julia. Easily switch between factorization and Krylov methods, add preconditioners, and all in one interface.

LinearSolve.jl

Fast implementations of linear solving algorithms in Julia that satisfy the SciML common interface. LinearSolve.jl makes it easy to define high level algorithms which allow for swapping out the linear solver that is used while maintaining maximum efficiency. Specifically, LinearSolve.jl includes:

• Fast pure Julia LU factorizations which outperform standard BLAS
• KLU for faster sparse LU factorization on unstructured matrices
• UMFPACK for faster sparse LU factorization on matrices with some repeated structure
• MKLPardiso wrappers for handling many sparse matrices faster than SuiteSparse (KLU, UMFPACK) methods
• Sparspak.jl for sparse LU factorization in pure Julia for generic number types and for non-GPL distributions
• GPU-offloading for large dense matrices
• Wrappers to all of the Krylov implementations (Krylov.jl, IterativeSolvers.jl, KrylovKit.jl) for easy testing of all of them. LinearSolve.jl handles the API differences, especially with the preconditioner definitions
• A polyalgorithm that smartly chooses between these methods
• A caching interface which automates caching of symbolic factorizations and numerical factorizations as optimally as possible

For information on using the package, see the stable documentation. Use the in-development documentation for the version of the documentation which contains the unreleased features.

High Level Examples

n = 4
A = rand(n, n)
b1 = rand(n);
b2 = rand(n);
prob = LinearProblem(A, b1)

linsolve = init(prob)
sol1 = solve(linsolve)

sol1.u
#=
4-element Vector{Float64}:
 -0.9247817429364165
 -0.0972021708185121
  0.6839050402960025
  1.8385599677530706
=#

linsolve = LinearSolve.set_b(linsolve, b2)
sol2 = solve(linsolve)

sol2.u
#=
4-element Vector{Float64}:
  1.0321556637762768
  0.49724400693338083
 -1.1696540870182406
 -0.4998342686003478
=#

linsolve = LinearSolve.set_b(linsolve, b2)
sol2 = solve(linsolve, IterativeSolversJL_GMRES()) # Switch to GMRES
sol2.u
#=
4-element Vector{Float64}:
  1.0321556637762768
  0.49724400693338083
 -1.1696540870182406
 -0.4998342686003478
=#

A2 = rand(n, n)
linsolve = LinearSolve.set_A(linsolve, A2)
sol3 = solve(linsolve)

sol3.u
#=
4-element Vector{Float64}:
 -6.793605395935224
  2.8673042300837466
  1.1665136934977371
 -0.4097250749016653
=#

linearsolve.jl's Issues

Fix common argument handling

Common arguments should be handled as kwargs in init/solve, not in the algorithm.

https://diffeq.sciml.ai/stable/basics/common_solver_opts/

reltol, abstol, verbose are ones I've seen that need to get moved.

@vpuri3

Pardiso wrappers

Uses https://github.com/JuliaSparse/Pardiso.jl . Starter code:

https://github.com/SciML/DiffEqBase.jl/blob/master/src/init.jl#L265-L378

b expects matrix as opposed to vector

MWE:

A = rand(3,10)
b = rand(3,1)
prob = LinearProblem(A*A',b)
linsolve = init(prob)
solve(linsolve)

ERROR: BoundsError
Stacktrace:
  [1] _copyto_impl!(dest::Vector{Float64}, doffs::Int64, src::Vector{Float64}, soffs::Int64, n::Int64)
    @ Base ./array.jl:329
  [2] copyto!
    @ ./array.jl:322 [inlined]
  [3] copyto!
    @ ./array.jl:346 [inlined]
  [4] _ldiv!
    @ ~/.julia/packages/LinearSolve/7vwOr/src/factorization.jl:4 [inlined]
  [5] #solve#6
    @ ~/.julia/packages/LinearSolve/7vwOr/src/factorization.jl:14 [inlined]
  [6] solve
    @ ~/.julia/packages/LinearSolve/7vwOr/src/factorization.jl:10 [inlined]
  [7] solve(::LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LU{Float64, Matrix{Float64}}, IterativeSolvers.Identity, IterativeSolvers.Identity, Float64}, ::Nothing; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ LinearSolve ~/.julia/packages/LinearSolve/7vwOr/src/default.jl:70
  [8] solve
    @ ~/.julia/packages/LinearSolve/7vwOr/src/default.jl:56 [inlined]
  [9] #solve#5
    @ ~/.julia/packages/LinearSolve/7vwOr/src/common.jl:137 [inlined]
 [10] solve(::LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LU{Float64, Matrix{Float64}}, IterativeSolvers.Identity, IterativeSolvers.Identity, Float64})
    @ LinearSolve ~/.julia/packages/LinearSolve/7vwOr/src/common.jl:137
 [11] top-level scope
    @ ~/ARPAESurrogate3.jl/src/using OrdinaryDiffEq.jl:122

Change b = rand(3,) and it errors

HSL.jl wrapper

https://github.com/JuliaSmoothOptimizers/HSL.jl

Branch of `SciMLBase.has_ldiv` in `defaultalg`

in default alg branch on

if SciMLBase.has_ldiv!(A)
    # do ldiv!(u, A, b) via solve_function
elseif SciMLBase.has_ldiv(A)
    # do u .= A \ b via solve_function
end

Nonsquare Matrices throw Bounds Error

It seems like LinearSolve can not handle non-square matrices. A MWE would be

using LinearAlgebra
using LinearSolve

A = randn(8, 10)
x = randn(10)
b = A*x

ldiv!(x, svd(A), b) # works

prob = LinearProblem(A, b[:,1])
sol = solve(prob, SVDFactorization()) # Bounds error

This is repeatable for at least QR and LU.

RecursiveFactorizationLU

Uses https://github.com/YingboMa/RecursiveFactorization.jl

Fully non-dynamic linear solver

mutable struct LUFactorize{T}
  A::LU{T,Matrix{T}}
end
LUFactorize() = LUFactorize(lu(rand(1,1)))
function (p::LUFactorize)(x,A,b,update_matrix=false;kwargs...)
    if ArrayInterface.can_setindex(x) && (size(A,1) <= 100 || ((blasvendor === :openblas || blasvendor === :openblas64) && size(A,1) <= 500))
      p.A = RecursiveFactorization.lu!(A)
    else
      p.A = lu!(A)
    end
    ldiv!(x,p.A,b)  
end
function (p::LUFactorize)(::Type{Val{:init}},f,u0_prototype)
  LUFactorize(lu(rand(eltype(u0_prototype),1,1)))
end
Base.resize!(p::LUFactorize,i) = p.A = nothing

@btime solve(prob,Rodas5(linsolve=LUFactorize()),reltol=1.0e-8,abstol=1.0e-8, saveat = 1000)

Krylov.jl wrappers

https://github.com/JuliaSmoothOptimizers/Krylov.jl

Automatic GPU Offloading Mode

SciML/AutoOffload.jl#8

For large enough matrices it can be beneficial to offload to the GPU for the factorization and then retrieve it on demand.

mutable struct LinSolveGPUFactorize{F,T}
  factorization::F
  A
  x_cache::T
end
LinSolveGPUFactorize(factorization=qr) = LinSolveGPUFactorize(factorization,nothing,nothing)
function (p::LinSolveGPUFactorize)(x,A,b,update_matrix=false;kwargs...)
  if update_matrix
    p.A = p.factorization(cuify(A))
  end
  ldiv!(p.x_cache,p.A,cuify(b))
  x .= Array(p.x_cache)
end
function (p::LinSolveGPUFactorize)(::Type{Val{:init}},f,u0_prototype)
  LinSolveGPUFactorize(p.factorization,nothing,cuify(u0_prototype))
end
Base.resize!(p::LinSolveGPUFactorize,i) = p.A = nothing

Link to stable documentation in README is dead

In README.md see the stable documentation points to https://linearsolve.sciml.ai/stable/ but that page doesn't exist

Use FastLapackInterface.jl tooling

In Base.LinearAlgebra, the Lapack routines are always called twice, once for computing the necessary workspace and once for executing the function. In FastLapackInterface.jl, I introduce a specialized type for each factorization (LU, Cholesky, QR and Schur) that contains all necessary intermediary matrices and a function that execute the algorithm with preallocated space.

https://git.dynare.org/DynareJulia/FastLapackInterface.jl

Seems like that would be useful to use here since it would match our pre-caching interface.

@MichelJuillard

Hypre/BoomerAMG wrapper?

https://github.com/hypre-space/hypre

In particular, BoomerAMG only needs a general sparse matrix, without extra physical knowledge.

Trilinos solver wrappers

Some exist as jlls but not in Trilinos.jl. The newest ones do not.

unused function

LinearSolve.jl/src/default.jl

Line 4 in 29f41e7

function defaultalg(A,b)

[vp@MBP LinearSolve]:ls -l                                                                
total 64                                                                                  
-rw-r--r--   1 vp  staff   1175 Apr  1 11:19 LICENSE                                      
-rw-r--r--   1 vp  staff  17894 Apr  1 11:50 Manifest.toml                                
-rw-r--r--   1 vp  staff   1504 Apr  1 11:50 Project.toml                                 
-rw-r--r--   1 vp  staff   1914 Apr  1 11:19 README.md                                    
drwxr-xr-x   5 vp  staff    160 Apr  1 11:19 docs                                         
drwxr-xr-x  16 vp  staff    512 Apr  1 12:20 src                                          
drwxr-xr-x   6 vp  staff    192 Apr  1 11:19 test                                         
[vp@MBP LinearSolve]:grep -IRni defaultalg .                                              
./src/default.jl:4:function defaultalg(A,b)

Register

@JuliaRegistrator register()

SUPERLU_DIST Wrapper

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Pardiso wrapper

https://github.com/JuliaSparse/Pardiso.jl

Wrap AlgebraicMultigrid.jl

https://github.com/JuliaLinearAlgebra/AlgebraicMultigrid.jl

IterativeSolvers BICGSTBL and MINRES fail

Error During Test at C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:93
  Got exception outside of a @test
  MethodError: no method matching bicgstabl_iterator!(::Vector{Float64}, ::DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, ::Vector{Float64}, ::Bool, ::Float64, ::Float64, ::Int64, ::Int64; Pl=IterativeSolvers.Identity(), abstol=1.4901161193847656e-8, reltol=1.4901161193847656e-8, max_mv_products=16)
  Closest candidates are:
    bicgstabl_iterator!(::Any, ::Any, ::Any) at C:\Users\accou\.julia\packages\IterativeSolvers\rhYBz\src\bicgstabl.jl:27 got unsupported keyword arguments "Pl", "abstol", "reltol", "max_mv_products"
    bicgstabl_iterator!(::Any, ::Any, ::Any, ::Int64; Pl, max_mv_products, abstol, reltol, initial_zero) at C:\Users\accou\.julia\packages\IterativeSolvers\rhYBz\src\bicgstabl.jl:27
  Stacktrace:
    [1] init_cacheval(alg::IterativeSolversJL{typeof(IterativeSolvers.bicgstabl_iterator!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, A::DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, b::Vector{Float64}, u::Vector{Float64})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\wrappers.jl:236
    [2] init(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.bicgstabl_iterator!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}};
alias_A::Bool, alias_b::Bool, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:53
    [3] init(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.bicgstabl_iterator!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:49
    [4] solve(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.bicgstabl_iterator!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}; kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:87
    [5] solve(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.bicgstabl_iterator!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:87
    [6] test_interface(alg::IterativeSolversJL{typeof(IterativeSolvers.bicgstabl_iterator!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, prob1::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, prob2::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
      @ Main C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:18
    [7] macro expansion
      @ C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:94 [inlined]
    [8] macro expansion
      @ C:\buildbot\worker\package_win64\build\usr\share\julia\stdlib\v1.6\Test\src\Test.jl:1151 [inlined]
    [9] macro expansion
      @ C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:94 [inlined]
   [10] macro expansion
      @ C:\buildbot\worker\package_win64\build\usr\share\julia\stdlib\v1.6\Test\src\Test.jl:1151 [inlined]
   [11] top-level scope
      @ C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:84
   [12] eval
      @ .\boot.jl:360 [inlined]
   [13] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)
      @ Base .\loading.jl:1116
   [14] include_string
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\utils.jl:286 [inlined]
   [15] (::Atom.var"#202#207"{String, Int64, String, Module, Bool})()
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:121
   [16] withpath(f::Atom.var"#202#207"{String, Int64, String, Module, Bool}, path::String)
      @ CodeTools C:\Users\accou\.julia\packages\CodeTools\VsjEq\src\utils.jl:30
   [17] withpath(f::Function, path::String)
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:9
   [18] (::Atom.var"#201#206"{String, Int64, String, Module, Bool})()
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:119
   [19] with_logstate(f::Function, logstate::Any)
      @ Base.CoreLogging .\logging.jl:491
   [20] with_logger
      @ .\logging.jl:603 [inlined]
   [21] #200
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:118 [inlined]
   [22] hideprompt(f::Atom.var"#200#205"{String, Int64, String, Module, Bool})
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\repl.jl:127
   [23] macro expansion
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:117 [inlined]
   [24] macro expansion
      @ C:\Users\accou\.julia\packages\Media\ItEPc\src\dynamic.jl:24 [inlined]
   [25] eval(text::String, line::Int64, path::String, mod::String, errorinrepl::Bool)
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:114
   [26] invokelatest(::Any, ::Any, ::Vararg{Any, N} where N; kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
      @ Base .\essentials.jl:708
   [27] invokelatest(::Any, ::Any, ::Vararg{Any, N} where N)
      @ Base .\essentials.jl:706
   [28] macro expansion
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:41 [inlined]
   [29] (::Atom.var"#184#185")()
      @ Atom .\task.jl:411

MINRES: Error During Test at C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:93
  Got exception outside of a @test
  MethodError: no method matching minres_iterable!(::Vector{Float64}, ::DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, ::Vector{Float64}, ::Bool, ::Float64, ::Float64, ::Int64, ::Int64; abstol=1.4901161193847656e-8, reltol=1.4901161193847656e-8, maxiter=8)
  Closest candidates are:
    minres_iterable!(::Any, ::Any, ::Any; initially_zero, skew_hermitian, abstol, reltol, maxiter) at C:\Users\accou\.julia\packages\IterativeSolvers\rhYBz\src\minres.jl:39
  Stacktrace:
    [1] init_cacheval(alg::IterativeSolversJL{typeof(IterativeSolvers.minres_iterable!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool,
Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, A::DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, b::Vector{Float64}, u::Vector{Float64})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\wrappers.jl:241
    [2] init(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.minres_iterable!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}; alias_A::Bool, alias_b::Bool, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:53
    [3] init(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.minres_iterable!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:49
    [4] solve(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.minres_iterable!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}; kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:87
    [5] solve(::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, ::IterativeSolversJL{typeof(IterativeSolvers.minres_iterable!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
      @ LinearSolve C:\Users\accou\.julia\dev\LinearSolve\src\common.jl:87
    [6] test_interface(alg::IterativeSolversJL{typeof(IterativeSolvers.minres_iterable!), IterativeSolvers.Identity, IterativeSolvers.Identity, Float64, Int64, Tuple{Bool, Float64, Float64, Int64, Int64}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, prob1::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, prob2::LinearProblem{Vector{Float64}, true, DiffEqArrayOperator{Float64, Matrix{Float64}, typeof(SciMLBase.DEFAULT_UPDATE_FUNC)}, Vector{Float64}, SciMLBase.NullParameters, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
      @ Main C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:18
    [7] macro expansion
      @ C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:94 [inlined]
    [8] macro expansion
      @ C:\buildbot\worker\package_win64\build\usr\share\julia\stdlib\v1.6\Test\src\Test.jl:1151 [inlined]
    [9] macro expansion
      @ C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:94 [inlined]
   [10] macro expansion
      @ C:\buildbot\worker\package_win64\build\usr\share\julia\stdlib\v1.6\Test\src\Test.jl:1151 [inlined]
   [11] top-level scope
      @ C:\Users\accou\.julia\dev\LinearSolve\test\runtests.jl:84
   [12] eval
      @ .\boot.jl:360 [inlined]
   [13] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)
      @ Base .\loading.jl:1116
   [14] include_string
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\utils.jl:286 [inlined]
   [15] (::Atom.var"#202#207"{String, Int64, String, Module, Bool})()
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:121
   [16] withpath(f::Atom.var"#202#207"{String, Int64, String, Module, Bool}, path::String)
      @ CodeTools C:\Users\accou\.julia\packages\CodeTools\VsjEq\src\utils.jl:30
   [17] withpath(f::Function, path::String)
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:9
   [18] (::Atom.var"#201#206"{String, Int64, String, Module, Bool})()
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:119
   [19] with_logstate(f::Function, logstate::Any)
      @ Base.CoreLogging .\logging.jl:491
   [20] with_logger
      @ .\logging.jl:603 [inlined]
   [21] #200
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:118 [inlined]
   [22] hideprompt(f::Atom.var"#200#205"{String, Int64, String, Module, Bool})
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\repl.jl:127
   [23] macro expansion
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:117 [inlined]
   [24] macro expansion
      @ C:\Users\accou\.julia\packages\Media\ItEPc\src\dynamic.jl:24 [inlined]
   [25] eval(text::String, line::Int64, path::String, mod::String, errorinrepl::Bool)
      @ Atom C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:114
   [26] invokelatest(::Any, ::Any, ::Vararg{Any, N} where N; kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
      @ Base .\essentials.jl:708
   [27] invokelatest(::Any, ::Any, ::Vararg{Any, N} where N)
      @ Base .\essentials.jl:706
   [28] macro expansion
      @ C:\Users\accou\.julia\packages\Atom\bfwsW\src\eval.jl:41 [inlined]
   [29] (::Atom.var"#184#185")()
      @ Atom .\task.jl:411

AMGCL wrapper?

https://github.com/ddemidov/amgcl

Has OpenMP/MPI/CUDA implementations, similar to Hypre but much more lightweight. Already has a Python interface (see test)

PETSc wrappers

https://github.com/JuliaParallel/PETSc.jl

The LinearSolve.jl interface

• LinearProblem(A,b,p=SciMLBase.NullParameters();u0=nothing,kwargs...) where kwargs forward to solve
• ShiftedLinearProblem(A,b,gamma,p=SciMLBase.NullParameters();u0=nothing,kwargs...) = LinearProblem(WOperator,...)
• solve(prob,alg;reltol, abstol, weights, prec)
• cache = init(prob,alg; kwargs...) where solve = init -> solve!(cache)
• Functions on cache:
  • set_A!(cache,A)
  • set_b!(cache,b)
  • set_p!(cache,p)
  • set_prec(cache,prec)
  • update_prec!(cache) = set_prec!(cache,cache.prec(cache)...)`
• The cache should have fields A, cacheval, isfresh, pr, and pl
• The factorization alg should just have the factorization function
• IterativeSolversAlg should set the iterable to cacheval, factorization methods should store the factorized A there.
• Preconditioner functions:
  • @set cache.prec = f(Val{:init}, cache) for initialization
  • preconditioner function is f(cache) -> (pl,pr) user-defined.

Linear.pdf

error with 1.8beta3

[vp@MBP t]:jl                                                                                               [53/1491]
               _                                                                                                     
   _       _ _(_)_     |  Documentation: https://docs.julialang.org                                                  
  (_)     | (_) (_)    |                                                                                             
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.                                                      
  | | | | | | |/ _` |  |                                                                                             
  | | |_| | | | (_| |  |  Version 1.8.0-beta3 (2022-03-29)                                                           
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release                                                    
|__/                   |                                                                                             
                                                                                                                     
julia> versioninfo()                                                                                                 
Julia Version 1.8.0-beta3                                                                                            
Commit 3e092a2521 (2022-03-29 15:42 UTC)                                                                             
Platform Info:                                                                                                       
  OS: macOS (x86_64-apple-darwin18.7.0)                                                                              
  CPU: 4 × Intel(R) Core(TM) i5-5257U CPU @ 2.70GHz                                                                  
  WORD_SIZE: 64                                                                                                      
  LIBM: libopenlibm                                                                                                  
  LLVM: libLLVM-13.0.1 (ORCJIT, broadwell)                                                                           
  Threads: 4 on 4 virtual cores                                                                                      
Environment:                                                                                                         
  JULIA_NUM_PRECOMPILE_TASKS = 4                                                                                     
  JULIA_DEPOT_PATH = /Users/vp/.julia                                                                                
  JULIA_NUM_THREADS = 4                                   
                                                                                                                     
(t) pkg> st                                                                                                          
Status `~/.julia/dev/t/Project.toml`                      
  [052768ef] CUDA v3.9.0                                                                                             
  [7ed4a6bd] LinearSolve v1.15.0                                                                                     
                                                                                                                     
julia> using CUDA                                         
                                                                                                                     
julia> using LinearSolve                                                                                             
┌ Warning: Error requiring `CUDA` from `LinearSolve`                                                                 
│   exception =                                           
│    LoadError: UndefVarError: CuQR not defined                                                                      
│    Stacktrace:                                          
│      [1] getproperty(x::Module, f::Symbol)                                                                         
│        @ Base ./Base.jl:31                                                                                         
│      [2] top-level scope                                
│        @ ~/.julia/packages/LinearSolve/7vwOr/src/cuda.jl:48                                                        
│      [3] include(mod::Module, _path::String)                                                                       
│        @ Base ./Base.jl:422                                                                                        
│      [4] include(x::String)                             
│        @ LinearSolve ~/.julia/packages/LinearSolve/7vwOr/src/LinearSolve.jl:1                                      
│      [5] top-level scope                                
│        @ ~/.julia/packages/Requires/Z8rfN/src/Requires.jl:40                                                       
│      [6] eval                                           
│        @ ./boot.jl:368 [inlined]                        
│      [7] eval                                           
│        @ ~/.julia/packages/LinearSolve/7vwOr/src/LinearSolve.jl:1 [inlined]                                        
│      [8] (::LinearSolve.var"#31#37")()                  
│        @ LinearSolve ~/.julia/packages/Requires/Z8rfN/src/require.jl:101                                           
│      [9] macro expansion                                
│        @ ./timing.jl:359 [inlined]                      
│     [10] err(f::Any, listener::Module, modname::String, file::String, line::Any)                                   
│        @ Requires ~/.julia/packages/Requires/Z8rfN/src/require.jl:47                                               
│     [11] (::LinearSolve.var"#30#36")()                  
│        @ LinearSolve ~/.julia/packages/Requires/Z8rfN/src/require.jl:100                                           
│     [12] withpath(f::Any, path::String)                                                                            
│        @ Requires ~/.julia/packages/Requires/Z8rfN/src/require.jl:37                                               
|     [13] (::LinearSolve.var"#29#35")()                  
│        @ LinearSolve ~/.julia/packages/Requires/Z8rfN/src/require.jl:99                                            
│     [14] listenpkg(f::Any, pkg::Base.PkgId)                                                                        
│        @ Requires ~/.julia/packages/Requires/Z8rfN/src/require.jl:20                                               
│     [15] macro expansion                                
│        @ ~/.julia/packages/Requires/Z8rfN/src/require.jl:98 [inlined]                                              
│     [16] __init__()                                     
│        @ LinearSolve ~/.julia/packages/LinearSolve/7vwOr/src/init.jl:11                                            
│     [17] _include_from_serialized(path::String, depmods::Vector{Any})                                              
│        @ Base ./loading.jl:808                          
│     [18] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, depth::Int64)
│        @ Base ./loading.jl:916                          
│     [19] _require_search_from_serialized                                                                           
│        @ ./loading.jl:889 [inlined]                     
│     [20] _require(pkg::Base.PkgId)                      
│        @ Base ./loading.jl:1176                         
│     [21] _require_prelocked(uuidkey::Base.PkgId)                                                                   
│        @ Base ./loading.jl:1084                         
│     [22] macro expansion                                
│        @ ./loading.jl:1064 [inlined]                    
│     [23] macro expansion                                
│        @ ./lock.jl:223 [inlined]                        
│     [24] require(into::Module, mod::Symbol)                                                                        
│        @ Base ./loading.jl:1028                         
│     [25] top-level scope                                
│        @ ~/.julia/packages/CUDA/Uurn4/src/initialization.jl:52                                                     
│     [26] eval              
│        @ ./boot.jl:368 [inlined]                        
│     [27] eval_user_input(ast::Any, backend::REPL.REPLBackend)                                                      
│        @ REPL /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/REPL/src/REPL.jl:151
│     [28] repl_backend_loop(backend::REPL.REPLBackend)                                                              
│        @ REPL /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/REPL/src/REPL.jl:247
│     [29] start_repl_backend(backend::REPL.REPLBackend, consumer::Any)                                              
│        @ REPL /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/REPL/src/REPL.jl:232
│     [30] run_repl(repl::REPL.AbstractREPL, consumer::Any; backend_on_current_task::Bool)
│        @ REPL /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/REPL/src/REPL.jl:369
│     [31] run_repl(repl::REPL.AbstractREPL, consumer::Any)                                                          
│        @ REPL /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/REPL/src/REPL.jl:356
│     [32] (::Base.var"#964#966"{Bool, Bool, Bool})(REPL::Module)                                                    
│        @ Base ./client.jl:419                           
│     [33] #invokelatest#2                                
│        @ ./essentials.jl:729 [inlined]                  
│     [34] invokelatest                                   
│        @ ./essentials.jl:727 [inlined]                  
│     [35] run_main_repl(interactive::Bool, quiet::Bool, banner::Bool, history_file::Bool, color_set::Bool)
│        @ Base ./client.jl:404                           
│     [36] exec_options(opts::Base.JLOptions)                                                                        
│        @ Base ./client.jl:318                           
│     [37] _start()          
│        @ Base ./client.jl:522                           
│    in expression starting at /Users/vp/.julia/packages/LinearSolve/7vwOr/src/cuda.jl:48
└ @ Requires ~/.julia/packages/Requires/Z8rfN/src/require.jl:51                                                      

default branching to factorization on Diagonal type

Im passing in a Diagonal |> DiffEqArrayOperator to OrdinaryDffEq with alg SBDF3() , and LinearSolve is dispatching to lu!.

diffusion = A |> Diagonal |> DiffEqArrayOperator
ode_prob = SplitODEProblem(diffusion, rhs!, û₀[1], tspan; saveat=tsave)
ensemble_sol = solve(ensemble_prob, SBDF3(), ensemble_type; dt=1e-2 kwargs...)

nested task error: MethodError: no method matching lu!(::Diagonal{Float64, Vector{Floa
t64}}, ::RowMaximum; check=false)

We can either add a case for Diagonal type in the default alg https://github.com/SciML/LinearSolve.jl/blob/main/src/default.jl but won't it be more robust if we can just figure out if whatever type is passed in has a predefined ldiv! and just use that? I think just having a kwarg hasldiv! would be very good

Would ArrayInterface be the right place to look?

stable documentation link is broken

https://linearsolve.sciml.ai/stable/

https://github.com/ddemidov/amgcl

https://github.com/ddemidov/amgcl

LimitedLDLFactorizations.jl wrapper

https://github.com/JuliaSmoothOptimizers/LimitedLDLFactorizations.jl

CuQR is not present in CUDA.jl for julia 1.8+

https://github.com/JuliaGPU/CUDA.jl/blob/f52201036272591b74b994dd7d9df1496ba1f88a/lib/cusolver/linalg.jl#L72 removes CuQR

IterativeSolvers Wrappers

https://github.com/JuliaLinearAlgebra/IterativeSolvers.jl

Starter code: https://github.com/SciML/DiffEqBase.jl/blob/master/src/linear_nonlinear.jl#L161-L273

Uses https://iterativesolvers.julialinearalgebra.org/dev/iterators/

GenericFactorization with cholesky! fails tests

KrylovKit.jl wrapper

https://jutho.github.io/KrylovKit.jl/latest/

Rename to LinearSolve.jl

Matches NonlinearSolve.jl

KLU wrappers

https://ufdc.ufl.edu/UFE0011721/00001

@andreasnoack @ViralBShah is KLU wrapped in Julia? How would it be accessed through the SuiteSparse wrappers?

Magma wrapper

http://icl.cs.utk.edu/projectsfiles/magma/doxygen/_m_a_g_m_a-sparse.html#sparsesolvers

handle cases where `eps(eltype)` not defined like `Complex`, `Int`

LinearSolve.jl/src/common.jl

Lines 59 to 60 in e99d699

	abstol=√eps(eltype(prob.A)),
	reltol=√eps(eltype(prob.A)),

linearsolve using the transpose of the factorization

For defining rrules, I need to make use of the factorization in the forward pass. The rrules is also a linearsolve with the transpose of the linear system, how to avoid defining a new LinearProblem ?

This my current code, the LinearSolve interface with make it make use other algorithms and more clean

function ChainRulesCore.rrule(::typeof(efield), sim::Simulation,ϵ)
    linsys = ConstructLinearSystem(sim, ϵ )
    A ,b = linsys.A , linsys.b
    x = similar(b); x_adj = similar(b)
    F = lu(A)
    LinearAlgebra.ldiv!(x, F, b)
    sim.E = x
    function efield_pullback(ȳ)
        LinearAlgebra.ldiv!(x_adj, transpose(F), conj.(ȳ))
        f̄ = NoTangent()
        f̄oo =  NoTangent()
        ϵoo =  real(x .* x_adj)
        return f̄, f̄oo , ϵoo
    end
    return x, efield_pullback
end


Thanks!

Maybe build off of Preconditioners.jl?

https://github.com/mohamed82008/Preconditioners.jl from @mohamed82008 .

SLATE Wrapper

http://icl.eecs.utk.edu/slate/

v1.8.0 Breaks OrdinaryDiffEq.jl

Just failed to precompile my package with the following error message (rolling back to v1.7.0 of LinearSolve.jl fixes it)

The error chain is:
ModelingToolkit.jl -> DiffEqCallbacks.jl -> OrdinaryDiffEq.jl

Here is the full error message:

ERROR: LoadError: MethodError: Cannot `convert` an object of type 
  LinearSolve.LinearCache{Array{Float64{},2},Array{Float64{},1},Array{Float64{},1},SciMLBase.NullParameters{},Nothing{},LinearAlgebra.LU{Float64, Matrix{Float64}},LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64{},Array{Float64{},1}}},LinearAlgebra.Diagonal{Float64{},Array{Float64{},1}},Float64{}} to an object of type
  LinearSolve.LinearCache{Array{Float64{},2},Array{Float64{},1},Array{Float64{},1},SciMLBase.NullParameters{},Nothing{},LinearAlgebra.BunchKaufman{Float64, Matrix{Float64}},LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64{},Array{Float64{},1}}},LinearAlgebra.Diagonal{Float64{},Array{Float64{},1}},Float64{}}
Closest candidates are:
  convert(::Type{T}, ::T) where T at D:\Programs\julia-1.7.2\share\julia\base\essentials.jl:215
  LinearSolve.LinearCache{TA, Tb, Tu, Tp, Talg, Tc, Tl, Tr, Ttol}(::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any) where {TA, Tb, Tu, Tp, Talg, Tc, Tl, Tr, Ttol} at C:\Users\CarmanBr\.julia\packages\LinearSolve\AppDK\src\common.jl:2
Stacktrace:
  [1] setproperty!(x::OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Float64}, SciMLBase.NullParameters}, SciMLBase.UJacobianWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, SciMLBase.NullParameters}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LinearAlgebra.BunchKaufman{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, SparseDiffTools.ForwardColorJacCache{Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{Float64}, Vector{Vector{Tuple{Float64, Float64, Float64}}}, UnitRange{Int64}, Nothing}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 1}}, Float64, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, f::Symbol, v::LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LinearAlgebra.LU{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}) 
    @ Base .\Base.jl:39
  [2] perform_step!(integrator::OrdinaryDiffEq.ODEIntegrator{OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, true, Vector{Float64}, Nothing, Float64, SciMLBase.NullParameters, Float64, Float64, Float64, Float64, Vector{Vector{Float64}}, SciMLBase.ODESolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, SciMLBase.ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, OrdinaryDiffEq.InterpolationData{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Float64}, SciMLBase.NullParameters}, SciMLBase.UJacobianWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, SciMLBase.NullParameters}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LinearAlgebra.BunchKaufman{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, SparseDiffTools.ForwardColorJacCache{Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{Float64}, Vector{Vector{Tuple{Float64, Float64, Float64}}}, UnitRange{Int64}, Nothing}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 
1}}, Float64, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}}, DiffEqBase.DEStats}, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Float64}, SciMLBase.NullParameters}, SciMLBase.UJacobianWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, SciMLBase.NullParameters}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LinearAlgebra.BunchKaufman{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, SparseDiffTools.ForwardColorJacCache{Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{Float64}, Vector{Vector{Tuple{Float64, Float64, Float64}}}, UnitRange{Int64}, Nothing}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 1}}, Float64, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.DEOptions{Float64, Float64, Float64, Float64, OrdinaryDiffEq.PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, SciMLBase.CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, Nothing, Int64, Tuple{}, Tuple{}, Tuple{}}, Vector{Float64}, Float64, Nothing, OrdinaryDiffEq.DefaultInit}, cache::OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Float64}, SciMLBase.NullParameters}, SciMLBase.UJacobianWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, SciMLBase.NullParameters}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LinearAlgebra.BunchKaufman{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, SparseDiffTools.ForwardColorJacCache{Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{Float64}, Vector{Vector{Tuple{Float64, Float64, Float64}}}, UnitRange{Int64}, Nothing}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 1}}, Float64, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, repeat_step::Bool)
    @ OrdinaryDiffEq C:\Users\CarmanBr\.julia\packages\OrdinaryDiffEq\f7XiH\src\perform_step\rosenbrock_perform_step.jl:206
  [3] perform_step!
    @ C:\Users\CarmanBr\.julia\packages\OrdinaryDiffEq\f7XiH\src\perform_step\rosenbrock_perform_step.jl:109 [inlined]
  [4] solve!(integrator::OrdinaryDiffEq.ODEIntegrator{OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, true, Vector{Float64}, Nothing, Float64, SciMLBase.NullParameters, Float64, Float64, Float64, Float64, Vector{Vector{Float64}}, SciMLBase.ODESolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, SciMLBase.ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, OrdinaryDiffEq.InterpolationData{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Float64}, SciMLBase.NullParameters}, SciMLBase.UJacobianWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, SciMLBase.NullParameters}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LinearAlgebra.BunchKaufman{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, SparseDiffTools.ForwardColorJacCache{Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{Float64}, Vector{Vector{Tuple{Float64, Float64, Float64}}}, UnitRange{Int64}, Nothing}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 1}}, Float64, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}}, DiffEqBase.DEStats}, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Float64}, SciMLBase.NullParameters}, 
SciMLBase.UJacobianWrapper{SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, SciMLBase.NullParameters}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, Nothing, LinearAlgebra.BunchKaufman{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, SparseDiffTools.ForwardColorJacCache{Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 3}}, Vector{Float64}, Vector{Vector{Tuple{Float64, Float64, Float64}}}, UnitRange{Int64}, Nothing}, Vector{ForwardDiff.Dual{ForwardDiff.Tag{OrdinaryDiffEq.OrdinaryDiffEqTag, Float64}, Float64, 1}}, Float64, OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.DEOptions{Float64, Float64, Float64, Float64, OrdinaryDiffEq.PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, SciMLBase.CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, Nothing, Int64, Tuple{}, Tuple{}, Tuple{}}, Vector{Float64}, Float64, Nothing, OrdinaryDiffEq.DefaultInit})
    @ OrdinaryDiffEq C:\Users\CarmanBr\.julia\packages\OrdinaryDiffEq\f7XiH\src\solve.jl:478
  [5] __solve(::SciMLBase.ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, ::OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ OrdinaryDiffEq C:\Users\CarmanBr\.julia\packages\OrdinaryDiffEq\f7XiH\src\solve.jl:5
  [6] __solve
    @ C:\Users\CarmanBr\.julia\packages\OrdinaryDiffEq\f7XiH\src\solve.jl:4 [inlined]
  [7] #solve_call#37
    @ C:\Users\CarmanBr\.julia\packages\DiffEqBase\0PaUK\src\solve.jl:61 [inlined]
  [8] solve_call(_prob::SciMLBase.ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, args::OrdinaryDiffEq.Rosenbrock23{3, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing})
    @ DiffEqBase C:\Users\CarmanBr\.julia\packages\DiffEqBase\0PaUK\src\solve.jl:48
  [9] solve_up(prob::SciMLBase.ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, sensealg::Nothing, u0::Vector{Float64}, p::SciMLBase.NullParameters, args::OrdinaryDiffEq.Rosenbrock23{0, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ DiffEqBase C:\Users\CarmanBr\.julia\packages\DiffEqBase\0PaUK\src\solve.jl:87
 [10] solve_up
    @ C:\Users\CarmanBr\.julia\packages\DiffEqBase\0PaUK\src\solve.jl:78 [inlined]
 [11] #solve#38
    @ C:\Users\CarmanBr\.julia\packages\DiffEqBase\0PaUK\src\solve.jl:73 [inlined]
 [12] solve(prob::SciMLBase.ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, SciMLBase.ODEFunction{true, OrdinaryDiffEq.var"#lorenz#525", LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, args::OrdinaryDiffEq.Rosenbrock23{0, true, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing})
    @ DiffEqBase C:\Users\CarmanBr\.julia\packages\DiffEqBase\0PaUK\src\solve.jl:68
 [13] top-level scope
    @ C:\Users\CarmanBr\.julia\packages\OrdinaryDiffEq\f7XiH\src\OrdinaryDiffEq.jl:197
 [14] include
    @ .\Base.jl:417 [inlined]
 [15] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt64}}, source::String)
    @ Base .\loading.jl:1402
 [16] top-level scope
    @ none:1
 [17] eval
    @ .\boot.jl:368 [inlined]
 [18] eval(x::Expr)
    @ Base.MainInclude .\client.jl:465
 [19] top-level scope
    @ none:1
in expression starting at C:\Users\CarmanBr\.julia\packages\OrdinaryDiffEq\f7XiH\src\OrdinaryDiffEq.jl:1

Better initial guesses for reinitialized iterative solvers

https://scicomp.stackexchange.com/questions/23323/role-of-initial-guess-for-iterative-linear-solver
https://krypy.readthedocs.io/en/latest/krypy.utils.html#krypy.utils.hegedus
http://math.aalto.fi/~kuiduhut/spkry.pdf
https://fenicsproject.org/qa/7253/convergence-of-iterative-solver-with-initial-guess/

IncompleteLU.jl wrapper

https://github.com/haampie/IncompleteLU.jl

Insert default preconditioners

The default preconditioners are then composed with any preconditioner placed in there, like is done in https://github.com/SciML/DiffEqBase.jl/blob/v6.76.0/src/linear_nonlinear.jl#L219-L226 . This is shown to almost always speed up the convergence.

Cache symbolic factorization when doing a sparse factorization

Default algorithm

Can be based on https://github.com/SciML/DiffEqBase.jl/blob/master/src/linear_nonlinear.jl#L64-L155

Elemental.jl wrapper

https://github.com/JuliaParallel/Elemental.jl

Better initialization for most factorizations

LU factorizations use lu_instance, but the other factorizations do not init a cache. This means that blank A, such as a just initialized Jacobian, can call the factorization which costs an extra factorization and can be singular due to having blank values.

The fix might be #61

nonlinear system??

LinearSolve.jl/docs/src/solvers/solvers.md

Lines 3 to 8 in dacd618

	`solve(prob::LinearProlem,alg;kwargs)`
	Solves for ``Au=b`` in the problem defined by `prob` using the algorithm
	`alg`. If no algorithm is given, a default algorithm will be chosen.
	This page is solely focused on the methods for nonlinear systems.

nonlinear system arising from prob::LinearProblem?

docs: don't do `mul!(x, A, x)`

LinearSolve.jl/src/preconditioners.jl

Line 29 in 43111fc

LinearAlgebra.ldiv!(A::InvPreconditioner, x) = mul!(x, A.P, x)

docs:

Y <- mul!(Y, A, B)

Calculates the matrix-matrix or matrix-vector product AB and stores the result in Y, overwriting the existing value of Y. Note that Y must not be aliased with either A or B.