Ipopt | COIN-OR Interior Point Optimizer IPOPT | Math library

prob.driver.fail should be False if the the optimization was successful, and doesn't need to be read from a file. However, given the various levels of success in optimizers this might not be completely accurate. For instance, solved to acceptable tolerance vs. optimal solution found is a little difficult to capture in a simple boolean output, and we should probably find a better way to report the optimizer's success.

First, your problem is not converging to a feasible point, so there is no guarantee that the returned solution respects any constraints or bounds.

More importantly, ipopt is a continuous interior point solver and ignores discrete domains. If you look at the solver output (by adding tee=True' to the solve call), you should see:

The complaint is about the C++ standard library, i.e., libstc++ and its headers. The Clang compiler itself seems to be installed correctly, but it's looking for the GCC standard C++ library, and failing.

The problem might be if you have GCC 10 installed (or partially installed).

Does the https://github.com/RobotLocomotion/drake/issues/15652 advice help? Specifically:

Please update to Juniper v0.8.0. I fixed this issue a few days ago.

p.s., in future, please consider posting on the JuMP community forum: https://discourse.julialang.org/c/domain/opt/13. There are more readers of JuMP-specific questions.

I cannot reproduce this on the latest version of JuMP and Juniper:

There are a many ways to preferentially select one MV over another with additional resources on the course website with Control Objectives and Control Tuning.

• COST (minimize or maximize use of MV)
• DCOST (change penalty)
• DMAX (move change constraint)
• TIER (for strong decoupling)

For this particular problem, it appears that the two MVs (Manipulated Variables) Q1 and Q2 values should be a ratio and there is only one CV (Controlled Variable). An easy way to accomplish this is to add another equation such as:

You have a couple of issues in your code.

• Why are you creating a new model every loop? You cannot aggregate expressions across models like you do with Q=Q+k8+k9
• You cannot add nonlinear expressions like Q=Q+k8+k9. All nonlinear expressions must occur inside macros

In general, you are not limited to the specific syntax of JuMP. You can use any Julia data structures to help. In the code below, I just push expressions into a vec

I haven't tested, so there might be typos etc, but this should point you in the right direction:

This has been cross-posted on the Julia discourse, we'll continue to debug it there: https://discourse.julialang.org/t/cant-run-simple-jump-example/67938

It's either:

• An issue in VS-Code (although "when I run it directly in Julia" may rule this out)
• An issue with Ipopt, which is either due to it installing an old version, or a weird incompatibility with this user's system

Either way, this is likely hard to debug.

I haven't tried it for single exe app, but there is a working solution for one directory mode of PyInstaller.

1. Firstly you should specify a path to your solver executable in your pyomo optimization settings

   opt = pyomo.SolverFactory('ipopt', executable='ipopt.exe')

For this case pyomo will be looking for solver executable in your current directory with your Python script being runned.

1. Secondly, you may start compiling your script by PyInstaller.

2. Once the compilation is finished, paste solvers executables into the directory with .exe file.

If you are going to compile your code into single .exe file you can repeat that steps and compile the script into a single .exe. It should work with solvers executables placed in the very same directory of your single app file.

However if you are going to compile your code into single .exe file without any other auxiliary files, you may try to play with .spec file which contains settings for PyInstaller. If you have that file, it could look like