Update linearandinteger.md

Author: Vaibhavdixit02

docs/src/tutorials/linearandinteger.md

@@ -59,156 +59,8 @@ optprob = OptimizationProblem(optsys,
 sol = solve(optprob, HiGHS.Optimizer())
 ```
 
-<!--
-```julia
-using Enzyme
-objective(u, p) = u[14]
-
-constraints(res,u,p) = res .= [
-    u[1] + u[6] - u[9] # January
-    ,u[2] + u[7] - u[10] - 1.01u[1] + 1.003u[9] # February
-    ,u[3] + u[8] - u[11] - 1.01u[2] + 1.003u[10] # March
-    ,u[4] - u[12] - 1.02u[6] - 1.01u[3] + 1.003u[11] # April
-    ,u[5] - u[13] - 1.02u[7] - 1.01u[4] + 1.003u[12] # May
-    ,-u[14] - 1.02u[8] - 1.01u[5] + 1.003u[13] # June
-]
-
-optf = OptimizationFunction(objective, Optimization.AutoModelingToolkit(), cons = constraints)
-optprob = OptimizationProblem(optf, [zeros(13)..., 300]; lb = zeros(14), ub = vcat(ones(5).*100, fill(Inf, 9)), lcons = [150, 100, -200, 200, -50, -300], ucons = [150, 100, -200, 200, -50, -300], sense = Optimization.MaxSense)
-sol = solve(optprob, HiGHS.Optimizer())
-```
--->
 ## Mixed Integer Nonlinear Optimization
 
-<!--
-```julia
-    using Juniper, Ipopt, HiGHS
-
-    ModelingToolkit.@variables b[1:4] [bounds = (0, 1)]
-    ModelingToolkit.@variables i[1:24]
-    ModelingToolkit.@variables objvar
-
-    for j in 1:16
-        push!(vars, i[j])
-        ModelingToolkit.setmetadata(i[j], ModelingToolkit.VariableBounds, (0, 5))
-    end
-
-    ModelingToolkit.setmetadata(i[21], ModelingToolkit.VariableBounds, (0, 15))
-    ModelingToolkit.setmetadata(i[22], ModelingToolkit.VariableBounds, (0, 12))
-    ModelingToolkit.setmetadata(i[23], ModelingToolkit.VariableBounds, (0, 9))
-    ModelingToolkit.setmetadata(i[24], ModelingToolkit.VariableBounds, (0, 6))
-
-    constraints = [
-        -0.1 * b[1] - 0.2 * b[2] - 0.3 * b[3] - 0.4 * b[4] - i[21] - i[22] - i[23] -
-        i[24] + objvar ~ 0.0
-        ,9.0 ≲ i[21] * i[1] + i[22] * i[2] + i[23] * i[3] + i[24] * i[4]
-        ,7.0 ≲ i[21] * i[5] + i[22] * i[6] + i[23] * i[7] + i[24] * i[8]
-        ,12.0 ≲ i[21] * i[9] + i[22] * i[10] + i[23] * i[11] + i[24] * i[12]
-        ,11.0 ≲ i[21] * i[13] + i[22] * i[14] + i[23] * i[15] + i[24] * i[16]
-        ,-330 * i[1] - 360 * i[5] - 385 * i[9] - 415 * i[13] + 1700 * b[1] ≲ 0.0
-        ,-330 * i[2] - 360 * i[6] - 385 * i[10] - 415 * i[14] + 1700 * b[2] ≲ 0.0
-        ,-330 * i[3] - 360 * i[7] - 385 * i[11] - 415 * i[15] + 1700 * b[3] ≲ 0.0
-        ,-330 * i[4] - 360 * i[8] - 385 * i[12] - 415 * i[16] + 1700 * b[4] ≲ 0.0
-        ,330 * i[1] + 360 * i[5] + 385 * i[9] + 415 * i[13] - 1900 * b[1] ≲ 0.0
-        ,330 * i[2] + 360 * i[6] + 385 * i[10] + 415 * i[14] - 1900 * b[2] ≲ 0.0
-        ,330 * i[3] + 360 * i[7] + 385 * i[11] + 415 * i[15] - 1900 * b[3] ≲ 0.0
-        ,330 * i[4] + 360 * i[8] + 385 * i[12] + 415 * i[16] - 1900 * b[4] ≲ 0.0
-        ,-i[1] - i[5] - i[9] - i[13] + b[1] ≲ 0.0
-        ,-i[2] - i[6] - i[10] - i[14] + b[2] ≲ 0.0
-        ,-i[3] - i[7] - i[11] - i[15] + b[3] ≲ 0.0
-        ,-i[4] - i[8] - i[12] - i[16] + b[4] ≲ 0.0
-        ,i[1] + i[5] + i[9] + i[13] - 5 * b[1] ≲ 0.0
-        ,i[2] + i[6] + i[10] + i[14] - 5 * b[2] ≲ 0.0
-        ,i[3] + i[7] + i[11] + i[15] - 5 * b[3] ≲ 0.0
-        ,i[4] + i[8] + i[12] + i[16] - 5 * b[4] ≲ 0.0
-        ,b[1] - i[21] ≲ 0.0
-        ,b[2] - i[22] ≲ 0.0
-        ,b[3] - i[23] ≲ 0.0
-        ,b[4] - i[24] ≲ 0.0
-        ,-15 * b[1] + i[21] ≲ 0.0
-        ,-12 * b[2] + i[22] ≲ 0.0
-        ,-9 * b[3] + i[23] ≲ 0.0
-        ,-6 * b[4] + i[24] ≲ 0.0
-        ,8.0 ≲ i[21] + i[22] + i[23] + i[24]
-        ,-b[1] + b[2] ≲ 0.0
-        ,-b[2] + b[3] ≲ 0.0
-        ,-b[3] + b[4] ≲ 0.0
-        ,-i[21] + i[22] ≲ 0.0
-        ,-i[22] + i[23] ≲ 0.0
-        ,-i[23] + i[24] ≲ 0.0
-    ]
-
-    i_idxs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 21, 22, 23, 24]
-    vars = [b..., [i[j] for j in i_idxs]..., objvar]
-
-    @named optsys = OptimizationSystem(objvar, vars, [], constraints = constraints)
-    optprob = OptimizationProblem(optsys, vcat(ones(24), 5), int = vcat(fill(true, 24), false), grad = true,  cons_j = true, hess = true, cons_h = true)
-
-    nl_solver = OptimizationMOI.MOI.OptimizerWithAttributes(Ipopt.Optimizer,
-                                                            "print_level" => 0)
-    mip_solver = OptimizationMOI.MOI.OptimizerWithAttributes(HiGHS.Optimizer,
-                                                            "output_flag" => false
-                                                            )
-    minlp_solver = OptimizationMOI.MOI.OptimizerWithAttributes(Juniper.Optimizer,
-                                                               "nl_solver" => nl_solver,
-                                                               "mip_solver" => mip_solver)
-     opt = OptimizationMOI.MOI.OptimizerWithAttributes(Alpine.Optimizer,
-                                                                "minlp_solver" => minlp_solver,
-                                                               "nl_solver" => nl_solver,
-                                                               "mip_solver" => mip_solver)
-    sol = solve(optprob, opt)
-```
--->
-<!--
-```julia
-using Juniper, Ipopt
-
-    LB = [100, 1000, 1000, 10, 10, 10, 10, 10]
-    UB = [10000, 10000, 10000, 1000, 1000, 1000, 1000, 1000]
-
-    ModelingToolkit.@variables x[1:8]
-    ModelingToolkit.@variables y[1:5] [bounds = (0, 1)]
-
-    for j in 1:8
-        ModelingToolkit.setmetadata(x[j], ModelingToolkit.VariableBounds, (LB[j], UB[j]))
-    end
-
-    function cons(res, u, p)
-        x, y = u[1:8], u[9:13]
-        res .= [0.0025 * (x[4] * y[1] + x[6] * y[2])
-                        ,0.0025 * (x[5] - x[4] * y[1] + x[7])
-                        , 0.01(x[8] - x[5] * y[3]),
-                        100 * x[1] - x[1] * x[6] * y[1] + 833.33252 * x[4] * y[1]
-                        ,x[2] * x[4] * y[4] - x[2] * x[7] - 1250 * x[4] + 1250 * x[5],
-                        x[3] * x[5] * y[2] * y[5] - x[3] * x[8] * y[5] - 2500 * x[5] * y[1] * y[4] + 1250000,
-                        y[1] * y[2] * y[3],
-                        y[4] * y[5] - (y[2] * y[3]),
-                        y[1] * y[5] - (y[2] * y[4]),
-                        ]
-    end
-    lcons = fill(-Inf, 9)
-    ucons = [1, 1, 1, 83333.333, 0, 0, 0, 0, 0]
-    objective = (u,p) -> u[1] + u[2] + u[3]
-    optf = OptimizationFunction(objective, Optimization.AutoForwardDiff(), cons = cons)
-# @named optsys = OptimizationSystem(objective, [x..., y...], [], constraints = constraints)
-optprob = OptimizationProblem(optf, vcat((LB + UB) ./ 2,zeros(5));lb = vcat(LB, fill(0, 5)), ub = vcat(UB, fill(1, 5)), lcons, ucons, int = vcat(fill(false, 8), fill(true, 5)))
-
-nl_solver = OptimizationMOI.MOI.OptimizerWithAttributes(Ipopt.Optimizer,
-                                                            "print_level" => 0)
-mi_solver = OptimizationMOI.MOI.OptimizerWithAttributes(HiGHS.Optimizer,
-                                                            "presolve" => "on",
-                                                            "log_to_console" => false,
-                                                            )
-minlp_solver = OptimizationMOI.MOI.OptimizerWithAttributes(Juniper.Optimizer,
-                                                            "nl_solver" => nl_solver,
-                                                            "mip_solver" => mi_solver)
-opt = OptimizationMOI.MOI.OptimizerWithAttributes(Alpine.Optimizer,
-                                                            "minlp_solver" => minlp_solver,
-                                                            "nlp_solver" => nl_solver,
-                                                            "mip_solver" => mi_solver)
-sol = solve(optprob, minlp_solver)
-```
--->
 We choose an example from the [Juniper.jl readme](https://github.com/lanl-ansi/Juniper.jl#use-with-jump) to demonstrate mixed integer nonlinear optimization with Optimization.jl. The problem can be stated as follows:
 
 ```math