LP_SOLVE(1ES)                                       LP_SOLVE(1ES)

           lp_solve  - Solve (mixed integer) linear programming

           lp_solve [option]* "<" <input-file>

           -v          Verbose mode. Among other things, shows all the

           -h          Help mode, prints the usage.

           -d          Debug mode, all intermediate results are
                       printed, and the branch-and-bound decisions in
                       case of (mixed) integer problems.

           -p          Print the values of the dual variables as well
                       in the result. They are named r_1 until r_XXXXX
                       unless specified by the user.  Note that bounds
                       (constraints on just one variable) are not
                       considered real constraints, and are not given a
                       row in the matrix, and are therefore not printed

           -b <bound>  Specify an upper (when minimizing) or lower
                       (when maximizing) limit for the value of the
                       objective function to the program. Only useful
                       for (mixed) integer problems.  If close enough,
                       may speed up the calculations. The same result
                       can be obtained by adding an extra constraint to
                       the problem.

           -c          When branching in MILP problems, take the
                       ceiling of the selected non-integer variable
                       first instead of the floor. This can influence
                       the speed of MILP problems.

           -e <value>  Specify the accuracy with which it is checked
                       whether the value of a variable is really
                       integer. <value> must be between 0 and 0.5.
                       Default value is 1e-6 and should be OK for most
                       applications. Of course only useful for MILP

           -i          Print all intermediate valid solutions. Can give
                       you useful solutions even if the total run time
                       is too long.  Only useful for (mixed) integer

           -scale <value>
                       Scale all coefficients by <value> while solving.

      Page 1                                         (printed 11/16/94)

      LP_SOLVE(1ES)                                       LP_SOLVE(1ES)

                       This is useful if you have mainly very large or
                       very small coefficients, and are running into
                       numerical problems because of this. For a
                       problem with both large and small coefficients
                       the -autoscale option might be more appropriate.

           -autoscale  Both rows and columns are scaled according to
                       the geometric mean of the coefficients on them
                       before solving. This might improve the numerical
                       stability of your problem.

           The linear programming problem can be formulated as: Solve
           A.x >= V1, with V2.x maximal. A is a matrix, x a vector of
           (nonnegative) variables, V1 a vector called the right hand
           side, and V2 a vector specifying the objective function.
           Any number of the variables may be specified to be of type
           This program solves problems of this kind. It is slightly
           more general than the above problem, in that every row of A
           (specifying one constraint) can have its own (in)equality,
           <=, >= or =. The result specifies values for all variables.
           Uses a 'Simplex' algorithm and sparse matrix methods, for
           pure LP problems.  If one or more of the variables is
           declared integer, the Simplex algorithm is iterated with a
           branch and bound algorithm, until the desired optimal
           solution is found.

           In order to make it possible to get useful solutions for a
           mixed integer problem which takes too long to finish
           completely, the "interrupt" signal (kill -INT, ^C for many
           people) will not terminate the program when it is solving a
           MILP problem, but rather print the best valid solution found
           so far. This feature is not useful and thus disabled when
           you are solving a pure LP problem. If you see all zeros, it
           implies that no valid solution has been found yet. To really
           terminate the program, use a different signal, like KILL.
           The "-i" option will print all intermediate valid solutions.

           The input syntax is a set of algebraic expressions and "int"
           declarations in the following order:

           <objective function>


           - <objective function> is a linear combination of variables,
             ending with a semicolon, optionally preceded by "max: " or

      Page 2                                         (printed 11/16/94)

      LP_SOLVE(1ES)                                       LP_SOLVE(1ES)

             "min: " to indicate whether you want it to be minimized or
             maximized. The case is not important, "Max:" or "MAX:"
             will work as well. Maximization is the default.

           - <constraint> is an optional constraint name followed by a
             colon plus a linear combination of variables and
             constants, followed by a relational operator, followed
             again by a linear combination of variables and constants,
             ending with a semicolon. The relational operator can be
             any of the following:  "<" "<=" "=" ">" ">=". There
             is no  semantic difference between "<" and "<=" nor 
             between ">" and ">=" (even for integer variables!).

           - <declaration> is of the form: "int" <var>+ ";" 
             Commas are allowed between variables.

             So, the simplest linear problem consists of an objective
             function and 1 constraint.

           The simple problem:

           x1 >= 1
           x2 >= 1
           x1 + x2 >= 2
           minimize x1 + x2 (= maximize -(x1 + x2)), with x1 integer

           can be written as follows:

           -x1 + -x2;
           (or min: x1 + x2;)
           x1 > 1;
           x2 > 1;
           x1 + x2 > 2;
           int x1;

           The correct result for (x1, x2) is of course (1, 1).

           Specifying a constraint name for a bound (constraints on
           just single variables) does not have an effect: they are not
           stored inside the main matrix and are not assigned a dual
           variable. I am not going to change this behavior.
           There are a few situations where lp_solve is known to give
           wrong "No solutions".

           -    The problem consists entirely of constraints on just
                single variables (so-called "bounds", like x < 1; ) and
                no constraint with more than 1 variable (like x + 3 y >
                17; ). This leaves lp_solve with an empty problem
                matrix, as bounds are not stored in the main matrix. No
                real-life examples should be of this form, so I am not

      Page 3                                         (printed 11/16/94)

      LP_SOLVE(1ES)                                       LP_SOLVE(1ES)

                really chasing this problem.

           -    There are variables in the objective function which do
                not occur in a constraint with more than 1 variable,
                but just in a bound. This is a bug in lp_solve which I
                would like to repair, but I have sofar been
                unsuccessful.  Anyway, this can easily be avoided, as
                the value of a variable just occurring in a bound and
                the objective function is trivially clear from the
                beginning.  You can also just constrain the value of
                the entire objective function in the first constraint
                by a number which you know will not constrict your LP

           -    Many people forget that lp_solve can only handle
                POSITIVE values for the variables.

           -    Sometimes problems are numerically unstable, and the
                unavoidable rounding errors inside lp_solve will cause
                wrong results (usually aborts or wrong "no soution"
                messages). It is very hard to give general solutions to
                this problem, but try to keep all values in your
                problem in the order of magnitude of 1 by proper
                scaling. lp_solve does not do do any scaling itself.
                Almost parallel constraints are also not very good for
                numerical stability. Use "lp_solve -v" and observe the
                values of the pivots to see if there are any
                dangerously large or low numbers there.
                Building lp_solve with long doubles (see the Makefile)
                can help to increase numerical stability, but will also
                increase the run time considerably.
                You can consult the author as well if you encounter
                numerical problems, but please remember that it is very
                easy to formulate an infeasible LP problem, so be sure
                there is a solution.

      SEE ALSO
           The implementation of the simplex kernel was mainly based
           W. Orchard-Hays: "Advanced Linear Programming Computing
           Techniques", McGraw-Hill 1968
           The mixed integer branch and bound part was inspired by:
           section 6.4 of "An Introduction to Linear Programming and
           Game Theory" by Paul R. Thie, second edition published by
           John Wiley and Sons in 1988.
           This book refers to:
           Dakin, R.J., "A Tree Search Algorithm for MILP Problems",
           Comput. J., 8 (1965) pp. 250-255

           M.R.C.M. Berkelaar
           Eindhoven University of Technology

      Page 4                                         (printed 11/16/94)

      LP_SOLVE(1ES)                                       LP_SOLVE(1ES)

           Design Automation Section
           P.O. Box 513
           NL-5600 MB Eindhoven, The Netherlands
           phone ...-31-40-473345
           E-mail: michel@es.ele.tue.nl

           Use at own risk. Bug reports are welcome, as well as success

      Page 5                                         (printed 11/16/94)