Update PartitionedVectors.jl for Krylov.jl v0.10 (#55)

Author: amontoison

.cirrus.yml

@@ -1,13 +1,10 @@
 freebsd_instance:
-  image: freebsd-13-0-release-amd64
+  image: freebsd-14-2-release-amd64
 task:
   name: FreeBSD
   env:
     matrix:
-      - JULIA_VERSION: 1.6
       - JULIA_VERSION: 1
-      - JULIA_VERSION: nightly
-  allow_failures: $JULIA_VERSION == 'nightly'
   install_script:
     - sh -c "$(fetch https://raw.githubusercontent.com/ararslan/CirrusCI.jl/master/bin/install.sh -o -)"
   build_script:

.github/workflows/Documentation.yml

@@ -10,10 +10,10 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - uses: julia-actions/setup-julia@latest
         with:
-          version: '1.7'
+          version: '1'
       - name: Install dependencies
         run: julia --project=docs -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
       - name: Build and deploy

.github/workflows/ci.yml

@@ -13,30 +13,30 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ['1.6']
-        os: [ubuntu-latest, macOS-latest, windows-latest]
+        version: ['lts', '1']
+        os: [ubuntu-latest, macos-latest, windows-latest]
         arch: [x64]
         allow_failure: [false]
         include:
-          - version: 'nightly'
+          - version: 'pre'
             os: ubuntu-latest
             arch: x64
             allow_failure: true
-          - version: 'nightly'
+          - version: 'pre'
             os: macOS-latest
             arch: x64
             allow_failure: true
-          - version: 'nightly'
+          - version: 'pre'
             os: windows-latest
             arch: x64
             allow_failure: true
     steps:
-      - uses: actions/checkout@v2
-      - uses: julia-actions/setup-julia@v1
+      - uses: actions/checkout@v4
+      - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v1
+      - uses: actions/cache@v4
         env:
           cache-name: cache-artifacts
         with:
@@ -49,6 +49,6 @@ jobs:
       - uses: julia-actions/julia-buildpkg@v1      
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v1
+      - uses: codecov/codecov-action@v4
         with:
           file: lcov.info

Project.toml

@@ -10,18 +10,14 @@ LinearOperators = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125"
 PartitionedStructures = "a6683cb1-4e99-4d03-b5b5-b79ed0acabcf"
 
 [compat]
-Krylov = "0.9.8"
+Krylov = "0.10.3"
 LinearOperators = "2.4.0"
 PartitionedStructures = "0.1.4, 0.1.5"
-julia = "^1.6.0"
+julia = "1.10"
 
 [extras]
-Krylov = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7"
-LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-LinearOperators = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125"
-PartitionedStructures = "a6683cb1-4e99-4d03-b5b5-b79ed0acabcf"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "LinearAlgebra", "StatsBase", "Krylov", "LinearOperators"]
+test = ["StatsBase", "Test"]

docs/Project.toml

@@ -6,8 +6,8 @@ PartitionedStructures = "a6683cb1-4e99-4d03-b5b5-b79ed0acabcf"
 PartitionedVectors = "9d5e22db-ddc8-46c9-8309-91b035e7f733"
 
 [compat]
-Documenter = "~0.27"
-Krylov = "0.9.8"
+Documenter = "1"
+Krylov = "0.10.3"
 LinearOperators = "2.4.0"
 PartitionedStructures = "0.1.4, 0.1.5"
-julia = "^1.6.0"
+julia = "1.10"

docs/make.jl

@@ -4,7 +4,6 @@ makedocs(
   modules = [PartitionedVectors],
   doctest = true,
   # linkcheck = true,
-  strict = true,
   format = Documenter.HTML(
     assets = ["assets/style.css"],
     ansicolor = true,

docs/src/tutorial.md

@@ -3,7 +3,7 @@
 A `PartitionedVector <: DenseVector <: AbstractVector` wraps a [`PartitionedStructures`](https://github.com/JuliaSmoothOptimizers/PartitionedStructures.jl)`.Elemental_pv`, to make [JuliaSmoothOptimizers](https://github.com/JuliaSmoothOptimizers) modules able to exploit the partially separable structure.
 For now, `PartitionedVector` is the keystone to define [PartiallySeparableNLPModel](https://github.com/JuliaSmoothOptimizers/PartiallySeparableNLPModels.jl)s, and then to consequently:
 - replace `Vector` in [JSOSolvers.jl](https://github.com/JuliaSmoothOptimizers/JSOSolvers.jl); 
-- replace `Vector` in [KrylovSolvers.jl](https://github.com/JuliaSmoothOptimizers/Krylov.jl);
+- replace `Vector` in [Krylov.jl](https://github.com/JuliaSmoothOptimizers/Krylov.jl);
 - make `LinearOperator`s relying only on `PartitionedVector`s viable;
 - fit the NLPModels interface (ex: `NLPModels.obj(nlp::PartiallySeparableNLPModel, x::PartitionedVector)` see PartiallySeparableNLPModels.jl for more details).
 
@@ -131,10 +131,10 @@ lo = LinearOperators.LinearOperator(epm)
 lo * pv
 ```
 Note: `Matrix(lo)` will produce an error, since the default implementation assumes a complete `Vector`-like behaviour.
-- dedicated `CGSolver` from Krylov.jl to solve a partitioned linear system (from a partitioned `LinearOperator`).
+- dedicated `CgWorkspace` from Krylov.jl to solve a partitioned linear system (from a partitioned `LinearOperator`).
 ```@example PV
 using Krylov # 0.9.0
-solver = Krylov.CgSolver(pv)
+solver = Krylov.CgWorkspace(pv)
 
 pv_gradient = similar(pv)
 (N,) = size(pv)
@@ -143,5 +143,5 @@ for i = 1:N
   pv_gradient[i] = rand(nie)
 end
 
-Krylov.solve!(solver, lo, -pv_gradient)
-```
+Krylov.krylov_solve!(solver, lo, -pv_gradient)
+```

src/krylov.jl

@@ -1,5 +1,5 @@
 import LinearAlgebra: axpy!, axpby!
-import Krylov.CgSolver
+import Krylov.CgWorkspace
 import Base.setproperty!
 
 function axpy!(
@@ -124,30 +124,32 @@ function axpby!(
   return y
 end
 
-function CgSolver(pv::PartitionedVector{T}) where {T}
+function CgWorkspace(pv::PartitionedVector{T}) where {T}
   n = length(pv)
   Δx = similar(pv; simulate_vector = true)
   Δx .= (T)(0) # by setting Δx .= 0, we ensure that at each iterate the initial point `r` is 0.
   x = similar(pv; simulate_vector = true)
   x .= (T)(0)
   r = similar(pv; simulate_vector = true)
   r .= (T)(0) # will be reset at each cg! call to 0 because of mul!(r,A,Δx)
+  npc_dir = similar(pv; simulate_vector = true)
+  npc_dir .= (T)(0)
   p = similar(pv; simulate_vector = true)
   p .= (T)(0)
   Ap = similar(pv; simulate_vector = false) # result of the partitioned matrix vector product
   Ap .= (T)(0)
   z = similar(pv; simulate_vector = true)
   z .= (T)(0)
-  stats = Krylov.SimpleStats(0, false, false, T[], T[], T[], 0.0, "unknown")
-  solver = Krylov.CgSolver{T, T, PartitionedVector{T}}(n, n, Δx, x, r, p, Ap, z, true, stats)
+  stats = Krylov.SimpleStats(0, false, false, false, 0, T[], T[], T[], 0.0, "unknown")
+  solver = Krylov.CgWorkspace{T, T, PartitionedVector{T}}(n, n, Δx, x, r, npc_dir, p, Ap, z, true, stats)
   return solver
 end
 
 # This way, solver.warm_start stays true at all time.
 # It prevents the else case where r .= b at the beginning of cg!.
 # r is supposed to simulate a vector while b is not supposed to.
 function setproperty!(
-  solver::CgSolver{T, T, PartitionedVector{T}},
+  solver::CgWorkspace{T, T, PartitionedVector{T}},
   sym::Symbol,
   val::Bool,
 ) where {T}

test/krylov.jl

@@ -37,7 +37,7 @@ end
   PS.update!(epm, epv, Float32(2.0) * epv; verbose = false)
   lo_epm = LinearOperators.LinearOperator(epm)
 
-  solver = Krylov.CgSolver(pv_x)
+  solver = Krylov.CgWorkspace(pv_x)
 
   pv_gradient = PartitionedVector(element_variables; T = Float32, n)
   # pv_gradient .= Float32(10.) .* pv_gradient
@@ -46,20 +46,20 @@ end
     pv_gradient[i] = rand(Float32, nie)
   end
 
-  Krylov.solve!(solver, lo_epm, -pv_gradient)
+  Krylov.krylov_solve!(solver, lo_epm, -pv_gradient)
 
-  x = Vector(solution(solver))
+  x = Vector(Krylov.solution(solver))
   g = Vector(pv_gradient)
   A = Matrix(epm)
 
   @test norm(A * x + g) <= 1e-2 * norm(g)
 
   grad = Vector(pv_gradient)
   pm_v = LinearOperator_for_Vector(epm)
-  solver_vector = Krylov.CgSolver(pm_v, grad)
+  solver_vector = Krylov.CgWorkspace(pm_v, grad)
 
-  Krylov.solve!(solver_vector, pm_v, -grad)
-  x_vector = solution(solver_vector)
+  Krylov.krylov_solve!(solver_vector, pm_v, -grad)
+  x_vector = Krylov.solution(solver_vector)
   check_nan = mapreduce(isnan, |, x_vector)
   !check_nan && @test x_vector ≈ x
 end