Use CUTEst 2.7.0

Project.toml

@@ -17,7 +17,7 @@ SIFDecode_jll = "54dcf436-342f-53ea-8005-3708a1ae6c8c"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
 [compat]
-CUTEst_jll = "2.6.0"
+CUTEst_jll = "2.7.0"
 Combinatorics = "1.0"
 DataStructures = "0.19"
 JSON = "1.5"
@@ -30,7 +30,7 @@ Printf = "1.10"
 Quadmath = "0.5.10, 1.0.1"
 REPL = "1.10"
 Random = "1.10"
-SIFDecode_jll = "3.0.0"
+SIFDecode_jll = "3.1.1"
 SparseArrays = "1.10"
 Test = "1.10"
 julia = "1.10"

src/classification.jl

@@ -2,8 +2,6 @@ import JSON
 using NLPModels
 
 # Some enumerations and correspondance dicts
-# Dict comprehension isn't defined in 0.4 and isn't handled by Compat
-# See https://github.com/JuliaLang/Compat.jl/issues/231
 const objtypes = ["none", "constant", "linear", "quadratic", "sum_of_squares", "other"]
 const classdb_objtype = Dict(
   "N" => objtypes[1],

src/core_interface.jl

@@ -3088,7 +3088,11 @@ for (cutest_uterminate, T) in (
   (:cutest_uterminate_q_, :Float128),
 )
   @eval begin
-    function uterminate(::Type{$T}, libsif::Ptr{Cvoid}, status::StrideOneVector{Cint})
+    function uterminate(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      status::StrideOneVector{Cint},
+    )
       $cutest_uterminate(libsif, status)
     end
   end
@@ -3110,7 +3114,11 @@ for (cutest_cterminate, T) in (
   (:cutest_cterminate_q_, :Float128),
 )
   @eval begin
-    function cterminate(::Type{$T}, libsif::Ptr{Cvoid}, status::StrideOneVector{Cint})
+    function cterminate(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      status::StrideOneVector{Cint},
+    )
       $cutest_cterminate(libsif, status)
     end
   end
@@ -3337,7 +3345,13 @@ function fopen end
 for (fortran_open, T) in
     ((:fortran_open_s_, :Float32), (:fortran_open_, :Float64), (:fortran_open_q_, :Float128))
   @eval begin
-    function fopen(::Type{$T}, libsif::Ptr{Cvoid}, funit, outsdif, status)
+    function fopen(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      funit,
+      outsdif,
+      status::StrideOneVector{Cint},
+    )
       $fortran_open(libsif, funit, outsdif, status)
     end
   end
@@ -3351,7 +3365,12 @@ function fclose end
 for (fortran_close, T) in
     ((:fortran_close_s_, :Float32), (:fortran_close_, :Float64), (:fortran_close_q_, :Float128))
   @eval begin
-    function fclose(::Type{$T}, libsif::Ptr{Cvoid}, funit, status)
+    function fclose(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      funit,
+      status::StrideOneVector{Cint},
+    )
       $fortran_close(libsif, funit, status)
     end
   end
@@ -3365,7 +3384,13 @@ function cconst end
 for (cutest_cconst, T) in
     ((:cutest_cconst_s_, :Float32), (:cutest_cconst_, :Float64), (:cutest_cconst_q_, :Float128))
   @eval begin
-    function cconst(::Type{$T}, libsif::Ptr{Cvoid}, status, m, c)
+    function cconst(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      status::StrideOneVector{Cint},
+      m::StrideOneVector{Cint},
+      c::StrideOneVector{$T},
+    )
       $cutest_cconst(libsif, status, m, c)
     end
   end
@@ -3379,12 +3404,64 @@ function ccf end
 for (cutest_ccf, T) in
     ((:cutest_ccf_s_, :Float32), (:cutest_ccf_, :Float64), (:cutest_ccf_q_, :Float128))
   @eval begin
-    function ccf(::Type{$T}, libsif::Ptr{Cvoid}, status, n, m, x, c)
+    function ccf(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      status::StrideOneVector{Cint},
+      n::StrideOneVector{Cint},
+      m::StrideOneVector{Cint},
+      x::StrideOneVector{$T},
+      c::StrideOneVector{$T},
+    )
       $cutest_ccf(libsif, status, n, m, x, c)
     end
   end
 end
 
+"""
+    cdimscj(T, libsif, status, nnzj)
+"""
+function cdimscj end
+
+for (cutest_cdimscj, T) in
+    ((:cutest_cdimscj_s_, :Float32), (:cutest_cdimscj_, :Float64), (:cutest_cdimscj_q_, :Float128))
+  @eval begin
+    function cdimscj(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      status::StrideOneVector{Cint},
+      nnzj::StrideOneVector{Cint},
+    )
+      $cutest_cdimscj(libsif, status, nnzj)
+    end
+  end
+end
+
+"""
+    csj(T, libsif, status, n, x, nnzj, lcjac, cjac, indvar, indcon)
+"""
+function csj end
+
+for (cutest_cint_csj, T) in
+    ((:cutest_cint_csj_s_, :Float32), (:cutest_cint_csj_, :Float64), (:cutest_cint_csj_q_, :Float128))
+  @eval begin
+    function csj(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      status::StrideOneVector{Cint},
+      n::StrideOneVector{Cint},
+      x::StrideOneVector{$T},
+      nnzj::StrideOneVector{Cint},
+      lcjac::StrideOneVector{Cint},
+      cjac::StrideOneVector{$T},
+      indvar::StrideOneVector{Cint},
+      indcon::StrideOneVector{Cint},
+    )
+      $cutest_cint_csj(libsif, status, n, x, nnzj, lcjac, cjac, indvar, indcon)
+    end
+  end
+end
+
 """
     classification(T, libsif, status, funit, class)
 """
@@ -3396,7 +3473,13 @@ for (cutest_classification, T) in (
   (:cutest_classification_q_, :Float128),
 )
   @eval begin
-    function classification(::Type{$T}, libsif::Ptr{Cvoid}, status, funit, class)
+    function classification(
+      ::Type{$T},
+      libsif::Ptr{Cvoid},
+      status::StrideOneVector{Cint},
+      funit,
+      class,
+    )
       $cutest_classification(libsif, status, funit, class)
     end
   end

src/julia_interface.jl

@@ -249,6 +249,7 @@ function NLPModels.cons!(
   @lencheck nlp.meta.nvar x
   @lencheck nlp.meta.ncon c
   ccf(T, nlp.libsif, nlp.status, nlp.nvar, nlp.ncon, x, c)
+  cutest_error(nlp.status[])
   increment!(nlp, :neval_cons)
   return c
 end
@@ -289,6 +290,7 @@ function NLPModels.cons_nln!(nlp::CUTEstModel{T}, x::AbstractVector, c::StrideOn
   for j in nlp.meta.nln
     ref_j[] = j
     cifn(T, nlp.libsif, nlp.status, nlp.nvar, ref_j, x, view(c, k:k))
+    cutest_error(nlp.status[])
     k += 1
   end
   increment!(nlp, :neval_cons_nln)
@@ -336,15 +338,42 @@ function NLPModels.jac_nln_structure!(
   return rows, cols
 end
 
+function NLPModels.jac_coord!(
+  nlp::CUTEstModel{T},
+  x::StrideOneVector{T},
+  vals::StrideOneVector{T},
+) where {T}
+  @lencheck nlp.meta.nvar x
+  @lencheck nlp.meta.nnzj vals
+  csj(
+    T,
+    nlp.libsif,
+    nlp.status,
+    nlp.nvar,
+    x,
+    nlp.nnzj,
+    nlp.nnzj,
+    vals,
+    nlp.jcols,
+    nlp.jrows
+  )
+  println(nlp.meta.name)
+  cutest_error(nlp.status[])
+  increment!(nlp, :neval_jac)
+  return vals
+end
+
 function NLPModels.jac_coord!(
   nlp::CUTEstModel{T},
   x::AbstractVector,
   vals::AbstractVector,
 ) where {T}
   @lencheck nlp.meta.nvar x
   @lencheck nlp.meta.nnzj vals
-  cons_coord!(nlp, x, nlp.workspace_ncon, nlp.jrows, nlp.jcols, vals)
-  decrement!(nlp, :neval_cons)  # does not really count as a constraint eval
+  x_ = Vector{T}(x)
+  vals_ = Vector{T}(vals)
+  jac_coord!(nlp, x_, vals_)
+  vals .= vals_
   return vals
 end
 
@@ -388,6 +417,7 @@ function NLPModels.jac_nln_coord!(
       nlp.Jvar,
       bool,
     )
+    cutest_error(nlp.status[])
     for k = 1:nlp.nnzj[]
       vals[i] = nlp.Jval[k]
       i += 1
@@ -777,5 +807,6 @@ function NLPModels.jth_hess_coord!(
     nlp.hcols,
     nlp.hrows,
   )
+  cutest_error(nlp.status[])
   return vals
 end

src/libcutest.jl

@@ -69,6 +69,11 @@ function cutest_cdimsj_(libsif, status, nnzj)
   @ccall $ptr_cutest_cdimsj_(status::Ptr{Cint}, nnzj::Ptr{Cint})::Cvoid
 end
 
+function cutest_cdimscj_(libsif, status, nnzj)
+  ptr_cutest_cdimscj_ = Libdl.dlsym(libsif, :cutest_cdimscj_)
+  @ccall $ptr_cutest_cdimscj_(status::Ptr{Cint}, nnzj::Ptr{Cint})::Cvoid
+end
+
 function cutest_cdimsh_(libsif, status, nnzh)
   ptr_cutest_cdimsh_ = Libdl.dlsym(libsif, :cutest_cdimsh_)
   @ccall $ptr_cutest_cdimsh_(status::Ptr{Cint}, nnzh::Ptr{Cint})::Cvoid
@@ -297,6 +302,13 @@ function cutest_csjp_(libsif, status, nnzj, lj, jvar, jcon)
                            jcon::Ptr{Cint})::Cvoid
 end
 
+function cutest_cint_csj_(libsif, status, n, x, nnzj, lcjac, cjac, indvar, indcon)
+  ptr_cutest_cint_csj_ = Libdl.dlsym(libsif, :cutest_cint_csj_)
+  @ccall $ptr_cutest_cint_csj_(status::Ptr{Cint}, n::Ptr{Cint}, x::Ptr{Float64}, nnzj::Ptr{Cint},
+                               lcjac::Ptr{Cint}, cjac::Ptr{Float64}, indvar::Ptr{Cint},
+                               indcon::Ptr{Cint})::Cvoid
+end
+
 function cutest_cint_ccfsg_(libsif, status, n, m, x, c, nnzj, lcjac, cjac, indvar, indfun, grad)
   ptr_cutest_cint_ccfsg_ = Libdl.dlsym(libsif, :cutest_cint_ccfsg_)
   @ccall $ptr_cutest_cint_ccfsg_(status::Ptr{Cint}, n::Ptr{Cint}, m::Ptr{Cint}, x::Ptr{Float64},
@@ -626,6 +638,11 @@ function cutest_cdimsj_s_(libsif, status, nnzj)
   @ccall $ptr_cutest_cdimsj_s_(status::Ptr{Cint}, nnzj::Ptr{Cint})::Cvoid
 end
 
+function cutest_cdimscj_s_(libsif, status, nnzj)
+  ptr_cutest_cdimscj_s_ = Libdl.dlsym(libsif, :cutest_cdimscj_s_)
+  @ccall $ptr_cutest_cdimscj_s_(status::Ptr{Cint}, nnzj::Ptr{Cint})::Cvoid
+end
+
 function cutest_cdimsh_s_(libsif, status, nnzh)
   ptr_cutest_cdimsh_s_ = Libdl.dlsym(libsif, :cutest_cdimsh_s_)
   @ccall $ptr_cutest_cdimsh_s_(status::Ptr{Cint}, nnzh::Ptr{Cint})::Cvoid
@@ -857,6 +874,13 @@ function cutest_csjp_s_(libsif, status, nnzj, lj, jvar, jcon)
                              jcon::Ptr{Cint})::Cvoid
 end
 
+function cutest_cint_csj_s_(libsif, status, n, x, nnzj, lcjac, cjac, indvar, indcon)
+  ptr_cutest_cint_csj_s_ = Libdl.dlsym(libsif, :cutest_cint_csj_s_)
+  @ccall $ptr_cutest_cint_csj_s_(status::Ptr{Cint}, n::Ptr{Cint}, x::Ptr{Float32}, nnzj::Ptr{Cint},
+                                 lcjac::Ptr{Cint}, cjac::Ptr{Float32}, indvar::Ptr{Cint},
+                                 indcon::Ptr{Cint})::Cvoid
+end
+
 function cutest_cint_ccfsg_s_(libsif, status, n, m, x, c, nnzj, lcjac, cjac, indvar, indfun, grad)
   ptr_cutest_cint_ccfsg_s_ = Libdl.dlsym(libsif, :cutest_cint_ccfsg_s_)
   @ccall $ptr_cutest_cint_ccfsg_s_(status::Ptr{Cint}, n::Ptr{Cint}, m::Ptr{Cint}, x::Ptr{Float32},
@@ -1190,6 +1214,11 @@ function cutest_cdimsj_q_(libsif, status, nnzj)
   @ccall $ptr_cutest_cdimsj_q_(status::Ptr{Cint}, nnzj::Ptr{Cint})::Cvoid
 end
 
+function cutest_cdimscj_q_(libsif, status, nnzj)
+  ptr_cutest_cdimscj_q_ = Libdl.dlsym(libsif, :cutest_cdimscj_q_)
+  @ccall $ptr_cutest_cdimscj_q_(status::Ptr{Cint}, nnzj::Ptr{Cint})::Cvoid
+end
+
 function cutest_cdimsh_q_(libsif, status, nnzh)
   ptr_cutest_cdimsh_q_ = Libdl.dlsym(libsif, :cutest_cdimsh_q_)
   @ccall $ptr_cutest_cdimsh_q_(status::Ptr{Cint}, nnzh::Ptr{Cint})::Cvoid
@@ -1423,6 +1452,13 @@ function cutest_csjp_q_(libsif, status, nnzj, lj, jvar, jcon)
                              jcon::Ptr{Cint})::Cvoid
 end
 
+function cutest_cint_csj_q_(libsif, status, n, x, nnzj, lcjac, cjac, indvar, indcon)
+  ptr_cutest_cint_csj_q_ = Libdl.dlsym(libsif, :cutest_cint_csj_q_)
+  @ccall $ptr_cutest_cint_csj_q_(status::Ptr{Cint}, n::Ptr{Cint}, x::Ptr{Float128}, nnzj::Ptr{Cint},
+                                 lcjac::Ptr{Cint}, cjac::Ptr{Float128}, indvar::Ptr{Cint},
+                                 indcon::Ptr{Cint})::Cvoid
+end
+
 function cutest_cint_ccfsg_q_(libsif, status, n, m, x, c, nnzj, lcjac, cjac, indvar, indfun, grad)
   ptr_cutest_cint_ccfsg_q_ = Libdl.dlsym(libsif, :cutest_cint_ccfsg_q_)
   @ccall $ptr_cutest_cint_ccfsg_q_(status::Ptr{Cint}, n::Ptr{Cint}, m::Ptr{Cint}, x::Ptr{Float128},

src/model.jl

@@ -217,8 +217,7 @@ function CUTEstModel{T}(
 
   if ncon[] > 0
     cdimsh(T, libsif, status, nnzh)
-    cdimsj(T, libsif, status, nnzj)
-    nnzj[] -= nvar[]  # nnzj also counts the nonzeros in the objective gradient.
+    cdimscj(T, libsif, status, nnzj)
   else
     udimsh(T, libsif, status, nnzh)
   end

src/sifdecoder.jl

@@ -139,7 +139,7 @@ function sifdecoder(
       ),
     )
     error_str = read(errlog, String)
-    if length(error_str) > 0 && (error_str != "STOP 0\n")
+    if length(error_str) > 0
       println(error_str)
       error("Unable to compile a shared library for the problem $name.")
     end

test/test_counters.jl

@@ -165,10 +165,10 @@ end
     @test cutest_increments.neval_obj == 0  # CUTEst doesn't count obj in constrained setup
 
     @test julia_increments.neval_cons == 1
-    @test cutest_increments.neval_cons == 2  # CUTEst counts 1 extra constraint call
+    @test cutest_increments.neval_cons == 1
 
     @test julia_increments.neval_jac == 1
-    @test cutest_increments.neval_jac == 2  # CUTEst counts 1 extra jacobian call
+    @test cutest_increments.neval_jac == 1
 
     @test julia_increments.neval_hess == 1
     @test cutest_increments.neval_hess == 2  # CUTEst counts 1 extra hessian call