As a result of the emergence and progress of open-source languages SCM and OR analysts have access to a growing number of constantly improving tools and solvers. Julia, for example, is a flexible dynamic open-source programming language that is appropriate for scientific and numerical computing. Julia’s source code is available on GitHub and the programming language is supported by a growing number of frameworks and applications for optimization and scheduling.

I introduced Julia in one of my previous posts already, covering a linear programming example. In this article I will give a more comprehensive introduction to Julia, comparing it with other programming languages, and specifically focusing on optimization.

## JuMP: A package for mathematical programming in Julia

JuMP (Julia for Mathematical Programming) is a package available in Julia. This modelling framework allows users to formulate an optimization problem (linear, mixed-integer, quadratic, conic quadratic, semidefinite, and nonlinear) with easy-to-read code. The problem can then be solved by optimizers (solvers) written in low-level languages. The selected solver for this demonstration is GLPK which is a state-of-art open-source solver for * linear programming (LP) and mixed-integer programming (MIP) problems*. It incorporates algorithms such as the simplex method and the interior-point method.

# Comparing Julia vs. Matlab for optimization problems

At first, a quick comparison between Julia and Matlab is necessary to appreciate the power of open-source programming languages.

Criteria | Julia 🙂 | Matlab 🙁 |

Cost | Free | Hundreds of dollars per year |

License | Open-Source | One year user license |

Source | Non-profitable foundation and community | MathWorks company |

Scope | Mainly numeric | Numeric only |

Performance | Excellent | Faster than Python but slower than Julia |

Editor/IDE | Jupyter is recommended | IDE already included |

Packaging | Pkg manager included | Toolboxes included |

Usage | Generic | Industry and research in academia |

Fame | Young but starts to be known | Old and well-known |

Support | Community | MathWorks |

Documentation | Growing | Okay |

# JuMP and GLPK packages for optimization with Julia

**JuMP:**

- Modeling language and collection of supporting packages for mathematical optimization in Julia
- Supported solvers: GLPK, CLP, CBC, CPLEX, ECOS, GUROBI, HiGHS, MOSEK, XPRESS, OSQP, PATH, ProxSDP SCIP, SCS, SDPA.

The first step is to add the required packages: JuMP and GLPK. This is done using Pkg which is a built-in package manager in Julia. I can add the requried or desired packages using the following commands in Julia REPL. If Julia is installed, typing Julia in the command line is enough to open REPL (Julia run command).

*using Pkg*
*Pkg.add("JuMP")*
*Pkg.add("GLPK")*

Now, I should import the necessary packages in the IDE which is a Jupyter notebook in our case.

```
# Import pacakges: JuMP and GLPK
using JuMP # Julia package - high level programming language
using GLPK # open-source solver - low level language
```

# A test problem

Let us consider the following optimization model:

The feasible region (as x and y are continuous decision variables) is shown below:

According to the gradient of the objective (the red arrow) and direction of the optimization (maximization), the green point is the optimal solution, in which x=3.75, y=1.25, and the optimal value of the objective function is 23.75. I will solve this simple continuous linear programming model with the JuMP package in Julia and comment on its syntax.

# Solving the problem

The following commented code aims to solve the proposed linear programming model with JuMP (the name of the package) in Julia:

```
# Define the model
m = Model(); # m stands for model
# Set the optimizer
set_optimizer(m,GLPK.Optimizer); # calling the GLPK solver
# Define the variables
@variable(m, x>=0);
@variable(m, y>=0);
# Define the constraints
@constraint(m, x+y<=5);
@constraint(m, 10x+6y<=45);
# Define the objective function
@objective(m, Max, 5x+4y);
# Run the solver
optimize!(m);
# Output
println(objective_value(m)) # optimal value z
println("x = ", value.(x), "\n","y = ",value.(y)) # optimal solution x & y
```

In future work I will explore the power of Julia in solving supply chain management problems, specifically mixed integer programming (MIP).

A chemical engineer interested in optimization and using open-source software to empower research and academia!

## 2 thoughts on “Optimization with JuMP in Julia”