Add problems 5-13 except 9,10

src/ADNLPProblems/auglag.jl

@@ -0,0 +1,52 @@
+export auglag
+
+function auglag(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  λ₁ = T(-0.002008)
+  λ₂ = T(-0.001900)
+  λ₃ = T(-0.000261)
+
+  function f(x; n = length(x))
+    s = zero(T)
+    for i = 1:n
+      if mod(i, 5) == 0
+        prod_term = one(T)
+        sum_sq = zero(T)
+        for j = 1:5
+          idx = i + 1 - j
+          if 1 <= idx <= n
+            prod_term *= x[idx]
+            sum_sq += x[idx]^2
+          end
+        end
+        s += exp(prod_term) + 10 * (sum_sq - 10 - λ₁)^2
+
+        if i >= 4
+          s += 10 * (x[i-3] * x[i-2] - 5 * x[i-1] * x[i] - λ₂)^2
+        end
+
+        if i >= 4
+          s += 10 * (x[i-4]^3 + x[i-3]^3 + 1 - λ₃)^2
+        end
+      end
+    end
+    return s
+  end
+
+  x0 = zeros(T, n)
+  for i = 1:n
+    m = mod(i, 5)
+    if m == 1
+      x0[i] = i <= 2 ? T(-2) : T(-1)
+    elseif m == 2
+      x0[i] = i <= 2 ? T(2) : T(-1)
+    elseif m == 3
+      x0[i] = T(2)
+    elseif m == 4
+      x0[i] = T(-1)
+    else
+      x0[i] = T(-1)
+    end
+  end
+
+  return ADNLPModels.ADNLPModel(f, x0, name = "auglag"; kwargs...)
+end

src/ADNLPProblems/browngen1.jl

@@ -0,0 +1,16 @@
+export browngen1
+
+function browngen1(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  n = max(2, n)
+  function f(x; n = length(x))
+    s = zero(T)
+    @inbounds for i in 2:n
+      s += (x[i - 1] - 3)^2 +
+           (x[i - 1] - x[i])^2 +
+           exp(20 * (x[i - 1] - x[i]))
+    end
+    return s
+  end
+  x0 = [isodd(i) ? zero(T) : -one(T) for i in 1:n]
+  return ADNLPModels.ADNLPModel(f, x0, name = "browngen1"; kwargs...)
+end

src/ADNLPProblems/browngen2.jl

@@ -0,0 +1,14 @@
+export browngen2
+
+function browngen2(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  n = max(2, n)
+  function f(x; n = length(x))
+    s = zero(T)
+    @inbounds for i = 2:n
+      s += (x[i-1]^2)^(x[i]^2 + 1) + (x[i]^2)^(x[i-1]^2 + 1)
+    end
+    return s
+  end
+  x0 = [isodd(i) ? -one(T) : one(T) for i in 1:n]
+  return ADNLPModels.ADNLPModel(f, x0, name = "browngen2"; kwargs...)
+end

src/ADNLPProblems/broyden7d.jl

@@ -0,0 +1,48 @@
+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}
+  p = 7 // 3
+  function f(x; n = length(x),  p = p)
+    x0 = zero(T)
+    xn1 = zero(T)
+    s = zero(T)
+    s += abs((3 - 2 * x[1]) * x[1] - x0 - x[2] + 1)^p
+    for i = 2:(n - 1)
+      s += abs((3 - 2 * x[i]) * x[i] - x[i - 1] - x[i + 1] + 1)^p
+    end
+    s += abs((3 - 2 * x[n]) * x[n] - x[n - 1] - xn1 + 1)^p
+    nh = div(n, 2)
+    for i = 1:nh
+      s += abs(x[i] + x[i + nh])^p
+    end
+    return s
+  end
+  x0 = fill(-one(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}
+  x0 = fill(-one(T), n)
+  function F!(r, x; n = length(x))
+    p = 7 // 6
+    nh = div(n, 2)
+    @inbounds begin
+      r[1] = abs((3 - 2 * x[1]) * x[1] - zero(T) - x[2] + one(T))^p
+      for i = 2:(n - 1)
+        r[i] = abs((3 - 2 * x[i]) * x[i] - x[i - 1] - x[i + 1] + one(T))^p
+      end
+      r[n] = abs((3 - 2 * x[n]) * x[n] - x[n - 1] - zero(T) + one(T))^p
+      for i = 1:nh
+        r[n + i] = abs(x[i] + x[i + nh])^p
+      end
+    end
+    return r
+  end
+  nequ = n + div(n, 2)
+  return ADNLPModels.ADNLSModel!(F!, x0, nequ, 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,26 @@ 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))
+    nb = div(n, 2) - 1
+    r[1] = 1
+    idx = 2
+    @inbounds for i = 1:nb
+      r[idx]     = 10 * (x[2*i] - x[2*i - 1]^2)
+      r[idx + 1] = 1 - x[2*i - 1]
+      r[idx + 2] = T(sqrt(90)) * (x[2*i + 2] - x[2*i + 1]^2)
+      r[idx + 3] = 1 - x[2*i + 1]
+      r[idx + 4] = T(sqrt(10)) * (x[2*i] + x[2*i + 2] - 2)
+      r[idx + 5] = (x[2*i] - x[2*i + 2]) / T(sqrt(10))
+      idx += 6
+    end
+    return r
+  end
+  nequ = 1 + 6 * (div(n, 2) - 1)
+  x0 = vcat([-3, -1, -3, -1], -2 * ones(T, n - 4))
+  return ADNLPModels.ADNLSModel!(F!, x0, nequ, 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))
@@ -15,3 +20,21 @@ function cragglvy2(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...)
   x0 = vcat(1, 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[5 * (i - 1) + 1] = (exp(x[2 * i - 1]) - x[2 * i])^2
+      r[5 * (i - 1) + 2] = 10 * (x[2 * i] - x[2 * i + 1])^3
+      r[5 * (i - 1) + 3] = (tan(x[2 * i + 1] - x[2 * i + 2]))^2
+      r[5 * (i - 1) + 4] = x[2 * i - 1]^4
+      r[5 * (i - 1) + 5] = x[2 * i + 2] - 1
+    end
+    return r
+  end
+  nequ = 5 * (div(n, 2) - 1)
+  x0 = vcat(T(1), T(2) * ones(T, n - 1))
+  return ADNLPModels.ADNLSModel!(F!, x0, nequ, name = "cragglvy2-nls"; kwargs...)
+end

src/ADNLPProblems/genbroydenb.jl

@@ -0,0 +1,47 @@
+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, kwargs...) where {T}
+  p = 7 // 3
+  function f(x; n = length(x))
+    s = zero(T)
+    for i = 1:n
+      diag = (2 + 5 * x[i]^2) * x[i] + 1
+      neigh = zero(T)
+      @inbounds for j = max(1, i - 5):min(n, i + 1)
+        if j != i
+          neigh += x[j] * (1 + x[j])
+        end
+      end
+      s += abs(diag + neigh)^p
+    end
+    return s
+  end
+  x0 = fill(-one(T), n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "genbroydenb", minimize = true; kwargs...)
+end
+
+function genbroydenb(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  p = 7 // 6
+  function F!(r, x; n = length(x))
+    @inbounds for i = 1:n
+      diag = (2 + 5 * x[i]^2) * x[i] + 1
+      neigh = zero(T)
+      lo = max(1, i - 5)
+      hi = min(n, i + 1)
+      for j = lo:hi
+        if j != i
+          neigh += x[j] * (1 + x[j])
+        end
+      end
+      r[i] = abs(diag + neigh)^p
+    end
+    return r
+  end
+  x0 = fill(-one(T), n)
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "genbroydenb-nls"; kwargs...)
+end

src/ADNLPProblems/genbroydentri.jl

@@ -0,0 +1,40 @@
+export genbroydentri
+
+function genbroydentri(; use_nls::Bool = false, kwargs...)
+  model = use_nls ? :nls : :nlp
+  return genbroydentri(Val(model); kwargs...)
+end
+
+function genbroydentri(::Val{:nlp}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  p = 7 // 3
+  function f(x; n = length(x))
+    x0 = zero(T)
+    xn1 = zero(T)
+    s = abs((3 - 2 * x[1]) * x[1] - x0 - x[2] + 1)^p
+    for i = 2:(n - 1)
+      s += abs((3 - 2 * x[i]) * x[i] - x[i - 1] - x[i + 1] + 1)^p
+    end
+    s += abs((3 - 2 * x[n]) * x[n] - x[n - 1] - xn1 + 1)^p
+    return s
+  end
+  x0 = fill(-one(T), n)
+  return ADNLPModels.ADNLPModel(f, x0, name = "genbroydentri"; kwargs...)
+end
+
+function genbroydentri(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  p = 7 // 6
+  x0 = fill(-one(T), n)
+  function F!(r, x)
+    x0_val = zero(T)
+    xn1_val = zero(T)
+    @inbounds begin
+      r[1] = abs((3 - 2 * x[1]) * x[1] - x0_val - x[2] + 1)^p
+      for i = 2:(n - 1)
+        r[i] = abs((3 - 2 * x[i]) * x[i] - x[i - 1] - x[i + 1] + 1)^p
+      end
+      r[n] = abs((3 - 2 * x[n]) * x[n] - x[n - 1] - xn1_val + 1)^p
+    end
+    return r
+  end
+  return ADNLPModels.ADNLSModel!(F!, x0, n, name = "genbroydentri-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,21 @@ function genrose(; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) wh
   return ADNLPModels.ADNLPModel(f, x0, name = "genrose"; kwargs...)
 end
 
-rosenbrock(args...; kwargs...) =
-  genrose(args..., n = 2, name = "rosenbrock"; delete!(Dict(kwargs), :n)...)
+function genrose(::Val{:nls}; n::Int = default_nvar, type::Type{T} = Float64, kwargs...) where {T}
+  n = max(2, n)
+  nequ = 2 * (n - 1) + 1
+  function F!(r, x; n = length(x))
+    @inbounds begin
+      r[1] = 1
+      for i = 1:(n - 1)
+        r[i + 1] = 10 * (x[i + 1] - x[i]^2)
+        r[i + n] = x[i] - 1
+      end
+    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)...)