# Using lp_solve 5.5 in Java programs

## Contents

1. Introduction
2. Installation
3. Usage
4. Implementation notes
5. Building from source
6. Calling lp_solve from Python/Jython

## 1. Introduction

lp_solve is a free (see LGPL for the GNU lesser general public license) linear (integer) programming solver based on the revised simplex method and the Branch-and-bound method for the integers. lp_solve has its own community via the Yahoo group http://groups.yahoo.com/group/lp_solve. There you can find the latest sources, executables for the common platforms, examples, manuals and a message board where people can share their thoughts on lp_solve.

lp_solve is written in ANSI C and can be compiled on many different platforms like Linux and Windows. Basically, lp_solve is a library, a set of routines, that can be called easily from programming languages like C, C++, C# and VB. Unfortunately, there is no simple and straightforward way to use native C libraries like lp_solve in Java programs. This library (also called "Java wrapper") is designed to remedy this shortcoming. It consists of two main parts:

- A Java class library that is used by Java client programs. It gives access to all lp_solve routines through the `LpSolve` class.
- A native library written in C++, also called 'stub' library, that uses the JNI (Java Native Interface) API to translate Java method calls into calls to the corresponding routines of the lp_solve library. Java client programs do not interact directly with the stub library. This library must be compiled for each target platform. Precompiled binaries are included for Windows and Linux operating systems. There is also a build script for compiling the stub library on Mac OS X.

This document should help you getting started using the Java wrapper and lp_solve in your Java programs. Read it in addition to the documentation that comes with lp_solve. Always refer to the lp_solve docs as ultimate reference for using the routines of the optimization library. Bug reports, succes stories and requests for changes concerning the Java wrapper are welcome by email at `juergen.ebert@web.de` or in the lp_solve discussion group.

The current wrapper version was written to work with lp_solve 5.5.0.9 and was tested under Windows XP and Linux. As long as the API stays the same, other versions of lp_solve are likely to work as well. The wrapper requires a Java Runtime Environment 1.3 or later.

The latest version of the Java wrapper can be found in the files section of the lp_solve group. The wrapper is released under the same LGPL license conditions as lp_solve. A copy of the LGPL text is contained in the distribution archive.

## 2. Installation

- Copy the lp_solve dynamic libraries from the archives `lp_solve_5.5_dev.(zip or tar.gz)` and `lp_solve_5.5_exe.(zip or tar.gz)` to a standard library directory for your target platform. On Windows, a typical place would be `\WINDOWS` or `\WINDOWS\SYSTEM32`. On Linux, a typical place would be the directory `/usr/local/lib`.
- Unzip the Java wrapper distribution file to new directory of your choice.
- On Windows, copy the wrapper stub library `lpsolve55j.dll` to the directory that already contains `lpsolve55.dll`.
- On Linux, copy the wrapper stub library `liblpsolve55j.so` to the directory that already contains `liblpsolve55.so`. Run `ldconfig` to include the library in the shared libray cache.

## 3. Usage

To create a Java application that uses lp_solve routines, you must perform the following steps:

- Make sure you have a Java Runtime Environment 1.3 or later installed.
- Install lp_solve and the Java wrapper as described above.
- Copy the archive file `lpsolve55j.jar` from the Java wrapper distribution to a directory that is included in the CLASSPATH of your java program.
- Add an import statement for the package `lpsolve.*` at the beginning of your source file.
- Call `LpSolve.makeLp(...)` or one of the other static factory methods of the LpSolve class to create a `LpSolve` instance. Each `LpSolve` instance represents an optimization problem.
- Call the methods of the `LpSolve` instance to define the problem and obtain the solution. Use the examples and implementation notes later in this documentation for further information.
- When you run your Java file make sure to include `lpsolve55j.jar` in the CLASSPATH. Also, on Windows, if you installed the native stub library in a directory that is not included in the PATH variable, you have to define the Java system variable `java.library.path` which must point to the installation directory. On Linux, the equivalent of the Windows PATH variable is called LD_LIBRARY_PATH.

### A simple example

The following program is a very simple example that shows how to program with lp_solve in Java.

    import lpsolve.*;

    public class Demo {

      public static void main(String[] args) {
        try {
          // Create a problem with 4 variables and 0 constraints
          LpSolve solver = LpSolve.makeLp(0, 4);

          // add constraints
          solver.strAddConstraint("3 2 2 1", LpSolve.LE, 4);
          solver.strAddConstraint("0 4 3 1", LpSolve.GE, 3);

          // set objective function
          solver.strSetObjFn("2 3 -2 3");

          // solve the problem
          solver.solve();

          // print solution
          System.out.println("Value of objective function: " + solver.getObjective());
          double[] var = solver.getPtrVariables();
          for (int i = 0; i < var.length; i++) {
            System.out.println("Value of var[" + i + "] = " + var[i]);
          }

          // delete the problem and free memory
          solver.deleteLp();
        }
        catch (LpSolveException e) {
           e.printStackTrace();
        }
      }

    }

### Using callbacks

The following code fragment shows you how to use callbacks in Java. The example defines an anonymous inner class that implements the `AbortListener` interface which is then passed to the `putAbortfunc` method.

        LpSolve solver = LpSolve.makeLp(0, 4);
        AbortListener abortfunc = new AbortListener() {
          public boolean abortfunc(LpSolve problem, Object handle) {
            System.out.println("Java abortfunc called, handle = " + handle);
            return false;
          }
        };
        solver.putAbortfunc(abortfunc, new Integer(123));

### Running the demo application

Follow these steps to run the demo application, which is a port of the C demo program that comes with lp_solve to the Java language. You will need a Java Runtime Environment (JRE) on your machine in order to run the demo. You can download the latest JRE from http://java.sun.com

- Install lp_solve and the Java wrapper as described above.
- On Windows, go to the `demo` directory and start the batch script "run_demo.bat".
- On Linux, go to the `demo` directory of the wrapper distribution and run "sh run_demo".

### More example code

In the `demo` directory you will find the file `LpSolveTest.java` which contains more than 100 JUnit test cases (see http://www.junit.org for details about this highly useful software) to strengthen the faith in the Java wrapper implementation. The test cases may also seve as examples of basic lp_solve usage in Java. You will need the library `junit.jar` in your `CLASSPATH` to run the test cases. `junit.jar` is included in the `lib` directory of the Java wrapper. You can run the test cases directly by starting the batch script "run_unittests.bat" on Windows or "sh run_unittests" on Linux.

## 4. Implementation notes

- In general, the Java API tries to follow the original C/C++ API of lp_solve as closely as possible to make ist easier for programmers who have to write programs for lp_solve in multiple different programming languages. However, because of fundamental differences between the Java programming language and C/C++ this is not always strictly possible. For example, it is not possible in Java to pass simple datatypes by reference.
- Method names have been kept, but changed to Java convention, i.e. underscores have been removed, the following character is capitalized. For example `str_add_constraint` becomes `strAddConstraint` in Java.
- The `lprec*` argument taken by almost all lp_solve API routines is hidden completely inside the `LpSolve` class. All methods that create new `lprec` structures were made static methods of the `LpSolve` class.
- Return values denoting fatal internal errors have been changed to Java Exceptions. For example `set_row_name` returns FALSE if an error has occured. In Java, `setRowName` is of type void and throws a `LpSolveException`.
- Routines that have arguments or return values of type unsigned char, but only allow for TRUE or FALSE as legal values have been changed to type `boolean`. Example: `set_debug(lprec *lp, unsigned char debug)` is `setDebug(boolean debug)` in Java.
- Multiple problems may be solved concurrently by multiple threads, as long as a single `LpSolve` object, which represents a problem, is only used by one thread at a time.
- lp_solve does not require client programs to keep argument buffers allocated between calls to different library routines, because all input arguments are copied to internal buffers. Thus, it is easy to avoid memory leaks in the stub library. All objects returned by the Java wrapper routines are allocated by the JVM and are subject to the standard garbage collection process.
- The methods `get_ptr_sensitivity_rhs`, `get_ptr_reduced_costs`, `get_ptr_sensitivity_obj`, and `get_ptr_sensitivity_objex` are not implemented, because it is not possible in Java to pass pointers by reference to a method. Use the corresponding methods without the `Ptr` part in the method name instead, which require allocation of the resulting arrays by the caller.
- See the file `reference.html` for details on how the lp_solve API functions are mapped to the Java methods.

## 5. Building from source

The Java wrapper archive contains precompiled binary libraries for Windows and Linux. If you just want to use the wrapper there should be no need to build the libs from the sources. But if you absolutely have to, follow the guidelines in this chapter.

### On Windows OS

The following prerequisites must be met in order to build the wrapper C library from source on Windows operating systems:

- Microsoft Visual C++ compiler (I used V 7, others might work)
- Visual Studio envirement variables must be set.
- Sun Java Development Kit 1.4.x installed and JAVA_HOME environment variable set
- lp_solve Windows development archive `lp_solve_5.5_dev.zip` unpacked

Change to the `lib` directory and edit the file `build.bat`. Change the path to the directory where you unpacked the lp_solve Windows archive. Run the script to build `lpsolve55j.dll`. The dll will be created in directory win32 or win64 depending on the OS.

### On Linux

The following prerequisites must be met in order to build the wrapper C library from source on Linux operating systems:

- gcc and g++ compiler installed (I used gcc Version 3.3.1)
- Sun Java Development Kit 1.4.x installed
- lp_solve Linux development archive `lp_solve_5.5_dev.tar.gz` unpacked

Change to the `lib` directory and edit the file `build`. Change the paths to the directory where you unpacked the lp_solve linux archive and where the JDK is installed. Run `sh build` to build `liblpsolve55j.so`. The dll will be created in directory ux32 or ux64 depending on the OS.

### On Mac OS X

Change to the `lib/mac` directory and edit the file `build_osx`. Change the directory paths as indicated in the comments. Thanks to Sean P. Kane (spkane@genomatica.com) who provided this build script.

## 6. Calling lp_solve from Python/Jython

Jython (http://www.jython.org) is a 100% Java implementation of the popular scripting language Python. One of the most remarkable features of Jython is the seamless interaction between Python and Java. Java programmers can add the Jython libraries to their system to allow end users to write scripts that add functionality to the application. On the other hand, Python/Jython programs can interact with Java packages or with running Java applications.

lp_solve functions can be called via the Java wrapper from Python/Jython programs. See the file `demo.py` in the `demo` directory of the Java wrapper distribution for an example program. To run this program, you must install lp_solve, the Java wrapper, and Jython. Don't forget to include `lpsolve55j.jar` in the Java CLASSPATH when you run Jython.