Revert some modifications

JuliaSmoothOptimizers · Jan 30, 2023 · b04fc76 · b04fc76
1 parent 66f3059
commit b04fc76
Show file tree

Hide file tree

Showing 35 changed files with 132 additions and 132 deletions.
diff --git a/src/bicgstab.jl b/src/bicgstab.jl
@@ -23,7 +23,7 @@ export bicgstab, bicgstab!
                           verbose::Int=0, history::Bool=false,
                           callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, stats) = bicgstab(A, b, x0::AbstractVector; kwargs...)
@@ -77,13 +77,13 @@ BICGSTAB stops when `itmax` iterations are reached or when `‖rₖ‖ ≤ atol
 """
 function bicgstab end
 
-function bicgstab(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: RealOrComplex
+function bicgstab(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: FloatOrComplex
   solver = BicgstabSolver(A, b)
   bicgstab!(solver, A, b, x0; kwargs...)
   return (solver.x, solver.stats)
 end
 
-function bicgstab(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function bicgstab(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = BicgstabSolver(A, b)
   bicgstab!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)
@@ -99,7 +99,7 @@ See [`BicgstabSolver`](@ref) for more details about the `solver`.
 """
 function bicgstab! end
 
-function bicgstab!(solver :: BicgstabSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+function bicgstab!(solver :: BicgstabSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0)
   bicgstab!(solver, A, b; kwargs...)
   return solver

diff --git a/src/bilq.jl b/src/bilq.jl
@@ -19,7 +19,7 @@ export bilq, bilq!
                       verbose::Int=0, history::Bool=false,
                       callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, stats) = bilq(A, b, x0::AbstractVector; kwargs...)
@@ -64,13 +64,13 @@ When `A` is Hermitian and `b = c`, BiLQ is equivalent to SYMMLQ.
 """
 function bilq end
 
-function bilq(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: RealOrComplex
+function bilq(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: FloatOrComplex
   solver = BilqSolver(A, b)
   bilq!(solver, A, b, x0; kwargs...)
   return (solver.x, solver.stats)
 end
 
-function bilq(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function bilq(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = BilqSolver(A, b)
   bilq!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)
@@ -86,7 +86,7 @@ See [`BilqSolver`](@ref) for more details about the `solver`.
 """
 function bilq! end
 
-function bilq!(solver :: BilqSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+function bilq!(solver :: BilqSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0)
   bilq!(solver, A, b; kwargs...)
   return solver

diff --git a/src/bilqr.jl b/src/bilqr.jl
@@ -19,7 +19,7 @@ export bilqr, bilqr!
                           verbose::Int=0, history::Bool=false,
                           callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, y, stats) = bilqr(A, b, c, x0::AbstractVector, y0::AbstractVector; kwargs...)
@@ -69,13 +69,13 @@ QMR is used for solving dual system `Aᴴy = c` of size n.
 """
 function bilqr end
 
-function bilqr(A, b :: AbstractVector{FC}, c :: AbstractVector{FC}, x0 :: AbstractVector, y0 :: AbstractVector; kwargs...) where FC <: RealOrComplex
+function bilqr(A, b :: AbstractVector{FC}, c :: AbstractVector{FC}, x0 :: AbstractVector, y0 :: AbstractVector; kwargs...) where FC <: FloatOrComplex
   solver = BilqrSolver(A, b)
   bilqr!(solver, A, b, c, x0, y0; kwargs...)
   return (solver.x, solver.y, solver.stats)
 end
 
-function bilqr(A, b :: AbstractVector{FC}, c :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function bilqr(A, b :: AbstractVector{FC}, c :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = BilqrSolver(A, b)
   bilqr!(solver, A, b, c; kwargs...)
   return (solver.x, solver.y, solver.stats)
@@ -92,7 +92,7 @@ See [`BilqrSolver`](@ref) for more details about the `solver`.
 function bilqr! end
 
 function bilqr!(solver :: BilqrSolver{T,FC,S}, A, b :: AbstractVector{FC}, c :: AbstractVector{FC},
-                x0 :: AbstractVector, y0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+                x0 :: AbstractVector, y0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0, y0)
   bilqr!(solver, A, b, c; kwargs...)
   return solver

diff --git a/src/cg.jl b/src/cg.jl
@@ -23,7 +23,7 @@ export cg, cg!
                     verbose::Int=0, history::Bool=false,
                     callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, stats) = cg(A, b, x0::AbstractVector; kwargs...)
@@ -69,13 +69,13 @@ M also indicates the weighted norm in which residuals are measured.
 """
 function cg end
 
-function cg(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: RealOrComplex
+function cg(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: FloatOrComplex
   solver = CgSolver(A, b)
   cg!(solver, A, b, x0; kwargs...)
   return (solver.x, solver.stats)
 end
 
-function cg(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function cg(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CgSolver(A, b)
   cg!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)
@@ -91,7 +91,7 @@ See [`CgSolver`](@ref) for more details about the `solver`.
 """
 function cg! end
 
-function cg!(solver :: CgSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+function cg!(solver :: CgSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0)
   cg!(solver, A, b; kwargs...)
   return solver

diff --git a/src/cg_lanczos.jl b/src/cg_lanczos.jl
@@ -20,7 +20,7 @@ export cg_lanczos, cg_lanczos!
                             verbose::Int=0, history::Bool=false,
                             callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, stats) = cg_lanczos(A, b, x0::AbstractVector; kwargs...)
@@ -66,13 +66,13 @@ The method does _not_ abort if A is not definite.
 """
 function cg_lanczos end
 
-function cg_lanczos(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: RealOrComplex
+function cg_lanczos(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: FloatOrComplex
   solver = CgLanczosSolver(A, b)
   cg_lanczos!(solver, A, b, x0; kwargs...)
   return (solver.x, solver.stats)
 end
 
-function cg_lanczos(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function cg_lanczos(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CgLanczosSolver(A, b)
   cg_lanczos!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)
@@ -88,7 +88,7 @@ See [`CgLanczosSolver`](@ref) for more details about the `solver`.
 """
 function cg_lanczos! end
 
-function cg_lanczos!(solver :: CgLanczosSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+function cg_lanczos!(solver :: CgLanczosSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0)
   cg_lanczos!(solver, A, b; kwargs...)
   return solver

diff --git a/src/cg_lanczos_shift.jl b/src/cg_lanczos_shift.jl
@@ -21,7 +21,7 @@ export cg_lanczos_shift, cg_lanczos_shift!
                                   verbose::Int=0, history::Bool=false,
                                   callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
 The Lanczos version of the conjugate gradient method to solve a family
@@ -62,7 +62,7 @@ of size n. The method does _not_ abort if A + αI is not definite.
 """
 function cg_lanczos_shift end
 
-function cg_lanczos_shift(A, b :: AbstractVector{FC}, shifts :: AbstractVector{T}; kwargs...) where {T <: Real, FC <: RealOrComplex{T}}
+function cg_lanczos_shift(A, b :: AbstractVector{FC}, shifts :: AbstractVector{T}; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}}
   nshifts = length(shifts)
   solver = CgLanczosShiftSolver(A, b, nshifts)
   cg_lanczos_shift!(solver, A, b, shifts; kwargs...)

diff --git a/src/cgls.jl b/src/cgls.jl
@@ -35,7 +35,7 @@ export cgls, cgls!
                       itmax::Int=0, verbose::Int=0, history::Bool=false,
                       callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
 Solve the regularized linear least-squares problem
@@ -84,7 +84,7 @@ but simpler to implement.
 """
 function cgls end
 
-function cgls(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function cgls(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CglsSolver(A, b)
   cgls!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)

diff --git a/src/cgne.jl b/src/cgne.jl
@@ -36,7 +36,7 @@ export cgne, cgne!
                       verbose::Int=0, history::Bool=false,
                       callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
 Solve the consistent linear system
@@ -91,7 +91,7 @@ but simpler to implement. Only the x-part of the solution is returned.
 """
 function cgne end
 
-function cgne(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function cgne(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CgneSolver(A, b)
   cgne!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)

diff --git a/src/cgs.jl b/src/cgs.jl
@@ -18,7 +18,7 @@ export cgs, cgs!
                      verbose::Int=0, history::Bool=false,
                      callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, stats) = cgs(A, b, x0::AbstractVector; kwargs...)
@@ -78,13 +78,13 @@ TFQMR and BICGSTAB were developed to remedy this difficulty.»
 """
 function cgs end
 
-function cgs(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: RealOrComplex
+function cgs(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: FloatOrComplex
   solver = CgsSolver(A, b)
   cgs!(solver, A, b, x0; kwargs...)
   return (solver.x, solver.stats)
 end
 
-function cgs(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function cgs(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CgsSolver(A, b)
   cgs!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)
@@ -100,7 +100,7 @@ See [`CgsSolver`](@ref) for more details about the `solver`.
 """
 function cgs! end
 
-function cgs!(solver :: CgsSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+function cgs!(solver :: CgsSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0)
   cgs!(solver, A, b; kwargs...)
   return solver

diff --git a/src/cr.jl b/src/cr.jl
@@ -22,7 +22,7 @@ export cr, cr!
                     verbose::Int=0, history::Bool=false,
                     callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, stats) = cr(A, b, x0::AbstractVector; kwargs...)
@@ -71,13 +71,13 @@ M also indicates the weighted norm in which residuals are measured.
 """
 function cr end
 
-function cr(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: RealOrComplex
+function cr(A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where FC <: FloatOrComplex
   solver = CrSolver(A, b)
   cr!(solver, A, b, x0; kwargs...)
   return (solver.x, solver.stats)
 end
 
-function cr(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function cr(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CrSolver(A, b)
   cr!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)
@@ -93,7 +93,7 @@ See [`CrSolver`](@ref) for more details about the `solver`.
 """
 function cr! end
 
-function cr!(solver :: CrSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+function cr!(solver :: CrSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0)
   cr!(solver, A, b; kwargs...)
   return solver

diff --git a/src/craig.jl b/src/craig.jl
@@ -42,7 +42,7 @@ export craig, craig!
                           verbose::Int=0, history::Bool=false,
                           callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
 Find the least-norm solution of the consistent linear system
@@ -124,7 +124,7 @@ In this implementation, both the x and y-parts of the solution are returned.
 """
 function craig end
 
-function craig(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function craig(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CraigSolver(A, b)
   craig!(solver, A, b; kwargs...)
   return (solver.x, solver.y, solver.stats)

diff --git a/src/craigmr.jl b/src/craigmr.jl
@@ -34,7 +34,7 @@ export craigmr, craigmr!
                             verbose::Int=0, history::Bool=false,
                             callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
 Solve the consistent linear system
@@ -116,7 +116,7 @@ returned.
 """
 function craigmr end
 
-function craigmr(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function craigmr(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CraigmrSolver(A, b)
   craigmr!(solver, A, b; kwargs...)
   return (solver.x, solver.y, solver.stats)

diff --git a/src/crls.jl b/src/crls.jl
@@ -27,7 +27,7 @@ export crls, crls!
                       itmax::Int=0, verbose::Int=0, history::Bool=false,
                       callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
 Solve the linear least-squares problem
@@ -75,7 +75,7 @@ but simpler to implement.
 """
 function crls end
 
-function crls(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function crls(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CrlsSolver(A, b)
   crls!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)

diff --git a/src/crmr.jl b/src/crmr.jl
@@ -34,7 +34,7 @@ export crmr, crmr!
                       verbose::Int=0, history::Bool=false,
                       callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
 Solve the consistent linear system
@@ -89,7 +89,7 @@ but simpler to implement. Only the x-part of the solution is returned.
 """
 function crmr end
 
-function crmr(A, b :: AbstractVector{FC}; kwargs...) where FC <: RealOrComplex
+function crmr(A, b :: AbstractVector{FC}; kwargs...) where FC <: FloatOrComplex
   solver = CrmrSolver(A, b)
   crmr!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)

diff --git a/src/diom.jl b/src/diom.jl
@@ -18,7 +18,7 @@ export diom, diom!
                       verbose::Int=0, history::Bool=false,
                       callback=solver->false, iostream::IO=kstdout)
 
-`T` is a `Real` such as `Float32`, `Float64` or `BigFloat`.
+`T` is an `AbstractFloat` such as `Float32`, `Float64` or `BigFloat`.
 `FC` is `T` or `Complex{T}`.
 
     (x, stats) = diom(A, b, x0::AbstractVector; kwargs...)
@@ -70,13 +70,13 @@ and indefinite systems of linear equations can be handled by this single algorit
 """
 function diom end
 
-function diom(A, b :: AbstractVector{FC}, x0 :: AbstractVector; memory :: Int=20, kwargs...) where FC <: RealOrComplex
+function diom(A, b :: AbstractVector{FC}, x0 :: AbstractVector; memory :: Int=20, kwargs...) where FC <: FloatOrComplex
   solver = DiomSolver(A, b, memory)
   diom!(solver, A, b, x0; kwargs...)
   return (solver.x, solver.stats)
 end
 
-function diom(A, b :: AbstractVector{FC}; memory :: Int=20, kwargs...) where FC <: RealOrComplex
+function diom(A, b :: AbstractVector{FC}; memory :: Int=20, kwargs...) where FC <: FloatOrComplex
   solver = DiomSolver(A, b, memory)
   diom!(solver, A, b; kwargs...)
   return (solver.x, solver.stats)
@@ -95,7 +95,7 @@ See [`DiomSolver`](@ref) for more details about the `solver`.
 """
 function diom! end
 
-function diom!(solver :: DiomSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: Real, FC <: RealOrComplex{T}, S <: DenseVector{FC}}
+function diom!(solver :: DiomSolver{T,FC,S}, A, b :: AbstractVector{FC}, x0 :: AbstractVector; kwargs...) where {T <: AbstractFloat, FC <: FloatOrComplex{T}, S <: DenseVector{FC}}
   warm_start!(solver, x0)
   diom!(solver, A, b; kwargs...)
   return solver