Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

# Scala: Mathematical Optimization

DZone 's Guide to

# Scala: Mathematical Optimization

### Time for a math lesson! Let's see how to calculate minimum or maximum values of equations in Scala with some help from the Optimus library.

· Java Zone ·
Free Resource

Comment (1)

Save
{{ articles[0].views | formatCount}} Views

Hello, folks!

Today we are going to talk about the problem of solving the mathematical optimization. Let's look at a quick example.

Have you ever been in a condition where you have inequalities and you have to find out the maximum or minimum values of the variables for a particular equation?

For example: There are two equations: one equation that you need to maximize and another equation that acts as a constraint:

• Equation to be maximized : -2 * x + 5 * y

• Additional constraint : y >:= 200 – x

Range of values:

• For X: 100<x<=200

• For Y: 80<y<=170

So the value of X and Y for which this equation would be maximum will be x=100 and y=170 (Check out your mathematical skills!).

Now we need to solve such equations programmatically. This is where mathematical optimization libraries come in. In our case, we are going to use Optimus.

Now let’s get started with the programming.

First, you need to add the Optimus dependency in your build.sbt, so your buid.sbt should look like this.

``````name := "scala-mip"

version := "0.1"

scalaVersion := "2.12.4"

organization := "com.foobar"

// The necessary dependencies can be added here

libraryDependencies ++= Seq(
"com.typesafe" % "config" % "1.3.1",
//Mathematical Programming Dependencies
"com.github.vagmcs" %% "optimus" % "2.1.0",
"com.github.vagmcs" %% "optimus-solver-oj" % "2.1.0",
"org.scalatest" %% "scalatest" % "3.0.0" % "test"
)``````

Now we have to make a bounded variable to define this expression:

• For X: 100<x<=200

• For Y: 80<y<=170

In Optimus, we do it using this:

``````val x = MPFloatVar("x", 100, 200)
val y = MPFloatVar("y", 80, 170)``````

The whole code looks something like this like this:

``````import optimus.optimization._

implicit val problem = LQProblem(SolverLib.ojalgo)

val x = MPFloatVar("x", 100, 200)
val y = MPFloatVar("y", 80, 170)
maximize(-2 * x + 5 * y)

start()

println("objective: " + objectiveValue)

println("x = " + x.value + "y = " + y.value)

release()``````

## Explanation

• LQProblem: defines a linear equation problem. There can be other problems like a quadratic equation problem or a mixed integer problem.

• maximize(): takes the expression that needs to be maximized. There are other functions like minimize(), subjectTo(), etc.

• add(): takes a constraint expression that needs to be kept in consideration for maximizing that expression.

• start(): to start the computation.

• release(): to release all the resources.

And it results in this output:

Hence for the values of X and Y, this equation is maximum.

Currently, I am working on a use case in which I am looking forward to using MIP to solve the problem. The problem is optimal order fulfillment, which is described here: Optimal Order Fulfillment.

If someone has any suggestions for solving this problem, feel free to ping me! I can also use some help.

I hope you enjoyed this and found it interesting! If you have any questions, let me know!

Topics:
java ,scala ,math ,optimization ,tutorial

Comment (1)

Save
{{ articles[0].views | formatCount}} Views

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.