renamed: nonlin constraint vector C -> g

franckgaga · franckgaga · commit 11d59a63813c · 2023-11-01T21:23:38.000-04:00
diff --git a/src/controller/nonlinmpc.jl b/src/controller/nonlinmpc.jl
@@ -258,21 +258,21 @@ function init_optimization!(mpc::NonLinMPC)
     @constraint(optim, linconstraint, A*ΔŨvar .≤ b)
     # --- nonlinear optimization init ---
     model = mpc.estim.model
-    ny, nx̂, Hp, nC = model.ny, mpc.estim.nx̂, mpc.Hp, length(con.i_C)
+    ny, nx̂, Hp, ng = model.ny, mpc.estim.nx̂, mpc.Hp, length(con.i_g)
     # inspired from https://jump.dev/JuMP.jl/stable/tutorials/nonlinear/tips_and_tricks/#User-defined-operators-with-vector-outputs
-    Jfunc, Cfunc = let mpc=mpc, model=model, nC=nC, nvar=nvar , nŶ=Hp*ny, nx̂=nx̂
+    Jfunc, gfunc = let mpc=mpc, model=model, ng=ng, nvar=nvar , nŶ=Hp*ny, nx̂=nx̂
         last_ΔŨtup_float, last_ΔŨtup_dual = nothing, nothing
         Ŷ_cache::DiffCacheType = DiffCache(zeros(nŶ), nvar + 3)
-        C_cache::DiffCacheType = DiffCache(zeros(nC), nvar + 3)
+        g_cache::DiffCacheType = DiffCache(zeros(ng), nvar + 3)
         x̂_cache::DiffCacheType = DiffCache(zeros(nx̂), nvar + 3)
         function Jfunc(ΔŨtup::Float64...)
             Ŷ = get_tmp(Ŷ_cache, ΔŨtup[1])
             ΔŨ = collect(ΔŨtup)
             if ΔŨtup != last_ΔŨtup_float
                 x̂ = get_tmp(x̂_cache, ΔŨtup[1])
-                C = get_tmp(C_cache, ΔŨtup[1])
+                g = get_tmp(g_cache, ΔŨtup[1])
                 Ŷ, x̂end = predict!(Ŷ, x̂, mpc, model, ΔŨ)
-                con_nonlinprog!(C, mpc, model, x̂end, Ŷ, ΔŨ)
+                con_nonlinprog!(g, mpc, model, x̂end, Ŷ, ΔŨ)
                 last_ΔŨtup_float = ΔŨtup
             end
             return obj_nonlinprog(mpc, model, Ŷ, ΔŨ)
@@ -282,59 +282,59 @@ function init_optimization!(mpc::NonLinMPC)
             ΔŨ = collect(ΔŨtup)
             if ΔŨtup != last_ΔŨtup_dual
                 x̂ = get_tmp(x̂_cache, ΔŨtup[1])
-                C = get_tmp(C_cache, ΔŨtup[1])
+                g = get_tmp(g_cache, ΔŨtup[1])
                 Ŷ, x̂end = predict!(Ŷ, x̂, mpc, model, ΔŨ)
-                con_nonlinprog!(C, mpc, model, x̂end, Ŷ, ΔŨ)
+                con_nonlinprog!(g, mpc, model, x̂end, Ŷ, ΔŨ)
                 last_ΔŨtup_dual = ΔŨtup
             end
             return obj_nonlinprog(mpc, model, Ŷ, ΔŨ)
         end
-        function con_nonlinprog_i(i, ΔŨtup::NTuple{N, Float64}) where {N}
-            C = get_tmp(C_cache, ΔŨtup[1])
+        function gfunc_i(i, ΔŨtup::NTuple{N, Float64}) where {N}
+            g = get_tmp(g_cache, ΔŨtup[1])
             if ΔŨtup != last_ΔŨtup_float
                 x̂ = get_tmp(x̂_cache, ΔŨtup[1])
                 Ŷ = get_tmp(Ŷ_cache, ΔŨtup[1])
                 ΔŨ = collect(ΔŨtup)
                 Ŷ, x̂end = predict!(Ŷ, x̂, mpc, model, ΔŨ)
-                C = con_nonlinprog!(C, mpc, model, x̂end, Ŷ, ΔŨ)
+                g = con_nonlinprog!(g, mpc, model, x̂end, Ŷ, ΔŨ)
                 last_ΔŨtup_float = ΔŨtup
             end
-            return C[i]
+            return g[i]
         end
-        function con_nonlinprog_i(i, ΔŨtup::NTuple{N, Real}) where {N}
-            C = get_tmp(C_cache, ΔŨtup[1])
+        function gfunc_i(i, ΔŨtup::NTuple{N, Real}) where {N}
+            g = get_tmp(g_cache, ΔŨtup[1])
             if ΔŨtup != last_ΔŨtup_dual
                 x̂ = get_tmp(x̂_cache, ΔŨtup[1])
                 Ŷ = get_tmp(Ŷ_cache, ΔŨtup[1])
                 ΔŨ = collect(ΔŨtup)
                 Ŷ, x̂end = predict!(Ŷ, x̂, mpc, model, ΔŨ)
-                C = con_nonlinprog!(C, mpc, model, x̂end, Ŷ, ΔŨ)
+                g = con_nonlinprog!(g, mpc, model, x̂end, Ŷ, ΔŨ)
                 last_ΔŨtup_dual = ΔŨtup
             end
-            return C[i]
+            return g[i]
         end
-        Cfunc = [(ΔŨ...) -> con_nonlinprog_i(i, ΔŨ) for i in 1:nC]
-        (Jfunc, Cfunc)
+        gfunc = [(ΔŨ...) -> gfunc_i(i, ΔŨ) for i in 1:ng]
+        (Jfunc, gfunc)
     end
     register(optim, :Jfunc, nvar, Jfunc, autodiff=true)
     @NLobjective(optim, Min, Jfunc(ΔŨvar...))
-    if nC ≠ 0
+    if ng ≠ 0
         i_end_Ymin, i_end_Ymax, i_end_x̂min = 1Hp*ny, 2Hp*ny, 2Hp*ny + nx̂
         for i in eachindex(con.Ymin)
-            sym = Symbol("C_Ymin_$i")
-            register(optim, sym, nvar, Cfunc[i], autodiff=true)
+            sym = Symbol("g_Ymin_$i")
+            register(optim, sym, nvar, gfunc[i], autodiff=true)
         end
         for i in eachindex(con.Ymax)
-            sym = Symbol("C_Ymax_$i")
-            register(optim, sym, nvar, Cfunc[i_end_Ymin+i], autodiff=true)
+            sym = Symbol("g_Ymax_$i")
+            register(optim, sym, nvar, gfunc[i_end_Ymin+i], autodiff=true)
         end
         for i in eachindex(con.x̂min)
-            sym = Symbol("C_x̂min_$i")
-            register(optim, sym, nvar, Cfunc[i_end_Ymax+i], autodiff=true)
+            sym = Symbol("g_x̂min_$i")
+            register(optim, sym, nvar, gfunc[i_end_Ymax+i], autodiff=true)
         end
         for i in eachindex(con.x̂max)
-            sym = Symbol("C_x̂max_$i")
-            register(optim, sym, nvar, Cfunc[i_end_x̂min+i], autodiff=true)
+            sym = Symbol("g_x̂max_$i")
+            register(optim, sym, nvar, gfunc[i_end_x̂min+i], autodiff=true)
         end
     end
     return nothing
@@ -347,52 +347,52 @@ function setnonlincon!(mpc::NonLinMPC, ::NonLinModel)
     con = mpc.con
     map(con -> delete(optim, con), all_nonlinear_constraints(optim))
     for i in findall(.!isinf.(con.Ymin))
-        f_sym = Symbol("C_Ymin_$(i)")
+        f_sym = Symbol("g_Ymin_$(i)")
         add_nonlinear_constraint(optim, :($(f_sym)($(ΔŨvar...)) <= 0))
     end
     for i in findall(.!isinf.(con.Ymax))
-        f_sym = Symbol("C_Ymax_$(i)")
+        f_sym = Symbol("g_Ymax_$(i)")
         add_nonlinear_constraint(optim, :($(f_sym)($(ΔŨvar...)) <= 0))
     end
     for i in findall(.!isinf.(con.x̂min))
-        f_sym = Symbol("C_x̂min_$(i)")
+        f_sym = Symbol("g_x̂min_$(i)")
         add_nonlinear_constraint(optim, :($(f_sym)($(ΔŨvar...)) <= 0))
     end
     for i in findall(.!isinf.(con.x̂max))
-        f_sym = Symbol("C_x̂max_$(i)")
+        f_sym = Symbol("g_x̂max_$(i)")
         add_nonlinear_constraint(optim, :($(f_sym)($(ΔŨvar...)) <= 0))
     end
     return nothing
 end
 
 """
-    con_nonlinprog!(C, mpc::NonLinMPC, model::SimModel, x̂end, Ŷ, ΔŨ) -> C
+    con_nonlinprog!(g, mpc::NonLinMPC, model::SimModel, x̂end, Ŷ, ΔŨ) -> g
 
 Nonlinear constrains for [`NonLinMPC`](@ref) when `model` is not a [`LinModel`](@ref).
 
-The method mutates the `C` vector in argument and returns it.
+The method mutates the `g` vector in argument and returns it.
 """
-function con_nonlinprog!(C, mpc::NonLinMPC, ::SimModel, x̂end, Ŷ, ΔŨ)
+function con_nonlinprog!(g, mpc::NonLinMPC, ::SimModel, x̂end, Ŷ, ΔŨ)
     nx̂, nŶ = mpc.estim.nx̂, length(Ŷ)
     ϵ = !isinf(mpc.C) ? ΔŨ[end] : 0.0 # ϵ = 0.0 if Cwt=Inf (meaning: no relaxation)
-    for i in eachindex(C)
-        mpc.con.i_C[i] || continue
+    for i in eachindex(g)
+        mpc.con.i_g[i] || continue
         if i ≤ nŶ
             j = i
-            C[i] = (mpc.con.Ymin[j] - Ŷ[j])     - ϵ*mpc.con.C_ymin[j]
+            g[i] = (mpc.con.Ymin[j] - Ŷ[j])     - ϵ*mpc.con.C_ymin[j]
         elseif i ≤ 2nŶ
             j = i - nŶ
-            C[i] = (Ŷ[j] - mpc.con.Ymax[j])     - ϵ*mpc.con.C_ymax[j]
+            g[i] = (Ŷ[j] - mpc.con.Ymax[j])     - ϵ*mpc.con.C_ymax[j]
         elseif i ≤ 2nŶ + nx̂
             j = i - 2nŶ
-            C[i] = (mpc.con.x̂min[j] - x̂end[j])  - ϵ*mpc.con.c_x̂min[j]
+            g[i] = (mpc.con.x̂min[j] - x̂end[j])  - ϵ*mpc.con.c_x̂min[j]
         else
             j = i - 2nŶ - nx̂
-            C[i] = (x̂end[j] - mpc.con.x̂max[j])  - ϵ*mpc.con.c_x̂max[j]
+            g[i] = (x̂end[j] - mpc.con.x̂max[j])  - ϵ*mpc.con.c_x̂max[j]
         end
     end
-    return C
+    return g
 end
 
-"No nonlinear constraints if `model` is a [`LinModel`](@ref), return `C` unchanged."
-con_nonlinprog!(C, ::NonLinMPC, ::LinModel, _ , _ , _ ) = C
+"No nonlinear constraints if `model` is a [`LinModel`](@ref), return `g` unchanged."
+con_nonlinprog!(g, ::NonLinMPC, ::LinModel, _ , _ , _ ) = g
diff --git a/src/predictive_control.jl b/src/predictive_control.jl
@@ -74,7 +74,7 @@ struct ControllerConstraint
     C_ymax  ::Vector{Float64}
     c_x̂min  ::Vector{Float64}
     c_x̂max  ::Vector{Float64}
-    i_C     ::BitVector
+    i_g     ::BitVector
 end
 
 @doc raw"""
@@ -314,7 +314,7 @@ function setconstraint!(
     i_Ymin,  i_Ymax  = .!isinf.(con.Ymin),  .!isinf.(con.Ymax)
     i_x̂min,  i_x̂max  = .!isinf.(con.x̂min),  .!isinf.(con.x̂max)
     if notSolvedYet
-        con.i_b[:], con.i_C[:], con.A[:] = init_matconstraint(model,
+        con.i_b[:], con.i_g[:], con.A[:] = init_matconstraint(model,
             i_Umin, i_Umax, i_ΔŨmin, i_ΔŨmax, 
             i_Ymin, i_Ymax, i_x̂min, i_x̂max,
             con.A_Umin, con.A_Umax, con.A_ΔŨmin, con.A_ΔŨmax, 
@@ -328,11 +328,11 @@ function setconstraint!(
         @constraint(mpc.optim, linconstraint, A*ΔŨvar .≤ b)
         setnonlincon!(mpc, model)
     else
-        i_b, i_C = init_matconstraint(model, 
+        i_b, i_g = init_matconstraint(model, 
             i_Umin, i_Umax, i_ΔŨmin, i_ΔŨmax, 
             i_Ymin, i_Ymax, i_x̂min, i_x̂max
         )
-        if i_b ≠ con.i_b || i_C ≠ con.i_C
+        if i_b ≠ con.i_b || i_g ≠ con.i_g
             error("Cannot modify ±Inf constraints after calling moveinput!")
         end
     end
@@ -1027,7 +1027,7 @@ function init_defaultcon(estim, Hp, Hc, C, S, N_Hc, E, ex̂, fx̂, gx̂, jx̂, k
     i_ΔŨmin, i_ΔŨmax = .!isinf.(ΔŨmin), .!isinf.(ΔŨmax)
     i_Ymin,  i_Ymax  = .!isinf.(Ymin),  .!isinf.(Ymax)
     i_x̂min,  i_x̂max  = .!isinf.(x̂min),  .!isinf.(x̂max)
-    i_b, i_C, A = init_matconstraint(
+    i_b, i_g, A = init_matconstraint(
         model, 
         i_Umin, i_Umax, i_ΔŨmin, i_ΔŨmax, i_Ymin, i_Ymax, i_x̂min, i_x̂max,
         A_Umin, A_Umax, A_ΔŨmin, A_ΔŨmax, A_Ymin, A_Ymax, A_x̂max, A_x̂min
@@ -1037,7 +1037,7 @@ function init_defaultcon(estim, Hp, Hc, C, S, N_Hc, E, ex̂, fx̂, gx̂, jx̂, k
         ẽx̂      , fx̂    , gx̂     , jx̂       , kx̂     , vx̂     ,  
         Umin    , Umax  , ΔŨmin  , ΔŨmax    , Ymin   , Ymax   , x̂min   , x̂max,
         A_Umin  , A_Umax, A_ΔŨmin, A_ΔŨmax  , A_Ymin , A_Ymax , A_x̂min , A_x̂max,
-        A       , b     , i_b    , C_ymin   , C_ymax , c_x̂min , c_x̂max , i_C
+        A       , b     , i_b    , C_ymin   , C_ymax , c_x̂min , c_x̂max , i_g
     )
     return con, S̃, Ñ_Hc, Ẽ
 end
@@ -1245,19 +1245,19 @@ init_stochpred(estim::StateEstimator, _ ) = zeros(0, estim.nxs), zeros(0, estim.
 @doc raw"""
     init_matconstraint(model::LinModel,
         i_Umin, i_Umax, i_ΔŨmin, i_ΔŨmax, i_Ymin, i_Ymax, i_x̂min, i_x̂max, args...
-    ) -> i_b, i_C, A
+    ) -> i_b, i_g, A
 
-Init `i_b`, `i_C` and `A` matrices for the linear and nonlinear inequality constraints.
+Init `i_b`, `i_g` and `A` matrices for the linear and nonlinear inequality constraints.
 
 The linear and nonlinear inequality constraints are respectively defined as:
 ```math
 \begin{aligned} 
     \mathbf{A ΔŨ } &≤ \mathbf{b} \\ 
-    \mathbf{C(ΔŨ)} &≤ \mathbf{0}
+    \mathbf{g(ΔŨ)} &≤ \mathbf{0}
 \end{aligned}
 ```
 `i_b` is a `BitVector` including the indices of ``\mathbf{b}`` that are finite numbers. 
-`i_C` is a similar vector but for the indices of ``\mathbf{C}`` (empty if `model` is a 
+`i_g` is a similar vector but for the indices of ``\mathbf{g}`` (empty if `model` is a 
 [`LinModel`](@ref)). The method also returns the ``\mathbf{A}`` matrix if `args` is
 provided. In such a case, `args`  needs to contain all the inequality constraint matrices: 
 `A_Umin, A_Umax, A_ΔŨmin, A_ΔŨmax, A_Ymin, A_Ymax, A_x̂min, A_x̂max`.
@@ -1266,29 +1266,29 @@ function init_matconstraint(::LinModel,
     i_Umin, i_Umax, i_ΔŨmin, i_ΔŨmax, i_Ymin, i_Ymax, i_x̂min, i_x̂max, args...
 )
     i_b = [i_Umin; i_Umax; i_ΔŨmin; i_ΔŨmax; i_Ymin; i_Ymax; i_x̂min; i_x̂max]
-    i_C = BitVector()
+    i_g = BitVector()
     if isempty(args)
         A = zeros(length(i_b), 0)
     else
         A_Umin, A_Umax, A_ΔŨmin, A_ΔŨmax, A_Ymin, A_Ymax, A_x̂min, A_x̂max = args
         A = [A_Umin; A_Umax; A_ΔŨmin; A_ΔŨmax; A_Ymin; A_Ymax; A_x̂min; A_x̂max]
     end
-    return i_b, i_C, A
+    return i_b, i_g, A
 end
 
-"Init `i_b` and `A` without predicted output and terminal constraints if `model` is not a [`LinModel`](@ref)."
+"Init `i_b, A` without outputs and terminal constraints if `model` is not a [`LinModel`](@ref)."
 function init_matconstraint(::SimModel,
     i_Umin, i_Umax, i_ΔŨmin, i_ΔŨmax, i_Ymin, i_Ymax, i_x̂min, i_x̂max, args...
 )
     i_b = [i_Umin; i_Umax; i_ΔŨmin; i_ΔŨmax]
-    i_C = [i_Ymin; i_Ymax; i_x̂min; i_x̂max]
+    i_g = [i_Ymin; i_Ymax; i_x̂min; i_x̂max]
     if isempty(args)
         A = zeros(length(i_b), 0)
     else
         A_Umin, A_Umax, A_ΔŨmin, A_ΔŨmax, _ , _ , _ , _ = args
         A = [A_Umin; A_Umax; A_ΔŨmin; A_ΔŨmax]
     end
-    return i_b, i_C, A
+    return i_b, i_g, A
 end
 
 "Validate predictive controller weight and horizon specified values."
diff --git a/src/state_estim.jl b/src/state_estim.jl
@@ -151,15 +151,15 @@ function init_integrators(nint::IntVectorOrInt, ny, varname::String)
     nx = sum(nint)
     A, C = zeros(nx, nx), zeros(ny, nx)
     if nx ≠ 0
-        i_A, i_C = 1, 1
+        i_A, i_g = 1, 1
         for i = 1:ny
             nint_i = nint[i]
             if nint_i ≠ 0
                 rows_A = (i_A):(i_A + nint_i - 1)
                 A[rows_A, rows_A] = Bidiagonal(ones(nint_i), ones(nint_i-1), :L)
-                C[i, i_C+nint_i-1] = 1
+                C[i, i_g+nint_i-1] = 1
                 i_A += nint_i
-                i_C += nint_i
+                i_g += nint_i
             end
         end
     end
diff --git a/test/test_predictive_control.jl b/test/test_predictive_control.jl
@@ -392,9 +392,9 @@ end
     u = moveinput!(nmpc4, [0], d, R̂u=fill(12, nmpc4.Hp))
     @test u ≈ [12] atol=5e-2
     nmpc5 = setconstraint!(NonLinMPC(nonlinmodel, Hp=15, Cwt=Inf), ymin=[-1])
-    C_Ymax_end = nmpc5.optim.nlp_model.operators.registered_multivariate_operators[end].f
-    @test C_Ymax_end(Float64.((1.0, 1.0))) ≤ 0.0 # test con_nonlinprog_i(i,::NTuple{N, Float64})
-    @test C_Ymax_end(Float32.((1.0, 1.0))) ≤ 0.0 # test con_nonlinprog_i(i,::NTuple{N, Real})
+    g_Ymax_end = nmpc5.optim.nlp_model.operators.registered_multivariate_operators[end].f
+    @test g_Ymax_end(Float64.((1.0, 1.0))) ≤ 0.0 # test gfunc_i(i,::NTuple{N, Float64})
+    @test g_Ymax_end(Float32.((1.0, 1.0))) ≤ 0.0 # test gfunc_i(i,::NTuple{N, Real})
 end
 
 @testset "NonLinMPC step disturbance rejection" begin
