set_basisvarThis is an internal function that has been published for special purposes. It should generally not be used. int set_basisvar(lprec *lp, int basisPos, int enteringCol); Return Value Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI basisPos enteringCol Remarks Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI |
is_semicontGets the type of the variable. semi-continuous or not. unsigned char is_semicont(lprec *lp, int column); Return Value is_semicont returns TRUE (1) if the variable is set as semi-continuous, FALSE (0)
otherwise. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be checked. It must be between 1 and the number of columns in the lp. Remarks The is_semicont function returns if a variable must be semi-continuous or not. Default a variable is not semi-continuous. See semi-continuous variables for a description about semi-continuous variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_semicont |
get_Norig_rowsReturns the number of original rows (constraints) in the lp. int get_Norig_rows(lprec *lp); Return Value get_Norig_rows returns the number of original rows (constraints) in the lp. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_Norig_rows function returns the number of original rows (constraints) in the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_Nrows, get_Lrows, get_Ncolumns, get_Norig_columns, get_orig_index, get_lp_index |
print_strPrints a string. void print_str(lprec *lp, char *str); Return Value print_str has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI str The string to print Remarks
The print_str function prints a string. By default, the output is stdout. However
this can be changed via a call to set_outputstream, set_outputfile. Example See Also delete_lp, free_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, print_objective, print_solution, print_constraints, print_duals, print_scales, print_tableau, set_outputstream, set_outputfile, print_debugdump |
dualize_lpCreate the dual of the current model. unsigned char dualize_lp(lprec *lp); Return Value Returns TRUE if succeeded. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
Example See Also make_lp, copy_lp, delete_lp, free_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI |
set_bb_depthlimitSets the maximum branch-and-bound depth. void set_bb_depthlimit(lprec *lp, int bb_maxlevel); Return Value set_bb_depthlimit has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI bb_maxlevel Specifies the maximum branch-and-bound depth. A positive value means that the depth is absoluut. A negative value means a relative B&B depth limit. The "order" of a MIP problem is defined to be 2x the number of binary variables plus the number of SC and SOS variables. A relative value of -x results in a maximum depth of x times the order of the MIP problem. Remarks The set_bb_depthlimit function sets the maximum branch-and-bound depth. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_bb_depthlimit |
set_presolveSpecifies if a presolve must be done before solving. void set_presolve(lprec *lp, int do_presolve, int maxloops); Return Value set_presolve has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI do_presolve Specifies presolve level. Can be the (OR) combination of any of the following values:
maxloops The maximum number of times presolve may be done. Use get_presolveloops if you don't want to change this value. Remarks The set_presolve function specifies if a presolve must be done before
solving. Presolve looks at the model and tries to simplify it so that solving
times are shorter. For example a constraint on only one variable is converted
to a bound on this variable (and the constraint is deleted). Note that the
model dimensions can change because of this, so be careful with this. Both rows
and columns can be deleted by the presolve.
int Norig_columns, Norig_rows, i;
REAL value;
Norig_columns = get_Norig_columns(lp);
Norig_rows = get_Norig_rows(lp);
for(i = 1; i <= Norig_columns; i++) {
value = get_var_primalresult(lp, Norig_rows + i);
printf("%f\n", value);
}
Note that there is no possibility to get the values of deleted rows. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_presolve, get_presolveloops, is_presolve |
get_epselReturns the value that is used as a tolerance for rounding values to zero. REAL get_epsel(lprec *lp); Return Value get_epsel returns the value of epsel. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_epsel function returns the value that is used for rounding values
to zero. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_epsel, set_infinite, get_infinite, is_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsb, get_epsb, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
get_constraints, get_ptr_constraintsReturns the values of the constraints. unsigned char get_constraints(lprec *lp, REAL *constr); unsigned char get_ptr_constraints(lprec *lp, REAL **ptr_constr); Return Value get_constraints, get_ptr_constraints returns TRUE (1) if the operation
was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI constr An array that will contain the values of the constraints. ptr_constr The address of a pointer that will point to an array that will contain the values of the constraints. Remarks The get_constraints, get_ptr_constraints functions retrieve the
values of the constraints. Note that get_ptr_constraints returns a pointer to memory allocated and maintained by lp_solve. Be careful what you do with it. Don't modify its contents or free the memory. Unexpected behaviour would occur. Also note that this memory pointer is only guaranteed to remain constant until a next lp_solve API call is done. You should call this function again to make sure you have again the correct pointer. Otherwise, this pointer could point to invalid memory. This should not be a problem since this call is very efficient. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_feasible, get_objective, get_working_objective, get_variables, get_ptr_variables, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_constr_value, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex, |
is_binaryGets the type of the variable. Binary integer or floating point. unsigned char is_binary(lprec *lp, int column); Return Value is_binary returns TRUE (1) if the variable is set as binary, FALSE (0)
otherwise. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be checked. It must be between 1 and the number of columns in the lp. Remarks The is_binary function returns if a variable must be binary or not. Default a variable is not binary. A binary variable is an integer variable with lower bound 0 and upper bound 1. From the moment there is at least one integer variable in the model, the Branch and Bound algorithm is used to make these variables integer. Note that solving times can be considerably larger when there are integer variables. See integer variables for a description about integer variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_binary, is_int, set_int |
is_SOS_varReturns if the variable is SOS (Special Ordered Set) or not. unsigned char is_SOS_var(lprec *lp, int column); Return Value is_SOS_var returns TRUE (1) if the variable is a SOS var, FALSE (0) if
not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be checked. It must be between 1 and the number of columns in the lp. Remarks The is_SOS_var function returns if a variable is a SOS variable or not. Default a variable is not SOS. A variable becomes a SOS variable via add_SOS. See Special Ordered Sets for a description about SOS variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_SOS |
set_bb_ruleSpecifies the branch-and-bound rule. void set_bb_rule(lprec *lp, int bb_rule); Return Value set_bb_rule has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI bb_rule The branch-and-bound rule. Can by any of the following values:
One of these values may be or-ed with one or more of the following values:
Remarks The set_bb_rule function specifies the branch-and-bound rule for choosing
which non-integer variable is to be selected. This rule can influence solving
times considerably. Depending on the model one rule can be best and for another
model another rule. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_bb_rule, put_bb_nodefunc |
get_total_iterReturns the total number of iterations. long long get_total_iter(lprec *lp); Return Value get_total_iter returns the total number of iterations. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks If the model contains integer variables then it returns the number of iterations
to find a relaxed solution plus the number of iterations in the B&B process. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_max_level, get_total_nodes |
get_lp_indexReturns the index in the lp of the original row/column. int get_lp_index(lprec *lp, int orig_index); Return Value get_lp_index returns the index in the lp of the original row/column. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI orig_index Original constraint or column number. If orig_index is between 1 and get_Norig_rows then the index is a constraint (row) number. If orig_index is between 1+get_Norig_rows and get_Norig_rows + get_Norig_columns then the index is a column number. Remarks The get_lp_index function returns the index in the lp of the original row/column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_orig_index, get_Ncolumns, get_Norig_columns, get_Nrows, get_Norig_rows, get_Lrows, set_presolve |
set_epsintSpecifies the tolerance that is used to determine whether a floating-point number is in fact an integer. void set_epsint(lprec *lp, REAL epsint); Return Value set_epsint has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI epsint The tolerance that is used to determine whether a floating-point number is in fact an integer. Remarks The set_epsint function specifies the tolerance that is used to determine
whether a floating-point number is in fact an integer. This is only used when
there is at least one integer variable and the branch and bound algorithm is
used to make variables integer. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_epsint, set_infinite, is_infinite, get_infinite, set_epsb, get_epsb, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
get_maxpivotReturns the maximum number of pivots between a re-inversion of the matrix. int get_maxpivot(lprec *lp); Return Value get_maxpivot returns the maximum number of pivots between a
re-inversion of the matrix. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_maxpivot function returns the maximum number of pivots between
a re-inversion of the matrix. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_maxpivot |
Changes from version 5.1 to version 5.5Main features and changes to v5.5 compared to v5.1Why a jump from version numbers 5.1 to 5.5 ? This is done to indicate that this is more than just another update. The solver engine was revised and optimised in such a way that performance has improved considerably. Numerical stability is also better resulting in more models that can be solved. The LUSOL bfp is now also the default. In the past, the etaPFI bfp package was the default, but for larger models this leads faster to numerical instabilities and performance problems. Overall, the v5.5 code is faster and more robust than v5.1. This robustness is for example proven by the fact that many more models can now be solved even without scaling. The API hasn't changed very much. There are a couple of new routines and one routine has an extra argument. Some constants got new values.
Note the store and read options from a file. This can be a very nice new feature. lp_solve has a lot of options and with this new addition it is much easier to set these options. People can start looking for the best options that work for their models very easily and it could help to find even better default options. Changed API calls
New API calls
Removed API calls
|
set_upboSet the upper bound of a variable. unsigned char set_upbo(lprec *lp, int column, REAL value); Return Value set_upbo returns TRUE (1) if the operation was successful. A return value
of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable on which the bound must be set. It must be between 1 and the number of columns in the lp. Remarks The set_upbo function sets an upper bound on the variable identified by column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_upbo, set_lowbo, get_lowbo, set_bounds, set_unbounded, is_unbounded, is_negative |
integer variablesInteger variables are variables that must take an integer value (0, 1, 2, ...). A special kind of integer variables is binary variables. Binary variables can only take the value 0 or 1. They are integer variables with a maximum of 1 on them (and don't forget there is always an implicit minimum of 0 on each variable). If all variables are integer then it is a pure integer model, else it is a mixed-integer model, sometimes denoted as MIP (Mixed Integer Programming). There are many practical uses of such variables. Binary variables for example are used to specify that something may be used or not. Integer variables say that a variable must take a multiple of a given value. For example if you want that a given variable must be a multiple of 25 then you can construct following equation: var - 25 i = 0 with i the integer variable and var the variable that must be a multiple of 25. So an extra variable and an extra constraint is needed. This is ok if only a limited number of such variables are in the model, but if there are alot then the model dimensions will increase considerably. As an alternative you can also do a substitution of the variable: var = 25 i Everywhere where variable var is used, substitute it by 25 i. This in the objective function, the constraints and bounds. So variable var is removed from the model and replaced by i. i can be defined as integer. The objective value of this substituted model will be the same as the original one. However to obtain the value of variable var, you must multiply the returned variable i with 25. There is however one drawback on integer variables. These models are harder to solve and solution time can increment exponentially. The more integer variables there are the more time it takes to solve the model. A model without the integer variables may for example be solved in 0.1 seconds while the same model with some of the variables integer can take several minutes to solve. Be aware of this. Also try to limit the solution as much as possible. If you know some extra bounds on variables then it can be very good for the solution time to set them because this limits the number of combinations the algorithm has to examine. Another negative site on integer variables is the inaccurate sensitivity analysis when integer variables are used. See Inaccurate sensitivity analysis in a model with integer variables The integer solution is searched via the so-called 'branch-and-bound' algorithm. The model is first solved without the integer restrictions. Then it is investigated which of the integer variables are non-integer. When such a variable is found the model is split in two sub models. A first one with a minimum restriction on this variable that has the ceiling integer value and a second one with a maximum restriction on this variable that has the floor integer value. Both these sub models are optimised again and now this variable will have an integer value (if there is a solution). The algorithm then looks again if there are still (other) integer variables that have a non-integer value and if so the process is done again. This until a solution is found where are integer variables have integer values. This solution is then remembered as the best-until-now solution and the algorithm continues until it finds again an integer solution and if it is better it takes this one as the best-until-now solution. The more integer variables there are, the more combinations must be investigated and the more time it takes to solve the model. lp_solve supports integer variables since a long time. The API call set_int can be used to define a variable as integer. The API call set_binary can be used to define a variable as binary. In the mps format, integer variables can be specified in the
COLUMNS section. See mps-format .
ROWS
N r_0
L r_1
G r_2
G r_3
G r_4
COLUMNS
x1 r_0 -1 r_1 1
x1 r_2 2 r_3 -1
x2 r_0 -2 r_1 1
x2 r_2 -1 r_3 3
MARK0000 'MARKER' 'INTORG'
x3 r_0 0.1 r_4 1
MARK0001 'MARKER' 'INTEND'
x4 r_0 3 r_4 1
RHS
RHS r_1 5 r_4 0.5
BOUNDS
LO BND x3 1.1
ENDATA
The red lines are two lines that specify that variable x3 is an integer variable. It also has a lower bound of 1.1 set on it. The solution of this model is: Value of objective function: -8.13333 Actual values of the variables: x1 1.66667 x2 3.33333 x3 2 x4 0 As can be seen, the value of x3 is 2, an integer value. If the integer restrictions would not be set on x3 then the value would be 1.1. In the lp-format, variables can be specified as integer by putting them in the int section. See lp-format. The above mps example would be in lp-format: min: -x1 -2 x2 +0.1 x3 +3 x4; r_1: +x1 +x2 <= 5; r_2: +2 x1 -x2 >= 0; r_3: -x1 +3 x2 >= 0; r_4: +x3 +x4 >= 0.5; x3 >= 1.1; int x3; In the lp-format, variables can be specified as binary by putting them in the bin section. See lp-format. For example: min: -x1 -2 x2 +0.1 x3 +3 x4; r_1: +x1 +x2 <= 5; r_2: +2 x1 -x2 >= 0; r_3: -x1 +3 x2 >= 0; r_4: +x3 +x4 >= 0.5; bin x3; |
R is a language and environment for statistical computing and graphics. It is a GNU project which is similar to the S language and environment which was developed at Bell Laboratories (formerly AT&T, now Lucent Technologies) by John Chambers and colleagues. R can be considered as a different implementation of S. There are some important differences, but much code written for S runs unaltered under R.
R provides a wide variety of statistical (linear and nonlinear modelling, classical statistical tests, time-series analysis, classification, clustering, ...) and graphical techniques, and is highly extensible. The S language is often the vehicle of choice for research in statistical methodology, and R provides an Open Source route to participation in that activity.
One of R's strengths is the ease with which well-designed publication-quality plots can be produced, including mathematical symbols and formulae where needed. Great care has been taken over the defaults for the minor design choices in graphics, but the user retains full control.
R is available as Free Software under the terms of the Free Software Foundation's GNU General Public License in source code form. It compiles and runs on a wide variety of UNIX platforms and similar systems (including FreeBSD and Linux), Windows and MacOS.
R is an integrated suite of software facilities for data manipulation, calculation and graphical display. It includes
The term "environment" is intended to characterize it as a fully planned and coherent system, rather than an incremental accretion of very specific and inflexible tools, as is frequently the case with other data analysis software.
R, like S, is designed around a true computer language, and it allows users to add additional functionality by defining new functions. Much of the system is itself written in the R dialect of S, which makes it easy for users to follow the algorithmic choices made. For computationally-intensive tasks, C, C++ and Fortran code can be linked and called at run time. Advanced users can write C code to manipulate R objects directly.
Many users think of R as a statistics system. We prefer to think of it of an environment within which statistical techniques are implemented. R can be extended (easily) via packages. There are about eight packages supplied with the R distribution and many more are available through the CRAN family of Internet sites covering a very wide range of modern statistics.
We will not discuss the specifics of R here but instead refer the reader to the R website. Also see An Introduction to R
lpsolve is callable from R via an extension or module. As such, it looks like lpsolve is fully integrated with R. Matrices can directly be transferred between R and lpsolve in both directions. The complete interface is written in C so it has maximum performance.
There are currently two R packages based on lp_solve. Both packages are available from CRAN.
The lpSolve R package is the first implementation of an interface of lpsolve to R.
It provides high-level functions for solving general linear/integer problems, assignment problems and transportation problems.
The following link contains the version of the driver: lpSolve: Interface to Lp_solve v. 5.5 to solve linear/integer programs.
It does not contain the lpsolve API. Only the higher level calls.
Documentation for this interface can be found on: Interface to Lp_solve v. 5.5 to solve linear/integer programs
This driver is written and maintained by Sam Buttrey.
The lpSolveAPI R package is a second implementation of an interface of lpsolve to R.
It provides an R API mirroring the lp_solve C API and hence provides a great deal more functionality but has a steeper learning curve.
The R interface to lpsolve contains its own documentation.
See An R interface to the lp_solve library for the driver.
This driver is written and maintained by Kjell Konis.
How to install the driver depends on the environment.
In the RGui menu, there is a menu item 'Packages'. From there a package can be installed from a CRAN mirror or from a local zip file.
Packages can also be installed from the R command line. This is a more general approach that will work under all environments.
Installing the package takes a single command:
The lpSolve R package:
> install.packages("lpSolve")
and to install the lpSolveAPI package use the command:
> install.packages("lpSolveAPI")
The > shown before each R command is the R prompt. Only the text after > must be entered.
> library(lpSolveAPI)Or
> library("lpSolveAPI", character.only=TRUE)
Documentation is provided for each function in the lpSolve package using R's built-in help system. For example, the command
> ?add.constraintwill display the documentation for the add.constraint function.
This implementation provides the functions lp, lp.assign, lp.object, lp.transport and print.lp. These functions allow a linear program (and transport and assignment problems) to be defined and solved using a single command.
For more information enter:
> ?lp
> ?lp.assign
> ?lp.object
> ?lp.transport
> ?print.lp
See also Interface to Lp_solve v. 5.5 to solve linear/integer programs
This implementation provides an API for building and solving linear programs that mimics the lp_solve C API. This approach allows much greater flexibility but also has a few caveats. The most important is that the lpSolve linear program model objects created by make.lp and read.lp are not actually R objects but external pointers to lp_solve 'lprec' structures. R does not know how to deal with these structures. In particular, R cannot duplicate them. Thus one must never assign an existing lpSolve linear program model object in R code.
To load the library, enter:
> library(lpSolveAPI)
Consider the following example. First we create an empty model x.
> x <- make.lp(2, 2)Then we assign x to y.
> y <- xNext we set some columns in x.
> set.column(x, 1, c(1, 2)) > set.column(x, 2, c(3, 4))
And finally, take a look at y.
> y
Model name:
C1 C2
Minimize 0 0
R1 1 3 free 0
R2 2 4 free 0
Type Real Real
upbo Inf Inf
lowbo 0 0
The changes we made in x appear in y as well. Although x and y are two distinct objects in R, they both refer to the same lp_solve 'lprec' structure.
The safest way to use the lpSolve API is inside an R function - do not return the lpSolve linear program model object.
> lprec <- make.lp(0, 4)
> set.objfn(lprec, c(1, 3, 6.24, 0.1))
> add.constraint(lprec, c(0, 78.26, 0, 2.9), ">=", 92.3)
> add.constraint(lprec, c(0.24, 0, 11.31, 0), "<=", 14.8)
> add.constraint(lprec, c(12.68, 0, 0.08, 0.9), ">=", 4)
> set.bounds(lprec, lower = c(28.6, 18), columns = c(1, 4))
> set.bounds(lprec, upper = 48.98, columns = 4)
> RowNames <- c("THISROW", "THATROW", "LASTROW")
> ColNames <- c("COLONE", "COLTWO", "COLTHREE", "COLFOUR")
> dimnames(lprec) <- list(RowNames, ColNames)
Lets take a look at what we have done so far.
> lprec # or equivalently print(lprec)
Model name:
COLONE COLTWO COLTHREE COLFOUR
Minimize 1 3 6.24 0.1
THISROW 0 78.26 0 2.9 >= 92.3
THATROW 0.24 0 11.31 0 <= 14.8
LASTROW 12.68 0 0.08 0.9 >= 4
Type Real Real Real Real
upbo Inf Inf Inf 48.98
lowbo 28.6 0 0 18
Now lets solve the model.
> solve(lprec) [1] 0 > get.objective(lprec) [1] 31.78276 > get.variables(lprec) [1] 28.60000 0.00000 0.00000 31.82759 > get.constraints(lprec) [1] 92.3000 6.8640 391.2928
Note that there are some commands that return an answer. For the accessor functions (generally named get.*) the output should be clear. For other functions (e.g., solve), the interpretation of the returned value is described in the documentation. Since solve is generic in R, use the command
> ?solve.lpExtPtrto view the appropriate documentation. The assignment functions (generally named set.*) also have a return value - often a logical value indicating whether the command was successful - that is returned invisibly. Invisible values can be assigned but are not echoed to the console. For example,
> status <- add.constraint(lprec, c(12.68, 0, 0.08, 0.9), ">=", 4) > status [1] TRUEindicates that the operation was successful. Invisible values can also be used in flow control.
To free up resources and memory, the R command rm() must be used.
For example:
> rm(lprec)
See also Using lpsolve from MATLAB, Using lpsolve from O-Matrix, Using lpsolve from Octave, Using lpsolve from Python, Using lpsolve from Scilab
docs/5.5/is_presolve.htm 0000644 0001750 0001750 00000016421 11306036626 014034 0 ustar rene rene
is_presolveReturns if presolve level specified in testmask is active. unsigned char is_presolve(lprec *lp, int testmask); Return Value is_presolve returns TRUE or FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI testmask
Remarks The is_presolve function returns a flag if the presolve level specified
in testmask is active. Presolve looks at the model and tries to simplify
it so that solving times are shorter. For example a constraint on only one
variable is converted to a bound on this variable (and the constraint is
deleted). Note that the model dimensions can change because of this, so be
careful with this. Both rows and columns can be deleted by the presolve. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_presolve, get_presolve, get_presolveloops |
set_negrangeSet negative value below which variables are split into a negative and a positive part. void set_negrange(lprec *lp, REAL negrange); Return Value set_negrange has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI negrange The negative value below which variables are split into a negative and a positive part. RemarksThe set_negrange function specifies the negative value below which
variables are split into a negative and a positive part. This value must always
be zero or negative. If a positive value is specified, then 0 is taken. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_negrange |
set_epsperturbSpecifies the value that is used as perturbation scalar for degenerative problems. void set_epsperturb(lprec *lp, REAL epsperturb); Return Value set_epsperturb has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI epsperturb perturbation scalar. Remarks The default epsperturb value is 1e-5 Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_epsperturb, set_infinite, get_infinite, is_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_mip_gap, get_mip_gap |
set_basisSets an initial basis of the lp. unsigned char set_basis(lprec *lp, int *bascolumn, unsigned char nonbasic); Return Value set_basis returns TRUE if provided basis was set. FALSE if not. If FALSE then provided data was invalid. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI bascolumn An array with 1+get_Nrows or 1+get_Nrows+get_Ncolumns elements that specifies the basis. nonbasic If FALSE, then bascolumn must have 1+get_Nrows elements and only contains the basic variables. If TRUE, then bascolumn must have 1+get_Nrows+get_Ncolumns elements and will also contain the non-basic variables. Remarks
The set_basis function sets an initial basis of the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_basis, default_basis, read_basis, write_basis, guess_basis, get_basiscrash, set_basiscrash |
read_paramsRead settings from a parameter file. unsigned char read_params(lprec *lp, char *filename, char *options); Return Value Returns TRUE (1) if parameters could be read, else FALSE (0). Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI filename Filename to read the parameters from. options Optional options. Can be: Remarks lp_solve parameters (options) are read from a parameter file. This file has an ini-format as used by Windows applications. All parameters are read from a header. This is by default [Default]. The header can be specified in the options parameter. Other headers are ignored. Example parameter file: [Default] ; lp_solve version 5.5 settings anti_degen=ANTIDEGEN_FIXEDVARS + ANTIDEGEN_STALLING + ANTIDEGEN_INFEASIBLE basiscrash=CRASH_NONE improve=IMPROVE_DUALFEAS + IMPROVE_THETAGAP maxpivot=250 negrange=-1e+006 pivoting=PRICER_DEVEX + PRICE_ADAPTIVE presolve=PRESOLVE_NONE presolveloops=2147483647 scalelimit=5 scaling=SCALE_GEOMETRIC + SCALE_EQUILIBRATE + SCALE_INTEGERS simplextype=SIMPLEX_DUAL_PRIMAL bb_depthlimit=-50 bb_floorfirst=BRANCH_AUTOMATIC bb_rule=NODE_PSEUDONONINTSELECT + NODE_GREEDYMODE + NODE_DYNAMICMODE + NODE_RCOSTFIXING ;break_at_first=0 ;break_at_value=-1e+030 mip_gap_abs=1e-011 mip_gap_rel=1e-011 epsint=1e-007 epsb=1e-010 epsd=1e-009 epsel=1e-012 epsperturb=1e-005 epspivot=2e-007 infinite=1e+030 ;debug=0 ;obj_bound=1e+030 ;print_sol=0 ;timeout=0 ;trace=0 ;verbose=NORMAL Note that there are some options commented out (;). This is done because these options can not be used in general for all models or because they are debug/trace/print options. These options can be made active and will be read by read_params but note again that they are possible dangerous to be used in general (except for the debug/trace/print options). Note that there are two kind of entries:
Numercial values can be integer values like maxpivot or floating point values like epsel Options are a combination of constants as defined in the manual. Multiple options are added with +. For example option anti_degen. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, write_params, reset_params |
ZimplZimpl is a language to translate the mathematical model of a problem into a linear or (mixed-) integer mathematical program expressed in .lp or .mps file format which can be read and (hopefully) solved by a LP or MIP solver. See http://www.zib.de/koch/zimpl/ for the home page of this tool and examples. On the above page, a command line tool is provided to read a model written in the Zimpl language and it creates a CPLEX lp file.
lp_solve is able to read this generated CPLEX lp file via the xli_CPLEX XLI driver, but that would require an extra step. lp_solve -rxli xli_Zimpl chvatal_diet.zpl This gives as result: Value of objective function: 97 Actual values of the variables: x$Oatmeal 4 x$Chicken 0 x$Eggs 0 x$Milk 5 x$Pie 2 x$Pork 0 OptionsThe XLI accepts several options:
-b Enable Bison (Lex parser) debugging output.
-D name=value Sets the parameter name to the specified value.
This is equivalent with having this line in the ZIMPL program: param name:=val.
-f enable flex debugging output.
-n cm|cn|cf name column make/name/full
-O Try to reduce the generated LP by doing some presolve analysis.
-s seed Positive seed number for the random number generator.
-v[0-5] Set the verbosity level. 0 is quiet, 1 is default, 2 is verbose, 3 and 4 are chatter, and 5 is debug.
-V show version info
These options are the same as the stand-alone zimpl program. The lp_solve command line program can provide these parameters via the -rxliopt argument. lp_solve -rxli xli_Zimpl chvatal_diet.zpl -rxliopt "-v0 -O" Generating ZIMPL modelsThe XLI can also create a ZIMPL model, however it doesn't use the strength of the language. Constraints are written out line per line. But it can be a starter. For example: lp_solve model.lp -wxli xli_Zimpl model.zpl This gives as model.zpl: # Variable definitions var x >= 0; var y >= 0; # Objective function maximize obj: +143*x +60*y; # Constraints subto R1: +120*x +210*y <= 15000; subto R2: +110*x +30*y <= 4000; subto R3: +x +y <= 75; APIUse the lpsolve API call read_XLI to read a model and write_XLI to write a model. See also External Language Interfaces. IDEAlso from within the IDE, this XLI can be used. However, some entries must be added in LpSolveIDE.ini (in the folder where the IDE is installed). In the [XLI] section the following must be added: lib5=xli_ZIMPL And a new section for the ZIMPL XLI must also be added: [xli_ZIMPL] extension=.zpl language=ZIMPL Then make sure that the xli_ZIMPL.dll is available for the IDE. This must be done by placing this dll in the IDE folder or in the Windows system32 folder. Example modelschvatal_diet.zpl
# $Id: chvatal_diet.zpl,v 1.2 2003/10/02 08:20:12 bzfkocht Exp $
#
# From V. Chvatal: Linear Programming
# Chapter 1, Page 3ff.
#
# A diet problem
#
set Food := { "Oatmeal", "Chicken", "Eggs", "Milk", "Pie", "Pork" };
set Nutrients := { "Energy", "Protein", "Calcium" };
set Attr := Nutrients + {"Servings", "Price"};
param needed[Nutrients] := <"Energy"> 2000, <"Protein"> 55, <"Calcium"> 800;
param data[Food * Attr] :=
| "Servings", "Energy", "Protein", "Calcium", "Price" |
|"Oatmeal" | 4 , 110 , 4 , 2 , 3 |
|"Chicken" | 3 , 205 , 32 , 12 , 24 |
|"Eggs" | 2 , 160 , 13 , 54 , 13 |
|"Milk" | 8 , 160 , 8 , 284 , 9 |
|"Pie" | 2 , 420 , 4 , 22 , 20 |
|"Pork" | 2 , 260 , 14 , 80 , 19 |;
# (kcal) (g) (mg) (cents)
var x[<f> in Food] integer >= 0 <= data[f, "Servings"];
minimize cost: sum <f> in Food : data[f, "Price"] * x[f];
subto need :
forall <n> in Nutrients do
sum <f> in Food : data[f, n] * x[f] >= needed[n];
model.lp/* model.lp */ max: 143 x + 60 y; 120 x + 210 y <= 15000; 110 x + 30 y <= 4000; x + y <= 75; |
read_lp, read_LPCreate an lprec structure and read an lp model from file. lprec *read_lp(FILE *stream, int verbose, char *lp_name); lprec *read_LP(char *filename, int verbose, char *lp_name); Return Value
Returns a pointer to a new lprec structure. This must be provided to almost all
lp_solve functions. Parameters stream Pointer to FILE structure. filename Filename to read the lp model from. verbose The verbose level. Can be one of the following values: See also set_verbose and get_verbose. lp_name Initial name of the model. See also set_lp_name and get_lp_name. May be NULL if the model has no name. Remarks The read_lp and read_LP functions construct a new lprec structure and read the model from filename. read_lp needs a file pointer to an already opened file. read_LP accepts the name of the file. The latter function will generally be more convenient.
The model in the file must be in lp-format.
Example See Also delete_lp, free_lp, make_lp, copy_lp, write_lp, write_LP, write_lpex, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileex |
set_basiscrashDetermines a starting base. void set_basiscrash(lprec *lp, int mode); Return Value None Parameters Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI mode Specifies which basis crash mode is used. Can by any of the following values:
Remarks The set_basiscrash function specifies which basis crash mode must be used. Default is CRASH_NONE. When no base crash is done (the default), the initial basis from which lp_solve starts to solve the model is the basis containing all slack or artificial variables that is automatically associates with each constraint. When base crash is enabled, a heuristic ``crash procedure'' is executed before the first simplex iteration to quickly choose a basis matrix that has fewer artificial variables. This procedure tends to reduce the number of iterations to optimality since a number of iterations are skipped. lp_solve starts iterating from this basis until optimality. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_basiscrash, default_basis, read_basis, write_basis, guess_basis, get_basis, set_basis |
is_nativeBFPReturns if the native (build-in) basis factorization package (BFP) is used, or an external package. unsigned char is_nativeBFP(lprec *lp); Return Value is_nativeBFP returns TRUE if the native (build-in) BFP is used, else FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The is_nativeBFP function checks if an external BFP is set or not. See Basis Factorization Packages for a complete description on BFPs. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, has_BFP, set_BFP |
get_matGet a single element from the matrix. REAL get_mat(lprec *lp, int row, int column); Return Value
get_mat returns the value of the element on row row, column column.
If no value was set for this element, the function returns 0. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row Row number of the matrix. Must be between 0 and number of rows in the lp. Row 0 is objective function. column Column number of the matrix. Must be between 1 and number of columns in the lp. Remarks
This function is not efficient if many values are to be retrieved. Consider to use
get_row, get_rowex, get_column, get_columnex. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_row, get_rowex, get_column, get_columnex, set_column, set_columnex, set_mat, set_row, set_rowex |
get_NrowsReturns the number of rows (constraints) in the lp. int get_Nrows(lprec *lp); Return Value get_Nrows returns the number of rows (constraints) in the lp. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_Nrows function returns the number of rows (constraints) in the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_Norig_rows, get_Lrows, get_Ncolumns, get_Norig_columns, get_orig_index, get_lp_index |
lp_solve Frequently Asked Questions
- Where can I find the latest version of lp_solve?
- Can I use lp_solve in commercial code?
- Please explain what this LGPL license exactly means. I don't understand it.
lp_solve used
as compiled
library?
Yes No
-----------
lp_solve Yes | B1 | B2 |
code was |-----|-----|
modified? No | A | B3 |
-----------
A: "Work that uses the library" - But how much does lp_solve costs me? lp_solve is totally free - gratis - if you follow the rules of the LGPL. You may of course ask money for code you have developed or added, but only for that part, and the openness provisions of the LGPL have to be respected. If you are not willing to respect this, then the only recourse is that you seek an agreement with the copyright holders of the appropriate parts of lp_solve. - How should lp_solve be cited when I use it?
lpsolve citation data
----------------------
Description : Open source (Mixed-Integer) Linear Programming system
Language : Multi-platform, pure ANSI C / POSIX source code, Lex/Yacc based parsing
Official name : lp_solve (alternatively lpsolve)
Release data : Version 5.1.0.0 dated 1 May 2004
Co-developers : Michel Berkelaar, Kjell Eikland, Peter Notebaert
Licence terms : GNU LGPL (Lesser General Public Licence)
Citation policy : General references as per LGPL
Module specific references as specified therein
This text is also in citations.txt
- What are the default bounds on variables?
- Is it possible to set negative bounds on variables?
- Is it possible to set a minus infinite lower bound on a variable?
- What is the layout of the lp/mps/CPLEX format?
- When I call the API call solve(), several messages are printed on screen. How can I
disable those messages?
- lp_solve fails to solve my model or it takes a very long time to solve my model.
What can I do?
- Can lp_solve handle non-linear equations?
- Can lp_solve handle ratios? Have you entered your model via Word? Then the problem will probably be that some characters have ascii codes that are not recognised by lp_solve. For example, Word changes the minus sign (-) to another character that also looks like a minus sign, but it is a bit longer. The ascii code of this character is different from the ascii code of the real minus sign and lp_solve has problem with it. However you see a - on screen. The solution is not to use Word to enter your lp-model. Notepad should be ok. Better is to use the LPSolve IDE.
- lp_solve prints the output on screen. Can I have the output also in a file?
- I have a constraint saying that x < 2, but lp_solve comes with a solution of 2, how comes?
- When I solve my model, I get a stack overflow error/core dump/protection error. What is wrong?
- Version 4 solves my models slower than version 3 did. What can I do?
- It takes a long time to build the model via the API interface. Especially
add_constraint, add_constraintex, str_add_constraint
seems to be slow. How can it be made faster?
- Can lp_solve give me the 'simplex tableau' of the model?
- Is there documentation about the API interface?
- What is the maximum number of rows/columns that lp_solve can handle?
- I use a programming language that is not listed as supported or for which there
are no examples. Can lp_solve be called from this language?
- The Windows examples don't work. I get an error running them. Some dll cannot be
found.
- Does lp_solve supports the mps free format?
- Does the lp_solve lp format support comments?
- I want to compile lp_solve myself, but I get link errors. Also what should I
do with lp.y, lex.l, lp_rlp.y, lp_rlp.l?
- I compile lp_solve myself, but I get link errors saying that main (or _main)
is already defined.
- I want to use the lpsolve dll, but when I compile my C/C++ program, I get link
errors. He doesn't find any of the lpsolve API routines. What am I doing wrong?
- lp.c and lex.c that are generated on my system are different from the
versions that can be found in the support folder in the files section. Are the
latest versions of these files on your site?
- When I start the lp_solve program, nothing
happens. I just get a blinking cursor. If I enter a command like lp1 = make_lp(0,4),
I get a parse error. What is wrong here? How do I use the program?
ROWS
N r_0
L C1
L r_2
COLUMNS
MARK0000 'MARKER' 'INTORG'
x1 r_0 1 C1 2
x1 r_2 -4
x2 r_0 -2 C1 1
x2 r_2 4
MARK0001 'MARKER' 'INTEND'
RHS
RHS C1 5 r_2 5
ENDATA
To enable this input format in the lp_solve program, use the -mps option.
- Is there no more user-friendly interface than the lp_solve command line program? |
lag_solveSolve the model via Lagrangian relaxation. The Lagrangian solver does not work. Do not use this call. int lag_solve(lprec *lp, REAL start_bound, int num_iter, short verbose); Return Value
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI start_bound Initial bound. num_iter Maximum number of iterations. verbose Not used. Still included for backwards compatibility. Use set_lag_trace to set the verbose level. Remarks The Lagrangian solver does not work. Do not use this call.
The lag_solve function solves the model via Lagrangian relaxation. Gives
the ability to find an integer solution without the branch-and-bound algorithm. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, solve, get_statustext, is_feasible, get_objective, get_working_objective, get_variables, get_ptr_variables, get_constraints, get_ptr_constraints, get_constr_value, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex, add_lag_con, get_Lrows |
set_maximSet objective function to maximize. void set_maxim(lprec *lp); Return Value set_maxim has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The set_maxim function sets the objective direction to maximize. The default of lp_solve is to minimize, except for read_lp, read_LP where the default is to maximize. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_maxim, set_minim, set_sense |
set_timeoutSet a timeout. void set_timeout(lprec *lp, long sectimeout); Return Value set_timeout has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI sectimeout The number of seconds after which a timeout occurs. If zero, then no timeout will occur. Remarks The set_timeout function sets a timeout in seconds. The solve
and lag_solve functions may not last longer than
this time or the routines return with a timeout. The default timeout is 0, resulting in no timeout. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_timeout, time_elapsed, solve, lag_solve |
DownloadAll needed files can be downloaded from sourceforge on the following location: https://sourceforge.net/project/showfiles.php?group_id=145213&package_id=159735 |
get_timeoutGets the timeout. long get_timeout(lprec *lp); Return Value get_timeout returns the number of seconds after which a timeout occurs. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_timeout function returns a timeout in seconds. The solve and lag_solve functions may not last longer than this time or the routines return with a timeout. There is no valid solution at this time. The default timeout is 0, resulting in no timeout. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_timeout, time_elapsed, solve, lag_solve |
put_bb_branchfuncSpecifies a user function to select a B&B branching, given the column to branch on. void put_bb_branchfunc(lprec *lp, lphandleint_intfunc newbranch, void *bb_branchhandle); Return Value put_bb_branchfunc has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI newbranch The branch routine. bb_branchhandle A parameter that will be provided to the branch routine. Remarks Specifies a user function to select a B&B branching, given the column to branch on. With this function you can specify which branch must be taken first in the B&B algorithm. The floor or the ceiling. This overrules the setting of set_bb_floorfirst. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_bb_floorfirst, get_bb_floorfirst, set_var_branch, get_var_branch, set_var_weights, get_var_priority |
GNU Octave is a high-level language, primarily intended for numerical computations. It provides a convenient command line interface for solving linear and non-linear problems numerically, and for performing other numerical experiments. It may also be used as a batch-oriented language.
GNU Octave is also freely redistributable software.
We will not discuss the specifics of Octave here but instead refer the reader to the Octave website and GNU Octave Repository.
lpsolve is callable from Octave via a dynamic linked function. As such, it looks like lpsolve is fully integrated with Octave. Matrices can directly be transferred between Octave and lpsolve in both directions. The complete interface is written in C so it has maximum performance. The whole lpsolve API is implemented with some extra's specific for Octave (especially for matrix support). So you have full control to the complete lpsolve functionality via the octlpsolve Octave driver. If you find that this involves too much work to solve an lp model then you can also work via higher-level script files that can make things a lot easier. See further in this article.
Note that your version of Octave must support dynamic linking. To find out if it does, type the command:
octave_config_info ("ENABLE_DYNAMIC_LINKING")
at the Octave prompt. Support for dynamic linking is included if this expression returns the string "true".
If this is not the case, then Octave is not able to call dynamic linked routines and as such also not lpsolve. In that case you must recompile Octave with dynamic linked routines enabled. Under Linux, the following commands must be executed for this:
configure --enable-shared make
See Installing Octave for more information.
Under Windows, dynamic linking should already be active. If not, then Octave must be recompiled. The following document can help in this process: README.Windows
The octave dynamic linked routine is in a file with extension .oct. It is impossible to provide a precompiled octlpsolve.oct file with the lpsolve distribution because the structure of the .oct files change often on new releases of Octave and are not compatible with each other. Therefore you must build the driver yourself. Look at the end of this document how to do this.
A driver program is needed: octlpsolve (octlpsolve.oct). This driver must be put in a directory known to Octave (in one of the directories from the Octave 'path' command) and Octave can call the octlpsolve solver.
This driver calls lpsolve via the lpsolve shared library (lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux) (in archives lp_solve_5.5.0.13_dev.zip/lp_solve_5.5.0.13_dev.tar.gz). This has the advantage that the octlpsolve driver doesn't have to be recompiled when an update of lpsolve is provided.
So note the difference between the Octave lpsolve driver that is called octlpsolve and the lpsolve library that implements the API that is called lpsolve55.
There are also some Octave script files (.m) as a quick start.
To test if everything is installed correctly, enter octlpsolve in the Octave command window. If it gives the following, then everything is ok:
octlpsolve Octave Interface version 5.5.0.5
using lpsolve version 5.5.0.13
Usage: [ret1, ret2, ...] = octlpsolve('functionname', arg1, arg2, ...)
However, if you get the following:
error: 'octlpsolve' undefined near line 2 column 1
Then Octave cannot find octlpsolve.oct
If you get the following:
error: Failed to initialise lpsolve library.
Then Octave can find the octlpsolve driver program, but the driver program cannot find the lpsolve library that contains the lpsolve implementation. This library is called lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux. Under Windows, the dll should be in a directory specified by the PATH environment variables and under Unix/Linux in directory /lib, /usr/lib or a directory defined by LD_LIBRARY_PATH.
In the following text, octave:> before the Octave commands is the Octave prompt. Only the text after octave:> must be entered. Note that the default prompt also contains an incrementing number starting from one each time Octave starts. For this documentation, the default Octave was changed with the following command: PS1 = "\\s:> "
To call an lpsolve function, the following syntax must be used:
octave:> [ret1, ret2, ...] = octlpsolve('functionname', arg1, arg2, ...)
The return values are optional and depend on the function called. functionname must always be enclosed between single or double quotes to make it alphanumerical and it is case sensitive. The number and type of arguments depend on the function called. Some functions even have a variable number of arguments and a different behaviour occurs depending on the type of the argument. functionname can be (almost) any of the lpsolve API routines (see lp_solve API reference) plus some extra Octave specific functions. Most of the lpsolve API routines use or return an lprec structure. To make things more robust in Octave, this structure is replaced by a handle or the model name. The lprec structures are maintained internally by the lpsolve driver. The handle is an incrementing number starting from 0. Starting from driver version 5.5.0.2, it is also possible to use the model name instead of the handle. This can of course only be done if a name is given to the model. This is done via lpsolve routine set_lp_name or by specifying the model name in routine read_lp. See Using model name instead of handle.
Almost all callable functions can be found in the lp_solve API reference. Some are exactly as described in the reference guide, others have a slightly different syntax to make maximum use of the Octave functionality. For example make_lp is used identical as described. But get_variables is slightly different. In the API reference, this function has two arguments. The first the lp handle and the second the resulting variables and this array must already be dimensioned. When lpsolve is used from Octave, nothing must be dimensioned in advance. The octlpsolve driver takes care of dimensioning all return variables and they are always returned as return value of the call to octlpsolve. Never as argument to the routine. This can be a single value as for get_objective (although Octave stores this in a 1x1 matrix) or a matrix or vector as in get_variables. In this case, get_variables returns a 4x1 matrix (vector) with the result of the 4 variables of the lp model.
Note that you can get an overview of the available functionnames and their arguments by entering the following in Octave:
>> help octlpsolve.m
(Note that you can execute this example by entering command per command as shown below or by just entering example1. This will execute example1.m. You can see its contents by entering type example1.m)
octave:> lp=octlpsolve('make_lp', 0, 4);
octave:> octlpsolve('set_verbose', lp, 3);
octave:> octlpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1]);
octave:> octlpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], 2, 92.3);
octave:> octlpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
octave:> octlpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], 2, 4);
octave:> octlpsolve('set_lowbo', lp, 1, 28.6);
octave:> octlpsolve('set_lowbo', lp, 4, 18);
octave:> octlpsolve('set_upbo', lp, 4, 48.98);
octave:> octlpsolve('set_col_name', lp, 1, 'COLONE');
octave:> octlpsolve('set_col_name', lp, 2, 'COLTWO');
octave:> octlpsolve('set_col_name', lp, 3, 'COLTHREE');
octave:> octlpsolve('set_col_name', lp, 4, 'COLFOUR');
octave:> octlpsolve('set_row_name', lp, 1, 'THISROW');
octave:> octlpsolve('set_row_name', lp, 2, 'THATROW');
octave:> octlpsolve('set_row_name', lp, 3, 'LASTROW');
octave:> octlpsolve('write_lp', lp, 'a.lp');
octave:> octlpsolve('get_mat', lp, 1, 2)
ans = 78.260
octave:> octlpsolve('solve', lp)
ans = 0
octave:> octlpsolve('get_objective', lp)
ans = 31.783
octave:> octlpsolve('get_variables', lp)
ans =
28.60000
0.00000
0.00000
31.82759
octave:> octlpsolve('get_constraints', lp)
ans =
92.3000
6.8640
391.2928
Note that there are some commands that return an answer. To see the answer, the command was not terminated with a semicolon (;). If the semicolon is put at the end of a command, the answer is not shown. However it is also possible to write the answer in a variable. For example:
octave:> obj=octlpsolve('get_objective', lp)
obj = 31.783
Or without echoing on screen:
octave:> obj=octlpsolve('get_objective', lp);
The last command will only write the result in variable obj without showing anything on screen. get_variables and get_constraints return a vector with the result. This can also be put in a variable:
octave:> x=octlpsolve('get_variables', lp);
octave:> b=octlpsolve('get_constraints', lp);
It is always possible to show the contents of a variable by just giving it as command:
octave:> x x = 28.60000 0.00000 0.00000 31.82759
Don't forget to free the handle and its associated memory when you are done:
octave:> octlpsolve('delete_lp', lp);
octave:> lp=octlpsolve('make_lp', 0, 4);
octave:> octlpsolve('set_lp_name', lp, 'mymodel');
octave:> octlpsolve('set_verbose', 'mymodel', 3);
octave:> octlpsolve('set_obj_fn', 'mymodel', [1, 3, 6.24, 0.1]);
octave:> octlpsolve('add_constraint', 'mymodel', [0, 78.26, 0, 2.9], 2, 92.3);
octave:> octlpsolve('add_constraint', 'mymodel', [0.24, 0, 11.31, 0], 1, 14.8);
octave:> octlpsolve('add_constraint', 'mymodel', [12.68, 0, 0.08, 0.9], 2, 4);
octave:> octlpsolve('set_lowbo', 'mymodel', 1, 28.6);
octave:> octlpsolve('set_lowbo', 'mymodel', 4, 18);
octave:> octlpsolve('set_upbo', 'mymodel', 4, 48.98);
octave:> octlpsolve('set_col_name', 'mymodel', 1, 'COLONE');
octave:> octlpsolve('set_col_name', 'mymodel', 2, 'COLTWO');
octave:> octlpsolve('set_col_name', 'mymodel', 3, 'COLTHREE');
octave:> octlpsolve('set_col_name', 'mymodel', 4, 'COLFOUR');
octave:> octlpsolve('set_row_name', 'mymodel', 1, 'THISROW');
octave:> octlpsolve('set_row_name', 'mymodel', 2, 'THATROW');
octave:> octlpsolve('set_row_name', 'mymodel', 3, 'LASTROW');
octave:> octlpsolve('write_lp', 'mymodel', 'a.lp');
octave:> octlpsolve('get_mat', 'mymodel', 1, 2)
ans = 78.260
octave:> octlpsolve('solve', 'mymodel')
ans = 0
octave:> octlpsolve('get_objective', 'mymodel')
ans = 31.783
octave:> octlpsolve('get_variables', 'mymodel')
ans =
28.60000
0.00000
0.00000
31.82759
octave:> octlpsolve('get_constraints', 'mymodel')
ans =
92.3000
6.8640
391.2928
So everywhere a handle is needed, you can also use the model name. You can even mix the two methods.
There is also a specific Octave routine to get the handle from the model name: get_handle.
For example:
>> octlpsolve('get_handle', 'mymodel')
0
Don't forget to free the handle and its associated memory when you are done:
octave:> octlpsolve('delete_lp', 'mymodel');
In the next part of this documentation, the handle is used. But if you name the model, the name could thus also be used.
octave:> octlpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
Most of the time, variables are used to provide the data:
octave:> octlpsolve('add_constraint', lp, a1, 1, 14.8);
Where a1 is a matrix variable.
Most of the time, octlpsolve needs vectors (rows or columns). In all situations, it doesn't matter if the vectors are row or column vectors. The driver accepts them both. For example:
octave:> octlpsolve('add_constraint', lp, [0.24; 0; 11.31; 0], 1, 14.8);
Which is a column vector, but it is also accepted.
An important final note. Several lp_solve API routines accept a vector where the first element (element 0) is not used. Other lp_solve API calls do use the first element. In the Octave interface, there is never an unused element in the matrices. So if the lp_solve API specifies that the first element is not used, then this element is not in the Octave matrix.
All numerical data is stored in matrices. Alphanumerical data, however, is more difficult to store in matrices. Matrices require that each element has the same size (length) and that is difficult and unpractical for alphanumerical data. In a limited number of lpsolve routines, alphanumerical data is required or returned and in some also multiple elements. An example is set_col_name. For this, Octave sets are used. To specify a set of alphanumerical elements, the following notation is used: { 'element1', 'element2', ... }. Note the { and } symbols instead of [ and ] that are used with matrices.
Because Octave is all about matrices, all lpsolve API routines that need a column or row number to get/set information for that
column/row are extended in the octlpsolve Octave driver to also work with matrices. For example set_int in the API can
only set the integer status for one column. If the status for several integer variables must be set, then set_int
must be called multiple times. The octlpsolve Octave driver however also allows specifying a vector to set the integer
status of all variables at once. The API call is: return = octlpsolve('set_int', lp, column, must_be_int). The
matrix version of this call is: return = octlpsolve('set_int', lp, [must_be_int]).
The API call to return the integer status of a variable is: return = octlpsolve('is_int', lp, column). The
matrix version of this call is: [is_int] = octlpsolve('is_int', lp)
Also note the get_mat and set_mat routines. In Octave these are extended to return/set the complete constraint matrix.
See following example.
Above example can thus also be done as follows:
(Note that you can execute this example by entering command per command as shown below or by just entering example2.
This will execute example2.m. You can see its contents by entering type example2.m)
octave:> lp=octlpsolve('make_lp', 0, 4);
octave:> octlpsolve('set_verbose', lp, 3);
octave:> octlpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1]);
octave:> octlpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], 2, 92.3);
octave:> octlpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
octave:> octlpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], 2, 4);
octave:> octlpsolve('set_lowbo', lp, [28.6, 0, 0, 18]);
octave:> octlpsolve('set_upbo', lp, [Inf, Inf, Inf, 48.98]);
octave:> octlpsolve('set_col_name', lp, {'COLONE', 'COLTWO', 'COLTHREE', 'COLFOUR'});
octave:> octlpsolve('set_row_name', lp, {'THISROW', 'THATROW', 'LASTROW'});
octave:> octlpsolve('write_lp', lp, 'a.lp');
octave:> octlpsolve('get_mat', lp)
ans =
0.00000 78.26000 0.00000 2.90000
0.24000 0.00000 11.31000 0.00000
12.68000 0.00000 0.08000 0.90000
octave:> octlpsolve('solve', lp)
ans = 0
octave:> octlpsolve('get_objective', lp)
ans = 31.783
octave:> octlpsolve('get_variables', lp)
ans =
28.60000
0.00000
0.00000
31.82759
octave:> octlpsolve('get_constraints', lp)
ans =
92.3000
6.8640
391.2928
Note the usage of Inf in set_upbo. This stands for 'infinity'. Meaning an infinite upper bound. It is also possible to use -Inf to express minus infinity. This can for example be used to create a free variable.
To show the full power of the matrices, let's now do some matrix calculations to check the solution. It works further on above example:
octave:> A=octlpsolve('get_mat', lp);
octave:> X=octlpsolve('get_variables', lp);
octave:> B = A * X
B =
92.3000
6.8640
391.2928
So what we have done here is calculate the values of the constraints (RHS) by multiplying the constraint matrix with the solution vector. Now take a look at the values of the constraints that lpsolve has found:
octave:> octlpsolve('get_constraints', lp)
ans =
92.3000
6.8640
391.2928
Exactly the same as the calculated B vector, as expected.
Also the value of the objective can be calculated in a same way:
octave:> C=octlpsolve('get_obj_fn', lp);
octave:> X=octlpsolve('get_variables', lp);
octave:> obj = C * X
obj = 31.783
So what we have done here is calculate the value of the objective by multiplying the objective vector with the solution vector. Now take a look at the value of the objective that lpsolve has found:
octave:> octlpsolve('get_objective', lp)
ans = 31.783
Again exactly the same as the calculated obj value, as expected.
Octave can execute a sequence of statements stored in diskfiles. Script files mostly have the file type of ".m" as the last part of their filename (extension). Much of your work with Octave will be in creating and refining script files. Script files are usually created using your local editor.
Script files can be compared with batch files or scripts. You can put Octave commands in them and execute them at any time. The script file is executed like any other command, by entering its name (without the .m extension).
The octlpsolve Octave distribution contains some example script files to demonstrate this.
To see the contents of such a file, enter the command 'type filename'. You can also edit these files with your favourite text editor (or notepad).
Contains the commands as shown in the first example of this article.
Contains the commands as shown in the second example of this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
This script uses the API to create a higher-level function called lp_solve. This function accepts as arguments some matrices and options to create and solve an lp model. See the beginning of the file or type help lp_solve or just lp_solve to see its usage:
LP_SOLVE Solves mixed integer linear programming problems.
SYNOPSIS: [obj,x,duals] = lp_solve(f,a,b,e,vlb,vub,xint,scalemode,keep)
solves the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) = -1 ==> Less Than
e(i) = 0 ==> Equals
e(i) = 1 ==> Greater Than
vlb: n vector of lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
keep: Flag for keeping the lp problem after it's been solved.
If omitted, the lp will be deleted when solved.
OUTPUT: A nonempty output is returned if a solution is found:
obj: Optimal value of the objective function.
x: Optimal value of the decision variables.
duals: solution of the dual problem.
Example of usage. To create and solve following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
octave:> [obj, x]=lp_solve([-1, 2], [2, 1; -4, 4], [5, 5], [-1, -1], [], [], [1, 2]) obj = 3 x = 1 2
This script is analog to the lp_solve script and also uses the API to create a higher-level function called lp_maker. This function accepts as arguments some matrices and options to create an lp model. Note that this scripts only creates a model and returns a handle. See the beginning of the file or type help lp_maker or just lp_maker to see its usage:
octave:> help lp_maker
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
x >= vlb >= 0
x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Example of usage. To create following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
octave:> lp=lp_maker([-1, 2], [2, 1; -4, 4], [5, 5], [-1, -1], [], [], [1, 2]) lp = 0
To solve the model and get the solution:
octave:> octlpsolve('solve', lp)
ans = 0
octave:> octlpsolve('get_objective', lp)
ans = 3
octave:> octlpsolve('get_variables', lp)
ans =
1
2
Don't forget to free the handle and its associated memory when you are done:
octave:> octlpsolve('delete_lp', lp);
Contains several examples to build and solve lp models.
Contains several examples to build and solve lp models. Also solves the lp_examples from the lp_solve distribution.
We shall illustrate the method of linear programming by means of a simple example, giving a combination graphical/numerical solution, and then solve both a slightly as well as a substantially more complicated problem.
Suppose a farmer has 75 acres on which to plant two crops: wheat and barley. To produce these crops, it costs the farmer (for seed, fertilizer, etc.) $120 per acre for the wheat and $210 per acre for the barley. The farmer has $15000 available for expenses. But after the harvest, the farmer must store the crops while awaiting favourable market conditions. The farmer has storage space for 4000 bushels. Each acre yields an average of 110 bushels of wheat or 30 bushels of barley. If the net profit per bushel of wheat (after all expenses have been subtracted) is $1.30 and for barley is $2.00, how should the farmer plant the 75 acres to maximize profit?
We begin by formulating the problem mathematically. First we express the objective, that is the profit, and the constraints algebraically, then we graph them, and lastly we arrive at the solution by graphical inspection and a minor arithmetic calculation.
Let x denote the number of acres allotted to wheat and y the number of acres allotted to barley. Then the expression to be maximized, that is the profit, is clearly
P = (110)(1.30)x + (30)(2.00)y = 143x + 60y.
There are three constraint inequalities, specified by the limits on expenses, storage and acreage. They are respectively:
120x + 210y <= 15000
110x + 30y <= 4000
x + y <= 75
Strictly speaking there are two more constraint inequalities forced by the fact that the farmer cannot plant a negative number of acres, namely:
x >= 0, y >= 0.
Next we graph the regions specified by the constraints. The last two say that we only need to consider the first quadrant in the x-y plane. Here's a graph delineating the triangular region in the first quadrant determined by the first inequality.
octave:> X = 0.1:0.1:125; octave:> Y1 = (15000 - 120.*X)./210; octave:> bar(X, Y1);
Now let's put in the other two constraint inequalities.
octave:> X = 0.1:0.05:40; octave:> Y1 = (15000. - 120*X)/210; octave:> Y2 = max((4000 - 110.*X)./30, 0); octave:> Y3 = max(75 - X, 0); octave:> Ytop = min([Y1; Y2; Y3]); octave:> bar(X, Ytop);
The red area is the solution space that holds valid solutions. This means that any point in this area fulfils the constraints.
Now let's superimpose on top of this picture the objective function P.
octave:> hold on
octave:> X=15:25:40;
octave:> title('Solution space and objective')
octave:> plot(X,(6315.63-143.0*X)/60.0);
octave:> hold off
The line gives a picture of the objective function. All solutions that intersect with the red area are valid solutions, meaning that this result also fulfils the set constraints. The more the line goes to the right, the higher the objective value is. The optimal solution or best objective is a line that is still in the red area, but with an as large as possible value.
It seems apparent that the maximum value of P will occur on the level curve (that is, level
line) that passes through the vertex of the polygon that lies near (22,53).
It is the intersection of x + y = 75 and 110*x + 30*y = 4000
This is a corner point of the diagram. This is not a coincidence. The simplex algorithm, which is used
by lp_solve, starts from a theorem that the optimal solution is such a corner point.
In fact we can compute the result:
octave:> x = [1 1; 110 30] \ [75; 4000] x = 21.875 53.125
The acreage that results in the maximum profit is 21.875 for wheat and 53.125 for barley. In that case the profit is:
octave:> P = [143 60] * x P = 6315.6
That is, $6315.6.
Note that these command are in script example3.m
Now, lp_solve comes into the picture to solve this linear programming problem more generally. After that we will use it to solve two more complicated problems involving more variables and constraints.
For this example, we use the higher-level script lp_maker to build the model and then some lp_solve API calls to retrieve the solution. Here is again the usage of lp_maker:
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
x >= vlb >= 0
x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Now let's formulate this model with lp_solve:
octave:> f = [143 60];
octave:> A = [120 210; 110 30; 1 1];
octave:> b = [15000; 4000; 75];
octave:> lp = lp_maker(f, A, b, [-1; -1; -1], [], [], [], 1, 0);
octave:> solvestat = octlpsolve('solve', lp)
solvestat = 0
octave:> obj = octlpsolve('get_objective', lp)
obj = 6315.6
octave:> x = octlpsolve('get_variables', lp)
x =
21.875
53.125
octave:> octlpsolve('delete_lp', lp);
Note that these command are in script example4.m
With the higher-level script lp_maker, we provide all data to lp_solve. lp_solve returns a handle (lp) to the created model. Then the API call 'solve' is used to calculate the optimal solution of the model. The value of the objective function is retrieved via the API call 'get_objective' and the values of the variables are retrieved via the API call 'get_variables'. At last, the model is removed from memory via a call to 'delete_lp'. Don't forget this to free all memory allocated by lp_solve.
The solution is the same answer we obtained before. Note that the non-negativity constraints are accounted implicitly because variables are by default non-negative in lp_solve.
Well, we could have done this problem by hand (as shown in the introduction) because it is very small and it
can be graphically presented.
Now suppose that the farmer is dealing with a third crop, say corn, and that the corresponding data is:
cost per acre $150.75 yield per acre 125 bushels profit per bushel $1.56
With three variables it is already a lot more difficult to show this model graphically. Adding more variables makes it even impossible because we can't imagine anymore how to represent this. We only have a practical understanding of 3 dimentions, but beyound that it is all very theorethical.
If we denote the number of acres allotted to corn by z, then the objective function becomes:
P = (110)(1.30)x + (30)(2.00)y + (125)(1.56) = 143x + 60y + 195z
And the constraint inequalities are:
120x + 210y + 150.75z <= 15000
110x + 30y + 125z <= 4000
x + y + z <= 75
x >= 0, y >= 0, z >= 0
The problem is solved with lp_solve as follows:
octave:> f = [143 60 195];
octave:> A = [120 210 150.75; 110 30 125; 1 1 1];
octave:> b = [15000; 4000; 75];
octave:> lp = lp_maker(f, A, b, [-1; -1; -1], [], [], [], 1, 0);
octave:> solvestat = octlpsolve('solve', lp)
solvestat = 0
octave:> obj = octlpsolve('get_objective', lp)
obj = 6986.8
octave:> x = octlpsolve('get_variables', lp)
x =
0.00000
56.57895
18.42105
octave:> octlpsolve('delete_lp', lp);
Note that these command are in script example5.m
So the farmer should ditch the wheat and plant 56.5789 acres of barley and 18.4211 acres of corn.
There is no practical limit on the number of variables and constraints that Octave can handle. Certainly none that the relatively unsophisticated user will encounter. Indeed, in many true applications of the technique of linear programming, one needs to deal with many variables and constraints. The solution of such a problem by hand is not feasible, and software like Octave is crucial to success. For example, in the farming problem with which we have been working, one could have more crops than two or three. Think agribusiness instead of family farmer. And one could have constraints that arise from other things beside expenses, storage and acreage limitations. For example:
Below is a sequence of commands that solves exactly such a problem. You should be able to recognize the objective expression and the constraints from the data that is entered. But as an aid, you might answer the following questions:
octave:> f = [110*1.3 30*2.0 125*1.56 75*1.8 95*.95 100*2.25 50*1.35];
octave:> A = [120 210 150.75 115 186 140 85;
110 30 125 75 95 100 50;
1 1 1 1 1 1 1;
1 -1 0 0 0 0 0;
0 0 1 0 -2 0 0;
0 0 0 -1 0 -1 1];
octave:> b = [55000;40000;400;0;0;0];
octave:> lp = lp_maker(f, A, b, [-1; -1; -1; -1; -1; -1],
[10 10 10 10 20 20 20], [100 Inf 50 Inf Inf 250 Inf], [], 1, 0);
octave:> solvestat = octlpsolve('solve', lp)
solvestat = 0
octave:> obj = octlpsolve('get_objective', lp)
obj = 7.5398e+04
octave:> x = octlpsolve('get_variables', lp)
x =
10.000
10.000
40.000
45.652
20.000
250.000
20.000
octave:> octlpsolve('delete_lp', lp);
Note that these command are in script example6.m
Note that we have used in this formulation the vlb and vub arguments of lp_maker. This to set lower and upper bounds on variables. This could have been done via extra constraints, but it is more performant to set bounds on variables. Also note that Inf is used for variables that have no upper limit. This stands for Infinity.
Note that despite the complexity of the problem, lp_solve solves it almost instantaneously. It seems the farmer should bet the farm on crop number 6. We strongly suggest you alter the expense and/or the storage limit in the problem and see what effect that has on the answer.
Suppose we want to solve the following linear program using Octave:
max 4x1 + 2x2 + x3
s. t. 2x1 + x2 <= 1
x1 + 2x3 <= 2
x1 + x2 + x3 = 1
x1 >= 0
x1 <= 1
x2 >= 0
x2 <= 1
x3 >= 0
x3 <= 2
Convert the LP into Octave format we get:
f = [4 2 1]
A = [2 1 0; 1 0 2; 1 1 1]
b = [1; 2; 1]
Note that constraints on single variables are not put in the constraint matrix. lp_solve can set bounds on individual variables and this is more performant than creating additional constraints. These bounds are:
l = [ 0 0 0]
u = [ 1 1 2]
Now lets enter this in Octave:
octave:> f = [4 2 1]; octave:> A = [2 1 0; 1 0 2; 1 1 1]; octave:> b = [1; 2; 1]; octave:> l = [ 0 0 0]; octave:> u = [ 1 1 2];
Now solve the linear program using Octave: Type the commands
octave:> lp = lp_maker(f, A, b, [-1; -1; -1], l, u, [], 1, 0);
octave:> solvestat = octlpsolve('solve', lp)
solvestat = 0
octave:> obj = octlpsolve('get_objective', lp)
obj = 2.5000
octave:> x = octlpsolve('get_variables', lp)
x =
0.50000
0.00000
0.50000
octave:> octlpsolve('delete_lp', lp)
What to do when some of the variables are missing ?
For example, suppose there are no lower bounds on the variables. In this case define l to be the empty set using the Octave command:
octave:> l = [];
This has the same effect as before, because lp_solve has as default lower bound for variables 0.
But what if you want that variables may also become negative?
Then you can use -Inf as lower bounds:
octave:> l = [-Inf -Inf -Inf];
Solve this and you get a different result:
octave:> lp = lp_maker(f, A, b, [-1; -1; -1], l, u, [], 1, 0);
octave:> solvestat = octlpsolve('solve', lp)
solvestat = 0
octave:> obj = octlpsolve('get_objective', lp)
obj = 2.6667
octave:> x = octlpsolve('get_variables', lp)
x =
0.66667
-0.33333
0.66667
octave:> octlpsolve('delete_lp', lp)
Note again that the Octave command 'help octlpsolve.m' gives an overview of all functions that can be called via octlpsolve with their arguments and return values.
Note that everwhere where lp is used as argument that this can be a handle (lp_handle) or the models name.
These routines are not part of the lpsolve API, but are added for backwards compatibility. Most of them exist in the lpsolve API with another name.
See also Using lpsolve from O-Matrix, Using lpsolve from MATLAB, Using lpsolve from Scilab, Using lpsolve from Python, Using lpsolve from R
docs/5.5/get_constr_type.htm 0000644 0001750 0001750 00000005745 11306036626 014721 0 ustar rene rene
get_constr_typeGets the type of a constraint. int get_constr_type(lprec *lp, int row); Return Value get_constr_type returns the type of the constraint on row row. Can by any of the following values:
If there is an error then the function returns -1. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the constraint type must be retrieved. Must be between 1 and number of rows in the lp. Remarks The get_constr_type function returns the constraint type for the
specified row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_constr_type, set_constr_type, add_constraint, add_constraintex, str_add_constraint, del_constraint |
get_scalelimitSets the relative scaling convergence criterion for the active scaling mode. REAL get_scalelimit(lprec *lp); Return Value get_scalelimit returns the relative scaling convergence criterion for the active scaling mode; the integer part specifies the maximum number of iterations. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI scalelimit maximum number of iterations Remarks The get_scalelimit function the relative scaling convergence criterion for the active scaling mode; the integer part specifies the maximum number of iterations (default is 5). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_scalelimit, set_scaling, get_scaling, is_integerscaling |
is_nativeXLIReturns if a build-in External Language Interfaces (XLI) is available or not. unsigned char is_nativeXLI(lprec *lp); Return Value is_nativeXLI returns TRUE if a build-in XLI is available, FALSE if not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks At this moment, this routine always returns FALSE since no build-in XLI is available. See External Language Interfaces for a complete description on XLIs. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, write_XLI, has_XLI, set_XLI |
put_abortfuncSets an abort routine. void put_abortfunc(lprec *lp, lphandle_intfunc newctrlc, void *ctrlchandle); Return Value put_abortfunc has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI newctrlc The abort routine. ctrlchandle A parameter that will be provided to the abort routine. Remarks The put_abortfunc function sets an abort routine. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, put_logfunc |
set_print_solSets a flag if all intermediate valid solutions must be printed while solving. void set_print_sol(lprec *lp, int print_sol); Return Value set_print_sol has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI print_sol
Remarks The set_print_sol function sets a flag if all intermediate valid solutions must be printed while solving. Can give you useful solutions even if the total run time is too long. This function is mend for debugging purposes. The default is not to print (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_print_sol |
get_mip_gapReturns the MIP gap value. REAL get_mip_gap(lprec *lp, unsigned char absolute); Return Value get_mip_gap returns the MIP gap value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI absolute If TRUE then the absolute MIP gap is returned, else the relative MIP gap. Remarks The get_mip_gap function returns the MIP gap that specifies a tolerance
for the branch and bound algorithm. This tolerance is the difference between
the best-found solution yet and the current solution. If the difference is
smaller than this tolerance then the solution (and all the sub-solutions) is
rejected. This can result in faster solving times, but results in a solution
which is not the perfect solution. So be careful with this tolerance. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_mip_gap, get_epsd, set_epsd, set_infinite, get_infinite, set_epsint, get_epsint, set_epsb, get_epsb, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb |
get_var_priorityReturns, for the specified variable, the priority the variable has in the branch-and-bound algorithm. int get_var_priority(lprec *lp, int column); Return Value get_var_priority returns the priority of the variable. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable on which the priority must be returned. It must be between 1 and the number of columns in the lp. If it is not within this range, the return value is 0 Remarks The get_var_priority function returns the priority the variable has in the branch-and-bound algorithm. This priority is determined by the weights set by set_var_weights. The default priorities are the column positions of the variables in the model. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_var_weights, get_var_branch, set_var_branch, set_bb_floorfirst, get_bb_floorfirst |
add_constraint, add_constraintex, str_add_constraintAdd a constraint to the lp. unsigned char add_constraint(lprec *lp, REAL *row, int constr_type, REAL rh); unsigned char add_constraintex(lprec *lp, int count, REAL *row, int *colno, int constr_type, REAL rh); unsigned char str_add_constraint(lprec *lp, char *row_string, int constr_type, REAL rh); Return Value add_constraint, add_constraintex and str_add_constraint return TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI count Number of elements in row and colno. row An array with 1+get_Ncolumns (count for add_constraintex, if colno is different from NULL) elements that contains the values of the row. colno A zero-based array with count elements that contains the column numbers of the row. However this variable can also be NULL. In that case element i in the variable row is column i and values start at element 1. row_string A string with column elements that contains the values of the row. Each element must be separated by space(s). constr_type The type of the constraint. Can by any of the following values:
rh The value of the right hand side (RHS). Remarks The add_constraint, add_constraintex, str_add_constraint functions add a row to the
model (at the end) and sets all values of the row at once. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_row, set_rowex, set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj, set_add_rowmode, is_add_rowmode, resize_lp, get_constr_type, is_constr_type, del_constraint, add_column, add_columnex, str_add_column, set_column, set_columnex, get_column, get_columnex, get_row, get_rowex, get_mat |
set_scalingSpecifies which scaling algorithm must be used. void set_scaling(lprec *lp, int scalemode); Return Value set_scaling has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI scalemode Specifies which scaling algorithm must be used. Can by any of the
following values:
Additionally, the value can be OR-ed with any combination of one of the following values:
Remarks The set_scaling function specifies which scaling algorithm must be
used. This can influence numerical stability considerably. It is advisable to
always use some sort of scaling. Also see scaling for a description about scaling. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_scaling, is_integerscaling, is_scalemode, is_scaletype |
Special Ordered Sets (SOS)Special Ordered Sets of Type OneA Special Ordered Set of type One (SOS1) is defined to be a set of variables for which not more than one member from the set may be non-zero in a feasible solution. All such sets are mutually exclusive of each other, the members are not subject to any other discrete conditions and are grouped together consecutively in the data. The normal use of an SOS1 is to represent a set of mutually exclusive alternatives ordered in increasing values of size, cost or some other suitable units appropriate to the context of the model. This representation is a discrete programming extension of the separable programming model. There is a strong implied assumption that a non-linear function represented in this way is single valued over the range of its argument. Consider a function g(y) represented by the points P1,...,PK as shown in figure 2.
Figure 2
Given
the tabulated coordinates where The
discrete function can take only one of the This requirement could be expressed by restricting each xk to be a binary variable but the alternative of defining them collectively as a special ordered set of type one, which is a direct statement of their nature, leads to a more efficient solution process. The weighting variables xk are called special ordered set type one variables and the rows (1), (2), and (3) are called function rows, reference rows and convexity rows respectively. Should the SOS1's not represent a modelling of discrete, separable variables then none of these rows need actually exist, but there is an advantage to the system if it is aware of the reference rows at least.
Special Ordered Sets of Type TwoA Special Ordered Set of type Two (SOS2) is a set of consecutive variables in which not more than two adjacent members may be non-zero in a feasible solution. All such sets are mutually exclusive of each other, the members are not subject to any other discrete conditions and each set is grouped together consecutively in the data. SOS2s were introduced to make it easier to find global optimum solutions to problems containing piecewise linear approximations to a non-linear function of a single argument (as in classical Separable Programming). The overall problem has an otherwise LP or an IP structure except for such non-linear functions. Consider
the function
Figure 3
Any
point
where
Similarly,
as
This
leads to the representation of where Plus the added condition that not more than two adjacent variables can be non-zero at any one time. The weighting variables xk are called the special ordered set type two variables and the rows (4), (5), and (6) are called function rows, reference rows and the convexity rows respectively, as in equations (1), (2) and (3) of Topic "Special Ordered Sets of Type One". Should the SOS2's not represent separable functions then none of these rows need actually exist, but there is an advantage to the system if it is aware of the reference rows at least.
The lp_solve implementation of SOS is the following:A specially ordered set of degree N is a collection of variables where at most N variables may be non-zero. The non-zero variables must be contiguous (neighbours) sorted by the ascending value of their respective unique weights. In lp_solve, specially ordered sets may be of any cardinal type 1, 2, and higher, and may be overlapping. The number of variables in the set must be equal to, or exceed the cardinal SOS order. lp_solve supports Special Ordered Sets via the API interface, in the MPS format and in the lp format (from release 4.0.1.11). Below is a representation of a SOS in an MPS file, where each SOS is defined in its own SOS section, which should follow the BOUNDS section.
0 1 2 3 4
1234567890123456789012345678901234567890
SOS
Sx CaseName SOSName. SOSpriority.
CaseName VarName1 VarWeight1..
CaseName VarName2 VarWeight2..
CaseName VarNameN VarWeightN..
x at the second line, position 3, defines is the order of the SOS. Due to limitations in the MPS format, N is restricted to the 1..9 range. Each SOS should be given a unique name, SOSName. lp_solve does not currently use case names for SOS'es and the CaseName could be any non-empty value. Below is a representation of a SOS in an lp file. sos SOS: VarName1: VarWeight1, VarName2: VarWeight2, ..., VarNameN: VarWeightN <= 1: SOSpriority; In the lp format, the VarWeights are optional: sos SOS: VarName1, VarName2, ..., VarNameN <= 1: SOSpriority; In that case, the order of the variables define the VarWeights. So above is equal to: sos SOS: VarName1: 1, VarName2: 2, ..., VarNameN: N <= 1: SOSpriority; Also the SOSpriority is optional. In that case the order in which the SOS constraints are specified give them a priority. The SOSpriority value determines the order in which multiple SOS'es are analysed in lp_solve. VarWeight determines the adjacency of the variables. This is an importand piece of information. Remember that the SOS definition defines that the non-zero variables must be adjacent. The VarWeight values define this adjencency. SOS1 Example:
ROWS
L c1
L c2
N COST
COLUMNS
x1 c1 -1. c2 1.
x1 COST -1.
x2 c1 -1. COST -1.
x3 c1 1. c2 1.
x3 COST -3.
x4 c1 1. c2 -3.
x4 COST -2.
x5 COST -2.
RHS
RHS c1 30. c2 30.
BOUNDS
UP COLBND x1 40.
UP COLBND x2 1.
UP COLBND x5 1.
SOS
S1 SOS SOS 1.
SOS x1 1.
SOS x2 2.
SOS x3 3.
SOS x4 4.
SOS x5 5.
ENDATA
In lp format:
min: -x1 -x2 -3 x3 -2 x4 -2 x5;
c1: -x1 -x2 +x3 +x4 <= 30;
c2: +x1 +x3 -3 x4 <= 30;
x1 <= 40;
x2 <= 1;
x5 <= 1;
sos
SOS: x1,x2,x3,x4,x5 <= 1;
The SOS definition says that either x1 or x2 or x3 or x4 or x5 may be taken. It also says that x1 is adjacent to x2 which is adjacent to x3 which is adjacent to x4 which is adjacent to x5. The solution is:Value of objective function: -90 Actual values of the variables: x1 0 x2 0 x3 30 x4 0 x5 0 SOS2 Example:
ROWS
L c1
L c2
N COST
COLUMNS
x1 c1 -1. c2 1.
x1 COST -1.
x2 c1 -1. COST -1.
x3 c1 1. c2 1.
x3 COST -3.
x4 c1 1. c2 -3.
x4 COST -2.
x5 COST -2.
RHS
RHS c1 30. c2 30.
BOUNDS
UP COLBND x1 40.
UP COLBND x2 1.
UP COLBND x5 1.
SOS
S2 SOS SOS 1.
SOS x1 1.
SOS x2 2.
SOS x3 3.
SOS x4 4.
SOS x5 5.
ENDATA
In lp format:
min: -x1 -x2 -3 x3 -2 x4 -2 x5;
c1: -x1 -x2 +x3 +x4 <= 30;
c2: +x1 +x3 -3 x4 <= 30;
x1 <= 40;
x2 <= 1;
x5 <= 1;
sos
SOS: x1,x2,x3,x4,x5 <= 2;
The SOS definition says that two consecutive variables from x1, x2, x3, x4, x5 may be taken. It also says that x1 is adjacent to x2 which is adjacent to x3 which is adjacent to x4 which is adjacent to x5. The solution is:Value of objective function: -91 Actual values of the variables: x1 0 x2 1 x3 30 x4 0 x5 0 SOS3 Example:
ROWS
L c1
L c2
N COST
COLUMNS
x1 c1 -1. c2 1.
x1 COST -1.
x2 c1 -1. COST -1.
x3 c1 1. c2 1.
x3 COST -3.
x4 c1 1. c2 -3.
x4 COST -2.
x5 COST -2.
RHS
RHS c1 30. c2 30.
BOUNDS
UP COLBND x1 40.
UP COLBND x2 1.
UP COLBND x5 1.
SOS
S3 SOS SOS 1.
SOS x1 1.
SOS x2 2.
SOS x3 3.
SOS x4 4.
SOS x5 5.
ENDATA
In lp format:
min: -x1 -x2 -3 x3 -2 x4 -2 x5;
c1: -x1 -x2 +x3 +x4 <= 30;
c2: +x1 +x3 -3 x4 <= 30;
x1 <= 40;
x2 <= 1;
x5 <= 1;
sos
SOS: x1,x2,x3,x4,x5 <= 3;
The SOS definition says that three consecutive variables from x1, x2, x3, x4, x5 may be taken. It also says that x1 is adjacent to x2 which is adjacent to x3 which is adjacent to x4 which is adjacent to x5. The solution is:Value of objective function: -93.75 Actual values of the variables: x1 0 x2 1 x3 30.75 x4 0.25 x5 0 SOS4 Example:
ROWS
L c1
L c2
N COST
COLUMNS
x1 c1 -1. c2 1.
x1 COST -1.
x2 c1 -1. COST -1.
x3 c1 1. c2 1.
x3 COST -3.
x4 c1 1. c2 -3.
x4 COST -2.
x5 COST -2.
RHS
RHS c1 30. c2 30.
BOUNDS
UP COLBND x1 40.
UP COLBND x2 1.
UP COLBND x5 1.
SOS
S4 SOS SOS 1.
SOS x1 1.
SOS x2 2.
SOS x3 3.
SOS x4 4.
SOS x5 5.
ENDATA
In lp format:
min: -x1 -x2 -3 x3 -2 x4 -2 x5;
c1: -x1 -x2 +x3 +x4 <= 30;
c2: +x1 +x3 -3 x4 <= 30;
x1 <= 40;
x2 <= 1;
x5 <= 1;
sos
SOS: x1,x2,x3,x4,x5 <= 4;
The SOS definition says that four consecutive variables from x1, x2, x3, x4, x5 may be taken. It also says that x1 is adjacent to x2 which is adjacent to x3 which is adjacent to x4 which is adjacent to x5. The solution is:Value of objective function: -233.75 Actual values of the variables: x1 40 x2 1 x3 50.75 x4 20.25 x5 0 SOS5 Example:
ROWS
L c1
L c2
N COST
COLUMNS
x1 c1 -1. c2 1.
x1 COST -1.
x2 c1 -1. COST -1.
x3 c1 1. c2 1.
x3 COST -3.
x4 c1 1. c2 -3.
x4 COST -2.
x5 COST -2.
RHS
RHS c1 30. c2 30.
BOUNDS
UP COLBND x1 40.
UP COLBND x2 1.
UP COLBND x5 1.
SOS
S5 SOS SOS 1.
SOS x1 1.
SOS x2 2.
SOS x3 3.
SOS x4 4.
SOS x5 5.
ENDATA
In lp format:
min: -x1 -x2 -3 x3 -2 x4 -2 x5;
c1: -x1 -x2 +x3 +x4 <= 30;
c2: +x1 +x3 -3 x4 <= 30;
x1 <= 40;
x2 <= 1;
x5 <= 1;
sos
SOS: x1,x2,x3,x4,x5 <= 5;
The SOS definition says that five consecutive variables from x1, x2, x3, x4, x5 may be taken. It also says that x1 is adjacent to x2 which is adjacent to x3 which is adjacent to x4 which is adjacent to x5. The solution is:Value of objective function: -235.75 Actual values of the variables: x1 40 x2 1 x3 50.75 x4 20.25 x5 1 |
set_senseSet objective function sense. void set_sense(lprec *lp, unsigned char maximize); Return Value set_sense has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI maximize Set sense to minimize (FALSE) or maximize (TRUE). Remarks The set_sense function sets the objective sense. The default of lp_solve is to minimize, except for read_lp, read_LP where the default is to maximize. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_minim, set_maxim, is_maxim |
GNU MathProgGNU MathProg is a modeling language intended for describing linear mathematical programming models.
See http://gnuwin32.sourceforge.net/downlinks/glpk-doc-zip.php for a complete description of this modeling language. GNU MathProg is part of the GLPK solver.
See http://www.gnu.org/software/glpk/glpk.html
and http://gnuwin32.sourceforge.net/packages/glpk.htm
for the homepage of it. lp_solve -rxli xli_MathProg Diet1.mod This gives as result: Value of objective function: 88.2 Actual values of the variables: Buy[BEEF] 0 Buy[CHK] 0 Buy[FISH] 0 Buy[HAM] 0 Buy[MCH] 46.6667 Buy[MTL] 0 Buy[SPG] 0 Buy[TUR] 0 MathProg has also the possibility to have the model and data in two separate files. lp_solve can handle this also. For example: lp_solve -rxli xli_MathProg diet.mod -rxlidata diet.dat This gives as result: Value of objective function: 88.2 Actual values of the variables: Buy[BEEF] 0 Buy[CHK] 0 Buy[FISH] 0 Buy[HAM] 0 Buy[MCH] 46.6667 Buy[MTL] 0 Buy[SPG] 0 Buy[TUR] 0 Generating MathProg modelsThe XLI can also create a MathProg model, however it doesn't use the strength of the language. Constraints are written out line per line. But it can be a starter. For example: lp_solve model.lp -wxli xli_MathProg model.mod This gives as model.mod: /* Variable definitions */ var x >= 0; var y >= 0; /* Objective function */ maximize obj: +143*x +60*y; /* Constraints */ R1: +120*x +210*y <= 15000; R2: +110*x +30*y <= 4000; R3: +x +y <= 75; APIUse the lpsolve API call read_XLI to read a model and write_XLI to write a model. See also External Language Interfaces. IDEAlso from within the IDE, this XLI can be used. However, some entries must be added in LpSolveIDE.ini (in the folder where the IDE is installed). In the [XLI] section the following must be added: lib1=xli_MathProg And a new section for the MathProg XLI must also be added: [xli_MathProg] extension=.mod language=MATHPROG Then make sure that the xli_MathProg.dll is available for the IDE. This must be done by placing this dll in the IDE folder or in the Windows system32 folder. Example models/dataDiet1.mod
set NUTR;
set FOOD;
param cost {FOOD} > 0;
param f_min {FOOD} >= 0;
param f_max {j in FOOD} >= f_min[j];
param n_min {NUTR} >= 0;
param n_max {i in NUTR} >= n_min[i];
param amt {NUTR,FOOD} >= 0;
var Buy {j in FOOD} >= f_min[j], <= f_max[j];
minimize total_cost: sum {j in FOOD} cost[j] * Buy[j];
subject to diet {i in NUTR}:
n_min[i] <= sum {j in FOOD} amt[i,j] * Buy[j] <= n_max[i];
data;
set NUTR := A B1 B2 C ;
set FOOD := BEEF CHK FISH HAM MCH MTL SPG TUR ;
param: cost f_min f_max :=
BEEF 3.19 0 100
CHK 2.59 0 100
FISH 2.29 0 100
HAM 2.89 0 100
MCH 1.89 0 100
MTL 1.99 0 100
SPG 1.99 0 100
TUR 2.49 0 100 ;
param: n_min n_max :=
A 700 10000
C 700 10000
B1 700 10000
B2 700 10000 ;
param amt (tr):
A C B1 B2 :=
BEEF 60 20 10 15
CHK 8 0 20 20
FISH 8 10 15 10
HAM 40 40 35 10
MCH 15 35 15 15
MTL 70 30 15 15
SPG 25 50 25 15
TUR 60 20 15 10 ;
end;
diet.mod
set NUTR;
set FOOD;
param cost {FOOD} > 0;
param f_min {FOOD} >= 0;
param f_max {j in FOOD} >= f_min[j];
param n_min {NUTR} >= 0;
param n_max {i in NUTR} >= n_min[i];
param amt {NUTR,FOOD} >= 0;
var Buy {j in FOOD} >= f_min[j], <= f_max[j];
minimize total_cost: sum {j in FOOD} cost[j] * Buy[j];
subject to diet {i in NUTR}:
n_min[i] <= sum {j in FOOD} amt[i,j] * Buy[j] <= n_max[i];
diet.dat
set NUTR := A B1 B2 C ;
set FOOD := BEEF CHK FISH HAM MCH MTL SPG TUR ;
param: cost f_min f_max :=
BEEF 3.19 0 100
CHK 2.59 0 100
FISH 2.29 0 100
HAM 2.89 0 100
MCH 1.89 0 100
MTL 1.99 0 100
SPG 1.99 0 100
TUR 2.49 0 100 ;
param: n_min n_max :=
A 700 10000
C 700 10000
B1 700 10000
B2 700 10000 ;
param amt (tr):
A C B1 B2 :=
BEEF 60 20 10 15
CHK 8 0 20 20
FISH 8 10 15 10
HAM 40 40 35 10
MCH 15 35 15 15
MTL 70 30 15 15
SPG 25 50 25 15
TUR 60 20 15 10 ;
model.lp/* model.lp */ max: 143 x + 60 y; 120 x + 210 y <= 15000; 110 x + 30 y <= 4000; x + y <= 75; |
get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objexReturns the sensitivity of the objective function. unsigned char get_sensitivity_obj(lprec *lp, REAL *objfrom, REAL *objtill); unsigned char get_sensitivity_objex(lprec *lp, REAL *objfrom, REAL *objtill, REAL *objfromvalue, REAL *objtillvalue); unsigned char get_ptr_sensitivity_obj(lprec *lp, REAL **ptr_objfrom, REAL **ptr_objtill); unsigned char get_ptr_sensitivity_objex(lprec *lp, REAL **ptr_objfrom, REAL **ptr_objtill, REAL **ptr_objfromvalue, REAL **ptr_objtillvalue); Return Value get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex,
get_ptr_sensitivity_objex return TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI objfrom An array that will contain the values of the lower limits on the objective function. ptr_objfrom The address of a pointer that will point to an array that will contain the values of the lower limits of the objective function. objtill An array that will contain the values of the upper limits of the objective function. ptr_objtill The address of a pointer that will point to an array that will contain the values of the upper limits of the objective function. objfromvalue An array that will contain the values of the variables at their lower limit. Only applicable when the value of the variable is 0 (rejected). objtillvalue Not used at this time. ptr_objfromvalue The address of a pointer that will point to an array that will contain the values of the variables at their lower limit. Only applicable when the value of the variable is 0 (rejected). ptr_objtillvalue Not used at this time. Remarks The get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex,
get_ptr_sensitivity_objex functions return the sensitivity of the
objective function. Note that get_ptr_sensitivity_obj and get_ptr_sensitivity_objex return a pointer to memory allocated and maintained by lp_solve. Be careful what you do with it. Don't modify its contents or free the memory. Unexpected behaviour would occur. Also note that this memory pointer is only guaranteed to remain constant until a next lp_solve API call is done. You should call this function again to make sure you have again the correct pointer. Otherwise, this pointer could point to invalid memory. This should not be a problem since this call is very efficient. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_feasible, get_objective, get_working_objective, get_variables, get_ptr_variables, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_rhs, get_ptr_sensitivity_rhs, |
AMPL (A Mathematical Programming Language) is a high-level language for describing mathematical
programs. AMPL allows a mathematical programming model to be specified independently of the data
used for a specific instance of the model. AMPL's language for describing mathematical programs closely
follows that used by humans to describe mathematical programs to each other. For this reason, modellers
may spend more time improving the model and less time on the tedious details of data manipulation and
problem solution.
To start, AMPL needs a mathematical
programming model, which describes variables, objectives and relationships without referring to specific data.
AMPL also needs an instance of the data, or a particular data set. The model and one (or more) data files are
fed into the AMPL program. AMPL works like a compiler: the model and input are put into an intermediate
file that can be read by a solver. The solver actually finds an optimal solution to the problem by reading
in the intermediate file produced by AMPL and applying an appropriate algorithm. The solver outputs the
solution as a text file, which can be viewed directly and cross-referenced with the variables and constraints
specified in the model file.
We will not discuss the specifics of AMPL here but instead refer the reader to AMPL (A Mathematical Programming Language) at the University of Michigan Documentation and the AMPL website http://www.ampl.com.
One of the possible solvers that can be used by AMPL is lpsolve. However note that AMPL allows also defining non-linear models. These are not solvable by lpsolve because lpsolve can only handle MILP models. A message will be given if the AMPL model results in a model that cannot be handled by lpsolve.
To make this possible, a driver program is needed: lpsolve(.exe). This program must be put in the AMPL directory and AMPL can call the lpsolve solver. The newer versions of the lpsolve(.exe) driver call lpsolve via the shared library (lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux). This has the advantage that the lpsolve driver program doesn't have to be recompiled when an update of lpsolve is provided. The shared library must be somewhere in the path. That is all.
In the following text, ampl: before the AMPL commands is the AMPL prompt. Only the text after the : must be entered.
To select the lpsolve solver, the following command must be executed in AMPL:
ampl: option solver lpsolve;
To solve the model, the following command must be executed in AMPL:
ampl: solve;
Options can be passed to lpsolve. For example to enable scaling, the following command must be executed in AMPL:
ampl: option lpsolve_options 'scale';
Multiple options can be specified by separating them with at least one space:
ampl: option lpsolve_options 'scale scalemode=7 verbose';
A list of all options is given at the end of this document.
ampl: model diet.mod; ampl: data diet.dat; ampl: option solver lpsolve; ampl: option lpsolve_options 'scale scalemode=7'; ampl: solve;
This gives as result:
LP_SOLVE 5.5.0.13: scale scalemode=7 LP_SOLVE 5.5.0.13: optimal, objective 88.2 1 simplex iterations
AMPL has a parameter that is used to indicate the outcome of the optimisation process. It is used as follows
ampl: display solve_result_num
solve_result_num can take the values shown in following table which also presents a short explanation for each value.
|
ampl: model diet.mod; ampl: data diet.dat; ampl: option solver lpsolve; ampl: solve;
This gives as result:
LP_SOLVE 5.5.0.13: optimal, objective 88.2 3 simplex iterations
Note that 3 iterations were needed to solve the model. Now solve the model again:
ampl: solve;
This gives as result:
LP_SOLVE 5.5.0.13: optimal, objective 88.2 0 simplex iterations
Note now that no iterations are needed to solve the model. This because the result of the previous solve is used as a starting point for the new solve. It is even allowed to add or deleted variables and constraints in the model, lpsolve will still try to start from the last result to continue.
If, for some reason, you don't want this and let lpsolve resolve the model from scratch, there are two possibilities to let lpsolve ignore the starting base. Either via an lpsolve option or an AMPL option.
The lpsolve option that can be set is:
ampl: option lpsolve_options 'coldstart';
The AMPL option that can be set is:
ampl: option send_statuses 0;
ampl: solve;
This gives as result:
LP_SOLVE 5.5.0.13: coldstart LP_SOLVE 5.5.0.13: optimal, objective 88.2 3 simplex iterations
Special considerations for integer models. From the moment that a model contains integer variables,
the B&B algorithm must be used to solve this. This algorithm must go trough a tree of possible solutions
each time a solve is done. The last base of the best integer solution can not be used as a starting base for
a resolve. This is not an lpsolve limitation, but a B&B algorithm property...
For this reason, by default, AMPL doesn't provide a starting to the solver and solve is done from scratch.
By default... However, a compromise can be implemented by the solver. And this is also done in lpsolve. Solving
integer models is always started with solving the non-integer model. When this is done, the non-integer variables
are made integer via the B&B algorithm. lpsolve returns the base of the non-integer model and this base is
used as a starting base for the model at the next solve. As said, this is a compromise because it results in
a fast solve of the non-integer model, but the B&B algorithm must still be executed. So even if no
modifications are done to the model and solve is done again, there will be iterations needed by the B&B
algorithm to solve the integers. Because this must be explicitly implemented in the solver, AMPL doesn't
provide the starting base by default for integer models. It must explicitly be activated:
ampl: option send_statuses 2;
Only then, lpsolve will get a starting base when there are integers.
Example:
ampl: model multmip3.mod; ampl: data multmip3.dat; ampl: option solver lpsolve; ampl: solve;
This gives as result:
LP_SOLVE 5.5.0.13: optimal, objective 235625 1986 simplex iterations 592 branch & bound nodes: depth 21
Note that 1986 iterations were needed to solve the model. Now solve the model again:
ampl: solve;
This gives as result:
LP_SOLVE 5.5.0.13: optimal, objective 235625 1986 simplex iterations 592 branch & bound nodes: depth 21
The same as above. So no restart was done. Now activate the starting base for integer models and solve again:
ampl: option send_statuses 2; ampl: solve;
This gives as result:
LP_SOLVE 5.5.0.13: optimal, objective 235625 1922 simplex iterations 592 branch & bound nodes: depth 21
Note that less iterations are needed, but not 0 as in non-integer models. These are the iterations needed for the B&B algorithm.
lpsolve accepts a lot of options. Some options are just on/off switches and for there you just specify the option keyword (for example scale). Other options need a value and this is specified by an equal (=) sign after the option keyword and then the value (for example scalemode=7). Multiple options can be specified by separating them by a space (for example scale scalemode=7).
These options can be displayed from the command line by entering the following:
lpsolve -=
Here is a list of the possible lpsolve options:
k=1,...,K,
the function
g(y)
may be represented as
(1)
(2)
(3)
possible values weighted by the variables 
,
of which only one can be non-zero, and that must have the value one.
illustrated in Figure 3 as a piecewise linear function in one variable defined
over the closed intervals 
,
where the coordinates 
,
represent points P1,...,PK.
in the closed interval 
may be written as
.
is linear in the interval, it can be written as
.
using a set of weighting variables, 
,
by the equality
(4)
(5)
. (6)
bb=... branch-and-bound rule: one of
0 (default) for lowest indexed non-integer variable
1 for selection based on distance from the current bounds
2 for selection based on the largest current bound
3 for selection based on largest fractional value
4 for simple, unweighted pseudo-cost of a variable
5 this is an extended pseudo-costing strategy based on
minimizing the number of integer infeasibilities
6 this is an extended pseudo-costing strategy based on
maximizing the normal pseudo-cost divided by the
number of infeasibilities
plus
8 for weight reverse mode
16 when cauto is used, select the oposite direction that
autoselect had chosen
32 for greedy mode
64 for pseudo cost mode
128 select the node that has already been selected before
the most number of times
256 for randomize mode
1024 when mode 128 is selected, switch off this mode when
a first solution is found
2048 for restart mode
4096 select the node that has been selected before the
fewest number of times or not at all
bfp=... set basis factorization package
cauto in IPs, algorithm decides which branch being taken first
cfirst in IPs, take ceiling branch first
coldstart ignore starting base
crash=... determines a starting base: one of
0 (default) none
2 most feasible basis
debug debug mode
degen perturb degeneracies
degenx=... anti-degen handling: one of
0 (default) no anti-degeneracy handling
1 check if there are equality slacks in the basis and
try to drive them out in order to reduce chance of
degeneracy in Phase 1
2 ColumnCheck
4 Stalling
8 NumFailure
16 LostFeas
32 Infeasible
64 Dynamic
128 During BB
depth=... set branch-and-bound depth limit
dual prefer the dual simplex for both phases
eps=... tolerance for rounding to integer
epsb=... minimum tolerance for the RHS
epsd=... minimum tolerance for reduced costs
epsel=... minimum tolerance for rounding values to zero
epsp=... value that is used as perturbation scalar for
degenerative problems
f specifies that branch-and-bound algorithm stops at first
found solution
ga=... specifies the absolute MIP gap for branch-and-bound
gr=... specifies the relative MIP gap for branch-and-bound
improve=... the iterative improvement level: one of
0 improve none
1 Running accuracy measurement of solved equations based on
Bx=r (primal simplex), remedy is refactorization.
2 Improve initial dual feasibility by bound flips
(highly recommended, and default)
4 Low-cost accuracy monitoring in the dual, remedy is refactorization
8 By default there is a check for primal/dual feasibility at optimum
only for the relaxed problem, this also activates the test at the node level
n=... specify which solution number to return
o=... specifies that branch-and-bound algorithm stops when
objective value is better than value
objno=... objective number: 0 = none, 1 (default) = first
obound=... a lower bound for the objective function
may speed up the calculations
parse_only parse input file but do not solve
piv=... simplex pivot rule: one of
0 select first
1 select according to Dantzig
2 (default) select Devex pricing from Paula Harris
3 select steepest edge
piva temporarily use first index if cycling is detected
pivf in case of Steepest Edge, fall back to DEVEX in primal
pivla scan entering/leaving columns alternatingly left/right
pivll scan entering/leaving columns left rather than right
pivm multiple pricing
pivr adds a small randomization effect to the selected pricer
presolve presolve problem before start optimizing
presolvel also eliminate linearly dependent rows
presolver if the phase 1 solution process finds that a constraint is
redundant then this constraint is deleted
prim prefer the primal simplex for both phases
printsol=... print solution: one of
0 (default) print nothing
1 only objective value
2 obj value+variables
3 obj value+variables+constraints
4 obj value+variables+constraints+duals
5 obj value+variables+constraints+duals+lp model
6 obj value+variables+constraints+duals+lp model+scales
7 obj value+variables+constraints+duals+lp model+scales+
lp tableau
prlp print the LP
psols print (intermediate) feasible solutions
psolsa print (intermediate) feasible solutions (non-zeros)
r=... max nbr of pivots between a re-inversion of the matrix
rparname=... parameter file to read options from
rparoptions=... options parameter file
scale scale the problem
scalemode=... scale mode: one of
1 for scale to convergence using largest absolute value
2 for scale based on the simple numerical range
3 (default) for numerical range-based scaling
4 for geometric scaling
7 for Curtis & Reid scaling
plus
16 for scale to convergence using logarithmic mean
of all values
32 for also do Power scaling
64 to make sure that no scaled number is above 1
128 to scale integer variables
simplexdd set Phase1 Dual, Phase2 Dual
simplexdp set Phase1 Dual, Phase2 Primal
simplexpd set Phase1 Primal, Phase2 Dual
simplexpp set Phase1 Primal, Phase2 Primal
timeout=... timeout after sec seconds when not solution found
trace trace pivot selections
trej=... minimum pivot value
verbose verbose mode
version report version details
wafter write model after solve (usefull if presolve used)
wantsol=... solution report without -AMPL: sum of
1 ==> write .sol file
2 ==> print primal variable values
4 ==> print dual variable values
8 ==> do not print solution message
wfmps=... write to MPS file in free format
wlp=... write to LP filename
wmps=... write to MPS file in fixed format
wparname=... parameter file to write options to
wparoptions=... options parameter file
wxli=... write file with xli library
wxliname=... xli library
wxliopt=... options for xli library
Normally, the lpsolve program is called from AMPL. However the program can also be called stand-alone. When the command is invoked without an option or with the option -?, a list of the possible options is shown:
usage: lpsolve [options] stub [-AMPL] [<assignment> ...]
Options:
-- {end of options}
-= {show name= possibilities}
-? {show usage}
-e {suppress echoing of assignments}
-s {write .sol file (without -AMPL)}
-v {just show version}
stub and the -AMPL option is used when the program is called from AMPL.
The -v option shows the version of lpsolve.
The -= option shows all the options that can be passed to lpsolve from within AMPL.
These options can also be specified in an environment variable lpsolve_options.
To call the lpsolve command to solve a model, you first must have a stub file that can be read by lpsolve.
This stub file can be created by AMPL as follows:
ampl: model models\diet.mod; ampl: data models\diet.dat; ampl: write bdiet; ampl: quit
This created a binary file diet.nl. As an alternative the command write gdiet; can be used. This creates an ascii file that also can be read. However it is somewhat slower to read, especially when the models are larger.
This creates a file diet.nl in the current directory. This file is the stub file needed by lpsolve:
lpsolve lpsolve diet.nl
This gives:
LP_SOLVE 5.5.0.13: optimal, objective 88.19999999999999 3 simplex iterations
Options can be passed to lpsolve via the environment variable lpsolve_options:
set lpsolve_options=scale scalemode=7 verbose
Then the result of the previous lpsolve command is:
scale
scalemode=7
verbose
Model name: '' - run #1
Objective: Minimize(R0)
Submitted:
Model size: 4 constraints, 8 variables, 39 non-zeros.
Constraints: 0 equality, 0 GUB, 0 SOS.
Variables: 0 integer, 0 semi-cont., 0 SOS.
Using DUAL simplex for phase 1 and PRIMAL simplex for phase 2.
Optimal solution with dual simplex at iteration 1
lp_solve solution 88.2 final at iteration 1, 0 nodes explor
ed
Excellent numeric accuracy ||*|| = 1.13687e-013
Memo: Largest [etaPFI v1.0] inv(B) had 0 NZ entries, 0.0x largest basis.
In the total iteration count 1, 0 (0.0%) were minor/bound swaps.
There were 0 refactorizations, 0 triggered by time and 0 by density.
... on average 1.0 major pivots per refactorization.
Total solver time was 0.000 seconds.
LP_SOLVE 5.5.0.13: optimal, objective 88.19999999999999
1 simplex iterations
In this mode, the lpsolve option wantsol shows the solution:
set lpsolve_options=wantsol=2 lpsolve diet.nl
This gives:
wantsol=2 LP_SOLVE 5.5.0.13: optimal, objective 88.19999999999999 3 simplex iterations variable value _svar[1] 0 _svar[2] 0 _svar[3] 0 _svar[4] 0 _svar[5] 46.666666666666664 _svar[6] 0 _svar[7] -3.552713678800501e-15 _svar[8] 0
The -e option results in not echoing the options passed to lpsolve:
set lpsolve_options=wantsol=2 lpsolve -e diet.nl
This gives:
LP_SOLVE 5.5.0.13: optimal, objective 88.19999999999999 3 simplex iterations variable value _svar[1] 0 _svar[2] 0 _svar[3] 0 _svar[4] 0 _svar[5] 46.666666666666664 _svar[6] 0 _svar[7] -3.552713678800501e-15 _svar[8] 0
lpsolve options can also be passed at the command line, they don't overrule the lpsolve_options environment variable, they are added:
set lpsolve_options=wantsol=2 lpsolve diet.nl "verbose scale"
This gives:
wantsol=2
verbose
scale
Model name: '' - run #1
Objective: Minimize(R0)
Submitted:
Model size: 4 constraints, 8 variables, 39 non-zeros.
Constraints: 0 equality, 0 GUB, 0 SOS.
Variables: 0 integer, 0 semi-cont., 0 SOS.
Using DUAL simplex for phase 1 and PRIMAL simplex for phase 2.
Optimal solution with dual simplex at iteration 1
lp_solve solution 88.2 final at iteration 1, 0 nodes explor
ed
Excellent numeric accuracy ||*|| = 1.13687e-013
Memo: Largest [etaPFI v1.0] inv(B) had 0 NZ entries, 0.0x largest basis.
In the total iteration count 1, 0 (0.0%) were minor/bound swaps.
There were 0 refactorizations, 0 triggered by time and 0 by density.
... on average 1.0 major pivots per refactorization.
Total solver time was 0.000 seconds.
LP_SOLVE 5.5.0.13: optimal, objective 88.19999999999997
1 simplex iterations
variable value
_svar[1] 0
_svar[2] 0
_svar[3] 0
_svar[4] 0
_svar[5] 46.66666666666666
_svar[6] 0
_svar[7] 0
_svar[8] 0
Besides the specific lpsolve files, you also need the AMPL solvers files that must be linked with it.
These AMPL solvers files can be downloaded from various locations. The easiest way is via
ftp://netlib.bell-labs.com/netlib/ampl/solvers.tar.
untar them in directory lp_solve_5.5/extra/AMPL. This will put the files in lp_solve_5.5/extra/AMPL/solvers.
Then in the solvers directory, gunzip all the files with extension .gz.
Then, still in the solvers directory, execute the appropriate Makefile.
For example under Windows:
nmake /f makefile.vc
Under Unix this would be:
make -f makefile.u
This will generate amplsolv.lib under Windows and amplsolver.so under Unix systems.
However, Under windows, you must first create a file details.c by hand. It must contain the following single line:
char sysdetails_ASL[] = "MS VC++ 6.0";
See README for more information how to build the AMPL solvers files.
Then install the files from archive lp_solve_5.5_AMPL_source.tar.gz
When this is done, goto the lpsolve directory and execute the appropriate makefile.
There are two possibilities: generate a driver that links lpsolve statically and one that links lpsolve dynamically.
When linked dynamically, the lpsolve dll or shared library is used at runtime. When linked statically, the lpsolve static
library is linked at compile time with the AMPL lpsolve driver. For example:
nmake /f makefile5dyn.vc
This will generate lpsolve.exe (Windows) or lpsolve (Unix). Put this in the AMPL directory.
Xpress lp filesThe Xpress LP file format provides a facility for entering a problem in a natural, algebraic LP formulation from the keyboard. The problem can be modified and saved from within lpsolve. This procedure is one way to create a file in a format that lpsolve can read. An alternative technique is to create a similar file using a standard text editor and to read it into lpsolve. The Xpress LP format is provided as an input alternative to the MPS file format. An LP format file may be easier to generate than an MPS file if your problem already exists in an algebraic format or if you have an application that generates the problem file more readily in algebraic format (such as a C application). Note that the Xpress LP format is not the same as the lpsolve LP format. See LP file format for a description about the native lpsolve lp format. To read/write this format from lpsolve, you need an XLI (see External Language Interfaces). The XLI for the Xpress format is called xli_Xpress. OptionsThe XLI accepts several options: Reading-objconst Allow constants in the objective (default). -noobjconst Don't allow constants in the objective. From the documentation of the format it is not sure if Xpress allows a constant in the objective. Tests have shown that it allows a constant as first term in the objective function. Note that the lp_solve XLI allows a constant in the objective by default and it can be anywere in the objective. Use the option -noobjconst if this should not be allowed. The parser will then give an error. Writing-objconst Allow constants in the objective. -noobjconst Don't use constants in the objective (default). From the documentation of the format it is not sure if Xpress allows a constant in the objective. Tests have shown that it allows a constant as first term in the objective function. The lp_solve XLI writes the constant as first term when the option -objconst is active. By default or when the option -noobjconst is used, a constant in the objective is translated to a variable objconst_term with a bound equal to the constant set to it. So no error is generated when there is a constant. Examplelp_solve -rxli xli_Xpress input.lp lp_solve -mps input.mps -wxli xli_Xpress output.lp -wxliopt "-objconst" Syntax Rules of LP File Formatlpsolve will accept any problem saved in an ASCII file provided that it adheres to the following syntax rules.
Some examplesExample 1Minimize COST: XONE + 4 YTWO + 9 ZTHREE + 2 Subject To LIM1: XONE + YTWO <= 5 LIM2: XONE + ZTHREE >= 10 MYEQN: - YTWO + ZTHREE = 7 Bounds 0 <= XONE <= 4 -1 <= YTWO <= 1 End Example 2Minimize obj: - 2 x3 Subject To c1: x2 - x1 <= 10 c2: x1 + x2 + x3 <= 20 Bounds x1 <= 30 2 <= x3 <= 3 s.i. x3 x1 >= 2.1 End Example 3Minimize obj: - 2 x3 Subject To c1: x2 - x1 <= 10 \SOS sos101: 4 x2 + 2 x3 = S2 c2: x1 + x2 + x3 <= 20 sos102: x1 + x2 + x3 = S1 sos201: 1.2 x3 +1.3 x2 + 1.4 x1 = S2 Bounds x1 <= 30 2 <= x3 <= 3 End |
We shall illustrate the method of linear programming by means of a simple example, giving a combination graphical/numerical solution, and then solve the problem in lpsolve in different ways. This via ASCII files and from different programming languages.
Suppose a farmer has 75 acres on which to plant two crops: wheat and barley. To produce these crops, it costs the farmer (for seed, fertilizer, etc.) $120 per acre for the wheat and $210 per acre for the barley. The farmer has $15000 available for expenses. But after the harvest, the farmer must store the crops while awaiting favourable market conditions. The farmer has storage space for 4000 bushels. Each acre yields an average of 110 bushels of wheat or 30 bushels of barley. If the net profit per bushel of wheat (after all expenses have been subtracted) is $1.30 and for barley is $2.00, how should the farmer plant the 75 acres to maximize profit?
We begin by formulating the problem mathematically. First we express the objective, that is the profit, and the constraints algebraically, then we graph them, and lastly we arrive at the solution by graphical inspection and a minor arithmetic calculation.
Let x denote the number of acres allotted to wheat and y the number of acres allotted to barley. Then the expression to be maximized, that is the profit, is clearly
P = (110)(1.30)x + (30)(2.00)y = 143x + 60y.
There are three constraint inequalities, specified by the limits on expenses, storage and acreage. They are respectively:
120x + 210y <= 15000
110x + 30y <= 4000
x + y <= 75
Strictly speaking there are two more constraint inequalities forced by the fact that the farmer cannot plant a negative number of acres, namely:
x >= 0, y >= 0.
Next we graph the regions specified by the constraints. The last two say that we only need to consider the first quadrant in the x-y plane. Here's a graph delineating the triangular region in the first quadrant determined by the first inequality.
Now let's put in the other two constraint inequalities.
The black area is the solution space that holds valid solutions. This means that any point in this area fulfils the constraints.
Now let's superimpose on top of this picture a contour plot of the objective function P.
The lines give a picture of the objective function. All solutions that intersect with the black area are valid solutions, meaning that this result also fulfils the set constraints. The more the lines go to the right, the higher the objective value is. The optimal solution or best objective is a line that is still in the black area, but with an as large as possible value.
It seems apparent that the maximum value of P will occur on the level curve (that is, level
line) that passes through the vertex of the polygon that lies near (22,53).
It is the intersection of x + y = 75 and 110*x + 30*y = 4000
This is a corner point of the diagram. This is not a coincidence. The simplex algorithm, which is used
by lpsolve, starts from a theorem that the optimal solution is such a corner point.
In fact we can compute the result:
x + y = 75 (1) 110*x + 30*y = 4000 (2)
From (1), y can be expressed in function of x:
y = 75 - x (3)
This equation can be substituted in (2):
110*x + 30*(75 - x) = 4000
Or:
80*x = 1750
Or:
x = 21.875
From (3), y can be derived:
y = 75 - 21.875 = 53.125
The acreage that results in the maximum profit is 21.875 for wheat and 53.125 for barley. In that case the profit is:
P = 143*x + 60*y
Or:
P = 143*21.875 + 60*53.125 = 6326.625That is, $6315.625.
Now, lpsolve comes into the picture to solve this linear programming problem more generally.
First let us show this problem in its mathematical format:
max(143x + 60y) s.t. 120x + 210y <= 15000 110x + 30y <= 4000 x + y <= 75 x >= 0 y >= 0
There are several ways to model a linear problem via lpsolve:
There exist a lot of formats to model an lp problem into. Almost each solver has its format on its own.
The MPS format is supported by most lp solvers and thus very universal. The model is provided to the solver via an ASCII file. This format is very old and difficult to read by humans. See MPS file format for a complete description about the format. This problem is formulated as follows in MPS format:
* model.mps
NAME
ROWS
N R0
L R1
L R2
L R3
COLUMNS
x R0 143.00000000 R1 120.00000000
x R2 110.00000000 R3 1.0000000000
y R0 60.00000000 R1 210.00000000
y R2 30.000000000 R3 1.0000000000
RHS
RHS R1 15000.000000 R2 4000.0000000
RHS R3 75.000000000
ENDATA
Save this as ASCII file with name model.mps
To read this format in lpsolve, the API functions read_mps, read_freemps, read_MPS, read_freeMPS can be used. The lpsolve distribution comes with two applications that use this API call to read a model:
To read this MPS model via the lp_solve command line program and calculate the solution, enter the following command:
lp_solve -max -mps model.mps
This gives:
Value of objective function: 6315.63 Actual values of the variables: x 21.875 y 53.125
The lp_solve program has a lot of options that can be set. See lp_solve command
Under Windows, there is also a graphical IDE that can read an MPS file. See LPSolve IDE for more information.
The lp format is the native lpsolve format to provide LP models via an ASCII file to the solver. It is very readable and its syntax is very similar to the Mathematical formulation. See LP file format for a complete description about the format. This model is formulated as follows in lp-format:
/* model.lp */ max: 143 x + 60 y; 120 x + 210 y <= 15000; 110 x + 30 y <= 4000; x + y <= 75;
Save this as ASCII file with name model.lp
To read this format in lpsolve, the API functions read_lp, read_LP can be used. The lpsolve distribution comes with two applications that use this API call to read a model:
To read this lp model via the lp_solve command line program and calculate the solution, enter the following command:
lp_solve model.lp
This gives:
Value of objective function: 6315.63 Actual values of the variables: x 21.875 y 53.125
The lp_solve program has a lot of options that can be set. See lp_solve command
Under Windows, there is also a graphical IDE that can read an lp-file. See LPSolve IDE for more information.
The CPLEX lp format is another format to provide LP models via an ASCII file to the solver. It is very readable and its syntax is very similar to the Mathematical formulation. It is a format used by the CPLEX solver. See CPLEX lp files for a complete description about the format. This model is formulated as follows in CPLEX lp format:
\* model.lpt *\ Maximize +143 x +60 y Subject To +120 x +210 y <= 15000 +110 x +30 y <= 4000 +x +y <= 75 End
Save this as ASCII file with name model.lpt
lpsolve doesn't has an API call to read/write this format. However, the lpsolve distribution has an XLI that can do this. See External Language Interfaces for a description about XLIs. This uses the API call read_XLI. The xli to read/write this format is xli_CPLEX. The lpsolve distribution comes with two applications that use this API call to read a model:
To read this CPLEX lp model via the lp_solve command line program and calculate the solution, enter the following command:
lp_solve -rxli xli_CPLEX model.lpt
This gives:
Value of objective function: 6315.63 Actual values of the variables: x 21.875 y 53.125
The lp_solve program has a lot of options that can be set. See lp_solve command
Under Windows, there is also a graphical IDE that can read a CPLEX lp file via an XLI. See LPSolve IDE for more information.
The LINDO FILE format is another format to provide LP models via an ASCII file to the solver. It is very readable and its syntax is very similar to the Mathematical formulation. It is a format used by the LINDO solver. See LINDO lp files for a complete description about the format. This model is formulated as follows in LINDO FILE format:
! model.lnd MAXIMIZE +143 x +60 y SUBJECT TO +120 x +210 y <= 15000 +110 x +30 y <= 4000 +x +y <= 75 END
Save this as ASCII file with name model.lpt
lpsolve doesn't has an API call to read/write this format. However, the lpsolve distribution has an XLI that can do this. See External Language Interfaces for a description about XLIs. This uses the API call read_XLI. The xli to read/write this format is xli_LINDO. The lpsolve distribution comes with two applications that use this API call to read a model:
To read this LINDO lp model via the lp_solve command line program and calculate the solution, enter the following command:
lp_solve -rxli xli_LINDO model.lnd
This gives:
Value of objective function: 6315.63 Actual values of the variables: x 21.875 y 53.125
The lp_solve program has a lot of options that can be set. See lp_solve command
Under Windows, there is also a graphical IDE that can read a LINDO lp file via an XLI. See LPSolve IDE for more information.
The GNU MathProg format is another format to provide LP models via an ASCII file to the solver. It is very readable and its syntax is very similar to the Mathematical formulation. It is a format used by the GLPK solver and a subset of AMPL. It has also the possibility to use loops. See Modeling Language GNU MathProg This model is formulated as follows in GNU MathProg format:
/* model.mod */ var x >= 0; var y >= 0; maximize obj: +143*x +60*y; R1: +120*x +210*y <= 15000; R2: +110*x +30*y <= 4000; R3: +x +y <= 75;
Save this as ASCII file with name model.mod
lpsolve doesn't has an API call to read/write this format. However, the lp_solve distribution has an XLI that can do this. See External Language Interfaces for a description about XLIs. This uses the API call read_XLI. The xli to read/write this format is xli_MathProg. The lpsolve distribution comes with two applications that use this API call to read a model:
To read this GNU MathProg model via the lp_solve command line program and calculate the solution, enter the following command:
lp_solve -rxli xli_MathProg model.mod
This gives:
Value of objective function: 6315.63 Actual values of the variables: x 21.875 y 53.125
The lp_solve program has a lot of options that can be set. See lp_solve command
Under Windows, there is also a graphical IDE that can read a GNU MathProg file via an XLI. See LPSolve IDE for more information.
The LPFML XML format is another format to provide LP models via an ASCII file to the solver. This format is very recent and uses XML layout. It is not very readable by us, but because of the XML structure very flexible. See LPFML: A W3C XML Schema for Linear Programming for more information. This model is formulated as follows in LPFML XML format:
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<mathProgram xmlns="http://FML/lpfml.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://FML/lpfml.xsd lpfml.xsd">
<linearProgramDescription>
<source></source>
<maxOrMin>max</maxOrMin>
<numberRows>3</numberRows>
<numberVars>2</numberVars>
</linearProgramDescription>
<linearProgramData>
<rows>
<row rowName="R1" rowUB="15000"/>
<row rowName="R2" rowUB="4000"/>
<row rowName="R3" rowUB="75"/>
</rows>
<columns>
<col colName="x" colType="C" objVal="143"/>
<col colName="y" colType="C" objVal="60"/>
</columns>
<amatrix>
<sparseMatrix>
<pntANonz>
<el>3</el>
<el>6</el>
</pntANonz>
<rowIdx>
<el>0</el>
<el>1</el>
<el>2</el>
<el>0</el>
<el>1</el>
<el>2</el>
</rowIdx>
<nonz>
<el>120</el>
<el>110</el>
<el>1</el>
<el>210</el>
<el>30</el>
<el>1</el>
</nonz>
</sparseMatrix>
</amatrix>
</linearProgramData>
</mathProgram>
Save this as ASCII file with name model.xml
lpsolve doesn't has an API call to read/write this format. However, the lp_solve distribution has an XLI that can do this. See External Language Interfaces for a description about XLIs. This uses the API call read_XLI. The xli to read/write this format is xli_LPFML. The lpsolve distribution comes with two applications that use this API call to read a model:
To read this LPFML XML model via the lp_solve command line program and calculate the solution, enter the following command:
lp_solve -rxli xli_LPFML model.xml
This gives:
Value of objective function: 6315.63 Actual values of the variables: x 21.875 y 53.125
The lp_solve program has a lot of options that can be set. See lp_solve command
Under Windows, there is also a graphical IDE that can read a LPFML XML file via an XLI. See LPSolve IDE for more information.
There are several commercial and free Mathematical programming applications out there which can be used to solve lp problems. An lpsolve driver is made for several of them:
In several cases it is required that the solver is called from within the programming language in which an application is build. All the data is in memory and no files are created to provide data to the solver. lpsolve has a very rich, yet easy, API to do this. See lp_solve API reference for an overview of the API. lpsolve is a library of API routines. This library is called from the programming language. See Calling the lpsolve API from your application for more information. Above example is now formulated in several programming languages:
The example model can be formulated as follows in C:
/* demo.c */
#include "lp_lib.h"
int demo()
{
lprec *lp;
int Ncol, *colno = NULL, j, ret = 0;
REAL *row = NULL;
/* We will build the model row by row
So we start with creating a model with 0 rows and 2 columns */
Ncol = 2; /* there are two variables in the model */
lp = make_lp(0, Ncol);
if(lp == NULL)
ret = 1; /* couldn't construct a new model... */
if(ret == 0) {
/* let us name our variables. Not required, but can be useful for debugging */
set_col_name(lp, 1, "x");
set_col_name(lp, 2, "y");
/* create space large enough for one row */
colno = (int *) malloc(Ncol * sizeof(*colno));
row = (REAL *) malloc(Ncol * sizeof(*row));
if((colno == NULL) || (row == NULL))
ret = 2;
}
if(ret == 0) {
set_add_rowmode(lp, TRUE); /* makes building the model faster if it is done rows by row */
/* construct first row (120 x + 210 y <= 15000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 120;
colno[j] = 2; /* second column */
row[j++] = 210;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 15000))
ret = 3;
}
if(ret == 0) {
/* construct second row (110 x + 30 y <= 4000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 110;
colno[j] = 2; /* second column */
row[j++] = 30;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 4000))
ret = 3;
}
if(ret == 0) {
/* construct third row (x + y <= 75) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 1;
colno[j] = 2; /* second column */
row[j++] = 1;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 75))
ret = 3;
}
if(ret == 0) {
set_add_rowmode(lp, FALSE); /* rowmode should be turned off again when done building the model */
/* set the objective function (143 x + 60 y) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 143;
colno[j] = 2; /* second column */
row[j++] = 60;
/* set the objective in lpsolve */
if(!set_obj_fnex(lp, j, row, colno))
ret = 4;
}
if(ret == 0) {
/* set the object direction to maximize */
set_maxim(lp);
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
write_LP(lp, stdout);
/* write_lp(lp, "model.lp"); */
/* I only want to see important messages on screen while solving */
set_verbose(lp, IMPORTANT);
/* Now let lpsolve calculate a solution */
ret = solve(lp);
if(ret == OPTIMAL)
ret = 0;
else
ret = 5;
}
if(ret == 0) {
/* a solution is calculated, now lets get some results */
/* objective value */
printf("Objective value: %f\n", get_objective(lp));
/* variable values */
get_variables(lp, row);
for(j = 0; j < Ncol; j++)
printf("%s: %f\n", get_col_name(lp, j + 1), row[j]);
/* we are done now */
}
/* free allocated memory */
if(row != NULL)
free(row);
if(colno != NULL)
free(colno);
if(lp != NULL) {
/* clean up such that all used memory by lpsolve is freed */
delete_lp(lp);
}
return(ret);
}
int main()
{
demo();
}
When this is run, the following is shown on screen:
/* Objective function */ max: +143 x +60 y; /* Constraints */ +120 x +210 y <= 15000; +110 x +30 y <= 4000; +x +y <= 75; Objective value: 6315.625000 x: 21.875000 y: 53.125000
Note that this example is very limited. It is also possible to set bounds on variables, ranges on constraints, define variables as integer, get more result information, changing solver options and parameters and much more. See lp_solve API reference for an overview of the API to do this.
The example model can be formulated as follows in Java:
/* demo.java */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import lpsolve.*;
public class Demo {
public Demo() {
}
public int execute() throws LpSolveException {
LpSolve lp;
int Ncol, j, ret = 0;
/* We will build the model row by row
So we start with creating a model with 0 rows and 2 columns */
Ncol = 2; /* there are two variables in the model */
/* create space large enough for one row */
int[] colno = new int[Ncol];
double[] row = new double[Ncol];
lp = LpSolve.makeLp(0, Ncol);
if(lp.getLp() == 0)
ret = 1; /* couldn't construct a new model... */
if(ret == 0) {
/* let us name our variables. Not required, but can be useful for debugging */
lp.setColName(1, "x");
lp.setColName(2, "y");
lp.setAddRowmode(true); /* makes building the model faster if it is done rows by row */
/* construct first row (120 x + 210 y <= 15000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 120;
colno[j] = 2; /* second column */
row[j++] = 210;
/* add the row to lpsolve */
lp.addConstraintex(j, row, colno, LpSolve.LE, 15000);
}
if(ret == 0) {
/* construct second row (110 x + 30 y <= 4000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 110;
colno[j] = 2; /* second column */
row[j++] = 30;
/* add the row to lpsolve */
lp.addConstraintex(j, row, colno, LpSolve.LE, 4000);
}
if(ret == 0) {
/* construct third row (x + y <= 75) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 1;
colno[j] = 2; /* second column */
row[j++] = 1;
/* add the row to lpsolve */
lp.addConstraintex(j, row, colno, LpSolve.LE, 75);
}
if(ret == 0) {
lp.setAddRowmode(false); /* rowmode should be turned off again when done building the model */
/* set the objective function (143 x + 60 y) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 143;
colno[j] = 2; /* second column */
row[j++] = 60;
/* set the objective in lpsolve */
lp.setObjFnex(j, row, colno);
}
if(ret == 0) {
/* set the object direction to maximize */
lp.setMaxim();
/* just out of curioucity, now generate the model in lp format in file model.lp */
lp.writeLp("model.lp");
/* I only want to see important messages on screen while solving */
lp.setVerbose(LpSolve.IMPORTANT);
/* Now let lpsolve calculate a solution */
ret = lp.solve();
if(ret == LpSolve.OPTIMAL)
ret = 0;
else
ret = 5;
}
if(ret == 0) {
/* a solution is calculated, now lets get some results */
/* objective value */
System.out.println("Objective value: " + lp.getObjective());
/* variable values */
lp.getVariables(row);
for(j = 0; j < Ncol; j++)
System.out.println(lp.getColName(j + 1) + ": " + row[j]);
/* we are done now */
}
/* clean up such that all used memory by lpsolve is freed */
if(lp.getLp() != 0)
lp.deleteLp();
return(ret);
}
public static void main(String[] args) {
try {
new Demo().execute();
}
catch (LpSolveException e) {
e.printStackTrace();
}
}
}
When this is run, the following is shown on screen:
Objective value: 6315.625 x: 21.875000000000007 y: 53.12499999999999
And a file model.lp is created with the following contents:
/* Objective function */ max: +143 x +60 y; /* Constraints */ +120 x +210 y <= 15000; +110 x +30 y <= 4000; +x +y <= 75;
Note that this example is very limited. It is also possible to set bounds on variables, ranges on constraints, define variables as integer, get more result information, changing solver options and parameters and much more. See lp_solve API reference for an overview of the API to do this.
Also note that the API names in Java are a bit different than in the native lpsolve API and the lp argument is not there. See the lpsolve Java wrapper documentation for more details.
The example model can be formulated as follows in Delphi or Free Pascal:
program demo;
{$APPTYPE CONSOLE}
uses
SysUtils,
lpsolve;
var
Ncol, j, ret: integer;
colno: PIntArray;
row: PFloatArray;
lp: THandle;
begin
ret := 0;
colno := nil;
row := nil;
(* We will build the model row by row
So we start with creating a model with 0 rows and 2 columns *)
Ncol := 2; (* there are two variables in the model *)
lp := make_lp(0, Ncol);
if (lp = 0) then
ret := 1; (* couldn't construct a new model... *)
(* let us name our variables. Not required, but can be usefull for debugging *)
set_col_name(lp, 1, 'x');
set_col_name(lp, 2, 'y');
if (ret = 0) then
begin
(* create space large enough for one row *)
GetMem(colno, SizeOf(integer) * Ncol);
GetMem(row, SizeOf(double) * Ncol);
if ((colno = nil) or (row = nil)) then
ret := 2;
end;
if (ret = 0) then
begin
set_add_rowmode(lp, true); (* makes building the model faster if it is done rows by row *)
(* construct first row (120 x + 210 y <= 15000) *)
j := 0;
colno^[j] := 1; (* first column *)
row^[j] := 120;
j := j + 1;
colno^[j] := 2; (* second column *)
row^[j] := 210;
j := j + 1;
(* add the row to lp_solve *)
if (not add_constraintex(lp, j, row, colno, LE, 15000)) then
ret := 3;
end;
if (ret = 0) then
begin
(* construct second row (110 x + 30 y <= 4000) *)
j := 0;
colno^[j] := 1; (* first column *)
row^[j] := 110;
j := j + 1;
colno^[j] := 2; (* second column *)
row^[j] := 30;
j := j + 1;
(* add the row to lp_solve *)
if (not add_constraintex(lp, j, row, colno, LE, 4000)) then
ret := 3;
end;
if (ret = 0) then
begin
(* construct third row (x + y <= 75) *)
j := 0;
colno^[j] := 1; (* first column *)
row^[j] := 1;
j := j + 1;
colno^[j] := 2; (* second column *)
row^[j] := 1;
j := j + 1;
(* add the row to lp_solve *)
if (not add_constraintex(lp, j, row, colno, LE, 75)) then
ret := 3;
end;
if (ret = 0) then
begin
set_add_rowmode(lp, false); (* rowmode should be turned off again when done building the model *)
(* set the objective function (143 x + 60 y) *)
j := 0;
colno^[j] := 1; (* first column *)
row^[j] := 143;
j := j + 1;
colno^[j] := 2; (* second column *)
row^[j] := 60;
j := j + 1;
(* set the objective in lp_solve *)
if (not set_obj_fnex(lp, j, row, colno)) then
ret := 4;
end;
if (ret = 0) then
begin
(* set the object direction to maximize *)
set_maxim(lp);
(* just out of curioucity, now show the model in lp format *)
write_lp(lp, 'model.lp');
(* I only want to see importand messages on screen while solving *)
set_verbose(lp, IMPORTANT);
(* Now let lp_solve calculate a solution *)
ret := solve(lp);
if (ret = OPTIMAL) then
ret := 0
else
ret := 5;
end;
if (ret = 0) then
begin
(* a solution is calculated, now lets get some results *)
(* objective value *)
writeln(format('Objective value: %f', [get_objective(lp)]));
(* variable values *)
get_variables(lp, row);
for j := 0 to Ncol-1 do
writeln(format('%s: %f', [get_col_name(lp, j + 1), row^[j]]));
(* we are done now *)
end;
(* free allocated memory *)
if (row <> nil) then
FreeMem(row);
if (colno <> nil) then
FreeMem(colno);
if(lp <> 0) then
begin
(* clean up such that all used memory by lp_solve is freeed *)
delete_lp(lp);
end;
end.
When this is run, the following is shown:
Objective value: 6315.63 x: 21.88 y: 53.12
And a file model.lp is created with the following contents:
/* Objective function */ max: +143 x +60 y; /* Constraints */ +120 x +210 y <= 15000; +110 x +30 y <= 4000; +x +y <= 75;
Note that a unit lpsolve.pas+lpsolve.inc is needed for this to work. This is available via the Delphi example.
Note that this example is very limited. It is also possible to set bounds on variables, ranges on constraints, define variables as integer, get more result information, changing solver options and parameters and much more. See lp_solve API reference for an overview of the API to do this.
The example model can be formulated as follows in VB or VBScript:
Option Explicit
'demo
Private lpsolve As lpsolve55
Sub Main()
Set lpsolve = New lpsolve55
lpsolve.Init "."
Demo
Set lpsolve = Nothing
End Sub
Private Function Demo() As Integer
Dim lp As Long
Dim Ncol As Long, colno() As Long
Dim j As Integer, ret As Integer
Dim row() As Double
With lpsolve
' We will build the model row by row
' So we start with creating a model with 0 rows and 2 columns
Ncol = 2 ' there are two variables in the model
lp = .make_lp(0, Ncol)
If lp = 0 Then
ret = 1 ' couldn't construct a new model...
End If
If ret = 0 Then
' let us name our variables. Not required, but can be useful for debugging
.set_col_name lp, 1, "x"
.set_col_name lp, 2, "y"
' create space large enough for one row
ReDim colno(0 To Ncol - 1)
ReDim row(0 To Ncol - 1)
End If
If ret = 0 Then
.set_add_rowmode lp, True ' makes building the model faster if it is done rows by row
' construct first row (120 x + 210 y <= 15000)
j = 0
colno(j) = 1 ' first column
row(j) = 120
j = j + 1
colno(j) = 2 ' second column
row(j) = 210
j = j + 1
' add the row to lpsolve
If .add_constraintex(lp, j, row(0), colno(0), LE, 15000) = False Then
ret = 3
End If
End If
If ret = 0 Then
' construct second row (110 x + 30 y <= 4000)
j = 0
colno(j) = 1 ' first column
row(j) = 110
j = j + 1
colno(j) = 2 ' second column
row(j) = 30
j = j + 1
' add the row to lpsolve
If .add_constraintex(lp, j, row(0), colno(0), LE, 4000) = False Then
ret = 3
End If
End If
If ret = 0 Then
' construct third row (x + y <= 75)
j = 0
colno(j) = 1 ' first column
row(j) = 1
j = j + 1
colno(j) = 2 ' second column
row(j) = 1
j = j + 1
' add the row to lpsolve
If .add_constraintex(lp, j, row(0), colno(0), LE, 75) = False Then
ret = 3
End If
End If
If ret = 0 Then
.set_add_rowmode lp, False ' rowmode should be turned off again when done building the model
' set the objective function (143 x + 60 y)
j = 0
colno(j) = 1 ' first column
row(j) = 143
j = j + 1
colno(j) = 2 ' second column
row(j) = 60
j = j + 1
' set the objective in lpsolve
If .set_obj_fnex(lp, j, row(0), colno(0)) = False Then
ret = 4
End If
End If
If ret = 0 Then
' set the object direction to maximize
.set_maxim lp
' just out of curioucity, now show the model in lp format on screen
' this only works if this is a console application. If not, use write_lp and a filename
.write_lp lp, "model.lp"
' I only want to see important messages on screen while solving
.set_verbose lp, 3
' Now let lpsolve calculate a solution
ret = .solve(lp)
If ret = OPTIMAL Then
ret = 0
Else
ret = 5
End If
End If
If ret = 0 Then
' a solution is calculated, now lets get some results
' objective value
Debug.Print "Objective value: " & .get_objective(lp)
' variable values
.get_variables lp, row(0)
For j = 1 To Ncol
Debug.Print .get_col_name(lp, j) & ": " & row(j - 1)
Next
' we are done now
End If
' free allocated memory
Erase row
Erase colno
If lp <> 0 Then
' clean up such that all used memory by lpsolve is freed
.delete_lp lp
End If
Demo = ret
End With
End Function
When this is run, the following is shown in the debug window:
Objective value: 6315.625 x: 21.875 y: 53.125
And a file model.lp is created with the following contents:
/* Objective function */ max: +143 x +60 y; /* Constraints */ +120 x +210 y <= 15000; +110 x +30 y <= 4000; +x +y <= 75;
Note that a class lpsolve55.cls or the lpsolve55 COM object is needed for this to work. The class is available via the VB example and the COM object is also available.
Note that this example is very limited. It is also possible to set bounds on variables, ranges on constraints, define variables as integer, get more result information, changing solver options and parameters and much more. See lp_solve API reference for an overview of the API to do this.
The example model can be formulated as follows in VB.NET:
Option Strict Off
Option Explicit On
Module Module1
'demo
Private lpsolve As lpsolve55
Public Sub Main()
lpsolve = New lpsolve55
lpsolve.Init(".")
Demo()
lpsolve = Nothing
End Sub
Private Function Demo() As Integer
Dim lp As Integer
Dim Ncol As Integer
Dim colno() As Integer
Dim j, ret As Short
Dim row() As Double
With lpsolve
' We will build the model row by row
' So we start with creating a model with 0 rows and 2 columns
Ncol = 2 ' there are two variables in the model
lp = .make_lp(0, Ncol)
If lp = 0 Then
ret = 1 ' couldn't construct a new model...
End If
If ret = 0 Then
' let us name our variables. Not required, but can be useful for debugging
.set_col_name(lp, 1, "x")
.set_col_name(lp, 2, "y")
' create space large enough for one row
ReDim colno(Ncol - 1)
ReDim row(Ncol - 1)
End If
If ret = 0 Then
.set_add_rowmode(lp, True) ' makes building the model faster if it is done rows by row
' construct first row (120 x + 210 y <= 15000)
j = 0
colno(j) = 1 ' first column
row(j) = 120
j = j + 1
colno(j) = 2 ' second column
row(j) = 210
j = j + 1
' add the row to lpsolve
If .add_constraintex(lp, j, row(0), colno(0), lpsolve55.lpsolve_constr_types.LE, 15000) = False Then
ret = 3
End If
End If
If ret = 0 Then
' construct second row (110 x + 30 y <= 4000)
j = 0
colno(j) = 1 ' first column
row(j) = 110
j = j + 1
colno(j) = 2 ' second column
row(j) = 30
j = j + 1
' add the row to lpsolve
If .add_constraintex(lp, j, row(0), colno(0), lpsolve55.lpsolve_constr_types.LE, 4000) = False Then
ret = 3
End If
End If
If ret = 0 Then
' construct third row (x + y <= 75)
j = 0
colno(j) = 1 ' first column
row(j) = 1
j = j + 1
colno(j) = 2 ' second column
row(j) = 1
j = j + 1
' add the row to lpsolve
If .add_constraintex(lp, j, row(0), colno(0), lpsolve55.lpsolve_constr_types.LE, 75) = False Then
ret = 3
End If
End If
If ret = 0 Then
.set_add_rowmode(lp, False) ' rowmode should be turned off again when done building the model
' set the objective function (143 x + 60 y)
j = 0
colno(j) = 1 ' first column
row(j) = 143
j = j + 1
colno(j) = 2 ' second column
row(j) = 60
j = j + 1
' set the objective in lpsolve
If .set_obj_fnex(lp, j, row(0), colno(0)) = False Then
ret = 4
End If
End If
If ret = 0 Then
' set the object direction to maximize
.set_maxim(lp)
' just out of curioucity, now show the model in lp format on screen
' this only works if this is a console application. If not, use write_lp and a filename
.write_lp(lp, "model.lp")
' I only want to see important messages on screen while solving
.set_verbose(lp, 3)
' Now let lpsolve calculate a solution
ret = .solve(lp)
If ret = lpsolve55.lpsolve_return.OPTIMAL Then
ret = 0
Else
ret = 5
End If
End If
If ret = 0 Then
' a solution is calculated, now lets get some results
' objective value
System.Diagnostics.Debug.WriteLine("Objective value: " & .get_objective(lp))
' variable values
.get_variables(lp, row(0))
For j = 1 To Ncol
System.Diagnostics.Debug.WriteLine(.get_col_name(lp, j) & ": " & row(j - 1))
Next
' we are done now
End If
' free allocated memory
Erase row
Erase colno
If lp <> 0 Then
' clean up such that all used memory by lpsolve is freed
.delete_lp(lp)
End If
Demo = ret
End With
End Function
End Module
When this is run, the following is shown in the debug window:
Objective value: 6315.625 x: 21.875 y: 53.125
And a file model.lp is created with the following contents:
/* Objective function */ max: +143 x +60 y; /* Constraints */ +120 x +210 y <= 15000; +110 x +30 y <= 4000; +x +y <= 75;
Note that a class lpsolve55.vb is needed for this to work. The class is available via the VB.NET example.
Note that this example is very limited. It is also possible to set bounds on variables, ranges on constraints, define variables as integer, get more result information, changing solver options and parameters and much more. See lp_solve API reference for an overview of the API to do this.
The example model can be formulated as follows in C#.NET:
using System.Windows.Forms;
using lpsolve55;
/* demo.cs */
namespace demo
{
public class demo
{
public static void Main()
{
lpsolve.Init(".");
Demo();
}
private static int Demo()
{
int lp;
int Ncol;
int[] colno;
int j, ret = 0;
double[] row;
/* We will build the model row by row */
/* So we start with creating a model with 0 rows and 2 columns */
Ncol = 2; /* there are two variables in the model */
lp = lpsolve.make_lp(0, Ncol);
if (lp == 0)
ret = 1; /* couldn't construct a new model... */
if (ret == 0) {
/* let us name our variables. Not required, but can be useful for debugging */
lpsolve.set_col_name(lp, 1, "x");
lpsolve.set_col_name(lp, 2, "y");
}
/* create space large enough for one row */
colno = new int[Ncol];
row = new double[Ncol];
if (ret == 0) {
lpsolve.set_add_rowmode(lp, true); /* makes building the model faster if it is done rows by row */
/* construct first row (120 x + 210 y <= 15000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 120;
colno[j] = 2; /* second column */
row[j++] = 210;
/* add the row to lpsolve */
if (lpsolve.add_constraintex(lp, j, ref row[0], ref colno[0], lpsolve.lpsolve_constr_types.LE, 15000) == false)
ret = 3;
}
if (ret == 0) {
/* construct second row (110 x + 30 y <= 4000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 110;
colno[j] = 2; /* second column */
row[j++] = 30;
/* add the row to lpsolve */
if (lpsolve.add_constraintex(lp, j, ref row[0], ref colno[0], lpsolve.lpsolve_constr_types.LE, 4000) == false)
ret = 3;
}
if (ret == 0) {
/* construct third row (x + y <= 75) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 1;
colno[j] = 2; /* second column */
row[j++] = 1;
/* add the row to lpsolve */
if (lpsolve.add_constraintex(lp, j, ref row[0], ref colno[0], lpsolve.lpsolve_constr_types.LE, 75) == false)
ret = 3;
}
if (ret == 0) {
lpsolve.set_add_rowmode(lp, false); /* rowmode should be turned off again when done building the model */
/* set the objective function (143 x + 60 y) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 143;
colno[j] = 2; /* second column */
row[j++] = 60;
/* set the objective in lpsolve */
if (lpsolve.set_obj_fnex(lp, j, ref row[0], ref colno[0]) == false)
ret = 4;
}
if (ret == 0) {
lpsolve.lpsolve_return s;
/* set the object direction to maximize */
lpsolve.set_maxim(lp);
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
lpsolve.write_lp(lp, "model.lp");
/* I only want to see important messages on screen while solving */
lpsolve.set_verbose(lp, 3);
/* Now let lpsolve calculate a solution */
s = lpsolve.solve(lp);
if (s == lpsolve.lpsolve_return.OPTIMAL)
ret = 0;
else
ret = 5;
}
if (ret == 0) {
/* a solution is calculated, now lets get some results */
/* objective value */
System.Diagnostics.Debug.WriteLine("Objective value: " + lpsolve.get_objective(lp));
/* variable values */
lpsolve.get_variables(lp, ref row[0]);
for(j = 0; j < Ncol; j++)
System.Diagnostics.Debug.WriteLine(lpsolve.get_col_name(lp, j + 1) + ": " + row[j]);
/* we are done now */
}
/* free allocated memory */
if (lp != 0) {
/* clean up such that all used memory by lpsolve is freed */
lpsolve.delete_lp(lp);
}
return(ret);
} //Demo
}
}
When this is run, the following is shown in the debug window:
Objective value: 6315.625 x: 21.875 y: 53.125
And a file model.lp is created with the following contents:
/* Objective function */ max: +143 x +60 y; /* Constraints */ +120 x +210 y <= 15000; +110 x +30 y <= 4000; +x +y <= 75;
Note that a class lpsolve55.cs is needed for this to work. The class is available via the CS.NET example.
Note that this example is very limited. It is also possible to set bounds on variables, ranges on constraints, define variables as integer, get more result information, changing solver options and parameters and much more. See lp_solve API reference for an overview of the API to do this.
docs/5.5/quickstart.htm 0000644 0001750 0001750 00000021266 11306036626 013677 0 ustar rene rene
Quick Startlp_solve (or lpsolve) has allot of features in-house. For a beginner, it can be difficult to determine where to start. The distribution contains many files and to start with, you need only a couple of them. As you learn the package you may need extras. This text explains how to start with lp_solve. Skip the blabla, just give me a very quick start.How to call lp_solveBasically, lp_solve is a library, a set of routines, called the API that can be called from almost any programming language to solve MILP problems. There are several ways to pass the data to the library:
Via the APIThe API is a set of routines that can be called from a programming language to build the model in memory, solve it and return the results. There are many API routines to perform many possible tasks and set several options. See lp_solve API reference for an overview.Via input filesStandard, lp_solve supports several input files types.
The common known MPS format (see mps-format) is supported by most solvers, but
it is not very readable for humans. Another format is the lp format (see lp-format)
that is more readable. lp_solve has the unique ability to use user-written routines to input the model
(see External Language Interface).
See read_mps, read_freemps, read_MPS, read_freeMPS and read_lp, read_LP for
the API calls to read the model from file. Via an IDEThanks to Henri Gourvest, there is now also an IDE program called LPSolve IDE that uses the API to provide a Windows application to solve models. See LPSolve IDE for its usage. With this program you don't have to know anything of API or computer programming languages. You can just provide your model to the program and it will solve the model and give you the result. As already stated, lp_solve can be called from many programming language. Among them are C, C++, Pascal, Delphi, Java, VB, C#, VB.NET, Excel. But let this list not be a limitation. Any programming language capable of calling external libraries (DLLs under Windows, Shared libraries (.so) under Unix/Linux) can call lp_solve. Some key features of lp_solve
Quick quick startFormulating a problemIf you don't know much about linear programming, first take a look at Formulation of an lp problem in lpsolve. Start with reading the first part where a practical example is presented until the point where the formulation is given in mathematical format, then return to here. This practical example is used in the next presentations. Solve a problem via the IDEThe easiest way to start with lp_solve is via the IDE. This only works under Windows. See LPSolve IDE. Solve a problem via the lp_solve command line programAnother way to solve a model is via the lp_solve command line program. This works on any platform, but is completely command-line driven. Well known by Unix/Linux shell programmers and DOS box users. See lp_solve command. solve a problem via the APIProgrammers want to call lp_solve in a totally different way. They want to call lp_solve as a library directly from their programming language. This is what is called the API (Application Programming Interface). See Calling the lpsolve API from your application and Construct the model from a Programming Language. An overview of the complete API can be found on: lp_solve API reference. Compile the source code yourselfThe distribution contains precompiled libraries/binaries for Windows and Linux. However lp_solve can be compiled on other platforms also. You may also to make modifications to it and then you have to recompile also, even on the precompiled platforms. See Calling the lpsolve API from your application. In this article it is both explained how to link your code to the library and how to compile the lp_solve code. Basis Factorization PackagesAlternative inverse/re-factorization libraries can be used by lp_solve. This is a feature for the more experienced users of lp_solve. See Basis Factorization Packages for more information. The sources of these packages are in the lp_solve_5.5.0.13_bfp_*_source.tar.gz archives. The binaries are in the lp_solve_5.5.0.13_exe* archive. External Language InterfacesAlternative model readers and writers possible via the XLI implementation. Models expressed in format files other than lp or MPS format can also be read or written by lp_solve via this unique feature. See External Language Interfaces for more information. The sources of these packages are in the lp_solve_5.5.0.13_xli_*_source.tar.gz archives. The binaries are in the lp_solve_5.5.0.13_exe* archive. Calling lp_solve from higher level Mathematical languages.lp_solve can be called from AMPL, MATLAB, O-Matrix, Scilab, Octave, Python, R.You now have a pretty good idea what lp_solve is about. |
get_objectiveReturns the value of the objective function. REAL get_objective(lprec *lp); Return Value get_objective returns the value of the objective. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_objective function returns the value of the objective of the last
solve. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_feasible, get_variables, get_ptr_variables, get_working_objective, get_constraints, get_ptr_constraints, get_constr_value, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex |
is_obj_in_basisReturns if the objective is in the matrix or not. unsigned char is_obj_in_basis(lprec *lp); Return Value is_obj_in_basis returns if the objective is in the matrix or not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The is_obj_in_basis function returns if the objective is in the matrix or not. By default, the objective function is stored as the top row in the constraint matrix When this function is called with obj_in_basis = FALSE then it is moved out into separate storage. When out of the basis, the computation of reduced costs is somewhat slower. In the late versions of v5.5, there is now the option to calculate reduced cost in the textbook way, i.e. completely independently of the basis. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_obj_in_basis |
get_presolveReturns if a presolve must be done before solving. int get_presolve(lprec *lp); Return Value get_presolve returns the current presolve setting. Can by the combination (OR) of any of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_presolve function returns if a presolve must be done before
solving. Presolve looks at the model and tries to simplify it so that solving
times are shorter. For example a constraint on only one variable is converted
to a bound on this variable (and the constraint is deleted). Note that the
model dimensions can change because of this, so be careful with this. Both rows
and columns can be deleted by the presolve. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_presolveloops, set_presolve, is_presolve |
set_epslevelThis is a simplified way of specifying multiple eps thresholds that are "logically" consistent. unsigned char set_epslevel(lprec *lp, int epslevel); Return Value Returns TRUE if level accepted and FALSE if an incalid epsilon level was provided. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI epslevel Can by any of the following values:
Remarks This is a simplified way of specifying multiple eps thresholds that are "logically" consistent. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_epsel, set_epsb, set_epsd, set_epspivot, set_epsint, set_mip_gap |
Developed at INRIA, Scilab has been developed for system control and signal processing applications. It is freely distributed in source code format.
Scilab is made of three distinct parts: an interpreter, libraries of functions (Scilab procedures) and libraries of Fortran and C routines. These routines (which, strictly speaking, do not belong to Scilab but are interactively called by the interpreter) are of independent interest and most of them are available through Netlib. A few of them have been slightly modified for better compatibility with Scilab's interpreter. A key feature of the Scilab syntax is its ability to handle matrices: basic matrix manipulations such as concatenation, extraction or transpose are immediately performed as well as basic operations such as addition or multiplication. Scilab also aims at handling more complex objects than numerical matrices. For instance, control people may want to manipulate rational or polynomial transfer matrices. This is done in Scilab by manipulating lists and typed lists which allows a natural symbolic representation of complicated mathematical objects such as transfer functions, linear systems or graphs.
Polynomials, polynomials matrices and transfer matrices are also defined and the syntax used for manipulating these matrices is identical to that used for manipulating constant vectors and matrices.
Scilab provides a variety of powerful primitives for the analysis of non-linear systems. Integration of explicit and implicit dynamic systems can be accomplished numerically. The scicos toolbox allows the graphic definition and simulation of complex interconnected hybrid systems.
Scilab has an open programming environment where the creation of functions and libraries of functions is completely in the hands of the user. Functions are recognized as data objects in Scilab and, thus, can be manipulated or created as other data objects. For example, functions can be defined inside Scilab and passed as input or output arguments of other functions.
In addition Scilab supports a character string data type which, in particular, allows the on-line creation of functions. Matrices of character strings are also manipulated with the same syntax as ordinary matrices.
Finally, Scilab is easily interfaced with Fortran or C subprograms. This allows use of standardized packages and libraries in the interpreted environment of Scilab.
The general philosophy of Scilab is to provide the following sort of computing environment:
We will not discuss the specifics of Scilab here but instead refer the reader to the Scilab website and documentation.
lpsolve is callable from Scilab via an external interface. As such, it looks like lpsolve is fully integrated with Scilab. Matrices can directly be transferred between Scilab and lpsolve in both directions. The complete interface is written in C so it has maximum performance. The whole lpsolve API is implemented with some extra's specific for Scilab (especially for matrix support). So you have full control to the complete lpsolve functionality via the sclpsolve Scilab driver. If you find that this involves too much work to solve an lp model then you can also work via higher-level scripts that can make things a lot easier. See further in this article.
Compile and build sclpsolve:
----------------------------
1. Get the needed sources and libraries:
Archive lp_solve_5.5.0.13_scilab_source.tar.gz contains the sources to build sclpsolve.
Uncompress it to a directory, for example d:\lp_solve. Make sure that the folder structure is kept.
It will create a directory structure lp_solve_5.5\extra\scilab\lpsolve in that folder.
Archive lp_solve_5.5.0.13_dev.zip (Windows) or lp_solve_5.5.0.13_dev.tar.gz (Unix) contains
needed libraries and include files to link the sources with.
Uncompress it to the same folder as for the sources, appended with lp_solve_5.5.
In this example that would be d:\lp_solve\lp_solve_5.5
You have now all needed files in place.
In your chosen directory (in this example d:\lp_solve) there will only be a directory lp_solve_5.5
In this directory, you have a directory extra and some files ending with .h and .lib
The extra directory contains a scilab directory which contains a directory lpsolve with some files and directories.
2. Under Windows, the Microsoft Visual C/C++ compiler must be installed
and the environment variables must be active so that when a command prompt
is opened, the cl and nmake commands can be executed. This can be done also by opening
a command prompt and execute the batch file VCVARS32.BAT (somewhere on your system)
and then starting scilab from that same command prompt.
Under Unix/Linux, the standard c compiler is used so no special things must be done.
3. Edit the file Path.incl (under lp_solve_5.5\extra\scilab\lpsolve) and change pathnames as needed:
SCIDIR and SCIDIR1: two times the folder where scilab is installed. For example F:\Program Files\scilab-4.1.2
LPSOLVEDIR and LPSOLVELIBDIR: the folder where you uncompressed the scilab source archive into appened with \lp_solve_5.5.
In this example d:\lp_solve\lp_solve_5.5
4. Start Scilab
5. Check under Scilab that the current directory is the lpsolve directory.
Use the Scilab pwd command to show the current directory.
With the chdir command, you can change the current directory.
This current directory must be lp_solve_5.5/extra/scilab/lpsolve
example: chdir('d:/lp_solve/lp_solve_5.5/extra/scilab/lpsolve')
6. To compile and build sclpsolve, enter the following command in Scilab:
-->exec builder.sce
This should be done once to build the sclpsolve driver and to produce
the file loader.sce.
Load the sclpsolve driver in the Scilab memory space:
-----------------------------------------------------
1. Under Windows, make sure that the lpsolve55.dll file is somewhere in the path
Under Unix/Linux, make sure that the liblpsolve55.so shared library is in /usr/lib
or /lib so that Unix can find it.
They are in archives lp_solve_5.5.0.13_dev.zip/lp_solve_5.5.0.13_dev.tar.gz and were
installed in the lp_solve_5.5 directory of step 1 of the previous procedure.
2. It is required that the sclpsolve driver is first build.
That must be done only once. So if you haven't taken the steps yet
to build the sclpsolve driver, then do this first as described previously in
'Compile and build sclpsolve'
3. Start Scilab
4. Check under Scilab that the current directory is the lpsolve directory.
Use the Scilab pwd command to show the current directory.
With the chdir command, you can change the current directory.
This current directory must be lp_solve_5.5/extra/scilab/lpsolve
example: chdir('/lp_solve/lp_solve_5.5/extra/scilab/lpsolve')
5. Enter the following command in Scilab:
-->exec loader.sce
To make this possible, a driver program is needed: sclpsolve (sclpsolve.dll under Windows, sclpsolve.a under Unix/Linux). This driver must be put in a directory known to Scilab and Scilab can call the sclpsolve solver.
This driver calls lpsolve via the lpsolve shared library (lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux) (in archive lp_solve_5.5.0.13_dev.zip/lp_solve_5.5.0.13_dev.tar.gz). This has the advantage that the sclpsolve driver doesn't have to be recompiled when an update of lpsolve is provided. For Windows, the lpsolve55.dll file must be somewhere in the path. For Unix, the lpsolve shared library (liblpsolve55.so) must be in the /usr/lib or /lib directory.
So note the difference between the Scilab lpsolve driver that is called sclpsolve and the lpsolve library that implements the API that is called lpsolve55.
There are also some Scilab script files (*.sce, *.sci) as a quick start.
The first thing that must be done, each time Scilab is restarted and you want to use lpsolve is load the sclpsolve driver into the Scilab workspace. This can be done via the script loader.sce. The following command must be used to load the driver:
exec loader.sce
It is assumed here that the current directory is the Scilab lpsolve directory (lp_solve_5.5/extra/scilab/lpsolve), but this is not a requirement. You can also provide the full path to the script files. The current directory can be shown via the pwd command in Scilab:
pwd
That is basically all you need to do. From now on, you can use the library. This until Scilab is restarted. Then this command must be given again to reload the library.
To make things easier, you can edit the file scilab.star with your favourite editor (or notepad/vi) in the Scilab directory and add above line at the end of this file. That will automatically load the lpsolve driver in memory when Scilab is started. So it will appear as if the sclpsolve command is then always available.
If you get an error similar to below, then probably the lpsolve library can not be found:
link failed for dll c:\lp_solve\lp_solve_5.5\extra\scilab\lpsolve\libs\sclpsolve.dll
addinter(liblpmex,'lpmex_gateway','sclpsolve')
!--error 236
link: the shared archive was not loaded
Under Windows, the lpsolve55.dll file must be in one of the directories specified by the PATH environment variable. This path can be seen in Scilab via the command getenv("PATH"). It is common to place dlls in the WINDOWS\system32 folder.
Under Unix/Linux, the liblpsolve55.so file must be in the directory /usr/lib or /lib.
To test if everything is installed correctly, enter sclpsolve() in the Scilab command window. If it gives the following, then everything is ok:
sclpsolve scilab Interface version 5.5.0.5
using lpsolve version 5.5.0.13
Usage: [ret1, ret2, ...] = sclpsolve('functionname', arg1, arg2, ...)
All this is developed and tested with Scilab versions 2.7 and 3.0 both under Windows and Linux (RedHat).
In the following text, --> before the Scilab commands is the Scilab prompt. Only the text after --> must be entered.
To call an lpsolve function, the following syntax must be used:
-->[ret1, ret2, ...] = sclpsolve('functionname', arg1, arg2, ...)
The return values are optional and depend on the function called. functionname must always be enclosed between (single or double) quotes to make it alphanumerical and it is case sensitive. The number and type of arguments depend on the function called. Some functions even have a variable number of arguments and a different behaviour occurs depending on the type of the argument. functionname can be (almost) any of the lpsolve API routines (see lp_solve API reference) plus some extra Scilab specific functions. Most of the lpsolve API routines use or return an lprec structure. To make things more robust in Scilab, this structure is replaced by a handle or the model name. The lprec structures are maintained internally by the lpsolve driver. The handle is an incrementing number starting from 0. Starting from driver version 5.5.0.2, it is also possible to use the model name instead of the handle. This can of course only be done if a name is given to the model. This is done via lpsolve routine set_lp_name or by specifying the model name in routine read_lp. See Using model name instead of handle.
Almost all callable functions can be found in the lp_solve API reference. Some are exactly as described in the reference guide, others have a slightly different syntax to make maximum use of the Scilab functionality. For example make_lp is used identical as described. But get_variables is slightly different. In the API reference, this function has two arguments. The first the lp handle and the second the resulting variables and this array must already be dimensioned. When lpsolve is used from Scilab, nothing must be dimensioned in advance. The sclpsolve driver takes care of dimensioning all return variables and they are always returned as return value of the call to sclpsolve. Never as argument to the routine. This can be a single value as for get_objective (although Scilab stores this in a 1x1 matrix) or a matrix or vector as in get_variables. In this case, get_variables returns a 4x1 matrix (vector) with the result of the 4 variables of the lp model.
Note that you can get an overview of the available functionnames and their arguments by entering the following in Scilab:
-->help sclpsolve
(Note that you can execute this example by entering command per command as shown below or by just entering exec example1.sce. This will execute example1.sce.)
-->lp=sclpsolve('make_lp', 0, 4);
-->sclpsolve('set_verbose', lp, 3);
-->sclpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1]);
-->sclpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], 2, 92.3);
-->sclpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
-->sclpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], 2, 4);
-->sclpsolve('set_lowbo', lp, 1, 28.6);
-->sclpsolve('set_lowbo', lp, 4, 18);
-->sclpsolve('set_upbo', lp, 4, 48.98);
-->sclpsolve('set_col_name', lp, 1, 'COLONE');
-->sclpsolve('set_col_name', lp, 2, 'COLTWO');
-->sclpsolve('set_col_name', lp, 3, 'COLTHREE');
-->sclpsolve('set_col_name', lp, 4, 'COLFOUR');
-->sclpsolve('set_row_name', lp, 1, 'THISROW');
-->sclpsolve('set_row_name', lp, 2, 'THATROW');
-->sclpsolve('set_row_name', lp, 3, 'LASTROW');
-->sclpsolve('write_lp', lp, 'a.lp');
-->sclpsolve('get_mat', lp, 1, 2)
ans =
78.26
-->sclpsolve('solve', lp)
ans =
0.
-->sclpsolve('get_objective', lp)
ans =
31.782759
-->sclpsolve('get_variables', lp)
ans =
! 28.6 !
! 0. !
! 0. !
! 31.827586 !
-->sclpsolve('get_constraints', lp)
ans =
! 92.3 !
! 6.864 !
! 391.29283 !
Note that there are some commands that return an answer. To see the answer, the command was not terminated with a semicolon (;). If the semicolon is put at the end of a command, the answer is not shown. However it is also possible to write the answer in a variable. For example:
-->obj=sclpsolve('get_objective', lp)
obj =
31.782759
Or without echoing on screen:
-->obj=sclpsolve('get_objective', lp);
The last command will only write the result in variable obj without showing anything on screen. get_variables and get_constraints return a vector with the result. This can also be put in a variable:
-->x=sclpsolve('get_variables', lp);
-->b=sclpsolve('get_constraints', lp);
It is always possible to show the contents of a variable by just giving it as command:
-->x x = ! 28.6 ! ! 0. ! ! 0. ! ! 31.827586 !
Don't forget to free the handle and its associated memory when you are done:
-->sclpsolve('delete_lp', lp);
-->lp=sclpsolve('make_lp', 0, 4);
-->sclpsolve('set_lp_name', lp, 'mymodel');
-->sclpsolve('set_verbose', 'mymodel', 3);
-->sclpsolve('set_obj_fn', 'mymodel', [1, 3, 6.24, 0.1]);
-->sclpsolve('add_constraint', 'mymodel', [0, 78.26, 0, 2.9], 2, 92.3);
-->sclpsolve('add_constraint', 'mymodel', [0.24, 0, 11.31, 0], 1, 14.8);
-->sclpsolve('add_constraint', 'mymodel', [12.68, 0, 0.08, 0.9], 2, 4);
-->sclpsolve('set_lowbo', 'mymodel', 1, 28.6);
-->sclpsolve('set_lowbo', 'mymodel', 4, 18);
-->sclpsolve('set_upbo', 'mymodel', 4, 48.98);
-->sclpsolve('set_col_name', 'mymodel', 1, 'COLONE');
-->sclpsolve('set_col_name', 'mymodel', 2, 'COLTWO');
-->sclpsolve('set_col_name', 'mymodel', 3, 'COLTHREE');
-->sclpsolve('set_col_name', 'mymodel', 4, 'COLFOUR');
-->sclpsolve('set_row_name', 'mymodel', 1, 'THISROW');
-->sclpsolve('set_row_name', 'mymodel', 2, 'THATROW');
-->sclpsolve('set_row_name', 'mymodel', 3, 'LASTROW');
-->sclpsolve('write_lp', 'mymodel', 'a.lp');
-->sclpsolve('get_mat', 'mymodel', 1, 2)
ans =
78.26
-->sclpsolve('solve', 'mymodel')
ans =
0.
-->sclpsolve('get_objective', 'mymodel')
ans =
31.782759
-->sclpsolve('get_variables', 'mymodel')
ans =
! 28.6 !
! 0. !
! 0. !
! 31.827586 !
-->sclpsolve('get_constraints', 'mymodel')
ans =
! 92.3 !
! 6.864 !
! 391.29283 !
So everywhere a handle is needed, you can also use the model name. You can even mix the two methods.
There is also a specific Scilab routine to get the handle from the model name: get_handle.
For example:
-->sclpsolve('get_handle', 'mymodel')
0
Don't forget to free the handle and its associated memory when you are done:
-->sclpsolve('delete_lp', 'mymodel');
In the next part of this documentation, the handle is used. But if you name the model, the name could thus also be used.
-->sclpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
In sparse matrix notation, this can be written:
-->sclpsolve('add_constraint', lp, mtlb_sparse(sparse([0.24, 0, 11.31, 0])), 1, 14.8);
Most of the time, variables are used to provide the data:
-->sclpsolve('add_constraint', lp, a1, 1, 14.8);
Where a1 is a dense matrix variable. A sparse matrix is then provided as follows:
-->sclpsolve('add_constraint', lp, mtlb_sparse(a1), 1, 14.8);
The sclpsolve driver sees all provided matrices as sparse matrices. sclpsolve also uses sparse matrices internally and data can be provided sparse via the ex routines. For example add_constraintex. The sclpsolve driver always uses the ex routines to provide the data to lpsolve. Even if you call from Scilab the routine names that would require a dense matrix (for example add_constraint), the sclpsolve driver will always call the sparse version of the routine (for example add_constraintex). This results in the most performing behaviour. Note that if a dense matrix is provided, the dimension must exactly match the dimension that is expected by sclpsolve. Matrices with too few or too much elements gives an 'invalid vector.' error. Sparse matrices can off course provide less elements (the non provided elements are seen as zero). However if too many elements are provided or an element with a too large index, again an 'invalid vector.' error is raised.
Most of the time, sclpsolve needs vectors (rows or columns). In all situations, it doesn't matter if the vectors are row or column vectors. The driver accepts them both. For example:
-->sclpsolve('add_constraint', lp, [0.24; 0; 11.31; 0], 1, 14.8);
Which is a column vector, but it is also accepted.
An important final note. Several lp_solve API routines accept a vector where the first element (element 0) is not used. Other lp_solve API calls do use the first element. In the Scilab interface, there is never an unused element in the matrices. So if the lp_solve API specifies that the first element is not used, then this element is not in the Scilab matrix.
All numerical data is stored in matrices. Alphanumerical data, however, is more difficult to store in matrices. Matrices require that each element has the same size (length) and that is difficult and unpractical for alphanumerical data. In a limited number of lpsolve routines, alphanumerical data is required or returned and in some also multiple elements. An example is set_col_name. For this, Scilab sets are used. To specify a set of alphanumerical elements, the following notation is used: { 'element1', 'element2', ... }. Note the { and } symbols instead of [ and ] that are used with matrices.
It is noted however that this doesn't seem to work very well in Scilab. Scilab allows to return string sets, but when a string set is provided to an interface program, the following error occurs:
!--error 9999
Invalid string matrix (at most one column!)
!--error 999
SIGSTP: aborting current computation
This is not an error generated by the sclpsolve driver, but from the Scilab parser. Hopefully, this problem will be corrected in the future.
Because Scilab is all about matrices, all lpsolve API routines that need a column or row number to get/set information for that
column/row are extended in the sclpsolve Scilab driver to also work with matrices. For example set_int in the API can
only set the integer status for one column. If the status for several integer variables must be set, then set_int
must be called multiple times. The sclpsolve Scilab driver however also allows specifying a vector to set the integer
status of all variables at once. The API call is: return = sclpsolve('set_int', lp, column, must_be_int). The
matrix version of this call is: return = sclpsolve('set_int', lp, [must_be_int]).
The API call to return the integer status of a variable is: return = sclpsolve('is_int', lp, column). The
matrix version of this call is: [is_int] = sclpsolve('is_int', lp)
Also note the get_mat and set_mat routines. In Scilab these are extended to return/set the complete constraint matrix.
See following example.
Above example can thus also be done as follows:
(Note that you can execute this example by entering command per command as shown below or by just entering exec example2.sce.
This will execute example2.sce.)
-->lp=sclpsolve('make_lp', 0, 4);
-->sclpsolve('set_verbose', lp, 3);
-->sclpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1]);
-->sclpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], 2, 92.3);
-->sclpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
-->sclpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], 2, 4);
-->sclpsolve('set_lowbo', lp, [28.6, 0, 0, 18]);
-->sclpsolve('set_upbo', lp, [%inf, %inf, %inf, 48.98]);
-->// gives a Scilab error with most releases :-(
-->// sclpsolve('set_col_name', lp, {'COLONE','COLTWO','COLTHREE','COLFOUR'});
-->// sclpsolve('set_row_name', lp, {'THISROW','THATROW','LASTROW'});
-->sclpsolve('write_lp', lp, 'a.lp');
-->sclpsolve('get_mat', lp)
ans =
! 0. 78.26 0. 2.9 !
! .24 0. 11.31 0. !
! 12.68 0. .08 .9 !
-->sclpsolve('solve', lp)
ans =
0.
-->sclpsolve('get_objective', lp)
ans =
31.782759
-->sclpsolve('get_variables', lp)
ans =
! 28.6 !
! 0. !
! 0. !
! 31.827586 !
-->sclpsolve('get_constraints', lp)
ans =
! 92.3 !
! 6.864 !
! 391.29283 !
Note the usage of %inf in set_upbo. This stands for 'infinity'. Meaning an infinite upper bound. It is also possible to use -%inf to express minus infinity. This can for example be used to create a free variable.
Starting from driver version 5.5.0.3, get_mat can also return the matrix in sparse format. By default the function returns it in dense format for backwards compatibility. However if a 3rd argument is provided that is non-zero, the returned matrix is sparse:
-->sclpsolve('get_mat', lp, 1)
ans =
(3, 4) m sparse matrix
(2, 1) .24
(3, 1) 12.68
(1, 2) 78.26
(2, 3) 11.31
(3, 3) .08
(1, 4) 2.9
(3, 4) .9
To show the full power of the matrices, let's now do some matrix calculations to check the solution. It works further on above example:
-->A=sclpsolve('get_mat', lp);
-->X=sclpsolve('get_variables', lp);
-->B = A * X
B =
! 92.3 !
! 6.864 !
! 391.29283 !
So what we have done here is calculate the values of the constraints (RHS) by multiplying the constraint matrix with the solution vector. Now take a look at the values of the constraints that lpsolve has found:
-->sclpsolve('get_constraints', lp)
ans =
! 92.3 !
! 6.864 !
! 391.29283 !
Exactly the same as the calculated B vector, as expected.
Also the value of the objective can be calculated in a same way:
-->C=sclpsolve('get_obj_fn', lp);
-->X=sclpsolve('get_variables', lp);
obj =
31.782759
So what we have done here is calculate the value of the objective by multiplying the objective vector with the solution vector. Now take a look at the value of the objective that lpsolve has found:
-->sclpsolve('get_objective', lp)
ans =
31.7828
Again exactly the same as the calculated obj value, as expected.
Scilab can execute a sequence of statements stored in diskfiles. Scilab has two kinds of these. The first kinds are ASCII files where Scilab commands are written in the same way as in the command window. These files normally have the extension .sce. These script files must be executed via the exec command. For example:
exec example1.sce
The second kinds are binary files. However the user enters the commands first in an ASCII file (normally with extension .sci) and then these are translated to binary files via the Scilab genlib command. The .sci files also may only contain Scilab commands. There are two advantages of using these. The first is that you don't have to use the exec command or provide the extension to execute them. So it is as if you execute a regular Scilab command. The second advantage is that they are somewhat faster.
The lpsolve distribution contains some sample .sce files that must be executed via exec and also some .sci high-level routines that can be executed without exec. They are already precompiled.
Contains the commands as shown in the first example of this article. Execute via exec example1.sce
Contains the commands as shown in the second example of this article. Execute via exec example2.sce
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
This script uses the API to create a higher-level function called lp_solve. This function accepts as arguments some matrices and options to create and solve an lp model. See the beginning of the file or type help lp_solve to see its usage:
LP_SOLVE Solves mixed integer linear programming problems.
SYNOPSIS: [obj,x,duals] = lp_solve(f,a,b,e,vlb,vub,xint,scalemode,keep)
solves the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) = -1 ==> Less Than
e(i) = 0 ==> Equals
e(i) = 1 ==> Greater Than
vlb: n vector of lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
keep: Flag for keeping the lp problem after it's been solved.
If omitted, the lp will be deleted when solved.
OUTPUT: A nonempty output is returned if a solution is found:
obj: Optimal value of the objective function.
x: Optimal value of the decision variables.
duals: solution of the dual problem.
Example of usage. To create and solve following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
-->[obj, x]=lp_solve([-1, 2], [2, 1; -4, 4], [5, 5], [-1, -1], [], [], [1, 2])
x =
! 1. !
! 2. !
obj =
3.
Note that you can also provide sparse matrices to this function without having to use mtlb_sparse. The script is taking care of this.
This script is analog to the lp_solve script and also uses the API to create a higher-level function called lp_maker. This function accepts as arguments some matrices and options to create an lp model. Note that this scripts only creates a model and returns a handle. See the beginning of the file or type help lp_maker or just lp_maker to see its usage:
-->help lp_maker
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
x >= vlb >= 0
x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Example of usage. To create following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
-->lp=lp_maker([-1, 2], [2, 1; -4, 4], [5, 5], [-1, -1], [], [], [1, 2])
lp =
0.
To solve the model and get the solution:
-->sclpsolve('solve', lp)
ans =
0.
-->sclpsolve('get_objective', lp)
ans =
3.
-->sclpsolve('get_variables', lp)
ans =
! 1. !
! 2. !
Don't forget to free the handle and its associated memory when you are done:
-->sclpsolve('delete_lp', lp);
Note that you can also provide sparse matrices to this function without having to use mtlb_sparse. The script is taking care of this.
Contains several examples to build and solve lp models. Execute via exec lpdemo.sce
Contains several examples to build and solve lp models. Also solves the lp_examples from the lp_solve distribution. Execute via exec ex.sce
We shall illustrate the method of linear programming by means of a simple example, giving a combination graphical/numerical solution, and then solve both a slightly as well as a substantially more complicated problem.
Suppose a farmer has 75 acres on which to plant two crops: wheat and barley. To produce these crops, it costs the farmer (for seed, fertilizer, etc.) $120 per acre for the wheat and $210 per acre for the barley. The farmer has $15000 available for expenses. But after the harvest, the farmer must store the crops while awaiting favourable market conditions. The farmer has storage space for 4000 bushels. Each acre yields an average of 110 bushels of wheat or 30 bushels of barley. If the net profit per bushel of wheat (after all expenses have been subtracted) is $1.30 and for barley is $2.00, how should the farmer plant the 75 acres to maximize profit?
We begin by formulating the problem mathematically. First we express the objective, that is the profit, and the constraints algebraically, then we graph them, and lastly we arrive at the solution by graphical inspection and a minor arithmetic calculation.
Let x denote the number of acres allotted to wheat and y the number of acres allotted to barley. Then the expression to be maximized, that is the profit, is clearly
P = (110)(1.30)x + (30)(2.00)y = 143x + 60y.
There are three constraint inequalities, specified by the limits on expenses, storage and acreage. They are respectively:
120x + 210y <= 15000
110x + 30y <= 4000
x + y <= 75
Strictly speaking there are two more constraint inequalities forced by the fact that the farmer cannot plant a negative number of acres, namely:
x >= 0, y >= 0.
Next we graph the regions specified by the constraints. The last two say that we only need to consider the first quadrant in the x-y plane. Here's a graph delineating the triangular region in the first quadrant determined by the first inequality.
-->clear -->X = 0.1:0.1:125; -->Y1 = (15000. - 120*X)/210; -->plot2d3(X, Y1)
Now let's put in the other two constraint inequalities.
-->clear
-->X = 0.1:0.05:38;
-->Y1 = (15000. - 120*X)/210;
-->Y2 = max((4000 - 110.*X)./30, 0);
-->Y3 = max(75 - X, 0.);
-->Ytop = min(min(Y1, Y2), Y3);
-->plot2d3(X, Ytop)
-->xtitle("Solution space")
The black area is the solution space that holds valid solutions. This means that any point in this area fulfils the constraints.
Now let's superimpose on top of this picture the objective function P.
-->X = 15:20:35;
-->plot2d(X, (6315.63 - 143.0 * X) / 60.0)
-->xtitle("Solution space and objective")
The line gives a picture of the objective function. All solutions that intersect with the black area are valid solutions, meaning that this result also fulfils the set constraints. The more the line goes to the right, the higher the objective value is. The optimal solution or best objective is a line that is still in the black area, but with an as large as possible value (as shown here).
It seems apparent that the maximum value of P will occur on the level curve (that is, level
line) that passes through the vertex of the polygon that lies near (22,53).
It is the intersection of x + y = 75 and 110*x + 30*y = 4000
This is a corner point of the diagram. This is not a coincidence. The simplex algorithm, which is used
by lp_solve, starts from a theorem that the optimal solution is such a corner point.
In fact we can compute the result:
-->x = [1, 1; 110, 30] \ [75; 4000] x = ! 21.875 ! ! 53.125 !
The acreage that results in the maximum profit is 21.875 for wheat and 53.125 for barley. In that case the profit is:
-->P = [143, 60] * x
P =
6315.625
That is, $6315.625.
Note that these command are in script example3.sce
Now, lp_solve comes into the picture to solve this linear programming problem more generally. After that we will use it to solve two more complicated problems involving more variables and constraints.
For this example, we use the higher-level script lp_maker to build the model and then some lp_solve API calls to retrieve the solution. Here is again the usage of lp_maker:
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
x >= vlb >= 0
x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Now let's formulate this model with lp_solve:
-->f = [143, 60];
-->A = [120, 210; 110, 30; 1, 1];
-->b = [15000, 4000, 75];
-->lp = lp_maker(f, A, b, [-1, -1, -1], [], [], [], 1, 0);
-->solvestat = sclpsolve("solve", lp)
solvestat =
0.
-->sclpsolve("get_objective", lp)
ans =
6315.625
-->sclpsolve("get_variables", lp)
ans =
! 21.875 !
! 53.125 !
-->sclpsolve("delete_lp", lp);
Note that these command are in script example4.oms
With the higher-level script lp_maker, we provide all data to lp_solve. lp_solve returns a handle (lp) to the created model. Then the API call 'solve' is used to calculate the optimal solution of the model. The value of the objective function is retrieved via the API call 'get_objective' and the values of the variables are retrieved via the API call 'get_variables'. At last, the model is removed from memory via a call to 'delete_lp'. Don't forget this to free all memory allocated by lp_solve.
The solution is the same answer we obtained before. Note that the non-negativity constraints are accounted implicitly because variables are by default non-negative in lp_solve.
Well, we could have done this problem by hand (as shown in the introduction) because it is very small and it
can be graphically presented.
Now suppose that the farmer is dealing with a third crop, say corn, and that the corresponding data is:
cost per acre $150.75 yield per acre 125 bushels profit per bushel $1.56
With three variables it is already a lot more difficult to show this model graphically. Adding more variables makes it even impossible because we can't imagine anymore how to represent this. We only have a practical understanding of 3 dimentions, but beyound that it is all very theorethical.
If we denote the number of acres allotted to corn by z, then the objective function becomes:
P = (110)(1.30)x + (30)(2.00)y + (125)(1.56) = 143x + 60y + 195z
And the constraint inequalities are:
120x + 210y + 150.75z <= 15000
110x + 30y + 125z <= 4000
x + y + z <= 75
x >= 0, y >= 0, z >= 0
The problem is solved with lp_solve as follows:
-->f = [143, 60, 195];
-->A = [120, 210, 150.75; 110, 30, 125; 1, 1, 1];
-->b = [15000, 4000, 75];
-->lp = lp_maker(f, A, b, [-1, -1, -1], [], [], [], 1, 0);
-->solvestat = sclpsolve("solve", lp)
solvestat =
0.
-->sclpsolve("get_objective", lp)
ans =
6986.8421
-->sclpsolve("get_variables", lp)
ans =
! 0. !
! 56.578947 !
! 18.421053 !
-->sclpsolve("delete_lp", lp);
Note that these command are in script example5.oms
So the farmer should ditch the wheat and plant 56.5789 acres of barley and 18.4211 acres of corn.
There is no practical limit on the number of variables and constraints that Scilab can handle. Certainly none that the relatively unsophisticated user will encounter. Indeed, in many true applications of the technique of linear programming, one needs to deal with many variables and constraints. The solution of such a problem by hand is not feasible, and software like Scilab is crucial to success. For example, in the farming problem with which we have been working, one could have more crops than two or three. Think agribusiness instead of family farmer. And one could have constraints that arise from other things beside expenses, storage and acreage limitations. For example:
Below is a sequence of commands that solves exactly such a problem. You should be able to recognize the objective expression and the constraints from the data that is entered. But as an aid, you might answer the following questions:
-->f = [110*1.3, 30*2.0, 125*1.56, 75*1.8, 95*.95, 100*2.25, 50*1.35];
-->A = [120,210,150.75,115,186,140,85;110,30,125,75,95,100,50;1,1,1,1,1,1,1;
1,-1,0,0,0,0,0;0,0,1,0,-2,0,0;0,0,0,-1,0,-1,1];
-->b = [55000, 40000, 400, 0, 0, 0];
-->lp = lp_maker(f, A, b, [-1,-1,-1,-1,-1,-1],[10,10,10,10,20,20,20],[100,%inf,50,%inf,%inf,250,%inf],[],1,0);
-->solvestat = sclpsolve("solve", lp)
solvestat =
0.
-->sclpsolve("get_objective", lp)
ans =
75398.043
-->sclpsolve("get_variables", lp)
ans =
! 10. !
! 10. !
! 40. !
! 45.652174 !
! 20. !
! 250. !
! 20. !
-->sclpsolve("delete_lp", lp);
Note that these command are in script example6.oms
Note that we have used in this formulation the vlb and vub arguments of lp_maker. This to set lower and upper bounds on variables. This could have been done via extra constraints, but it is more performant to set bounds on variables. Also note that %inf is used for variables that have no upper limit. This stands for Infinity.
Note that despite the complexity of the problem, lp_solve solves it almost instantaneously. It seems the farmer should bet the farm on crop number 6. We strongly suggest you alter the expense and/or the storage limit in the problem and see what effect that has on the answer.
Suppose we want to solve the following linear program using Scilab:
max 4x1 + 2x2 + x3
s. t. 2x1 + x2 <= 1
x1 + 2x3 <= 2
x1 + x2 + x3 = 1
x1 >= 0
x1 <= 1
x2 >= 0
x2 <= 1
x3 >= 0
x3 <= 2
Convert the LP into Scilab format we get:
f = [4, 2, 1]
A = [2, 1, 0; 1, 0, 2; 1, 1, 1]
b = [1, 2, 1]
Note that constraints on single variables are not put in the constraint matrix. lp_solve can set bounds on individual variables and this is more performant than creating additional constraints. These bounds are:
l = [ 0, 0, 0]
u = [ 1, 1, 2]
Now lets enter this in Scilab:
-->f = [4, 2, 1]; -->A = [2, 1, 0; 1, 0, 2; 1, 1, 1]; -->b = [1, 2, 1]; -->l = [ 0, 0, 0]; -->u = [ 1, 1, 2];
Now solve the linear program using Scilab: Type the commands
-->lp = lp_maker(f, A, b, [-1, -1, -1], l, u, [], 1, 0);
-->solvestat = sclpsolve("solve", lp)
solvestat =
0.
-->sclpsolve("get_objective", lp)
ans =
2.5
-->sclpsolve("get_variables", lp)
ans =
! 0.5 !
! 0. !
! 0.5 !
-->sclpsolve("delete_lp", lp)
What to do when some of the variables are missing ?
For example, suppose there are no lower bounds on the variables. In this case define l to be the empty set using the Scilab command:
-->l = [];
This has the same effect as before, because lp_solve has as default lower bound for variables 0.
But what if you want that variables may also become negative?
Then you can use -%inf as lower bounds:
-->l = [-%inf, -%inf, -%inf];
Solve this and you get a different result:
-->lp = lp_maker(f, A, b, [-1, -1, -1], l, u, [], 1, 0);
-->solvestat = sclpsolve("solve", lp)
solvestat =
0.
-->sclpsolve("get_objective", lp)
ans =
2.6666667
-->sclpsolve("get_variables", lp)
ans =
! 0.6666667 !
! - 0.3333333 !
! 0.6666667 !
-->sclpsolve("delete_lp", lp)
Note that everwhere where lp is used as argument that this can be a handle (lp_handle) or the models name.
These routines are not part of the lpsolve API, but are added for backwards compatibility. Most of them exist in the lpsolve API with another name.
Under Windows, the sclpsolve Scilab driver is a dll: sclpsolve.dll
Under Unix/Linux, the sclpsolve Scilab driver is a static library sclpsolve.a
The library is an interface to the lpsolve55 library that contains the implementation of lp_solve.
Under windows this is a dll lpsolve55.dll and under Unix/Linux it is a shared library liblpsolve55.so
They are distributed with the lp_solve package (archive lp_solve_5.5.0.13_dev.zip/lp_solve_5.5.0.13_dev.tar.gz). See at the beginning of this article where these files must be installed.
The sclpsolve Scilab driver is just
a wrapper between Scilab and lp_solve to translate the input/output to/from Scilab and the lp_solve library.
The sclpsolve Scilab driver is written in C. To compile this code, under Windows the Microsoft C compiler is needed and under
Unix the standard compiler is used.
This compiler must be called from Scilab. To make the compilation process easier, a script can be used:
builder.sce
Before the compilation is started, it may be necessary to edit the file Path.incl. In this file it is specified where scilab is installed
and were lp_solve is installed. Change the paths as needed.
To make everything, just enter exec builder.sce and everything is build.
This compiles the source files to the needed libraries, compiles the sci scripts and makes the manuals. It also
generates a new loader.sce file to load the driver into the Scilab workspace.
This build process is the same under Windows and Unix/Linux. Note that builder.sce generates Makefiles that are then used to build the code. Don't edit the Makefiles since your changes will be lost when build.sce is executed again.
See also Using lpsolve from MATLAB, Using lpsolve from O-Matrix, Using lpsolve from Octave, Using lpsolve from Python, Using lpsolve from R
docs/5.5/set_epsb.htm 0000644 0001750 0001750 00000007031 11306036626 013303 0 ustar rene rene
set_epsbSpecifies the value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0. void set_epsb(lprec *lp, REAL epsb); Return Value set_epsb has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI epsb The value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0. Remarks The set_epsb function specifies the value that is used as a tolerance for
the Right Hand Side (RHS) to determine whether a value should be considered as
0. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_epsb, set_infinite, get_infinite, is_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
solvesolve the model. int solve(lprec *lp); Return Value
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
The solve function solves the model. solve can be called more
than once. Between calls, the model may be modified in every way. Restrictions
may be changed, matrix values may be changed and even rows and/or columns may
be added or deleted. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, lag_solve, statustext, is_feasible, get_objective, get_working_objective, get_variables, get_ptr_variables, get_constraints, get_ptr_constraints, get_constr_value, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex |
has_BFPReturns if there is a basis factorization package (BFP) available. unsigned char has_BFP(lprec *lp); Return Value has_BFP returns TRUE if there is a BFP available, else FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks There should always be a BFP available, else lpsolve can not solve. Normally lpsolve is compiled with a default BFP. See Basis Factorization Packages for a complete description on BFPs. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_nativeBFP, set_BFP |
get_rh_rangeGets the range on a constraint. REAL get_rh_range(lprec *lp, int row); Return Value get_rh_range returns the range set on the constraint specified by row. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row number of the constraint from which the range must be retrieved. It must be between 1 and the number of rows in the lp. Remarks The get_rh_range function gets the range on the constraint (row)
identified by row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_rh_range |
set_debugSets a flag if all intermediate results and the branch-and-bound decisions must be printed while solving. void set_debug(lprec *lp, unsigned char debug); Return Value set_debug has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI debug TRUE or FALSE. Debug or do not debug. Remarks The set_debug function sets a flag if all intermediate results and the branch-and-bound decisions must be printed while solving. This function is mend for debugging purposes. The default is not to debug (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_debug |
set_unboundedSets if the variable is free. unsigned char set_unbounded(lprec *lp, int column); Return Value set_unbounded returns TRUE (1) if the variable could be set as free, FALSE (0)
otherwise. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be set. It must be between 1 and the number of columns in the lp. Remarks The set_unbounded function sets if a variable is free or not. Free means a lower bound of -infinity and an upper bound of +infinity. Default a variable is not free because default it has a lower bound of 0 (and an upper bound of +infinity). See free variables for a description about free variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_upbo, set_upbo, set_lowbo, get_lowbo, set_bounds, is_unbounded, is_negative |
get_variables, get_ptr_variablesReturns the values of the variables. unsigned char get_variables(lprec *lp, REAL *var); unsigned char get_ptr_variables(lprec *lp, REAL **ptr_var); Return Value get_variables, get_ptr_variables returns TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI var An array that will contain the values of the variables. ptr_var The address of a pointer that will point to an array that will contain the values of the variables. Remarks The get_variables, get_ptr_variables functions retrieve the values
of the variables. Note that get_ptr_variables returns a pointer to memory allocated and maintained by lp_solve. Be careful what you do with it. Don't modify its contents or free the memory. Unexpected behaviour would occur. Also note that this memory pointer is only guaranteed to remain constant until a next lp_solve API call is done. You should call this function again to make sure you have again the correct pointer. Otherwise, this pointer could point to invalid memory. This should not be a problem since this call is very efficient. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_feasible, get_objective, get_working_objective, get_constraints, get_ptr_constraints, get_constr_value, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex |
set_preferdualSets the desired combination of primal and dual simplex algorithms. void set_preferdual(lprec *lp, unsigned char dodual); Return Value set_preferdual has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI dodual
When TRUE, the simplex strategy is set to SIMPLEX_DUAL_DUAL. Remarks The set_preferdual function sets the desired combination of primal and dual simplex algorithms. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_simplextype |
The main things to know about fixed MPS format are that it is column oriented
(as opposed to entering the model as equations), and everything
(variables, rows, etc.) gets a name.
MPS is an old format, so it is set up as though you were using punch
cards, and is not free format. Fields start in column 2, 5, 15, 25, 40
and 50. Sections of an MPS file are marked by so-called header cards,
which are distinguished by their starting in column 1. Although it is
typical to use upper-case throughout the file (like I said, MPS has
long historical roots), many MPS-readers will accept mixed-case for
anything except the header cards, and some allow mixed-case anywhere.
The names that you choose for the individual entities (constraints or
variables) are not important to the solver; you should pick names that
are meaningful to you, or will be easy for a post-processing code to
read.
Here is a little sample model written in MPS format (explained in more
detail below):
NAME TESTPROB
ROWS
N COST
L LIM1
G LIM2
E MYEQN
COLUMNS
XONE COST 1 LIM1 1
XONE LIM2 1
YTWO COST 4 LIM1 1
YTWO MYEQN -1
ZTHREE COST 9 LIM2 1
ZTHREE MYEQN 1
RHS
RHS1 LIM1 5 LIM2 10
RHS1 MYEQN 7
BOUNDS
UP BND1 XONE 4
LO BND1 YTWO -1
UP BND1 YTWO 1
ENDATA
For comparison, here is the same model written out in lp-format:
min: +XONE +4 YTWO +9 ZTHREE;
LIM1: +XONE +YTWO <= 5;
LIM2: +XONE +ZTHREE >= 10;
MYEQN: -YTWO +ZTHREE = 7;
XONE <= 4;
YTWO >= -1;
YTWO <= 1;
Strangely, there is nothing in MPS format that specifies the direction
of optimisation. And there really is no standard "default" direction;
some LP codes will maximize if you don't specify otherwise, others will
minimize, and still others put safety first and have no default and
require you to specify it somewhere in a control program or by a
calling parameter. If you have a model formulated for minimization
and the code you are using insists on maximization (or vice versa), it
may be easy to convert: just multiply all the coefficients in your
objective function by (-1). The optimal value of the objective
function will then be the negative of the true value, but the values of
the variables themselves will be correct.
Any line with an asterisk (*) in Column 1 is treated as a comment.
The eight character names used to specify variables, constraints and
other entities are fixed format. Names are not automatically justified,
so blanks are treated just like other characters. For example "ROW1 "
is not the same as " ROW1 ". (Note that some optimisers do not permit
blanks in names.) No case conversion is performed, so "row1 " is
different from "ROW1 ".
Floating point numbers may be specified in free format within the 12
character field (including embedded blanks). The following list describes
the possible ways of writing a number.
Mantissa:
+ or - optional sign character (no sign indicates a positive number)
digits optional integer part of the mantissa
. optional decimal point (if not present, a decimal point will
be assumed after the mantissa digit)
digits optional fraction part of the mantissa -the mantissa must
contain at least one digit
Exponent (optional):
D or E exponent leader
+ or - optional exponent sign
digits exponent digits
Numbers with an absolute value greater than 1010 or less than 10-10 are rejected.
The NAME card can have anything you want, starting in column 15. The
ROWS section defines the names of all the constraints; entries in
column 2 or 3 are E for equality rows, L for less-than ( <= ) rows, G
for greater-than ( >= ) rows, and N for non-constraining rows (the
first of which would be interpreted as the objective function). The
order of the rows named in this section is unimportant.
The largest part of the file is in the COLUMNS section, which is the
place where the entries of the A-matrix are put. All entries for a given
column must be placed consecutively, although within a column the
order of the entries (rows) is irrelevant. Rows not mentioned for a
column are implied to have a coefficient of zero.
The RHS section allows one or more right-hand-side vectors to be
defined; most people don't bother having more than one. In the above
example, the name of the RHS vector is RHS1, and has non-zero values
in all 3 of the constraint rows of the problem. Rows not mentioned in
an RHS vector would be assumed to have a right-hand-side of zero.
The optional BOUNDS section lets you put lower and upper bounds on
individual variables (no * wild cards, unfortunately), instead of
having to define extra rows in the matrix. All the bounds that have
a given name in column 5 are taken together as a set. Variables not
mentioned in a given BOUNDS set are taken to be non-negative (lower
bound zero, no upper bound). A bound of type UP means an upper bound
is applied to the variable. A bound of type LO means a lower bound is
applied. A bound type of FX ("fixed") means that the variable has
upper and lower bounds equal to a single value. A bound type of FR
("free") means the variable has neither lower nor upper bounds.
There is another optional section called RANGES that I won't go into
here. The final card must be ENDATA, and yes, it is spelled funny.
==========================================================================
MPS input format was originally introduced by IBM to express linear
and integer programs in a standard way. The format is a fixed column
format, so care must be taken that all information is placed in the
correct columns as described below.
The following is not intended as a complete description of MPS format,
but only as a brief introduction. For more information, the reader is
directed to:
"Advanced Linear Programming," by Bruce A. Murtagh
"Computer Solutions of Linear Programs," by J.L. Nazareth
It may be useful to look at an example MPS file while reading this
MPS information.
The following template is a guide for the use of MPS format:
---------------------------------------------------------------------
Field: 1 2 3 4 5 6
Columns: 2-3 5-12 15-22 25-36 40-47 50-61
NAME problem name
ROWS
type name
COLUMNS
column row value row value
name name name
RHS
rhs row value row value
name name name
RANGES
range row value row value
name name name
BOUNDS
type bound column value
name name
SOS
type CaseName SOSName SOSpriority
CaseName VarName1 VarWeight1
CaseName VarName2 VarWeight2
CaseName VarNameN VarWeightN
ENDATA
---------------------------------------------------------------------
NOTES:
A. In the ROWS section, each row of the constraint matrix must have a
row type and a row name specified. The code for indicating row type
is as follows:
type meaning
---------------------------
E equality
L less than or equal
G greater than or equal
N objective
N no restriction
B. In the COLUMNS section, the names of the variables are defined along
with the coefficients of the objective and all the nonzero constraint
matrix elements. It is not necessary to specify columns for slack or
surplus variables as this is taken care of automatically.
C. The RHS section contains information for the right-hand side of the problem.
D. The RANGES section is for constraints of the form: h <= constraint <= u .
The range of the constraint is r = u - h . The value of r is specified
in the RANGES section, and the value of u or h is specified in the RHS
section. If b is the value entered in the RHS section, and r is the
value entered in the RANGES section, then u and h are thus defined:
row type sign of r h u
----------------------------------------------
G + or - b b + |r|
L + or - b - |r| b
E + b b + |r|
E - b - |r| b
E. In the BOUNDS section, bounds on the variables are specified. When
bounds are not indicated, the default bounds ( 0 <= x < infinity )
are assumed. The code for indicating bound type is as follows:
type meaning
---------------------------------------------------
LO lower bound b <= x (< +inf)
UP upper bound (0 <=) x <= b
FX fixed variable x = b
FR free variable -inf < x < +inf
MI lower bound -inf -inf < x (<= 0)
PL upper bound +inf (0 <=) x < +inf
BV binary variable x = 0 or 1
LI integer variable b <= x (< +inf)
UI integer variable (0 <=) x <= b
SC semi-cont variable x = 0 or l <= x <= b
l is the lower bound on the variable
If none set then defaults to 1
F. Sections RANGES and BOUNDS are optional as are the fields 5 and 6.
Everything else is required. In regards to fields 5 and 6, consider
the following 2 constraints:
const1: 2x + 3y <= 6
const2: 5x + 8y <= 20
Two ways to enter the variable x in the COLUMNS section are:
(Field: 2 3 4 5 6 )
1. x const1 2.0 const2 5.0
2. x const1 2.0
x const2 5.0
G. A mixed integer program requires the specification of which variables
are required to be integer. Markers are used to indicate the start
and end of a group of integer variables. The start marker has its
name in field 2, 'MARKER' in field 3, and 'INTORG' in field 5. The
end marker has its name in field 2, 'MARKER' in field 3, and 'INTEND'
in field 5. These markers are placed in the COLUMNS section.
H. A specially ordered set of degree N is a collection of variables where
at most N variables may be non-zero. The non-zero variables must be
contiguous (neighbours) sorted by the ascending value of their respective
unique weights. In lp_solve, specially ordered sets may be of any
cardinal type 1, 2, and higher, and may be overlapping. The number of
variables in the set must be equal to, or exceed the cardinal SOS order.
Below is a representation of a SOS in an MPS file, where each SOS is
defined in its own SOS section, which should follow the BOUNDS section.
0 1 2 3 4
1234567890123456789012345678901234567890
SOS
Sx CaseName SOSName. SOSpriority.
CaseName VarName1 VarWeight1..
CaseName VarName2 VarWeight2..
CaseName VarNameN VarWeightN..
x at the second line, position 3, defines is the order of the SOS.
Due to limitations in the MPS format, N is restricted to the 1..9 range.
Each SOS should be given a unique name, SOSName. lp_solve does not
currently use case names for SOS'es and the CaseName could be any non-empty
value. The SOSpriority value determines the order in which multiple SOS'es
are analysed in lp_solve.
See also Interpolation with GAMS.
Example:
NAME SOS2test
ROWS
N obj
L c1
L c2
E c3
COLUMNS
x1 obj -1 c1 -1
x1 c2 1
x2 obj -2 c1 1
x2 c2 -3 c3 1
x3 obj -3 c1 1
x3 c2 1
x4 obj -1 c1 10
x4 c3 -3.5
x5 obj 0
RHS
rhs c1 30 c2 30
BOUNDS
UP BOUND x1 40
LI BOUND x4 2
UI BOUND x4 3
SOS
S2 SET SOS2 10
SET x1 10000
SET x2 20000
SET x4 40000
SET x5 50000
ENDATA
The free format is very similar to the fixed MPS format, but it is less restrictive e.g. it allows longer names. Also some implementations allow more than 12 positions to specify the values. The fields do not have fixed column positions as in the fixed MPS format. They may be written anywhere except column 1, with each field separated from the next by one or more blanks. However, they must appear in the same sequence as in fixed format. In the rows and bounds sections, the codes can be lower and upper case and at any starting position. Repeated column names are sometimes skipped and spaces are put there instead. The Fortran D exponent is allowed in the values.
There is one important limitation compared to the fixed MPS format: names may not contain blanks.
Note that the free MPS parser cannot read all fixed MPS formats correctly. Spaces in the names or names starting with spaces will give problems. It is not sure that an error will be given in that case. If the format complies to the free MPS format then it won't... So if you know that a model is in fixed MPS format, use it and not the free format. It is advised to first try the fixed format and only if it doesn't work, use the free format.
Also note that there is no real standard for the free format. Each implementer has its own implementation and interpretation of the free format ... Some allow one space in the name, some require that names must take at least 8 positions (and thus extended with spaces). Some allow to have more than 6 fields on a line. lp_solve only reads the first 6 fields and ignores the rest.
lp_solve tries to handle all possible free formats. The only real limitation is that there may be no blanks in names (also no leading blanks) and only 6 fields per line may be used. When lp_solve writes an mps file in free format, it will be the same as for fixed format, except if names are longer than 8 characters. In that case all data is shifted to the right.
Several solvers have added a 'standard' to the free MPS format to allow to specify the objective direction.
This via the new optional section OBJSENSE. Below this section, there may be one line that specifies the objective direction.
This in field 1 of this line via the following possible keywords: MAXIMIZE, MAX, MINIMIZE, MIN. If the section
is not specified, then lp_solve assumes minimization, just like the fixed MPS format.
For example:
OBJSENSE MAX
This section should be before the ROWS section.
For example:
NAME TESTPROB
OBJSENSE
MAX
ROWS
N COST
L LIM1
G LIM2
E MYEQN
COLUMNS
XONE COST 1 LIM1 1
XONE LIM2 1
YTWO COST 4 LIM1 1
YTWO MYEQN -1
ZTHREE COST 9 LIM2 1
ZTHREE MYEQN 1
RHS
RHS1 LIM1 5 LIM2 10
RHS1 MYEQN 7
BOUNDS
UP BND1 XONE 4
LO BND1 YTWO -1
UP BND1 YTWO 1
ENDATA
The lp_solve free MPS reader recognises and interprets all possible OBJSENSE direction values. When a free MPS file is created, the OBJSENSE section will only be written when the direction is maximization. This because minimization is by default assumed and to stay as compatible as possible with other solvers.
Several solvers have added a 'standard' to the free MPS format to allow to specify the objective row.
By default the first "N" row defined in the ROWS section becomes a problem's objective; a different objective may be
specified in the optional OBJNAME section, which contains exactly one data line that names the objective in field 1.
For example:
OBJNAME obj2
This section should be before the ROWS section.
For example:
NAME TESTPROB
OBJNAME
PROFIT
ROWS
N COST
N PROFIT
L LIM1
G LIM2
E MYEQN
COLUMNS
XONE COST -1 PROFIT 1
XONE LIM1 1 LIM2 1
YTWO COST -4 PROFIT 4
YTWO LIM1 1 MYEQN -1
ZTHREE COST -9 PROFIT 9
ZTHREE LIM2 1 MYEQN 1
RHS
RHS1 LIM1 5 LIM2 10
RHS1 MYEQN 7
BOUNDS
UP BND1 XONE 4
LO BND1 YTWO -1
UP BND1 YTWO 1
ENDATA
The lp_solve free MPS reader recognises and interprets this OBJNAME section and uses the objective name specified here. Other "N" cards in the ROWS section are then ignored. Note that if there is no OBJNAME section that, just like in the fixed MPS format, the first "N" card from the rows section is then taken and all other "N" cards are ignored. When a free MPS file is created, the OBJNAME section will never be created since lp_solve always only has one objective function in memory.
docs/5.5/read_XLI.htm 0000644 0001750 0001750 00000006271 11306036626 013133 0 ustar rene rene
read_XLICreate an lprec structure and read a model via the External Language Interface. lprec *read_XLI(char *xliname, char *modelname, char *dataname, char *options, int verbose); Return Value
Returns a pointer to a new lprec structure. This must be provided to almost all
lp_solve functions. Parameters xliname Filename of the XLI package. modelname Filename to read the model from. dataname Filename to read the data from. This may be optional. In that case, set the parameter to NULL. options Extra options that can be used by the reader. verbose The verbose level. Can be one of the following values: See also set_verbose and get_verbose. Remarks The read_XLI function constructs a new lprec structure and reads the model from filename via the specified XLI. See External Language Interfaces for a complete description on XLIs. Example See Also delete_lp, free_lp, make_lp, copy_lp, write_lp, write_LP, write_lpex, read_mps, read_freemps, read_MPS, read_freeMPS, write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileex, write_XLI, has_XLI, is_nativeXLI, set_XLI |
set_boundsSet the upper and lower bound of a variable. unsigned char set_bounds(lprec *lp, int column, REAL lower, REAL upper); Return Value set_bounds returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable on which the bounds must be set. It must be between 1 and the number of columns in the lp. Remarks The set_bounds function sets a lower and upper bound on the variable
identified by column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_lowbo, get_lowbo, set_upbo, get_upbo, set_unbounded, is_unbounded, is_negative |
get_statusReturns an extra status after a call to a function. int get_status(lprec *lp); Return Value Extra status which indicates type of problem after call to function. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_status function returns an extra status after a call to a function. Some functions return FALSE when they have failed. To have more information on the reason of the failure, this routine can be used to get an extended error code. Example See Also free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI |
lpsolve distributed fileslpsolve is distributed as several separate archive files. It is most unlikely that you need them all for your purpose. This text describes each archive's contents. There are two kind of archive files:
Ziped files are basically binaries (executables/libraries) for the Windows platform. gziped tar files can be divided into two categories:
List of archives
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
has_XLIReturns if there is an external language interface (XLI) set. unsigned char has_XLI(lprec *lp); Return Value has_XLI returns TRUE if there is an XLI set, else FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks See External Language Interfaces for a complete description on XLIs. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, write_XLI, is_nativeXLI, set_XLI |
set_pivotingSets the pivot rule and mode. void set_pivoting(lprec *lp, int pivoting); Return Value set_pivoting has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI pivoting The pivot rule and mode. Can be one of the following rules:
Some of these values can be combined with any (ORed) of the following modes:
Remarks The set_pivoting function specifies the pivot rule (rule for selecting row
and column entering/leaving) and mode. The rule is an exclusive option and the mode
is a modifier to the rule. This rule/mode can influence solving times
considerably. Depending on the model one rule/mode can be best and for another model
another rule/mode. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_pivoting, is_piv_rule, is_piv_mode |
PresolvePresolve is a preprocess of the lp-model. It looks for ways to simplify it.
For example it can delete unused variables and restrictions. Substitute fixed variable values by a
constant and so on. The result is a new model that is less complex than the original model and likely solves faster.
Presolve is not active by default. It must specifically being enabled via the API call set_presolve. A simple example: max: x1 + x2 + x3; r1: x2 = 2; r2: x1 + x2 <= 6; r3: x1 - 2 x3 >= 2; r4: x2 + 3 x3 <= 5; Row r1 is a constraint on one variable. Presolve can detect this and convert it to a bound on that variable. For this, presolve of rows must be activated: lp_solve model.lp -wlp con -S1 -wafter -presolverow /* Objective function */ max: +x1 +x2 +x3; /* Constraints */ r2: +x1 +x2 <= 6; r3: +x1 -2 x3 >= 2; r4: +x2 +3 x3 <= 5; /* Variable bounds */ x2 = 2;
And even this model can be presolved further. lp_solve model.lp -wlp con -S1 -wafter -presolverow -presolvecol /* Objective function */ max: +x1 +x3 +2; /* Constraints */ r3: +x1 -2 x3 >= 2; /* Variable bounds */ x1 <= 4; x3 <= 1; Note the -wafter option. If this option is not specified, the original model is printed. The reason for this is the moment that write_lp is called. The effect of presolve happens when a solve is done. If write_lp is called before solve then the original model is given. If called after solve then the presolved model is.
As previously stated, presolve can result in removal of variables and/or constraints.
For some models, presolve can even find the solution of the model. Example in C:
#include <stdio.h>
#include "lp_lib.h"
int main(void)
{
# if defined ERROR
# undef ERROR
# endif
# define ERROR() { fprintf(stderr, "Error\n"); exit(1); }
lprec *lp;
if ((lp=make_lp(0, 3)) == NULL)
ERROR();
set_col_name(lp, 1, "x1");
set_col_name(lp, 2, "x2");
set_col_name(lp, 3, "x3");
set_maxim(lp);
if (!str_add_constraint(lp, "0 1 0", EQ, 2))
ERROR();
set_row_name(lp, 1, "R1");
if (!str_add_constraint(lp, "1 1 0", LE, 6))
ERROR();
set_row_name(lp, 2, "R2");
if (!str_add_constraint(lp, "1 0 -2", GE, 2))
ERROR();
set_row_name(lp, 3, "R3");
if (!str_add_constraint(lp, "0 1 3", LE, 5))
ERROR();
set_row_name(lp, 4, "R4");
if (!str_set_obj_fn(lp, "1 1 1"))
ERROR();
write_LP(lp, stdout);
set_presolve(lp, PRESOLVE_ROWS + PRESOLVE_COLS, 0);
solve(lp);
print_objective(lp);
print_solution(lp, 1);
print_constraints(lp, 1);
print_duals(lp);
write_LP(lp, stdout);
delete_lp(lp);
}
This gives:
/* Objective function */
max: +x1 +x2 +x3;
/* Constraints */
R1: +x2 = 2;
R2: +x1 +x2 <= 6;
R3: +x1 -2 x3 >= 2;
R4: +x2 +3 x3 <= 5;
Model name: '' - run #1
Objective: Maximize(R0)
SUBMITTED
Model size: 4 constraints, 3 variables, 7 non-zeros.
Sets: 0 GUB, 0 SOS.
Presolve O:1 -> Reduced rows: 3, cols: 1 --- changed bnds: 4, Ab: 0.
PRESOLVE Elimination loops performed.......... O3:M3:I5
1 empty or fixed variables............. REMOVED.
3 empty or redundant constraints....... REMOVED.
4 bounds............................... TIGHTENED.
[ +2 < Z < +7 ]
REDUCED
Model size: 1 constraints, 2 variables, 2 non-zeros.
Sets: 0 GUB, 0 SOS.
Row-types: 0 LE, 1 GE, 0 EQ.
Using DUAL simplex for phase 1 and PRIMAL simplex for phase 2.
The primal and dual simplex pricing strategy set to 'Devex'.
Optimal solution 7 after 0 iter.
Excellent numeric accuracy ||*|| = 0
MEMO: lp_solve version 5.5.0.13 for 32 bit OS, with 64 bit REAL variables.
In the total iteration count 0, 0 (100.0%) were bound flips.
There were 0 refactorizations, 0 triggered by time and 0 by density.
... on average 0.0 major pivots per refactorization.
The largest [etaPFI v1.4] fact(B) had 0 NZ entries, 0.0x largest basis.
The constraint matrix inf-norm is 2, with a dynamic range of 2.
Time to load data was 0.235 seconds, presolve used 0.140 seconds,
... 0.047 seconds in simplex solver, in total 0.422 seconds.
Value of objective function: 7
Actual values of the variables:
x1 4
x2 2
x3 1
Actual values of the constraints:
R3 2
Objective function limits:
From Till FromValue
x1 0 1e+030 -1e+030
x3 0 1e+030 -1e+030
Dual values with from - till limits:
Dual value From Till
R3 0 -1e+030 1e+030
x1 1 4 1e+030
x3 1 -1e+030 1
/* Objective function */
max: +x1 +x3 +2;
/* Constraints */
R3: +x1 -2 x3 >= 2;
/* Variable bounds */
x1 <= 4;
x3 <= 1;
The result only shows values of contraint R3, the one that is kept.
The information of the removed constraints is no longer there. Almost all API calls return information of the presolved model. get_Nrows and get_Ncolumns return the number of rows and columns of the presolved model. To know the original values, get_Norig_rows and get_Norig_columns must be used:
printf("get_Nrows: %d\n", get_Nrows(lp));
printf("get_Norig_rows: %d\n", get_Norig_rows(lp));
printf("get_Ncolumns: %d\n", get_Ncolumns(lp));
printf("get_Norig_columns: %d\n", get_Norig_columns(lp));
get_Nrows: 1
get_Norig_rows: 4
get_Ncolumns: 2
get_Norig_columns: 3
To retrieve the variable data of all variables, including the presolved variables, API call
get_var_primalresult must be used.
This is the only call available to get all information.
int column, Nrows, Ncolumns;
Ncolumns = get_Norig_columns(lp);
Nrows = get_Norig_rows(lp);
for (column = 1; column <= Ncolumns; column++) {
printf("x%d: %f\n", column, get_var_primalresult(lp, Nrows + column));
}
With result: x1: 4.000000 x2: 2.000000 x3: 1.000000
get_var_primalresult also returns information about rows.
int row, Nrows;
Nrows = get_Norig_rows(lp);
for (row = 1; row <= Nrows; row++) {
printf("R%d: %f\n", row, get_var_primalresult(lp, row));
}
With result: R1: 0.000000 R2: 0.000000 R3: 2.000000 R4: 0.000000 You could think here that a result for all original rows are returned, but this is not the case. Only the result of constraints that were kept in the model are given. The other rows will return 0!
There is also a possibility to know which rows and columns are removed from the model.
get_orig_index can be used for that.
int row, Nrows;
int column, Ncolumns;
Ncolumns = get_Ncolumns(lp);
Nrows = get_Nrows(lp);
for (row = 1; row <= Nrows; row++)
printf("row %d was row R%d\n", row, get_orig_index(lp, row));
for (column = 1; column <= Ncolumns; column++)
printf("column %d was column x%d\n", column, get_orig_index(lp, Nrows + column));
With result: row 1 was row R3 column 1 was column x1 column 2 was column x3 So from this it can be determined that only row R3 and columns x1 and x3 are kept in the model. The others are removed by presolve. Again note that all other API calls return information about the presolved model. So for example get_ptr_primal_solution must be used like this:
int row, Nrows;
int column, Ncolumns;
double *pv;
get_ptr_primal_solution(lp, &pv);
Ncolumns = get_Ncolumns(lp);
Nrows = get_Nrows(lp);
for (row = 1; row <= Nrows; row++)
printf("row %d: %f\n", row, pv[row]);
for (column = 1; column <= Ncolumns; column++)
printf("column %d: %f\n", column, pv[Nrows + column]);
With result: row 1: 2.000000 column 1: 4.000000 column 2: 1.000000 Row and column names of the original model can be obtained via get_origrow_name and get_origcol_name:
int row, Nrows;
int column, Ncolumns;
Ncolumns = get_Norig_columns(lp);
Nrows = get_Norig_rows(lp);
for (row = 1; row <= Nrows; row++)
printf("row %d: %s\n", row, get_origrow_name(lp, row));
for (column = 1; column <= Ncolumns; column++)
printf("column %d: %s\n", column, get_origcol_name(lp, column));
With result: row 1: R1 row 2: R2 row 3: R3 row 4: R4 column 1: x1 column 2: x2 column 3: x3 Row and column names of the presolved model can be obtained via get_row_name and get_col_name:
int row, Nrows;
int column, Ncolumns;
Ncolumns = get_Ncolumns(lp);
Nrows = get_Nrows(lp);
for (row = 1; row <= Nrows; row++)
printf("row %d: %s\n", row, get_row_name(lp, row));
for (column = 1; column <= Ncolumns; column++)
printf("column %d: %s\n", column, get_col_name(lp, column));
With result: row 1: R3 column 1: x1 column 2: x3 |
get_orig_indexReturns the original row/column where a constraint/variable was before presolve. int get_orig_index(lprec *lp, int lp_index); Return Value get_orig_index returns the original row/column where a constraint/variable was before presolve. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI lp_index constraint or column number. If lp_index is between 1 and get_Nrows then the index is a constraint (row) number. If lp_index is between 1+get_Nrows and get_Nrows + get_Ncolumns then the index is a column number. Remarks The get_orig_index function returns the original row/column where a constraint/variable was before presolve. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_lp_index, get_Ncolumns, get_Norig_columns, get_Nrows, get_Norig_rows, get_Lrows, get_lp_index |
get_print_solReturns a flag if all intermediate valid solutions must be printed while solving. int get_print_sol(lprec *lp); Return Value get_print_sol returns the debug print status. Can by any of following values: Can be any of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_print_sol function returns a flag if all intermediate valid solutions must be printed while solving. Can give you useful solutions even if the total run time is too long. This function is mend for debugging purposes. The default is not to print (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_print_sol |
set_constr_typeSet the type of a constraint. unsigned char set_constr_type(lprec *lp, int row, int con_type); Return Value set_constr_type returns TRUE (1) if the operation was successful. A
return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the constraint type must be set. Must be between 1 and number of rows in the lp. con_type The type of the constraint. Can by any of the following values:
Remarks The set_constr_type function sets the constraint type for the specified
row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_constr_type, is_constr_type, add_constraint, add_constraintex, str_add_constraint, del_constraint |
get_basiscrashDetermines a starting base. int get_basiscrash(lprec *lp); Return Value Specifies which basis crash mode is used. Can by any of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_basiscrash function returns which basis crash mode must be used. Default is CRASH_NONE. When no base crash is done (the default), the initial basis from which lp_solve starts to solve the model is the basis containing all slack or artificial variables that is automatically associates with each constraint. When base crash is enabled, a heuristic ``crash procedure'' is executed before the first simplex iteration to quickly choose a basis matrix that has fewer artificial variables. This procedure tends to reduce the number of iterations to optimality since a number of iterations are skipped. lp_solve starts iterating from this basis until optimality. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_basiscrash, default_basis, get_basis, set_basis, read_basis, write_basis, guess_basis |
delete_lpDeletes an lprec structure. void delete_lp(lprec *lp); Return Value None Parameters lp lprec structure to delete. Remarks The delete_lp function frees all memory allocated to the lp structure. Example See Also free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI |
set_BFPSet basis factorization package. unsigned char set_BFP(lprec *lp, char *filename); Return Value set_BFP returns TRUE if the call has succeeded, else FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI filename The name of the BFP package. Currently following BFPs are implemented:
Remarks The set_BFP function sets the basis factorization package (BFP). See Basis Factorization Packages for a complete description on BFPs. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, has_BFP, is_nativeBFP |
get_Norig_columnsReturns the number of original columns (variables) in the lp. int get_Norig_columns(lprec *lp); Return Value get_Norig_columns returns the number of original columns (variables) in
the lp. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_Norig_columns function returns the number of original columns
(variables) in the lp. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_Ncolumns, get_Nrows, get_Norig_rows, get_orig_index, get_lp_index, get_Lrows |
is_integerscalingReturns if integer scaling is active. unsigned char is_integerscaling(lprec *lp); Return Value is_integerscaling returns if integer scaling is active (SCALE_INTEGERS set in get_scalelimit) Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The is_integerscaling function returns if integer scaling is active (SCALE_INTEGERS set in get_scalelimit). By default integers are not scaled. set_scaling must be called to active this feature. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_scaling, set_scaling, set_scalelimit, get_scalelimit |
set_binarySet the type of the variable. Binary or floating point. unsigned char set_binary(lprec *lp, int column, unsigned char must_be_bin); Return Value set_binary returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be set. It must be between 1 and the number of columns in the lp. must_be_bin TRUE (1) if the variable must be binary, FALSE (0) if not. Remarks The set_binary function defines if a variable must be binary or not. Default a variable is not binary. A binary variable is an integer variable with a lower bound of 0 and an upper bound of 1. This function also sets these bounds. The argument must_be_bin defines what the status of the variable becomes. From the moment there is at least one integer variable in the model, the Branch and Bound algorithm is used to make these variables integer. Note that solving times can be considerably larger when there are integer variables. See integer variables for a description about integer variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_binary, is_int, set_int |
is_break_at_firstReturns if the branch-and-bound algorithm stops at first found solution. unsigned char is_break_at_first(lprec *lp); Return Value is_break_at_first returns if the branch-and-bound algorithm stops at
first found solution. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The is_break_at_first function returns if the branch-and-bound algorithm
stops at the first found solution or not. Stopping at the first found solution
can be useful if you are only interested for a solution, but not necessarily
(and most probably) the most optimal solution. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_break_at_first, set_break_at_value, get_break_at_value, set_obj_bound, get_obj_bound, set_mip_gap, get_mip_gap |
free_lpDeletes an lprec structure and initialise the plp variable. void free_lp(lprec **plp); Return Value None Parameters plp lprec structure to delete. After the call, *plp will be set to NULL. Remarks The free_lp function frees all memory allocated to the lp structure and initialises the *plp variable. Example See Also delete_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI |
get_col_name, get_origcol_nameGets the name of a column in the lp. char *get_col_name(lprec *lp, int column); char *get_origcol_name(lprec *lp, int column); Return Value get_col_name and get_origcol_name return the name of the specified column. A return value of NULL indicates an error. The difference between get_col_name and get_origcol_name is only visible when a presolve (set_presolve) was done. Presolve can result in deletion of columns in the model. In get_col_name, column specifies the column number after presolve was done. In get_origcol_name, column specifies the column number before presolve was done, ie the original column number. If presolve is not active then both functions are equal. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column for which the name must be retrieved. Must be between 1 and the number of columns in the lp. In get_col_name, column specifies the column number after presolve was done. In get_origcol_name, column specifies the column number before presolve was done, ie the original column number. Remarks The get_col_name and get_origcol_name functions return the name of
the column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_col_name, set_row_name, get_row_name, get_origrow_name, get_nameindex |
set_maxpivotSets the maximum number of pivots between a re-inversion of the matrix. void set_maxpivot(lprec *lp, int max_num_inv); Return Value set_maxpivot has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI max_num_inv The maximum number of pivots between a re-inversion of the matrix. Remarks The set_maxpivot function sets the maximum number of pivots between a
re-inversion of the matrix. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_maxpivot |
get_infiniteReturns the value of "infinite". REAL get_infinite(lprec *lp); Return Value get_infinite returns the value of "infinite". Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_infinite function returns the practical value for "infinite".
This value is used for very big numbers. For example the upper bound of a
variable without an upper bound. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_infinite, is_infinite, set_epsint, get_epsint, set_epsb, get_epsb, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb |
get_epspivotReturns epspivot. REAL get_epspivot(lprec *lp); Return Value get_epspivot returns the value of epspivot. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_epspivot function returns the value that is used as a tolerance
for the pivot element to determine whether a value should be considered as 0. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_epspivot, set_infinite, get_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsel, get_epsel, get_epsperturb, set_epsperturb, set_mip_gap, get_mip_gap |
is_piv_ruleChecks if the specified pivot rule is active. unsigned char is_piv_rule(lprec *lp, int rule); Return Value is_piv_rule returns TRUE if the specified pivot rule is active, else FALSE Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI rule Can be one of the following values:
Remarks This rule can influence solving times
considerably. Depending on the model one rule can be best and for another model
another rule. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_pivoting, set_pivoting, is_piv_mode |
reset_basisCauses reinversion at next opportunity void reset_basis(lprec *lp); Return Value reset_basis has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
This routine is ment for internal use and development.
It causes a reinversion of the matrix at a next opportunity.
The routine should only be used by people deeply understanding the code. See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_basis, set_basis, default_basis, get_basiscrash set_basiscrash |
set_minimSet objective function to minimize. void set_minim(lprec *lp); Return Value set_minim has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The set_minim function sets the objective direction to minimize. The default of lp_solve is to minimize, except for read_lp, read_LP where the default is to maximize. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_maxim, is_maxim, set_sense |
The MPS format can also be used to specify some predefined basis for an LP problem, i.e. to specify which rows and columns are basic and which are non-basic.
As in the MPS format, a number of fields are defined on fixed column positions:
Field: 1 2 3 4 5 6 Columns: 2-3 5-12 15-22 25-36 40-47 50-61
The order of a basis file in the MPS format is:
Any line with an asterisk (*) in Column 1 is treated as a comment.
The NAME card can have anything you want, starting in column 15.
lp_solve sets the number of iterations, the number of rows and number of columns of the model to the NAME record.
The eight character names used to specify variables and constraints entities are fixed format. Names are not automatically justified, so blanks are treated just like other characters. For example "ROW1 " is not the same as " ROW1 ". (Note that some optimisers do not permit blanks in names.) No case conversion is performed, so "row1 " is different from "ROW1 ".
Each data card specifies either a pair "basic column--non-basic row" or a non-basic column. All the data cards have the following format.
'XL' in the field 1 means that a column, whose name is given in
the field 2, is basic, and a row, whose name is given in the field 3,
is non-basic and placed on its lower bound.
'XU' in the field 1 means that a column, whose name is given in
the field 2, is basic, and a row, whose name is given in the field 3,
is non-basic and placed on its upper bound.
'LL' in the field 1 means that a column, whose name is given in
the field 3, is non-basic and placed on its lower bound.
'UL' in the field 1 means that a column, whose name is given in
the field 3, is non-basic and placed on its upper bound.
The field 2 contains a column name.
If the indicator given in the field 1 is 'XL' or 'XU',
the field 3 contains a row name. Otherwise, if the indicator is
'LL' or 'UL', the field 3 is not used and should be empty.
The field 4, 5, and 6 are not used and should be empty.
| Value | Status |
|---|---|
XU | Variable 1 is basic; variable 2 is nonbasic at its upper bound |
XL | Variable 1 is basic; variable 2 is nonbasic at its lower bound |
UL | Variable 1 is nonbasic and is at its upper bound |
LL | Variable 1 is nonbasic and is at its lower bound |
Field 1: Indicator specifying status of the named variables in Fields 2 and 3.
Field 2: Variable 1 identifier
Field 3: Variable 2 identifier (ignored if Field 1 is UL or LL)
Variable 1 specifies a structural variable identifier which has entered the basis. By convention, this structural variable must displace one of the row variables. Variable 2 is a row variable that has left the basis. No relationship between structural variables entering the basis and row variables leaving the basis is implied within the BAS file.
A basis file in the MPS format acts like a patch: it doesn't specify a basis completely, instead that it is just shows in what a given basis differs from the "standard" basis, where all rows (auxiliary variables) are assumed to be basic and all columns (structural variables) are assumed to be non-basic.
A basis defines a list of basic structural variables and row variables. A structural variable is one of the variables (columns) defined in the MPS problem file. A row variable is actually the slack, surplus, or artificial variable associated with a row. The total number of basic variables-both structural and row-is equal to the number of rows in the constraint matrix. Additionally, the number of basic structural variables is equal to the number of nonbasic row variables. By convention, an MPS basis file is built on the assumption that all row variables are basic and that all structural variables are nonbasic with values at their lower bound. The data records in a BAS file list structural and row variables that violate this assumption. This convention minimizes the size of the BAS file.
Example:
*000000001111111111222222222233333333334444444444555555555566 *234567890123456789012345678901234567890123456789012345678901 NAME TESTPROB Iterations 0 Rows 3 Cols 3 XL ZTHREE LIM2 UL XONE ENDATAdocs/5.5/Java/ 0000755 0001750 0001750 00000000000 11306036627 011646 5 ustar rene rene docs/5.5/Java/docs/ 0000755 0001750 0001750 00000000000 11306036627 012576 5 ustar rene rene docs/5.5/Java/docs/api/ 0000755 0001750 0001750 00000000000 11306036627 013347 5 ustar rene rene docs/5.5/Java/docs/api/lpsolve/ 0000755 0001750 0001750 00000000000 11306036627 015033 5 ustar rene rene docs/5.5/Java/docs/api/lpsolve/package-summary.html 0000644 0001750 0001750 00000017371 11306036626 021017 0 ustar rene rene
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
See:
Description
| Interface Summary | |
| AbortListener | Classes that implement this interface may be passed
to the putAbortfunc method of the LpSolve class. |
| BbListener | Classes that implement this interface may be passed
to the putbbBranchfunc and putbbNodefunc method
of the LpSolve class. |
| LogListener | Classes that implement this interface may be passed
to the putLogfunc method of the LpSolve class. |
| MsgListener | Classes that implement this interface may be passed
to the putMsgfunc method of the LpSolve class. |
| Class Summary | |
| LpSolve | Object wrapper for a problem structure of the lp_solve library. |
| VersionInfo | Contains the full version info for a lp_solve library instance. |
| Exception Summary | |
| LpSolveException | Exception thrown by the native methods in the C stub DLL. |
This package contains the files for the Java wrapper for the lp_solve optimization library. See the file README.html in the root direcory of the distribution archive for details.
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
| AbortListener
BbListener LogListener LpSolve LpSolveException MsgListener VersionInfo |
This file contains a reference for all methods in the lp_solve library and the Java wrapper. The first column of the following table contains the C functions of the lp_solve library, the second column the corresponding methods of the Java wrapper.
| C function | Java wrapper method (LpSolve class) |
|---|---|
| unsigned char add_column (lprec* lp, REAL* column) | void addColumn(double[] column) throws LpSolveException |
| unsigned char add_columnex (lprec* lp, int count, REAL* column, int* rowno) | void addColumnex(int count, double[] column, int[] rowno) throws LpSolveException |
| unsigned char add_constraint (lprec* lp, REAL *row, int constr_type, REAL rh) | void addConstraint(double[] row, int constrType, double rh) throws LpSolveException |
| unsigned char add_constraintex (lprec *lp, int count, REAL *row, int *colno, int constr_type, REAL rh) | void addConstraintex(int count, double[] row, int[] colno, int constrType, double rh) throws LpSolveException |
| unsigned char add_lag_con (lprec* lp, REAL *row, int con_type, REAL rhs) | void addLagCon(double[] row, int constrType, double rh) throws LpSolveException |
| int add_SOS (lprec* lp, char *name, int sostype, int priority, int count, int *sosvars, REAL *weights) | void addSOS(String name, int sostype, int priority, int count, int[] sosvars, double[] weights) throws LpSolveException |
| int column_in_lp (lprec* lp, REAL *column) | int columnInLp(double[] column) |
| void default_basis (lprec* lp) | void defaultBasis() |
| unsigned char del_column(lprec *lp, int column) | void delColumn(int columnnr) throws LpSolveException |
| unsigned char del_constraint(lprec *lp, int del_row) | void delConstraint(int rownr) throws LpSolveException |
| void delete_lp(lprec *lp) | void deleteLp() |
| void free_lp(lprec **plp) | <Not implemented, use deleteLp() instead> |
| int get_anti_degen(lprec *lp) | int getAntiDegen() |
| void get_basis(lprec *lp, int *bascolumn, unsigned char nonbasic) | void getBasis(int[] bascolumn, boolean nonbasic) |
| int get_basiscrash(lprec *lp) | int getBasiscrash() |
| int get_bb_depthlimit(lprec *lp) | int getBbDepthlimit() |
| int get_bb_floorfirst(lprec *lp) | int getBbFloorfirst() |
| int get_bb_rule(lprec *lp) | int getBbRule() |
| unsigned char get_bounds_tighter(lprec *lp) | boolean getBoundsTighter() |
| REAL get_break_at_value(lprec *lp) | double getBreakAtValue() |
| char *get_col_name(lprec *lp, int column) | String getColName(int colnr) throws LpSolveException |
| unsigned char get_column(lprec *lp, int col_nr, REAL *column) | void getColumn(int columnrnr, double[] column) throws LpSolveException |
| <Not implemented> | double[] getPtrColumn(int columnrnr) throws LpSolveException |
| int get_constr_type(lprec *lp, int row) | short getConstrType(int rownr) throws LpSolveException |
| unsigned char get_constraints(lprec *lp, REAL *constr) | void getConstraints(double[] var) throws LpSolveException |
| unsigned char get_dual_solution(lprec *lp, REAL *duals) | void getDualSolution(double[] duals) throws LpSolveException |
| REAL get_epsb(lprec *lp) | double getEpsb() |
| REAL get_epsd(lprec *lp) | double getEpsd() |
| REAL get_epsel(lprec *lp) | double getEpsel() |
| REAL get_epsint(lprec *lp) | double getEpsint() |
| REAL get_epsperturb(lprec *lp) | double getEpsperturb() |
| REAL get_epspivot(lprec *lp) | double getEpspivot() |
| int get_improve(lprec *lp) | int getImprove() |
| REAL get_infinite(lprec *lp) | double getInfinite() |
| unsigned char get_lambda(lprec *lp, REAL *lambda) | void getLambda(double[] lambda) throws LpSolveException |
| REAL get_lowbo(lprec *lp, int column) | double getLowbo(int colnr) throws LpSolveException |
| int get_lp_index(lprec *lp, int orig_index) | int getLpIndex(int index) |
| char *get_lp_name(lprec *lp) | String getLpName() throws LpSolveException |
| int get_Lrows(lprec *lp) | int getLrows() |
| REAL get_mat(lprec *lp, int row, int column) | double getMat(int row, int column) |
| int get_max_level(lprec *lp) | int getMaxLevel() |
| int get_maxpivot(lprec *lp) | int getMaxpivot() |
| REAL get_mip_gap(lprec *lp, unsigned char absolute) | double getMipGap(boolean absolute) |
| int get_Ncolumns(lprec *lp) | int getNcolumns() |
| REAL get_negrange(lprec *lp) | double getNegrange() |
| int get_nonzeros(lprec *lp) | int getNonzeros() |
| int get_Norig_columns(lprec *lp) | int getNorigColumns() |
| int get_Norig_rows(lprec *lp) | int getNorigRows() |
| int get_Nrows(lprec *lp) | int getNrows() |
| REAL get_obj_bound(lprec *lp) | double getObjBound() |
| REAL get_objective(lprec *lp) | getObjective() |
| int get_orig_index(lprec *lp, int lp_index) | int getOrigIndex(int index) |
| char *get_origcol_name(lprec *lp, int column) | String getOrigcolName(int colnr) throws LpSolveException |
| char *get_origrow_name(lprec *lp, int row) | String getOrigrowName(int rownr) throws LpSolveException |
| int get_pivoting(lprec *lp) | int getPivoting() |
| int get_presolve(lprec *lp) | int getPresolve() |
| unsigned char get_primal_solution(lprec *lp, REAL *pv) | void getPrimalSolution(double[] pv) throws LpSolveException |
| int get_print_sol(lprec *lp) | int getPrintSol() |
| unsigned char get_ptr_constraints(lprec *lp, REAL **ptr_constr) | double[] getPtrConstraints() throws LpSolveException |
| unsigned char get_ptr_dual_solution(lprec *lp, REAL **ptr_duals) | double[] getPtrDualSolution() throws LpSolveException |
| unsigned char get_ptr_lambda(lprec *lp, REAL **ptr_lambda) | double[] getPtrLambda() throws LpSolveException |
| unsigned char get_ptr_primal_solution(lprec *lp, REAL **ptr_pv) | double[] getPtrPrimalSolution() throws LpSolveException |
| unsigned char get_ptr_sensitivity_obj(lprec *lp, REAL **ptr_objfrom, REAL **ptr_objtill) | double[][] getPtrSensitivityObj() throws LpSolveException |
| unsigned char get_ptr_sensitivity_objex(lprec *lp, REAL **ptr_objfrom, REAL **ptr_objtill, REAL *ptr_objfromvalue, REAL *ptr_objtillvalue) | double[][] getPtrSensitivityObjex() throws LpSolveException |
| unsigned char get_ptr_sensitivity_rhs(lprec *lp, REAL **ptr_duals, REAL **ptr_dualsfrom, REAL **ptr_dualstill) | double[][] getPtrSensitivityRhs() throws LpSolveException |
| unsigned char get_ptr_variables(lprec *lp, REAL **ptr_var) | double[] getPtrVariables() throws LpSolveException |
| REAL get_rh(lprec *lp, int row) | double getRh(int row) |
| REAL get_rh_range(lprec *lp, int row) | double getRhRange(int rownr) throws LpSolveException |
| unsigned char get_row(lprec *lp, int row_nr, REAL *row) | void getRow(int rownr, double[] row) throws LpSolveException |
| <Not implemented> | double[] getPtrRow(int rownr) throws LpSolveException |
| char *get_row_name(lprec *lp, int row) | String getRowName(int rownr) throws LpSolveException |
| REAL get_scalelimit(lprec *lp) | double getScalelimit() |
| int get_scaling(lprec *lp) | int getScaling() |
| unsigned char get_sensitivity_obj(lprec *lp, REAL *objfrom, REAL *objtill) | void getSensitivityObj(double[] objfrom, double[] objtill) throws LpSolveException |
| unsigned char get_sensitivity_objex(lprec *lp, REAL *objfrom, REAL *objtill, REAL *objfromvalue, REAL *objtillvalue) | void getSensitivityObjex(double[] objfrom, double[] objtill, double[] objfromvalue, double[] objtillvalue) throws LpSolveException |
| unsigned char get_sensitivity_rhs(lprec *lp, REAL *duals, REAL *dualsfrom, REAL *dualstill) | void getSensitivityRhs(double[] duals, double[] dualsfrom, double[] dualstill) throws LpSolveException |
| int get_simplextype(lprec *lp) | int getSimplextype() |
| int get_solutioncount(lprec *lp) | int getSolutioncount() |
| int get_solutionlimit(lprec *lp) | int getSolutionlimit() |
| int get_status(lprec *lp) | int getStatus() |
| char *get_statustext(lprec *lp, int statuscode) | String getStatustext(int statuscode) |
| long get_timeout(lprec *lp) | long getTimeout() |
| int get_total_iter(lprec *lp) | int getTotalIter() |
| int get_total_nodes(lprec *lp) | int getTotalNodes() |
| REAL get_upbo(lprec *lp, int column) | double getUpbo(int colnr) throws LpSolveException |
| int get_var_branch(lprec *lp, int column) | int getVarBranch(int colnr) throws LpSolveException |
| REAL get_var_dualresult(lprec *lp, int index) | double getVarDualresult(int index) throws LpSolveException |
| REAL get_var_primalresult(lprec *lp, int index) | double getVarPrimalresult(int index) throws LpSolveException |
| int get_var_priority(lprec *lp, int column) | int getVarPriority(int colnr) throws LpSolveException |
| unsigned char get_variables(lprec *lp, REAL *var) | void getVariables(double[] var) throws LpSolveException |
| int get_verbose(lprec *lp) | int getVerbose() |
| REAL get_working_objective(lprec *lp) | double getWorkingObjective() throws LpSolveException |
| unsigned char guess_basis(lprec *lp, double *guessvector, int *basisvector) | void guessBasis(double[] guessvector, int[] basisvector) throws LpSolveException |
| unsigned char has_BFP(lprec *lp) | boolean hasBFP() |
| unsigned char has_XLI(lprec *lp) | boolean hasXLI() |
| unsigned char is_add_rowmode(lprec *lp) | boolean isAddRowmode() |
| unsigned char is_anti_degen(lprec *lp, int testmask) | boolean isAntiDegen(int testmask) |
| unsigned char is_binary(lprec *lp, int column) | boolean isBinary(int colnr) |
| unsigned char is_break_at_first(lprec *lp) | boolean isBreakAtFirst() |
| unsigned char is_constr_type(lprec *lp, int row, int mask) | boolean isConstrType(int row, int mask) |
| unsigned char is_debug(lprec *lp) | boolean isDebug() |
| unsigned char is_feasible(lprec *lp, REAL *values, REAL threshold) | boolean isFeasible(double[] values, double threshold) throws LpSolveException |
| unsigned char is_free(lprec *lp, int column) | boolean isFree(int colnr) |
| unsigned char is_infinite(lprec *lp, REAL value) | boolean isInfinite(double value) |
| unsigned char is_int(lprec *lp, int column) | boolean isInt(int colnr) |
| unsigned char is_integerscaling(lprec *lp) | boolean isIntegerscaling() |
| unsigned char is_lag_trace(lprec *lp) | boolean isLagTrace() |
| unsigned char is_maxim(lprec *lp) | boolean isMaxim() |
| unsigned char is_nativeBFP(lprec *lp) | boolean isNativeBFP() |
| unsigned char is_nativeXLI(lprec *lp) | boolean isNativeXLI() |
| unsigned char is_negative(lprec *lp, int column) | boolean isNegative(int colnr) |
| unsigned char is_piv_mode(lprec *lp, int testmask) | boolean isPivMode(int testmask) |
| unsigned char is_piv_rule(lprec *lp, int rule) | boolean isPivRule(int rule) |
| unsigned char is_presolve(lprec *lp, int testmask) | boolean isPresolve(int testmask) |
| unsigned char is_scalemode(lprec *lp, int testmask) | boolean isScalemode(int testmask) |
| unsigned char is_scaletype(lprec *lp, int scaletype) | boolean isScaletype(int scaletype) |
| unsigned char is_semicont(lprec *lp, int column) | boolean isSemicont(int colnr) |
| unsigned char is_SOS_var(lprec *lp, int column) | boolean isSOSVar(int colnr) throws LpSolveException |
| unsigned char is_trace(lprec *lp) | boolean isTrace() |
| int lag_solve(lprec *lp, REAL start_bound, int num_iter, short verbose) | <Function is currently not exported from lp_solve dll> |
| void lp_solve_version(int *majorversion, int *minorversion, int *release, int *build) | static VersionInfo lpSolveVersion() |
| lprec *make_lp(int rows, int columns) | static LpSolve makeLp(int rows, int columns) throws LpSolveException |
| void print_constraints(lprec *lp, int columns) | void printConstraints(int columns) |
| unsigned char print_debugdump(lprec *lp, char *filename) | void printDebugdump(String filename) throws LpSolveException |
| void print_duals(lprec *lp) | void printDuals() |
| void print_lp(lprec *lp) | void printLp() |
| void print_objective(lprec *lp) | void printObjective() |
| void print_scales(lprec *lp) | void printScales() |
| void print_solution(lprec *lp, int columns) | void printSolution(int columns) |
| void print_str(lprec *lp, char *str) | void printStr(String str) |
| void print_tableau(lprec *lp) | void printTableau() |
| void put_abortfunc(lprec *lp, ctrlcfunc newctrlc, void *ctrlchandle) | void putAbortfunc(AbortListener listener, Object userhandle) throws LpSolveException |
| void put_logfunc(lprec *lp, logfunc newlog, void *loghandle) | void putLogfunc(LogListener listener, Object userhandle) throws LpSolveException |
| void put_msgfunc(lprec *lp, msgfunc newmsg, void *msghandle, int mask) | void putMsgfunc(MsgListener listener, Object userhandle, int mask) throws LpSolveException |
| lprec *read_freeMPS(char *filename, int verbose) | static LpSolve readFreeMps(String filename, int verbose) throws LpSolveException |
| lprec *read_freemps(FILE *stream, int verbose) | <Not implemented, use readFreeMps instead> |
| lprec *read_lp(FILE *stream, int verbose, char *lp_name) | <Not implemented, use readLp instead> |
| lprec *read_LP(char *filename, int verbose, char *lp_name) | static LpSolve readLp(String filename, int verbose, String lpName) throws LpSolveException |
| lprec *read_lpt(FILE *stream, int verbose, char *lp_name) | <Not implemented, use readLpt instead> |
| lprec *read_LPT(char *filename, int verbose, char *lp_name) | static LpSolve readLpt(String filename, int verbose, String lpName) throws LpSolveException |
| lprec *read_mps(FILE *stream, int verbose) | <Not implemented, use readMps instead> |
| lprec *read_MPS(char *filename, int verbose) | static LpSolve readMps(String filename, int verbose) throws LpSolveException |
| lprec *read_XLI(char *xliname, char *modelname, char *dataname, char *options, int verbose) | static LpSolve readXLI(String xliname, String modelname, String dataname, String options, int verbose) throws LpSolveException |
| void reset_basis(lprec *lp) | void resetBasis() |
| unsigned char resize_lp(lprec *lp, int rows, int columns) | void resizeLp(int rows, int columns) throws LpSolveException |
| unsigned char set_add_rowmode(lprec *lp, unsigned char turnon) | boolean setAddRowmode(boolean turnon) |
| void set_anti_degen(lprec *lp, int anti_degen) | void setAntiDegen(int antiDegen) |
| unsigned char set_basis(lprec *lp, int *bascolumn, unsigned char nonbasic) | void setBasis(int[] bascolumn, boolean nonbasic) throws LpSolveException |
| void set_basiscrash(lprec *lp, int mode) | void setBasiscrash(int mode) |
| void set_bb_depthlimit(lprec *lp, int bb_maxlevel) | void setBbDepthlimit(int bbMaxlevel) |
| void set_bb_floorfirst(lprec *lp, int bb_floorfirst) | void setBbFloorfirst(int floorFirst) |
| void set_bb_rule(lprec *lp, int bb_rule) | void setBbRule(int bbRule) |
| unsigned char set_BFP(lprec *lp, char *filename) | void setBFP(String filename) throws LpSolveException |
| unsigned char set_XLI(lprec *lp, char *filename) | void setXLI(String filename) throws LpSolveException |
| unsigned char set_binary(lprec *lp, int column, unsigned char must_be_bin) | void setBinary(int colnr, boolean mustBeBin) throws LpSolveException |
| unsigned char set_bounds(lprec *lp, int column, REAL lower, REAL upper) | void setBounds(int colnr, double lower, double upper) throws LpSolveException |
| void set_bounds_tighter(lprec *lp, unsigned char tighten) | void setBoundsTighter(boolean tighten) |
| void set_break_at_first(lprec *lp, unsigned char break_at_first) | void setBreakAtFirst(boolean breakAtFirst) |
| void set_break_at_value(lprec *lp, REAL break_at_value) | void setBreakAtValue(double breakAtValue) |
| unsigned char set_col_name(lprec *lp, int column, char *new_name) | void setColName(int colnr, String name) throws LpSolveException |
| unsigned char set_column(lprec *lp, int col_no, REAL *column) | void setColumn(int colno, double[] column) throws LpSolveException |
| unsigned char set_columnex(lprec *lp, int col_no, int count, REAL *column, int *rowno) | void setColumnex(int colno, int count, double[] column, int[] rowno) throws LpSolveException |
| unsigned char set_constr_type(lprec *lp, int row, int con_type) | void setConstrType(int rownr, int constrType) throws LpSolveException |
| void set_debug(lprec *lp, unsigned char debug) | void setDebug(boolean debug) |
| void set_epsb(lprec *lp, REAL epsb) | void setEpsb(double value) |
| void set_epsd(lprec *lp, REAL epsd) | void setEpsd(double value) |
| void set_epsel(lprec *lp, REAL epsel) | void setEpsel(double value) |
| void set_epsint(lprec *lp, REAL epsint) | void setEpsint(double value) |
| void set_epsperturb(lprec *lp, REAL epsperturb) | void setEpsperturb(double value) |
| void set_epspivot(lprec *lp, REAL epspivot) | void setEpspivot(double value) |
| unsigned char set_free(lprec *lp, int column) | void setFree(int colnr) throws LpSolveException |
| void set_improve(lprec *lp, int improve) | void setImprove(int improve) |
| void set_infinite(lprec *lp, REAL infinite) | void setInfinite(double value) |
| unsigned char set_int(lprec *lp, int column, unsigned char must_be_int) | void setInt(int colnr, boolean mustBeInteger) throws LpSolveException |
| void set_lag_trace(lprec *lp, unsigned char lag_trace) | void setLagTrace(boolean lagTrace) |
| unsigned char set_lowbo(lprec *lp, int column, REAL value) | void setLowbo(int colnr, double value) throws LpSolveException |
| unsigned char set_lp_name(lprec *lp, char *lpname) | void setLpName(String name) throws LpSolveException |
| unsigned char set_mat(lprec *lp, int row, int column, REAL value) | void setMat(int row, int column, double value) throws LpSolveException |
| void set_maxim(lprec *lp) | void setMaxim() |
| void set_maxpivot(lprec *lp, int max_num_inv) | void setMaxpivot(int maxNumInv) |
| void set_minim(lprec *lp) | void setMinim() |
| void set_mip_gap(lprec *lp, unsigned char absolute, REAL mip_gap) | void setMipGap(boolean absolute, double value) |
| void set_negrange(lprec *lp, REAL negrange) | void setNegrange(double negRange) |
| void set_obj_bound(lprec *lp, REAL obj_bound) | void setObjBound(double objBound) |
| unsigned char set_obj_fn(lprec *lp, REAL *row) | void setObjFn(double[] row) throws LpSolveException |
| unsigned char set_obj_fnex(lprec *lp, int count, REAL *row, int *colno) | void setObjFnex(int count, double[] row, int[] colno) throws LpSolveException |
| unsigned char set_obj(lprec *lp, int column, REAL value) | void setObj(int column, double value) throws LpSolveException |
| void set_outputstream(lprec *lp, FILE *stream) | <Not implemented, use setOutputfile instead> |
| unsigned char set_outputfile(lprec *lp, char *filename) | void setOutputfile(String filename) throws LpSolveException |
| void set_pivoting(lprec *lp, int pivoting) | void setPivoting(int pivRule) |
| void set_preferdual(lprec *lp, unsigned char dodual) | void setPreferdual(int dodual) |
| void set_presolve(lprec *lp, int do_presolve) | void setPresolve(int doPresolve) |
| void set_print_sol(lprec *lp, int print_sol) | void setPrintSol(int printSol) |
| unsigned char set_rh(lprec *lp, int row, REAL value) | void setRh(int row, double value) throws LpSolveException |
| unsigned char set_rh_range(lprec *lp, int row, REAL deltavalue) | void setRhRange(int rownr, double range) throws LpSolveException |
| void set_rh_vec(lprec *lp, REAL *rh) | void setRhVec(double[] rh) throws LpSolveException |
| unsigned char set_row(lprec *lp, int row_no, REAL *row) | void setRow(int rowno, double[] row) throws LpSolveException |
| unsigned char set_rowex(lprec *lp, int row_no, int count, REAL *row, int *colno) | void setRowex(int rowno, int count, double[] row, int[] colno) throws LpSolveException |
| unsigned char set_row_name(lprec *lp, int row, char *new_name) | void setRowName(int rownr, String name) throws LpSolveException |
| void set_scalelimit(lprec *lp, REAL scalelimit) | void setScalelimit(double scalelimit) |
| void set_scaling(lprec *lp, int scalemode) | void setScaling(int scalemode) |
| unsigned char set_semicont(lprec *lp, int column, unsigned char must_be_sc) | void setSemicont(int colnr, boolean mustBeSc) throws LpSolveException |
| void set_sense(lprec *lp, unsigned char maximize) | void setSense(boolean maximize) |
| void set_simplextype(lprec *lp, int simplextype) | void setSimplextype(int simplextype) |
| void set_solutionlimit(lprec *lp, int limit) | void setSolutionlimit(int limit) |
| void set_timeout(lprec *lp, long sectimeout) | void setTimeout(long timeout) |
| void set_trace(lprec *lp, unsigned char trace) | void setTrace(boolean trace) |
| unsigned char set_upbo(lprec *lp, int column, REAL value) | void setUpbo(int colnr, double value) throws LpSolveException |
| unsigned char set_var_branch(lprec *lp, int column, int branch_mode) | void setVarBranch(int colnr, int branchMode) throws LpSolveException |
| unsigned char set_var_weights(lprec *lp, REAL *weights) | void setVarWeights(double[] weights) throws LpSolveException |
| void set_verbose(lprec *lp, int verbose) | void setVerbose(int verbose) |
| int solve(lprec *lp) | int solve() throws LpSolveException |
| unsigned char str_add_column (lprec* lp, char* col_string) | void strAddColumn(String column) throws LpSolveException |
| unsigned char str_add_constraint (lprec* lp, char *row_string, int constr_type, REAL rh) | void strAddConstraint(String row, int constrType, double rh) throws LpSolveException |
| unsigned char str_add_lag_con (lprec* lp, char *row_string, int con_type, REAL rhs) | void strAddLagCon(String row, int constrType, double rh) throws LpSolveException |
| unsigned char str_set_obj_fn(lprec *lp, char *row_string) | void strSetObjFn(String row) throws LpSolveException |
| unsigned char str_set_rh_vec(lprec *lp, char *rh_string) | void strSetRhVec(String rh) throws LpSolveException |
| REAL time_elapsed(lprec *lp) | double timeElapsed() |
| void unscale(lprec *lp) | void unscale() |
| unsigned char write_freeMPS(lprec *lp, FILE *stream) | <Not implemented, use writeFreeMps instead> |
| unsigned char write_freemps(lprec *lp, char *filename) | void writeFreeMps(String filename) throws LpSolveException |
| unsigned char write_lp(lprec *lp, char *filename) | void writeLp(String filename) throws LpSolveException |
| unsigned char write_LP(lprec *lp, FILE *stream) | <Not implemented, use writeLp instead> |
| unsigned char write_mps(lprec *lp, char *filename) | void writeMps(String filename) throws LpSolveException |
| unsigned char write_MPS(lprec *lp, FILE *stream) | <Not implemented, use writeMps instead> |
| unsigned char write_XLI(lprec *lp, char *filename, char *options, unsigned char results) | void writeXLI(String filename, String options, boolean results) throws LpSolveException |
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:
LpSolve class.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.
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.
lpsolve55j.dll
to the directory that already contains lpsolve55.dll.
liblpsolve55j.so
to the directory that already contains liblpsolve55.so. Run ldconfig to include
the library in the shared libray cache.
To create a Java application that uses lp_solve routines, you must perform the following steps:
lpsolve55j.jar from the Java wrapper distribution to a
directory that is included in the CLASSPATH of your java program.lpsolve.* at the beginning of your
source file.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.LpSolve instance to define the problem and obtain the solution.
Use the examples and implementation notes later in this documentation for further
information.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.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();
}
}
}
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));
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
demo directory and
start the batch script "run_demo.bat".demo directory of the wrapper distribution and
run "sh run_demo".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.
str_add_constraint
becomes strAddConstraint in Java.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.set_row_name returns FALSE if an error has occured. In Java,
setRowName is of type void and throws a LpSolveException.boolean. Example:
set_debug(lprec *lp, unsigned char debug) is setDebug(boolean debug) in Java.
LpSolve object, which represents a problem, is only used by one thread at a
time.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.reference.html for details on how the lp_solve API functions
are mapped to the Java methods.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.
lp_solve_5.5_dev.zip unpackedlib/win32 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.
lp_solve_5.5_dev.tar.gz unpackedlib/linux 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.
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.
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.
get_scalingSpecifies which scaling algorithm is used. int get_scaling(lprec *lp); Return Value get_scaling returns which scaling algorithm is used. Can by any of the
following values:
Additionally, the value can be OR-ed with any combination of one of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_scaling function returns which scaling algorithm is used. This
can influence numerical stability considerably. It is advisable to always use
some sort of scaling. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_scaling, set_scalelimit, get_scalelimit, is_integerscaling, is_scalemode, is_scaletype |
LINDO lp filesThe LINDO LP file format provides a facility for entering a problem in a natural, algebraic LP formulation from the keyboard. The problem can be modified and saved from within lpsolve. This procedure is one way to create a file in a format that lpsolve can read. An alternative technique is to create a similar file using a standard text editor and to read it into lpsolve. The LINDO FILE format is provided as an input alternative to the MPS file format. An LP format file may be easier to generate than an MPS file if your problem already exists in an algebraic format or if you have an application that generates the problem file more readily in algebraic format (such as a C application). Note that the LINDO FILE format is not the same as the lpsolve LP format. See LP file format for a description about the native lpsolve lp format. To read/write this format from lpsolve, you need an XLI (see External Language Interfaces). The XLI for the LINDO format is called xli_LINDO. OptionsThe XLI accepts no options at this time. Examplelp_solve -rxli xli_LINDO input.lpt lp_solve -mps input.mps -wxli xli_LINDO output.lpt Syntax Rules of the LINDO FILE Formatlpsolve will accept any problem saved in an ASCII file provided that it adheres to the following syntax rules. The MPS file format is a column-oriented format. If a row-oriented format is more convenient, then the LINDO file format is of interest. The list of rules is rather short and easy to learn. Flow of ControlThe objective function must always be at the start of the model and is initiated with any of the following keywords:
The end of the objective function and the beginning of the constraints are signified with any of the following keywords:
The end of the constraints is signified with the word END. FormattingVariable names are limited to eight characters. Names must begin with an alphabetic character (A to Z), which may then be followed by up to seven additional characters. These additional characters may include anything with the exception of the following: ! ) + - = < >. As an example, the following names are valid:
whereas the following are not:
The first example contains more than eight characters, the second contains a forbidden hyphen, and the last example does not begin with an alphabetic character. You may, optionally, name constraints in a model. Constraint names must follow the same conventions as variable names. To name a constraint, you must start the constraint with its name terminated with a right parenthesis. After the right parenthesis, you enter the constraint as before. As an example, the following constraint is given the name XBOUND:
Only five operators are recognized: plus (+), minus (-), greater than (>), less than (<), and equals (=). When you enter the strict inequality operators greater than (>) and less than (<), they will be interpreted as the loose inequality operators greater-than-or-equal-to () and less-than-or-equal-to (), respectively. This is because many keyboards do not have the loose inequality operators. Even for systems having the loose operators, they will not be recognized. However, if you prefer, you may enter ">=" (and "<=") in place of ">" (and "<"). Parentheses as indicators of a preferred order of precedence are not accepted. All operations are ordered from left to right. Comments may be placed anywhere in a model. A comment is denoted by an exclamation mark. Anything following an exclamation mark on the current line will be considered a comment. For example:
Comments are allowed, but they will not be stored with the model. Therefore, if later an equivalent model will be written, the comments will be removed. Constraints and the objective function may be split over multiple lines or combined on single lines. You may split a line anywhere except in the middle of a variable name or a coefficient. The following would be mathematically equivalent to our example (although not quite as easy to read):
However, if the objective function appeared as follows:
then an error would be returned because the variable STD is split between lines and the coefficient 15 is also. Only constant values--not variables--are permitted on the right-hand side of a constraint equation. Thus, an entry such as:
would be rejected. Such an entry could be written as:
Conversely, only variables and their coefficients are permitted on the left-hand side of constraints. For instance, the constraint:
is not permitted because of the constant term of -10 on the left-hand side. The constraint may be recast as:
By default, all variables have lower bounds of zero and upper bounds of infinity. Optional Modeling StatementsIn addition to the three required model components of an objective function, variables, and constraints, a number of other optional modeling statements may appear in a model following the END statement. These statements and their functions appear in the table below:
Next, we will briefly illustrate the use of each of these statements. FREE StatementThe default lower bound for a variable is 0. In other words, unless you specify otherwise, variables are not allowed to be negative. The FREE statement allows you to remove all bounds on a variable, so it may take on any real value, positive or negative. The following small example illustrates the use of the FREE statement:
Had we not set Y to be a free variable in this example, the optimal solution of X = 6 and Y = -1 would not have been found. Instead, given the default lower bound of 0 on Y, the solution X = 7 and Y = 0 would be returned. GIN StatementBy default, all variables are assumed to be continuous. In other words, unless told otherwise, variables are assumed to be any nonnegative fractional number. In many applications, fractional values may be of little use (e.g., 2.5 employees). In these instances, you will want to make use of the general integer statement, GIN. The GIN statement followed by a variable name restricts the value of the variable to the nonnegative integers (0,1,2,...). The following small example illustrates the use of the GIN statement:
Had we not specified X and Y to be general integers in this model, the optimal solution of X = 6 and Y = 0 would not have been found. Instead, X and Y would have been treated as continuous and returned the solution of X = 5.29 and Y = 1.43. Note also that simply rounding the continuous solution to the nearest integer values does not yield the optimal solution in this example. In general, rounded continuous solutions may be nonoptimal and, at worst, infeasible. Based on this, one can imagine that it can be very time consuming to obtain the optimal solution to a model with many integer variables. In general, this is true, and you are best off utilizing the GIN feature only when absolutely necessary. INT StatementUsing the INT statement restricts a variable to being either 0 or 1. These variables are often referred to as binary variables. In many applications, binary variables can be very useful in modeling all-or-nothing situations. Examples might include such things as taking on a fixed cost, building a new plant, or buying a minimum level of some resource to receive a quantity discount. The following small example illustrates the use of the INT statement:
Had we not specified X to be binary in this example, a solution of X = .4, A = 4, and B = 7 for an objective value of 124 would not have been returned. Forcing X to be binary, you might guess that the optimal solution would be for X to be 0 because .4 is closer to 0 than it is to 1. If we round X to 0 and optimize for A and B, we get an objective of 84. In reality, a considerably better solution is obtained at X = 1, A = 10, and B = 1 for an objective of 112. In general, rounded continuous solutions may be nonoptimal and, at worst, infeasible. Based on this, one can imagine that it can be very time consuming to obtain the optimal solution to a model with many binary variables. In general, this is true and you are best off utilizing the INT feature only when absolutely necessary. SUB and SLB StatementsIf you do not specify otherwise, LINDO API assumes variables are continuous (bounded below by zero and unbounded from above). That is, variables can be any positive fractional number increasing indefinitely. In many applications, this assumption may not be realistic. Suppose your facilities limit the quantity produced of an item. In this case, the variable that represents the quantity produced is bounded from above. Or, suppose you want to allow for backordering in a system. An easy way to model this is to allow an inventory variable to go negative. In which case, you would like to circumvent the default lower bound of zero. The SUB and SLB statements are used to alter the bounds on a variable. SLB stands for Simple Lower Bound and is used to set lower bounds. Similarly, SUB stands for Simple Upper Bound and is used to set upper bounds. The following small example illustrates the use of the SUB and SLB:
In this example, we could have just as easily used constraints to represent the bounds. Specifically, we could have entered our small model as follows:
This formulation would yield the same results, but there are two points to keep in mind. First, SUBs and SLBs are handled implicitly by the solver, and, therefore, are more efficient from a performance point of view than constraints. Secondly, SUBs and SLBs do not count against the constraint limit, allowing you to solve larger models within that limit. TITLE StatementThis statement is used to associate a title with a model. The title may be any alphanumeric string of up to 74 characters in length. Unlike all the other statements that must appear after the END statement, the TITLE statement may appear before the objective or after the END statement of a model. Here is an example of a small model with a title:
|
set_epselSpecifies the value that is used as a tolerance for rounding values to zero. void set_epsel(lprec *lp, REAL epsel); Return Value set_epsel has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI epsel The value that is used as a tolerance for rounding values to zero. Remarks The set_epsel function specifies the value that is used as a tolerance
for rounding values to zero. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_epsel, set_infinite, get_infinite, is_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsb, get_epsb, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
DIMACS minimum cost flow problemsDIMACS (Center for Discrete Mathematics and Theoretical Computer Science (see http://dimacs.rutgers.edu/)) has formulated some 'challenges' for some specific problem instances (see http://dimacs.rutgers.edu/Challenges/). One of these challenges is network flows and matching - the first DIMACS implementation challenge. One of these network flows are minimum cost flow problems: Network Structure
There is a specific file format available for these kinds of problems: The DIMACS minimum-cost flow format requires that bounds on feasible arc flows be integer-valued (the LOW and CAP fields described below). All files contain only ASCII characters with information collected on each line, as described below. A line is terminated with an end-of-line character. Fields in each line are separated by at least one blank space. Each line begins with a one-character designator to identify the line type. The following information makes up a DIMACS minimum-cost flow input file:
As noted above, information is collected into lines, which begin with one-character designators. We describe each type of information line in turn.
Input File Example :The example network pictured here is followed by a corresponding DIMACS minimum-cost flow input file. Items listed in the lower-right of the graphic represent fields described above.
c This is a simple example file to demonstrate the DIMACS c input file format for minimum cost flow problems. The solution c vector is [2,2,2,0,4] with cost at 14. c c Problem line (nodes, links) p min 4 5 c c Node descriptor lines (supply+ or demand-) n 1 4 n 4 -4 c c Arc descriptor lines (from, to, minflow, maxflow, cost) a 1 2 0 4 2 a 1 3 0 2 2 a 2 3 0 2 1 a 2 4 0 3 3 a 3 4 0 5 1 c c End of file lp_solve can read/write and solve these models via the xli_DIMACS XLI driver (see External Language Interfaces).
It reads such a model in above format and solves it via linear programming.
The xli can also generate a DIMACS formatted file. lp_solve -rxli xli_DIMACS mincostflow.net This gives as result: Value of objective function: 14 Actual values of the variables: C1 2 C2 2 C3 2 C4 0 C5 4 Also from within the IDE, this XLI can be used. However, some entries must be added in LpSolveIDE.ini (in the folder where the IDE is installed). In the [XLI] section the following must be added: lib6=xli_DIMACS And a new section for the DIMACS XLI must also be added: [xli_DIMACS] extension=.net language=DIMACS Then make sure that the xli_DIMACS.dll is available for the IDE. This must be done by placing this dll in the IDE folder or in the Windows system32 folder. Solution :The solution vector of above example is [2, 2, 2, 0, 4] Output :The solution of the model can also be written in a DIMACS format:
For each network problem, the solution is an integer-valued flow assignment. The output file should list the solution and flow assignment for all arcs in the graph. As noted above, information is collected into lines, which begin with one-character designators. We describe each type of information line in turn.
lp_solve can generate a solution file via the xli_DIMACS XLI driver (see External Language Interfaces). lp_solve -rxli xli_DIMACS mincostflow.net -wxlisol xli_DIMACS mincostflow.sol This generates the following solution contents: c mincostflow.net c c Dimacs-format minimum cost flow result file c generated by lp_solve c c Solution s 14 c c SRC DST FLOW f 1 2 2 f 1 3 2 f 2 3 2 f 2 4 0 f 3 4 4 c c End of file lp_solve can also generate a solution file with only non-zero values. lp_solve -rxli xli_DIMACS mincostflow.net -wxlisol xli_DIMACS mincostflow.sol -wxlisolopt "-nz" This generates the following solution contents: c mincostflow.net c c Dimacs-format minimum cost flow result file c generated by lp_solve c c Solution s 14 c c Only non-zero flows are written c SRC DST FLOW f 1 2 2 f 1 3 2 f 2 3 2 f 3 4 4 c c End of file A testset of models can be found at http://elib.zib.de/pub/Packages/mp-testdata/mincost/ See Also DIMACS maximum flow problems, DIMACS assignment problems |
get_nameindexGets the index of a given column or row name in the lp. int get_nameindex(lprec *lp, char *name, unsigned char isrow); Return Value get_nameindex returns the index (column/row number) of the given column/row name. A return value of -1 indicates that the name does not exist. Note that the index is the original index number. So if presolve is active, it has no effect. It is the original column/row number that is returned. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI name The name of the column or row for which the index (column/row number) must be retrieved. isrow Set to FALSE (0) if column information is needed and TRUE (1) if row information is needed. Remarks The get_nameindex function returns the index (column/row number) of the given column/row name.
Note that this index starts from 1. Some API routines expect zero-based indexes and thus this value must then be corrected with -1. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_row_name, get_row_name, get_origrow_name, set_col_name, get_col_name, get_origcol_name |
get_rhGets the value of the right hand side (RHS) vector (column 0) for one row. REAL get_rh(lprec *lp, int row); Return Value
get_rh returns the value of the RHS for the specified row. If row is out
of range it returns 0. If no previous value was set, then it also returns 0,
the default RHS value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the RHS value must be retrieved. Must be between 0 and number of rows in the lp. value The value of the RHS. Remarks
The get_rh function returns the value of the RHS vector (column 0) for
the specified row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_rh, set_rh_vec, str_set_rh_vec, add_constraint, add_constraintex, str_add_constraint, get_column, get_columnex, add_column, add_columnex, str_add_column, set_column, set_columnex, get_row, get_rowex, get_mat |
DIMACS maximum flow problemsDIMACS (Center for Discrete Mathematics and Theoretical Computer Science (see http://dimacs.rutgers.edu/)) has formulated some 'challenges' for some specific problem instances (see http://dimacs.rutgers.edu/Challenges/). One of these challenges is network flows and matching - the first DIMACS implementation challenge. One of these network flows are maximum flow problems: Network Structure
The following information makes up a DIMACS maximum flow input file:
As noted above, information is collected into lines, which begin with one-character designators. We describe each type of information line in turn.
Input File Example :The example network pictured here is followed by a corresponding DIMACS maximum flow input file.
c This is a simple example file to demonstrate the DIMACS c input file format for maximum flow problems. The solution c vector is [5,10,5,0,5,5,10,5] with cost at 15. c Problem line (nodes, links) p max 6 8 c source n 1 s c sink n 6 t c Arc descriptor lines (from, to, capacity) a 1 2 5 a 1 3 15 a 2 4 5 a 2 5 5 a 3 4 5 a 3 5 5 a 4 6 15 a 5 6 5 c c End of file lp_solve can read/write and solve these models via the xli_DIMACS XLI driver (see External Language Interfaces).
It reads such a model in above format and solves it via linear programming.
The xli can also generate a DIMACS formatted file. lp_solve -rxli xli_DIMACS maxflow.net This gives as result: Value of objective function: 45 Actual values of the variables: C1 5 C2 10 C3 5 C4 0 C5 5 C6 5 C7 10 C8 5 Also from within the IDE, this XLI can be used. However, some entries must be added in LpSolveIDE.ini (in the folder where the IDE is installed). In the [XLI] section the following must be added: lib6=xli_DIMACS And a new section for the DIMACS XLI must also be added: [xli_DIMACS] extension=.net language=DIMACS Then make sure that the xli_DIMACS.dll is available for the IDE. This must be done by placing this dll in the IDE folder or in the Windows system32 folder. Solution :The solution vector of above example is [5, 10, 5, 0, 5, 5, 10, 5] Output :The solution of the model can also be written in a DIMACS format:
For each network problem, the solution is an integer-valued flow assignment. The output file should list the solution and flow assignment for all arcs in the graph. As noted above, information is collected into lines, which begin with one-character designators. We describe each type of information line in turn.
lp_solve can generate a solution file via the xli_DIMACS XLI driver (see External Language Interfaces). lp_solve -rxli xli_DIMACS maxflow.net -wxlisol xli_DIMACS maxflow.sol This generates the following solution contents: c maxflow.net c c Dimacs-format maximum flow result file c generated by lp_solve c c Solution s 15 c c SRC DST FLOW f 1 2 5 f 1 3 10 f 2 4 5 f 2 5 0 f 3 4 5 f 3 5 5 f 4 6 10 f 5 6 5 c c End of file lp_solve can also generate a solution file with only non-zero values. lp_solve -rxli xli_DIMACS maxflow.net -wxlisol xli_DIMACS maxflow.sol -wxlisolopt "-nz" This generates the following solution contents: c maxflow.net c c Dimacs-format maximum flow result file c generated by lp_solve c c Solution s 15 c c Only non-zero flows are written c SRC DST FLOW f 1 2 5 f 1 3 10 f 2 4 5 f 3 4 5 f 3 5 5 f 4 6 10 f 5 6 5 c c End of file A testset of models can be found at the dimacs ftp site: ftp://dimacs.rutgers.edu/pub/netflow See Also DIMACS minimum cost flow problems, DIMACS assignment problems |
Introduction to lp_solve 5.5.0.13What is lp_solve and what is it not? The simple answer is, lp_solve is a Mixed Integer Linear Programming (MILP) solver. And what is Linear Programming? See "What is Linear Programming?" and "Oh, and we also want to solve it as an integer program." for a brief description. Also see Formulation of an lp problem in lpsolve. 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 was originally developed by Michel Berkelaar at Eindhoven University of Technology.
The work of Jeroen Dirks made the transition from the basic version 1.5 to the full version 2.0 possible.
He contributed the procedural interface, a built-in MPS reader, and many fixes and enhancements to the code.
At that point there was also a Java port of lp_solve 2.0. This was not a Java native interface (JNI) to the C
library, but rather a translation of the algorithm (ver 2.0) from C into Java. It was also very limited
This meant that it did not keep up with lp_solve as it evolved.
Starting at version 3.0, lp_solve is released under the LGPL license. Before the code could only be used for
non-commercial purposes. Many other people also contributed to lp_solve, but there was no track of them. Sorry
if you are not mentioned.
Development was stagnated for some time at version 3.2, but now it is again alive and well via the new
developers Kjell Eikland and Peter Notebaert.
But also other people help to improve the product.
For example the new Java interface to lp_solve was made by Juergen Ebert.
It is a JNI interface that supports the full functionality of lp_solve. He did a great job. We encourage other people to participate in the development of lp_solve. Basically, lp_solve is a library, a set of routines, called the API that can be called from almost any programming language to solve MILP problems. There are several ways to pass the data to the library:
Via the APIThe API is a set of routines that can be called from a programming language to build the model in memory, solve it and return the results. There are many API routines to perform many possible tasks and set several options. See lp_solve API reference for an overview.Via input filesStandard, lp_solve supports several input files types.
The common known MPS format (see mps-format) is supported by most solvers, but
it is not very readable for humans. Another format is the lp format (see lp-format)
that is more readable. lp_solve has the unique ability to use user-written routines to input the model
(see External Language Interface).
See read_mps, read_freemps, read_MPS, read_freeMPS and read_lp, read_LP for
the API calls to read the model from file. Via an IDEThanks to Henri Gourvest, there is now also an IDE program called LPSolve IDE that uses the API to provide a Windows application to solve models. See LPSolve IDE for its usage. With this program you don't have to know anything of API or computer programming languages. You can just provide your model to the program and it will solve the model and give you the result. As already stated, lp_solve can be called from many programming language. Among them are C, C++, Pascal, Delphi, Java, VB, C#, VB.NET, Excel. But let this list not be a limitation. Any programming language capable of calling external libraries (DLLs under Windows, Shared libraries (.so) under Unix/Linux) can call lp_solve. Here is a list of some key features of lp_solve:
|
add_SOSAdd a SOS (Special Ordered Sets) constraint. int add_SOS(lprec *lp, char *name, int sostype, int priority, int count, int *sosvars, REAL *weights); Return Value add_SOS returns the list index of the new SOS if the operation was successful. A return value of 0 indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI name The name of the SOS constraint. sostype The type of the SOS constraint. Must be >= 1 priority Priority of the SOS constraint in the SOS set. count The number of variables in the SOS list. sosvars An array specifying the count variables (their column numbers). weights An array specifying the count variable weights. May also be NULL. In that case, lp_solve will weight the variables in the order they are specified. Remarks The add_SOS function adds an SOS constraint. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_SOS_var |
print_solutionPrints the solution (variables) of the lp. void print_solution(lprec *lp, int columns); Return Value print_solution has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI columns Number of columns to print solution. Remarks
The print_solution function prints the solution (variables) of the lp.
This can only be done after a successful solve. Example See Also delete_lp, free_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_variables, get_ptr_variables, print_lp, print_objective, print_constraints, print_duals, print_scales, print_tableau, print_str, set_outputstream, set_outputfile, print_debugdump |
write_paramsWrite settings to a parameter file. unsigned char write_params(lprec *lp, char *filename, char *options); Return Value Returns TRUE (1) if parameters could be written, else FALSE (0). Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI filename Filename to write the parameters to. options Optional options. Can be: Remarks All lp_solve parameters (options) are written to a parameter file. This file has an ini-format as used by Windows applications. All parameters are written under a header. This is by default [Default]. The header can be specified in the options parameter. Other headers are preserved. Example parameter file: [Default] ; lp_solve version 5.5 settings anti_degen=ANTIDEGEN_FIXEDVARS + ANTIDEGEN_STALLING + ANTIDEGEN_INFEASIBLE basiscrash=CRASH_NONE improve=IMPROVE_DUALFEAS + IMPROVE_THETAGAP maxpivot=250 negrange=-1e+006 pivoting=PRICER_DEVEX + PRICE_ADAPTIVE presolve=PRESOLVE_NONE presolveloops=2147483647 scalelimit=5 scaling=SCALE_GEOMETRIC + SCALE_EQUILIBRATE + SCALE_INTEGERS simplextype=SIMPLEX_DUAL_PRIMAL bb_depthlimit=-50 bb_floorfirst=BRANCH_AUTOMATIC bb_rule=NODE_PSEUDONONINTSELECT + NODE_GREEDYMODE + NODE_DYNAMICMODE + NODE_RCOSTFIXING ;break_at_first=0 ;break_at_value=-1e+030 mip_gap_abs=1e-011 mip_gap_rel=1e-011 epsint=1e-007 epsb=1e-010 epsd=1e-009 epsel=1e-012 epsperturb=1e-005 epspivot=2e-007 infinite=1e+030 ;debug=0 ;obj_bound=1e+030 ;print_sol=0 ;timeout=0 ;trace=0 ;verbose=NORMAL Note that there are some options commented out (;). This is done because these options can not be used in general for all models or because they are debug/trace/print options. These options can be made active and will be read by read_params but note again that they are possible dangerous to be used in general (except for the debug/trace/print options). Note that there are two kind of entries:
Numercial values can be integer values like maxpivot or floating point values like epsel Options are a combination of constants as defined in the manual. Multiple options are added with +. For example option anti_degen. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, read_params, reset_params |
is_maximReturns objective function direction. unsigned char is_maxim(lprec *lp); Return Value is_maxim returns a boolean value indicating if the objective direction is
maximize (TRUE) or minimize (FALSE). Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The default of lp_solve is to minimize, except for read_lp, read_LP where the default is to maximize. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_maxim, set_minim, set_sense |
set_row, set_rowexset a constraint in the lp. unsigned char set_row(lprec *lp, int row_no, REAL *row); unsigned char set_rowex(lprec *lp, int row_no, int count, REAL *row, int *colno); Return Value set_row, set_rowex return TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row_no The row number that must be changed. count Number of elements in row and colno. row An array with 1+get_Ncolumns (count for set_rowex, if colno is different from NULL) elements that contains the values of the row. colno A zero-based array with count elements that contains the column numbers of the row. However this variable can also be NULL. In that case element i in the variable row is column i and values start at element 1. Remarks The set_row, set_rowex functions change the values of an existing row in the
model at once. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_row, get_rowex, add_constraint, add_constraintex, str_add_constraint, set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj, set_add_rowmode, is_add_rowmode, get_constr_type, is_constr_type, del_constraint, add_column, add_columnex, str_add_column, set_column, set_columnex, get_column, get_columnex, get_mat |
write_lp, write_LP, write_lpexWrite an lp model to a file or via a routine. unsigned char write_LP(lprec *lp, FILE *stream); unsigned char write_lp(lprec *lp, char *filename); unsigned char write_lpex(lprec *lp, void *userhandle, (void *userhandle, char *buf) write_modeldata_routine); Return Value
The routines return TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI stream Pointer to FILE structure. filename Filename to write the lp model to. write_modeldata_routine
Routine to write the lp model to. The routine has following definition: Remarks The write_lp and write_LP functions write the model to filename. write_LP needs a file pointer to an already opened file. write_lp accepts the name of the file. The latter function will generally be more convenient. write_lpex writes the model via a user defined routine. When stream or filename are NULL, then output is written to output set by set_outputstream, set_outputfile. By default this is stdout.The model in the file will be in lp-format. Example See Also delete_lp, free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileex |
is_constr_typeReturns if constraint type specified in mask is active. unsigned char is_constr_type(lprec *lp, int row, int mask); Return Value is_constr_type returns TRUE or FALSE Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the constraint type must be retrieved. Must be between 1 and number of rows in the lp. mask Any of the following values:
Remarks The is_constr_type function returns a flag if constraint type specified in mask is active. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_constr_type, set_constr_type, add_constraint, add_constraintex, str_add_constraint, del_constraint |
is_feasibleChecks if provided solution is a feasible solution. unsigned char is_feasible(lprec *lp, REAL *values, REAL threshold); Return Value is_feasible returns FALSE (0) or TRUE (1) that indicates if provided
solution is feasible. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI values An array of row/column values that are checked against the bounds
and ranges. threshold A tolerance value. The values may differ that much. Recommended to use get_epsint for this value. Remarks The is_feasible function checks if provided solution is a feasible
solution. All values of the values array must be between the bounds and
ranges to be a feasible solution. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_objective, get_working_objective, get_variables, get_ptr_variables, get_constraints, get_ptr_constraints, get_constr_value, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex |
set_obj_in_basisSpecifies if the objective is in the matrix or not. void set_obj_in_basis(lprec *lp, unsigned char obj_in_basis); Return Value set_obj_in_basis has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI obj_in_basis TRUE or FALSE. Objective is in matrix or not. Remarks The set_obj_in_basis function specifies if the objective is in the matrix or not. By default, the objective function is stored as the top row in the constraint matrix When this function is called with obj_in_basis = FALSE then it is moved out into separate storage. When out of the basis, the computation of reduced costs is somewhat slower. In the late versions of v5.5, there is now the option to calculate reduced cost in the textbook way, i.e. completely independently of the basis. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_obj_in_basis |
set_solutionlimitSets the solution number that must be returned. void set_solutionlimit(lprec *lp, int limit); Return Value set_solutionlimit has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI limit The solution number that must be returned. This value gives the number of the solution that must be returned. Remarks This function is only valid if there are integer, semi-continious or SOS variables in the model so that the branch-and-bound algoritm is used. If there are more solutions with the same objective value, then this number specifies which solution must be returned. This can be used to retrieve all possible solutions. Start with 1 till get_solutioncount Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_solutionlimit, get_solutioncount |
get_solutioncountReturns the number of equal solutions. int get_solutioncount(lprec *lp); Return Value get_solutioncount returns the number of equal solutions. This is only valid if there are integer, semi-continious or SOS variables in the model so that the branch-and-bound algoritm is used. This count gives the number of solutions with the same optimal objective value. If there is only one optimal solution, this value is 1. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_solutioncount function returns the number of equal solutions up to get_solutionlimit. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_solutionlimit, set_solutionlimit |
get_statustextReturns the description of a returncode of the solve function. char *get_statustext(lprec *lp, int statuscode); Return Value The description of a returncode of the solve function Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI statuscode Returncode of solve Remarks The get_statustext function returns a comprehensible description of a returncode of the solve function. Example See Also free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, solve |
print_constraintsPrints the values of the constraints of the lp. void print_constraints(lprec *lp, int columns); Return Value print_constraints has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI columns Number of columns to print solution. Remarks
The print_constraints function prints the values of the constraints of the lp.
This can only be done after a successful solve. Example See Also delete_lp, free_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_constraints, get_constr_value, print_lp, print_objective, print_solution, print_duals, print_scales, print_tableau, print_str, set_outputstream, set_outputfile, print_debugdump |
write_basisWrites current basis to a file. unsigned char write_basis(lprec *lp, char *filename); Return Value Returns TRUE if basis could be written to filename and FALSE if not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI filename Filename to write the basis to. Remarks
The write_basis function writes the current basis to filename. The basis in the file is written in MPS bas file format. When filename is NULL, then output is written to output set by set_outputstream, set_outputfile. By default this is stdout. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_basis, set_basis, default_basis, read_basis, guess_basis, get_basiscrash, set_basiscrash |
set_matSet a single element in the matrix. unsigned char set_mat(lprec *lp, int row, int column, REAL value); Return Value
set_mat returns TRUE (1) if the operation was successful. A return value
of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row Row number of the matrix. Must be between 0 and number of rows in the lp. Row 0 is objective function. column Column number of the matrix. Must be between 1 and number of columns in the lp. value Value to be set for row row, column column. Remarks
The set_mat function sets a value in the matrix. If there was already a
value for this element, it is replaced and if there was no value, it is added. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_constraint, add_constraintex, str_add_constraint, set_row, set_rowex, set_obj_fn, set_obj_fnex, str_set_obj_fn, add_column, add_columnex, str_add_column, set_column, set_columnex, get_column, get_columnex, get_row, get_rowex, get_mat |
get_verboseReturns the verbose level. int get_verbose(lprec *lp); Return Value get_verbose returns the current verbose level. Can be one of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_verbose function returns the verbose level. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_verbose, put_logfunc |
make_lpCreate and initialise a new lprec structure. lprec *make_lp(int rows, int columns); Return Value
Returns a pointer to a new lprec structure. This must be provided to almost all
lp_solve functions. Parameters rows Initial number of rows. Can be 0 as new rows can be added via add_constraint, add_constraintex, str_add_constraint columns Initial number of columns. Can be 0 as new columns can be added via add_column, add_columnex, str_add_column Remarks
The make_lp function constructs a new LP. Sets all variables to initial
values. Example See Also copy_lp, delete_lp, free_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, resize_lp |
set_var_weightsSet the weights on variables. unsigned char set_var_weights(lprec *lp, REAL *weights); Return Value set_var_weights returns TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI weights The weights array. Remarks The set_var_weights sets a weight factor on each variable. This is only
used for the integer variables in the branch-and-bound algorithm. Array members
are unique, real-valued numbers indicating the "weight" of the variable at the
given index. The array is 0-based. So variable 1 is at index 0, variable 2 at
index 1. The array must contain get_Ncolumns
elements. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_var_priority, set_var_branch, get_var_branch, set_bb_floorfirst, get_bb_floorfirst |
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!
docs/5.5/get_bounds_tighter.htm 0000644 0001750 0001750 00000006011 11306036626 015353 0 ustar rene rene
get_bounds_tighterReturns if set bounds may only be tighter or also less restrictive. unsigned char get_bounds_tighter(lprec *lp); Return Value get_bounds_tighter returns if bounds may only be tighter or also less restrictive. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_bounds_tighter function returns if bounds may only be tighter or also less restrictive. If set to TRUE then bounds may only be tighter. This means that when set_lowbo or set_lowbo is used to set a bound and the bound is less restrictive than an already set bound, then this new bound will be ignored. If FALSE, the new bound is accepted. This functionality is useful when several bounds are set on a variable and at the end you want the most restrictive ones. By default, this setting is FALSE. Note that this setting does not affect set_bounds. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_bounds_tighter, set_upbo, get_upbo, set_lowbo, get_lowbo, set_bounds, set_unbounded, is_unbounded, is_negative |
get_obj_boundReturns initial "at least better than" guess for objective function. REAL get_obj_bound(lprec *lp); Return Value get_obj_bound returns the initial "at least better than" guess for
objective function. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI RemarksThe get_obj_bound function returns the initial "at least better than"
guess for objective function. This is only used in the branch-and-bound
algorithm when integer variables exist in the model. All solutions with a worse
objective value than this value are immediately rejected. This can result in
faster solving times, but it can be difficult to predict what value to take for
this bound. Also there is the chance that the found solution is not the most
optimal one. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_obj_bound, set_break_at_value, get_break_at_value, set_mip_gap, get_mip_gap |
is_add_rowmodeReturns a flag which of the add routines perform best. unsigned char is_add_rowmode(lprec *lp); Return Value is_add_rowmode returns TRUE or FALSE. If FALSE, then add_column, add_columnex, str_add_column performs best. If TRUE, then add_constraint, add_constraintex, str_add_constraint performs best. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks Default, this is FALSE, meaning that add_column, add_columnex,
str_add_column performs best. If the model is build via
add_constraint, add_constraintex, str_add_constraint calls, then these routines will be much faster
if this routine is called with turnon set on TRUE. This is also called row entry mode.
The speed improvement is spectacular,
especially for bigger models, so it is advisable to call this routine to set the mode.
Normally a model is build either column by column or row by row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_add_rowmode, set_add_rowmode, set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj, add_column, add_columnex, str_add_column, add_constraint, add_constraintex, str_add_constraint |
DIMACS assignment problemsDIMACS (Center for Discrete Mathematics and Theoretical Computer Science (see http://dimacs.rutgers.edu/)) has formulated some 'challenges' for some specific problem instances (see http://dimacs.rutgers.edu/Challenges/). One of these challenges is network flows and matching - the first DIMACS implementation challenge. One of these network flows are assignment problems: Network Structure
There is a specific file format available for these kinds of problems: The following information makes up a DIMACS assignment problem input file:
As noted above, information is collected into lines, which begin with one-character designators. We describe each type of information line in turn.
Input File Example :Consider the table below which shows the cost of allocating 5 jobs to 5 machines. Machine
6 7 8 9 10
Job 1 22 30 26 16 25
2 27 29 28 20 32
3 33 25 21 29 23
4 24 24 30 19 26
5 30 33 32 37 31
Which jobs should be allocated to which machines so as to minimise the total cost?
Problems of this type are called assignment problems since they involve the assignment of n (in this case n=5) distinct entities to another n distinct entities. For example in the area of production planning we might be interested in assigning operators to machines, or in assigning operators to jobs, or (as above) in assigning jobs to machines. c This is a simple example file to demonstrate the DIMACS c input file format for assignment problems. c c Problem line (resources+tasks) (resources*tasks) p asn 10 25 c c Node descriptor lines (indeces of assignable resources only) n 1 n 2 n 3 n 4 n 5 c c Arc descriptor lines (tasks over each resource and "score") a 1 6 22 a 1 7 30 a 1 8 26 a 1 9 16 a 1 10 25 a 2 6 27 a 2 7 29 a 2 8 28 a 2 9 20 a 2 10 32 a 3 6 33 a 3 7 25 a 3 8 21 a 3 9 29 a 3 10 23 a 4 6 24 a 4 7 24 a 4 8 30 a 4 9 19 a 4 10 26 a 5 6 30 a 5 7 33 a 5 8 32 a 5 9 37 a 5 10 31 c c End of file lp_solve can read/write and solve these models via the xli_DIMACS XLI driver (see External Language Interfaces).
It reads such a model in above format and solves it via linear programming.
The xli can also generate a DIMACS formatted file. lp_solve -rxli xli_DIMACS assignment.net This gives as result: Value of objective function: 118 Actual values of the variables: C1 1 C2 0 C3 0 C4 0 C5 0 C6 0 C7 0 C8 0 C9 1 C10 0 C11 0 C12 0 C13 1 C14 0 C15 0 C16 0 C17 1 C18 0 C19 0 C20 0 C21 0 C22 0 C23 0 C24 0 C25 1 Also from within the IDE, this XLI can be used. However, some entries must be added in LpSolveIDE.ini (in the folder where the IDE is installed). In the [XLI] section the following must be added: lib6=xli_DIMACS And a new section for the DIMACS XLI must also be added: [xli_DIMACS] extension=.net language=DIMACS Then make sure that the xli_DIMACS.dll is available for the IDE. This must be done by placing this dll in the IDE folder or in the Windows system32 folder. Solution :The solution vector of above example is [1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1] Output :The solution of the model can also be written in a DIMACS format:
For each network problem, the solution is an integer-valued flow assignment. The output file should list the solution and flow assignment for all arcs in the graph. As noted above, information is collected into lines, which begin with one-character designators. We describe each type of information line in turn.
lp_solve can generate a solution file via the xli_DIMACS XLI driver (see External Language Interfaces). lp_solve -rxli xli_DIMACS assignment.net -wxlisol xli_DIMACS assignment.sol This generates the following solution contents: c assignment.net c c Dimacs-format network assignment result file c generated by lp_solve c c Solution s 118 c c SRC DST FLOW f 1 6 1 f 1 7 0 f 1 8 0 f 1 9 0 f 1 10 0 f 2 6 0 f 2 7 0 f 2 8 0 f 2 9 1 f 2 10 0 f 3 6 0 f 3 7 0 f 3 8 1 f 3 9 0 f 3 10 0 f 4 6 0 f 4 7 1 f 4 8 0 f 4 9 0 f 4 10 0 f 5 6 0 f 5 7 0 f 5 8 0 f 5 9 0 f 5 10 1 c c End of file lp_solve can also generate a solution file with only non-zero values. lp_solve -rxli xli_DIMACS assignment.net -wxlisol xli_DIMACS assignment.sol -wxlisolopt "-nz" This generates the following solution contents: c assignment.net c c Dimacs-format network assignment result file c generated by lp_solve c c Solution s 118 c c Only non-zero flows are written c SRC DST FLOW f 1 6 1 f 2 9 1 f 3 8 1 f 4 7 1 f 5 10 1 c c End of file See Also DIMACS minimum cost flow problems, DIMACS maximum flow problems |
Java is a programming language originally developed by Sun Microsystems and released in 1995 as a core component of Sun's Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities. Java applications are typically compiled to bytecode which can run on any Java virtual machine (JVM) regardless of computer architecture.
The original and reference implementation Java compilers, virtual machines, and class libraries were developed by Sun from 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun made available most of their Java technologies as free software under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath.
Java is an object oriented programming language. The lpsolve API is not object oriented.
However there is a wrapper created by Juergen Ebert that is
object oriented. All lpsolve API is available via this wrapper but in an object oriented way and in the
case as used by Java. For example lpsolve API call make_lp is accessed as makeLP
in Java. The general rule of renamed API names is that a name begins in lower case, each underscore is removed
and the letter after the underscore is in upper case.
See C - Java function reference for the translation of calls.
An introduction of using lpsolve with Java is given in the document Using lp_solve 5.5 in Java programs
The Java object model is described in the document Java api
get_constr_valueGets the value of a constraint according to provided variable values. REAL get_constr_value(lprec *lp, int row, int count, REAL *primsolution, int *nzindex); Return Value get_constr_value returns the value of the constraint as calculated with the provided variable values. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the constraint value must be calculated. Must be between 1 and number of rows in the lp. count The number of items in primsolution and nzindex. primsolution The values of the variables. nzindex The variable indexes. Remarks The get_constr_value function returns the value of a constraint according to provided variable values. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_constraints, get_ptr_constraints, get_variables, get_ptr_variables, get_primal_solution, get_ptr_primal_solution, get_var_primalresult |
get_epsintReturns the tolerance that is used to determine whether a floating-point number is in fact an integer. REAL get_epsint(lprec *lp); Return Value get_epsint returns the value of epsint. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_epsint function returns the tolerance that is used to determine
whether a floating-point number is in fact an integer. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_epsint, set_infinite, is_infinite, get_infinite, set_epsb, get_epsb, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb |
get_row_name, get_origrow_nameGets the name of a constraint (row) in the lp. char *get_row_name(lprec *lp, int row); char *get_origrow_name(lprec *lp, int row); Return Value get_row_name and get_origrow_name return the name of the specified row. A return value of NULL indicates an error. The difference between get_row_name and get_origrow_name is only visible when a presolve (set_presolve) was done. Presolve can result in deletion of rows in the model. In get_row_name, row specifies the row number after presolve was done. In get_origrow_name, row specifies the row number before presolve was done, ie the original row number. If presolve is not active then both functions are equal. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the name must be retrieved. Must be between 0 and the number of rows in the lp. In get_row_name, row specifies the row number after presolve was done. In get_origrow_name, row specifies the row number before presolve was done, ie the original row number. Remarks The get_row_name and get_origrow_name functions return the name of
the row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_row_name, set_col_name, get_col_name, get_origcol_name, get_nameindex |
is_unboundedReturns if the variable is free. unsigned char is_unbounded(lprec *lp, int column); Return Value is_unbounded returns TRUE (1) if the variable is defined as free, FALSE (0)
otherwise. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be checked. It must be between 1 and the number of columns in the lp. Remarks The is_unbounded function returns if a variable is free or not. Free means a lower bound of -infinity and an upper bound of +infinity. Default a variable is not free because default it has a lower bound of 0 (and an upper bound of +infinity). See free variables for a description about free variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_upbo, set_upbo, set_lowbo, get_lowbo, set_bounds, set_unbounded, is_negative |
get_working_objectiveReturns the value of the objective function. REAL get_working_objective(lprec *lp); Return Value get_working_objective returns the current value of the objective while
solving the model. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_working_objective function returns the current value of the
objective while solving the model. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_working_objective, is_feasible, get_variables, get_ptr_variables, get_constraints, get_ptr_constraints, get_constr_value, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex |
get_anti_degenReturns the used degeneracy rule. int get_anti_degen(lprec *lp); Return Value get_anti_degen returns the used degeneracy rule. Can be a combination of any of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_anti_degen function returns the used degeneracy rule. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_anti_degen, is_anti_degen |
is_scalemodeReturns if scaling mode specified in testmask is active. unsigned char is_scalemode(lprec *lp, int testmask); Return Value is_scalemode returns if scaling mode specified in testmask is active. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI testmask
Additionally, the value can be OR-ed with any combination of one of the following values:
Remarks The is_scalemode function returns if scaling mode specified in testmask.
This can influence numerical stability considerably. It is advisable to always
use some sort of scaling. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_scaling, get_scaling, set_scalelimit, get_scalelimit, is_integerscaling, is_scaletype |
print_objectivePrints the objective value of the lp. void print_objective(lprec *lp); Return Value print_objective has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
The print_objective function prints the objective value of the lp. This can only be done after a successful solve. Example See Also delete_lp, free_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_objective, print_lp, print_solution, print_constraints, print_duals, print_scales, print_tableau, print_str, set_outputstream, set_outputfile, print_debugdump |
add_column, add_columnex, str_add_columnAdd a column to the lp. unsigned char add_column(lprec *lp, REAL *column); unsigned char add_columnex(lprec *lp, int count, REAL *column, int *rowno); unsigned char str_add_column(lprec *lp, char *col_string); Return Value add_column, add_columnex, and str_add_column return TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI count Number of elements in column and rowno. column An array with 1+get_Nrows (count for add_columnex, if rowno is different from NULL) elements that contains the values of the column. rowno A zero-based array with count elements that contains the row numbers of the column. However this variable can also be NULL. In that case element i in the variable column is row i. col_string A string with row elements that contains the values of the column. Each element must be separated by space(s). Remarks The add_column, add_columnex, str_add_column functions add
a column to the model (at the end) and sets all values of the column at once. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj, set_column, set_columnex, del_column, set_add_rowmode, is_add_rowmode, resize_lp, add_constraint, add_constraintex, str_add_constraint, set_row, set_rowex, get_column, get_columnex, get_row, get_rowex, get_mat, column_in_lp |
write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileexWrite an mps model. unsigned char write_MPS(lprec *lp, FILE *stream); unsigned char write_freeMPS(lprec *lp, FILE *stream); unsigned char write_mps(lprec *lp, char *filename); unsigned char write_freemps(lprec *lp, char *filename); unsigned char MPS_writefileex(lprec *lp, int typeMPS, void *userhandle, (void *userhandle, char *buf) write_modeldata_routine); Return Value
The routines return TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI stream Pointer to FILE structure. filename Filename to write the mps model to. typeMPS type of the MPS file. Can be one of the following values:
write_modeldata_routine
Routine to write the MPS model to. The routine has following definition: Remarks The write_mps, write_freemps, write_MPS, write_freeMPS functions write the model to filename. write_MPS, write_freeMPS need a file pointer to an already opened file. write_mps, write_freemps accept the name of the file. The latter function will generally be more convenient. MPS_writefileex writes the model via a user defined routine. When stream or filename are NULL, then output is written to output set by set_outputstream, set_outputfile. By default this is stdout.The model in the file will be in mps-format. The write_free* routines write files in free MPS format. The other routines write files in fixed MPS format. Example See Also delete_lp, free_lp, make_lp, copy_lp,read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, read_lp, read_LP, write_lp, write_LP, write_lpex, read_lp, read_LP |
MATLAB® is a high-performance language for technical computing. It integrates computation, visualization, and programming in an easy-to-use environment where problems and solutions are expressed in familiar mathematical notation. Typical uses include
MATLAB is an interactive system whose basic data element is an array that does not require dimensioning. This allows you to solve many technical computing problems, especially those with matrix and vector formulations, in a fraction of the time it would take to write a program in a scalar non-interactive language such as C or Fortran.
The name MATLAB stands for matrix laboratory. MATLAB was originally written to provide easy access to matrix software developed by the LINPACK and EISPACK projects. Today, MATLAB engines incorporate the LAPACK and BLAS libraries, embedding the state of the art in software for matrix computation.
MATLAB has evolved over a period of years with input from many users. In university environments, it is the standard instructional tool for introductory and advanced courses in mathematics, engineering, and science. In industry, MATLAB is the tool of choice for high-productivity research, development, and analysis.
MATLAB features a family of add-on application-specific solutions called toolboxes. Very important to most users of MATLAB, toolboxes allow you to learn and apply specialized technology. Toolboxes are comprehensive collections of MATLAB functions (M-files) that extend the MATLAB environment to solve particular classes of problems. Areas in which toolboxes are available include signal processing, control systems, neural networks, fuzzy logic, wavelets, simulation, and many others.
We will not discuss the specifics of MATLAB here but instead refer the reader to the MATLAB website and documentation.
lpsolve is callable from MATLAB via an external interface or MEX-function. As such, it looks like lpsolve is fully integrated with MATLAB. Matrices can directly be transferred between MATLAB and lpsolve in both directions. The complete interface is written in C so it has maximum performance. The whole lpsolve API is implemented with some extra's specific for MATLAB (especially for matrix support). So you have full control to the complete lpsolve functionality via the mxlpsolve MATLAB driver. If you find that this involves too much work to solve an lp model then you can also work via higher-level M-files that can make things a lot easier. See further in this article.
MATLAB is ideally suited to handle linear programming problems. These are problems in which you have a quantity, depending linearly on several variables, that you want to maximize or minimize subject to several constraints that are expressed as linear inequalities in the same variables. If the number of variables and the number of constraints are small, then there are numerous mathematical techniques for solving a linear programming problem. Indeed these techniques are often taught in high school or university level courses in finite mathematics. But sometimes these numbers are high, or even if low, the constants in the linear inequalities or the object expression for the quantity to be optimized may be numerically complicated in which case a software package like MATLAB is required to effect a solution.
To make this possible, a driver program is needed: mxlpsolve (mxlpsolve.dll under Windows). This driver must be put in a directory known to MATLAB (specified via File, Set Path or via the MATLAB path command) and MATLAB can call the mxlpsolve solver.
This driver calls lpsolve via the lpsolve shared library (lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux) (archive lp_solve_5.5.0.13_dev.zip/lp_solve_5.5.0.13_dev.tar.gz). This has the advantage that the mxlpsolve driver doesn't have to be recompiled when an update of lpsolve is provided. The shared library must be somewhere in the Windows path.
So note the difference between the MATLAB lpsolve driver that is called mxlpsolve and the lpsolve library that implements the API that is called lpsolve55.
There are also some MATLAB script files (.m) as a quick start.
To test if everything is installed correctly, enter mxlpsolve in the MATLAB command window. If it gives the following, then everything is ok:
mxlpsolve MATLAB Interface version 5.5.0.5
using lpsolve version 5.5.0.13
Usage: [ret1, ret2, ...] = mxlpsolve('functionname', arg1, arg2, ...)
However, if you get the following:
mxlpsolve driver not found !!! Check if mxlpsolve.dll is on your system and in a directory known to MATLAB. Press enter to see the paths where MATLAB looks for the driver.
Then MATLAB can find the mxlpsolve.m file, but not the mxlpsolve.dll file. This dll should be in the same directory as the .m file.
If you get the following:
??? Undefined function or variable 'mxlpsolve'.
Then MATLAB cannot find the mxlpsolve.* files. Enter path in the command line to see the MATLAB search path for its files. You can modify this path via File, Set Path. Specify the path where the mxlpsolve.* files are located on your system.
If you get the following (Windows):
??? Failed to initialise lpsolve library. Error in == > ...\mxlpsolve.dll
Or (Unix/Linux):
liblpsolve55.so: cannot open shared object file: No such file or directory.
Then MATLAB can find the mxlpsolve driver program, but the driver program cannot find the lpsolve library
that contains the lpsolve implementation.
This library is called lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux.
Under Windows, the lpsolve55.dll file must be in a directory that in the PATH environment variable.
This path can be shown via the following command in MATLAB: !PATH
It is common to place this in the WINDOWS\system32 folder.
Under Unix/Linux, the liblpsolve55.so shared library must be either in the directories /lib or /usr/lib or in
a directory specified by the LD_LIBRARY_PATH environment variable.
Note that it may also be necessary to restart MATLAB after having put the files in the specified directory. It was noted that MATLAB sometimes doesn't see the newly added files in folders until it is restarted.
All this is developed and tested with MATLAB version 6.0.0.88 Release 12.
In the following text, >> before the MATLAB commands is the MATLAB prompt. Only the text after >> must be entered.
To call an lpsolve function, the following syntax must be used:
>> [ret1, ret2, ...] = mxlpsolve('functionname', arg1, arg2, ...)
The return values are optional and depend on the function called. functionname must always be enclosed between single quotes to make it alphanumerical and it is case sensitive. The number and type of arguments depend on the function called. Some functions even have a variable number of arguments and a different behaviour occurs depending on the type of the argument. functionname can be (almost) any of the lpsolve API routines (see lp_solve API reference) plus some extra MATLAB specific functions. Most of the lpsolve API routines use or return an lprec structure. To make things more robust in MATLAB, this structure is replaced by a handle or the model name. The lprec structures are maintained internally by the lpsolve driver. The handle is an incrementing number starting from 0. Starting from driver version 5.5.0.2, it is also possible to use the model name instead of the handle. This can of course only be done if a name is given to the model. This is done via lpsolve routine set_lp_name or by specifying the model name in routine read_lp. See Using model name instead of handle.
Almost all callable functions can be found in the lp_solve API reference. Some are exactly as described in the reference guide, others have a slightly different syntax to make maximum use of the MATLAB functionality. For example make_lp is used identical as described. But get_variables is slightly different. In the API reference, this function has two arguments. The first the lp handle and the second the resulting variables and this array must already be dimensioned. When lpsolve is used from MATLAB, nothing must be dimensioned in advance. The mxlpsolve driver takes care of dimensioning all return variables and they are always returned as return value of the call to mxlpsolve. Never as argument to the routine. This can be a single value as for get_objective (although MATLAB stores this in a 1x1 matrix) or a matrix or vector as in get_variables. In this case, get_variables returns a 4x1 matrix (vector) with the result of the 4 variables of the lp model.
Note that you can get an overview of the available functionnames and their arguments by entering the following in MATLAB:
>> help mxlpsolve
(Note that you can execute this example by entering command per command as shown below or by just entering example1. This will execute example1.m. You can see its contents by entering type example1.m)
>> lp=mxlpsolve('make_lp', 0, 4);
>> mxlpsolve('set_verbose', lp, 3);
>> mxlpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1]);
>> mxlpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], 2, 92.3);
>> mxlpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
>> mxlpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], 2, 4);
>> mxlpsolve('set_lowbo', lp, 1, 28.6);
>> mxlpsolve('set_lowbo', lp, 4, 18);
>> mxlpsolve('set_upbo', lp, 4, 48.98);
>> mxlpsolve('set_col_name', lp, 1, 'COLONE');
>> mxlpsolve('set_col_name', lp, 2, 'COLTWO');
>> mxlpsolve('set_col_name', lp, 3, 'COLTHREE');
>> mxlpsolve('set_col_name', lp, 4, 'COLFOUR');
>> mxlpsolve('set_row_name', lp, 1, 'THISROW');
>> mxlpsolve('set_row_name', lp, 2, 'THATROW');
>> mxlpsolve('set_row_name', lp, 3, 'LASTROW');
>> mxlpsolve('write_lp', lp, 'a.lp');
>> mxlpsolve('get_mat', lp, 1, 2)
ans =
78.2600
>> mxlpsolve('solve', lp)
ans =
0
>> mxlpsolve('get_objective', lp)
ans =
31.7828
>> mxlpsolve('get_variables', lp)
ans =
28.6000
0
0
31.8276
>> mxlpsolve('get_constraints', lp)
ans =
92.3000
6.8640
391.2928
Note that there are some commands that return an answer. To see the answer, the command was not terminated with a semicolon (;). If the semicolon is put at the end of a command, the answer is not shown. However it is also possible to write the answer in a variable. For example:
>> obj=mxlpsolve('get_objective', lp)
obj =
31.7828
Or without echoing on screen:
>> obj=mxlpsolve('get_objective', lp);
The last command will only write the result in variable obj without showing anything on screen. get_variables and get_constraints return a vector with the result. This can also be put in a variable:
>> x=mxlpsolve('get_variables', lp);
>> b=mxlpsolve('get_constraints', lp);
It is always possible to show the contents of a variable by just giving it as command:
>> x
x =
28.6000
0
0
31.8276
Don't forget to free the handle and its associated memory when you are done:
>> mxlpsolve('delete_lp', lp);
>> lp=mxlpsolve('make_lp', 0, 4);
>> mxlpsolve('set_lp_name', lp, 'mymodel');
>> mxlpsolve('set_verbose', 'mymodel', 3);
>> mxlpsolve('set_obj_fn', 'mymodel', [1, 3, 6.24, 0.1]);
>> mxlpsolve('add_constraint', 'mymodel', [0, 78.26, 0, 2.9], 2, 92.3);
>> mxlpsolve('add_constraint', 'mymodel', [0.24, 0, 11.31, 0], 1, 14.8);
>> mxlpsolve('add_constraint', 'mymodel', [12.68, 0, 0.08, 0.9], 2, 4);
>> mxlpsolve('set_lowbo', 'mymodel', 1, 28.6);
>> mxlpsolve('set_lowbo', 'mymodel', 4, 18);
>> mxlpsolve('set_upbo', 'mymodel', 4, 48.98);
>> mxlpsolve('set_col_name', 'mymodel', 1, 'COLONE');
>> mxlpsolve('set_col_name', 'mymodel', 2, 'COLTWO');
>> mxlpsolve('set_col_name', 'mymodel', 3, 'COLTHREE');
>> mxlpsolve('set_col_name', 'mymodel', 4, 'COLFOUR');
>> mxlpsolve('set_row_name', 'mymodel', 1, 'THISROW');
>> mxlpsolve('set_row_name', 'mymodel', 2, 'THATROW');
>> mxlpsolve('set_row_name', 'mymodel', 3, 'LASTROW');
>> mxlpsolve('write_lp', 'mymodel', 'a.lp');
>> mxlpsolve('get_mat', 'mymodel', 1, 2)
ans =
78.2600
>> mxlpsolve('solve', 'mymodel')
ans =
0
>> mxlpsolve('get_objective', 'mymodel')
ans =
31.7828
>> mxlpsolve('get_variables', 'mymodel')
ans =
28.6000
0
0
31.8276
>> mxlpsolve('get_constraints', 'mymodel')
ans =
92.3000
6.8640
391.2928
So everywhere a handle is needed, you can also use the model name. You can even mix the two methods.
There is also a specific MATLAB routine to get the handle from the model name: get_handle.
For example:
>> mxlpsolve('get_handle', 'mymodel')
0
Don't forget to free the handle and its associated memory when you are done:
>> mxlpsolve('delete_lp', 'mymodel')
In the next part of this documentation, the handle is used. But if you name the model, the name could thus also be used.
>> mxlpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
In sparse matrix notation, this can be written:
>> mxlpsolve('add_constraint', lp, sparse([0.24, 0, 11.31, 0]), 1, 14.8);
Most of the time, variables are used to provide the data:
>> mxlpsolve('add_constraint', lp, a1, 1, 14.8);
Where a1 is a matrix variable that can be dense or sparse.
The mxlpsolve driver sees all provided matrices as sparse matrices. mxlpsolve also uses sparse matrices internally and data can be provided sparse via the ex routines. For example add_constraintex. The mxlpsolve driver always uses the ex routines to provide the data to lpsolve. Even if you call from MATLAB the routine names that would require a dense matrix (for example add_constraint), the mxlpsolve driver will always call the sparse version of the routine (for example add_constraintex). This results in the most performing behaviour. Note that if a dense matrix is provided, the dimension must exactly match the dimension that is expected by mxlpsolve. Matrices with too few or too much elements gives an 'invalid vector.' error. Sparse matrices can off course provide less elements (the non provided elements are seen as zero). However if too many elements are provided or an element with a too large index, again an 'invalid vector.' error is raised.
Most of the time, mxlpsolve needs vectors (rows or columns). In all situations, it doesn't matter if the vectors are row or column vectors. The driver accepts them both. For example:
>> mxlpsolve('add_constraint', lp, [0.24; 0; 11.31; 0], 1, 14.8);
Which is a column vector, but it is also accepted.
An important final note. Several lp_solve API routines accept a vector where the first element (element 0) is not used. Other lp_solve API calls do use the first element. In the MATLAB interface, there is never an unused element in the matrices. So if the lp_solve API specifies that the first element is not used, then this element is not in the MATLAB matrix.
All numerical data is stored in matrices. Alphanumerical data, however, is more difficult to store in matrices. Matrices require that each element has the same size (length) and that is difficult and unpractical for alphanumerical data. In a limited number of lpsolve routines, alphanumerical data is required or returned and in some also multiple elements. An example is set_col_name. For this, MATLAB sets are used. To specify a set of alphanumerical elements, the following notation is used: { 'element1', 'element2', ... }. Note the { and } symbols instead of [ and ] that are used with matrices.
Because MATLAB is all about matrices, all lpsolve API routines that need a column or row number to get/set information for that
column/row are extended in the mxlpsolve MATLAB driver to also work with matrices. For example set_int in the API can
only set the integer status for one column. If the status for several integer variables must be set, then set_int
must be called multiple times. The mxlpsolve MATLAB driver however also allows specifying a vector to set the integer
status of all variables at once. The API call is: return = mxlpsolve('set_int', lp, column, must_be_int). The
matrix version of this call is: return = mxlpsolve('set_int', lp, [must_be_int]).
The API call to return the integer status of a variable is: return = mxlpsolve('is_int', lp, column). The
matrix version of this call is: [is_int] = mxlpsolve('is_int', lp)
Also note the get_mat and set_mat routines. In MATLAB these are extended to return/set the complete constraint matrix.
See following example.
Above example can thus also be done as follows:
(Note that you can execute this example by entering command per command as shown below or by just entering example2.
This will execute example2.m. You can see its contents by entering type example2.m)
>> lp=mxlpsolve('make_lp', 0, 4);
>> mxlpsolve('set_verbose', lp, 3);
>> mxlpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1]);
>> mxlpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], 2, 92.3);
>> mxlpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
>> mxlpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], 2, 4);
>> mxlpsolve('set_lowbo', lp, [28.6, 0, 0, 18]);
>> mxlpsolve('set_upbo', lp, [Inf, Inf, Inf, 48.98]);
>> mxlpsolve('set_col_name', lp, {'COLONE', 'COLTWO', 'COLTHREE', 'COLFOUR'});
>> mxlpsolve('set_row_name', lp, {'THISROW', 'THATROW', 'LASTROW'});
>> mxlpsolve('write_lp', lp, 'a.lp');
>> mxlpsolve('get_mat', lp)
ans =
0 78.2600 0 2.9000
0.2400 0 11.3100 0
12.6800 0 0.0800 0.9000
>> mxlpsolve('solve', lp)
ans =
0
>> mxlpsolve('get_objective', lp)
ans =
31.7828
>> mxlpsolve('get_variables', lp)
ans =
28.6000
0
0
31.8276
>> mxlpsolve('get_constraints', lp)
ans =
92.3000
6.8640
391.2928
Note the usage of Inf in set_upbo. This stands for 'infinity'. Meaning an infinite upper bound. It is also possible to use -Inf to express minus infinity. This can for example be used to create a free variable.
Starting from driver version 5.5.0.3, get_mat can also return the matrix in sparse format. By default the function returns it in dense format for backwards compatibility. However if a 3rd argument is provided that is non-zero, the returned matrix is sparse:
>> mxlpsolve('get_mat', lp, 1)
ans =
(2,1) 0.2400
(3,1) 12.6800
(1,2) 78.2600
(2,3) 11.3100
(3,3) 0.0800
(1,4) 2.9000
(3,4) 0.9000
To show the full power of the matrices, let's now do some matrix calculations to check the solution. It works further on above example:
>> A=mxlpsolve('get_mat', lp);
>> X=mxlpsolve('get_variables', lp);
>> B = A * X
B =
92.3000
6.8640
391.2928
So what we have done here is calculate the values of the constraints (RHS) by multiplying the constraint matrix with the solution vector. Now take a look at the values of the constraints that lpsolve has found:
>> mxlpsolve('get_constraints', lp)
ans =
92.3000
6.8640
391.2928
Exactly the same as the calculated B vector, as expected.
Also the value of the objective can be calculated in a same way:
>> C=mxlpsolve('get_obj_fn', lp);
>> X=mxlpsolve('get_variables', lp);
>> obj = C * X
obj =
31.7828
So what we have done here is calculate the value of the objective by multiplying the objective vector with the solution vector. Now take a look at the value of the objective that lpsolve has found:
>> mxlpsolve('get_objective', lp)
ans =
31.7828
Again exactly the same as the calculated obj value, as expected.
MATLAB can execute a sequence of statements stored in diskfiles. Such files are called "M-files" because they must have the file type of ".m" as the last part of their filename (extension). Much of your work with MATLAB will be in creating and refining M-files. M-files are usually created using your local editor.
M-files can be compared with batch files or scripts. You can put MATLAB commands in them and execute them at any time. The M-file is executed like any other command, by entering its name (without the .m extension).
The mxlpsolve MATLAB distribution contains some example M-files to demonstrate this.
To see the contents of such a file, enter the command 'type filename'. You can also edit these files with your favourite text editor (or notepad).
Contains the commands as shown in the first example of this article.
Contains the commands as shown in the second example of this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
This script uses the API to create a higher-level function called lp_solve. This function accepts as arguments some matrices and options to create and solve an lp model. See the beginning of the file or type help lp_solve or just lp_solve to see its usage:
>> help lp_solve
LP_SOLVE Solves mixed integer linear programming problems.
SYNOPSIS: [obj,x,duals] = lp_solve(f,a,b,e,vlb,vub,xint,scalemode,keep)
solves the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) = -1 ==> Less Than
e(i) = 0 ==> Equals
e(i) = 1 ==> Greater Than
vlb: n vector of lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
keep: Flag for keeping the lp problem after it's been solved.
If omitted, the lp will be deleted when solved.
OUTPUT: A nonempty output is returned if a solution is found:
obj: Optimal value of the objective function.
x: Optimal value of the decision variables.
duals: solution of the dual problem.
Example of usage. To create and solve following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
>> [obj, x]=lp_solve([-1, 2], [2, 1; -4, 4], [5, 5], [-1, -1], [], [], [1, 2])
obj =
3
x =
1
2
This script is analog to the lp_solve script and also uses the API to create a higher-level function called lp_maker. This function accepts as arguments some matrices and options to create an lp model. Note that this scripts only creates a model and returns a handle. See the beginning of the file or type help lp_maker or just lp_maker to see its usage:
>> help lp_maker
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: Autoscale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Example of usage. To create following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
>> lp=lp_maker([-1, 2], [2, 1; -4, 4], [5, 5], [-1, -1], [], [], [1, 2])
lp =
0
To solve the model and get the solution:
>> mxlpsolve('solve', lp)
ans =
0
>> mxlpsolve('get_objective', lp)
ans =
3
>> mxlpsolve('get_variables', lp)
ans =
1
2
Don't forget to free the handle and its associated memory when you are done:
>> mxlpsolve('delete_lp', lp);
Contains several examples to build and solve lp models.
Contains several examples to build and solve lp models. Also solves the lp_examples from the lp_solve distribution.
We shall illustrate the method of linear programming by means of a simple example, giving a combination graphical/numerical solution, and then solve both a slightly as well as a substantially more complicated problem.
Suppose a farmer has 75 acres on which to plant two crops: wheat and barley. To produce these crops, it costs the farmer (for seed, fertilizer, etc.) $120 per acre for the wheat and $210 per acre for the barley. The farmer has $15000 available for expenses. But after the harvest, the farmer must store the crops while awaiting favourable market conditions. The farmer has storage space for 4000 bushels. Each acre yields an average of 110 bushels of wheat or 30 bushels of barley. If the net profit per bushel of wheat (after all expenses have been subtracted) is $1.30 and for barley is $2.00, how should the farmer plant the 75 acres to maximize profit?
We begin by formulating the problem mathematically. First we express the objective, that is the profit, and the constraints algebraically, then we graph them, and lastly we arrive at the solution by graphical inspection and a minor arithmetic calculation.
Let x denote the number of acres allotted to wheat and y the number of acres allotted to barley. Then the expression to be maximized, that is the profit, is clearly
P = (110)(1.30)x + (30)(2.00)y = 143x + 60y.
There are three constraint inequalities, specified by the limits on expenses, storage and acreage. They are respectively:
120x + 210y <= 15000
110x + 30y <= 4000
x + y <= 75
Strictly speaking there are two more constraint inequalities forced by the fact that the farmer cannot plant a negative number of acres, namely:
x >= 0, y >= 0.
Next we graph the regions specified by the constraints. The last two say that we only need to consider the first quadrant in the x-y plane. Here's a graph delineating the triangular region in the first quadrant determined by the first inequality.
>> X = 0:125; >> Y1 = (15000 - 120.*X)./210; >> area(X, Y1)
Now let's put in the other two constraint inequalities.
>> Y2 = max((4000 - 110.*X)./30, 0); >> Y3 = max(75 - X, 0); >> Ytop = min([Y1; Y2; Y3]); >> area(X, Ytop) >> axis([0 40 0 75])
The blue area is the solution space that holds valid solutions. This means that any point in this area fulfils the constraints.
Now let's superimpose on top of this picture a contour plot of the objective function P.
>> hold on >> [U V] = meshgrid(0:40, 0:75); >> contour(U, V, 143.*U + 60.*V); >> hold off
The lines give a picture of the objective function. All solutions that intersect with the blue area are valid solutions, meaning that this result also fulfils the set constraints. The more the lines go to the right, the higher the objective value is. The optimal solution or best objective is a line that is still in the blue area, but with an as large as possible value.
It seems apparent that the maximum value of P will occur on the level curve (that is, level
line) that passes through the vertex of the polygon that lies near (22,53).
It is the intersection of x + y = 75 and 110*x + 30*y = 4000
This is a corner point of the diagram. This is not a coincidence. The simplex algorithm, which is used
by lp_solve, starts from a theorem that the optimal solution is such a corner point.
In fact we can compute the result:
>> x = [1 1; 110 30] \ [75; 4000] x = 21.8750 53.1250
The acreage that results in the maximum profit is 21.875 for wheat and 53.125 for barley. In that case the profit is:
>> format bank
>> P = [143 60] * x
P =
6315.63
That is, $6315.63.
Note that these command are in script example3.m
Now, lp_solve comes into the picture to solve this linear programming problem more generally. After that we will use it to solve two more complicated problems involving more variables and constraints.
For this example, we use the higher-level script lp_maker to build the model and then some lp_solve API calls to retrieve the solution. Here is again the usage of lp_maker:
>> help lp_maker
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: Autoscale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Now let's formulate this model with lp_solve:
>> f = [143 60];
>> A = [120 210; 110 30; 1 1];
>> b = [15000; 4000; 75];
>> lp = lp_maker(f, A, b, [-1; -1; -1], [], [], [], 1, 0);
>> solvestat = mxlpsolve('solve', lp)
solvestat =
0
>> format bank
>> obj = mxlpsolve('get_objective', lp)
obj =
6315.63
>> format short
>> x = mxlpsolve('get_variables', lp)
x =
21.8750
53.1250
>> mxlpsolve('delete_lp', lp);
Note that these command are in script example4.m
With the higher-level script lp_maker, we provide all data to lp_solve. lp_solve returns a handle (lp) to the created model. Then the API call 'solve' is used to calculate the optimal solution of the model. The value of the objective function is retrieved via the API call 'get_objective' and the values of the variables are retrieved via the API call 'get_variables'. At last, the model is removed from memory via a call to 'delete_lp'. Don't forget this to free all memory allocated by lp_solve.
The solution is the same answer we obtained before. Note that the non-negativity constraints are accounted implicitly because variables are by default non-negative in lp_solve.
Well, we could have done this problem by hand (as shown in the introduction) because it is very small and it
can be graphically presented.
Now suppose that the farmer is dealing with a third crop, say corn, and that the corresponding data is:
cost per acre $150.75 yield per acre 125 bushels profit per bushel $1.56
With three variables it is already a lot more difficult to show this model graphically. Adding more variables makes it even impossible because we can't imagine anymore how to represent this. We only have a practical understanding of 3 dimentions, but beyound that it is all very theorethical.
If we denote the number of acres allotted to corn by z, then the objective function becomes:
P = (110)(1.30)x + (30)(2.00)y + (125)(1.56) = 143x + 60y + 195z
And the constraint inequalities are:
120x + 210y + 150.75z <= 15000
110x + 30y + 125z <= 4000
x + y + z <= 75
x >= 0, y >= 0, z >= 0
The problem is solved with lp_solve as follows:
>> f = [143 60 195];
>> A = [120 210 150.75; 110 30 125; 1 1 1];
>> b = [15000; 4000; 75];
>> lp = lp_maker(f, A, b, [-1; -1; -1], [], [], [], 1, 0);
>> solvestat = mxlpsolve('solve', lp)
solvestat =
0
>> format bank
>> obj = mxlpsolve('get_objective', lp)
obj =
6986.84
>> format short
>> x = mxlpsolve('get_variables', lp)
x =
0
56.5789
18.4211
>> mxlpsolve('delete_lp', lp);
Note that these command are in script example5.m
So the farmer should ditch the wheat and plant 56.5789 acres of barley and 18.4211 acres of corn.
There is no practical limit on the number of variables and constraints that MATLAB can handle. Certainly none that the relatively unsophisticated user will encounter. Indeed, in many true applications of the technique of linear programming, one needs to deal with many variables and constraints. The solution of such a problem by hand is not feasible, and software like MATLAB is crucial to success. For example, in the farming problem with which we have been working, one could have more crops than two or three. Think agribusiness instead of family farmer. And one could have constraints that arise from other things beside expenses, storage and acreage limitations. For example:
Below is a sequence of commands that solves exactly such a problem. You should be able to recognize the objective expression and the constraints from the data that is entered. But as an aid, you might answer the following questions:
>> f = [110*1.3 30*2.0 125*1.56 75*1.8 95*.95 100*2.25 50*1.35];
>> A = [120 210 150.75 115 186 140 85;
110 30 125 75 95 100 50;
1 1 1 1 1 1 1;
1 -1 0 0 0 0 0;
0 0 1 0 -2 0 0;
0 0 0 -1 0 -1 1];
>> b = [55000;40000;400;0;0;0];
>> lp = lp_maker(f, A, b, [-1; -1; -1; -1; -1; -1], [10 10 10 10 20 20 20], [100 Inf 50 Inf Inf 250 Inf], [], 1, 0);
>> solvestat = mxlpsolve('solve', lp)
solvestat =
0
>> format bank
>> obj = mxlpsolve('get_objective', lp)
obj =
75398.04
>> format short
>> x = mxlpsolve('get_variables', lp)
x =
10.0000
10.0000
40.0000
45.6522
20.0000
250.0000
20.0000
>> mxlpsolve('delete_lp', lp);
Note that these command are in script example6.m
Note that we have used in this formulation the vlb and vub arguments of lp_maker. This to set lower and upper bounds on variables. This could have been done via extra constraints, but it is more performant to set bounds on variables. Also note that Inf is used for variables that have no upper limit. This stands for Infinity.
Note that despite the complexity of the problem, lp_solve solves it almost instantaneously. It seems the farmer should bet the farm on crop number 6. We strongly suggest you alter the expense and/or the storage limit in the problem and see what effect that has on the answer.
Suppose we want to solve the following linear program using MATLAB:
max 4x1 + 2x2 + x3
s. t. 2x1 + x2 <= 1
x1 + 2x3 <= 2
x1 + x2 + x3 = 1
x1 >= 0
x1 <= 1
x2 >= 0
x2 <= 1
x3 >= 0
x3 <= 2
Convert the LP into MATLAB format we get:
f = [4 2 1]
A = [2 1 0; 1 0 2; 1 1 1]
b = [1; 2; 1]
Note that constraints on single variables are not put in the constraint matrix. lp_solve can set bounds on individual variables and this is more performant than creating additional constraints. These bounds are:
l = [ 0 0 0]
u = [ 1 1 2]
Now lets enter this in MATLAB:
>> f = [4 2 1]; >> A = [2 1 0; 1 0 2; 1 1 1]; >> b = [1; 2; 1]; >> l = [ 0 0 0]; >> u = [ 1 1 2];
Now solve the linear program using MATLAB: Type the commands
>> lp = lp_maker(f, A, b, [-1; -1; -1], l, u, [], 1, 0);
>> solvestat = mxlpsolve('solve', lp)
solvestat =
0
>> obj = mxlpsolve('get_objective', lp)
obj =
2.5000
>> x = mxlpsolve('get_variables', lp)
x =
0.5000
0
0.5000
>> mxlpsolve('delete_lp', lp)
What to do when some of the variables are missing ?
For example, suppose there are no lower bounds on the variables. In this case define l to be the empty set using the MATLAB command:
>> l = [];
This has the same effect as before, because lp_solve has as default lower bound for variables 0.
But what if you want that variables may also become negative?
Then you can use -Inf as lower bounds:
>> l = [-Inf -Inf -Inf];
Solve this and you get a different result:
>> lp = lp_maker(f, A, b, [-1; -1; -1], l, u, [], 1, 0);
>> solvestat = mxlpsolve('solve', lp)
solvestat =
0
>> obj = mxlpsolve('get_objective', lp)
obj =
2.6667
>> x = mxlpsolve('get_variables', lp)
x =
0.6667
-0.3333
0.6667
>> mxlpsolve('delete_lp', lp)
Note again that the MATLAB command 'help mxlpsolve' gives an overview of all functions that can be called via mxlpsolve with their arguments and return values.
Note that everwhere where lp is used as argument that this can be a handle (lp_handle) or the models name.
These routines are not part of the lpsolve API, but are added for backwards compatibility. Most of them exist in the lpsolve API with another name.
Under Windows, the mxlpsolve MATLAB driver is a dll: mxlpsolve.dll
This dll is an interface to the lpsolve55.dll lpsolve dll that contains the implementation of lp_solve.
lpsolve55.dll is distributed with the lp_solve package (archive lp_solve_5.5.0.13_dev.zip). The mxlpsolve MATLAB driver dll (mxlpsolve.dll) is just
a wrapper between MATLAB and lp_solve to translate the input/output to/from MATLAB and the lp_solve library.
Also the library lp_explicit.lib is needed. The lp_explicit.lib file is a wrapper library between the lp_solve dll and the compiled application. This wrapper is needed because the lp_solve dll uses __stdcall calling convention. There seems to be a problem in MATLAB to call __stdcall functions directly (unexpected crashes). The lp_explicit library uses __cdecl calling convention and this then calls the lp_solve dll which uses __stdcall calling convention. Looks a bit complex, but it works without any problem.
There appears to be another way to compile MATLAB mex files with gcc for Windows. This is not tested. See Compiling Matlab mex files with gcc for Windows.
Under Unix/Linux, the mxlpsolve MATLAB driver is a shared library. The resulting file has a platform-dependent extension, as shown in the table below:
sol2, SunOS 5.x - .mexsol
hpux - .mexhpux
hp700 - .mexhp7
ibm_rs - .mexrs6
sgi - .mexsg
alpha - .mexaxp
glnx86 - .mexglx
Mac OS X - .mexmac
This shared library is an interface to the lpsolve55.so lpsolve shared library that contains the implementation of lp_solve. lpsolve55.so is distributed with the lp_solve package (archive lp_solve_5.5.0.13_dev.tar.gz). The mxlpsolve MATLAB driver library is just a wrapper between MATLAB and lp_solve to translate the input/output to/from MATLAB and the lp_solve library.
The mxlpsolve MATLAB driver is written in C. To compile this code, the MATLAB compiler is needed (mex).
This compiler must be called from MATLAB. To make the compilation process easier, a makefile can be used:
Makefile.m
Enter 'help Makefile' from the MATLAB command window to see a list of options.
It may be necessary to edit this file first to change the path where lp_solve is installed.
Change at the beginning lpsolvepath.
To make for release, just enter Makefile and everything is build.
This compiles three source files: lpsolve.c, matlab.c and hash.c
The optional arguments to Makefile are used for development. The first argument allows specifying a filename
so that only this file is build. For example hash.c should only be compiled once while developing. So specifying
'lpsolve.c' as first argument will only compile this file and then link everything. This makes the build process a bit faster.
The second argument is by default 0. When set to 1, then extra argument checking is done and while executing,
some debug information is printed. Should only be used for debugging purposes. When released, this parameter should be 0.
The third argument is by default 1. When set to 0, the makefile will not ask to press enter to start building.
See also Using lpsolve from O-Matrix, Using lpsolve from Scilab, Using lpsolve from Octave, Using lpsolve from Python, Using lpsolve from R
docs/5.5/get_presolveloops.htm 0000644 0001750 0001750 00000004711 11306036626 015254 0 ustar rene rene
get_presolveloopsReturns the number of times presolve is done. int get_presolveloops(lprec *lp); Return Value get_presolveloops returns the number of times presolve is done. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_presolveloops function returns the number of times presolve is done. After a presolve is done, another presolve can again result in elimination of extra rows and/or columns. This number specifies the maximum number of times this process is repeated. By default this is until presolve has nothing to do anymore. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_presolve, get_presolve, get_presolveloops |
The lp-format is lpsolves native format to read and write lp models. Note that this format is not the same as the CPLEX LP format (see CPLEX lp files) or the Xpress LP format (see Xpress lp files) The lp-format input syntax is a set of algebraic expressions and "free", "int", "bin", "sec", "sos" declarations in the following order: <objective function> <constraint>* <declaration>* where: - <objective function> is a linear combination of optional variables and constants, ending with a semicolon, optionally preceded by "max: " or "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. Alternatives are minimise, minimize, maximise, Maximize. The objective function is required, but can be empty. - <constraint> is an optional constraint name followed by a colon plus a linear combination of variables and constants or (just one) constraint name followed by a colon (a range) or (just one) variable name without a colon (a bound), 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 one of the forms: To define variables as integer: "int" var [","] var [","] var ... ";" To define variables as binary: "bin"|"binary" var [","] var [","] var ... ";" To define variables as semi-cont: "sec" var [","] var [","] var ... ";" To define variables as free: "free" var [","] var [","] var ... ";" To define Special Ordered Sets (SOS): "sos" [sosdescr:] [","] var[:weight] [","] var[:weight] [","] var[:weight] ... "<[=]" sostype[:sosorder] ";" ... or: "sosx" [sosdescr:] var[:weight] [","] var[:weight] [","] var[:weight] ... ";" ... - A var must start with a letter (either upper or lower case), and may contain any number of additional letters, numerals, or characters from this list: _[]{}/.&#$%~'@^ - Comments can be used with the /* */ syntax, just like in C. It can be put anywhere in the file and even over multiple lines. lp_solve 4.0.1.11 and newer also supports the C++ line comment //. - Empty lines are also allowed. EXAMPLES The simple problem: x1 >= 1 x2 >= 1 x1 + x2 >= 2 minimize x1 + x2 (= maximize -(x1 + x2)), with x1 integer Can be written as follows in lp-format: -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). If you want to give a name to a restriction then begin the line with the name and a colon. For example: min: x1 + x2; x1 >= 1; x2 >= 1; myrow: x1 + x2 >= 2; int x1; The objective function may also be empty, but it must be there: min: ; x1 >= 1; x2 >= 1; myrow: x1 + x2 >= 2; int x1; Also constants may be put in the objective function: min: x1 + x2 + 3; x1 >= 1; x2 >= 1; myrow: x1 + x2 >= 2; int x1; Or even the following is ok. The constants will be added to one constant value: min: 2 + x1 + 3 + x2 + 4; x1 >= 1; x2 >= 1; myrow: x1 + x2 >= 2; int x1; This will lead to the same solution as without the constant(s), but the objective value will be increased with this value. Note that for bounds on variables, you should not put labels before them. This is because lp_solve then makes this an extra restriction. If you don't put a label before single variables then lp_solve doesn't have to create an extra row for bounds on variables, resulting in better performance. So it is better to write: x1 >= 1; than r_x1: x1 >= 1; Note that this is only for single variables, so myrow: x1 + x2 >= 2; performs as well as x1 + x2 >= 2; In addition, the variable can have a constant, without performance penalty. For example: 2 x1 >= 2; is automatically translated to x1 >= 1; by lp_solve, so this is not a restriction, but a (better performing) bound. The moment there is more than one variable in a constraint, lp_solve can only create a restriction (extra row) for this. Sometimes there is a lower and upper bound on a variable. This can be written in several ways: x1 >= 1; x1 <= 3; It doesn't matter if the lower bound comes first or not. They are also not required to be together. Another way to write this is: 1 <= x1 <= 3; Or 3 >= x1 >= 1; These bounds on variables are handled by lp_solve in a special way so that no extra restrictions (rows) are created, which will lead to better performance. Also on restrictions there can be both a lower and upper value. They are called ranges. For example: myrow: x1 + x2 >= 2; Suppose that the same restriction should also be <= 6, then this could be written as: myrowmin: x1 + x2 >= 2; myrowmax: x1 + x2 <= 6; However, then there are two rows in the model which makes it larger and harder to solve. lp_solve can handle this in one row so that the model is smaller and it will solve more quickly. This will only be done if the modeling is done in one of the following ways: myrow: x1 + x2 >= 2; myrow: <= 6; Or myrow: x1 + x2 <= 6; myrow: >= 2; Or myrow: 6 >= x1 + x2 >= 2; Or myrow: 2 <= x1 + x2 <= 6; Or 6 >= x1 + x2 >= 2; Or 2 <= x1 + x2 <= 6; Note that there must be a row label if the construction label: op constant is used. This requirement does not count if the min and max restriction is put on one line. Also the range must come after the constraint definition. Example with integer variables: min: -x1 -2 x2 +0.1 x3 +3 x4; r_1: +x1 +x2 <= 5; r_2: +2 x1 -x2 >= 0; r_3: -x1 +3 x2 >= 0; r_4: +x3 +x4 >= 0.5; x3 >= 1.1; int x3, x4; See integer variables for a description about integer variables. Example with binary variables: min: -x1 -2 x2 +0.1 x3 +3 x4; r_1: +x1 +x2 <= 5; r_2: +2 x1 -x2 >= 0; r_3: -x1 +3 x2 >= 0; r_4: +x3 +x4 >= 0.5; bin x3, x4; See integer variables for a description about integer and binary variables. Example with semi-continuous variables: max: x1 + 2x2 - 4x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; sec x3, x4; See semi-continuous variables for a description about semi-continuous variables. Example with free variables: max: x1 + 2x2 - 4x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; free x2, x4; See free variables for a description about free variables. Examples with Special Ordered Sets (SOS): min: -x1 -x2 -3 x3 -2 x4 -2 x5; c1: -x1 -x2 +x3 +x4 <= 30; c2: +x1 +x3 -3 x4 <= 30; x1 <= 40; x2 <= 1; x5 <= 1; sos SOS1: x1, x2, x3, x4 <= 2; SOS2: x2, x3, x4, x5 <= 3; Alternative: min: -x1 -x2 -3 x3 -2 x4 -2 x5; c1: -x1 -x2 +x3 +x4 <= 30; c2: +x1 +x3 -3 x4 <= 30; x1 <= 40; x2 <= 1; x5 <= 1; sos2 SOS1: x1, x2, x3, x4; SOS2: x2, x3, x4, x5; With SOS weights: min: -x1 -x2 -3 x3 -2 x4 -2 x5; c1: -x1 -x2 +x3 +x4 <= 30; c2: +x1 +x3 -3 x4 <= 30; x1 <= 40; x2 <= 1; x5 <= 1; sos SOS1: x1:5, x2:9, x3:12, x4:17 <= 2:3; SOS2: x2:9, x3:12, x4:17, x5:21 <= 2:3; See Special Ordered Sets (SOS) for a description about Special Ordered Sets.docs/5.5/is_trace.htm 0000644 0001750 0001750 00000004277 11306036626 013301 0 ustar rene renePeculiarities of the lp format:
Note that some strange effects can occur.Exponents:
Consider the following lp: min: d1 + e1; -0.5 d1 + e1 <= 3; d1 + e1 >= 6; 3 d1 - 2 e1 <= 16; This works as expected. d1 and e1 are always seen as variables. Now consider this: min: d1 + e1; -0.5 d1 + e1 <= 3; d1 + e1 >= 6; 3d1 - 2e1 <= 16; You would expect that this is exactly the same model as before. And for variable d1, this is also the case. However, e1 in the last constraint is a problem. Here lp_solve doesn't recognise 2e1 as two times variable e1, but as the constant value 2.0e1 (20). It sees the e1 as an exponent! There is no problem when there is at least one space between 2 and e1. In that case lp_solve knows that it is two times variables e1 because there may not be any spaces in numbers.Operators
Consider the following constraint: +3 x + 2 y <= 16; The + sign is optional. So above equation can also be written as: 3 x + 2 y <= 16; But also as: 3 x 2 y <= 16; This may look somewhat strange and can even lead to confusion. Consider the equation without the factor 2: 3 x y <= 16; This is still considered as: 3 x + y <= 16; And not as 3 x * y <= 16; as could be thought... Also, lp_solve allows adjacent operators. Consider the following constraint: +3 x - 2 y <= 16; This may also be written as: +3 x + -2 y <= 16; or +3 x +- 2 y <= 16; or +3 x - +2 y <= 16; And the constraint +3 x + 2 y <= 16; may also be written as: +3 x + +2 y <= 16; or +3 x + + 2 y <= 16; and even: +3 x - -2 y <= 16; Note that the lp-format does not allow parentheses () to make things clearer ... So the following is not allowed: +3 x - (-2) y <= 16; In fact, there is no limit on the number of operators that are placed next to each other, separated with as many or as few spaces as desired... For example - -- -- is seen as -, while ---- -- is seen as +.
is_traceReturns a flag if pivot selection must be printed while solving. unsigned char is_trace(lprec *lp); Return Value is_trace returns TRUE or FALSE. Print or do not print. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The is_trace function returns a flag if pivot selection must be printed while solving. This function is mend for debugging purposes. The default is not to print (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_trace |
get_max_levelReturns the deepest Branch-and-bound level of the last solution. int get_max_level(lprec *lp); Return Value get_max_level returns the deepest Branch-and-bound level of the last
solution. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_max_level function returns the deepest Branch-and-bound level of
the last solution. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLIget_total_nodes, get_total_iter |
read_basisRead basis from a file and set as default basis. unsigned char read_basis(lprec *lp, char *filename, char *info); Return Value Returns TRUE if basis could be read from filename and FALSE if not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI filename Filename to read the basis from. info When not NULL, returns the information of the INFO card in filename. When NULL, the information is ignored. Note that when not NULL, that you must make sure that this variable is long enough, else a memory overrun could occur. Remarks
The read_basis function reads a basis from filename and
sets it as initial basis of the lp. The basis in the file must be in MPS bas file format. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_basis, set_basis, default_basis, write_basis, guess_basis, get_basiscrash, set_basiscrash |
set_XLISet External Language Interfaces package. unsigned char set_XLI(lprec *lp, char *filename); Return Value set_XLI returns TRUE if the call has succeeded, else FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI filename The name of the XLI package. Remarks The set_XLI function sets the External Language Interface (XLI). This call is normally only needed when write_XLI will be called. read_XLI automatically calls this routine. See External Language Interfaces for a complete description on XLIs. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, write_XLI, has_XLI, is_nativeXLI |
is_scaletypeReturns if scaling type specified in scaletype is active. unsigned char is_scaletype(lprec *lp, int scaletype); Return Value is_scaletype returns if scaling mode specified in scaletype is active. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI scaletype
Remarks The is_scaletype function returns if scaling mode specified in scaletype.
This can influence numerical stability considerably. It is advisable to always
use some sort of scaling. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_scaling, get_scaling, set_scalelimit, get_scalelimit, is_integerscaling, is_scalemode |
Changes from version 4 to version 5.1Main features and changes to v5.1 compared to v4Overall, the v5 code is faster and more robust than v4. This robustness is for example proven by the fact that many more models can now be solved even without scaling. However, scaling should still be considered. The API has also routine to do a crash of basis (determine a starting point so that solving goes faster). The lp_solve program has been extended with options to handle the new functionality. It now also has options to write the model in the different file formats.
Changes in lp_solve programThe lp_solve program has many new options to make use of as many as possible possibilities of lpsolve. There are several extra options, some are extended and some are removed because they are obsolete. See lp_solve for a list of all possible options. Note that on this link there is also a reference to the API call(s) that are used for this option. There you can find more information on the option. See the list above for some of the new features.What happened with lp2mps, mps2lp ?These programs are removed. But don't panic, there is another way to convert from one format to another. This via the lp_solve program. This is done because of the support of a new format: The CPLEX-format. Because there are now 3 formats supported, it would have required 6 programs to convert from one format to another. Instead of doing this, lp_solve has new parameters to be able to write the model to a file, and that in all formats. So, lp_solve can read the model in any format and write it back in any format. In that case, it is most likely not whished to also calculate the model and therefore the parameter -parse_only can be used. Here some examples how to convert from one format to another:lp to mps: lp_solve -parse_only -lp lpfile -wmps mpsfile mps to lp: lp_solve -parse_only -mps mpsfile -wlp lpfile It is even possible to generate several formats at the same time: lp to all formats: lp_solve -parse_only -lp lpfile -wlp lpfile -wmps mpsfile Changes in API callsThe API is not that much changed, but has been expanded to handle new functionality. Some simplification has taken place, for example in scaling, and a call to auto_scale is not necessary any more.However the changes in some routines is big enough to break compatibility with version 4. Be aware of this. You must review your source code for the mentioned functions. Especially those with a (!) behind are very important to check. That is also the reason why the Windows dll will be called lpsolve51.dll compared to lpsolve.dll for version 4. Don't just rename this dll and expect that your program will work then. Changed API calls
New API calls
Removed API calls
|
set_simplextypeSets the desired combination of primal and dual simplex algorithms. void set_simplextype(lprec *lp, int simplextype); Return Value set_simplextype has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI simplextype The desired combination of primal and dual simplex algorithms. Can by any of the following values:
Remarks The set_simplextype function sets the desired combination of primal and dual simplex algorithms. The default is SIMPLEX_DUAL_PRIMAL (6). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_simplextype, set_preferdual |
get_solutionlimitReturns the solution number that must be returned. int get_solutionlimit(lprec *lp); Return Value get_solutionlimit returns the solution number that must be returned. This value gives the number of the solution that must be returned. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks This is only valid if there are integer, semi-continious or SOS variables in the model so that the branch-and-bound algoritm is used. If there are more solutions with the same objective value, then this number specifies which solution must be returned. This can be used to retrieve all possible solutions. Start with 1 till get_solutioncount Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_solutionlimit, get_solutioncount |
LPSolve IDEThe LPSolve IDE (Integrated Development Interface) is a very user friendly Windows interface to the lpsolve API. All functionality of lpsolve can be accessed via a graphical and very user friendly application. Many thanks to Henri Gourvest for making this nice interface to lpsolve and making it available to the community. Here is a list of some of the features of the IDE:
Here are some screen shorts:
InstallationDownload the setup lp_solve_5.5.0.13_IDE_Setup.exe and run the setup, that is all.Note that it needs the lpsolve dll (lpsolve55.dll) to do its job. Four your convenience, a dll is provided with this archive, but it is not guaranteed to be the most recent one. To get the most recent lpsolve dll, extract if from the lp_solve_5.5.0.13_dev.zip archive and put it in the folder where you installed the IDE files in. Also note that the IDE also puts some messages on the console. This may be changed in the future. When started from a command prompt, the messages are shown in this screen, when started from Windows, a console screen will also be created. If you are looking for a message not shown in the IDE, maybe it is shown on the console window... UsageThe IDE is very easy to use and doesn't need much explanations. When you start it, you get an editor window where a model file must be entered. By default this in the lp format. Initially, you will see the following:/* Objective function */ min: ; /* Variable bounds */As an example, clear this and enter the following: max: 143 x + 60 y; 120 x + 210 y <= 15000; 110 x + 30 y <= 4000; x + y <= 75;Now press the F9 button or click the green arrow (Solve) in the toolbar to solve this model. In the result tab you see the result of this model. Note that this is the model presented in Formulation of an lp problem in lpsolve. The model is formulated in the lp format. See lp-format for a description of it. |
get_epsperturbReturns the value that is used as perturbation scalar for degenerative problems. REAL get_epsperturb(lprec *lp); Return Value get_epsperturb returns the perturbation scalar. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The default epsperturb value is 1e-5 Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_epsperturb, set_infinite, get_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_mip_gap, get_mip_gap |
write_XLIWrite a model to a file via the External Language Interface. unsigned char write_XLI(lprec *lp, char *filename, char *options, unsigned char results); Return Value
write_XLI returns TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI filename Filename to write the model to. options Extra options that can be used by the writer. results FALSE to generate a model file and TRUE to generate a solution file. Remarks The write_XLI function writes the model to filename via the External Language Interface. Note that set_XLI must be called before this routine to set an XLI. See External Language Interfaces for a complete description on XLIs.Example See Also delete_lp, free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileex, read_XLI, has_XLI, is_nativeXLI, set_XLI |
get_var_branchReturns, for the specified variable, which branch to take first in branch-and-bound algorithm. int get_var_branch(lprec *lp, int column); Return Value get_var_branch returns which branch to take first in branch-and-bound
algorithm.
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable on which the mode must be returned. It must be between 1 and the number of columns in the lp. If it is not within this range, the return value is the value of get_bb_floorfirst Remarks The get_var_branch function returns which branch to take first in
branch-and-bound algorithm. This can influence solving times considerably.
Depending on the model one rule can be best and for another model another rule. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_var_branch, set_bb_floorfirst, get_bb_floorfirst, set_var_weights, get_var_priority |
resize_lpAllocate memory for the specified size. unsigned char resize_lp(lprec *lp, int rows, int columns); Return Value Returns TRUE if succeeded, FALSE if not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI rows Allocate memory for this amount of rows. columns Allocate memory for this amount of columns. Remarks
The resize_lp function deletes the last rows/columns of the model if the new number
of rows/columns is less than the number of rows/columns before the call. Example See Also copy_lp, delete_lp, free_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_column, add_columnex, str_add_column, add_constraint, add_constraintex, str_add_constraint |
get_break_at_valueReturns the value at which the branch-and-bound algorithm stops when the object value is better than this value. REAL get_break_at_value(lprec *lp); Return Value get_break_at_value returns the value to break on. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_break_at_value function returns the value at which the
branch-and-bound algorithm stops when the object value is better than this
value. Stopping at a given object value can be useful if you are only
interested for a solution that has an object value which is at least a given
value, but not necessarily (and most probably) the most optimal solution. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_break_at_value, set_break_at_first, is_break_at_first, set_obj_bound, get_obj_bound, set_mip_gap, get_mip_gap |
set_col_nameSet the name of a column in the lp. unsigned char set_col_name(lprec *lp, int column, char *new_name); Return Value set_col_name returns TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column for which the name must be set. Must be between 1 and the number of columns in the lp. new_name The name for the column. Remarks The set_col_name sets the name of the column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_col_name, get_origcol_name, set_row_name, get_row_name, get_origrow_name, get_nameindex |
is_lag_traceReturns a flag if Lagrangian progression must be printed while solving. unsigned char is_lag_trace(lprec *lp); Return Value is_lag_trace returns TRUE or FALSE. Print or do not print. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The is_lag_trace function returns a flag if Lagrangian progression must be printed while solving. This function is mend for debugging purposes. The default is not to print (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_lag_trace |
get_lowboGets the lower bound of a variable. REAL get_lowbo(lprec *lp, int column); Return Value get_lowbo returns the lower bound on the specified variable. If no bound
was set, it returns 0, the default lower bound. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable. It must be between 1 and the number of columns in the lp. Remarks The get_lowbo function returns the lower bound on the variable identified by column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_lowbo, set_upbo, get_upbo, set_bounds, set_unbounded, is_unbounded, is_negative |
set_use_namesSets if variable or constraint names are used. void set_use_names(lprec *lp, unsigned char isrow, unsigned char use_names); Return Value set_use_names has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI isrow Set to FALSE (0) if column information is needed and TRUE (1) if row information is needed. use_names If FALSE (0), then names are not used, else they are. Remarks When a model is read from file or created via the API, variables and constraints can be named.
These names are used to report information or to save the model in a given format.
However, sometimes it is required to ignore these names and to use the internal names of lp_solve.
This is for example the case when the names do not comply to the syntax rules of the format that
will be used to write the model to. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_use_names, set_col_name, get_col_name, set_row_name, get_row_name |
free variablesFree variables are variables that have no lower or upper bound. By default, variables don't have an upper bound, but they do have a lower bound of zero. So they can only take positive values. Free variables can also become negative until -infinite. lp_solve supports free variables since a long time. Internally, these variables are split in a positive and negative part. So the result of using free variables is that the number of columns increases. However this is transparent to the user. The API call set_unbounded can be used to define a variable as free. In the mps format, free variables can be specified in the
BOUNDS section. See mps-format.
NAME
ROWS
N R0
L R1
G R2
G R3
G R4
COLUMNS
x1 R0 -1.000000000 R1 1.0000000000
x1 R2 2.0000000000 R3 -1.000000000
x2 R0 -2.000000000 R1 1.0000000000
x2 R2 -1.000000000 R3 3.0000000000
x3 R0 4.0000000000 R4 1.0000000000
x4 R0 3.0000000000 R4 1.0000000000
RHS
RHS R1 5.0000000000 R4 0.5000000000
BOUNDS
FR BND x2
UP BND x3 10.000000000
LO BND x3 1.1000000000
FR BND x4
ENDATA
The red lines specify that variables x2 and x4 are free variables.
In the lp format, free variables can be specified in the
free section. See lp-format.
max: x1 + 2x2 - 4x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; free x2, x4; The red line specifies that variables x2 and x4 are free variables. The solution of this model is: Value of objective function: 5.73333 Actual values of the variables: x1 1.66667 x2 3.33333 x3 1.1 x4 -0.6 As can be seen, the value of x4 is -0.6, a negative value. If the variable would not be set as free, it would not be negative. |
set_anti_degenSpecifies if special handling must be done to reduce degeneracy/cycling while solving. void set_anti_degen(lprec *lp, int anti_degen); Return Value set_anti_degen has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI anti_degen Can be any combination (OR) of following values:
Remarks The set_anti_degen function specifies if special handling must be done to reduce degeneracy/cycling while solving. Setting this flag can avoid cycling, but can also increase numerical instability. The default is ANTIDEGEN_INFEASIBLE + ANTIDEGEN_STALLING + ANTIDEGEN_FIXEDVARS (37). Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_anti_degen, is_anti_degen |
Calling the lpsolve API from your applicationThere are two ways to call the lpsolve API from an application:
Dynamically means that the lpsolve code is dynamically linked to your code. This means that it is linked to your program when the executable is started or even only when you make calls to the lpsolve library. The lpsolve library is then not linked with the executable and is provided in a separate file. Under Windows this is a dll (lpsolve55.dll), under Unix/Linux this is a shared library (liblpsolve55.so). You must distribute this separate library with your program to make it work. The library must be located on a place that can be found by the program. There are several advantages of this way of working. Almost all programming languages have a way to call dynamic libraries or even can only call libraries that way. One example is VB6. Another advantage is that it is easier to update the package. The program doesn't have to be recompiled/relinked. You only have to provide a new lpsolve library. Statically means that the lpsolve code is statically linked to the code. This means that the program does not need extra files to be able to call lpsolve since the code is already contained in the executable. The executable will thus be larger. This can only be done if you have the source code of your program and you can recompile it and link it with the lpsolve code. Not all programming languages have the possibility to statically link code. For example VB6 does not have a way to do that. The advantage of this way of calling the lpsolve library is that you don't have to provide extra files with your executable since the library is already in the exe. The disadvantage is that you must recompile (or at least link) the program with the lpsolve code when an update of lpsolve is needed. There are two ways to link your application with lpsolve. The first way is add the needed lpsolve source code to the project and compile it together as one unit. This is most probably only possible when the code is also written in C/C++ (however not always since for example .NET allows to link for example C# code with C code). The disadvantage of this way of working is that you have to revise your project when you use a new version of lpsolve since there could be files added or removed in the lpsolve package. Also you may have to define some defines. A better way of working is making use of the lpsolve library. Under DOS/Windows this is called liblpsolve55.lib (liblpsolve55d.lib in debug mode), under Unix/Linux liblpsolve55.a. The advantages are that other languages (like Pascal) can also link with such a library, your project is not overloaded with the lpsolve source files and also not unimportant, the linker only takes the code from the library that you really use resulting in a smaller executable. One disadvantage is that you cannot debug and step trough the lpsolve code then, if you would want to do that. So what method to choose to call lpsolve from your application? Dynamically link your application with lpsolvelpsolve is separated from the application. So there are two separate compilations. One of the application and one of the lpsolve library. Most people will not compile the lpsolve library themselves since it is provided for several popular platforms. The files are in lp_solve_5.5.0.13_dev.zip for Windows and lp_solve_5.5_dev.gz for Linux. Therefore it is first explained how to access the lpsolve library in your application. This depends on the OS and the calling language. The most common are described here. There are two ways of linking a dynamic library to the application: Implicit and Explicit linking. It depends on the programming language which way of linking is supported. Some support only one of the two, some can do both ways.
Some may see Implicit linking as 'early binding' and Explicit linking as 'late binding'.
Although it is not exactly the same, the analogy is true. Just like 'early binding', with
Implicit linking, the symbols are resolved and checked at compile (actually link) time.
There is strong type checking and less chance to pass wrong arguments. Just like 'late binding',
with Explicit linking, the symbols are resolved and checked at runtime. The type checking is
loose and there is chance that wrong parameters are passed to the function with possible
disastrous results. But with the flexibility to dynamically load and call functions.
Statically link your application with lpsolvelpsolve is linked with the application. The application is most likely a C/C++ application. It must at least be a programming environment with a linker such that the lpsolve code can be linked with your code. Some header files are also needed. They are included with the archive where the libraries are also in lp_solve_5.5.0.13_dev.zip and lp_solve_5.5_dev.gz. Only lp_lib.h must be included in your source code. The other header files are included by this master include file. There are two ways to link lpsolve statically with your application: Implicit linking with the lpsolve static library and link your code with the lpsolve source code.
|
is_intGets the type of the variable. Integer or floating point. unsigned char is_int(lprec *lp, int column); Return Value is_int returns TRUE (1) if the variable is set as integer, FALSE (0)
otherwise. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be checked. It must be between 1 and the number of columns in the lp. Remarks The is_int function returns if a variable must be integer or not. Default a variable is not integer. From the moment there is at least one integer variable in the model, the Branch and Bound algorithm is used to make these variables integer. Note that solving times can be considerably larger when there are integer variables. See integer variables for a description about integer variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_int, is_binary, set_binary |
The lp_solve program is a command line application that can use as good as all functionality of the library.
A list of all options is given by entering the following command:
lp_solve -h
This gives:
Usage of lp_solve version 5.5.0.13: lp_solve [options] [[<]input_file] List of options: -h prints this message -lp read from LP file (default) See read_LP, See lp-format -mps read from MPS file in fixed format See read_MPS, See mps-format -fmps read from MPS file in free format See read_freeMPS, See mps-format -rxli xliname filename read file with xli library See external language interface -rxlidata datafilename data file name for xli library. See external language interface -rxliopt options options for xli library. See external language interface -rbas filename read basis from filename See read_basis, See mps bas file format -rpar filename read parameters from filename. See read_params -rparopt options options for parameter file: -H headername: header name for parameters. By default 'Default' -wlp filename write to LP file See write_lp, See lp-format -wmps filename write to MPS file in fixed format See write_mps, See mps-format -wfmps filename write to MPS file in free format See write_freemps, See mps-format -wxli xliname filename write file with xli library See external language interface -wxliopt options options for xli library. See external language interface -wxlisol xliname filename write solution file with xli library. See external language interface -wxlisolopt options options for xli library. See external language interface -wbas filename write basis to filename. See write_basis, See mps bas file format -wpar filename write parameters to filename. See write_params -wparopt options options for parameter file: -H headername: header name for parameters. By default 'Default' -wafter Write model after solve (useful if presolve used). -parse_only parse input file but do not solve -nonames Ignore variables and constraint names See set_use_names -norownames Ignore constraint names See set_use_names -nocolnames Ignore variable names See set_use_names -min Minimize the lp problem (overrules setting in file) See set_minim -max Maximize the lp problem (overrules setting in file) See set_maxim -r <value> specify max nbr of pivots between a re-inversion of the matrix See set_maxpivot -piv <rule> specify simplex pivot rule See set_pivoting -piv0: Select first -piv1: Select according to Dantzig -piv2: Select Devex pricing from Paula Harris (default) -piv3: Select steepest edge These pivot rules can be combined with any of the following: -pivf In case of Steepest Edge, fall back to DEVEX in primal. See set_pivoting -pivm Multiple pricing. See set_pivoting -piva Temporarily use First Index if cycling is detected. See set_pivoting -pivr Adds a small randomization effect to the selected pricer. See set_pivoting -pivll Scan entering/leaving columns left rather than right. See set_pivoting -pivla Scan entering/leaving columns alternatingly left/right. See set_pivoting -pivh Use Harris' primal pivot logic rather than the default. See set_pivoting -pivt Use true norms for Devex and Steepest Edge initializations. See set_pivoting -o0 Don't put objective in basis. See set_obj_in_basis -o1 Put objective in basis (default). See set_obj_in_basis -s <mode> <scaleloop> use automatic problem scaling. See set_scaling -s0: No scaling -s1: Geometric scaling (default) -s2: Curtis-reid scaling -s3: Scale to convergence using largest absolute value -s: -s4: Numerical range-based scaling -s5: Scale to convergence using logarithmic mean of all values -s6: Scale based on the simple numerical range -s7: Scale quadratic These scaling rules can be combined with any of the following: -sp also do power scaling. See set_scaling -si also do Integer scaling (default). See set_scaling -se also do equilibration to scale to the -1..1 range (default). See set_scaling -presolve presolve problem before start optimizing (rows+columns) See set_presolve -presolverow presolve problem before start optimizing (rows only) See set_presolve -presolvecol presolve problem before start optimizing (columns only) See set_presolve -presolvel also eliminate linearly dependent rows See set_presolve -presolves also convert constraints to SOSes (only SOS1 handled) See set_presolve -presolver If the phase 1 solution process finds that a constraint is redundant then this constraint is deleted See set_presolve -presolvek Simplification of knapsack-type constraints through addition of an extra variable, which also helps bound the OF See set_presolve -presolveq Direct substitution of one variable in 2-element equality constraints; this requires changes to the constraint matrix See set_presolve -presolvef Identify implied free variables (releasing their expl. bounds) See set_presolve -presolveg Reduce (tighten) coef. in integer models based on GCD argument See set_presolve -presolveb Attempt to fix binary variables at one of their bounds See set_presolve -presolvec Attempt to reduce coefficients in binary models See set_presolve -presolverowd Idenfify and delete qualifying constraints that are dominated by others, also fixes variables at a bound See set_presolve -presolvecold Deletes variables (mainly binary), that are dominated by others (only one can be non-zero) See set_presolve -C <mode> basis crash mode See set_basiscrash -C0: No crash basis -C2: Most feasible basis -C3: Least degenerate basis -prim Prefer the primal simplex for both phases. See set_preferdual -dual Prefer the dual simplex for both phases. See set_preferdual -simplexpp Set Phase1 Primal, Phase2 Primal. See set_simplextype -simplexdp Set Phase1 Dual, Phase2 Primal. See set_simplextype -simplexpd Set Phase1 Primal, Phase2 Dual. See set_simplextype -simplexdd Set Phase1 Dual, Phase2 Dual. See set_simplextype -degen use perturbations to reduce degeneracy, can increase numerical instability See set_anti_degen -degenc use column check to reduce degeneracy See set_anti_degen -degend dynamic check to reduce degeneracy See set_anti_degen -degenf anti-degen fixedvars See set_anti_degen -degens anti-degen stalling See set_anti_degen -degenn anti-degen numfailure See set_anti_degen -degenl anti-degen lostfeas See set_anti_degen -degeni anti-degen infeasible See set_anti_degen -degenb anti-degen B&B See set_anti_degen -degenr anti-degen Perturbation of the working RHS at refactorization See set_anti_degen -degenp anti-degen Limit bound flips See set_anti_degen -trej <Trej> set minimum pivot value See set_epspivot -epsd <epsd> set minimum tolerance for reduced costs See set_epsd -epsb <epsb> set minimum tolerance for the RHS See set_epsb -epsel <epsel> set tolerance for rounding values to zero See set_epsel -epsp <epsp> set the value that is used as perturbation scalar for degenerative problems See set_epsperturb -improve <level> iterative improvement level See set_improve -improve0: none -improve1: Running accuracy measurement of solved equations on Bx=r -improve2: Improve initial dual feasibility by bound flips (default) -improve4: Low-cost accuracy monitoring in the dual -improve8: check for primal/dual feasibility at the node level -timeout <sec> Timeout after sec seconds when not solution found. See set_timeout -bfp <filename> Set basis factorization package. See set_BFP -noint Ignore integer restrictions -e <number> specifies the tolerance which is used to determine whether a floating point number is in fact an integer. Should be < 0.5 See set_epsint -g <number> -ga <number> specifies the absolute MIP gap for branch-and-bound. See set_mip_gap This specifies the absolute allowed tolerance on the object function. Can result in faster solving times. -gr <number> specifies the relative MIP gap for branch-and-bound. See set_mip_gap This specifies the relative allowed tolerance on the object function. Can result in faster solving times. -f specifies that branch-and-bound algorithm stops at first found solution See set_break_at_first -b <bound> specify a lower bound for the objective function See set_obj_bound to the program. If close enough, may speed up the calculations. -o <value> specifies that branch-and-bound algorithm stops when objective value is better than value See set_break_at_value -c -cc during branch-and-bound, take the ceiling branch first See set_bb_floorfirst -cf during branch-and-bound, take the floor branch first See set_bb_floorfirst -ca during branch-and-bound, the algorithm chooses branch See set_bb_floorfirst -depth <limit> set branch-and-bound depth limit See set_bb_depthlimit -n <solnr> specify which solution number to return See set_solutionlimit -B <rule> specify branch-and-bound rule See set_bb_rule -B0: Select Lowest indexed non-integer column (default) -B1: Selection based on distance from the current bounds -B2: Selection based on the largest current bound -B3: Selection based on largest fractional value -B4: Simple, unweighted pseudo-cost of a variable -B5: This is an extended pseudo-costing strategy based on minimizing the number of integer infeasibilities -B6: This is an extended pseudo-costing strategy based on maximizing the normal pseudo-cost divided by the number of infeasibilities. Similar to (the reciprocal of) a cost/benefit ratio These branch-and-bound rules can be combined with any of the following: -Bw WeightReverse branch-and-bound See set_bb_rule -Bb BranchReverse branch-and-bound See set_bb_rule -Bg Greedy branch-and-bound See set_bb_rule -Bp PseudoCost branch-and-bound See set_bb_rule -Bf DepthFirst branch-and-bound See set_bb_rule -Br Randomize branch-and-bound See set_bb_rule -BG GubMode branch-and-bound See set_bb_rule -Bd Dynamic branch-and-bound See set_bb_rule -Bs RestartMode branch-and-bound See set_bb_rule -BB BreadthFirst branch-and-bound See set_bb_rule -Bo Order variables to improve branch-and-bound performance See set_bb_rule -Bc Do bound tightening during B&B based of reduced cost info See set_bb_rule -Bi Initialize pseudo-costs by strong branching See set_bb_rule -time Print CPU time to parse input and to calculate result. See time_elapsed -v <level> verbose mode, gives flow through the program. See set_verbose if level not provided (-v) then -v4 (NORMAL) is taken. -v0: NEUTRAL -v1: CRITICAL -v2: SEVERE -v3: IMPORTANT (default) -v4: NORMAL -v5: DETAILED -v6: FULL -t trace pivot selection See set_trace -d debug mode, all intermediate results are printed, and the branch-and-bound decisions See set_debug -R report information while solving the model See put_msgfunc See get_working_objective -Db <filename> Do a generic readable data dump of key lp_solve model variables before solve. See print_debugdump Principally for run difference and debugging purposes -Da <filename> Do a generic readable data dump of key lp_solve model variables after solve. See print_debugdump Principally for run difference and debugging purposes -i print all intermediate valid solutions. See set_print_sol Can give you useful solutions even if the total run time is too long -ia print all intermediate (only non-zero values) valid solutions. See set_print_sol Can give you useful solutions even if the total run time is too long -S <detail> Print solution. If detail omitted, then -S2 is used. -S0: Print nothing -S1: Only objective value See print_objective See get_objective -S2: Obj value+variables (default) See print_solution See get_variables, get_ptr_variables -S3: Obj value+variables+constraints See print_constraints See get_constraints -S4: Obj value+variables+constraints+duals See print_duals See get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, See get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex -S5: Obj value+variables+constraints+duals+lp model See print_lp -S6: Obj value+variables+constraints+duals+lp model+scales See print_scales -S7: Obj value+variables+constraints+duals+lp model+scales+lp tableau See print_tableau
Enter the following in your favorite text editor (Windows users, don't use Word or Wordpad, that won't work. If you don't have an editor, use notepad).
max: 143 x + 60 y; 120 x + 210 y <= 15000; 110 x + 30 y <= 4000; x + y <= 75;
Save this on your hard disk with name model.lp (don't forget in which directory/folder you save it).
Now enter the following:
lp_solve -S3 model.lp
This gives:
Value of objective function: 6315.63 Actual values of the variables: x 21.875 y 53.125 Actual values of the constraints: R1 13781.2 R2 4000 R3 75
Note that this is the model presented in Formulation of an lp problem in lpsolve. The model is formulated in the lp format. See lp-format for a description of it.
docs/5.5/scaling.htm 0000644 0001750 0001750 00000012534 11306036626 013123 0 ustar rene rene
ScalingScaling is a very important issue to consider in mathematical computations on a computer. A computer stores floating-point numbers with a limited precision because it uses a fixed number of bytes to store them. Consider for example the result of the following calculation: 1/3 In our metric system, the result of this computation cannot be represented with a finite number of digits. The value is 0.3333333333333... with an infinite number of digits. Because a computer only has a certain precision, the result is stored with a finite number of digits. For regular floating-point numbers this is about 15 digits, independent of its size. So this result would for example be stored as 0.333333333333333 on a computer. The computation of 100000000000000000/3 would be stored as 33333333333333300. In several cases, this is no problem. The stored value is close enough to the value that is needed. However, when doing calculations, problems can arise because of this. Especially if small and large values are added or subtracted from each other. In that case, the precision of the small number is lost. This can result in the effect that calculated values aren't correct anymore. The more floating-point calculations are done, the more chance there is that numerical instability occurs and doing calculations with big and small numbers results in faster occurrence of this effect. Then there is also the effect of accumulating rounding errors which can result in a totally screwed up data matrix after having done several calculations. The simplex algorithm is a typical iterating process where factors of thousands of floating calculations are done to find the optimal solution. The chance of numerical instability is then also quite big. But scaling not only improves numerical stability and minimizes rounding errors, it also improves performance. This may seem strange, but it is true. When a model is not scaled, the algorithm could reject certain pivot elements because they are too small and because of this, the solver doesn't choose the shortest route to the solution. If a model is proper scaled, this effect will not occur. There are several ways to cope with this and it starts with the input data. The chance for numerical instability and rounding errors is considerably larger when the input data contains both large and small numbers. So to improve stability, one must try to work with numbers that are somewhat in the same range. Ideally in the neighbourhood of 1. You should realize, that you the user are probably in a better position to scale
the problem than any computer algorithm. The way to do this is: first choose appropriately
scaled units for the extensive variables of the problem, e.g., kilo-tons instead of pounds,
tankcar loads instead of gallons, millions of dollars instead of pennies, or nanometers instead
of feet, so that the numerical spread of the coefficients in each single constraint, and in the
objective function, will be at most one or two orders of magnitude; and then second scale the
constraints themselves, by multiplying each entire constraint relation by an appropriate positive
constant, so that the numerical spread of the coefficients in the different constraints is at most
another one or two orders of magnitude.
For example saying: lp_solve also has some build-in scaling routines which can take over this scaling job from the modeller or maybe better, to do additional scaling. This is implemented in such a way that it is transparent to the user. When scaling is done, lp_solve scales rows and/or columns, but the user doesn't see anything of this process. The returned values are still as if no scaling was done. See set_scaling for the possible scaling types. Note that lp_solve, by default doesn't do scaling. It must be invoked explicitly. Also note that even when scaling is enabled that integer variables are then again by default not scaled. To scale also integer variables, SCALE_INTEGERS must be added to the scale mode. This is done because of the nature of integer variables. If you want them integer, but you also scale them, then they aren't integer anymore. It is possible to scale those variables with the SCALE_INTEGERS flag, but some accuracy on being integer can be lost. Conslusion. You should always do some sort of scaling. It starts when you design the model. Extra scaling can be accomplished by one of the scaling options of lp_solve. |
get_bb_floorfirstReturns which branch to take first in branch-and-bound algorithm. int get_bb_floorfirst(lprec *lp); Return Value get_bb_floorfirst returns which branch to take first in branch-and-bound algorithm. Can by any of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_bb_floorfirst function returns which branch to take first in
branch-and-bound algorithm. This can influence solving times considerably.
Depending on the model one rule can be best and for another model another rule. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_bb_floorfirst, set_var_branch, get_var_branch, set_var_weights, get_var_priority |
get_simplextypeReturns the desired combination of primal and dual simplex algorithms. int get_simplextype(lprec *lp); Return Value get_simplextype returns the desired combination of primal and dual simplex
algorithms.
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_simplextype function returns the desired combination of primal and dual simplex algorithms. The default is SIMPLEX_DUAL_PRIMAL (6). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_simplextype, set_preferdual |
get_bb_depthlimitReturns the maximum branch-and-bound depth. int get_bb_depthlimit(lprec *lp); Return Value get_bb_depthlimit returns the maximum branch-and-bound depth. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_bb_depthlimit function returns the maximum branch-and-bound
depth. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_bb_depthlimit |
default_basisSets the starting base to an all slack basis (the default simplex starting basis). void default_basis(lprec *lp); Return Value None Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The default_basis function sets the starting base to an all slack basis (the default simplex starting basis). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_basiscrash, set_basiscrash, get_basis, set_basis, read_basis, write_basis, guess_basis |
get_NcolumnsReturns the number of columns (variables) in the lp. int get_Ncolumns(lprec *lp); Return Value get_Ncolumns returns the number of columns (variables) in the lp. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_Ncolumns function returns the number of columns (variables) in the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_Norig_columns, get_Nrows, get_Norig_rows, get_orig_index, get_lp_index, get_Lrows |
print_tableauPrints the tableau. void print_tableau(lprec *lp); Return Value print_tableau has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
The print_tableau function prints the tableau. This function only works after a successful solve Example See Also delete_lp, free_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, print_objective, print_solution, print_constraints, print_duals, print_scales, print_str, set_outputstream, set_outputfile, print_debugdump |
get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresultReturns the sensitivity of the constraints and the variables. unsigned char get_sensitivity_rhs(lprec *lp, REAL *duals, REAL *dualsfrom, REAL *dualstill); unsigned char get_ptr_sensitivity_rhs(lprec *lp, REAL **ptr_duals, REAL **ptr_dualsfrom, REAL **ptr_dualstill); unsigned char get_dual_solution(lprec *lp, REAL *duals); unsigned char get_ptr_dual_solution(lprec *lp, REAL **ptr_duals); REAL get_var_dualresult(lprec *lp, int index); Return Value get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution,
get_ptr_dual_solution return TRUE (1) if the operation was successful.
A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI duals An array that will contain the values of the dual variables aka reduced costs. ptr_duals The address of a pointer that will point to an array that will contain the values of the dual variables aka reduced costs. dualsfrom An array that will contain the values of the lower limits on the dual variables aka reduced costs. ptr_dualsfrom The address of a pointer that will point to an array that will contain the values of the lower limits of the dual variables aka reduced costs. dualstill An array that will contain the values of the upper limits on the dual variables aka reduced costs. ptr_dualstill The address of a pointer that will point to an array that will contain the values of the upper limits of the dual variables aka reduced costs. index The column of the variable for which the reduced cost is required. Note that this is the column number before presolve was done, if active. If index is 0, then the value of the objective function is returned by get_var_dualresult Remarks The get_sensitivity_rhs, get_ptr_sensitivity_rhs functions return
the values of the dual variables aka reduced costs and their limits. Note that get_ptr_sensitivity_rhs and get_ptr_dual_solution return a pointer to memory allocated and maintained by lp_solve. Be careful what you do with it. Don't modify its contents or free the memory. Unexpected behaviour would occur. Also note that this memory pointer is only guaranteed to remain constant until a next lp_solve API call is done. You should call this function again to make sure you have again the correct pointer. Otherwise, this pointer could point to invalid memory. This should not be a problem since this call is very efficient. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_feasible, get_objective, get_working_objective, get_variables, get_ptr_variables, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex, |
Infeasible modelsA linear program is infeasible if there exists no solution that satisfies all of the constraints -- in other words, if no feasible solution can be constructed. Since any real operation that you are modelling must remain within the constraints of reality, infeasibility most often indicates an error of some kind. Simplex-based LP software like lp_solve efficiently detects when no feasible solution is possible. The source of infeasibility is often difficult to track down. It may stem from an error in specifying some of the constraints in your model, or from some wrong numbers in your data. It can be the result of a combination of factors, such as the demands at some customers being too high relative to the supplies at some warehouses. Upon detecting infeasibility, LP codes typically show you the most recent infeasible solution that they have encountered. Sometimes this solution provides a good clue as to the source of infeasibility. If it fails to satisfy certain capacity constraints, for example, then you would do well to check whether the capacity is sufficient to meet the demand; perhaps a demand number has been mistyped, or an incorrect expression for the capacity has been used in the capacity constraint, or the model simply lacks any provision for coping with increasing demands. More often, unfortunately, LP codes respond to an infeasible problem by returning a meaninglessly infeasible solution, such as one that violates material balances. lp_solve is behaving also as such. lp_solve currently doesn't provide analysis routines to detect infeasible constraints however that doesn't mean that it stops there. A useful approach is to forestall meaningless infeasibilities by explicitly modelling those sources of infeasibility that you view as realistic. As a simple example, you could add a new "slack" variable on each capacity constraint, having a very high penalty cost. Then infeasibilities in your capacities would be signalled by positive values for these slacks at the optimal solution, rather than by a mysterious lack of feasibility in the linear program as a whole. Modelling approaches that use this technique are called sometimes "elastic programming" or "elastic filter". So in practice, if a constraint is a < constraint, add a variable to the model and give it for that constraint a -1 coefficient for that variable. In the objective you give it a relative large cost. If a constraint is a > constraint, add a variable to the model and give it for that constraint a +1 coefficient for that variable. In the objective you give it a relative large cost. If a constraint is an equal constraint, add two variables to the model and give it for that constraint respectively a -1 and +1 coefficient for that variable. In the objective you give them a relative large cost. Or you only add one variable and give it an -infinite lower bound. This will result in an automatic relaxation of the constraint(s) when needed (if that constraint would make the model infeasible). To make sure that these added variables only get non-zero values when the constraint is violating, the value in the objective must be relative large. Like that this variable gets a penalty cost and it will only become non-zero when really needed. Note that the signs of these objective coefficients must be positive when minimizing and negative when maximizing. Don't make these costs too big also because that introduces instabilities. If none of these added variables have a non-zero value then the model was initially feasible. When at least one is non-zero then the original model is infeasible. Note that the objective value will then not be very useful. However you could subtract the cost * value of all these variables from the objective to obtain the objective value of the relaxed model. Note that a model can also become infeasible because of bounds set on variables. Above approach doesn't relax these. Example:min: x + y; c1: x >= 6; c2: y >= 6; c3: x + y <= 11; This model is clearly infeasible. Now introduce extra variables to locate the infeasibility: min: x + y + 1000 e1 + 1000 e2 + 1000 e3; c1: x + e1 >= 6; c2: y + e2 >= 6; c3: x + y - e3 <= 11; The result of this model is: Value of objective function: 1011 Actual values of the variables: x 5 y 6 e1 1 e2 0 e3 0 With this simple example model, multiple solutions were possible. Here, the first constraint was relaxed since e1 is non-zero. Only this one constraint had to be relaxed to make the model feasible. The objective value of 1011 isn't saying very much. However if we subtract 1000 e1 + 1000 e2 + 1000 e3 from it, then it becomes 11 which is the value of the original objective function (x + y). |
set_break_at_valueSpecifies if the branch-and-bound algorithm stops when the object value is better than a given value. void set_break_at_value(lprec *lp, REAL break_at_value); Return Value set_break_at_value has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI break_at_value The value to break on. Remarks The set_break_at_value function allows the branch-and-bound algorithm to
stops when the object value is better than a given value. Stopping at a given
object value can be useful if you are only interested for a solution that has
an object value which is at least a given value, but not necessarily (and most
probably) the most optimal solution. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_break_at_value, set_break_at_first, is_break_at_first, set_obj_bound, get_obj_bound, set_mip_gap, get_mip_gap |
Absolute valuesConstraintsLinear constraints are of the form: a1 x1 + a2 x2 + a3 x3 + ... <= maximum a1 x1 + a2 x2 + a3 x3 + ... >= minimum Where minimum and maximum are constants. lp_solve can only handle these kind of Linear equations. So what if absolute values must be formulated: abs(a1 x1 + a2 x2 + a3 x3) = 0 abs(a1 x1 + a2 x2 + a3 x3) <= maximum abs(a1 x1 + a2 x2 + a3 x3) >= minimum = 0 (or <= 0)This is the easiest case. If abs(X) must be equal to zero, then this can only be fulfilled if X is zero. So the condition can also be written as: a1 x1 + a2 x2 + a3 x3 = 0 <= maximumThis is a bit more complicated, but still quite easy. Let's first represent a1 x1 + a2 x2 + a3 x3 by X. So the condition becomes: abs(X) <= maximum What is in fact abs(X) ? It is X if X is positive or 0 and it is -X if X is negative. This also implies that maximum is always bigger than or equal to zero. Else the constraint would always be impossible (mathematical impossible with real numbers). The geometric representation of this is: ----+===============+---- -maximum 0 +maximum The section between -maximum and +maximum fulfils the constraint. So if X is positive, the restriction becomes: X <= maximum If X is negative, the restriction becomes: -X <= maximum And the fortunate thing is that if we need the one restriction that the other is always redundant. If X is positive, then -X is negative and thus always less than maximum (which is always positive, remember) and thus the second equation is then redundant. If X is negative, then it is always less than maximum (which is always positive, remember) and thus the first equation is then redundant. This can also be seen easily from the graphical representation. So just add the following two equations: X <= maximum -X <= maximum And the abs(X) <= maximum condition is fulfilled. And what if the condition is abs(X) + Y <= maximum With Y any linear combination. It is easy to see that the same reasoning can be used to become: X + Y <= maximum -X + Y <= maximum With the original definition of X this becomes: a1 x1 + a2 x2 + a3 x3 + Y <= maximum -a1 x1 - a2 x2 - a3 x3 + Y <= maximumSpecial case 1 abs(x1) + abs(x2) + ... <= maximum;First consider each abs(xi) value. From above, consider the following: xiabs >= xi; xiabs >= -xi;This makes xiabs >= abs(xi) Greater than or equal, but as is, not for sure equal. However, in combination with other constraints, this can become equal. If following constraint is added, and when active, then each xiabs will represent the absolute value of xi: x1abs + x2abs + ... <= maximum;So, for each abs(xi) variable in the constraint, add a new variable xiabs and add two extra constraints for it. Then replace abs(xi) by xiabs in the constraint and the condition is fulfilled. Note that the objective may be minimization or maximization, it doesn't matter. Note that the variables may have an extra coefficient, but not negative! If the sign would be negative, then xiabs will not have the intention to become as small as possible, but as large as possible and the result would be that xiabs would not be equal to abs(xi). It could become larger. Example: max: x1 + 2x2 - 4x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; abs(x2) + abs(x4) <= 1.5; /* Note that this is not a valid expression. It will be converted. */ free x2, x4;The converted model becomes: max: x1 + 2x2 - 4x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; x2abs >= x2; x2abs >= -x2; x4abs >= x4; x4abs >= -x4; x2abs + x4abs <= 1.5; free x2, x4;The result is: Value of objective function: 2.6 Actual values of the variables: x1 3.75 x2 1.25 x3 1.1 x4 -0.25 x2abs 1.25 x4abs 0.25 >= minimumLet's first represent a1 x1 + a2 x2 + a3 x3 by X. So the condition becomes: abs(X) >= minimum What is in fact abs(X) ? It is X if X is positive or 0 and it is -X if X is negative. This also implies that minimum should always be bigger than zero. Else the constraint would always be fulfilled and there is no point in having the constraint. The geometric representation of this is: ====+---------------+==== -minimum 0 +minimum The section not between -minimum and +minimum fulfils the constraint. So if X is positive, the restriction becomes: X >= minimum If X is negative, the restriction becomes: -X >= minimum Unfortunately, the trick as for a maximum cannot be used here. If X is positive, then -X is not greater than minimum, in contrary ... It can also be seen from the graphical representation that this restriction is discontinue. This has as effect that it is not possible to convert this into a set of linear equations. A possible approach to overcome this is making use of integer variables. In particular by using a binary variable B: X + M * B >= minimum -X + M * (1 - B) >= minimum M is a large enough constant. See later. If B is 0, then the equations can be written as: X >= minimum -X + M >= minimum So in this case, the restriction X >= minimum is active. X must be positive and larger than minimum. With M large enough, the second constraint is always fulfilled. If B is 1, then the equations can be written as: X + M >= minimum -X >= minimum So in this case, the restriction -X >= minimum is active. X must be negative and -X be larger than minimum. With M large enough, the first constraint is always fulfilled. It is important to use a realistic value for M. Don't use for example 1e30 for it. This creates numerical instabilities and even if not then tolerances will give problem. Because of tolerances, B may not be zero, but actually for example 1e-20. This multiplied with 1e30 gives not zero, but 1e10! This results in X + 1e10 >= minimum instead of X >= minimum. Not what was mathematically formulated! So how big must M be? If we can predict how large X can become (absolutely), then we can predict a maximum value needed for M for this to work. If abs(X) cannot be larger than maximum, then M can be minimum+maximum. In most cases, it is possible to determine a reasonable upper bound for X. In lp-format, the needed equations are: X + M * B >= minimum; X + M * B <= M - minimum; B <= 1; int B; And what if the condition is abs(X) + Y >= minimum With Y any linear combination. It is easy to see that the same reasoning can be used to become: X + M * B + Y >= minimum -X + M * (1 - B) + Y >= minimum With M >= minimum - Y + abs(X) In lp-format: X + M * B + Y >= minimum; X + M * B - Y <= M - minimum B <= 1; int B; Objective functionThe objective function is of the form: min or max: a1 x1 + a2 x2 + a3 x3 + ... What if there is an absolute value in the objective: abs(a1 x1 + a2 x2 + a3 x3) + a4 x4 + a5 x5 Let's first represent a1 x1 + a2 x2 + a3 x3 by X and a4 x4 + a5 x5 by Y. Then the objective becomes: abs(X) + Y Depending on the sign before the abs and the objective direction, there is an easy and a harder way to solve this. minimization and sign is positive or maximization and sign is negative.min: abs(X) + Y or max: -abs(X) + Y In these two situations, abs(X) will be as small as possible, ideally zero. We can use that fact. Add one variable X' and two constraints to the model: X <= X' -X <= X' And replace in the objective abs(X) with X': min: X' + Y or max: -X' + Y That is all. So how does this work? There are 3 cases to consider: X > 0In this case, -X is negative and the second constraint -X <= X' is always fulfilled because X' is implicitly >= 0. The first constraint X <= X' is however different. Because X is positive, X' must be at least as large as X. But because X' is in the objective in such a way that is tends to be as small as possible, X' will be equal to X. So X' is abs(X) in this case. X < 0In this case, X is negative and the first constraint X <= X' is always fulfilled because X' is implicitly >= 0. The second constraint -X <= X' is however different. Because X is negative (-X positive), X' must be at least as large as -X. But because X' is in the objective in such a way that is tends to be as small as possible, X' will be equal to -X. So X' is abs(X) in this case. X = 0In this case, both constraints are always fulfilled because X' is implicitly >= 0. Because X' is in the objective in such a way that is tends to be as small as possible, X' will be equal to X, in this case 0. So X' is abs(X). So in all cases, X' equals abs(X) With the original definition of X and Y this becomes: min: X' + a4 x4 + a5 x5 or max: -X' + a4 x4 + a5 x5 a1 x1 + a2 x2 + a3 x3 <= X' -a1 x1 - a2 x2 - a3 x3 <= X' minimization and sign is negative or maximization and sign is positive.min: -abs(X) + Y or max: abs(X) + Y This is a different story. abs(X) now tends to be as large as possible. So the previous trick cannot be used now. A possible approach to overcome this is making use of integer variables. In particular by using a binary variable B and adding a variable X'. Add following constraints to the model: X + M * B >= X' -X + M * (1 - B) >= X' X <= X' -X <= X' And replace in the objective abs(X) with X': min: -X' + Y or max: X' + Y That is all. So how does this work? In fact this is a combination of a maximum and minimum constraint on an absolute expression. X' represents the absolute expression and is used in the objective. M is a large enough constant. See later. If B is 0, then the equations can be written as: X >= X' -X + M >= X' X <= X' -X <= X' So in this case, the restriction X >= X' is active. X must be positive and larger than X'. With M large enough, the second constraint is always fulfilled. The third constraint says that X <= X'. The forth constraint is always fulfilled. In fact the first and third constraint have as result that X' equals X, which is positive in this case. If B is 1, then the equations can be written as: X + M >= X' -X >= X' X <= X' -X <= X' So in this case, the restriction -X >= X' is active. X must be negative and -X be larger than X'. With M large enough, the first constraint is always fulfilled. The third constraint is always fulfilled. The forth constraint says that -X < X'. In fact the second and forth constraint have as result that X' equals -X, which is positive in this case. It is important to use a realistic value for M. Don't use for example 1e30 for it. This creates numerical instabilities and even if not then tolerances will give problem. Because of tolerances, B may not be zero, but actually for example 1e-20. This multiplied with 1e30 gives not zero, but 1e10! This results in X + 1e10 >= X' instead of X >= X'. Not what was mathematically formulated! So how big must M be? If we can predict how large X can become (absolutely), then we can predict a maximum value needed for M for this to work. If abs(X) cannot be larger than maximum, then M can be 2 * maximum. In most cases, it is possible to determine a reasonable upper bound for X. In lp-format, the needed equations are: max: X' + Y; X + M * B - X' >= 0; X + M * B + X' <= M; X <= X' -X <= X' B <= 1; int B; |
read_mps, read_freemps, read_MPS, read_freeMPSCreate an lprec structure and read an mps model from file. lprec *read_mps(FILE *stream, int verbose); lprec *read_freemps(FILE *stream, int verbose); lprec *read_MPS(char *filename, int verbose); lprec *read_freeMPS(char *filename, int verbose); Return Value
Returns a pointer to a new lprec structure. This must be provided to almost all
lp_solve functions. Parameters stream Pointer to FILE structure. filename Filename to read the mps model from. verbose The verbose level. Can be one of the following values: See also set_verbose and get_verbose. Remarks The read_mps, read_freemps, read_MPS, read_freeMPS functions construct a new lprec structure and read the model from filename. read_mps, read_freemps need a file pointer to an already opened file. read_MPS, read_freeMPS accepts the name of the file. The latter functions will generally be more convenient.
The model in the file must be in mps-format.
The read_free* routines accept files in free MPS format.
The other routines accept files in fixed MPS format. Example See Also delete_lp, free_lp, make_lp, write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileex, read_lp, read_LP, write_lp, write_LP, write_lpex |
put_logfuncSets a log routine. void put_logfunc(lprec *lp, lphandlestr_func newlog, void *loghandle); Return Value put_logfunc has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI newlog The log routine. loghandle A parameter that will be provided to the log routine. Remarks The put_logfunc function sets a log routine. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, put_abortfunc |
O-Matrix is an integrated environment for analysing and visualizing data, and building turnkey scientific and engineering computing solutions. The program includes hundreds of engineering and statistical functions for solving a broad range of technical computing problems. Easy-to-use and flexible plotting commands enable you to rapidly build design prototypes, and implement sophisticated systems.
The foundation of O-Matrix is a high-performance matrix language that is specifically designed for high-performance technical computing. The notation of this language will dramatically reduce your design and implementation efforts, and enable the construction of systems that execute far quicker than other interpreted environments. O-Matrix also provides a compatibility mode that enables you to run MATLAB© m-files. This enables you to leverage existing m-files, and simplifies the transition to O-Matrix for users experienced with MATLAB.
The O-Matrix environment is interpreted which means your commands are immediately executed as you enter them. Textual output is displayed in the Command window, and plotting commands are displayed in one or more Graphic windows. The environment provides a debugger for debugging, analysing, and profiling complex algorithms.
We will not discuss the specifics of O-Matrix here but instead refer the reader to the O-Matrix website.
lpsolve is callable from O-Matrix via a dynamic linked DLL function. As such, it looks like lpsolve is fully integrated with O-Matrix. Matrices can directly be transferred between O-Matrix and lpsolve in both directions. The complete interface is written in C so it has maximum performance. The whole lpsolve API is implemented with some extra's specific for O-Matrix (especially for matrix support). So you have full control to the complete lpsolve functionality via the omlpsolve O-Matrix driver. If you find that this involves too much work to solve an lp model then you can also work via higher-level script files that can make things a lot easier. See further in this article.
Compile and build omlpsolve:
----------------------------
1. Under Windows, the Microsoft Visual C/C++ compiler must be installed
and the environment variables must be active do that when a command prompt
is opened, the cl and nmake commands can be executed.
2. Go to directory lp_solve_5.5\extra\O-Matrix\lpsolve
3. To compile and build omlpsolve, enter the following command:
cvc
Load the omlpsolve driver in the O-Matrix memory space:
-------------------------------------------------------
1. Under Windows, make sure that the lpsolve55.dll file is somewhere in the path
(archive lp_solve_5.5.0.13_dev.zip)
2. A precompiled library is provided for Windows (omlpsolve.dll).
3. Start O-Matrix
4. Enter the following command in O-Matrix:
O> dll <path>\omlpsolve.dll, omlpsolve
This can also be added in autoexec.oms to automatically load the omlpsolve driver.
Note that O-Matrix version 5.8 or above is strongly recommended. Lower versions (at least 5.7) should work with this driver, but these versions don't have the ability to print information on the command prompt. For example default while a solve is done, information is printed to the command window. This will only be visible from version 5.8 or above.
O-Matrix is ideally suited to handle linear programming problems. These are problems in which you have a quantity, depending linearly on several variables, that you want to maximize or minimize subject to several constraints that are expressed as linear inequalities in the same variables. If the number of variables and the number of constraints are small, then there are numerous mathematical techniques for solving a linear programming problem. Indeed these techniques are often taught in high school or university level courses in finite mathematics. But sometimes these numbers are high, or even if low, the constants in the linear inequalities or the object expression for the quantity to be optimized may be numerically complicated in which case a software package like O-Matrix is required to effect a solution.
To make this possible, a driver program is needed: omlpsolve (omlpsolve.dll under Windows). This driver must be loaded in O-Matrix and O-Matrix can call the omlpsolve solver.
This driver calls lpsolve via the lpsolve shared library (lpsolve55.dll under Windows). This has the advantage that the omlpsolve driver doesn't have to be recompiled when an update of lpsolve is provided. The shared library must be somewhere in the Windows path.
So note the difference between the O-Matrix lpsolve driver that is called omlpsolve and the lpsolve library that implements the API that is called lpsolve55.
There are also some O-Matrix script files (.oms) as a quick start.
The first thing that must be done, each time O-Matrix is restarted and you want to use lpsolve is load the omlpsolve driver into the O-Matrix workspace. This is done via the dll command. Suppose that omlpsolve.dll is installed in c:\omwin\dll, then the following command must be used to load the driver:
dll c:\omwin\dll\omlpsolve.dll, omlpsolve
That is basically all you need to do. From now on, you can use the library. This until a clear command is given or O-Matrix is restarted. Then this command must be given again to reload the library.
To make things easier, you can edit the file autoexec.oms with your favourite editor (or notepad) in the omwin folder and add above line at the end of this file (before the last end). That will automatically load the lpsolve driver in memory when O-Matrix is started and also when a clear command is executed. So it will appear as if the omlpsolve command is then always available.
To test if everything is installed correctly, enter omlpsolve in the O-Matrix command prompt. If it gives the following, then everything is ok:
omlpsolve O-Matrix Interface version 5.5.0.5
using lpsolve version 5.5.0.13
Usage: [ret1, ret2, ...] = omlpsolve("functionname", arg1, arg2, ...)
Possibly, this is followed with:
No printing capability to command window available. You need to upgrade to version 5.8 for this feature.
Then you are working with an O-Matrix version lower than 5.8. The driver should work, but nothing is printed on the command window when lpsolve has something to report (for example while solving).
However, if you get a message box with the following:
The identifier omlpsolve is not defined.
Then either the dll command that was previous given was unsuccessful (or not given at all) or something was misspelled after the ,
If you get the following:
This application has failed to start because lpsolve55.dll was not found. Re-installing the application may fix this problem.
Then O-Matrix can find the omlpsolve driver program, but the driver program cannot find the lpsolve library that contains the lpsolve implementation. This library is called lpsolve55.dll and should be on your system in a directory that in the PATH environment variable. This path can be shown via the command getenv("PATH")
The lpsolve55.dll files must be in one of these specified directories. It is common to place this in the WINDOWS\system32 folder.
All this is developed and tested with O-Matrix version 5.7. This is the minimum supported release. Older releases are unsupported.
In the following text, O> before the O-Matrix commands is the O-Matrix command line. Only the text after O> must be entered.
To call an lpsolve function, the following syntax must be used:
O> [ret1, ret2, ...] = omlpsolve("functionname", arg1, arg2, ...)
The return values are optional and depend on the function called. functionname must always be enclosed between double quotes to make it alphanumerical and it is case sensitive. The number and type of arguments depend on the function called. Some functions even have a variable number of arguments and a different behaviour occurs depending on the type of the argument. functionname can be (almost) any of the lpsolve API routines (see lp_solve API reference) plus some extra O-Matrix specific functions. Most of the lpsolve API routines use or return an lprec structure. To make things more robust in O-Matrix, this structure is replaced by a handle or the model name. The lprec structures are maintained internally by the lpsolve driver. The handle is an incrementing number starting from 0. Starting from driver version 5.5.0.2, it is also possible to use the model name instead of the handle. This can of course only be done if a name is given to the model. This is done via lpsolve routine set_lp_name or by specifying the model name in routine read_lp. See Using model name instead of handle.
Almost all callable functions can be found in the lp_solve API reference. Some are exactly as described in the reference guide, others have a slightly different syntax to make maximum use of the O-Matrix functionality. For example make_lp is used identical as described. But get_variables is slightly different. In the API reference, this function has two arguments. The first the lp handle and the second the resulting variables and this array must already be dimensioned. When lpsolve is used from O-Matrix, nothing must be dimensioned in advance. The omlpsolve driver takes care of dimensioning all return variables and they are always returned as return value of the call to omlpsolve. Never as argument to the routine. This can be a single value as for get_objective (although O-Matrix stores this in a 1x1 matrix) or a matrix or vector as in get_variables. In this case, get_variables returns a 4x1 matrix (vector) with the result of the 4 variables of the lp model.
(Note that you can execute this example by entering command per command as shown below or by just entering example1. This will execute example1.oms.)
O> lp=omlpsolve("make_lp", 0, 4);
O> omlpsolve("set_verbose", lp, 3);
O> omlpsolve("set_obj_fn", lp, [1, 3, 6.24, 0.1]);
O> omlpsolve("add_constraint", lp, [0, 78.26, 0, 2.9], 2, 92.3);
O> omlpsolve("add_constraint", lp, [0.24, 0, 11.31, 0], 1, 14.8);
O> omlpsolve("add_constraint", lp, [12.68, 0, 0.08, 0.9], 2, 4);
O> omlpsolve("set_lowbo", lp, 1, 28.6);
O> omlpsolve("set_lowbo", lp, 4, 18);
O> omlpsolve("set_upbo", lp, 4, 48.98);
O> omlpsolve("set_col_name", lp, 1, "COLONE");
O> omlpsolve("set_col_name", lp, 2, "COLTWO");
O> omlpsolve("set_col_name", lp, 3, "COLTHREE");
O> omlpsolve("set_col_name", lp, 4, "COLFOUR");
O> omlpsolve("set_row_name", lp, 1, "THISROW");
O> omlpsolve("set_row_name", lp, 2, "THATROW");
O> omlpsolve("set_row_name", lp, 3, "LASTROW");
O> omlpsolve("write_lp", lp, "a.lp");
O> omlpsolve("get_mat", lp, 1, 2)
78.2600
O> omlpsolve("solve", lp)
0
O> omlpsolve("get_objective", lp)
31.7828
O> omlpsolve("get_variables", lp)
{
28.6
0
0
31.8276
}
O> omlpsolve("get_constraints", lp)
{
92.3
6.8640
391.293
}
Note that there are some commands that return an answer. To see the answer, the command was not terminated with a semicolon (;). If the semicolon is put at the end of a command, the answer is not shown. However it is also possible to write the answer in a variable. In that case the result is never shown. With or without a terminating semicolon. For example:
O> obj=omlpsolve("get_objective", lp)
Or:
O> obj=omlpsolve("get_objective", lp);
Both will only write the result in variable obj without showing anything on screen. get_variables and get_constraints return a vector with the result. This can also be put in a variable:
O> x=omlpsolve("get_variables", lp);
O> b=omlpsolve("get_constraints", lp);
It is always possible to show the contents of a variable by just giving it as command:
O> x
{
28.6
0
0
31.8276
}
Don't forget to free the handle and its associated memory when you are done:
O> omlpsolve("delete_lp", lp);
O> lp=omlpsolve("make_lp", 0, 4);
O> omlpsolve("set_lp_name", lp, "mymodel");
O> omlpsolve("set_verbose", "mymodel", 3);
O> omlpsolve("set_obj_fn", "mymodel", [1, 3, 6.24, 0.1]);
O> omlpsolve("add_constraint", "mymodel", [0, 78.26, 0, 2.9], 2, 92.3);
O> omlpsolve("add_constraint", "mymodel", [0.24, 0, 11.31, 0], 1, 14.8);
O> omlpsolve("add_constraint", "mymodel", [12.68, 0, 0.08, 0.9], 2, 4);
O> omlpsolve("set_lowbo", "mymodel", 1, 28.6);
O> omlpsolve("set_lowbo", "mymodel", 4, 18);
O> omlpsolve("set_upbo", "mymodel", 4, 48.98);
O> omlpsolve("set_col_name", "mymodel", 1, "COLONE");
O> omlpsolve("set_col_name", "mymodel", 2, "COLTWO");
O> omlpsolve("set_col_name", "mymodel", 3, "COLTHREE");
O> omlpsolve("set_col_name", "mymodel", 4, "COLFOUR");
O> omlpsolve("set_row_name", "mymodel", 1, "THISROW");
O> omlpsolve("set_row_name", "mymodel", 2, "THATROW");
O> omlpsolve("set_row_name", "mymodel", 3, "LASTROW");
O> omlpsolve("write_lp", "mymodel", "a.lp");
O> omlpsolve("get_mat", "mymodel", 1, 2)
78.2600
O> omlpsolve("solve", "mymodel")
0
O> omlpsolve("get_objective", "mymodel")
31.7828
O> omlpsolve("get_variables", "mymodel")
{
28.6
0
0
31.8276
}
O> omlpsolve("get_constraints", "mymodel")
{
92.3
6.8640
391.293
}
So everywhere a handle is needed, you can also use the model name. You can even mix the two methods.
There is also a specific O-Matrix routine to get the handle from the model name: get_handle.
For example:
O> omlpsolve("get_handle", "mymodel")
0
Don't forget to free the handle and its associated memory when you are done:
O> omlpsolve("delete_lp", "mymodel")
In the next part of this documentation, the handle is used. But if you name the model, the name could thus also be used.
O> omlpsolve("add_constraint", lp, [0.24, 0, 11.31, 0], 1, 14.8);
Most of the time, variables are used to provide the data:
O> omlpsolve("add_constraint", lp, a1, 1, 14.8);
Where a1 is a matrix variable.
Matrices with too few or too much elements gives an 'invalid vector.' error.
Most of the time, omlpsolve needs vectors (rows or columns). In all situations, it doesn't matter if the vectors are row or column vectors. The driver accepts them both. For example:
O> omlpsolve("add_constraint", lp, {0.24, 0, 11.31, 0}, 1, 14.8);
Which is a column vector, but it is also accepted.
An important final note. Several lp_solve API routines accept a vector where the first element (element 0) is not used. Other lp_solve API calls do use the first element. In the O-Matrix interface, there is never an unused element in the matrices. So if the lp_solve API specifies that the first element is not used, then this element is not in the O-Matrix matrix.
Because O-Matrix is all about matrices, all lpsolve API routines that need a column or row number to get/set information for that
column/row are extended in the omlpsolve O-Matrix driver to also work with matrices. For example set_int in the API can
only set the integer status for one column. If the status for several integer variables must be set, then set_int
must be called multiple times. The omlpsolve O-Matrix driver however also allows specifying a vector to set the integer
status of all variables at once. The API call is: return = omlpsolve("set_int", lp, column, must_be_int). The
matrix version of this call is: return = omlpsolve("set_int", lp, [must_be_int]).
The API call to return the integer status of a variable is: return = omlpsolve("is_int", lp, column). The
matrix version of this call is: [is_int] = omlpsolve("is_int", lp)
Also note the get_mat and set_mat routines. In O-Matrix these are extended to return/set the complete constraint matrix.
See following example.
Above example can thus also be done as follows:
(Note that you can execute this example by entering command per command as shown below or by just entering example2.
This will execute example2.oms.)
O> lp=omlpsolve("make_lp", 0, 4);
O> omlpsolve("set_verbose", lp, 3);
O> omlpsolve("set_obj_fn", lp, [1, 3, 6.24, 0.1]);
O> omlpsolve("add_constraint", lp, [0, 78.26, 0, 2.9], 2, 92.3);
O> omlpsolve("add_constraint", lp, [0.24, 0, 11.31, 0], 1, 14.8);
O> omlpsolve("add_constraint", lp, [12.68, 0, 0.08, 0.9], 2, 4);
O> omlpsolve("set_lowbo", lp, [28.6, 0, 0, 18]);
O> omlpsolve("set_upbo", lp, [INF, INF, INF, 48.98]);
O> omlpsolve("set_col_name", lp, {"COLONE", "COLTWO", "COLTHREE", "COLFOUR"});
O> omlpsolve("set_row_name", lp, {"THISROW", "THATROW", "LASTROW"});
O> omlpsolve("write_lp", lp, "a.lp");
O> omlpsolve("get_mat", lp)
{
[ 0 , 78.26 , 0 , 2.9 ]
[ 0.24 , 0 , 11.31 , 0 ]
[ 12.68 , 0 , 0.08 , 0.9 ]
}
O> omlpsolve("solve", lp)
0
O> omlpsolve("get_objective", lp)
31.7828
O> omlpsolve("get_variables", lp)
{
28.6
0
0
31.8276
}
O> omlpsolve("get_constraints", lp)
{
92.3
6.8640
391.293
}
Note the usage of INF in set_upbo. This stands for "infinity". Meaning an infinite upper bound. It is also possible to use -INF to express minus infinity. This can for example be used to create a free variable.
To show the full power of the matrices, let's now do some matrix calculations to check the solution. It works further on above example:
O> A=omlpsolve("get_mat", lp);
O> X=omlpsolve("get_variables", lp);
O> B = A * X
O> B
{
92.3
6.864
391.293
}
So what we have done here is calculate the values of the constraints (RHS) by multiplying the constraint matrix with the solution vector. Now take a look at the values of the constraints that lpsolve has found:
O> omlpsolve("get_constraints", lp)
{
92.3
6.864
391.293
}
Exactly the same as the calculated B vector, as expected.
Also the value of the objective can be calculated in a same way:
O> C=omlpsolve("get_obj_fn", lp);
O> X=omlpsolve("get_variables", lp);
O> obj = C * X
O> obj
31.7828
So what we have done here is calculate the value of the objective by multiplying the objective vector with the solution vector. Now take a look at the value of the objective that lpsolve has found:
O> omlpsolve("get_objective", lp)
31.7828
Again exactly the same as the calculated obj value, as expected.
O-Matrix can execute a sequence of statements stored in files. Such files are called oms files because they must have the file type of ".oms" as the last part of their filename (extension).
oms scripts can be compared with batch files or scripts. You can put O-Matrix commands in them and execute them at any time. The oms script is executed like any other command, by entering its name (without the .oms extension).
The omlpsolve O-Matrix distribution contains some example oms scripts to demonstrate this.
You can also edit these files with your favourite text editor (or notepad).
Contains the commands as shown in the first example of this article. To execute and also see which commands are executed in the debug window, use following commands:
O> stop O> trace on example1.oms O> quit O> example1
Note however that execution is much slower when trace is on. It is only used here to see the statements executed.
Contains the commands as shown in the second example of this article. To execute and also see which commands are executed in the debug window, use following commands:
O> stop O> trace on example2.oms O> quit O> example2
Note however that execution is much slower when trace is on. It is only used here to see the statements executed.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
This script uses the API to create a higher-level function called lp_solve. This function accepts as arguments some matrices and options to create and solve an lp model. See the beginning of the file to see its usage:
LP_SOLVE Solves mixed integer linear programming problems.
SYNOPSIS: [obj,x,duals] = lp_solve(f,a,b,e,vlb,vub,xint,scalemode,keep)
solves the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) = -1 ==> Less Than
e(i) = 0 ==> Equals
e(i) = 1 ==> Greater Than
vlb: n vector of lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
keep: Flag for keeping the lp problem after it's been solved.
If omitted, the lp will be deleted when solved.
OUTPUT: A nonempty output is returned if a solution is found:
obj: Optimal value of the objective function.
x: Optimal value of the decision variables.
duals: solution of the dual problem.
Example of usage. To create and solve following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
O> include lp_solve.oms
O> [obj, x]=lp_solve([-1, 2], {[2, 1], [-4, 4]}, [5, 5], [-1, -1], [], [], [1, 2])
O> obj
3
O> x
{
1
2
}
This script is analog to the lp_solve script and also uses the API to create a higher-level function called lp_maker. This function accepts as arguments some matrices and options to create an lp model. Note that this scripts only creates a model and returns a handle. See the beginning of the file to see its usage:
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Example of usage. To create following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
O> include lp_maker.oms
O> lp=lp_maker([-1, 2], {[2, 1], [-4, 4]}, [5, 5], [-1, -1], [], [], [1, 2])
O> lp
0
To solve the model and get the solution:
O> omlpsolve("solve", lp)
0
O> omlpsolve("get_objective", lp)
3
O> omlpsolve("get_variables", lp)
{
1
2
}
Don't forget to free the handle and its associated memory when you are done:
O> omlpsolve("delete_lp", lp);
Contains several examples to build and solve lp models. To execute and also see which commands are executed in the debug window, use following commands:
O> stop O> trace on lpdemo.oms O> quit O> lpdemo
Note however that execution is much slower when trace is on. It is only used here to see the statements executed.
Contains several examples to build and solve lp models. Also solves the lp_examples from the lp_solve distribution. To execute and also see which commands are executed in the debug window, use following commands:
O> stop O> trace on ex.oms O> quit O> ex
Note however that execution is much slower when trace is on. It is only used here to see the statements executed.
We shall illustrate the method of linear programming by means of a simple example, giving a combination graphical/numerical solution, and then solve both a slightly as well as a substantially more complicated problem.
Suppose a farmer has 75 acres on which to plant two crops: wheat and barley. To produce these crops, it costs the farmer (for seed, fertilizer, etc.) $120 per acre for the wheat and $210 per acre for the barley. The farmer has $15000 available for expenses. But after the harvest, the farmer must store the crops while awaiting favourable market conditions. The farmer has storage space for 4000 bushels. Each acre yields an average of 110 bushels of wheat or 30 bushels of barley. If the net profit per bushel of wheat (after all expenses have been subtracted) is $1.30 and for barley is $2.00, how should the farmer plant the 75 acres to maximize profit?
We begin by formulating the problem mathematically. First we express the objective, that is the profit, and the constraints algebraically, then we graph them, and lastly we arrive at the solution by graphical inspection and a minor arithmetic calculation.
Let x denote the number of acres allotted to wheat and y the number of acres allotted to barley. Then the expression to be maximized, that is the profit, is clearly
P = (110)(1.30)x + (30)(2.00)y = 143x + 60y.
There are three constraint inequalities, specified by the limits on expenses, storage and acreage. They are respectively:
120x + 210y <= 15000
110x + 30y <= 4000
x + y <= 75
Strictly speaking there are two more constraint inequalities forced by the fact that the farmer cannot plant a negative number of acres, namely:
x >= 0, y >= 0.
Next we graph the regions specified by the constraints. The last two say that we only need to consider the first quadrant in the x-y plane. Here's a graph delineating the triangular region in the first quadrant determined by the first inequality.
O> clear O> X = 0.1:0.05:125; O> Y1 = (15000. - 120*X)/210; O> bar(X, Y1)
Now let's put in the other two constraint inequalities.
O> clear
O> X = 0.1:0.05:38;
O> mlmode
O> Y1 = (15000. - 120*X)/210;
O> Y2 = max((4000 - 110.*X)./30, 0);
O> Y3 = max(75 - X, 0.);
O> Ytop = min(min(Y1, Y2), Y3);
O> omatrix
O> bar(X, Ytop)
O> gtitle("Solution space")
The black area is the solution space that holds valid solutions. This means that any point in this area fulfils the constraints.
Now let's superimpose on top of this picture a contour plot of the objective function P.
O> mlmode meshgrid.m
O> [U, V] = meshgrid(0:1:40, 0:1:80);
O> Ur = U.row(1)
O> Vc = V.col(1)
O> Z = 143.*U + 60.*V
O> levels = (0:1:11)*1000.
O> contour(Z', levels, Ur', Vc');
O> gtitle("Solution space and objective")
The lines give a picture of the objective function. All solutions that intersect with the black area are valid solutions, meaning that this result also fulfils the set constraints. The more the lines go to the right, the higher the objective value is. The optimal solution or best objective is a line that is still in the black area, but with an as large as possible value.
It seems apparent that the maximum value of P will occur on the level curve (that is, level
line) that passes through the vertex of the polygon that lies near (22,53).
It is the intersection of x + y = 75 and 110*x + 30*y = 4000
This is a corner point of the diagram. This is not a coincidence. The simplex algorithm, which is used
by lp_solve, starts from a theorem that the optimal solution is such a corner point.
In fact we can compute the result:
O> x = {[1, 1], [110, 30]} \ {75, 4000}
O> print "x =", x
x = {
21.875
53.125
}
The acreage that results in the maximum profit is 21.875 for wheat and 53.125 for barley. In that case the profit is:
O> P = [143, 60] * x O> print "Profit, P =", P Profit, P = 6315.63
That is, $6315.63.
Note that these command are in script example3.oms
Now, lp_solve comes into the picture to solve this linear programming problem more generally. After that we will use it to solve two more complicated problems involving more variables and constraints.
For this example, we use the higher-level script lp_maker to build the model and then some lp_solve API calls to retrieve the solution. Here is again the usage of lp_maker:
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Now let's formulate this model with lp_solve:
O> f = [143, 60];
O> A = {[120, 210], [110, 30], [1, 1]};
O> b = {15000, 4000, 75};
O> lp = lp_maker(f, A, b, [-1, -1, -1], [], [], [], 1, 0);
O> solvestat = omlpsolve("solve", lp)
O> omlpsolve("get_objective", lp)
6315.63
O> omlpsolve("get_variables", lp)
{
21.875
53.125
}
O> omlpsolve("delete_lp", lp);
Note that these command are in script example4.oms
With the higher-level script lp_maker, we provide all data to lp_solve. lp_solve returns a handle (lp) to the created model. Then the API call 'solve' is used to calculate the optimal solution of the model. The value of the objective function is retrieved via the API call 'get_objective' and the values of the variables are retrieved via the API call 'get_variables'. At last, the model is removed from memory via a call to 'delete_lp'. Don't forget this to free all memory allocated by lp_solve.
The solution is the same answer we obtained before. Note that the non-negativity constraints are accounted implicitly because variables are by default non-negative in lp_solve.
Well, we could have done this problem by hand (as shown in the introduction) because it is very small and it
can be graphically presented.
Now suppose that the farmer is dealing with a third crop, say corn, and that the corresponding data is:
cost per acre $150.75 yield per acre 125 bushels profit per bushel $1.56
With three variables it is already a lot more difficult to show this model graphically. Adding more variables makes it even impossible because we can't imagine anymore how to represent this. We only have a practical understanding of 3 dimentions, but beyound that it is all very theorethical.
If we denote the number of acres allotted to corn by z, then the objective function becomes:
P = (110)(1.30)x + (30)(2.00)y + (125)(1.56) = 143x + 60y + 195z
And the constraint inequalities are:
120x + 210y + 150.75z <= 15000
110x + 30y + 125z <= 4000
x + y + z <= 75
x >= 0, y >= 0, z >= 0
The problem is solved with lp_solve as follows:
O> f = [143, 60, 195];
O> A = {[120, 210, 150.75], [110, 30, 125], [1, 1, 1]};
O> b = {15000, 4000, 75};
O> lp = lp_maker(f, A, b, [-1, -1, -1], [], [], [], 1, 0);
O> solvestat = omlpsolve("solve", lp)
O> omlpsolve("get_objective", lp)
6986.84
O> omlpsolve("get_variables", lp)
{
0
56.5789
18.4211
}
O> omlpsolve("delete_lp", lp);
Note that these command are in script example5.oms
So the farmer should ditch the wheat and plant 56.5789 acres of barley and 18.4211 acres of corn.
There is no practical limit on the number of variables and constraints that O-Matrix can handle. Certainly none that the relatively unsophisticated user will encounter. Indeed, in many true applications of the technique of linear programming, one needs to deal with many variables and constraints. The solution of such a problem by hand is not feasible, and software like O-Matrix is crucial to success. For example, in the farming problem with which we have been working, one could have more crops than two or three. Think agribusiness instead of family farmer. And one could have constraints that arise from other things beside expenses, storage and acreage limitations. For example:
Below is a sequence of commands that solves exactly such a problem. You should be able to recognize the objective expression and the constraints from the data that is entered. But as an aid, you might answer the following questions:
O> f = [110*1.3, 30*2.0, 125*1.56, 75*1.8, 95*.95, 100*2.25, 50*1.35];
O> A = {[120,210,150.75,115,186,140,85],[110,30,125,75,95,100,50],[1,1,1,1,1,1,1],
[1,-1,0,0,0,0,0],[0,0,1,0,-2,0,0],[0,0,0,-1,0,-1,1]};
O> b = {55000, 40000, 400, 0, 0, 0};
O> lp = lp_maker(f, A, b, [-1,-1,-1,-1,-1,-1],[10,10,10,10,20,20,20],[100,INF,50,INF,INF,250,INF],[],1,0);
O> solvestat = omlpsolve("solve", lp)
O> omlpsolve("get_objective", lp)
75398
O> omlpsolve("get_variables", lp)
{
10
10
40
45.6522
20
250
20
}
O> omlpsolve("delete_lp", lp);
Note that these command are in script example6.oms
Note that we have used in this formulation the vlb and vub arguments of lp_maker. This to set lower and upper bounds on variables. This could have been done via extra constraints, but it is more performant to set bounds on variables. Also note that Inf is used for variables that have no upper limit. This stands for Infinity.
Note that despite the complexity of the problem, lp_solve solves it almost instantaneously. It seems the farmer should bet the farm on crop number 6. We strongly suggest you alter the expense and/or the storage limit in the problem and see what effect that has on the answer.
Suppose we want to solve the following linear program using O-Matrix:
max 4x1 + 2x2 + x3
s. t. 2x1 + x2 <= 1
x1 + 2x3 <= 2
x1 + x2 + x3 = 1
x1 >= 0
x1 <= 1
x2 >= 0
x2 <= 1
x3 >= 0
x3 <= 2
Convert the LP into O-Matrix format we get:
f = [4, 2, 1]
A = {[2, 1, 0], [1, 0, 2], [1, 1, 1]}
b = {1, 2, 1}
Note that constraints on single variables are not put in the constraint matrix. lp_solve can set bounds on individual variables and this is more performant than creating additional constraints. These bounds are:
l = [ 0, 0, 0]
u = [ 1, 1, 2]
Now lets enter this in O-Matrix:
O> f = [4, 2, 1];
O> A = {[2, 1, 0], [1, 0, 2], [1, 1, 1]};
O> b = {1, 2, 1};
O> l = [ 0, 0, 0];
O> u = [ 1, 1, 2];
Now solve the linear program using O-Matrix: Type the commands
O> lp = lp_maker(f, A, b, [-1, -1, -1], l, u, [], 1, 0);
O> solvestat = omlpsolve("solve", lp)
O> omlpsolve("get_objective", lp)
2.5
O> omlpsolve("get_variables", lp)
{
0.5
0
0.5
}
O> omlpsolve("delete_lp", lp)
What to do when some of the variables are missing ?
For example, suppose there are no lower bounds on the variables. In this case define l to be the empty set using the O-Matrix command:
O> l = [];
This has the same effect as before, because lp_solve has as default lower bound for variables 0.
But what if you want that variables may also become negative?
Then you can use -INF as lower bounds:
O> l = [-INF, -INF, -INF];
Solve this and you get a different result:
O> lp = lp_maker(f, A, b, [-1, -1, -1], l, u, [], 1, 0);
O> solvestat = omlpsolve("solve", lp)
O> omlpsolve("get_objective", lp)
2.66667
O> omlpsolve("get_variables", lp)
{
0.666667
-0.333333
0.666667
}
O> omlpsolve("delete_lp", lp)
Note that everwhere where lp is used as argument that this can be a handle (lp_handle) or the models name.
These routines are not part of the lpsolve API, but are added for backwards compatibility. Most of them exist in the lpsolve API with another name.
Under Windows, the omlpsolve O-Matrix driver is a dll: omlpsolve.dll
This dll is an interface to the lpsolve55.dll lpsolve dll that contains the implementation of lp_solve.
lpsolve55.dll is distributed with the lp_solve package (archive lp_solve_5.5.0.13_dev.zip). The omlpsolve O-Matrix driver dll (omlpsolve.dll) is just
a wrapper between O-Matrix and lp_solve to translate the input/output to/from O-Matrix and the lp_solve library.
The omlpsolve O-Matrix driver is written in C. To compile this code, Microsoft compiler is needed.
Other compilers might also work, but this is untested.
To make the compilation process easier, a batch file can be used: cvc.bat
It may be necessary to edit this file first to change the path where lp_solve and the O-Matrix dll sources are installed.
Change at the beginning lpsolvepath and dllsrcpath. dllsrcpath must point to the folder where dll.h is located.
To make for release, just enter cvc and everything is build.
This compiles three source files: lpsolve.c, omatrix.c and hash.c
Then these are linked with the library lpsolve55.lib to generate the omlpsolve.dll file.
The optional arguments to cvc are used for development. Source files can be provided and then only these are compiled.
For example hash.c should only be compiled once while developing. So specifying
lpsolve.c as first argument will only compile this file and then link everything. This makes the build process a bit faster.
Also the option -DDEMO can be added to add the demo command to test some functionality of lpsolve. This is also only for debugging.
Also the option -DDEBUG can be added. This to print some debug information while executing omlpsolve.
Should only be used for debugging purposes.
Note that the omlpsolve.dll file can be locked by O-Matrix. Then the build process will fail because the dll can not be overwritten. This can be solved by giving the clear command in O-Matrix. This will free the dll.
At this moment, there is no O-Matrix version for this platform.
See also Using lpsolve from MATLAB, Using lpsolve from Scilab, Using lpsolve from Octave, Using lpsolve from Python, Using lpsolve from R
docs/5.5/column_in_lp.htm 0000644 0001750 0001750 00000005541 11306036626 014161 0 ustar rene rene
column_in_lpCheck if a column is already present in the lp. int column_in_lp(lprec *lp, REAL *column); Return Value column_in_lp returns the (first) column number if the column is already in the lp and
0 if not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column An array with 1+get_Nrows elements that are checked against the existing columns in the lp. Remarks The column_in_lp functions checks if a column is already present in the
lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_column, add_columnex, str_add_column, set_column, set_columnex, del_column |
semi-continuous variablesSemi-continuous variables are variables that must take a value between their minimum and maximum or zero. So these variables are treated the same as regular variables, except that a value of zero is also accepted, even if there is a minimum bigger than zero is set on the variable. 
The practical usage of such variables is the following. If the variable is taken then take at least the minimum or else don't take it at all. For example in a blending problem this could mean if an amount of a raw material is taken then it must be at least the minimum or else take none at all. This because less than the minimum cannot be weighted for example. If a fixed minimum would be set then it would not be allowed to not to use the raw material at all. However via semi-continuous variables it is possible to state this kind of restrictions. Since release 4, lp_solve has supported semi-continuous variables
via the API call set_semicont or in the mps
format in the bounds section via the SC bound type. See mps-format.
If there is no minimum set on a semi-continuous variable then the default
minimum is 1. The SC bound type normally needs the maximum in field 4. However
this value may be omitted. In that case an upper bound of infinity is taken.
NAME
ROWS
N r_0
L r_1
G r_2
G r_3
G r_4
COLUMNS
x1 r_0 -1 r_1 1
x1 r_2 2 r_3 -1
x2 r_0 -2 r_1 1
x2 r_2 -1 r_3 3
x3 r_0 4 r_4 1
x4 r_0 3 r_4 1
RHS
RHS r_1 5 r_4 0.5
BOUNDS
SC BND x3 10
LO BND x3 1.1
ENDATA
The red lines are two lines that specify that variable x3 is a semi-continuous variable with a maximum of 10 and a minimum of 1.1. If the LO entry would not be there then the minimum would be 1, the default. If the 10 is omitted in the SC entry then there is no maximum. Since lp_solve version 4.0.1.10, lp_solve also supports semi-continuous variables in the lp-format See lp-format. The above mps example would be in lp-format: max: x1 + 2x2 - 4x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; sec x3; If the line x3 >= 1.1; is omitted then there is an implicit minimum of 1. If the line x3 <= 10; is omitted then there is no maximum on the variable. The new section sec is analogue as the int section and specifies all the variables that are semi-continuous. Multiple variables can be specified separated by a comma (,) or space. The solution for this model is: Value of objective function: 6.83333 Actual values of the variables: x1 1.66667 x2 3.33333 x3 0 x4 0.5 Why does it take 0 and not 1.1? Because the objective value is better if 0 is taken than 1.1. If the variable would not be semi-continuous (delete sec x3;) then the solution would be: Value of objective function: 3.93333 Actual values of the variables: x1 1.66667 x2 3.33333 x3 1.1 x4 0 6.83333 is a better solution than 3.93333 If the model is changed to: max: x1 + 2x2 - 0.1x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; sec x3; Only the cost of x3 is changed here from -4 to -0.1. The solution of this model is: Value of objective function: 8.22333 Actual values of the variables: x1 1.66667 x2 3.33333 x3 1.1 x4 0 Now the solver takes the 1.1 as value because this solution is better than if 0 would be taken. This can be proven with the following model: max: x1 + 2x2 - 1x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 <= 0; sec x3; This gives as solution: Value of objective function: 6.83333 Actual values of the variables: x1 1.66667 x2 3.33333 x3 0 x4 0.5 6.83333 is worse than 8.22333, thus the solver takes the 1.1 solution. Note that semi-continuous variables may be combined with integer variables. The same rules then apply, but the variable must also be integer then. For example: max: x1 + 2x2 - .1x3 -3x4; x1 + x2 <= 5; 2x1 - x2 >= 0; -x1 + 3x2 >= 0; x3 + x4 >= .5; x3 >= 1.1; x3 <= 10; sec x3; int x3; The solution of this model is: Value of objective function: 8.13333 Actual values of the variables: x1 1.66667 x2 3.33333 x3 2 x4 0 Because x3 must now be integer, it takes the value 2 instead of 1.1. The objective value 8.13333 is still better than he objective value if x3 would be 0 (6.83333). In the mps format this can be either specified via the SI attribute or via SC attribute with the MARKER INTORG, MARKER INTEND in the COLUMNS section:
ROWS
N r_0
L r_1
G r_2
G r_3
G r_4
COLUMNS
x1 r_0 -1 r_1 1
x1 r_2 2 r_3 -1
x2 r_0 -2 r_1 1
x2 r_2 -1 r_3 3
x3 r_0 0.1 r_4 1
x4 r_0 3 r_4 1
RHS
RHS r_1 5 r_4 0.5
BOUNDS
SI BND x3 10
LO BND x3 1.1
ENDATA
Or
ROWS
N r_0
L r_1
G r_2
G r_3
G r_4
COLUMNS
x1 r_0 -1 r_1 1
x1 r_2 2 r_3 -1
x2 r_0 -2 r_1 1
x2 r_2 -1 r_3 3
MARK0000 'MARKER' 'INTORG'
x3 r_0 0.1 r_4 1
MARK0001 'MARKER' 'INTEND'
x4 r_0 3 r_4 1
RHS
RHS r_1 5 r_4 0.5
BOUNDS
SC BND x3 10
LO BND x3 1.1
ENDATA
|
set_lowboSet the lower bound of a variable. unsigned char set_lowbo(lprec *lp, int column, REAL value); Return Value set_lowbo returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable on which the bound must be set. It must be between 1 and the number of columns in the lp. Remarks The set_lowbo function sets a lower bound on the variable identified by column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_lowbo, set_upbo, get_upbo, set_bounds, set_unbounded, is_unbounded, is_negative |
set_var_branchSpecifies, for the specified variable, which branch to take first in branch-and-bound algorithm. unsigned char set_var_branch(lprec *lp, int column, int branch_mode); Return Value set_var_branch returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable on which the mode must be set. It must be between 1 and the number of columns in the lp. branch_mode Specifies, for the specified variable, which branch to take first
in branch-and-bound algorithm.
Remarks The set_var_branch function specifies which branch to take first in
branch-and-bound algorithm. This can influence solving times considerably.
Depending on the model one rule can be best and for another model another rule. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_var_branch, set_bb_floorfirst, get_bb_floorfirst, set_var_weights, get_var_priority |
lp_solve_versionReturns the full version number of lp_solve. void lp_solve_version(int *majorversion, int *minorversion, int *release, int *build); Return Value lp_solve_version has no return value. Parameters majorversion major version number. minorversion minor version number. release release number. build build number. Remarks The lp_solve_version function returns the full version number of lp_solve. Example See Also |
set_bounds_tighterSpecifies if set bounds may only be tighter or also less restrictive. void set_bounds_tighter(lprec *lp, unsigned char tighten); Return Value set_bounds_tighter has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI tighten Specifies if set bounds may only be tighter (TRUE) or also less restrictive (FALSE). Remarks The set_bounds_tighter function sets if bounds may only be tighter or also less restrictive. If set to TRUE then bounds may only be tighter. This means that when set_lowbo or set_lowbo is used to set a bound and the bound is less restrictive than an already set bound, then this new bound will be ignored. If tighten is set to FALSE, the new bound is accepted. This functionality is useful when several bounds are set on a variable and at the end you want the most restrictive ones. By default, this setting is FALSE. Note that this setting does not affect set_bounds. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_bounds_tighter, set_upbo, get_upbo, set_lowbo, get_lowbo, set_bounds, set_unbounded, is_unbounded, is_negative |
get_LrowsReturns the number of Lagrangian rows in the lp. The Lagrangian solver does not work. Do not use this call. int get_Lrows(lprec *lp); Return Value get_Lrows returns the number of Lagrangian rows in the lp. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The Lagrangian solver does not work. Do not use this call. The get_Lrows function returns the number of Lagrangian rows in the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_Nrows, get_Norig_rows, get_Ncolumns, get_Norig_columns, get_orig_index, get_lp_index, add_lag_con, lag_solve |
get_bb_ruleReturns the branch-and-bound rule. int get_bb_rule(lprec *lp); Return Value get_bb_rule returns the branch-and-bound rule. Can by any of the following values:
One of these values may be or-ed with one or more of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI RemarksThe get_bb_rule function returns the branch-and-bound rule for choosing
which non-integer variable is to be selected. This rule can influence solving
times considerably. Depending on the model one rule can be best and for another
model another rule. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_bb_rule, put_bb_nodefunc |
guess_basisCreate a starting base from the provided guess vector. unsigned char guess_basis(lprec *lp, REAL *guessvector, int *basisvector); Return Value guess_basis returns TRUE if a valid base could be termined and FALSE if not. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI guessvector A vector that must contain a feasible solution vector. It must contain at least 1+get_Ncolumns elements. Element 0 is not used. basisvector When successful, this vector contains a feasible basis corresponding to guessvector. The array must already be dimentioned for at least 1+get_Nrows+get_Ncolumns elements. When the routine returns successful, basisvector is filled with the basis. This array can be provided to set_basis. Remarks This routine is ment to find a basis based on provided variable values. This basis can be provided to lp_solve via set_basis. This can result in getting faster to an optimal solution. However the simplex algorithm doesn't guarantee you that. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_basis, set_basis, default_basis, get_basiscrash set_basiscrash |
reset_paramsResets parameters back to their default values. void reset_params(lprec *lp); Return Value No return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks This routine resets parameters back to their default values. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, read_params, write_params |
is_infiniteChecks if the provided absolute of the value is larger or equal to "infinite". unsigned char is_infinite(lprec *lp, REAL value); Return Value is_infinite returns TRUE if the value is equal or larger to "infinite". Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI value The value to check against "infinite". Remarks Note that the absolute of the provided value is checked against the value set by set_infinite. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_infinite, get_infinite, set_epsint, get_epsint, set_epsb, get_epsb, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb |
is_piv_modeReturns if pivot mode specified in testmask is active. unsigned char is_piv_mode(lprec *lp, int testmask); Return Value is_piv_mode returns TRUE or FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI testmask
Remarks The is_piv_mode function checks if the pivot mode specified in testmask is active. The pivot mode is an extra modifier to the pivot rule. Any combination (OR) of the defined values is possible. Example
See Also make_lp, copy_lp,
read_lp, read_LP, read_mps,
read_freemps, read_MPS, read_freeMPS, read_XLI, set_pivoting,
get_pivoting, is_piv_rule |
External Language InterfacesTo facilitate the development of other model language interfaces, a
quite simple "eXternal Language Interface" (XLI) has been defined, which allows lp_solve
to be dynamically configured (at run-time) to use alternative means to read and
write the MIP model or write a solution file in a specific format.
lp_solve has several build-in interfaces to models: mps, lp.
XLI allows implementing a custom reader and writer for other model layouts and a solution layout. Under Windows, an XLI is provided as DLL (xli_*.dll), under UNIX/LINUX as a dynamic linked library (libxli_*.so). These libraries are loaded/linked at runtime with lp_solve. Under Unix/Linux it is standard that a library has the lib prefix and a .so postfix. To make the calling structure for XLIs uniform across different types of OS, lp_solve automatically adds the prefix and postfix if not provided. So for example under all platforms, the MathProg XLI may be referenced as xli_MathProg. It is advised to call the XLIs as such. To locate the XLI on the file system, the following search order is used if no path is provided: Windows
Unix/Linux
Note again that this search path is only used if no path is specified for the XLI. Using an XLI with the lp_solve stand-alone programThe lp_solve program provides a way to specify an XLI for reading a model, an XLI for writing the model and an XLI for writing the solution file. These can be different so that a model in one format can be converted to another format. It is still possible to both read and write the models with the build-in formats (mps, lp) and you can combine with the XLI. Read a model
With the lp_solve program, to set the XLI to read the model, use the option filename is the name (with optional path) of the model name to read. If no path is specified, the file is read from the current directory.
Depending on the XLI, an optional data file name can be provided. Use the option For example for the MathProg XLI, there is a possible optional datafilename containing the data. Note that this name may not start with a minus sign (-)
Depending on the XLI, options can be provided to change the behaviour of the routine.
Use the option So the following commands are valid for both Windows and Unix/Linux:
lp_solve -rxli xli_MathProg input.mod -rxlidata input.dat The latter makes sure that the XLI is searched in the current directory, especially for Unix/Linux. Write a model
With the lp_solve program, to set the XLI to write the model, use the option filename is the name (with optional path) of the model name to write. If no path is specified, the file is written in the current directory.
Depending on the XLI, options can be provided to change the behaviour of the routine.
Use the option So the following commands are valid for both Windows and Unix/Linux:
lp_solve input.lp -wxli xli_MathProg output.mod The latter makes sure that the XLI is searched in the current directory, especially for Unix/Linux. Write a solution
With the lp_solve program, to set the XLI to write the solution, use the option filename is the name (with optional path) of the solution name to write. If no path is specified, the file is written in the current directory.
Depending on the XLI, options can be provided to change the behaviour of the routine.
Use the option So the following commands are valid for both Windows and Unix/Linux:
lp_solve -rxli xli_DIMACS maxflow.net -wxlisol xli_DIMACS maxflow.sol The latter makes sure that the XLI is searched in the current directory, especially for Unix/Linux. Using an XLI from the lpsolve APIRead a model
The read_XLI reads a model via an XLI. Write a modelTo write a model, two API calls are needed:
First use set_XLI to set the XLI library
Then use write_XLI to write the model. Write a solutionTo write a model, two API calls are needed:
First use set_XLI to set the XLI library
Then use write_XLI to write the model. Creating an XLIThis section is only for people who will create their own XLI because you have a model file type that is not supported by lp_solve. The developers would appreciate it if you would make this XLI public. To create your own XLI, you have to create a DLL/shared library that implements the following routines:
lp_XLI1.c must be included at the beginning of the source file. This to include an extra routine xli_compatible needed by the lpsolve library to check the compatibility. If you want to create XLIs yourself, make sure that under Windows,
you use 8 byte alignments. This is needed for the XLIs to work correctly with the general
distribution of lp_solve and also to make sharing XLIs as uncomplicated as possible. If not, it will likely crash.
It doesn't matter which calling convention is used to compile the library. The XLI_CALLMODEL directive
makes sure that the calling convention of the needed routines is always ok independent of the
calling convention specified in the project. EXPORTS xli_compatible @1 xli_name @2 xli_readmodel @3 xli_writemodel @4
The definition file must be added to the project. How to do this depends on the version. XLI prototype
/* Generic include libraries */
#include <malloc.h>
#include <string.h>
#include "lp_lib.h"
#ifdef FORTIFY
# include "lp_fortify.h"
#endif
/* Include routines common to language interface implementations */
#include "lp_XLI1.c"
char * XLI_CALLMODEL xli_name(void)
{
return("XLI_xxx v1.0" ); /* return the name and version */
}
MYBOOL XLI_CALLMODEL xli_readmodel(lprec *lp, char *model, char *data, char *options, int verbose)
{
MYBOOL status = FALSE;
/* implement the code here to read the model */
return(status); /* status says if the model could be read or not. TRUE is ok, FALSE is not ok */
}
MYBOOL XLI_CALLMODEL xli_writemodel(lprec *lp, char *filename, char *options, MYBOOL results)
{
MYBOOL status = FALSE;
/* implement the code here to write the model */
return( status ); /* status says if the model could be written or not. TRUE is ok, FALSE is not ok */
}
Working example:demo.c:
/* Modularized external language interface module - w/interface for lp_solve v5.0+
----------------------------------------------------------------------------------
Author: Peter Notebaert
Contact: lpsolve@peno.be
License terms: LGPL.
Template used:
Requires:
Release notes:
v1.0.0 28 June 2004 First implementation.
---------------------------------------------------------------------------------- */
/* Generic include libraries */
#include <malloc.h>
#include <string.h>
#include "lp_lib.h"
/* Include libraries for this language system */
#include <math.h>
#ifdef FORTIFY
# include "lp_fortify.h"
#endif
/* Include routines common to language interface implementations */
#include "lp_XLI1.c"
char * XLI_CALLMODEL xli_name(void)
{
return( "xli_demo v1.0" );
}
MYBOOL XLI_CALLMODEL xli_readmodel(lprec *lp, char *model, char *data, char *options, int verbose)
{
MYBOOL status = FALSE;
REAL row[1+2]; /* must be 1 more then number of columns ! */
lp->add_columnex(lp, 0, NULL, NULL); /* add empty column */
lp->add_columnex(lp, 0, NULL, NULL); /* add empty column */
lp->set_add_rowmode(lp, TRUE);
row[1] = 1.0;
row[2] = 2.0;
lp->add_constraint(lp, row, GE, 3.0); /* constructs the row: +v_1 +2 v_2 >= 3 */
lp->set_add_rowmode(lp, FALSE);
status = TRUE;
return(status);
}
MYBOOL XLI_CALLMODEL xli_writemodel(lprec *lp, char *filename, char *options, MYBOOL results)
{
if (!results)
return(lp->write_lp(lp, filename));
else {
lp->print_objective(lp);
lp->print_solution(lp, 1);
lp->print_constraints(lp, 1);
return(TRUE);
}
}
demo.def:
EXPORTS xli_compatible @1 xli_name @2 xli_readmodel @3 xli_writemodel @4 This example is not very practical. It is only useful for demonstration purposes.
Let's assume that the name of this library is xli_demo. This XLI can be called from lp_solve via the following syntax: lp_solve -S0 -rxli xli_demo "" -wxli xli_demo output.txt -wxlisol xli_demo "" An empty ("") filename is provided because it isn't used by this demo. This command will create a file output.txt with contents: /* Objective function */ min: ; /* Constraints */ +C1 +2 C2 >= 3; Because we didn't provide the option -parse_only, the model is also solved. However the lp_solve option -S0 disables showing the results. Results are generated via the -wxlisol option: Value of objective function: 0 Actual values of the variables: C1 3 C2 0 Actual values of the constraints: R1 3 |
get_pivotingReturns the pivot rule and mode. int get_pivoting(lprec *lp); Return Value get_pivoting returns the pivot rule and mode. Can be one of the following rules:
Some of these values can be combined with any (ORed) of the following modes:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI RemarksThe get_pivoting function returns the pivot rule (rule for selecting row
and column entering/leaving) and mode. The rule is an exclusive option and the mode
is a modifier to the rule. This rule/mode can influence solving times
considerably. Depending on the model one rule/mode can be best and for another model
another rule/mode. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_piv_rule, set_pivoting, is_piv_mode |
get_upboGets the upper bound of a variable. REAL get_upbo(lprec *lp, int column); Return Value get_upbo returns the upper bound on the specified variable. If no bound
was set, it returns a very big number, the value of get_infinite, the default upper bound. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable. It must be between 1 and the number of columns in the lp. Remarks The get_upbo function returns the upper bound on the variable identified by column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_upbo, set_lowbo, get_lowbo, set_bounds, set_unbounded, is_unbounded, is_negative |
set_rhSet the value of the right hand side (RHS) vector (column 0) for one row. unsigned char set_rh(lprec *lp, int row, REAL value); Return Value
set_rh returns TRUE (1) if the operation was successful. A return value
of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the RHS value must be set. Must be between 0 and number of rows in the lp. value The value of the RHS. Remarks
The set_rh function sets the value of the RHS vector (column 0) for the
specified row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_rh_vec, str_set_rh_vec, get_rh, add_constraint, add_constraintex, str_add_constraint, get_row, get_rowex, get_mat |
get_improveReturns the iterative improvement level. int get_improve(lprec *lp); Return Value get_improve returns the iterative improvement level. Can by any of the following values:
Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI improve
Remarks The default is IMPROVE_DUALFEAS + IMPROVE_THETAGAP (6). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_improve |
add_lag_con, str_add_lag_conAdd a Lagrangian constraint to the lp. The Lagrangian solver does not work. Do not use this call. unsigned char add_lag_con(lprec *lp, REAL *row, int con_type, REAL rhs); unsigned char str_add_lag_con(lprec *lp, char *row_string, int con_type, REAL rhs); Return Value add_lag_con and str_add_lag_con returns TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row An array with column elements that contains the values of the row. row_string A string with column elements that contains the values of the row. Each element must be separated by space(s). con_type The type of the constraint. Can by any of the following values:
rhs The value of the right hand side (RHS). Remarks The Lagrangian solver does not work. Do not use this call. The add_lag_con, str_add_lag_con functions adds a Lagrangian row
to the model (at the end) and sets all values of the row at once. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_constraint, add_constraintex, str_add_constraint, set_row, set_rowex, set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj, get_constr_type, del_constraint, add_column, add_columnex, str_add_column, set_column, set_columnex, get_column, get_columnex, get_row, get_rowex, get_mat, lag_solve, get_Lrows |
set_add_rowmodeSpecifies which add routine performs best. add_column, add_columnex, str_add_column or add_constraint, add_constraintex, str_add_constraint unsigned char set_add_rowmode(lprec *lp, unsigned char turnon); Return Value set_add_rowmode return TRUE if changed from mode and FALSE if this mode was already set. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI turnon TRUE or FALSE. If FALSE, then add_column, add_columnex, str_add_column performs best. If TRUE, then add_constraint, add_constraintex, str_add_constraint performs best. Remarks Default, this is FALSE, meaning that add_column, add_columnex,
str_add_column performs best. If the model is build via
add_constraint, add_constraintex, str_add_constraint calls, then these routines will be much faster
if this routine is called with turnon set on TRUE. This is also called row entry mode.
The speed improvement is spectacular,
especially for bigger models, so it is advisable to call this routine to set the mode.
Normally a model is build either column by column or row by row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_add_rowmode, set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj, add_column, add_columnex, str_add_column, set_column, set_columnex, add_constraint, add_constraintex, str_add_constraint |
set_infiniteSpecifies the practical value for "infinite". void set_infinite(lprec *lp, REAL infinite); Return Value set_infinite has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI infinite The value that must be used for "infinite". Remarks The set_infinite function specifies the practical value for "infinite".
This value is used for very big numbers. For example the upper bound of a
variable without an upper bound. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_infinite, is_infinite, set_epsint, get_epsint, set_epsb, get_epsb, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
is_negativeReturns if the variable is negative. unsigned char is_negative(lprec *lp, int column); Return Value is_negative returns TRUE (1) if the variable is defined as negative,
FALSE (0) otherwise. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be checked. It must be between 1 and the number of columns in the lp. Remarks The is_negative function returns if a variable is negative or not. Negative means a lower and upper bound that are both negative. Default a variable is not free because default it has a lower bound of 0 (and an upper bound of +infinity). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_upbo, set_upbo, set_lowbo, get_lowbo, set_bounds, is_unbounded, set_unbounded |
set_epsdSpecifies the value that is used as a tolerance for reduced costs to determine whether a value should be considered as 0. void set_epsd(lprec *lp, REAL epsd); Return Value set_epsd has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI epsd The value that is used as a tolerance for reduced costs to determine whether a value should be considered as 0. Remarks The set_epsd function specifies the value that is used as a tolerance for reduced costs to
determine whether a value should be considered as 0. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_epsd, set_infinite, is_infinite, get_infinite, set_epsint, get_epsint, set_epsb, get_epsb, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
Basis Factorization PackagesBasis Factorization Package (shortened as BFP) is a unique lp_solve feature. Considerable effort has been put in this new feature and we have big expectations for this. BFP is a generic interface model and users can develop their own implementations based on the provided templates. We are very interested in providing as many different BFPs as possible to the community.
Until version 4, lp_solve always used the product form of the inverse (etaPFI) to perform
its matrix pivot changes. However there are other methods
like LU decomposition. Each method has its advantages and disadvantages. Some
are faster/slower, other are numerical more/less stable. The speed and
stability of a solver depends considerably on the BFP. One model will be solved
better with one BFP and another with another BFP. lp_solve version 5.5 has the LUSOL engine built in as default. In addition two other BFPs are included for both Windows and Linux: bfp_LUSOL.dll, bfp_etaPFI.dll for Windows and libbfp_LUSOL.so, libbfp_etaPFI.so for Linux. The standalone bfp_etaPFI is v2.0 and includes advanced column ordering using the COLAMD library, as well as better pivot management for stability. For complex models, however, the LU factorization approach is much better, and lp_solve now includes LUSOL as one of the most stable engines available anywhere. LUSOL was originally developed by Prof. Saunders at Stanford, and it has now been ported to C and enhanced by Kjell Eikland. These BFPs are not statically linked, but are dynamically loaded
when requested (except for the default LUSOL engine). It is even possible for people to write their own BFP.
Under Windows, a BFP is provided as DLL (bfp_*.dll), under UNIX/LINUX as a dynamic linked
library (libbfp_*.so). Under Windows, the following search order is used:
Under Unix/Linux, following search order is used:
Under Unix/Linux it is standard that a library has the lib prefix and a .so postfix.
Under Windows there is no prefix and a .dll postfix.
lp_solve -bfp bfp_LUSOL input.lp The latter makes sure that the BFP is searched in the current directory, especially for Unix/Linux. A third BFP based on GLPK may be included later, but license issues must first be resolved. In the interim, you may experiment with the working sample BFP interface files for GLPK. If you compile BFPs yourself, make sure that under Windows, you use __stdcall convention and use 8 byte alignments. This is needed for the BFPs to work correctly with the general distribution of lp_solve and also to make sharing BFPs as uncomplicated as possible. |
set_break_at_firstSpecifies if the branch-and-bound algorithm stops at first found solution. void set_break_at_first(lprec *lp, unsigned char break_at_first); Return Value set_break_at_first has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI break_at_first TRUE or FALSE. Stop branch-and-bound algorithm at first found solution or not. Remarks The set_break_at_first function specifies if the branch-and-bound
algorithm stops at the first found solution or not. Stopping at the first found
solution can be useful if you are only interested for a solution, but not
necessarily (and most probably) the most optimal solution. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_break_at_first, set_break_at_value, get_break_at_value, set_obj_bound, get_obj_bound, set_mip_gap, get_mip_gap |
set_rh_vec, str_set_rh_vecSet the right hand side (RHS) vector (column 0). void set_rh_vec(lprec *lp, REAL *rh); unsigned char str_set_rh_vec(lprec *lp, char *rh_string); Return Value set_rh_vec has no return value. str_set_rh_vec returns TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI rh An array with row elements that contains the values of the RHS. rh_string A string with row elements that contains the values of the RHS. Each element must be separated by space(s). Remarks
The set_rh_vec, str_set_rh_vec functions set all values of the
RHS vector (column 0) at once. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_rh, get_rh, add_constraint, add_constraintex, str_add_constraint, add_column, add_columnex, str_add_column, get_mat, get_column, get_columnex, set_column, set_columnex, get_row, get_rowex, set_row, set_rowex |
get_total_nodesReturns the total number of nodes processed in branch-and-bound. long long get_total_nodes(lprec *lp); Return Value get_total_nodes returns the total number of nodes processed in branch-and-bound of the last
solution. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_total_nodes function returns the total number of nodes processed in branch-and-bound of
the last solution. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_max_level, get_total_iter |
set_epspivotSpecifies the value that is used as a tolerance pivot element to determine whether a value should be considered as 0. void set_epspivot(lprec *lp, REAL epspivot); Return Value set_epspivot has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI epspivot The value that is used as a tolerance for the pivot element to determine whether a value should be considered as 0. Remarks The set_epspivot function specifies the value that is used as a tolerance
for the pivot element to determine whether a value should be considered as 0. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_epspivot, set_infinite, get_infinite, is_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsel, get_epsel, get_epsperturb, set_epsperturb, set_mip_gap, get_mip_gap |
get_primal_solution, get_ptr_primal_solution, get_var_primalresultReturns the solution of the model. unsigned char get_primal_solution(lprec *lp, REAL *pv); unsigned char get_ptr_primal_solution(lprec *lp, REAL **ptr_pv); REAL get_var_primalresult(lprec *lp, int index); Return Value get_primal_solution, get_ptr_primal_solution return TRUE (1) if the
operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI pv An array that will contain the value of the objective function (element 0), values of the constraints (elements 1 till Nrows), and the values of the variables (elements Nrows+1 till Nrows+NColumns). ptr_pv The address of a pointer that will point to an array that will contain the value of the objective function (element 0), values of the constraints (elements 1 till Nrows), and the values of the variables (elements Nrows+1 till Nrows+NColumns). index index of the constraint/variable. Remarks The get_primal_solution, get_ptr_primal_solution, get_var_primalresult
functions retrieve the values of the objective function, constraints and
variables. Note that get_ptr_primal_solution returns a pointer to memory allocated and maintained by lp_solve. Be careful what you do with it. Don't modify its contents or free the memory. Unexpected behaviour would occur. Also note that this memory pointer is only guaranteed to remain constant until a next lp_solve API call is done. You should call this function again to make sure you have again the correct pointer. Otherwise, this pointer could point to invalid memory. This should not be a problem since this call is very efficient. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_feasible, get_objective, get_working_objective, get_variables, get_ptr_variables, get_constraints, get_ptr_constraints, get_constr_value, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex |
set_column, set_columnexset a column in the lp. unsigned char set_column(lprec *lp, int col_no, REAL *column); unsigned char set_columnex(lprec *lp, int col_no, int count, REAL *column, int *rowno); Return Value set_column, set_columnex return TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI col_no The column number that must be changed. count Number of elements in column and rowno. column An array with 1+get_Nrows (count for set_columnex, if rowno is different from NULL) elements that contains the values of the column. rowno A zero-based array with count elements that contains the row numbers of the column. However this variable can also be NULL. In that case element i in the variable column is row i. Remarks The set_column, set_columnex functions change the values of an existing column in the
model at once. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_column, get_columnex, add_column, add_columnex, str_add_column, add_constraint, add_constraintex, str_add_constraint, set_row, set_rowex, set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj, set_add_rowmode, is_add_rowmode, get_constr_type, is_constr_type, del_constraint, add_column, add_columnex, str_add_column, get_column, get_columnex, get_row, get_rowex, get_mat |
set_verboseSet the verbose level. void set_verbose(lprec *lp, int verbose); Return Value set_verbose has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI verbose The verbose level. Can be one of the following values:
Remarks The set_verbose function sets the verbose level. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_verbose, put_logfunc |
set_traceSets a flag if pivot selection must be printed while solving. void set_trace(lprec *lp, unsigned char trace); Return Value set_trace has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI trace TRUE or FALSE. Print or do not print. Remarks The set_trace function sets a flag if pivot selection must be printed while solving. This function is mend for debugging purposes. The default is not to print (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_trace |
Linear programming basicsA short explanation is given what Linear programming is and some basic knowledge you need to know. A linear programming problem is mathematically formulated as follows:
The problem is usually expressed in matrix form, and then becomes:
maximize CT x
subject to A x <= B
x >= 0
So a linear programming model consists of one objective which is a linear equation that must be maximized or minimized. Then there are a number of linear inequalities or constraints. cT, A and B are constant matrixes. x are the variables (unknowns). All of them are real, continue values. Note the default lower bounds of zero on all variables x. People tend to forget this build-in default. If no negative (or negative infinite) lower bound is explicitely set on variables, they can and will take only positive (zero included) values. The inequalities can be <=, >= or = Also note that both objective function and constraints must be linear equations. This means that no variables can be multiplied with each other. This formulation is called the Standard form. It is the usual and most intuitive form of describing a linear programming problem. Example:
minimize 3 x1 - x2
subject to -x1 + 6 x2 - x3 + x4 >= -3
7 x2 + 2 x4 = 5
x1 + x2 + x3 = 1
x3 + x4 <= 2
Sometimes, these problems are formulated in the canonical form. All inequalities are converted to equalities by adding an extra variable where needed:
maximize CT x
subject to A x = B
x >= 0
Above example can then be written as:
minimize 3 x1 - x2
subject to -x1 + 6 x2 - x3 + x4 - s = -3
7 x2 + 2 x4 = 5
x1 + x2 + x3 = 1
x3 + x4 + t = 2
So everywhere an equality was specified, an extra variable is introduced and subtracted (if it was >) or added (if it was <) to the constraint. These variables also only take positive (or zero) values only. These extra variables are called slack or surplus variables. lp_solve add's these variables automatically to its internal structure. The formulator doesn't have to do it and it is even better not to. There will be fewer variables in the model and thus quicker to solve. See Formulation of an lp problem in lpsolve for a practical example. The right hand side (RHS), the B-vector, must be a constant matrix. Some people see this as a problem, but it isn't The RHS can always be brought to the left by a simple operation:
A x <= B
Is equal to:
A x - B <= 0
So if B is not constant, just do that.
Basic mathematics also states that if a constraint is multiplied by a negative constant, that the inequality changes from direction. For example:
5 x1 - 2 x2 >= 3
If multiplied by -1, it becomes:
-5 x1 + 2 x2 <= -3
If the objective is multiplied by -1, then maximization becomes minimization and the other way around. For example:
minimize 3 x1 - x2
Can also be written as:
maximize -3 x1 + x2
The result will be the same, but changed from sign. BoundsMinima and maxima on single variables are special cases of restrictions. They are called bounds. The optimization algorithm can handle these bounds more effeciently than other restrictions. They consume less memory and the algorithm is faster with them. As already specified, there is by default an implicit lower bound of zero on each variable. Only when explicitly another lower bound is set, the default of 0 is overruled. This other bound can be negative also. There is no default upper bound on variables. Almost all solvers support bounds on variables. So does lp_solve. RangesFrequently, it happens that on the same equation a less than and a greater than restriction must be set. Instead of adding two extra restrictions to the model, it is more performant and less memory consument to only add one restiction with either the less than or greater than restriction and put the other inequality on that same constraint by means of a range. Not all solvers support this feature but lp_solve does. Integer and binary variablesBy default, all variables are real. Sometimes it is required that one or more variables must be integer. It is not possible to just solve the model as is and then round to the nearest solution. At best, this result will maybe furfill all constraints, but you cannot be sure of. As you cannot be sure of the fact that this is the most optimal solution. Problems with integer variables are called integer or descrete programming problems. If all variables are integer it is called a pure integer programming problem, else it is a mixed integer programming problem. A special case of integer variables are binary variables. These are variables that can only take 0 or 1 as value. They are used quite frequently to program discontinue conditions. lp_solve can handle integer and binary variables. Binary variables are defined as integer variables with a maximum (upper bound) of 1 on them. See integer variables for a description on them. Semi-continuous variablesSemi-continuous variables are variables that must take a value between their minimum and maximum or zero. So these variables are treated the same as regular variables, except that a value of zero is also accepted, even if there is a minimum bigger than zero is set on the variable. See semi-continuous variables for a description on them. Special ordered sets (SOS)A specially ordered set of degree N is a collection of variables where at most N variables may be non-zero. The non-zero variables must be contiguous (neighbours) sorted by the ascending value of their respective unique weights. In lp_solve, specially ordered sets may be of any cardinal type 1, 2, and higher, and may be overlapping. The number of variables in the set must be equal to, or exceed the cardinal SOS order. See Special ordered sets (SOS) for a description on them.
lp_solve uses the simplex algorithm to solve these problems. To solve the integer restrictions, the branch and bound (B&B) method is used. |
set_intSet the type of the variable. Integer or floating point. unsigned char set_int(lprec *lp, int column, unsigned char must_be_int); Return Value set_int returns TRUE (1) if the operation was successful. A return value
of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be set. It must be between 1 and the number of columns in the lp. must_be_int TRUE (1) if the variable must be integer, FALSE (0) if not. Remarks The set_int function defines if a variable must be integer or not. Default a variable is not integer. The argument must_be_int defines what the status of the variable becomes. From the moment there is at least one integer variable in the model, the Branch and Bound algorithm is used to make these variables integer. Note that solving times can be considerably larger when there are integer variables. See integer variables for a description about integer variables. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_int, is_binary, set_binary |
get_column, get_columnexGet all (get_column) or only the non-zero (get_columnex) column elements from the matrix.
unsigned char get_column(lprec *lp, int col_nr, REAL *column); Return Value
get_column returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI col_nr Column number of the matrix. Must be between 1 and number of columns in the lp. column Array in which the values are returned. For get_column, the array must be dimensioned with at least 1get_Nrows elements in the lp. For get_columnex, the array must be dimentioned with at least the number of non-zero elements in the column. If that is unknown, then use 1+get_Nrows in the lp. The return value of the function indicates how many non-zero elements there are. nzrow Array in which the row numbers are returned. The array must be dimentioned with at least the number of non-zero elements in the column. If that is unknown, then use 1+get_Nrows in the lp. The return value of the function indicates how many non-zero elements there are. Remarks
get_column retrieves all values for the given column. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_mat, get_row, get_rowex, set_row, set_rowex, set_rh, set_rh_vec, str_set_rh_vec, add_constraint, add_constraintex, str_add_constraint, add_column, add_columnex, str_add_column, set_column, set_columnex |
get_epsbReturns the value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0. REAL get_epsb(lprec *lp); Return Value get_epsb returns the value of epsb. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_epsb function returns the value that is used as a tolerance for the Right Hand Side (RHS) to
determine whether a value should be considered as 0. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_epsb, set_infinite, get_infinite, is_infinite, set_epsint, get_epsint, set_epsd, get_epsd, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
get_nonzerosReturns the number of non-zero elements in the matrix. int get_nonzeros(lprec *lp); Return Value get_nonzeros returns the number of non-zero elements in the matrix. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_nonzeros function returns the number of non-zeros in the matrix. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI |
RatiosConstraintsLinear constraints are of the form: a1 x1 + a2 x2 + a3 x3 + ... >= minimum a1 x1 + a2 x2 + a3 x3 + ... <= maximum Where minimum and maximum are constants. lp_solve can only handle these kind of Linear equations. However sometimes there are tricks to convert an equation that seems non-Linear at first sight to a Linear equation. One of these is ratio's: a11 x1 + a12 x2 + a13 x3 + ... <= minimum On condition that a21 x1 + a22 x2 + a23 x3 + ... is positive, this is equal to: a11 x1 + a12 x2 + a13 x3 + ... <= minimum * (a21 x1 + a22 x2 +
a23 x3 + ...) If the denominator is always negative, then it can be converted to: a11 x1 + a12 x2 + a13 x3 + ... >= minimum * (a21 x1 + a22 x2 + a23 x3 + ...) Let's continue with the case that the denominator is positive, then the equation is also equal to: a11 x1 + a12 x2 + a13 x3 + ... - minimum * (a21 x1 + a22 x2 + a23 x3 + ...) <= 0 Or (a11 - minimum * a21) x1 + (a12 - minimum * a22) x2 + (a13 - minimum * a23) x3 + ... <= 0 And there we have again a Linear equation. The same can be done for a maximum or equality of course. Don't forget that there is one assumption: the denominator is positive or negative. If it can be both, then this trick cannot be used. One example of this is for example that it is required that two variables must have a ration of 1/2. For example: x1 = 1/2 With the formula above, this gives: x1 - 0.5 x2 = 0 Adding this equation will result in the fact that x2 will be two times larger than x1. Again in the assumption that x2 stays positive. Oh, and what if the denominator is zero? Division by zero is undefined and cannot give a real value. In the above example with two variables, if x2 is zero, then x1 is also forced to be zero. That is the side effect by converting the non-Linear equation to a Linear equation. Objective function
max c0 + c1 x1 + c2 x2 + c3 x3 + ...
d0 + d1 x1 + d2 x2 + d3 x3 + ...
s.t. ai1 x1 + ai2 x2 + ai3 x3 + ... <= bi
xj >= 0
Note that c0 and d0 are constants. They are optional and not required for this solution. Linear programming only accepts models with equations in the first degree. The objective function however has a numerator and denominator so this seems not possible to solve with pure linear programming. However there is a trick to overcome to this problem. This model can be transformed to another model that is pure linear. When the solution is found to this transformed model, the results can be recalculated back to the original model. There is only one condition to make this possible: the denominator must be strictly positive (or negative, but in that case you can multiply numerator and denominator by -1 such that the denominator becomes positive). d0 + d1 x1 + d2 x2 + d3 x3 + ... > 0 Again note the > sign. The denominator may also not become zero. If the transformed model returns a solution saying that it is zero, then the solution is invalid. Now with this assumption in mind, we can introduce a new variable y0:
y0 = 1
d0 + d1 x1 + d2 x2 + d3 x3 + ...
Then the model can also be written as:
max c0 y0 + c1 x1 y0 + c2 x2 y0 + c3 x3 y0 + ...
s.t. ai1 x1 + ai2 x2 + ai3 x3 + ... <= bi
y0 = 1
d0 + d1 x1 + d2 x2 + d3 x3 + ...
y0, xj >= 0
The constraints can also be multiplied by y0 and the y0 constraint can be written differently:
max c0 y0 + c1 x1 y0 + c2 x2 y0 + c3 x3 y0 + ...
s.t. ai1 x1 y0 + ai2 x2 y0 + ai3 x3 y0 + ... <= bi y0
d0 y0 + d1 x1 y0 + d2 x2 y0 + d3 x3 y0 + ... = 1
y0, xj y0 >= 0
Note again that this can only be done if y0 > 0 Now also make following substitution:
yj = xj y0
Also put the bi y0 term to the left:
max c0 y0 + c1 y1 + c2 y2 + c3 y3 + ...
s.t. -bi y0 + ai1 y1 + ai2 y1 + ai3 y3 + ... <= 0
d0 y0 + d1 y1 + d2 y2 + d3 y3 + ... = 1
yj >= 0
All yj are variables (j starting from 0) This new transformed model is an exact transformation of the original model, but
with the advantage that it is a pure linear model. Also note that this model has one extra
variable (y0) with coefficients in the matrix which are the negative of the right hand side (-bi y0).
A constraint is also added requiring the constant term in the denominator times the new variable (d0 y0)
plus the denominator terms involving the transformed variables to equal 1. The transformed model
uses the same aij's as the original. Its right hand sides are all 0's except the one in the new constraint.
The objective function does not have a denominator term and the objective function altered to include
the numerator constant times the new variable y0.
yj = xj y0
So:
xj = yj / y0
ExampleSuppose that it is desirable to solve the following problem.
max 1.8 x1 + 1.7 x2
10 + 4.0 x1 + 4.1 x2
s.t. 1.5 x1 + x2 <= 6
3.0 x1 + 4 x2 <= 20
x1, x2 >= 0
Then the transformed problem is:
max 1.8 y1 + 1.7 y2
s.t. -6 y0 + 1.5 y1 + y2 <= 0
-20 y0 + 3.0 y1 + 4 y2 <= 0
10 y0 + 4.0 y1 + 4.1 y2 = 1
y0, y1, y2 >= 0
The solution of this transformed model is:
Value of objective function: 0.289916
Actual values of the variables:
y1 0.0420168
y2 0.12605
y0 0.0315126
Dual values with from - till limits:
Dual value From Till
R1 0.342437 -0.03278689 0.1090909
R2 0.04222689 -0.3076923 0.1156069
R3 0.289916 0 1e+030
y1 0 -1e+030 1e+030
y2 0 -1e+030 1e+030
y0 0 -1e+030 1e+030
The value of the objective function of this transformed model is also the value of the objective function of the original model. The values of the original xi variables are calculated by dividing the yi values by y0: x1 = y1 / y0 = 0.0420168 / 0.0315126 = 1.33333333 x2 = y2 / y0 = 0.12605 / 0.0315126 = 4 Plugging back into the original problem, the numerator equals 9.2; the denominator, 31.73, and their fraction 0.289916 (the objective function value reported). One may also recover the dual values or reduced costs. In this case since the rows are multiplied by one over the denominator, the original values may be recovered by dividing through by the denominator (1 / y0 or multiplying them by y0). Thus the effective dual value for constraint 1 is 0.01079, and constraint 2 is 0.0013307. Constraint 3 has no analogue in the original problem, and thus, is not transformed. The From - Till limits can also be recalculated back by dividing them by y0 and correcting these values with the bi y0 term. CommentsThis is an exact transformation as long as the denominator remains strictly positive. The formulation fails if y0 equals zero in the optimal solution. Much research has been done on fractional programming. The original development appears in Charnes and Cooper (1962). A historical perspective and literature review can be found in Schaible and Ibaraki. Integer variablesExtra complexity arises if there are integer variables in the original model. Ie, one or more of the xi variables must be integer. Remember that:yj = xj y0and y0 = 1 / denominatorBecause of the latter, y0 is a real number. So yj is real, even if xj is integer. None of the xj variables are in the transformed model and from above you can see that you can't make the yj variables integer to have xj integer. So is it then not possible to define something that xj become integer? Remember that xj = yj / y0Suppose that xj must take an integer value i: yj / y0 = ior yj = i * y0Unfortunately, this constraint can't be handled by lpsolve since it is quadratic. However a special case of integer variables can be solved: Binary variablesBinary variables are a special kind of integer variables. They can only take 0 or 1 values. From the previous section we know thatyj = i * y0In this case is i either zero or one. If zero, then yj must be zero. If one, then yj = y0. If we can put this into the formulation, then the xj variables will be binary. To make this possible, you must introduce extra binary variables: zj When zj = 0, then it must make yj = 0 and when zj = 1, then it must make yj = y0 One way to make this possible is by doing the following. First you must determine a constant value f1 for which you know that f1 > yj in all cases and f2 for which you know that f2 > y0 in all cases. Then you can write: yj <= f1 zj yj - y0 - f2 zj >= -f2 yj - y0 + f2 zj <= f2Two cases have to be considered: 1) zj = 0 yj <= 0 yj - y0 >= -f2 yj - y0 <= f2or yj = 0 -y0 >= -f2 -y0 <= f2or yj = 0 y0 <= f2 y0 >= -f2since you have chosen the constant f2 such that it is always larger than y0, equations 2 and 3 are redundant in this case and yj is indeed 0. And from above, this means that xj will be 0. 2) zj = 1 yj <= f1 yj - y0 - f2 >= -f2 yj - y0 + f2 <= f2or yj <= f1 yj - y0 >= 0 yj - y0 <= 0since you have chosen the constant f1 such that it is always larger than yj, equation 1 is redundant. Equations 2 and 3 together make that yj equals y0. And from above, this means that xj will be 1. Of course your model becomes alot more complex. Per xj integer variable, you must introduce an extra binary variable zj and add 3 constraints for each. And you must have a guess for f1 and f2. Don't take a very very large number like 1e10 or something like this because that would make the model very unstable because of scaling/rouding errors. You must deduce from your model what these two factors can be. Maybe by first solving the model without integer constraints and determine f1 and f2 from this real result. Using the example from above, now requiring that both x1 and x2 are integer. The result of the real model is: Value of objective function: 0.289916 Actual values of the variables: y1 0.0420168 y2 0.12605 y0 0.0315126From this, choose f1 and f2 being 10. Now add the following constraints to this model: y1 <= 10 z1 y1 - y0 - 10 z1 >= -10 y1 - y0 + 10 z1 <= 10 y2 <= 10 z2 y2 - y0 - 10 z2 >= -10 y2 - y0 + 10 z2 <= 10 int z1, z2The solution of this model is: Value of objective function: 0.19337 Actual values of the variables: y1 0.0552486 y2 0.0552486 y0 0.0552486 z1 1 z2 1 x1 = y1 / y0 = 1 x2 = y2 / y0 = 1Indeed binary values. |
set_bb_floorfirstSpecifies which branch to take first in branch-and-bound algorithm. void set_bb_floorfirst(lprec *lp, int bb_floorfirst); Return Value set_bb_floorfirst has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI bb_floorfirst Specifies which branch to take first in branch-and-bound algorithm. Can by any of the following values:
Remarks The set_bb_floorfirst function specifies which branch to take first in
branch-and-bound algorithm. This can influence solving times considerably.
Depending on the model one rule can be best and for another model another rule. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_bb_floorfirst, set_var_branch, get_var_branch, set_var_weights, get_var_priority, put_bb_branchfunc |
is_use_namesReturns if variable or constraint names are used. unsigned char is_use_names(lprec *lp, unsigned char isrow); Return Value is_use_names returns a boolean value indicating if variable or constraint names
are used. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI isrow Set to FALSE (0) if column information is needed and TRUE (1) if row information is needed. Remarks When a model is read from file or created via the API, variables and constraints can be named.
These names are used to report information or to save the model in a given format.
However, sometimes it is required to ignore these names and to use the internal names of lp_solve.
This is for example the case when the names do not comply to the syntax rules of the format that
will be used to write the model to. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_use_names, set_col_name, get_col_name, set_row_name, get_row_name |
get_epsdReturns the value that is used as a tolerance for the reduced costs to determine whether a value should be considered as 0. REAL get_epsd(lprec *lp); Return Value get_epsd returns the value of epsd. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_epsd function returns the value that is used as a tolerance for
the reduced costs to determine whether a value should be considered as
0. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_epsd, set_infinite, is_infinite, get_infinite, set_epsint, get_epsint, set_epsb, get_epsb, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb, set_mip_gap, get_mip_gap |
set_scalelimitSets the relative scaling convergence criterion for the active scaling mode; the integer part specifies the maximum number of iterations. void set_scalelimit(lprec *lp, REAL scalelimit); Return Value set_scalelimit has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI scalelimit The relative scaling convergence criterion for the active scaling mode; the integer part specifies the maximum number of iterations Remarks The set_scalelimit function sets the relative scaling convergence criterion for the active scaling mode; the integer part specifies the maximum number of iterations (default is 5). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_scalelimit, set_scaling, get_scaling, is_integerscaling, is_scalemode, is_scaletype |
add_column, add_columnex, str_add_column
add_constraint, add_constraintex, str_add_constraint
add_lag_con, str_add_lag_con
add_SOS
column_in_lp
copy_lp
default_basis
del_column
del_constraint
delete_lp
dualize_lp
free_lp
get_anti_degen
get_basis
get_basiscrash
get_bb_depthlimit
get_bb_floorfirst
get_bb_rule
get_bounds_tighter
get_break_at_value
get_col_name, get_origcol_name
get_column, get_columnex
get_constr_type
get_constr_value
get_constraints, get_ptr_constraints
get_epsb
get_epsd
get_epsel
get_epsint
get_epsperturb
get_epspivot
get_improve
get_infinite
get_lambda, get_ptr_lambda, get_lambda, get_ptr_lambda
get_lowbo
get_lp_index
get_lp_name
get_Lrows
get_mat
get_max_level, get_max_level
get_maxpivot
get_mip_gap
get_Ncolumns
get_nameindex
get_negrange
get_nonzeros
get_Norig_columns
get_Norig_rows
get_Nrows
get_obj_bound
get_objective
get_orig_index
get_pivoting
get_presolve
get_presolveloops
get_primal_solution, get_ptr_primal_solution, get_var_primalresult
get_print_sol
get_rh
get_rh_range
get_row, get_rowex
get_row_name, get_origrow_name
get_scalelimit
get_scaling
get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex
get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult
get_simplextype
get_solutioncount
get_solutionlimit
get_status
get_statustext
get_timeout
get_total_iter
get_total_nodes
get_upbo
get_var_branch
get_var_priority, get_var_priority
get_variables, get_ptr_variables
get_verbose
get_working_objective
guess_basis
has_BFP
has_XLI
is_add_rowmode
is_anti_degen
is_binary
is_break_at_first
is_constr_type
is_debug
is_feasible
is_unbounded
is_infinite
is_int
is_integerscaling
is_lag_trace
is_maxim
is_nativeBFP
is_nativeXLI
is_negative
is_obj_in_basis
is_piv_mode
is_piv_rule
is_presolve
is_scalemode
is_scaletype
is_semicont
is_SOS_var
is_trace
is_use_names
lag_solve
lp_solve_version
make_lp
print_constraints
print_debugdump
print_duals
print_lp
print_objective
print_scales
print_solution
print_str
print_tableau
put_abortfunc
put_bb_branchfunc
put_bb_nodefunc
put_logfunc
put_msgfunc
read_basis
read_lp, read_LP
read_mps, read_freemps, read_MPS, read_freeMPS
read_params
read_XLI
reset_basis
reset_params
resize_lp
set_add_rowmode
set_anti_degen, get_anti_degen
set_basis
set_basiscrash
set_basisvar
set_bb_depthlimit
set_bb_floorfirst
set_bb_rule
set_BFP
set_XLI
set_binary
set_bounds
set_bounds_tighter
set_break_at_first
set_break_at_value
set_column, set_columnex
set_col_name
set_constr_type
set_debug
set_epsb
set_epsd
set_epsel
set_epsint
set_epsperturb
set_epspivot
set_epslevel
set_unbounded
set_improve
set_infinite
set_int
set_lag_trace
set_lowbo
set_lp_name
set_mat
set_maxim
set_maxpivot
set_minim
set_mip_gap
set_negrange
set_obj_bound
set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj
set_obj_in_basis
set_outputstream, set_outputfile
set_pivoting
set_preferdual
set_presolve
set_print_sol
set_rh
set_rh_range
set_rh_vec, str_set_rh_vec
set_row, set_rowex
set_row_name
set_scalelimit
set_scaling
set_semicont
set_sense
set_simplextype
set_solutionlimit
set_timeout
set_trace
set_upbo
set_use_names
set_var_branch
set_var_weights
set_verbose
solve
time_elapsed
unscale
write_basis
write_lp, write_LP, write_lpex
write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileex
write_params
write_XLI
docs/5.5/print_debugdump.htm 0000644 0001750 0001750 00000005464 11306036626 014677 0 ustar rene reneCreate/destroy model
copy_lp
make_lp
read_lp, read_LP
read_mps, read_freemps, read_MPS, read_freeMPS
read_XLI
delete_lp
free_lp
Build model
add_column, add_columnex, str_add_column, set_column, set_columnex, get_column, get_columnex
add_constraint, add_constraintex, str_add_constraint, set_row, set_rowex
add_lag_con, str_add_lag_con
add_SOS, is_SOS_var
del_column
del_constraint, get_row, get_rowex
get_nameindex
is_infinite
is_negative
resize_lp
set_add_rowmode, is_add_rowmode
set_binary, is_binary
set_bounds
set_bounds_tighter, get_bounds_tighter
set_col_name, get_col_name, get_origcol_name
set_constr_type, get_constr_type, is_constr_type
set_unbounded, is_unbounded
set_infinite, get_infinite
set_int, is_int
set_lowbo, get_lowbo
set_lp_name, get_lp_name
set_mat, get_mat
set_obj_bound, get_obj_bound
set_obj_fn, set_obj_fnex, str_set_obj_fn, set_obj
set_rh, get_rh
set_rh_range, get_rh_range
set_rh_vec, str_set_rh_vec
set_row_name, get_row_name, get_origrow_name
set_semicont, is_semicont
set_upbo, get_upbo
set_var_branch, get_var_branch
set_var_weights
Solver settings
default_basis
read_basis
reset_basis
write_basis
guess_basis
read_params, write_params
reset_params
set_anti_degen, is_anti_degen
set_basis, get_basis
set_basiscrash, get_basiscrash
set_bb_depthlimit, get_bb_depthlimit
set_bb_floorfirst, get_bb_floorfirst
set_bb_rule, get_bb_rule
set_BFP, has_BFP, is_nativeBFP
set_break_at_first, is_break_at_first
set_break_at_value, get_break_at_value
set_epsb, get_epsb
set_epsd, get_epsd
set_epsel, get_epsel
set_epsint, get_epsint
set_epsperturb, get_epsperturb
set_epspivot, get_epspivot
set_epslevel
set_improve, get_improve
set_maxim, is_maxim
set_maxpivot, get_maxpivot
set_minim
set_mip_gap, get_mip_gap
set_negrange, get_negrange
set_obj_in_basis, is_obj_in_basis
set_pivoting, get_pivoting, is_piv_mode, is_piv_rule
set_preferdual
set_presolve, get_presolve, get_presolveloops, is_presolve
set_scalelimit, get_scalelimit
set_scaling, get_scaling, is_integerscaling, is_scalemode, is_scaletype
set_sense
set_simplextype, get_simplextype
set_solutionlimit, get_solutionlimit
set_timeout, get_timeout
set_use_names, is_use_names
unscale
Callback routines
put_abortfunc
put_bb_branchfunc
put_bb_nodefunc
put_logfunc
put_msgfunc
Solve
solve
lag_solve
Solution
get_constraints, get_ptr_constraints
get_constr_value get_objective
get_primal_solution, get_ptr_primal_solution, get_var_primalresult
get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex
get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult
get_solutioncount
get_total_iter
get_total_nodes
get_variables, get_ptr_variables
get_working_objective
is_feasible
Debug/print settings
set_debug, is_debug
set_lag_trace, is_lag_trace
set_outputstream, set_outputfile
set_print_sol, get_print_sol
set_trace, is_trace
set_verbose, get_verbose
Debug/print
print_constraints
print_debugdump
print_duals
print_lp
print_objective
print_scales
print_solution
print_str
print_tableau
Write model to file
write_lp, write_LP, write_lpex
write_mps, write_freemps, write_MPS, write_freeMPS, MPS_writefileex
write_XLI, set_XLI, has_XLI, is_nativeXLI
Miscellaneous routines
column_in_lp
dualize_lp
get_lp_index
get_Lrows
get_Ncolumns
get_nonzeros
get_Norig_columns
get_Norig_rows
get_Nrows
get_orig_index
get_statustext
get_statustext
lp_solve_version
set_basisvar
time_elapsed
print_debugdumpDo a generic readable data dump of key lp_solve model variables; principally for run difference and debugging purposes. unsigned char print_debugdump(lprec *lp, char *filename); Return Value print_debugdump returns TRUE if data could be written, else FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
The print_debugdump function creates a generic readable data dump of key
lp_solve model variables; principally for run difference and debugging purposes Example See Also delete_lp, free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, print_lp, print_objective, print_constraints, print_duals, print_scales, print_tableau, print_str |
set_lag_traceSets a flag if Lagrangian progression must be printed while solving. void set_lag_trace(lprec *lp, unsigned char lag_trace); Return Value set_lag_trace has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI lag_trace TRUE or FALSE. Print or do not print. Remarks The set_lag_trace function sets a flag if Lagrangian progression must be printed while solving. This function is mend for debugging purposes. The default is not to print (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_lag_trace |
set_improveSpecifies the iterative improvement level. void set_improve(lprec *lp, int improve); Return Value set_improve has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI improve Specifies the iterative improvement level. Can by any of the following values:
Remarks The default is IMPROVE_DUALFEAS + IMPROVE_THETAGAP (6). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_improve |
get_row, get_rowexGet all (get_row) or only the non-zero (get_rowex) row elements from the matrix.
unsigned char get_row(lprec *lp, int row_nr, REAL *row); Return Value
get_row returns TRUE (1) if the operation was successful. A return value
of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row_nr Row number of the matrix. Must be between 0 and number of rows in the lp. Row 0 is objective function. row Array in which the values are returned. For get_row, the array must be dimensioned with at least 1+get_Ncolumns elements in the lp. For get_rowex, the array must be dimentioned with at least the number of non-zero elements in the row. If that is unknown, then use the number of columns in the lp. The return value of the function indicates how many non-zero elements there are. colno Array in which the column numbers are returned. The array must be dimentioned with at least the number of non-zero elements in the row. If that is unknown, then use the number of columns in the lp. The return value of the function indicates how many non-zero elements there are. Remarks
get_row retrieves all values for the given row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_row, set_rowex, get_mat, get_column, get_columnex, set_column, set_columnex, set_mat, set_rh, set_rh_vec, str_set_rh_vec, add_constraint, add_constraintex, str_add_constraint, add_column, add_columnex, str_add_column |
del_columnRemove a column from the lp. unsigned char del_column(lprec *lp, int column); Return Value del_column returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column to delete. Must be between 1 and the number of columns in the lp. Remarks The del_column function deletes a column from the model. The column is
effectively deleted, so all columns after this column shift one left. Example See Also resize_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_column, add_columnex, str_add_column |
get_basisReturns the basis of the lp. unsigned char get_basis(lprec *lp, int *bascolumn, unsigned char nonbasic); Return Value get_basis returns TRUE if a basis could be returned, else FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI bascolumn An array with 1+get_Nrows or 1+get_Nrows+get_Ncolumns elements that will contain the basis after the call. nonbasic If FALSE, then bascolumn must have 1+get_Nrows elements and only contains the basic variables. If TRUE, then bascolumn must have 1+get_Nrows+get_Ncolumns elements and will also contain the non-basic variables. Remarks
The get_basis function returns the basis of the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_basis, default_basis, read_basis, write_basis, guess_basis, get_basiscrash, set_basiscrash |
get_lp_nameGets the name of the lp. char *get_lp_name(lprec *lp); Return Value get_lp_name returns the name of the lp. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The get_lp_name returns the name of the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_lp_name |
set_rh_rangeSet the range on a constraint. unsigned char set_rh_range(lprec *lp, int row, REAL deltavalue); Return Value set_rh_range returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row number of the constraint on which the range must be set. It must be between 1 and the number of rows in the lp. deltavalue The range on the constraint. Remarks The set_rh_range function sets a range on the constraint (row) identified
by row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_rh_range |
unscaleUnscales the model. void unscale(lprec *lp); Return Value unscale has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The unscale function unscales the model. Scaling can influence numerical
stability considerably. It is advisable to always use some sort of scaling. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_scaling, get_scaling, is_integerscaling, set_scalelimit, get_scalelimit, is_scalemode, is_scaletype |
print_scalesPrints the scales of the lp. void print_scales(lprec *lp); Return Value print_scales has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
The print_scales function prints the scales of the lp. This can only be
done after a successful solve. It will only output something when the model is
scaled. Example See Also delete_lp, free_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, print_lp, print_objective, print_solution, print_constraints, print_duals, print_tableau, print_str, set_outputstream, set_outputfile, set_scaling, print_debugdump |
print_lpPrints the lp model. void print_lp(lprec *lp); Return Value print_lp has no return value. Note that row entry mode must be off, else this function fails. See set_add_rowmode Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
The print_lp function prints the lp model. Example See Also delete_lp, free_lp, make_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, print_objective, print_solution, print_constraints, print_duals, print_scales, print_tableau, print_str, set_outputstream, set_outputfile, print_debugdump |
Python is an interpreted, interactive, object-oriented programming language. It is often compared to Tcl, Perl, Scheme or Java.
Python combines remarkable power with very clear syntax. It has modules, classes, exceptions, very high level dynamic data types, and dynamic typing. There are interfaces to many system calls and libraries, as well as to various windowing systems (X11, Motif, Tk, Mac, MFC, wxWidgets). New built-in modules are easily written in C or C++. Python is also usable as an extension language for applications that need a programmable interface.
The Python implementation is portable: it runs on many brands of UNIX, on Windows, OS/2, Mac, Amiga, and many other platforms.
Some of Python's notable features:
We will not discuss the specifics of Python here but instead refer the reader to the Python website. Also see Dive Into Python - Python from novice to pro
lpsolve is callable from Python via an extension or module. As such, it looks like lpsolve is fully integrated with Python. Matrices can directly be transferred between Python and lpsolve in both directions. The complete interface is written in C so it has maximum performance. The whole lpsolve API is implemented with some extra's specific for Python (especially for matrix support). So you have full control to the complete lpsolve functionality via the lpsolve Python driver. If you find that this involves too much work to solve an lp model then you can also work via higher-level script files that can make things a lot easier. See further in this article.
Python is ideally suited to handle linear programming problems. These are problems in which you have a quantity, depending linearly on several variables, that you want to maximize or minimize subject to several constraints that are expressed as linear inequalities in the same variables. If the number of variables and the number of constraints are small, then there are numerous mathematical techniques for solving a linear programming problem. Indeed these techniques are often taught in high school or university level courses in finite mathematics. But sometimes these numbers are high, or even if low, the constants in the linear inequalities or the object expression for the quantity to be optimised may be numerically complicated in which case a software package like Python is required to effect a solution.
To make this possible, a driver program is needed: lpsolve55.pyd. This driver must be put in a directory known to Python and Python can call the lpsolve solver.
This driver calls lpsolve via the lpsolve shared library (lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux) (archive lp_solve_5.5.0.13_dev.zip/lp_solve_5.5.0.13_dev.tar.gz). This has the advantage that the lpsolve driver doesn't have to be recompiled when an update of lpsolve is provided. The shared library must be somewhere in the Windows path.
So note the difference between the Python lpsolve driver that is called lpsolve and the lpsolve library that implements the API that is called lpsolve55.
There are also some Python script files (.py) as a quick start.
See Install the lpsolve driver for the installation of these files.
To test if everything is installed correctly, enter the following in the Python command window.
>>> from lpsolve55 import * >>> lpsolve()
If it gives the following, then everything is ok:
lpsolve Python Interface version 5.5.0.5
using lpsolve version 5.5.0.13
Usage: [ret1, ret2, ...] = lpsolve('functionname', arg1, arg2, ...)
If you get the following:
This application has failed to start because lpsolve55.dll was not found. Re-installing the application may fix this problem.
Or (Unix/Linux):
liblpsolve55.so: cannot open shared object file: No such file or directory.
Then Python can find the lpsolve driver program, but the driver program cannot find the lpsolve library
that contains the lpsolve implementation.
This library is called lpsolve55.dll under Windows and liblpsolve55.so under Unix/Linux.
Under Windows, the lpsolve55.dll file must be in a directory that in the PATH environment variable.
This path can be shown via the following command in Python: !PATH
It is common to place this in the WINDOWS\system32 folder.
Under Unix/Linux, the liblpsolve55.so shared library must be either in the directories /lib or /usr/lib or in
a directory specified by the LD_LIBRARY_PATH environment variable.
In the following text, >>> before the Python commands is the Python prompt. Only the text after >>> must be entered.
To call an lpsolve function, the following syntax must be used:
>>> [ret1, ret2, ...] = lpsolve('functionname', arg1, arg2, ...)
The return values are optional and depend on the function called. functionname must always be enclosed between single quotes to make it alphanumerical and it is case sensitive. The number and type of arguments depend on the function called. Some functions even have a variable number of arguments and a different behaviour occurs depending on the type of the argument. functionname can be (almost) any of the lpsolve API routines (see lp_solve API reference) plus some extra Python specific functions. Most of the lpsolve API routines use or return an lprec structure. To make things more robust in Python, this structure is replaced by a handle or the model name. The lprec structures are maintained internally by the lpsolve driver. The handle is an incrementing number starting from 0. Starting from driver version 5.5.0.2, it is also possible to use the model name instead of the handle. This can of course only be done if a name is given to the model. This is done via lpsolve routine set_lp_name or by specifying the model name in routine read_lp. See Using model name instead of handle.
Almost all callable functions can be found in the lp_solve API reference. Some are exactly as described in the reference guide, others have a slightly different syntax to make maximum use of the Python functionality. For example make_lp is used identical as described. But get_variables is slightly different. In the API reference, this function has two arguments. The first the lp handle and the second the resulting variables and this array must already be dimensioned. When lpsolve is used from Python, nothing must be dimensioned in advance. The lpsolve driver takes care of dimensioning all return variables and they are always returned as return value of the call to lpsolve. Never as argument to the routine. This can be a single value as for get_objective or a matrix or vector as in get_variables. In this case, get_variables returns a 4x1 matrix (vector) with the result of the 4 variables of the lp model.
Note that you can get a usage of lpsolve, its arguments and the constants that it defines by entering the following in Python:
>>> import lpsolve55 >>> help(lpsolve55)
Help on module lpsolve55:
NAME
lpsolve55
FILE
c:\python24\lib\site-packages\lpsolve55.pyd
CLASSES
exceptions.Exception
lpsolve.error
class error(exceptions.Exception)
| Methods inherited from exceptions.Exception:
|
| __getitem__(...)
|
| __init__(...)
|
| __str__(...)
FUNCTIONS
lpsolve(...)
lpsolve('functionname', arg1, arg2, ...) -> execute lpsolve functionname with args
DATA
ANTIDEGEN_BOUNDFLIP = 512
ANTIDEGEN_COLUMNCHECK = 2
ANTIDEGEN_DURINGBB = 128
ANTIDEGEN_DYNAMIC = 64
ANTIDEGEN_FIXEDVARS = 1
ANTIDEGEN_INFEASIBLE = 32
ANTIDEGEN_LOSTFEAS = 16
ANTIDEGEN_NONE = 0
ANTIDEGEN_NUMFAILURE = 8
ANTIDEGEN_RHSPERTURB = 256
ANTIDEGEN_STALLING = 4
BRANCH_AUTOMATIC = 2
BRANCH_CEILING = 0
BRANCH_FLOOR = 1
CRASH_LEASTDEGENERATE = 3
CRASH_MOSTFEASIBLE = 2
CRASH_NONE = 0
CRITICAL = 1
DEGENERATE = 4
DETAILED = 5
EQ = 3
FEASFOUND = 12
FR = 0
FULL = 6
GE = 2
IMPORTANT = 3
IMPROVE_BBSIMPLEX = 8
IMPROVE_DUALFEAS = 2
IMPROVE_NONE = 0
IMPROVE_SOLUTION = 1
IMPROVE_THETAGAP = 4
INFEASIBLE = 2
Infinite = 1e+030
LE = 1
MSG_LPFEASIBLE = 8
MSG_LPOPTIMAL = 16
MSG_MILPBETTER = 512
MSG_MILPEQUAL = 256
MSG_MILPFEASIBLE = 128
MSG_PRESOLVE = 1
NEUTRAL = 0
NODE_AUTOORDER = 8192
NODE_BRANCHREVERSEMODE = 16
NODE_BREADTHFIRSTMODE = 4096
NODE_DEPTHFIRSTMODE = 128
NODE_DYNAMICMODE = 1024
NODE_FIRSTSELECT = 0
NODE_FRACTIONSELECT = 3
NODE_GAPSELECT = 1
NODE_GREEDYMODE = 32
NODE_GUBMODE = 512
NODE_PSEUDOCOSTMODE = 64
NODE_PSEUDOCOSTSELECT = 4
NODE_PSEUDONONINTSELECT = 5
NODE_PSEUDORATIOSELECT = 6
NODE_RANDOMIZEMODE = 256
NODE_RANGESELECT = 2
NODE_RCOSTFIXING = 16384
NODE_RESTARTMODE = 2048
NODE_STRONGINIT = 32768
NODE_USERSELECT = 7
NODE_WEIGHTREVERSEMODE = 8
NOFEASFOUND = 13
NOMEMORY = -2
NORMAL = 4
NUMFAILURE = 5
OPTIMAL = 0
PRESOLVED = 9
PRESOLVE_BOUNDS = 262144
PRESOLVE_COLDOMINATE = 16384
PRESOLVE_COLFIXDUAL = 131072
PRESOLVE_COLS = 2
PRESOLVE_DUALS = 524288
PRESOLVE_ELIMEQ2 = 256
PRESOLVE_IMPLIEDFREE = 512
PRESOLVE_IMPLIEDSLK = 65536
PRESOLVE_KNAPSACK = 128
PRESOLVE_LINDEP = 4
PRESOLVE_MERGEROWS = 32768
PRESOLVE_NONE = 0
PRESOLVE_PROBEFIX = 2048
PRESOLVE_PROBEREDUCE = 4096
PRESOLVE_REDUCEGCD = 1024
PRESOLVE_REDUCEMIP = 64
PRESOLVE_ROWDOMINATE = 8192
PRESOLVE_ROWS = 1
PRESOLVE_SENSDUALS = 1048576
PRESOLVE_SOS = 32
PRICER_DANTZIG = 1
PRICER_DEVEX = 2
PRICER_FIRSTINDEX = 0
PRICER_STEEPESTEDGE = 3
PRICE_ADAPTIVE = 32
PRICE_AUTOPARTIAL = 256
PRICE_HARRISTWOPASS = 4096
PRICE_LOOPALTERNATE = 2048
PRICE_LOOPLEFT = 1024
PRICE_MULTIPLE = 8
PRICE_PARTIAL = 16
PRICE_PRIMALFALLBACK = 4
PRICE_RANDOMIZE = 128
PRICE_TRUENORMINIT = 16384
PROCBREAK = 11
PROCFAIL = 10
SCALE_COLSONLY = 1024
SCALE_CURTISREID = 7
SCALE_DYNUPDATE = 256
SCALE_EQUILIBRATE = 64
SCALE_EXTREME = 1
SCALE_GEOMETRIC = 4
SCALE_INTEGERS = 128
SCALE_LOGARITHMIC = 16
SCALE_MEAN = 3
SCALE_NONE = 0
SCALE_POWER2 = 32
SCALE_QUADRATIC = 8
SCALE_RANGE = 2
SCALE_ROWSONLY = 512
SCALE_USERWEIGHT = 31
SEVERE = 2
SIMPLEX_DUAL_DUAL = 10
SIMPLEX_DUAL_PRIMAL = 6
SIMPLEX_PRIMAL_DUAL = 9
SIMPLEX_PRIMAL_PRIMAL = 5
SUBOPTIMAL = 1
TIMEOUT = 7
UNBOUNDED = 3
USERABORT = 6
(Note that you can execute this example by entering command per command as shown below or by executing script example1. This will execute example1.py.)
>>> from lpsolve55 import *
>>> lp = lpsolve('make_lp', 0, 4)
>>> lpsolve('set_verbose', lp, IMPORTANT)
>>> ret = lpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1])
>>> ret = lpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], GE, 92.3)
>>> ret = lpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], LE, 14.8)
>>> ret = lpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], GE, 4)
>>> ret = lpsolve('set_lowbo', lp, 1, 28.6)
>>> ret = lpsolve('set_lowbo', lp, 4, 18)
>>> ret = lpsolve('set_upbo', lp, 4, 48.98)
>>> ret = lpsolve('set_col_name', lp, 1, 'COLONE')
>>> ret = lpsolve('set_col_name', lp, 2, 'COLTWO')
>>> ret = lpsolve('set_col_name', lp, 3, 'COLTHREE')
>>> ret = lpsolve('set_col_name', lp, 4, 'COLFOUR')
>>> ret = lpsolve('set_row_name', lp, 1, 'THISROW')
>>> ret = lpsolve('set_row_name', lp, 2, 'THATROW')
>>> ret = lpsolve('set_row_name', lp, 3, 'LASTROW')
>>> ret = lpsolve('write_lp', lp, 'a.lp')
>>> print lpsolve('get_mat', lp, 1, 2)
78.26
>>> lpsolve('solve', lp)
0L
>>> print lpsolve('get_objective', lp)
31.7827586207
>>> print lpsolve('get_variables', lp)[0]
[28.600000000000001, 0.0, 0.0, 31.827586206896552]
>>> print lpsolve('get_constraints', lp)[0]
[92.299999999999997, 6.863999999999999, 391.2928275862069]
Note that there are commands that return an answer. If they do and their result is not stored in a variable, then it is echoed on screen. If assigned to a variable then the value is not echoed. For example:
>>> obj = lpsolve('get_objective', lp)
The result in then not shown on screen. But the contents of the variable can be printed:
>>> print obj 31.7827586207
Or even:
>>> obj 31.782758620689656
Note that get_variables and get_constraints return two results: The result vector and a status. If only the vector is needed, then [0] can be used as in the example. Or the result can be stored in an extra variables:
>>> [x, ret] = lpsolve('get_variables', lp)
Variable x will contain the result vector and ret the return status of the call.
Note that if this is stored only in one variable that you get the following:
>>> x = lpsolve('get_variables', lp)
>>> print x
[[28.600000000000001, 0.0, 0.0, 31.827586206896552], 1L]
Don't forget to free the handle and its associated memory when you are done:
>>> lpsolve('delete_lp', lp)
Note that there is another way to access the lpsolve library. It is more object oriented, but requires more typing:
>>> import lpsolve55
>>> lp = lpsolve55.lpsolve('make_lp', 0, 4)
>>> lpsolve55.lpsolve('set_verbose', lp, lpsolve55.IMPORTANT)
.
.
.
>>> lpsolve55.lpsolve('delete_lp', lp)
This technique will not be used in this description because the lpsolve library is not really object oriented structured. But if you prefer it, there is nothing that should stop you. The only difference is that you have to put lpsolve55. before every lpsolve function and constant.
>>> from lpsolve55 import *
>>> lp = lpsolve('make_lp', 0, 4)
>>> ret = lpsolve('set_lp_name', lp, 'mymodel')
>>> lpsolve('set_verbose', 'mymodel', IMPORTANT)
>>> ret = lpsolve('set_obj_fn', 'mymodel', [1, 3, 6.24, 0.1])
>>> ret = lpsolve('add_constraint', 'mymodel', [0, 78.26, 0, 2.9], GE, 92.3)
>>> ret = lpsolve('add_constraint', 'mymodel', [0.24, 0, 11.31, 0], LE, 14.8)
>>> ret = lpsolve('add_constraint', 'mymodel', [12.68, 0, 0.08, 0.9], GE, 4)
>>> ret = lpsolve('set_lowbo', 'mymodel', 1, 28.6)
>>> ret = lpsolve('set_lowbo', 'mymodel', 4, 18)
>>> ret = lpsolve('set_upbo', 'mymodel', 4, 48.98)
>>> ret = lpsolve('set_col_name', 'mymodel', 1, 'COLONE')
>>> ret = lpsolve('set_col_name', 'mymodel', 2, 'COLTWO')
>>> ret = lpsolve('set_col_name', 'mymodel', 3, 'COLTHREE')
>>> ret = lpsolve('set_col_name', 'mymodel', 4, 'COLFOUR')
>>> ret = lpsolve('set_row_name', 'mymodel', 1, 'THISROW')
>>> ret = lpsolve('set_row_name', 'mymodel', 2, 'THATROW')
>>> ret = lpsolve('set_row_name', 'mymodel', 3, 'LASTROW')
>>> ret = lpsolve('write_lp', 'mymodel', 'a.lp')
>>> print lpsolve('get_mat', 'mymodel', 1, 2)
78.26
>>> lpsolve('solve', 'mymodel')
0L
>>> print lpsolve('get_objective', 'mymodel')
31.7827586207
>>> print lpsolve('get_variables', 'mymodel')[0]
[28.600000000000001, 0.0, 0.0, 31.827586206896552]
>>> print lpsolve('get_constraints', 'mymodel')[0]
[92.299999999999997, 6.863999999999999, 391.2928275862069]
So everywhere a handle is needed, you can also use the model name. You can even mix the two methods.
There is also a specific Python routine to get the handle from the model name: get_handle.
For example:
>>> lp = lpsolve('get_handle', 'mymodel')
>>> print lp
0
Don't forget to free the handle and its associated memory when you are done:
>>> lpsolve('delete_lp', 'mymodel')
In the next part of this documentation, the handle is used. But if you name the model, the name could thus also be used.
>>> lpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8)
[0.24, 0, 11.31, 0] is a list type variable.
Most of the time, variables are used to provide the data:
>>> lpsolve('add_constraint', lp, a1, 1, 14.8)
Where a1 is a variable of type list. Sometimes a two-dimensional matrix is used:
>>> lpsolve('set_mat', lp, [[1, 2, 3], [4, 5, 6]])
[1, 2, 3] is the first row and [4, 5, 6] is the second row.
The lpsolve driver sees all provided matrices as sparse matrices. lpsolve uses sparse matrices internally and data can be provided sparse via the ex routines. For example add_constraintex. The lpsolve driver always uses the ex routines to provide the data to lpsolve. Even if you call from Python the routine names that would require a dense matrix (for example add_constraint), the lpsolve driver will always call the sparse version of the routine (for example add_constraintex). This results in the most performing behaviour. Matrices with too few or too much elements gives an 'invalid vector.' error.
An important final note. Several lp_solve API routines accept a vector where the first element (element 0) is not used. Other lp_solve API calls do use the first element. In the Python interface, there is never an unused element in the matrices. So if the lp_solve API specifies that the first element is not used, then this element is not in the Python matrix.
Because Python has the list possibility to represent vectors, all lpsolve API routines that need a column or row number to get/set information for that
column/row are extended in the lpsolve Python driver to also work with vectors. For example set_int in the API can
only set the integer status for one column. If the status for several integer variables must be set, then set_int
must be called multiple times. The lpsolve Python driver however also allows specifying a vector to set the integer
status of all variables at once. The API call is: return = lpsolve('set_int', lp, column, must_be_int). The
matrix version of this call is: return = lpsolve('set_int', lp, [must_be_int]).
The API call to return the integer status of a variable is: return = lpsolve('is_int', lp, column). The
matrix version of this call is: [is_int] = lpsolve('is_int', lp)
Also note the get_mat and set_mat routines. In Python these are extended to return/set the complete constraint matrix.
See following example.
Above example can thus also be done as follows:
(Note that you can execute this example by entering command per command as shown below or by executing script example2.
This will execute example2.py.)
>>> lp = lpsolve('make_lp', 0, 4)
>>> lpsolve('set_verbose', lp, IMPORTANT)
>>> ret = lpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1])
>>> ret = lpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], GE, 92.3)
>>> ret = lpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], LE, 14.8)
>>> ret = lpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], GE, 4)
>>> ret = lpsolve('set_lowbo', lp, [28.6, 0, 0, 18])
>>> ret = lpsolve('set_upbo', lp, [Infinite, Infinite, Infinite, 48.98])
>>> ret = lpsolve('set_col_name', lp, ['COLONE', 'COLTWO', 'COLTHREE', 'COLFOUR'])
>>> ret = lpsolve('set_row_name', lp, ['THISROW', 'THATROW', 'LASTROW'])
>>> ret = lpsolve('write_lp', lp, 'a.lp')
>>> print lpsolve('get_mat', lp)[0]
[[0.0, 78.26, 0.0, 2.9], [0.24, 0.0, 11.31, 0.0], [12.68, 0.0, 0.08, 0.9]]
>>> lpsolve('solve', lp)
0L
>>> print lpsolve('get_objective', lp)
31.7827586207
>>> print lpsolve('get_variables', lp)[0]
[28.600000000000001, 0.0, 0.0, 31.827586206896552]
>>> print lpsolve('get_constraints', lp)[0]
[92.299999999999997, 6.8639999999999999, 391.29282758620695]
Note the usage of Infinite in set_upbo. This stands for 'infinity'. Meaning an infinite upper bound. It is also possible to use -Infinite to express minus infinity. This can for example be used to create a free variable. Infinite is a constant defined by the lpsolve library.
To show the full power of the matrices, let's now do some matrix calculations to check the solution. It works further on above example. Note that Python doesn't support matrix calculations on lists. However, there are several numerical packages that can do this. The list type variables must be converted to the matrix types of these packages. A common known package for this is Numeric. It is not installed by default but can be easily installed. See http://sourceforge.net/project/showfiles.php?group_id=1369&package_id=1351. There are newer packages like SciPy: http://sourceforge.net/project/showfiles.php?group_id=1369&package_id=6222. See http://numeric.scipy.org/ for a brief overview. This documentation works with Numeric to do the math calculations.
>>> from Numeric import *
>>> A = array(lpsolve('get_mat', lp)[0])
>>> A
array([[ 0. , 78.26, 0. , 2.9 ],
[ 0.24, 0. , 11.31, 0. ],
[ 12.68, 0. , 0.08, 0.9 ]])
>>> X = array(lpsolve('get_variables', lp)[0])
>>> X
array([ 28.6 , 0. , 0. , 31.82758621])
>>> B = matrixmultiply(A, X)
>>> B
array([ 92.3 , 6.864 , 391.29282759])
We even don't have to explicitly convert the lists to matrices:
>>> from Numeric import *
>>> a = lpsolve('get_mat', lp)[0]
>>> a
[[0.0, 78.26, 0.0, 2.9], [0.24, 0.0, 11.31, 0.0], [12.681, 0.0, 0.018, 0.9]]
>>> x = lpsolve('get_variables', lp)[0]
>>> x
[28.600000000000001, 0.0, 0.0, 31.827586206896552]
>>> B = matrixmultiply(a, x)
>>> B
array([ 92.3 , 6.864 , 391.29282759])
matrixmultiply returns not a list, but a Numeric array object. If the result is needed again in a list, then this can be easily done:
>>> b = list(B) >>> b [92.299999999999997, 6.8639999999999999, 391.29282758620695]
So what we have done here is calculate the values of the constraints (RHS) by multiplying the constraint matrix with the solution vector. Now take a look at the values of the constraints that lpsolve has found:
>>> lpsolve('get_constraints', lp)[0]
[92.299999999999997, 6.8639999999999999, 391.29282758620695]
Exactly the same as the calculated B vector, as expected.
Also the value of the objective can be calculated in a same way:
>>> c = lpsolve('get_obj_fn', lp)[0]
>>> x = lpsolve('get_variables', lp)[0]
>>> obj = matrixmultiply(c, x)
>>> obj
31.782758620689656
So what we have done here is calculate the value of the objective by multiplying the objective vector with the solution vector. Now take a look at the value of the objective that lpsolve has found:
>>> lpsolve('get_objective', lp)
31.782758620689656
Again exactly the same as the calculated obj value, as expected.
Python can execute a sequence of statements stored in diskfiles. Such files are called Python scripts and should have the file type of ".py" as the last part of their filename (extension).
You can put Python commands in them and execute them at any time. The Python script is executed either via the command python script.py. The script files contain plain ascii data.
The lpsolve Python distribution contains some example script to demonstrate this.
Contains the commands as shown in the first example of this article.
Contains the commands as shown in the second example of this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
Contains the commands of a practical example. See further in this article.
This script uses the API to create a higher-level function called lp_solve. This function accepts as arguments some matrices and options to create and solve an lp model. Type help(lp_solve) or just lp_solve() to see its usage:
LP_SOLVE Solves mixed integer linear programming problems.
SYNOPSIS: [obj,x,duals] = lp_solve(f,a,b,e,vlb,vub,xint,scalemode,keep)
solves the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) = -1 ==> Less Than
e(i) = 0 ==> Equals
e(i) = 1 ==> Greater Than
vlb: n vector of lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: scale flag. Off when 0 or omitted.
keep: Flag for keeping the lp problem after it's been solved.
If omitted, the lp will be deleted when solved.
OUTPUT: A nonempty output is returned if a solution is found:
obj: Optimal value of the objective function.
x: Optimal value of the decision variables.
duals: solution of the dual problem.
Example of usage. To create and solve following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
>>> from lp_solve import * >>> [obj, x, duals] = lp_solve([-1, 2], [[2, 1], [-4, 4]], [5, 5], [-1, -1], None, None, [1, 2]) >>> print obj 3.0 >>> print x [1.0, 2.0]
This script is analog to the lp_solve script and also uses the API to create a higher-level function called lp_maker. This function accepts as arguments some matrices and options to create an lp model. Note that this scripts only creates a model and returns a handle. Type help(lp_maker) or just lp_maker() to see its usage:
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: Autoscale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Example of usage. To create following lp-model:
max: -x1 + 2 x2; C1: 2x1 + x2 < 5; -4 x1 + 4 x2 <5; int x2,x1;
The following command can be used:
>>> from lp_maker import * >>> lp = lp_maker([-1, 2], [[2, 1], [-4, 4]], [5, 5], [-1, -1], None, None, [1, 2]) >>> lp 0L
To solve the model and get the solution:
>>> lpsolve('solve', lp)
0L
>>> lpsolve('get_objective', lp)
3.0
>>> lpsolve('get_variables', lp)[0]
[1.0, 2.0]
Don't forget to free the handle and its associated memory when you are done:
>>> lpsolve('delete_lp', lp)
Contains several examples to build and solve lp models.
Contains several examples to build and solve lp models. Also solves the lp_examples from the lp_solve distribution.
We shall illustrate the method of linear programming by means of a simple example, giving a combination graphical/numerical solution, and then solve both a slightly as well as a substantially more complicated problem.
Suppose a farmer has 75 acres on which to plant two crops: wheat and barley. To produce these crops, it costs the farmer (for seed, fertilizer, etc.) $120 per acre for the wheat and $210 per acre for the barley. The farmer has $15000 available for expenses. But after the harvest, the farmer must store the crops while awaiting favourable market conditions. The farmer has storage space for 4000 bushels. Each acre yields an average of 110 bushels of wheat or 30 bushels of barley. If the net profit per bushel of wheat (after all expenses have been subtracted) is $1.30 and for barley is $2.00, how should the farmer plant the 75 acres to maximize profit?
We begin by formulating the problem mathematically. First we express the objective, that is the profit, and the constraints algebraically, then we graph them, and lastly we arrive at the solution by graphical inspection and a minor arithmetic calculation.
Let x denote the number of acres allotted to wheat and y the number of acres allotted to barley. Then the expression to be maximized, that is the profit, is clearly
P = (110)(1.30)x + (30)(2.00)y = 143x + 60y.
There are three constraint inequalities, specified by the limits on expenses, storage and acreage. They are respectively:
120x + 210y <= 15000
110x + 30y <= 4000
x + y <= 75
Strictly speaking there are two more constraint inequalities forced by the fact that the farmer cannot plant a negative number of acres, namely:
x >= 0, y >= 0.
Next we graph the regions specified by the constraints. The last two say that we only need to consider the first quadrant in the x-y plane. Here's a graph delineating the triangular region in the first quadrant determined by the first inequality.
Now let's put in the other two constraint inequalities.
The black area is the solution space that holds valid solutions. This means that any point in this area fulfils the constraints.
Now let's superimpose on top of this picture a contour plot of the objective function P.
The lines give a picture of the objective function. All solutions that intersect with the black area are valid solutions, meaning that this result also fulfils the set constraints. The more the lines go to the right, the higher the objective value is. The optimal solution or best objective is a line that is still in the black area, but with an as large as possible value.
It seems apparent that the maximum value of P will occur on the level curve (that is, level
line) that passes through the vertex of the polygon that lies near (22,53).
It is the intersection of x + y = 75 and 110*x + 30*y = 4000
This is a corner point of the diagram. This is not a coincidence. The simplex algorithm, which is used
by lpsolve, starts from a theorem that the optimal solution is such a corner point.
In fact we can compute the result:
>>> from Numeric import * >>> from LinearAlgebra import * >>> x = matrixmultiply(inverse(array([[1, 1], [110, 30]])), array([75, 4000])) >>> print x [ 21.875 53.125]
The acreage that results in the maximum profit is 21.875 for wheat and 53.125 for barley. In that case the profit is:
>>> P = matrixmultiply(array([143, 60]), x) >>> print P 6315.625
That is, $6315.625.
Note that these command are in script example3.py
Now, lp_solve comes into the picture to solve this linear programming problem more generally. After that we will use it to solve two more complicated problems involving more variables and constraints.
For this example, we use the higher-level script lp_maker to build the model and then some lp_solve API calls to retrieve the solution. Here is again the usage of lp_maker:
LP_MAKER Makes mixed integer linear programming problems.
SYNOPSIS: lp_handle = lp_maker(f,a,b,e,vlb,vub,xint,scalemode,setminim)
make the MILP problem
max v = f'*x
a*x <> b
vlb <= x <= vub
x(int) are integer
ARGUMENTS: The first four arguments are required:
f: n vector of coefficients for a linear objective function.
a: m by n matrix representing linear constraints.
b: m vector of right sides for the inequality constraints.
e: m vector that determines the sense of the inequalities:
e(i) < 0 ==> Less Than
e(i) = 0 ==> Equals
e(i) > 0 ==> Greater Than
vlb: n vector of non-negative lower bounds. If empty or omitted,
then the lower bounds are set to zero.
vub: n vector of upper bounds. May be omitted or empty.
xint: vector of integer variables. May be omitted or empty.
scalemode: Autoscale flag. Off when 0 or omitted.
setminim: Set maximum lp when this flag equals 0 or omitted.
OUTPUT: lp_handle is an integer handle to the lp created.
Now let's formulate this model with lp_solve:
>>> from lp_maker import *
>>> f = [143, 60]
>>> A = [[120, 210], [110, 30], [1, 1]]
>>> b = [15000, 4000, 75]
>>> lp = lp_maker(f, A, b, [-1, -1, -1], None, None, None, 1, 0)
>>> solvestat = lpsolve('solve', lp)
>>> obj = lpsolve('get_objective', lp)
>>> print obj
6315.625
>>> x = lpsolve('get_variables', lp)[0]
>>> print x
[21.874999999999993, 53.125000000000007]
>>> lpsolve('delete_lp', lp)
Note that these command are in script example4.py
With the higher-level script lp_maker, we provide all data to lp_solve. lp_solve returns a handle (lp) to the created model. Then the API call 'solve' is used to calculate the optimal solution of the model. The value of the objective function is retrieved via the API call 'get_objective' and the values of the variables are retrieved via the API call 'get_variables'. At last, the model is removed from memory via a call to 'delete_lp'. Don't forget this to free all memory allocated by lp_solve.
The solution is the same answer we obtained before. Note that the non-negativity constraints are accounted implicitly because variables are by default non-negative in lp_solve.
Well, we could have done this problem by hand (as shown in the introduction) because it is very small and it
can be graphically presented.
Now suppose that the farmer is dealing with a third crop, say corn, and that the corresponding data is:
cost per acre $150.75 yield per acre 125 bushels profit per bushel $1.56
With three variables it is already a lot more difficult to show this model graphically. Adding more variables makes it even impossible because we can't imagine anymore how to represent this. We only have a practical understanding of 3 dimensions, but beyond that it is all very theoretical.
If we denote the number of acres allotted to corn by z, then the objective function becomes:
P = (110)(1.30)x + (30)(2.00)y + (125)(1.56) = 143x + 60y + 195z
And the constraint inequalities are:
120x + 210y + 150.75z <= 15000
110x + 30y + 125z <= 4000
x + y + z <= 75
x >= 0, y >= 0, z >= 0
The problem is solved with lp_solve as follows:
>>> from lp_maker import *
>>> f = [143, 60, 195]
>>> A = [[120, 210, 150.75], [110, 30, 125], [1, 1, 1]]
>>> b = [15000, 4000, 75]
>>> lp = lp_maker(f, A, b, [-1, -1, -1], None, None, None, 1, 0)
>>> solvestat = lpsolve('solve', lp)
>>> obj = lpsolve('get_objective', lp)
>>> print obj
6986.84210526
>>> x = lpsolve('get_variables', lp)[0]
>>> print x
[0.0, 56.578947368421055, 18.421052631578945]
>>> lpsolve('delete_lp', lp)
Note that these command are in script example5.py
So the farmer should ditch the wheat and plant 56.5789 acres of barley and 18.4211 acres of corn.
There is no practical limit on the number of variables and constraints that Python can handle. Certainly none that the relatively unsophisticated user will encounter. Indeed, in many true applications of the technique of linear programming, one needs to deal with many variables and constraints. The solution of such a problem by hand is not feasible, and software like Python is crucial to success. For example, in the farming problem with which we have been working, one could have more crops than two or three. Think agribusiness instead of family farmer. And one could have constraints that arise from other things beside expenses, storage and acreage limitations. For example:
Below is a sequence of commands that solves exactly such a problem. You should be able to recognize the objective expression and the constraints from the data that is entered. But as an aid, you might answer the following questions:
>>> from lpsolve55 import *
>>> from lp_maker import *
>>> f = [110*1.3, 30*2.0, 125*1.56, 75*1.8, 95*.95, 100*2.25, 50*1.35]
>>> A = [[120, 210, 150.75, 115, 186, 140, 85], [110, 30, 125, 75, 95, 100, 50], [1, 1, 1, 1, 1, 1, 1],
[1, -1, 0, 0, 0, 0, 0], [0, 0, 1, 0, -2, 0, 0], [0, 0, 0, -1, 0, -1, 1]]
>>> b = [55000, 40000, 400, 0, 0, 0]
>>> lp = lp_maker(f, A, b, [-1, -1, -1, -1, -1, -1], [10, 10, 10, 10, 20, 20, 20],
[100, Infinite, 50, Infinite, Infinite, 250, Infinite], None, 1, 0)
>>> solvestat = lpsolve('solve', lp)
>>> obj = lpsolve('get_objective', lp)
>>> print obj
75398.0434783
>>> x = lpsolve('get_variables', lp)[0]
>>> print x
[10.0, 10.0, 40.0, 45.652173913043455, 20.0, 250.0, 20.0]
>>> lpsolve('delete_lp', lp)
Note that these command are in script example6.py
Note that we have used in this formulation the vlb and vub arguments of lp_maker. This to set lower and upper bounds on variables. This could have been done via extra constraints, but it is more performant to set bounds on variables. Also note that Infinity is used for variables that have no upper limit.
Note that despite the complexity of the problem, lp_solve solves it almost instantaneously. It seems the farmer should bet the farm on crop number 6. We strongly suggest you alter the expense and/or the storage limit in the problem and see what effect that has on the answer.
Suppose we want to solve the following linear program using Python:
max 4x1 + 2x2 + x3
s. t. 2x1 + x2 <= 1
x1 + 2x3 <= 2
x1 + x2 + x3 = 1
x1 >= 0
x1 <= 1
x2 >= 0
x2 <= 1
x3 >= 0
x3 <= 2
Convert the LP into Python format we get:
f = [4, 2, 1]
A = [[2, 1, 0], [1, 0, 2], [1, 1, 1]]
b = [1, 2, 1]
Note that constraints on single variables are not put in the constraint matrix. lp_solve can set bounds on individual variables and this is more performant than creating additional constraints. These bounds are:
l = [ 0, 0, 0]
u = [ 1, 1, 2]
Now lets enter this in Python:
>>> f = [4, 2, 1] >>> A = [[2, 1, 0], [1, 0, 2], [1, 1, 1]] >>> b = [1, 2, 1] >>> l = [ 0, 0, 0] >>> u = [ 1, 1, 2]
Now solve the linear program using Python: Type the commands
>>> from lpsolve55 import *
>>> from lp_maker import *
>>> lp = lp_maker(f, A, b, [-1, -1, -1], l, u, None, 1, 0)
>>> solvestat = lpsolve('solve', lp)
>>> obj = lpsolve('get_objective', lp)
>>> print obj
2.5
>>> x = lpsolve('get_variables', lp)[0]
>>> print x
[0.5, 0.0, 0.5]
>>> lpsolve('delete_lp', lp)
What to do when some of the variables are missing ?
For example, suppose there are no lower bounds on the variables. In this case define l to be the empty set using the Python command:
>>> l = None
This has the same effect as before, because lp_solve has as default lower bound for variables 0.
But what if you want that variables may also become negative?
Then you can use -Infinite as lower bounds:
>>> l = [-Infinite, -Infinite, -Infinite]
Solve this and you get a different result:
>>> lp = lp_maker(f, A, b, [-1, -1, -1], l, u, None, 1, 0)
>>> solvestat = lpsolve('solve', lp)
>>> obj = lpsolve('get_objective', lp)
>>> print obj
2.66666666667
>>> x = lpsolve('get_variables', lp)[0]
>>> print x
[0.66666666666666674, -0.33333333333333348, 0.66666666666666674]
>>> lpsolve('delete_lp', lp)
Note that everwhere where lp is used as argument that this can be a handle (lp) or the models name.
These routines are not part of the lpsolve API, but are added for backwards compatibility. Most of them exist in the lpsolve API with another name.
The lpsolve Python driver is called lpsolve55.pyd (windows) and lpsolve55.so (Unix).
This driver is an interface to the lpsolve55.dll (windows) and liblpsolve55.so (Unix) lpsolve shared library that contains the implementation of lp_solve.
lpsolve55.dll/liblpsolve55.so is distributed with the lp_solve package (archive lp_solve_5.5.0.13_dev.zip/lp_solve_5.5.0.13_dev.tar.gz). The lpsolve Python driver is just
a wrapper between Python and lp_solve to translate the input/output to/from Python and the lp_solve library.
The lpsolve Python driver is written in C. To compile this code a C compiler is needed.
Under Unix, this is the standard C compiler (c/gcc) and under windows it is the Microsoft compiler from Visual Studio .NET.
This compiler must be called from Python. To make the compilation process easier, a Python script can be used:
setup.py
To compile and install the package, just enter the following in a command prompt/shell:
python setup.py install
and everything is done.
Under Windows, there is an installer that installs the Python lpsolve driver and the supporting scripts lp_maker.py
and lp_solve.py. Just run lpsolve55-5.5.0.5.win32-py2.4.exe (this installer is in archive lp_solve_5.5_Python_exe.zip).
On other platforms, the lpsolve driver must be compiled as described in the previous section: Compile the lpsolve driver
Don't forget that lpsolve55.dll (Windows) or liblpsolve55.so (Unix/Linux) is also needed for this (In archive lp_solve_5.5.0.13_dev.zip).
See also Using lpsolve from MATLAB, Using lpsolve from O-Matrix, Using lpsolve from Scilab, Using lpsolve from Octave, Using lpsolve from R
docs/5.5/put_msgfunc.htm 0000644 0001750 0001750 00000010407 11306036626 014032 0 ustar rene rene
put_msgfuncSets a message routine. void put_msgfunc(lprec *lp, lphandleint_func newmsg, void *msghandle, int mask); Return Value put_msgfunc has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI newmsg The message routine. msghandle A parameter that will be provided to the message routine. mask Any combination of the following values:
Remarks The put_msgfunc function sets a message routine. This routine is called when a situation specified in mask occurs. Note that this routine is called while solving the model. This can be useful to follow the solving progress. Example See Also make_lp, copy_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, put_abortfunc |
is_anti_degenReturns if the degeneracy rule specified in testmask is active. unsigned char is_anti_degen(lprec *lp, int testmask); Return Value is_anti_degen returns TRUE or FALSE. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI testmask
Remarks The is_anti_degen function returns a flag if the degeneracy rule specified in testmask is active. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_anti_degen, get_anti_degen |
print_dualsPrints the values of the duals of the lp. void print_duals(lprec *lp); Return Value print_duals has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks
The print_duals function prints the values of the duals of the lp. This
can only be done after a successful solve. Example See Also delete_lp, free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex, print_lp, print_objective, print_solution, print_constraints, print_scales, print_tableau, print_str, set_outputstream, set_outputfile, print_debugdump |
set_row_nameSet the name of a constraint (row) in the lp. unsigned char set_row_name(lprec *lp, int row, char *new_name); Return Value set_row_name returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI row The row for which the name must be set. Must be between 0 and the number of rows in the lp. new_name The name for the row. Remarks The set_row_name sets the name of the row. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_row_name, get_origrow_name, set_col_name, get_col_name, get_origcol_name, get_nameindex |
set_obj_fn, set_obj_fnex, str_set_obj_fn, set_objSet the objective function (row 0) of the matrix. unsigned char set_obj_fn(lprec *lp, REAL *row); unsigned char set_obj_fnex(lprec *lp, int count, REAL *row, int *colno); unsigned char str_set_obj_fn(lprec *lp, char *row_string); unsigned char set_obj(lprec *lp, int column, REAL value); Return Value set_obj_fn, set_obj_fnex, str_set_obj_fn and set_obj return TRUE (1) if the operation was successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI count Number of elements in row and colno. row An array with 1+get_Ncolumns (count for set_obj_fnex) elements that contains the values of the objective function. colno An array with count elements that contains the column numbers of the row. However this variable can also be NULL. In that case element i in the variable row is column i. row_string A string with column elements that contains the values of the objective function. Each element must be separated by space(s). column The column number for which the value must be set. value The value that must be set. Remarks
The set_obj_fn, set_obj_fnex, str_set_obj_fn functions set all values of the
objective function at once. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_constraint, add_constraintex, str_add_constraint, set_row, set_rowex, add_column, add_columnex, str_add_column, set_column, set_columnex, get_column, get_columnex, get_row, get_rowex, get_mat |
del_constraintRemove a constraint from the lp. unsigned char del_constraint(lprec *lp, int del_row); Return Value del_constraint returns TRUE (1) if the operation was successful. A
return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI del_row The row to delete. Must be between 1 and the number of rows in the lp. Remarks The del_constraint function deletes a row from the model. The row is
effectively deleted, so all rows after this row shift one up. Example See Also resize_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, add_constraint, add_constraintex, str_add_constraint |
set_outputstream, set_outputfileDefines the output when lp_solve has something to report. void set_outputstream(lprec *lp, FILE *stream); unsigned char set_outputfile(lprec *lp, char *filename); Return Value set_outputstream has no return value. set_outputfile returns TRUE (1) if the file could be opened, else FALSE (0).Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI stream The stream to print the results to. If NULL, then output is stdout again. filename The file to print the results to. If NULL, then output is stdout again. If "", then output is ignored. It doesn't go to the console or to a file then. This is usefull in combination with put_logfunc to redirect output to somewhere completely different. Remarks
The set_outputstream, set_outputfile functions define the output
when lp_solve has something to report. Example See Also delete_lp, free_lp, make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, put_logfunc, print_lp, print_objective, print_solution, print_constraints, print_duals, print_scales, print_tableau, print_str, print_debugdump, write_lp, write_LP, write_mps, write_freemps, write_MPS, write_freeMPS, write_basis |
put_bb_nodefuncAllows to set a user function that specifies which non-integer variable to select next to make integer in the B&B solve. void put_bb_nodefunc(lprec *lp, lphandleint_intfunc newnode, void *bbnodehandle); Return Value put_bb_nodefunc has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI newnode The node selection routine. bb_nodehandle A parameter that will be provided to the node selection routine. Remarks Allows to set a user function that specifies which non-integer variable to select next to make integer in the B&B solve. Via this routine the user can implement his own rule to select the next non-integer variable to make integer. This overrules the setting of set_bb_rule. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_bb_rule |
SensitivitySensitivity or post-optimal analysis is extra information that is provided about the current optimal solution. lp_solve provides a substantial amount of sensitivity information. Several API calls are available to retrieve the sensitivity: get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult. The lp_solve program doesn't show the sensitivity by default. So to see the sensitivity information, use the -S4 option. The best way to explain this is via an example. min: +COLONE +3 COLTWO +6.24 COLTHREE +0.1 COLFOUR; THISROW: +78.26 COLTWO +2.9 COLFOUR >= 92.3; THATROW: +0.24 COLONE +11.31 COLTHREE <= 14.8; LASTROW: +12.68 COLONE +0.08 COLTHREE +0.9 COLFOUR >= 4; COLONE >= 28.6; COLFOUR >= 18.00; COLFOUR <= 48.98; The solution of this model is (with the -S4 option):
Value of objective function: 31.7828
Actual values of the variables:
COLONE 28.6
COLTWO 0
COLTHREE 0
COLFOUR 31.8276
Actual values of the constraints:
THISROW 92.3
THATROW 6.864
LASTROW 391.293
Objective function limits:
From Till FromValue
COLONE 0 1e+030 -1e+030
COLTWO 2.698621 1e+030 0.5123946
COLTHREE 0 1e+030 0.7016799
COLFOUR 0 0.1111679 -1e+030
Dual values with from - till limits:
Dual value From Till
THISROW 0.03448276 52.2 142.042
THATROW 0 -1e+030 1e+030
LASTROW 0 -1e+030 1e+030
COLONE 1 -1.943598 61.66667
COLTWO 0.3013793 -0.6355993 0.5123946
COLTHREE 6.24 -4841.16 0.7016799
COLFOUR 0 -1e+030 1e+030
First look at 'Objective function limits' (via API obtained by get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex). There is a list of all variables with for each variable 3 values. From, Till and FromValue. From - Till gives the limits where between the objective value may vary so that the solution stays the same. For example, variable COLFOUR has a From value of 0 and a Till value of 0.1111679. The coefficient in the objective function of this variable is 0.1. This means that as this coefficient varies between 0 and 0.1111679, the solution doesn't change. The values for the variables and the constraints will remain unchanged as long as the objective coefficient stays in this range. The objective function value will vary of course and also the sensitivity information of the other variables, but the solution will stay the same if only the objective coefficient value for this variable is changed. When the objective coefficient of variable COLFOUR is above 0.1111679 then the solution will change. The FromValue is only meaningful if the variable has a value of 0 (rejected). This is the value that this variable becomes when the From (minimization) or Till (maximization) value is reached. For example, the variable COLTWO that has an amount of 0 will become 0.5123946 if the coefficient in the objective function of COLTWO reaches 2.698621. Note that you only get information about this variable. There is no information what the values will be of the other variables. In a blending example where the coefficients of the objective function are generally the prices of ingredients this information tells you at what point a price may change to have the same composition and the FromValue says at what value a relected ingredient will be taken when the price lowers till the lower range value. Another piece of information are the Dual values with the from - till limits. This is provided for both the constraints and the variables. The information is the same for both. For example, constraint THISROW has a dual value of 0.03448276 with a From value of 52.2 and a Till value of 142.042. This means that the Dual value specifies how much the objective function will vary if the constraint value is incremented by one unit. This implies that there is only a non-zero dual value if the constraint is active. Constraint THATROW for example is not active because the constraint is <= 14.8, but its value is only 6.864. However constraint THISROW is >= 92.3 and its value is also 92.3, thus active. If the constraint is changed to 93.3 (+1), then the objective value will be the current value + change * dual value = 31.7828 + 1 * 0.03448276 = 31.81728. However this is only true for the range From - Till, which means that the dual value stays only the same as long as the constraint lies between the From - Till limits. The moment that you are outside of these limits, the dual value will change. The dual value gives a very good indication how much this restriction costs. If the dual value is very high then this constraint is very influential on the objective function and if you are able to change it a bit then the solution will be much better. Also the sign of the dual value has a meaning. A positive value means that as the restriction becomes larger, the objective value will be larger, and as it becomes more negative, the objective value will be smaller. Also note that changes in the restrictions, even between the limits, can cause the solution to change. The from - till limits only say that the cost will remain the same, nothing less, nothing more. Inaccurate sensitivity analysis in a model with integer variablesThe sensitivity analysis doesn't take the integer restrictions in account. This is almost impossible since it would ask too much calculation time. In particular the from - till limits on both the objective function and the dual values are trustworthy. They only apply for the current solution without the integer restrictions. Keep this in mind. The dual values are correct. |
get_negrangeReturns the negative value below which variables are split into a negative and a positive part. REAL get_negrange(lprec *lp); Return Value get_negrange returns the negative value below which variables are split
into a negative and a positive part. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI RemarksThe get_negrange function returns the negative value below which
variables are split into a negative and a positive part. This value is always
zero or negative. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_negrange |
set_semicontSet the type of the variable. semi-continuous or not. unsigned char set_semicont(lprec *lp, int column, unsigned char must_be_sc); Return Value set_semicont returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI column The column number of the variable that must be set. It must be between 1 and the number of columns in the lp. must_be_sc TRUE (1) if the variable must be semi-continuous, FALSE (0) if not. Remarks The set_semicont function defines if a variable is semi-continuous
or not. By default, a variable is not semi-continuous. The argument must_be_sc
defines what the status of the variable becomes. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_semicont, set_lowbo |
set_mip_gapSpecifies the MIP gap value. void set_mip_gap(lprec *lp, unsigned char absolute, REAL mip_gap); Return Value set_mip_gap has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI absolute If TRUE then the absolute MIP gap is set, else the relative MIP gap mip_gap The MIP gap. Remarks The set_mip_gap function sets the MIP gap that specifies a tolerance for
the branch and bound algorithm. This tolerance is the difference between the
best-found solution yet and the current solution. If the difference is smaller
than this tolerance then the solution (and all the sub-solutions) is rejected.
This can result in faster solving times, but results in a solution which is not
the perfect solution. So be careful with this tolerance. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_mip_gap, get_epsd, set_epsd, set_infinite, get_infinite, is_infinite, set_epsint, get_epsint, set_epsb, get_epsb, set_epsel, get_epsel, get_epspivot, set_epspivot, set_epsperturb, get_epsperturb |
is_debugReturns a flag if all intermediate results and the branch-and-bound decisions must be printed while solving. unsigned char is_debug(lprec *lp); Return Value is_debug returns TRUE or FALSE. Debug or do not debug. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The is_debug function returns a flag if all intermediate results and the branch-and-bound decisions must be printed while solving. This function is mend for debugging purposes. The default is not to debug (FALSE). Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, set_debug |
set_obj_boundSet initial "at least better than" guess for objective function. void set_obj_bound(lprec *lp, REAL obj_bound); Return Value set_obj_bound has no return value. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI obj_bound The initial "at least better than" guess for objective function. RemarksThe set_obj_bound function specifies the initial "at least better than"
guess for objective function. This is only used in the branch-and-bound
algorithm when integer variables exist in the model. All solutions with a worse
objective value than this value are immediately rejected. This can result in
faster solving times, but it can be difficult to predict what value to take for
this bound. Also there is the chance that the found solution is not the most
optimal one. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_obj_bound, , set_break_at_value, get_break_at_value set_mip_gap, get_mip_gap |
get_lambda, get_ptr_lambdaReturns the Lamdba vectors (Lagrangian optimization). unsigned char get_lambda(lprec *lp, REAL *lambda); unsigned char get_ptr_lambda(lprec *lp, REAL **ptr_lambda); Return Value get_lambda, get_ptr_lambda returns TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI lambda An array that will contain the values of the Lamdba vectors. ptr_lambda The address of a pointer that will point to an array that will contain the values of the Lamdba vectors. Remarks The get_lambda, get_ptr_lambda functions retrieve the Lamdba
vectors. Note that get_ptr_lambda returns a pointer to memory allocated and maintained by lp_solve. Be careful what you do with it. Don't modify its contents or free the memory. Unexpected behaviour would occur. Also note that this memory pointer is only guaranteed to remain constant until a next lp_solve API call is done. You should call this function again to make sure you have again the correct pointer. Otherwise, this pointer could point to invalid memory. This should not be a problem since this call is very efficient. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, is_feasible, get_objective, get_working_objective, get_variables, get_ptr_variables, get_primal_solution, get_ptr_primal_solution, get_var_primalresult, get_sensitivity_rhs, get_ptr_sensitivity_rhs, get_dual_solution, get_ptr_dual_solution, get_var_dualresult, get_sensitivity_obj, get_ptr_sensitivity_obj, get_sensitivity_objex, get_ptr_sensitivity_objex, get_constraints, get_ptr_constraints, get_constr_value, lag_solve |
Usefull linksA Tour of Linear Programming Entries in the Mathematical Programming GlossaryAMPL Advanced linear programming Alternate Optimal Solutions, Degeneracy, Unboudedness, Infeasibility BAS File Format Benchmarks for Optimization Software But my Problem isn't linear! Communication Networks Cycling and Resolution Cycling in the Simplex Method: Example from Chvatal's Text. Decision Tree for Optimization Software Practical Optimization: A Gentle Introduction LPSolver (Linear Programming Solver) is a Solver Add-on for OpenOffice.org/StarOffice Linear Programming Linear Programming Linear Programming Frequently Asked Questions MATLAB Matlab Clones MIPLIB 3.0 MPS Format MPS Input Format MP-TESTDATA - The NETLIB Problems for MADLIB Michels site where you can also find older versions NETLIB LP Test Problems O-Matrix Practical Integer Programming Practical Optimization: A Gentle Introduction Scilab The Mechanics of the Simplex Method The MPS file format The NETLIB LP Test Problem Set The Simplex Method The Simplex Method: Solving Standard Maximization Problems Tutorials, Books and a Dictionary NEOS server for optimization Lp_solve link to Excel lpsolve reference guide lp_solve yahoo group Linear programming - Wikipedia Web page simplex tool |
set_lp_nameSet the name of the lp. unsigned char set_lp_name(lprec *lp, char *lpname); Return Value set_lp_name returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI lpname The name for the lp. Remarks The set_lp_name sets the name of the lp. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_lp_name |
copy_lpCopy an existing lprec structure to a new lprec structure. lprec *copy_lp(lprec *lp); Return Value
Returns a pointer to a new lprec structure. This must be provided to almost all
lp_solve functions. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The copy_lp function constructs a new LP from an existing lp structure. The new structure is independent from the original one. Example See Also make_lp, delete_lp, free_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI |
time_elapsedGets the time elapsed since start of solve. REAL time_elapsed(lprec *lp); Return Value time_elapsed returns the number of seconds after
solve and lag_solve has started. Parameters lp Pointer to previously created lp model. See return value of make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI Remarks The time_elapsed function returns the time in seconds since solve and lag_solve has started. Example See Also make_lp, copy_lp, read_lp, read_LP, read_mps, read_freemps, read_MPS, read_freeMPS, read_XLI, get_timeout, set_timeout, solve, lag_solve |