Address comments of Discourse

[ChrisRackauckas]

https://discourse.julialang.org/t/what-is-a-recommended-way-to-solve-a-linear-equation

[github-actions]

[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

	* Offloading: offloading takes a CPU-based problem and automatically transforms it into a
	GPU-based problem in the background, and returns the solution on CPU. Thus using
	offloading requires no change on the part of the user other than to choose an offloading
	solver.
	* Array type interface: the array type interface requires that the user defines the
	`LinearProblem` using an `AbstractGPUArray` type and chooses an appropriate solver
	(or uses the default solver). The solution will then be returned as a GPU array type.
	- Offloading: offloading takes a CPU-based problem and automatically transforms it into a
	GPU-based problem in the background, and returns the solution on CPU. Thus using
	offloading requires no change on the part of the user other than to choose an offloading
	solver.
	- Array type interface: the array type interface requires that the user defines the
	`LinearProblem` using an `AbstractGPUArray` type and chooses an appropriate solver
	(or uses the default solver). The solution will then be returned as a GPU array type.

[github-actions]

[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

[github-actions]

[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

[github-actions]

[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

[github-actions]

[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

	* [BandedMatrices.jl](https://github.com/JuliaLinearAlgebra/BandedMatrices.jl)
	* [BlockDiagonals.jl](https://github.com/JuliaArrays/BlockDiagonals.jl)
	* [CUDA.jl](https://cuda.juliagpu.org/stable/) (CUDA GPU-based dense and sparse matrices)
	* [FastAlmostBandedMatrices.jl](https://github.com/SciML/FastAlmostBandedMatrices.jl)
	* [Metal.jl](https://metal.juliagpu.org/stable/) (Apple M-series GPU-based dense matrices)
	- [BandedMatrices.jl](https://github.com/JuliaLinearAlgebra/BandedMatrices.jl)
	- [BlockDiagonals.jl](https://github.com/JuliaArrays/BlockDiagonals.jl)
	- [CUDA.jl](https://cuda.juliagpu.org/stable/) (CUDA GPU-based dense and sparse matrices)
	- [FastAlmostBandedMatrices.jl](https://github.com/SciML/FastAlmostBandedMatrices.jl)
	- [Metal.jl](https://metal.juliagpu.org/stable/) (Apple M-series GPU-based dense matrices)

[github-actions]

[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

	if hasmethod(LinearAlgebra.issuccess, Tuple{typeof(fact)}) && !LinearAlgebra.issuccess(fact)
	if hasmethod(LinearAlgebra.issuccess, Tuple{typeof(fact)}) &&
	!LinearAlgebra.issuccess(fact)

[WalterMadelim]

This link.
The first sentence under this link is not comprehensive.
To specify the model Au = b, I need to provide an A matrix, a b vector, and then I call prob = LinearProblem(A, b).
What "Type" should I choose? Should the user specify a concrete type, will this be beneficial?
For the matrix A, it can have varied types

julia> A1 = rand(4, 4)
4×4 Matrix{Float64}:
 0.639008   0.0695166  0.157621  0.112311
 0.0444344  0.840106   0.461039  0.140124
 0.646453   0.626477   0.655603  0.717909
 0.649285   0.151508   0.165179  0.411041

julia> A2 = Symmetric(rand(4, 4))
4×4 Symmetric{Float64, Matrix{Float64}}:
 0.904668  0.484867  0.860761   0.72931
 0.484867  0.945613  0.648764   0.996674
 0.860761  0.648764  0.101596   0.0521238
 0.72931   0.996674  0.0521238  0.00692615

julia> A3 = SparseArrays.sprand(4, 4, .2)
4×4 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
  ⋅    ⋅         ⋅         ⋅
  ⋅   0.729519  0.680267   ⋅
  ⋅    ⋅         ⋅         ⋅
  ⋅    ⋅         ⋅         ⋅

julia> A4 = Symmetric(SparseArrays.sprand(4, 4, .2))
4×4 Symmetric{Float64, SparseMatrixCSC{Float64, Int64}}:
 0.892644   ⋅         ⋅         ⋅
  ⋅        0.702673  0.381419  0.745596
  ⋅        0.381419   ⋅         ⋅
  ⋅        0.745596   ⋅         ⋅

Will the typeof(A4) be preferable than typeof(A1)?
Similarly, for the vector

julia> b1 = rand(4)
4-element Vector{Float64}:
 0.6830613731051517
 0.5774420692994588
 0.2954095531849277
 0.7373953570499356

julia> b2 = SparseArrays.sprand(4, .8)
4-element SparseVector{Float64, Int64} with 4 stored entries:
  [1]  =  0.221711
  [2]  =  0.904912
  [3]  =  0.68406
  [4]  =  0.740414

Will the LinearSolve interface benefit from typeof(b2) rather than typeof(b1)?

And secondly, I don't quite understand the first sentence under this link.

There is no difference in the interface for using LinearSolve.jl on sparse and structured matrices.

What does "no difference" mean? Does it suggest that the user can write any code freely (e.g. the aforementioned varied types) as long as it won't ERROR, and the performance is the same?

Similerly structure matrix types, like banded matrices...

The word is "Similarly"?
will specifying the special structure be beneficial?