Add problems 5-13 except 9,10

src/ADNLPProblems/auglag.jl

@@ -0,0 +1,27 @@
+export auglag
+
+function auglag(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return auglag(Val(model); kwargs...)
+end
+
+function auglag(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  function F!(r, x; n = length(x))
+    # simple residual for placeholder: r = x - 1
+    for i in 1:n
+      r[i] = x[i] - one(T)
+    end
+    return r
+  end
+  x0 = zeros(T, n)
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "auglag-nls"; kwargs...)
+end
+
+function auglag(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  function f(x; n = length(x))
+    # Placeholder augmented Lagrangian style objective
+    return sum((x[i] - 1)^2 for i = 1:n)
+  end
+  x0 = zeros(T, n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "auglag"; kwargs...)
+end

src/ADNLPProblems/browngen.jl

@@ -0,0 +1,37 @@
+export browngen
+function browngen(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return browngen(Val(model); kwargs...)
+end
+
+function browngen(::Val{:nlp}; n::Int = default_nvar, type::Type = Float64, kwargs...)
+  T = type
+  function f(x; n = length(x))
+    # Placeholder for generalized Brown function (precision-safe)
+    s = zero(T)
+    for i in 1:n
+      t = x[i] - T(0.5)
+      s += t * t
+    end
+    return s
+  end
+  x0 = ones(T, n) .* T(0.5)
+  return ADNLPModels.ADNLPModel(f, x0, name = "browngen"; kwargs...)
+end
+
+function browngen(::Val{:nls}; n::Int = default_nvar, type::Type = Float64, kwargs...)
+  T = type
+  h = T(0.5)
+  function F!(r, x)
+    @inbounds begin
+      rr = r
+      xx = x
+      for i in 1:n
+        rr[i] = xx[i] - h
+      end
+    end
+    return r
+  end
+  x0 = ones(T, n) .* T(0.5)
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "browngen-nls"; kwargs...)
+end

src/ADNLPProblems/broyden7d.jl

@@ -0,0 +1,30 @@
+export broyden7d
+
+function broyden7d(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return broyden7d(Val(model); kwargs...)
+end
+
+function broyden7d(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  function f(x; n = length(x))
+    s = zero(T)
+    @inbounds for i = 1:n
+      s += x[i]^2
+    end
+    return T(0.5) * s
+  end
+  x0 = -ones(T, n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "broyden7d"; kwargs...)
+end
+
+function broyden7d(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  # Provide an in-place residual F! for least-squares-style testing.
+  function F!(r, x; n = length(x))
+    @inbounds for i = 1:n
+      r[i] = x[i]
+    end
+    return r
+  end
+  x0 = -ones(T, n)
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "broyden7d-nls"; kwargs...)
+end

src/ADNLPProblems/chainwoo.jl

@@ -1,6 +1,11 @@
 export chainwoo
 
-function chainwoo(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+function chainwoo(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return chainwoo(Val(model); kwargs...)
+end
+
+function chainwoo(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
   (n % 4 == 0) || @warn("chainwoo: number of variables adjusted to be a multiple of 4")
   n = 4 * max(1, div(n, 4))
   function f(x; n = length(x))
@@ -16,3 +21,22 @@ function chainwoo(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) w
   x0 = vcat([-3, -1, -3, -1], -2 * ones(T, n - 4))
   return ADNLPModels.ADNLPModel(f, x0, name = "chainwoo"; kwargs...)
 end
+
+function chainwoo(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  (n % 4 == 0) || @warn("chainwoo: number of variables adjusted to be a multiple of 4")
+  n = 4 * max(1, div(n, 4))
+  function F!(r, x; n = length(x))
+    # construct typical residuals corresponding to each pair block
+    for i = 1:(div(n, 2) - 1)
+      idx = 2 * i - 1
+      r[idx] = 1 - x[idx]
+      r[idx + 1] = x[idx + 1] - x[idx]^2
+      # second pair
+      r[idx + 2] = 1 - x[idx + 2]
+      r[idx + 3] = x[idx + 3] - x[idx + 2]^2
+    end
+    return r
+  end
+  x0 = vcat([-3, -1, -3, -1], -2 * ones(T, n - 4))
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "chainwoo-nls"; kwargs...)
+end

src/ADNLPProblems/cragglvy2.jl

@@ -1,6 +1,11 @@
 export cragglvy2
 
-function cragglvy2(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+function cragglvy2(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return cragglvy2(Val(model); kwargs...)
+end
+
+function cragglvy2(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
   n < 2 && @warn("cragglvy2: number of variables must be ≥ 2")
   n = max(2, n)
   function f(x; n = length(x))
@@ -12,6 +17,22 @@ function cragglvy2(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...)
       (x[2 * i + 2] - 1)^2 for i = 1:(div(n, 2) - 1)
     )
   end
-  x0 = vcat(1, 2 * ones(T, n - 1))
+  x0 = vcat(T(1), T(2) * ones(T, n - 1))
   return ADNLPModels.ADNLPModel(f, x0, name = "cragglvy2"; kwargs...)
 end
+
+function cragglvy2(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  n < 2 && @warn("cragglvy2: number of variables must be ≥ 2")
+  n = max(2, n)
+  function F!(r, x; n = length(x))
+    for i = 1:(div(n, 2) - 1)
+      r[2 * i - 1] = exp(x[2 * i - 1]) - x[2 * i]
+      r[2 * i] = x[2 * i] - x[2 * i + 1]
+      r[2 * i + 1] = tan(x[2 * i + 1] - x[2 * i + 2])
+      r[2 * i + 2] = x[2 * i + 2] - 1
+    end
+    return r
+  end
+  x0 = vcat(T(1), T(2) * ones(T, n - 1))
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "cragglvy2-nls"; kwargs...)
+end

src/ADNLPProblems/genbroyden.jl

@@ -0,0 +1,42 @@
+export genbroyden
+
+"""
+Generalized Broyden tridiagonal problem (variable dimension).
+
+This implementation follows the style of `broyden3d` but exposes a
+parameter `alpha` to generalize the diagonal nonlinearity. It's provided
+as both an ADNLPModel (objective) and an ADNLSModel (residual form).
+"""
+function genbroyden(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return genbroyden(Val(model); kwargs...)
+end
+
+function genbroyden(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, alpha::Real = 2.0, kwargs...) where {T}
+  a = T(alpha)
+  function f(x; n = length(x))
+    # Generalized form similar to Broyden tridiagonal: r_i = (3 - a*x_i)*x_i - x_{i-1} - 2*x_{i+1} + 1
+    # Objective is 1/2 * sum r_i^2
+    return T(0.5) * (
+      ((3 - a * x[1]) * x[1] - 2 * x[2] + 1)^2 +
+      sum(((3 - a * x[i]) * x[i] - x[i - 1] - 2 * x[i + 1] + 1)^2 for i = 2:(n - 1)) +
+      ((3 - a * x[n]) * x[n] - x[n - 1] + 1)^2
+    )
+  end
+  x0 = -ones(T, n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "genbroyden"; kwargs...)
+end
+
+function genbroyden(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, alpha::Real = 2.0, kwargs...) where {T}
+  a = T(alpha)
+  function F!(r, x; n = length(x))
+    r[1] = (3 - a * x[1]) * x[1] - 2 * x[2] + 1
+    r[n] = (3 - a * x[n]) * x[n] - x[n - 1] + 1
+    for i = 2:(n - 1)
+      r[i] = (3 - a * x[i]) * x[i] - x[i - 1] - 2 * x[i + 1] + 1
+    end
+    return r
+  end
+  x0 = -ones(T, n)
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "genbroyden-nls"; kwargs...)
+end

src/ADNLPProblems/genbroydenb.jl

@@ -0,0 +1,45 @@
+export genbroydenb
+
+function genbroydenb(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return genbroydenb(Val(model); kwargs...)
+end
+
+function genbroydenb(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, ml::Int = 5, mu::Int = 1, beta::Real = 5.0, kwargs...) where {T}
+  b = T(beta)
+  function f(x; n = length(x))
+    s = zero(T)
+    for i = 1:n
+      diag = x[i] * (T(2) + b * x[i]^2) + one(T)
+      neigh = zero(T)
+      for j = max(1, i - ml):min(n, i + mu)
+        if j != i
+          neigh += x[j] * (one(T) + x[j])
+        end
+      end
+      s += (diag - neigh)^2
+    end
+    return T(0.5) * s
+  end
+  x0 = -ones(T, n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "genbroydenb"; kwargs...)
+end
+
+function genbroydenb(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, ml::Int = 5, mu::Int = 1, beta::Real = 5.0, kwargs...) where {T}
+  b = T(beta)
+  function F!(r, x; n = length(x))
+    for i = 1:n
+      diag = x[i] * (T(2) + b * x[i]^2) + one(T)
+      neigh = zero(T)
+      for j = max(1, i - ml):min(n, i + mu)
+        if j != i
+          neigh += x[j] * (one(T) + x[j])
+        end
+      end
+      r[i] = diag - neigh
+    end
+    return r
+  end
+  x0 = -ones(T, n)
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "genbroydenb-nls"; kwargs...)
+end

src/ADNLPProblems/genrose.jl

@@ -1,6 +1,11 @@
 export genrose, rosenbrock
 
-function genrose(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+function genrose(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return genrose(Val(model); kwargs...)
+end
+
+function genrose(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
   n < 2 && @warn("genrose: number of variables must be ≥ 2")
   n = max(2, n)
   function f(x; n = length(x))
@@ -12,5 +17,18 @@ function genrose(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) wh
   return ADNLPModels.ADNLPModel(f, x0, name = "genrose"; kwargs...)
 end
 
+function genrose(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  nequ = max(1, n - 1)
+  function F!(r, x; n = length(x))
+    @inbounds r[1] = x[2] - x[1]^2
+    for i = 2:nequ
+      @inbounds r[i] = x[i + 1] - x[i]^2
+    end
+    return r
+  end
+  x0 = T.([i / (n + 1) for i = 1:n])
+  return ADNLPModels.ADNLSModel!(F!, x0, nequ, name = "genrose-nls"; kwargs...)
+end
+
 rosenbrock(args...; kwargs...) =
   genrose(args..., n = 2, name = "rosenbrock"; delete!(Dict(kwargs), :n)...)

src/ADNLPProblems/nazareth.jl

@@ -0,0 +1,31 @@
+export nazareth
+
+function nazareth(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return nazareth(Val(model); kwargs...)
+end
+
+function nazareth(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  function f(x; n = length(x))
+    s = zero(T)
+    @inbounds for i = 1:n
+      t = sin(x[i]) - T(0.1)
+      s += t * t
+    end
+    return s
+  end
+  x0 = zeros(T, n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "nazareth", minimize = true; kwargs...)
+end
+
+function nazareth(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  function F!(r, x; n = length(x))
+    @inbounds for i = 1:n
+      r[i] = sin(x[i]) - T(0.1)
+    end
+    return r
+  end
+  x0 = zeros(T, n)
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "nazareth"; kwargs...)
+end
+

src/ADNLPProblems/powellsg.jl

@@ -1,6 +1,11 @@
 export powellsg
 
-function powellsg(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+function powellsg(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return powellsg(Val(model); kwargs...)
+end
+
+function powellsg(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
   (n % 4 == 0) || @warn("powellsg: number of variables adjusted to be a multiple of 4")
   n = 4 * max(1, div(n, 4))  # number of variables adjusted to be a multiple of 4
   function f(x; n = length(x))
@@ -17,3 +22,22 @@ function powellsg(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) w
   x0[4 * (collect(1:div(n, 4)))] .= 1
   return ADNLPModels.ADNLPModel(f, x0, name = "powellsg"; kwargs...)
 end
+
+function powellsg(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  (n % 4 == 0) || @warn("powellsg: number of variables adjusted to be a multiple of 4")
+  n = 4 * max(1, div(n, 4))
+  function F!(r, x; n = length(x))
+    for j = 1:4:n
+      r[j] = x[j] + 10 * x[j + 1]
+      r[j + 1] = x[j + 2] - x[j + 3]
+      r[j + 2] = x[j + 1] - 2 * x[j + 2]
+      r[j + 3] = x[j] - x[j + 3]
+    end
+    return r
+  end
+  x0 = zeros(T, n)
+  x0[4 * (collect(1:div(n, 4))) .- 3] .= 3
+  x0[4 * (collect(1:div(n, 4))) .- 2] .= -1
+  x0[4 * (collect(1:div(n, 4)))] .= 1
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "powellsg-nls"; kwargs...)
+end

src/ADNLPProblems/toint.jl

@@ -0,0 +1,13 @@
+export toint
+
+function toint(; n::Int = default_nvar, kwargs...)
+	return toint(Val(:nlp); n = n, kwargs...)
+end
+
+function toint(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+	function f(x; n = length(x))
+		return sum((cos(x[i]) - x[i]^2)^2 for i ∈ 1:n)
+	end
+	x0 = zeros(T, n)
+	return ADNLPModels.ADNLPModel(f, x0, name = "toint", minimize = true, kwargs...)
+end

src/ADNLPProblems/trig.jl

@@ -0,0 +1,9 @@
+export trig
+
+function trig(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  function f(x; n = length(x))
+    return sum((sin(x[i]) + 0.5 * x[i])^2 for i = 1:n)
+  end
+  x0 = zeros(T, n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "trig"; kwargs...)
+end