OptimJ

The example of map coloring

The goal of a map coloring problem is to color a map so that regions sharing a common border have different colors. It can be expressed in OptimJ as follows.

<span id="mwFA"></span><span class="kn" id="mwFQ">package</span><span class="w" id="mwFg"> </span><span class="nn" id="mwFw">examples</span><span class="p" id="mwGA">;</span> <span class="c1" id="mwGQ">// a simple model for the map-coloring problem</span> <span class="kd" id="mwGg">public</span><span class="w" id="mwGw"> </span><span class="n" id="mwHA">model</span><span class="w" id="mwHQ"> </span><span class="n" id="mwHg">SimpleColoring</span><span class="w" id="mwHw"> </span><span class="n" id="mwIA">solver</span><span class="w" id="mwIQ"> </span><span class="n" id="mwIg">lpsolve</span> <span class="p" id="mwIw">{</span> <span class="w" id="mwJA"> </span><span class="c1" id="mwJQ">// maximum number of colors</span> <span class="w" id="mwJg"> </span><span class="kt" id="mwJw">int</span><span class="w" id="mwKA"> </span><span class="n" id="mwKQ">nbColors</span><span class="w" id="mwKg"> </span><span class="o" id="mwKw">=</span><span class="w" id="mwLA"> </span><span class="mi" id="mwLQ">4</span><span class="p" id="mwLg">;</span> <span class="w" id="mwLw"> </span><span class="c1" id="mwMA">// decision variables hold the color of each country</span> <span class="w" id="mwMQ"> </span><span class="kd" id="mwMg">var</span><span class="w" id="mwMw"> </span><span class="n" id="mwNA">int</span><span class="w" id="mwNQ"> </span><span class="n" id="mwNg">belgium</span><span class="w" id="mwNw"> </span><span class="n" id="mwOA">in</span><span class="w" id="mwOQ"> </span><span class="mi" id="mwOg">1</span><span class="w" id="mwOw"> </span><span class="p" id="mwPA">..</span><span class="w" id="mwPQ"> </span><span class="n" id="mwPg">nbColors</span><span class="p" id="mwPw">;</span> <span class="w" id="mwQA"> </span><span class="kd" id="mwQQ">var</span><span class="w" id="mwQg"> </span><span class="n" id="mwQw">int</span><span class="w" id="mwRA"> </span><span class="n" id="mwRQ">denmark</span><span class="w" id="mwRg"> </span><span class="n" id="mwRw">in</span><span class="w" id="mwSA"> </span><span class="mi" id="mwSQ">1</span><span class="w" id="mwSg"> </span><span class="p" id="mwSw">..</span><span class="w" id="mwTA"> </span><span class="n" id="mwTQ">nbColors</span><span class="p" id="mwTg">;</span> <span class="w" id="mwTw"> </span><span class="kd" id="mwUA">var</span><span class="w" id="mwUQ"> </span><span class="n" id="mwUg">int</span><span class="w" id="mwUw"> </span><span class="n" id="mwVA">germany</span><span class="w" id="mwVQ"> </span><span class="n" id="mwVg">in</span><span class="w" id="mwVw"> </span><span class="mi" id="mwWA">1</span><span class="w" id="mwWQ"> </span><span class="p" id="mwWg">..</span><span class="w" id="mwWw"> </span><span class="n" id="mwXA">nbColors</span><span class="p" id="mwXQ">;</span> <span class="w" id="mwXg"> </span><span class="c1" id="mwXw">// neighbouring countries must have a different color</span> <span class="w" id="mwYA"> </span><span class="n" id="mwYQ">constraints</span><span class="w" id="mwYg"> </span><span class="p" id="mwYw">{</span> <span class="w" id="mwZA"> </span><span class="n" id="mwZQ">belgium</span><span class="w" id="mwZg"> </span><span class="o" id="mwZw">!=</span><span class="w" id="mwaA"> </span><span class="n" id="mwaQ">germany</span><span class="p" id="mwag">;</span> <span class="w" id="mwaw"> </span><span class="n" id="mwbA">germany</span><span class="w" id="mwbQ"> </span><span class="o" id="mwbg">!=</span><span class="w" id="mwbw"> </span><span class="n" id="mwcA">denmark</span><span class="p" id="mwcQ">;</span> <span class="w" id="mwcg"> </span><span class="p" id="mwcw">}</span> <span class="w" id="mwdA"> </span><span class="c1" id="mwdQ">// a main entry point to test our model</span> <span class="w" id="mwdg"> </span><span class="kd" id="mwdw">public</span><span class="w" id="mweA"> </span><span class="kd" id="mweQ">static</span><span class="w" id="mweg"> </span><span class="kt" id="mwew">void</span><span class="w" id="mwfA"> </span><span class="nf" id="mwfQ">main</span><span class="p" id="mwfg">(</span><span class="n" id="mwfw">String</span><span class="o" id="mwgA">[]</span><span class="w" id="mwgQ"> </span><span class="n" id="mwgg">args</span><span class="p" id="mwgw">)</span> <span class="w" id="mwhA"> </span><span class="p" id="mwhQ">{</span> <span class="w" id="mwhg"> </span><span class="c1" id="mwhw">// instantiate the model</span> <span class="w" id="mwiA"> </span><span class="n" id="mwiQ">SimpleColoring</span><span class="w" id="mwig"> </span><span class="n" id="mwiw">m</span><span class="w" id="mwjA"> </span><span class="o" id="mwjQ">=</span><span class="w" id="mwjg"> </span><span class="k" id="mwjw">new</span><span class="w" id="mwkA"> </span><span class="n" id="mwkQ">SimpleColoring</span><span class="p" id="mwkg">();</span> <span class="w" id="mwkw"> </span><span class="c1" id="mwlA">// solve it</span> <span class="w" id="mwlQ"> </span><span class="n" id="mwlg">m</span><span class="p" id="mwlw">.</span><span class="na" id="mwmA">extract</span><span class="p" id="mwmQ">();</span> <span class="w" id="mwmg"> </span><span class="n" id="mwmw">m</span><span class="p" id="mwnA">.</span><span class="na" id="mwnQ">solve</span><span class="p" id="mwng">();</span> <span class="w" id="mwnw"> </span><span class="c1" id="mwoA">// print solutions</span> <span class="w" id="mwoQ"> </span><span class="n" id="mwog">System</span><span class="p" id="mwow">.</span><span class="na" id="mwpA">out</span><span class="p" id="mwpQ">.</span><span class="na" id="mwpg">println</span><span class="p" id="mwpw">(</span><span class="s" id="mwqA">"Belgium: "</span><span class="w" id="mwqQ"> </span><span class="o" id="mwqg">+</span><span class="w" id="mwqw"> </span><span class="n" id="mwrA">m</span><span class="p" id="mwrQ">.</span><span class="na" id="mwrg">value</span><span class="p" id="mwrw">(</span><span class="n" id="mwsA">m</span><span class="p" id="mwsQ">.</span><span class="na" id="mwsg">belgium</span><span class="p" id="mwsw">));</span> <span class="w" id="mwtA"> </span><span class="n" id="mwtQ">System</span><span class="p" id="mwtg">.</span><span class="na" id="mwtw">out</span><span class="p" id="mwuA">.</span><span class="na" id="mwuQ">println</span><span class="p" id="mwug">(</span><span class="s" id="mwuw">"Denmark: "</span><span class="w" id="mwvA"> </span><span class="o" id="mwvQ">+</span><span class="w" id="mwvg"> </span><span class="n" id="mwvw">m</span><span class="p" id="mwwA">.</span><span class="na" id="mwwQ">value</span><span class="p" id="mwwg">(</span><span class="n" id="mwww">m</span><span class="p" id="mwxA">.</span><span class="na" id="mwxQ">denmark</span><span class="p" id="mwxg">));</span> <span class="w" id="mwxw"> </span><span class="n" id="mwyA">System</span><span class="p" id="mwyQ">.</span><span class="na" id="mwyg">out</span><span class="p" id="mwyw">.</span><span class="na" id="mwzA">println</span><span class="p" id="mwzQ">(</span><span class="s" id="mwzg">"Germany: "</span><span class="w" id="mwzw"> </span><span class="o" id="mw0A">+</span><span class="w" id="mw0Q"> </span><span class="n" id="mw0g">m</span><span class="p" id="mw0w">.</span><span class="na" id="mw1A">value</span><span class="p" id="mw1Q">(</span><span class="n" id="mw1g">m</span><span class="p" id="mw1w">.</span><span class="na" id="mw2A">germany</span><span class="p" id="mw2Q">));</span> <span class="w" id="mw2g"> </span><span class="p" id="mw2w">}</span> <span class="p" id="mw3A">}</span>

Readers familiar with Java will notice a strong similarity with this language. Indeed, OptimJ is a conservative extension of Java: every valid Java program is also a valid OptimJ program and has the same behavior.

This map coloring example also shows features specific to optimization that have no direct equivalent in Java, introduced by the keywords model, var, constraints.

OR-specific concepts

Models

A model is an extension of a Java class that can contain not only fields and methods but also constraints and an objective function. It is introduced by the model keyword and follows the same rules as class declarations. A non-abstract model must be linked to a solver, introduced by the keyword solver. The capabilities of the solver will determine what kind of constraints can be expressed in the model, for instance a linear solver such as lp solve will only allow linear constraints.

<span id="mw6w"></span><span class="kd" id="mw7A">public</span><span class="w" id="mw7Q"> </span><span class="n" id="mw7g">model</span><span class="w" id="mw7w"> </span><span class="n" id="mw8A">SimpleColoring</span><span class="w" id="mw8Q"> </span><span class="n" id="mw8g">solver</span><span class="w" id="mw8w"> </span><span class="n" id="mw9A">lpsolve</span>

Decision variables

Imperative languages such as Java provide a notion of imperative variables, which basically represent memory locations that can be written to and read from.

OptimJ also introduces the notion of a decision variable, which basically represents an unknown quantity whose value one is searching. A solution to an optimization problem is a set of values for all its decision variables that respects the constraints of the problem—without decision variables, it would not possible to express optimization problems. The term "decision variable" comes from the optimization community, but decision variables in OptimJ are the same concept as logical variables in logical languages such as Prolog.

Decision variables have special types introduced by the keyword var. There is a var type for each possible Java type.

<span id="mw_g"></span><span class="w" id="mw_w"> </span><span class="c1" id="mwAQA">// a var type for a Java primitive type</span> <span class="w" id="mwAQE"> </span><span class="kd" id="mwAQI">var</span><span class="w" id="mwAQM"> </span><span class="n" id="mwAQQ">int</span><span class="w" id="mwAQU"> </span><span class="n" id="mwAQY">x</span><span class="p" id="mwAQc">;</span> <span class="w" id="mwAQg"> </span><span class="c1" id="mwAQk">// a var type for a user-defined class</span> <span class="w" id="mwAQo"> </span><span class="kd" id="mwAQs">var</span><span class="w" id="mwAQw"> </span><span class="n" id="mwAQ0">MyClass</span><span class="w" id="mwAQ4"> </span><span class="n" id="mwAQ8">y</span><span class="p" id="mwARA">;</span>

In the map coloring example, decision variables were introduced together with the range of values they may take.

<span id="mwARQ"></span><span class="w" id="mwARU"> </span><span class="kd" id="mwARY">var</span><span class="w" id="mwARc"> </span><span class="n" id="mwARg">int</span><span class="w" id="mwARk"> </span><span class="n" id="mwARo">germany</span><span class="w" id="mwARs"> </span><span class="n" id="mwARw">in</span><span class="w" id="mwAR0"> </span><span class="mi" id="mwAR4">1</span><span class="w" id="mwAR8"> </span><span class="p" id="mwASA">..</span><span class="w" id="mwASE"> </span><span class="n" id="mwASI">nbColors</span><span class="p" id="mwASM">;</span>

This is just a shorthand equivalent to putting a constraint on the variable.

Constraints

Constraints express conditions that must be true in any solution of the problem. A constraint can be any Java boolean expression involving decision variables.

In the map coloring example, this set of constraints states that in any solution to the map coloring problem, the color of Belgium must be different from the color of Germany, and the color of Germany must be different from the color of Denmark.

<span id="mwASo"></span><span class="w" id="mwASs"> </span><span class="n" id="mwASw">constraints</span><span class="w" id="mwAS0"> </span><span class="p" id="mwAS4">{</span> <span class="w" id="mwAS8"> </span><span class="n" id="mwATA">belgium</span><span class="w" id="mwATE"> </span><span class="o" id="mwATI">!=</span><span class="w" id="mwATM"> </span><span class="n" id="mwATQ">germany</span><span class="p" id="mwATU">;</span> <span class="w" id="mwATY"> </span><span class="n" id="mwATc">germany</span><span class="w" id="mwATg"> </span><span class="o" id="mwATk">!=</span><span class="w" id="mwATo"> </span><span class="n" id="mwATs">denmark</span><span class="p" id="mwATw">;</span> <span class="w" id="mwAT0"> </span><span class="p" id="mwAT4">}</span>

The operator != is the standard Java not-equal operator.

Constraints typically come in batches and can be quantified with the forall operator. For instance, instead of listing all countries and their neighbors explicitly in the source code, one may have an array of countries, an array of decision variables representing the color of each country, and an array boolean[][] neighboring or a predicate (a boolean function) boolean isNeighbor().

<span id="mwAUc"></span><span class="n" id="mwAUg">constraints</span><span class="w" id="mwAUk"> </span><span class="p" id="mwAUo">{</span> <span class="w" id="mwAUs"> </span><span class="n" id="mwAUw">forall</span><span class="p" id="mwAU0">(</span><span class="n" id="mwAU4">Country</span><span class="w" id="mwAU8"> </span><span class="n" id="mwAVA">c1</span><span class="w" id="mwAVE"> </span><span class="p" id="mwAVI">:</span><span class="w" id="mwAVM"> </span><span class="n" id="mwAVQ">countries</span><span class="p" id="mwAVU">,</span><span class="w" id="mwAVY"> </span><span class="n" id="mwAVc">Country</span><span class="w" id="mwAVg"> </span><span class="n" id="mwAVk">c2</span><span class="w" id="mwAVo"> </span><span class="p" id="mwAVs">:</span><span class="w" id="mwAVw"> </span><span class="n" id="mwAV0">countries</span><span class="p" id="mwAV4">,</span><span class="w" id="mwAV8"> </span><span class="p" id="mwAWA">:</span><span class="n" id="mwAWE">isNeighbor</span><span class="p" id="mwAWI">(</span><span class="n" id="mwAWM">c1</span><span class="p" id="mwAWQ">,</span><span class="n" id="mwAWU">c2</span><span class="p" id="mwAWY">))</span><span class="w" id="mwAWc"> </span><span class="p" id="mwAWg">{</span> <span class="w" id="mwAWk"> </span><span class="n" id="mwAWo">color</span><span class="o" id="mwAWs">[</span><span class="n" id="mwAWw">c1</span><span class="o" id="mwAW0">]</span><span class="w" id="mwAW4"> </span><span class="o" id="mwAW8">!=</span><span class="w" id="mwAXA"> </span><span class="n" id="mwAXE">color</span><span class="o" id="mwAXI">[</span><span class="n" id="mwAXM">c2</span><span class="o" id="mwAXQ">]</span><span class="p" id="mwAXU">;</span> <span class="w" id="mwAXY"> </span><span class="p" id="mwAXc">}</span> <span class="p" id="mwAXg">}</span>

Country c1 : countries is a generator: it iterates c1 over all the values in the collection countries.

:isNeighbor(c1,c2) is a filter: it keeps only the generated values for which the predicate is true (the symbol : may be read as "if").

Assuming that the array countries contains belgium, germany and denmark, and that the predicate isNeighbor returns true for the couples (Belgium , Germany) and (Germany, Denmark), then this code is equivalent to the constraints block of the original map coloring example.

Objectives

Optionally, when a model describes an optimization problem, an objective function to be minimized or maximized can be stated in the model.

Generalist concepts

Generalist concepts are programming concepts that are not specific to OR problems and would make sense for any kind of application development. The generalist concepts added to Java by OptimJ make the expression of OR models easier or more concise. They are often present in older modeling languages and thus provide OR experts with a familiar way of expressing their models.

Associative arrays

While Java arrays can only be indexed by 0-based integers, OptimJ arrays can be indexed by values of any type. Such arrays are typically called associative arrays or maps. In this example, the array age contains the age of persons, identified by their name:

<span id="mwAZY"></span><span class="w" id="mwAZc"> </span><span class="kt" id="mwAZg">int</span><span class="o" id="mwAZk">[</span><span class="n" id="mwAZo">String</span><span class="o" id="mwAZs">]</span><span class="w" id="mwAZw"> </span><span class="n" id="mwAZ0">age</span><span class="p" id="mwAZ4">;</span>

The type int[String] denoting an array of int indexed by String. Accessing OptimJ arrays using the standard Java syntax:

<span id="mwAaU"></span><span class="w" id="mwAaY"> </span><span class="n" id="mwAac">age</span><span class="o" id="mwAag">[</span><span class="s" id="mwAak">"Stephan"</span><span class="o" id="mwAao">]</span><span class="w" id="mwAas"> </span><span class="o" id="mwAaw">=</span><span class="w" id="mwAa0"> </span><span class="mi" id="mwAa4">37</span><span class="p" id="mwAa8">;</span> <span class="w" id="mwAbA"> </span><span class="n" id="mwAbE">x</span><span class="w" id="mwAbI"> </span><span class="o" id="mwAbM">=</span><span class="w" id="mwAbQ"> </span><span class="n" id="mwAbU">age</span><span class="o" id="mwAbY">[</span><span class="s" id="mwAbc">"Lynda"</span><span class="o" id="mwAbg">]</span><span class="p" id="mwAbk">;</span>

Traditionally, associative arrays are heavily used in the expression of optimization problems. OptimJ associative arrays are very handy when associated to their specific initialization syntax. Initial values can be given in intensional definition, as in:

<span id="mwAb4"></span><span class="kt" id="mwAb8">int</span><span class="o" id="mwAcA">[</span><span class="n" id="mwAcE">String</span><span class="o" id="mwAcI">]</span><span class="w" id="mwAcM"> </span><span class="n" id="mwAcQ">age</span><span class="w" id="mwAcU"> </span><span class="o" id="mwAcY">=</span><span class="w" id="mwAcc"> </span><span class="p" id="mwAcg">{</span><span class="w" id="mwAck"> </span> <span class="w" id="mwAco"> </span><span class="s" id="mwAcs">"Stephan"</span><span class="w" id="mwAcw"> </span><span class="o" id="mwAc0">-></span><span class="w" id="mwAc4"> </span><span class="mi" id="mwAc8">37</span><span class="p" id="mwAdA">,</span> <span class="w" id="mwAdE"> </span><span class="s" id="mwAdI">"Lynda"</span><span class="w" id="mwAdM"> </span><span class="o" id="mwAdQ">-></span><span class="w" id="mwAdU"> </span><span class="mi" id="mwAdY">29</span><span class="w" id="mwAdc"> </span> <span class="p" id="mwAdg">};</span>

or can be given in extensional definition, as in:

<span id="mwAd0"></span><span class="w" id="mwAd4"> </span><span class="kt" id="mwAd8">int</span><span class="o" id="mwAeA">[</span><span class="n" id="mwAeE">String</span><span class="o" id="mwAeI">]</span><span class="w" id="mwAeM"> </span><span class="n" id="mwAeQ">length</span><span class="o" id="mwAeU">[</span><span class="n" id="mwAeY">String</span><span class="w" id="mwAec"> </span><span class="n" id="mwAeg">name</span><span class="w" id="mwAek"> </span><span class="p" id="mwAeo">:</span><span class="w" id="mwAes"> </span><span class="n" id="mwAew">names</span><span class="o" id="mwAe0">]</span><span class="w" id="mwAe4"> </span><span class="o" id="mwAe8">=</span><span class="w" id="mwAfA"> </span><span class="n" id="mwAfE">name</span><span class="p" id="mwAfI">.</span><span class="na" id="mwAfM">length</span><span class="p" id="mwAfQ">();</span>

Here each of the entries length[i] is initialized with names[i].length().

Extended initialization

Tuples

Tuples are ubiquitous in computing, but absent from most mainstream languages including Java. OptimJ provides a notion of tuple at the language level that can be very useful as indexes in combination with associative arrays.

<span id="mwAf4"></span><span class="w" id="mwAf8"> </span><span class="p" id="mwAgA">(:</span><span class="w" id="mwAgE"> </span><span class="kt" id="mwAgI">int</span><span class="p" id="mwAgM">,</span><span class="w" id="mwAgQ"> </span><span class="n" id="mwAgU">String</span><span class="w" id="mwAgY"> </span><span class="p" id="mwAgc">:)</span><span class="w" id="mwAgg"> </span><span class="n" id="mwAgk">myTuple</span><span class="w" id="mwAgo"> </span><span class="o" id="mwAgs">=</span><span class="w" id="mwAgw"> </span><span class="k" id="mwAg0">new</span><span class="w" id="mwAg4"> </span><span class="p" id="mwAg8">(:</span><span class="w" id="mwAhA"> </span><span class="mi" id="mwAhE">3</span><span class="p" id="mwAhI">,</span><span class="w" id="mwAhM"> </span><span class="s" id="mwAhQ">"Three"</span><span class="w" id="mwAhU"> </span><span class="p" id="mwAhY">:);</span> <span class="w" id="mwAhc"> </span><span class="n" id="mwAhg">String</span><span class="w" id="mwAhk"> </span><span class="n" id="mwAho">s</span><span class="w" id="mwAhs"> </span><span class="o" id="mwAhw">=</span><span class="w" id="mwAh0"> </span><span class="n" id="mwAh4">myTuple</span><span class="err" id="mwAh8">#</span><span class="mi" id="mwAiA">1</span><span class="p" id="mwAiE">;</span>

Tuple types and tuple values are both written between (: and :).

Ranges

Comprehensions

Comprehensions, also called aggregates operations or reductions, are OptimJ expressions that extend a given binary operation over a collection of values. A common example is the sum:

<span id="mwAis"></span><span class="w" id="mwAiw"> </span><span class="c1" id="mwAi0">// the sum of all integers from 1 to 10</span> <span class="w" id="mwAi4"> </span><span class="kt" id="mwAi8">int</span><span class="w" id="mwAjA"> </span><span class="n" id="mwAjE">k</span><span class="w" id="mwAjI"> </span><span class="o" id="mwAjM">=</span><span class="w" id="mwAjQ"> </span><span class="n" id="mwAjU">sum</span><span class="w" id="mwAjY"> </span><span class="p" id="mwAjc">{</span><span class="w" id="mwAjg"> </span><span class="n" id="mwAjk">i</span><span class="w" id="mwAjo"> </span><span class="o" id="mwAjs">|</span><span class="w" id="mwAjw"> </span><span class="kt" id="mwAj0">int</span><span class="w" id="mwAj4"> </span><span class="n" id="mwAj8">i</span><span class="w" id="mwAkA"> </span><span class="n" id="mwAkE">in</span><span class="w" id="mwAkI"> </span><span class="mi" id="mwAkM">1</span><span class="w" id="mwAkQ"> </span><span class="p" id="mwAkU">..</span><span class="w" id="mwAkY"> </span><span class="mi" id="mwAkc">10</span><span class="p" id="mwAkg">};</span>

This construction is very similar to the big-sigma summation notation used in mathematics, with a syntax compatible with the Java language.

Comprehensions can also be used to build collections, such as lists, sets, multisets or maps:

<span id="mwAk4"></span><span class="w" id="mwAk8"> </span><span class="c1" id="mwAlA">// the set of all integers from 1 to 10</span> <span class="w" id="mwAlE"> </span><span class="n" id="mwAlI">HashSet</span><span class="o" id="mwAlM"><</span><span class="n" id="mwAlQ">Integer</span><span class="o" id="mwAlU">></span><span class="w" id="mwAlY"> </span><span class="n" id="mwAlc">s</span><span class="w" id="mwAlg"> </span><span class="o" id="mwAlk">=</span><span class="w" id="mwAlo"> </span><span class="err" id="mwAls">`</span><span class="n" id="mwAlw">hashSet</span><span class="p" id="mwAl0">(){</span><span class="w" id="mwAl4"> </span><span class="n" id="mwAl8">i</span><span class="w" id="mwAmA"> </span><span class="o" id="mwAmE">|</span><span class="w" id="mwAmI"> </span><span class="kt" id="mwAmM">int</span><span class="w" id="mwAmQ"> </span><span class="n" id="mwAmU">i</span><span class="w" id="mwAmY"> </span><span class="n" id="mwAmc">in</span><span class="w" id="mwAmg"> </span><span class="mi" id="mwAmk">1</span><span class="w" id="mwAmo"> </span><span class="p" id="mwAms">..</span><span class="w" id="mwAmw"> </span><span class="mi" id="mwAm0">10</span><span class="p" id="mwAm4">};</span>

Comprehension expressions can have an arbitrary expression as target, as in:

<span id="mwAnI"></span><span class="w" id="mwAnM"> </span><span class="c1" id="mwAnQ">// the sum of all squares of integers from 1 to 10</span> <span class="w" id="mwAnU"> </span><span class="kt" id="mwAnY">int</span><span class="w" id="mwAnc"> </span><span class="n" id="mwAng">k</span><span class="w" id="mwAnk"> </span><span class="o" id="mwAno">=</span><span class="w" id="mwAns"> </span><span class="n" id="mwAnw">sum</span><span class="w" id="mwAn0"> </span><span class="p" id="mwAn4">{</span><span class="w" id="mwAn8"> </span><span class="n" id="mwAoA">i</span><span class="o" id="mwAoE">*</span><span class="n" id="mwAoI">i</span><span class="w" id="mwAoM"> </span><span class="o" id="mwAoQ">|</span><span class="w" id="mwAoU"> </span><span class="kt" id="mwAoY">int</span><span class="w" id="mwAoc"> </span><span class="n" id="mwAog">i</span><span class="w" id="mwAok"> </span><span class="n" id="mwAoo">in</span><span class="w" id="mwAos"> </span><span class="mi" id="mwAow">1</span><span class="w" id="mwAo0"> </span><span class="p" id="mwAo4">..</span><span class="w" id="mwAo8"> </span><span class="mi" id="mwApA">10</span><span class="p" id="mwApE">};</span>

They can also have an arbitrary number of generators and filters:

<span id="mwApU"></span><span class="w" id="mwApY"> </span><span class="c1" id="mwApc">// the sum of all f(i,j), for 0<=i<10, 1<=j<=10 and i!=j </span> <span class="w" id="mwApg"> </span><span class="kt" id="mwApk">int</span><span class="w" id="mwApo"> </span><span class="n" id="mwAps">k</span><span class="w" id="mwApw"> </span><span class="o" id="mwAp0">=</span><span class="w" id="mwAp4"> </span><span class="n" id="mwAp8">sum</span><span class="p" id="mwAqA">{</span><span class="w" id="mwAqE"> </span><span class="n" id="mwAqI">f</span><span class="p" id="mwAqM">(</span><span class="n" id="mwAqQ">i</span><span class="p" id="mwAqU">,</span><span class="n" id="mwAqY">j</span><span class="p" id="mwAqc">)</span><span class="w" id="mwAqg"> </span><span class="o" id="mwAqk">|</span><span class="w" id="mwAqo"> </span><span class="kt" id="mwAqs">int</span><span class="w" id="mwAqw"> </span><span class="n" id="mwAq0">i</span><span class="w" id="mwAq4"> </span><span class="p" id="mwAq8">:</span><span class="w" id="mwArA"> </span><span class="mi" id="mwArE">10</span><span class="p" id="mwArI">,</span><span class="w" id="mwArM"> </span><span class="kt" id="mwArQ">int</span><span class="w" id="mwArU"> </span><span class="n" id="mwArY">j</span><span class="w" id="mwArc"> </span><span class="p" id="mwArg">:</span><span class="w" id="mwArk"> </span><span class="mi" id="mwAro">1</span><span class="w" id="mwArs"> </span><span class="p" id="mwArw">..</span><span class="w" id="mwAr0"> </span><span class="mi" id="mwAr4">10</span><span class="p" id="mwAr8">,</span><span class="w" id="mwAsA"> </span><span class="p" id="mwAsE">:</span><span class="n" id="mwAsI">i</span><span class="o" id="mwAsM">!=</span><span class="n" id="mwAsQ">j</span><span class="w" id="mwAsU"> </span><span class="p" id="mwAsY">}</span>

Comprehension need not apply only to numeric values. Set or multiset-building comprehensions, especially in combination with tuples of strings, make it possible to express queries very similar to SQL database queries:

<span id="mwAso"></span><span class="w" id="mwAss"> </span><span class="c1" id="mwAsw">// select name from persons where age > 18</span> <span class="w" id="mwAs0"> </span><span class="err" id="mwAs4">`</span><span class="n" id="mwAs8">multiSet</span><span class="p" id="mwAtA">(){</span><span class="w" id="mwAtE"> </span><span class="n" id="mwAtI">p</span><span class="p" id="mwAtM">.</span><span class="na" id="mwAtQ">name</span><span class="w" id="mwAtU"> </span><span class="o" id="mwAtY">|</span><span class="w" id="mwAtc"> </span><span class="n" id="mwAtg">Person</span><span class="w" id="mwAtk"> </span><span class="n" id="mwAto">p</span><span class="w" id="mwAts"> </span><span class="p" id="mwAtw">:</span><span class="w" id="mwAt0"> </span><span class="n" id="mwAt4">persons</span><span class="p" id="mwAt8">,</span><span class="w" id="mwAuA"> </span><span class="p" id="mwAuE">:</span><span class="n" id="mwAuI">p</span><span class="p" id="mwAuM">.</span><span class="na" id="mwAuQ">age</span><span class="w" id="mwAuU"> </span><span class="o" id="mwAuY">></span><span class="w" id="mwAuc"> </span><span class="mi" id="mwAug">18</span><span class="w" id="mwAuk"> </span><span class="p" id="mwAuo">}</span>

In the context of optimization models, comprehension expressions provide a concise and expressive way to pre-process and clean the input data, and format the output data.

Development environment

OptimJ is available as an Eclipse plug-in. The compiler implements a source-to-source translation from OptimJ to standard Java, thus providing immediate compatibility with most development tools of the Java ecosystem.

OptimJ GUI and Rapid Prototyping

Since the OptimJ compiler knows about the structure of all data used in models, it is able to generate a structured graphical view of this data at compile-time. This is especially relevant in the case of associative arrays where the compiler knows the collections used for indexing the various dimensions.

The basic graphical view generated by the compiler is reminiscent of an OLAP cube. It can then be customized in many different ways, from simple coloring up to providing new widgets for displaying data elements.

The compiler-generated OptimJ GUI saves the OR expert from writing all the glue code required when mapping graphical libraries to data. It enables rapid prototyping, by providing immediate visual hints about the structure of data.

Another part of the OptimJ GUI reports in real time performance statistics from the solver. This information can be used for understanding performance problems and improving solving time. At this time, it is available only for lp_solve.

Supported solvers

OptimJ is available for free with the following solvers lp_solve, glpk, LP or MPS file formats and also supports the following commercial solvers: Mosek, IBM ILOG CPLEX Optimization Studio.