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.
Names are used by default.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_use_names(lp, FALSE, FALSE); /* specify that variable names are ignored */
delete_lp(lp);
return(0);
}
doc/lp_solve_5.5.0.12.chw 0000664 0001750 0001750 00000100563 14777273331 013610 0 ustar rene rene ITSF ` |{ "|{ "` 8 ` T s .! "T U n c o m p r e s s e d M S C o m p r e s s e d { 7 F C 2 8 9 4 0 - 9 D 3 1 - 1 1 D 0 LZXC C d ;) X44
$ /' a b s o l u t e v a l u e s a d d _ c o l u m n
a d d _ c o l u m n e x a d d _ c o n s t r a i n t ' a d d _ c o n s t r a i n t e x 4 a d d _ l a g _ c o n A a d d _ S O S
N B a s i s F a c t o r i z a t i o n P a c k a g e s [ C a l l i n g t h e l p s o l v e A P I f r o m y o u r a p p l i c a t i o n h C h a n g e s f r o m v e r s i o n 4 t o v e r s i o n 5 . 1 u C h a n g e s f r o m v e r s i o n 5 . 1 t o v e r s i o n 5 . 5 c o l u m n _ i n _ l p c o p y _ l p C P L E X l p f i l e s d e f a u l t _ b a s i s
d e l _ c o l u m n d e l _ c o n s t r a i n t d e l e t e _ l p D I M A C S m a x i m u m f l o w p r o b l e m s D I M A C S m i n i m u m a s s i g n m e n t p r o b l e m s D I M A C S m i n i m u m c o s t f l o w p r o b l e m s D o w n l o a d d u a l i z e _ l p E x t e r n a l L a n g u a g e I n t e r f a c e s + F o r m u l a t i o n o f a n l p m o d e l i n l p s o l v e 8 f r e e v a r i a b l e s E f r e e _ l p R F r e q u e n t l y A s k e d Q u e s t i o n s _ g e t _ a n t i _ d e g e n l g e t _ b a s i s y % g e t _ b a s i s c r a s h g e t _ b b _ d e p t h l i m i t g e t _ b b _ f l o o r f i r s t g e t _ b b _ r u l e g e t _ b o u n d s _ t i g h t e r g e t _ b r e a k _ a t _ v a l u e g e t _ c o l _ n a m e g e t _ c o l u m n g e t _ c o l u m n e x g e t _ c o n s t r _ t y p e g e t _ c o n s t r _ v a l u e g e t _ c o n s t r a i n t s g e t _ d u a l _ s o l u t i o n " g e t _ e p s b ! / g e t _ e p s d " < g e t _ e p s e l # I g e t _ e p s i n t $ V g e t _ e p s p e r t u r b % c g e t _ e p s p i v o t & p g e t _ i m p r o v e ' } g e t _ i n f i n i t e ( g e t _ l a m b d a ) g e t _ l o w b o * g e t _ l p _ i n d e x + g e t _ l p _ n a m e , g e t _ L r o w s - g e t _ m a t . g e t _ m a x _ l e v e l / g e t _ m a x p i v o t 0 g e t _ m i p _ g a p 1 g e t _ n a m e i n d e x 2 g e t _ N c o l u m n s 3 g e t _ n e g r a n g e 4 & g e t _ n o n z e r o s 5 3 g e t _ N o r i g _ c o l u m n s 6 @ g e t _ N o r i g _ r o w s 7 M g e t _ N r o w s 8 Z ! g e t _ o b j _ b o u n d 9 g g e t _ o b j e c t i v e : t g e t _ o r i g _ i n d e x ; g e t _ o r i g c o l _ n a m e g e t _ o r i g r o w _ n a m e < g e t _ p i v o t i n g = g e t _ p r e s o l v e > g e t _ p r e s o l v e l o o p s ? g e t _ p r i m a l _ s o l u t i o n @ g e t _ p r i n t _ s o l A g e t _ p t r _ c o n s t r a i n t s g e t _ p t r _ d u a l _ s o l u t i o n g e t _ p t r _ l a m b d a ) g e t _ p t r _ p r i m a l _ s o l u t i o n @ g e t _ p t r _ s e n s i t i v i t y _ o b j B g e t _ p t r _ s e n s i t i v i t y _ o b j e x B * g e t _ p t r _ s e n s i t i v i t y _ r h s 7 g e t _ p t r _ v a r i a b l e s C D g e t _ r h D Q g e t _ r h _ r a n g e E ^ g e t _ r o w F k g e t _ r o w _ n a m e < x g e t _ r o w e x F g e t _ s c a l e l i m i t G g e t _ s c a l i n g H g e t _ s e n s i t i v i t y _ o b j B g e t _ s e n s i t i v i t y _ o b j e x B g e t _ s e n s i t i v i t y _ r h s g e t _ s i m p l e x t y p e I g e t _ s o l u t i o n c o u n t J g e t _ s o l u t i o n l i m i t K g e t _ s t a t u s L g e t _ s t a t u s t e x t M 8 Z $ g e t _ t i m e o u t N g e t _ t o t a l _ i t e r O ! g e t _ t o t a l _ n o d e s P . g e t _ u p b o Q ; g e t _ v a r _ b r a n c h R H g e t _ v a r _ d u a l r e s u l t U g e t _ v a r _ p r i m a l r e s u l t @ b g e t _ v a r _ p r i o r i t y S o g e t _ v a r i a b l e s C | g e t _ v e r b o s e T g e t _ w o r k i n g _ o b j e c t i v e U G N U L E S S E R G E N E R A L P U B L I C L I C E N S E G N U M a t h P r o g g u e s s _ b a s i s V h a s _ B F P W h a s _ X L I X I n f e a s i b l e m o d e l s i n t e g e r v a r i a b l e s I n t r o d u c t i o n i s _ a d d _ r o w m o d e Y i s _ a n t i _ d e g e n Z i s _ b i n a r y [ % i s _ b r e a k _ a t _ f i r s t \ 2 i s _ c o n s t r _ t y p e ] ? i s _ d e b u g ^ L i s _ f e a s i b l e _ Y i s _ i n f i n i t e a f i s _ i n t b s i s _ i n t e g e r s c a l i n g c i s _ l a g _ t r a c e d i s _ m a x i m e i s _ n a t i v e B F P f i s _ n a t i v e X L I g i s _ n e g a t i v e h i s _ o b j _ i n _ b a s i s i i s _ p i v _ m o d e j # i s _ p i v _ r u l e k i s _ p r e s o l v e l i s _ s c a l e m o d e m i s _ s c a l e t y p e n i s _ s e m i c o n t o i s _ S O S _ v a r p ) i s _ t r a c e q 6 i s _ u n b o u n d e d ` C i s _ u s e _ n a m e s r P l a g _ s o l v e s ] L I N D O l p f i l e s j L i n e a r p r o g r a m m i n g b a s i c s w L i n e a r P r o g r a m m i n g F A Q l p f i l e f o r m a t l p _ s o l v e A P I r e f e r e n c e l p _ s o l v e c o m m a n d l p _ s o l v e Y a h o o g r o u p l p _ s o l v e _ v e r s i o n t l p s o l v e d i s t r i b u t e d f i l e s L P S o l v e I D E m a k e _ l p u m p s b a s f i l e f o r m a t m p s f i l e f o r m a t M P S _ w r i t e f i l e e x v P r e s o l v e p r i n t _ c o n s t r a i n t s w - p r i n t _ d e b u g d u m p x : p r i n t _ d u a l s y G p r i n t _ l p z T p r i n t _ o b j e c t i v e { a p r i n t _ s c a l e s | n p r i n t _ s o l u t i o n } { p r i n t _ s t r ~ p r i n t _ t a b l e a u p u t _ a b o r t f u n c j * % p u t _ b b _ b r a n c h f u n c p u t _ b b _ n o d e f u n c p u t _ l o g f u n c p u t _ m s g f u n c Q u i c k s t a r t r a t i o ' s r e a d _ b a s i s r e a d _ f r e e m p s
r e a d _ f r e e M P S r e a d _ l p $ r e a d _ L P 1 r e a d _ m p s > r e a d _ M P S K r e a d _ p a r a m s X r e a d _ X L I e r e s e t _ b a s i s r r e s e t _ p a r a m s r e s i z e _ l p s c a l i n g s e m i - c o n t i n u o u s v a r i a b l e s s e n s i t i v i t y s e t _ a d d _ r o w m o d e s e t _ a n t i _ d e g e n s e t _ b a s i s s e t _ b a s i s c r a s h s e t _ b a s i s v a r s e t _ b b _ d e p t h l i m i t
s e t _ b b _ f l o o r f i r s t
s e t _ b b _ r u l e
s e t _ B F P (
s e t _ b i n a r y 5
s e t _ b o u n d s B
s e t _ b o u n d s _ t i g h t e r O
s e t _ b r e a k _ a t _ f i r s t \
s e t _ b r e a k _ a t _ v a l u e i
s e t _ c o l _ n a m e v
s e t _ c o l u m n
j ' s e t _ c o l u m n e x
s e t _ c o n s t r _ t y p e
s e t _ d e b u g
s e t _ e p s b
s e t _ e p s d
s e t _ e p s e l
s e t _ e p s i n t
s e t _ e p s l e v e l
s e t _ e p s p e r t u r b
s e t _ e p s p i v o t s e t _ i m p r o v e s e t _ i n f i n i t e s e t _ i n t , s e t _ l a g _ t r a c e 9 s e t _ l o w b o F s e t _ l p _ n a m e S s e t _ m a t ` s e t _ m a x i m m s e t _ m a x p i v o t z s e t _ m i n i m s e t _ m i p _ g a p s e t _ n e g r a n g e s e t _ o b j s e t _ o b j _ b o u n d s e t _ o b j _ f n s e t _ o b j _ f n e x s e t _ o b j _ i n _ b a s i s s e t _ o u t p u t f i l e s e t _ o u t p u t s t r e a m s e t _ p i v o t i n g s e t _ p r e f e r d u a l s e t _ p r e s o l v e # s e t _ p r i n t _ s o l 0 s e t _ r h = s e t _ r h _ r a n g e J s e t _ r h _ v e c W s e t _ r o w d s e t _ r o w _ n a m e q s e t _ r o w e x ~ j & ! s e t _ s c a l e l i m i t s e t _ s c a l i n g s e t _ s e m i c o n t s e t _ s e n s e s e t _ s i m p l e x t y p e s e t _ s o l u t i o n l i m i t s e t _ t i m e o u t s e t _ t r a c e s e t _ u n b o u n d e d s e t _ u p b o
s e t _ u s e _ n a m e s
s e t _ v a r _ b r a n c h
s e t _ v a r _ w e i g h t s '
s e t _ v e r b o s e 4
s e t _ X L I A
s o l v e N
s p e c i a l o r d e r e d s e t s [
s t r _ a d d _ c o l u m n h
s t r _ a d d _ c o n s t r a i n t u
s t r _ a d d _ l a g _ c o n
s t r _ s e t _ o b j _ f n
s t r _ s e t _ r h _ v e c
t i m e _ e l a p s e d
u n s c a l e
U s e f u l l l i n k s
U s i n g l p s o l v e f r o m A M P L
U s i n g l p s o l v e f r o m J a v a
U s i n g l p s o l v e f r o m M A T L A B
U s i n g l p s o l v e f r o m O c t a v e
U s i n g l p s o l v e f r o m O - M a t r i x U s i n g l p s o l v e f r o m P y t h o n U s i n g l p s o l v e f r o m R U s i n g l p s o l v e f r o m S c i l a b + ~ j w r i t e _ b a s i s 8 w r i t e _ f r e e m p s v E w r i t e _ f r e e M P S v R w r i t e _ l p _ w r i t e _ L P l w r i t e _ l p e x y w r i t e _ m p s v w r i t e _ M P S v w r i t e _ p a r a m s w r i t e _ X L I X p r e s s l p f i l e s Z i m p l a r _ b r a n c h
s e t _ v a r _ w e i g h t s '
s e t _ v e r b o s e 4
s e t _ X L I A
s o l v e N
s p e c i a l o r d e r e d s e t s [
s t r _ a d d _ c o l u m n h
s t r _ a d d _ c o n s t r a i n t u
s t r _ a d d _ l a g _ c o n
s t r _ s e t _ o b j _ f n
s t r _ s e t _ r h _ v e c
t i m e _ e l a p s e d
u n s c a l e
U s e f u l l l i n k s
U s i n g l p s o l v e f r o m A M P L
U s i n g l p s o l v e f r o m J a v a
U s i n g l p s o l v e f r o m M A T L A B
U s i n g l p s o l v e f r o m O c t a v e
U s i n g l p s o l v e f r o m O - M a t r i x U s i n g l p s o l v e f r o m P y t h o n U s i n g l p s o l v e f r o m R U s i n g l p s o l v e f r o m S c i l a b + ~ j Z g e t _ b a s i s c r a s h g e t _ o b j _ b o u n d 9 g e t _ t i m e o u t N i s _ p i v _ r u l e k p u t _ b b _ b r a n c h f u n c s e t _ c o l u m n e x s e t _ s c a l e l i m i t w r i t e _ b a s i s $ bFV Of /' ITSP T j].! "T PMGL^ / /$HHTitleMap R! /$OBJINST J4/$WWAssociativeLinks/ /$WWAssociativeLinks/PROPERTY :/$WWKeywordLinks/ /$WWKeywordLinks/BTREE ^L/$WWKeywordLinks/DATA
T/$WWKeywordLinks/MAP >J/$WWKeywordLinks/PROPERTY * ::DataSpace/NameList 4<(::DataSpace/Storage/MSCompressed/Content ,::DataSpace/Storage/MSCompressed/ControlData )::DataSpace/Storage/MSCompressed/SpanInfo /::DataSpace/Storage/MSCompressed/Transform/List p&_::DataSpace/Storage/MSCompressed/Transform/{7FC28940-9D31-11D0-9B27-00A0C91E9C7C}/InstanceData/ i::DataSpace/Storage/MSCompressed/Transform/{7FC28940-9D31-11D0-9B27-00A0C91E9C7C}/InstanceData/ResetTable a lp_solve_5.5.0.12mm doc/get_constr_type.htm 0000664 0001750 0001750 00000005623 14777273331 014237 0 ustar rene rene
get_constr_type
get_constr_type
Gets 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:
LE (1)
Less than or equal (<=)
EQ (3)
Equal (=)
GE (2)
Greater than or equal (>=)
If there is an error then the function returns -1.
The set_obj_in_basis function specifies if the objective is in the matrix or not.
The default is that the objective is in the matrix.
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_obj_in_basis(lp, FALSE);
delete_lp(lp);
return(0);
}
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.
This function can be useful for debugging/demo purposes.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(1, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
solve(lp);
print_str(lp, "We are here\n");
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
long timeout;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
timeout = get_timeout(lp); /* will return 0 since no timeout was set */
delete_lp(lp);
return(0);
}
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.
Note that a semi-continuous variable must also have a lower bound to have effect.
This because the default lower bound on variables is zero, also when defined as
semi-continuous, and without a lower bound it has no point to define a variable
as such. The lower bound may be set before or after setting the semi-continuous status.
See semi-continuous variables for a description about semi-continuous variables.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_lowbo(lp, 1, 2.0);
set_semicont(lp, 1, TRUE); /* sets variable 1 to semi-continuous */
delete_lp(lp);
return(0);
}
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.
The default is 1e30
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_infinite(lp, 1.0e100); /* sets infinite to 1e100 */
delete_lp(lp);
return(0);
}
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.
Peculiarities 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 +.
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.
If the model contains no integer variables then it returns the number of iterations
to find a solution.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
long long total_iter;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
total_iter = get_total_iter(lp);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int solutionlimit;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
solve(lp);
solutionlimit = get_solutionlimit(lp);
delete_lp(lp);
return(0);
}
To 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.
This feature again gives a unique flexibility and openness to the user and developer
community that we have quite some expectations for.
If you write your own XLI, we would be glad if you would share your code with the lp_solve
community. We are very interested in providing as many different XLIs as possible to the
community.
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.
For example libxli_MathProg.so
Under Windows there is no prefix and the postfix is .dll
For example xli_MathProg.dll
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
Current directory.
A semi-colon-separated (;) list of directories in the user's PATH environment variable.
Unix/Linux
A colon-separated (:) list of directories in the user's LD_LIBRARY_PATH environment variable.
The list of libraries specified in /etc/ld.so.cache (which is generated from /etc/ld.so.conf).
/lib, followed by /usr/lib. Note the order here; this is the reverse of the order used by the old a.out loader.
The old a.out loader, when loading a program, first searched /usr/lib, then /lib (see the man page ld.so(8)).
This shouldn't normally matter, since a library should only be in one or the other directory (never both),
and different libraries with the same name are a disaster waiting to happen.
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 program
The 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
-rxli xliname filename
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
-rxlidata datafilename
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
-rxliopt "options"
So the following commands are valid for both Windows and Unix/Linux:
The latter makes sure that the XLI is searched in the current directory, especially for Unix/Linux.
Using an XLI from the lpsolve API
Read a model
The read_XLI reads a model via an XLI.
See the API call for its usage.
Write a model
To write a model, two API calls are needed:
First use set_XLI to set the XLI library
See the API call for its usage.
Then use write_XLI to write the model.
See the API call for its usage. Note that the last argument, results must FALSE.
Write a solution
To write a model, two API calls are needed:
First use set_XLI to set the XLI library
See the API call for its usage.
Then use write_XLI to write the model.
See the API call for its usage. Note that the last argument, results must TRUE.
Creating an XLI
This 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:
char * XLI_CALLMODEL xli_name(void)
Return Value
xli_name must return a string describing the XLI library.
Must return TRUE or FALSE to indicate if successful (TRUE) or not (FALSE).
Parameters
lp
An initial lp structure created via make_lp(0, 0).
model
Filename to read the model from.
data
Optional data to read data from. For example used by the MathProg XLI.
options
Extra options that can be used by the reader.
verbose
The verbose level. Can be used to output more or less information while creating the model.
Remarks
This routine is called when the read_XLI API is called.
Via the provided lp variable all lpsolve API routines can be accessed to create the model.
Note that xli_readmodel already provides an lp structure. You must use this one to build the model.
The lp structure is created via make_lp(0, 0). So it contains 0 rows
and 0 columns.
The filename argument of write_XLI. Filename to write the model/solution to.
options
The options argument of write_XLI. Extra options that can be used by the writer.
results
The results argument of write_XLI.
When FALSE, the XLI should create a model file and when TRUE is should create a solution file.
Remarks
This routine is called when the write_XLI API is called.
This routine must be used to write the model/solution.
Via the provided lp variable all lpsolve API routines can be accessed to do the job.
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.
Also under windows, a definition file must be added. If this is not done, it will not work.
The definition file should have extension .def and contain the following:
The definition file must be added to the project. How to do this depends on the version.
For Visual Studio 6: Project, Add to Project, Files, Files of type: Definition files (.def) and
choose the created .def file
For Visual Studio .NET: Project, Properties, Linker, Input, Module Definition file. There you enter the name (with optional path) of the .def file.
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);
}
}
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.
xli_readmodel creates the model. It doesn't even read from a file in this example.
xli_writemodel uses write_lp to write the model to filename and
some print_* functions to print the solution.
This XLI can be called from lp_solve via the following syntax:
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
The get_lp_name returns the name of the lp.
Giving the lp a name is optional. The default name is "Unnamed".
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
char *name;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
name = get_lp_name(lp); /* will be "Unnamed" since no name was set */
delete_lp(lp);
return(0);
}
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.
At least 1 Lagrangian constraint must be added via add_lag_con,
str_add_lag_con before lag_solve can be used.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int ret;
REAL row[1+2]; /* must be 1 more then number of columns ! */
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
row[1] = 1.0;
row[2] = 1.0;
add_lag_con(lp, row, LE, 1.0);
ret = lag_solve(lp, 0, 30, FALSE);
delete_lp(lp);
return(0);
}
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. set_scaling must be called before
solve is called.
SCALE_EXTREME, SCALE_RANGE, SCALE_MEAN, SCALE_GEOMETRIC, SCALE_CURTISREID are
the possible scaling algorithms.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int scaletype;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
scaletype = is_scaletype(lp, SCALE_MEAN);
delete_lp(lp);
return(0);
}
DIMACS (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:
The maximum flow problem is structured on a network.
Here the arc capacities, or upper bounds, are the only relevant parameters.
The problem is to find the maximum flow possible from some given source node
to a given sink node. All arc costs are zero.
Since the goal of the optimization is to minimize cost, the maximum flow possible
is delivered to the sink node. Applications of this problem include finding the
maximum flow of orders through a job shop, the maximum flow of water through a
storm sewer system, and the maximum flow of product through a product distribution
system, among others.
Network Structure
A network is a directed graph with n nodes and m arcs.
Nodes are identified by integers 1...n.
Graphs do not have to be symmetric: if an arc (v,w) is in the graph,
the reverse arc (w,v) does not have to be in the graph.
Parallel arcs are not allowed.
Self-loops are not allowed.
Arc capacities are 32-bit signed integers.
The source and the sink are distinct.
The sink may be unreachable from the source.
The following information makes up a DIMACS maximum flow input file:
comment lines
problem line
node descriptors
arc descriptors
As noted above, information is collected into lines, which begin with
one-character designators. We describe each type of information line in turn.
Comment Lines: Comment lines give human-readable information about the file and
are ignored by programs. Comment lines can appear anywhere in the file. Each comment line
begins with a lower-case character c.
c This is an example of a comment line.
Problem Line: There is one problem line per input file. The problem line must
appear before any node or arc descriptor lines. For maximum flow network instances
the problem line has the following format:
p max NODES ARCS
The lower-case character p signifies that this is a problem line. The
three-character problem designator max identifies the file as containing
specification information for a maximum flow problem. The NODES field
contains an integer value specifying n, the number of nodes in the network. The ARCS
field contains an integer value specifying m, the number of arcs in the network.
Node Descriptors: All node descriptor lines must appear before all arc descriptor
lines. Node descriptors are of the form:
n ID WHICH
where ID is the node id and WHICH is s for the source and
t for the sink.
Two node descriptors, one for the source
and one for the sink, must appear between the problem line and the arc
descriptor lines.
Arc Descriptors: There is one arc descriptor line for each arc in the network.
For a maximum flow instance, arc descriptor lines are of the following form.
a SRC DST CAP
The lower-case character a signifies that this is an arc descriptor line. For
a directed arc (v,w) the SRC field gives the identification number for the
source vertex v, and the DST field gives the destination vertex w.
Identification numbers are integers between 1 and n. The CAP
field gives the arc capacity.
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.
For example:
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]
This must be interpreted as follows:
There are as many variables as there are arc descriptor lines in the input file and
they appear in the same order. So:
C1 specifies how much flow there is for the first arc definition, in this case from A -> B
C2 specifies how much flow there is for the second arc definition, in this case from A -> C
...
This means there is a flow of 5 from node A to B, a flow of 10 from node A to C, ...
The value of the objective of lp_solve doesn't give you much information.
It is the sum of all variables used.
Output :
The solution of the model can also be written in a DIMACS format:
comment lines
solution lines
flow assignments
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.
Comment Lines: Comment lines give human-readable information about the file and
are ignored by programs. Comment lines can appear anywhere in the file. Each comment line
begins with a lower-case character c.
c This is an example of a comment line.
Solution line.
The solution line contains the flow value and has the following format:
s VALUE
The lower-case character s signifies that this is a solution line.
The VALUE field
contains the value of the objective.
Flow assignments.
There is one flow assignment line for each arc in the input network.
These lines have the following format:
f SRC DST FLOW
The lower-case character f signifies that this is a flow assignment line. For arc (u,v), the SRC and DST fields give v and w, respectively. The FLOW field gives the amount of flow assigned to arc (u,v).
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.
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
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_XLI(lp, "xli_MathProg");
delete_lp(lp);
return(0);
}
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.
Note that there are several restrictions with this mode:
Only use this function after a make_lp call. Not when the model
is read from file. Also, if this function is used, first add the objective function via set_obj_fn, set_obj_fnex, str_set_obj_fn
and after that add the constraints via
add_constraint, add_constraintex, str_add_constraint. Don't call other API functions while in row entry mode.
No other data matrix access is allowed while in row entry mode.
After adding the contraints, turn row entry mode back off. Once turned of, you cannot switch back
to row entry mode. So in short:
- turn row entry mode on
- set the objective function
- create the constraints
- turn row entry mode off
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char rowmode;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
rowmode = is_add_rowmode(lp); /* Will return FALSE */
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_solutionlimit(lp, 3); /* return the 3rd solution */
solve(lp);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char sc;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
sc = is_semicont(lp, 1); /* will return 0 since the variable is not set as semi-continuous at this point */
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_lag_trace(lp, TRUE);
delete_lp(lp);
return(0);
}
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.
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.
Row names are optional. If no row name was specified, the function returns Rx
with x the row number. row 0 is the objective function.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
char *name;
/* Create a new LP model */
lp = make_lp(1, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
name = get_row_name(lp, 1); /* will be R1 since no row name was set */
delete_lp(lp);
return(0);
}
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.
Setting a range on a row is the way to go instead of adding an extra constraint
(row) to the model. Setting a range doesn't increase the model size that means
that the model stays smaller and will be solved faster.
If the row has a less than constraint then the range means setting a minimum on
the constraint that is equal to the RHS value minus the range. If the row has a
greater than constraint then the range means setting a maximum on the
constraint that is equal to the RHS value plus the range.
Note that the range value is the difference value and not the absolute value.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(1, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_rh_range(lp, 1, 1.0);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int ret;
REAL guessvector[1 + 2];
int basis[1 + 2 + 2];
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_maxim(lp);
str_add_constraint(lp, "1 0", LE, 3);
str_add_constraint(lp, "0 1", LE, 3);
guessvector[1] = 3;
guessvector[2] = 3;
ret = guess_basis(lp, guessvector, basis);
set_basis(lp, basis, TRUE);
set_print_sol(lp, TRUE);
solve(lp); /* notice that the number of iterations is NULL because we provided a base that is immediately optimal */
delete_lp(lp);
return(0);
}
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.
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.
Setting a bound on a variable is the way to go instead of adding an extra
constraint (row) to the model. Setting a bound doesn't increase the model size
that means that the model stays smaller and will be solved faster.
The default upper bound of a variable is infinity (well not quite. It is a very big number, the value of get_infinite).
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL a;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
a = get_upbo(lp, 1); /* will return 1e30 since no upper bound was set */
delete_lp(lp);
return(0);
}
The negative value below which variables are split into a
negative and a positive part.
Remarks
The 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.
In some cases, negative variables must be split in a positive part and a
negative part. This is when a negative lower or upper bound is set on a
variable. If a bound is less than this value, it is possibly split.
The default is -1e6.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_negrange(lp, -1000);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char hasBFP;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
hasBFP = has_BFP(lp);
delete_lp(lp);
return(0);
}
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.
Note that there are several restrictions with this mode:
Only use this function after a make_lp call. Not when the model
is read from file. Also, if this function is used, first add the objective function via set_obj_fn, set_obj_fnex, str_set_obj_fn
and after that add the constraints via
add_constraint, add_constraintex, str_add_constraint. Don't call other API functions while in row entry mode.
No other data matrix access is allowed while in row entry mode.
After adding the contraints, turn row entry mode back off. Once turned of, you cannot switch back
to row entry mode. So in short:
- turn row entry mode on
- set the objective function
- create the constraints
- turn row entry mode off
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 10);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_add_rowmode(lp, TRUE);
/* first! set the objective function */
/* now add the constraints */
set_add_rowmode(lp, FALSE);
delete_lp(lp);
return(0);
}
doc/LGPL.htm 0000664 0001750 0001750 00000064161 14777273331 011567 0 ustar rene rene
GNU LESSER GENERAL PUBLIC LICENSE
GNU LESSER GENERAL PUBLIC LICENSE
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!
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int negative;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
negative = is_negative(lp, 1); /* will return 0 since the variable is not set as negative at this point */
delete_lp(lp);
return(0);
}
The routines return TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error.
Note that row entry mode must be off, else this function also fails. See set_add_rowmode
type of the MPS file. Can be one of the following values:
MPSFIXED (1)
Fixed MPS format
MPSFREE (2)
Free MPS format
write_modeldata_routine
Routine to write the MPS model to. The routine has following definition:
typedef int (__WINAPI write_modeldata_func)(void *userhandle, char *buf);
userhandle is the second parameter passed to write_lp_ex
buf is a shrunk of data.
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
write_mps(lp, "model.mps");
delete_lp(lp);
return(0);
}
doc/R.htm 0000664 0001750 0001750 00000030307 14777273331 011225 0 ustar rene rene
Using lpsolve from R
Using lpsolve from R
R?
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.
The R environment
R is an integrated suite of software facilities for data
manipulation, calculation and graphical display. It includes
an effective data handling and storage facility,
a suite of operators for calculations on arrays, in particular matrices,
a large, coherent, integrated collection of intermediate tools for data
analysis,
graphical facilities for data analysis and display either
on-screen or on hardcopy, and
a well-developed, simple and effective programming language which
includes conditionals, loops, user-defined recursive functions and
input and output facilities.
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
R and lpsolve
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.
Installing the lpsolve driver in R
How to install the driver depends on the environment.
Windows
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.
R command line
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")
Note
The > shown before each R command is the R prompt. Only the text after > must be entered.
Loading the lpsolve driver in R
Installing the package is not enough. It must also loaded in the R memory space before it can be used.
This can be done with the following command:
> library(lpSolveAPI)
Or
> library("lpSolveAPI", character.only=TRUE)
Getting Help
Documentation is provided for each function in the lpSolve package using R's built-in help system. For example, the command
> ?add.constraint
will display the documentation for the add.constraint function.
Building and Solving Linear Programs Using the lpSolve R Package
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.
Building and Solving Linear Programs Using the lpSolveAPI R Package
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.
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.lpExtPtr
to 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] TRUE
indicates that the operation was successful. Invisible values can also be used in flow control.
Cleaning up
To free up resources and memory, the R command rm() must be used.
For example:
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.
Note that for set_row (and set_rowex when colno is
NULL) element 1 of the array is column 1, element 2 is column 2, ... element 0 is not used.
set_rowex has the possibility to specify only the non-zero elements. And in contrary to set_row,
set_rowex reads the arrays starting from element 0. However when colno is NULL then
set_rowex acts as set_row and then values start at element 1.
When colno is provided, then it specifies the column numbers of the non-zero elements.
This will speed up building the model considerably if there are a lot of zero values.
In most cases the matrix is sparse and has many zero value. Thus it is almost always
better to use set_rowex instead of set_row. set_rowex
is always at least as performant as set_row.
It is more performant to call these functions than multiple times set_mat.
Note that unspecified values by set_rowex are set to zero.
Note that these routines will perform much better when set_add_rowmode
is called before adding constraints.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL row[1+3]; /* must be 1 more than number of columns ! */
REAL sparserow[2]; /* must be the number of non-zero values */
int colno[2];
/* Create a new LP model */
lp = make_lp(2, 3);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
row[1] = 1.0;
row[2] = 0.0; /* also zero elements must be provided */
row[3] = 2.0;
set_row(lp, 1, row); /* changes the values of existing row 1 */
colno[0] = 1; sparserow[0] = 1.0; /* column 1 */
colno[1] = 3; sparserow[1] = 2.0; /* column 3 */
set_rowex(lp, 2, 2, sparserow, colno);
delete_lp(lp);
return(0);
}
The get_working_objective function returns the current value of the
objective while solving the model.
This value can be retrieved while solving in a callback function.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int msgfunction(lprec *lp, void *userhandle, char *buf)
{
printf("%f\n", get_working_objective(lp));
return(0);
}
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
put_msgfunc(lp, msgfunction, NULL, 0);
delete_lp(lp);
return(0);
}
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.
Note that row entry mode must be off, else this function also fails. See set_add_rowmode
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.
If row and/or column are outside the allowed range, the function returns 0.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL a;
/* Create a new LP model */
lp = make_lp(2, 3);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
a = get_mat(lp, 1, 2); /* will return 0 because this element isn't created */
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char dodebug;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
dodebug = is_debug(lp); /* Will return FALSE */
delete_lp(lp);
return(0);
}
Additionally, the value can be OR-ed with any combination of one of the
following values:
SCALE_QUADRATIC (8)
SCALE_LOGARITHMIC (16)
Scale to convergence using logarithmic mean of all values
SCALE_USERWEIGHT (31)
User can specify scalars
SCALE_POWER2 (32)
also do Power scaling
SCALE_EQUILIBRATE (64)
Make sure that no scaled number is above 1
SCALE_INTEGERS (128)
also scaling integer variables
SCALE_DYNUPDATE (256)
dynamic update
SCALE_ROWSONLY (512)
scale only rows
SCALE_COLSONLY (1024)
scale only columns
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. set_scaling must be called before
solve is called.
SCALE_EXTREME, SCALE_RANGE, SCALE_MEAN, SCALE_GEOMETRIC, SCALE_CURTISREID are
the possible scaling algorithms. SCALE_QUADRATIC, SCALE_LOGARITHMIC,
SCALE_USERWEIGHT, SCALE_POWER2, SCALE_EQUILIBRATE, SCALE_INTEGERS are possible
additional scaling parameters.
SCALE_POWER2 results in creating a scalar of power 2. May improve stability.
SCALE_INTEGERS results also in scaling Integer columns. Default they are not
scaled.
SCALE_DYNUPDATE is new from version 5.1.1.0
It has always been so that scaling is done only once on the original model. If a solve
is done again (most probably after changing some data in the model), the scaling factors
aren't computed again. The scalars of the original model are used. This is not always
good, especially if the data has changed considerably. One way to solve this was/is call
unscale before a next solve. In that case, scale factors are recomputed.
From version 5.1.1.0 on, there is another
way to make sure that scaling factors are recomputed and this is by settings SCALE_DYNUPDATE. In
that case, the scaling factors are recomputed also when a restart is done. Note
that they are then always recalculated with each solve, even when no change was made to the model, or
a change that doesn't influence the scaling factors like changing the RHS (Right Hand Side) values
or the bounds/ranges. This can influence performance. It is up to you to decide
if scaling factors must be recomputed or not for a new solve, but by default it still isn't so.
It is possible to set/unset this flag at each next solve and it is even allowed to choose
a new scaling algorithm between each solve. Note that the scaling done by the SCALE_DYNUPDATE is incremental
and the resulting scalarsare typically different from scalars recomputed from scratch.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int scalemode;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
scalemode = is_scalemode(lp, SCALE_MEAN);
delete_lp(lp);
return(0);
}
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.
Setting a bound on a variable is the way to go instead of adding an extra
constraint (row) to the model. Setting a bound doesn't increase the model size
that means that the model stays smaller and will be solved faster.
The default upper bound of a variable is infinity (well not quite. It is a very big number, the value of get_infinite).
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_upbo(lp, 1, 1.0);
delete_lp(lp);
return(0);
}
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.
The default is not (FALSE) stop at first found solution.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char break_at_first;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
break_at_first = is_break_at_first(lp); /* Will return 0 (FALSE) */
delete_lp(lp);
return(0);
}
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.
Setting a range on a row is the way to go instead of adding an extra constraint
(row) to the model. Setting a range doesn't increase the model size that means
that the model stays smaller and will be solved faster.
If the row has a less than constraint then the range means setting a minimum on
the constraint that is equal to the RHS value minus the range. If the row has
a greater than constraint then the range means setting a maximum on the
constraint that is equal to the RHS value plus the range.
Note that the range value is the difference value and not the absolute value.
If no range was set then get_rh_range returns a very big number, the value of get_infinite.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL a;
/* Create a new LP model */
lp = make_lp(1, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
a = get_rh_range(lp, 1);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_trace(lp, TRUE);
delete_lp(lp);
return(0);
}
Integer 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 .
Example:
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:
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.
The default mip_gap value is 1e-11
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL mip_gap;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
mip_gap = get_mip_gap(lp, TRUE); /* Will return 1e-9 */
delete_lp(lp);
return(0);
}
The print_objective function prints the objective value of the lp. This can only be done after a successful solve.
This function is meant for debugging purposes. By default, the output is stdout. However
this can be changed via a call to set_outputstream, set_outputfile.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(1, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
solve(lp);
print_objective(lp);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int tighter;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
tighter = get_bounds_tighter(lp);
delete_lp(lp);
return(0);
}
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.
Floating-point calculations always result in loss of precision and rounding
errors. Therefore a very small value (example 1e-99) could be the result of such
errors and should be considered as 0 for the algorithm. epsb specifies
the tolerance to determine if a RHS value should be considered as 0. If
abs(value) is less than this epsb value in the RHS, it is considered as
0.
The default epsb value is 1.0e-10
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_epsb(lp, 1.0e-9); /* sets epsb to 1e-9 */
delete_lp(lp);
return(0);
}
The get_Norig_columns function returns the number of original columns
(variables) in the lp.
Note that the number of columns (get_Ncolumns)
can change when a presolve is done or when negative variables are split in a
positive and a negative part. get_Norig_columns does not change and thus
returns the original number of columns in the lp.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int Norig_columns;
/* Create a new LP model */
lp = make_lp(0, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
Norig_columns = get_Norig_columns(lp); /* Will return 1 */
set_presolve(lp, PRESOLVE_COLS);
solve(lp);
Norig_columns = get_Norig_columns(lp); /* Will return 1 */
delete_lp(lp);
return(0);
}
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:
Python uses an elegant syntax for readable programs.
Python is an agile language that makes it easy to get your program working. This makes Python an ideal language for prototype development and other ad-hoc programming tasks, without compromising maintainability.
A variety of basic data types are available: numbers (floating point, complex, and unlimited-length long integers), strings (both ASCII and Unicode), lists, dictionaries.
Python supports object-oriented programming with classes and multiple inheritance.
Code can be grouped into modules and packages.
The language supports raising and catching exceptions, resulting in cleaner error handling.
Data types are strongly and dynamically typed. Mixing incompatible types (e.g. attempting to add a string and a number) causes an exception to be raised.
Python contains advanced programming features such as generators and list comprehensions.
Automatic garbage collection frees you from the hassles of memory management.
The large standard library supports many common programming tasks such as connecting to web servers, regular expressions, and file handling.
Python's interactive mode makes it easy to test short snippets of code. There's also a bundled development environment called IDLE.
The Python interpreter is easily extended by adding new modules implemented in a compiled language such as C or C++.
The interpreter can also be embedded into an application to provide a programmable interface.
Python runs on many different computers and operating systems: Windows, MacOS, many brands of Unix, OS/2, ...
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.
Installation
To make this possible, a driver program is needed: lpsolve55.pyd/lpsolve55.so.
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.2.14_dev.zip/lp_solve_5.5.2.14_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.
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.6
using lpsolve version 5.5.2.14
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.
Solve an lp model from Python via lpsolve
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:
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:
(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:
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.
Using model name instead of handle
From driver version 5.5.0.2, it is possible to use the model name instead of the handle. From the moment the model
has a name, you can use this name instead of the handle. This is best shown by an example. Above example would look
like this:
>>> 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:
[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.
Maximum usage of matrices with lpsolve
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.)
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. Two common known packages for this are Numeric and numpy.
These are not installed by default but can be easily installed.
See http://sourceforge.net/project/showfiles.php?group_id=1369&package_id=1351 and
http://sourceforge.net/projects/numpy/files/.
See http://numpy.scipy.org/ for a brief overview.
>>> from numpy import *
or
>>> from Numeric import *
This documentation works with numpy, but Numeric can be used also.
>>> from numpy 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 = dot(A, X)
>>> B
array([ 92.3 , 6.864 , 391.29282759])
We even don't have to explicitly convert the lists to matrices:
>>> from numpy 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 = dot(a, x)
>>> B
array([ 92.3 , 6.864 , 391.29282759])
dot returns not a list, but an 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:
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 = dot(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:
Again exactly the same as the calculated obj value, as expected.
numpy package
In the above section Maximum usage of matrices with lpsolve the
package numpy was already mentioned. See http://numpy.scipy.org/ for a brief overview.
This package is the successor of the older and obsolete package Numeric.
Since lp_solve is all about arrays and matrices, it is logical that the lpsolve Python driver accepts numpy arrays.
This is possible from driver version 5.5.0.9. Before it was needed that numpy arrays were converted to lists.
For example:
>>> from numpy import *
>>> from lpsolve55 import *
>>> lp=lpsolve('make_lp', 0, 4);
>>> c = array([1, 3, 6.24, 0.1])
>>> ret = lpsolve('set_obj_fn', lp, c)
Note that the numpy array variable c is passed directly to lpsolve.
Before driver version 5.5.0.9 this gave an error since lpsolve did not know numpy arrays.
They had to be converted to lists:
>>> ret = lpsolve('set_obj_fn', lp, list(c))
That is ok for small models, but for larger arrays this gives an extra memory overhead since c is now two times in
memory. Once as the numpy array and once as list.
Note that all returned arrays from lpsolve are always lists.
Also note that the older package Numeric is not supported by lpsolve.
So it is not possible to provide a Numeric array to lpsolve. That will give an error.
Using string constants
From driver version 5.5.2.14 on, it is possible to use string constants
everywhere an lp_solve constant is needed or returned. This is best shown by an example.
In the above code we had:
Note the 3rd parameter on set_verbose and the 4th on add_constraint. These are
lp_solve constants. One can define all the possible constants in Python as is
done in the Python driver and
then use them in the calls, but that has several disadvantages. First there
stays the possibility to provide a constant that is not intended for that
particular call. Another issue is that calls that return a constant are still
returning it numerical.
Both issues can now be handled by string constants. The above code can be done as
following with string constants:
This is not only more readable, there is much lesser chance that mistakes are
being made. The calling routine knows which constants are possible and only
allows these. So unknown constants or constants that are intended for other
calls are not accepted. For example:
>>> lpsolve('set_verbose', lp, 'blabla');
Traceback (most recent call last):
File "", line 1, in
lpsolve('set_verbose', lp, 'blabla');
error: BLABLA: Unknown.
>>> lpsolve('set_verbose', lp, 'GE');
Traceback (most recent call last):
File "", line 1, in
lpsolve('set_verbose', lp, 'GE');
error: GE: Not allowed here.
Note the difference between the two error messages. The first says that the
constant is not known, the second that the constant cannot be used at that
place.
Constants are case insensitive. Internally they are always translated to upper
case. Also when returned they will always be in upper case.
The constant names are the ones as specified in the documentation of each API
routine. There are only 3 exceptions, extensions actually. 'LE', 'GE' and 'EQ' in
add_constraint and is_constr_type
can also be '<', '<=', '>', '>=', '='. When returned however, 'GE', 'LE', 'EQ'
will be used.
Also in the matrix version of calls, string constants are possible. For example:
>>> ret = lpsolve('set_constr_type', lp, ['LE', 'EQ', 'GE']);
Some constants can be a combination of multiple constants. For example
set_scaling:
>>> lpsolve('set_scaling', lp, 3+128);
With the string version of constants this can be done as following:
| is the OR operator used to combine multiple constants. There may optinally be
spaces before and after the |.
Not all OR combinations are legal. For example in set_scaling, a choice must be
made between SCALE_EXTREME, SCALE_RANGE, SCALE_MEAN, SCALE_GEOMETRIC or
SCALE_CURTISREID. They may not be combined with each other. This is also tested:
>>> lpsolve('set_scaling', lp, 'SCALE_MEAN|SCALE_RANGE');
Traceback (most recent call last):
File "", line 1, in
lpsolve('set_scaling', lp, 'SCALE_MEAN|SCALE_RANGE');
error: SCALE_RANGE cannot be combined with SCALE_MEAN
Everywhere constants must be provided, numeric or string values may be provided.
The routine automatically interpretes them.
Returning constants is a different
story. The user must let lp_solve know how to return it. Numerical or as string.
The default is numerical:
>>> lpsolve('get_scaling', lp)
131L
To let lp_solve return a constant as string, a call to a new function must be
made: return_constants
>>> ret = lpsolve('return_constants', 1);
From now on, all returned constants are returned as string:
This for all routines until return_constants is again called with 0:
>>> ret = lpsolve('return_constants', 0);
The (new) current setting of return_constants is always returned by the call.
Even when set:
>>> lpsolve('return_constants', 1)
1L
To get the value without setting it, don't provide the second argument:
>>> lpsolve('return_constants')
1L
In the next part of this documentation, return_constants is the default, 0, so all
constants are returned numerical and provided constants are also numerical. This
to keep the documentation as compatible as possible with older versions. But
don't let you hold that back to use string constants in your code.
Callbacks
lp_solve has a callback mechanisms to Python while it is in the solve process.
To enable this, a python routine must be registered to lp_solve and it will then be called when needed.
Following callbacks are possible:
Note that the callback routine *must* have the same parameter list as required by the callback routine for the put_* routine.
If that is not the case it is likely that the program will crash. There is no check done by lp_solve that this is the case.
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.
example1.py
Contains the commands as shown in the first example of this article.
example2.py
Contains the commands as shown in the second example of this article.
example3.py
Contains the commands of a practical example. See further in this article.
example4.py
Contains the commands of a practical example. See further in this article.
example5.py
Contains the commands of a practical example. See further in this article.
example6.py
Contains the commands of a practical example. See further in this article.
lp_solve.py
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:
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.
Don't forget to free the handle and its associated memory when you are done:
>>> lpsolve('delete_lp', lp)
lpdemo.py
Contains several examples to build and solve lp models.
ex.py
Contains several examples to build and solve lp models.
Also solves the lp_examples from the lp_solve distribution.
A practical example
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 numpy import *
>>> from numpy.linalg import inv
>>> x = dot(inv(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 = dot(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.
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:
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:
Availability of seed.This might lead to constraint inequalities like xj < k.
Personal preferences. Thus the farmer's spouse might have a preference
for one variety over another and insist on a corresponding planting,
or something similar with a collection of crops; thus constraint inequalities
like xi < xj or x1 + x2 > x3.
Government subsidies. It may take a moment's reflection on the reader's part,
but this could lead to inequalities like xj > k.
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:
How many crops are under consideration?
What are the corresponding expenses? How much is available for expenses?
What are the yields in each case? What is the storage capacity?
How many acres are available?
What crops are constrained by seed limitations? To what extent?
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.
Another, more theoretical, example
Suppose we want to solve the following linear program using Python:
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:
The count argument in the API documentation is not needed in Python since the number of elements is derived from the size of the sosvars and weights matrices. These must have the same size.
The bascolumn argument in the API documentation is here the return value. The nonbasic argument is optional in Python. If not provided, then 0 is used.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix in the first return value.
The return code of the call is the second return value.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
The objfrom, objtill, objfromvalue, objtillvalue arguments in the API documentation
are here the return values. Note that Python allows the return of fewer
variables. For example if only objfrom and objtill are needed then the
call can be [objfrom, objtill] = lpsolve('get_sensitivity_obj',
lp). The unrequested values are even not calculated.
Since the API routine doesn't calculate the objtillvalue value at this time, Python always
returns a zero vector for this.
The return code of the call is the last value.
get_sensitivity_obj and get_sensitivity_objex are both implemented, but have the same functionality.
The duals, dualsfrom, dualstill
arguments in the API documentation are here the return values. Note that
Python allows the return of fewer variables. For example if only duals is
needed then the call can be [duals] = lpsolve('get_sensitivity_rhs',
lp). The unrequested values are even not calculated.
The return code of the call is the last value.
get_sensitivity_rhs and get_sensitivity_rhsex are both implemented, but have the same functionality.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Python matrix.
The lpsolve API routine returns the version information in 4 provided argument variables while the Python version returns the information as a string in the format major.minor.release.build
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Python (Windows) this means
that the output is not shown.
The same information can also be obtained via lpsolve('get_constraints', lp). This shows the result on screen.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Python (Windows) this means
that the output is not shown.
The same information can be obtained via lpsolve('get_dual_solution', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Python (Windows) this means that the output is not shown.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Python (Windows) this means
that the output is not shown.
The same information can be obtained via lpsolve('get_objective', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Python (Windows) this means that the output is not shown.
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Python (Windows) this means
that the output is not shown.
The same information can also be obtained via lpsolve('get_variables', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Python (Windows) this means that the output is not shown.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Python (Windows) this means that the output is not shown.
However, the lpsolve driver sets a log function to redirect the output of lpsolve from stdout (which is not visible in Windows Python) to the command window of Python.
As such, all reported output can be seen in Python. How much output is seen is controlled by the verbose level that can be defined by set_verbose or can be specified in the read_ routines.
In Python, when you name a model, this name can be used everywhere where lp is specified.
This to access the model via the name instead of via a handle.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows to set the whole matrix (all rows/columns) at once.
This is the most performant way to provide the constraint matrix. Consider using a Python sparse matrix for maximum performance and least memory usage.
The matrix must be two-dimensional.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all variables. It is then the same as set_obj_fn
In the API description it says that setting filename to NULL results in writing output back to stdout.
In Python under Windows, output to stdout it not shown. However it results in closing the file.
Use '' to have the effect of NULL.
In Python, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all rows. Note that in this case, the value of row 0 is not specified in the matrix.
Returns the setting of return_constants and optionally sets its value.
Compile the lpsolve driver
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.2.14_dev.zip/lp_solve_5.5.2.14_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 (cc/gcc) and under windows it is the Microsoft compiler from Visual Studio .NET. or the mingw gcc compiler
This compiler must be called from Python. To make the compilation process easier, a Python script can be used:
setup.py (setup64.py for 64 bit OS)
To be able to compile this driver, Python must be installed on the system and callable from a shell or command prompt by just entering
the command Python. If this is not the case, set the PATH environment variable to the location where Python is installed.
For example C:\Python25
The lpsolve Python driver can use the Python numpy package. To be able to compile the lpsolve driver, this numpy package should also
be installed on the system. If the numpy package cannot be found at compilation time, the lpsolve Python driver will not be able to
work with numpy. The compilation script setup.py/setup64.py automatically detects if numpy is installed and uses it if found.
This is done by searching the numpy directory. This is done by the following python commands:
import sys
import os
p = sys.prefix
NUMPYPATH = ''
if os.path.isdir(p + '/include/numpy'):
NUMPY = 'NUMPY'
elif os.path.isdir(p + '/Lib/site-packages/numpy/core/include/numpy'):
NUMPY = 'NUMPY'
NUMPYPATH = p + '/Lib/site-packages/numpy/core/include'
else:
NUMPY = 'NONUMPY'
Under Unix, make sure you have enough rights. Possibly you must be logged in as a root user.
Under Windows, the Microsoft visual C compiler is needed by default.
Unfortunately apparently there is a test that the version must be exactly the same as the one where Python itself is build with.
However it is also possible to compile
with the mingw gcc compiler. For this, create (or edit) the file C:\Python25\Lib\distutils\distutils.cfg:
[build]
compiler=mingw32
The python folder can of course be different.
Note that liblpsolve55.a may not exist in directory ../../lpsolve55/bin/win32. Delete it or temporary rename it such that lpsolve55.dll is used.
Now to compile and install the package, just enter the following in a command prompt/shell:
python setup.py install
or
python setup64.py install
and everything is done.
To create a distribution package, enter:
python setup.py bdist
Under Windows, use:
python setup.py bdist_wininst
Install the lpsolve driver
Under Linux, the distributable packages is called lpsolve55-5.5.0.6.linux-i686.tar.gz
The contents must be expanded to the appropriate directory.
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.6.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.2.14_dev.zip).
The get_verbose function returns the verbose level.
lp_solve reports information back to the user. How much information is reported
depends on the verbose level. The default verbose level is NORMAL. lp_solve determines
how verbose a given message is. For example specifying a wrong row/column index
values is considered as a SEVERE error. verbose determines how much of
the lp_solve message are reported. All messages equal to and below the set
level are reported.
The default reporting device is the console screen. It is possible to set a
used defined reporting routine via put_logfunc.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int verbose;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
verbose = get_verbose(lp); /* Will return 4 (NORMAL) */
delete_lp(lp);
return(0);
}
Returns 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.
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.
These values are only valid after a successful solve and
if there are integer variables in the model then only if
set_presolve is called before solve with parameter PRESOLVE_SENSDUALS.
Functions get_sensitivity_obj, get_sensitivity_objex need arrays
that are already dimensioned with get_Ncolumns elements.
get_ptr_sensitivity_obj, get_ptr_sensitivity_objex returns a
pointer to an array already dimensioned by lp_solve. Element 0 will contain the
value of the first variable, element 1 of the second variable, ...
The meaning of these limits are the following. As long as the value of the
coefficient of the objective function stays between the lower limit (objfrom)
and the upper limit (objtill), the solution stays the same. Only the
objective value itself changes with a value equal to the difference multiplied
by the amount of this variable. If there is no lower/upper limit, then these
values are (-)infinity.
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL objfrom[1+2], objtill[1+2], *ptr_objfrom, *ptr_objtill;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
str_set_obj_fn(lp, "1 1");
str_add_constraint(lp, "2 4", GE, 10);
set_lowbo(lp, 1, 1);
solve(lp);
get_sensitivity_obj(lp, objfrom, objtill);
get_ptr_sensitivity_obj(lp, &ptr_objfrom, &ptr_objtill);
delete_lp(lp);
return(0);
}
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.
Note that the number of constraints (get_Nrows) and columns (get_Ncolumns) can change when a presolve is done or when
negative variables are split in a positive and a negative part. get_orig_index returns the original position of the constraint/variable. If lp_index is not a legal index, the return value is 0.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int index;
/* Create a new LP model */
lp = make_lp(0, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
index = get_orig_index(lp, 1); /* Will return 1 */
set_presolve(lp, PRESOLVE_COLS);
solve(lp);
index = get_orig_index(lp, 1); /* Will return 0 */
delete_lp(lp);
return(0);
}
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.
An error occurs when del_row is not between 1 and the number of rows in the
lp.
Note that row entry mode must be off, else this function also fails. See set_add_rowmode
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.
Note that row 0 (the objective function) cannot be deleted. There is always an
objective function.
Note that if you can also delete multiple constraints by a call to
resize_lp.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(1, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
del_constraint(lp, 1);
delete_lp(lp);
return(0);
}
The lp_solve program is a command line application that can use as good as all functionality of the library.
Installation
There is no installation procedure for this application. There is no need for it. You only need one file:
lp_solve.exe under Windows or lp_solve under Unix/Linux.
It can be found in the archive lp_solve_5.5.2.14_exe.zip (Windows) or lp_solve_5.5.2.14_exe.tar.gz (Unix/Linux).
Just extract the file and you can use it.
Note for Windows users, that you can not just run the lp_solve program by double clicking on it from Windows Explorer.
The program needs arguments and this is best done from the command line (cmd.exe / command.com) or via batch files.
lp_solve has many options as shown further.
Usage
This program reads the MIP model from standard input or from a file and outputs
the result back to the console or to a file. There are several possible input formats:
The 'lp' format (See lp-format),
and the 'mps' format (See mps-format) are build in,
but other formats are also supported via the XLI functionality (See external language interface).
For example a MathProg interface is developed via the XLI functionality (See external language interface for an example).
These input formats have nothing to do with the API. So lp1 = make_lp(0,4) is a totally wrong input for the lp_solve program.
The lp format is the default. Optionaly you can use the -lp option for it.
To enable the mps format, use the -mps option.
To enable the XLI, use the -rxli option.
If lp_solve is started without an input file, then it gives a
blinking cursor and waits for input. It is then possible to enter the model in
the specified format (lp by default). But this is not very handy. You must enter
the whole model each time you want to solve it and must be careful that you
don't type any errors. To stop input mode, press Ctrl Z. However it is much
better to write your model in a disk file with your favourite editor (make sure
it is in text format) and then provide this file to lp_solve.
For example:
lp_solve input.lp
It is also possible to use input redirection:
lp_solve <input.lp
Or more sophisticated constructs like:
gen_model | lp_solve
gen_model is here a user written program that outputs the model to standard output and via the pipe
character (|) this output is redirected to lp_solve. So no intermediate file is needed in this case.
A list of all options is given by entering the following command:
lp_solve -h
This gives:
Usage of lp_solve version 5.5.2.14:
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, default in fixed format See read_MPS, See mps-format
-mps_free use free format See read_MPS, See mps-format
-mps_ibm interprete integers accoring to ibm format See read_MPS, See mps-format
-mps_negobjconst negate objective constant See read_MPS, See mps-format
-fmps read from MPS file in free format See read_freeMPS, See mps-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'
-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
-gbas filename guess basis with variables from filename. See guess_basis
-plp print model. See print_lp
-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).
-wafters Write scaled model after solve (useful to see scaling effect).
-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: Same as -s4 -sl
-s6: Scale based on the simple numerical range
-s7: Same as -s4 -sq
These scaling rules can be combined with any of the following:
-sp: also do power scaling.
-si: also do integer scaling (default).
-se: also do equilibration to scale to the -1..1 range (default).
-sq: also do quadratic scaling.
-sl: Scale to convergence using logarithmic mean of all values.
-sd: Dynamic update.
-sr: Scale only rows.
-sc: Scale only columns.
-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
-presolvem Merge rows See set_presolve
-presolvefd COLFIXDUAL See set_presolve
-presolvebnd Presolve bounds See set_presolve
-presolved Presolve duals See set_presolve
-presolvef Identify implied free variables (releasing their expl. bounds) See set_presolve
-presolveslk IMPLIEDSLK 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
-timeoutok If timeout, take the best yet found solution.
-ac <accuracy> Fail when accuracy is less then specified value.
-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
-BR Extended 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_msgfuncSee 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
-ip print solution with more precision
-stat Print model statistics
-relax Relax model
-relaxnotighten Don't tighten relaxed model
-relaxexclude rowNr|RowName
Exclude row from relaxation
-checkmultiplesolutions deltaobj deltax
Check if multiple solutions
-S <detail> Print solution. If detail omitted, then -S2 is used.
-S0: Print nothing
-S1: Only objective value See print_objectiveSee get_objective
-S2: Obj value+variables (default) See print_solutionSee get_variables, get_ptr_variables
-S3: Obj value+variables+constraints See print_constraintsSee get_constraints
-S4: Obj value+variables+constraints+duals
See print_dualsSee 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
A practical example
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
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_maxim(lp);
delete_lp(lp);
return(0);
}
Specifies which basis crash mode is used. Can by any of the
following values:
CRASH_NONE (0)
No basis crash
CRASH_MOSTFEASIBLE (2)
Most feasible basis
CRASH_LEASTDEGENERATE (3)
Construct a basis that is in some measure the "least degenerate"
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
/* Model created */
set_basiscrash(lp, CRASH_MOSTFEASIBLE);
delete_lp(lp);
return(0);
}
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.
It does not look at bounds and types, only at matrix values.
The first matched column is returned. If there is no column match, then 0 is returned.
Note that element 0 is the objective function value. Element 1 is column 1, and so on.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL column[1+2]; /* must be 1 more then number of rows ! */
int ret;
/* Create a new LP model */
lp = make_lp(2, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
column[0] = 0.0;
column[1] = 0.0;
column[2] = 0.0;
ret = column_in_lp(lp, column); /* Will return 1 */
delete_lp(lp);
return(0);
}
The verbose level. Can be one of the following values:
NEUTRAL (0)
Only some specific debug messages in de debug print routines are reported.
CRITICAL (1)
Only critical messages are reported. Hard errors like instability, out of memory, ...
SEVERE (2)
Only severe messages are reported. Errors.
IMPORTANT (3)
Only important messages are reported. Warnings and Errors.
NORMAL (4)
Normal messages are reported. This is the default.
DETAILED (5)
Detailed messages are reported. Like model size, continuing B&B improvements, ...
FULL (6)
All messages are reported. Useful for debugging purposes and small models.
Remarks
The set_verbose function sets the verbose level.
lp_solve reports information back to the user. How much information is reported
depends on the verbose level. The default verbose level is NORMAL (4).
lp_solve determines how verbose a given message is. For example
specifying a wrong row/column index values is considered as a SEVERE error. verbose
determines how much of the lp_solve message are reported. All messages equal to
and below the set level are reported.
The default reporting device is the console screen. It is possible to set a
used defined reporting routine via put_logfunc.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_verbose(lp, NORMAL);
delete_lp(lp);
return(0);
}
doc/man.ncb 0000664 0001750 0001750 00000106000 14777273331 011543 0 ustar rene rene Microsoft C/C++ MSF 7.00
DS # t .1V 1+`D8# /names /ncb/targetinfo /ncb/moduleinfo /ncb/modulecommandlines /ncb/iinstdefs /ncb/auxnamemap /ncb/directorywatch /ncb/targetmap /ncb/filenameimodmap /ncb/moduleinfofreelist /ncb/versioninfo R
' ? r N ^
icrosoft.NET\Framework\v2.0.50727 -AIC:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\lib -AIC:\Program Files\Microsoft Visual Studio 9.0\VC\lib sual Studio 9.0\VC\lib" H D : \ L P _ S O L V E \ l p _ s o l v e _ 5 . 5 \ e x t r a \ m a n \ d : \ L P _ S O L V E \ l p _ s o l v e _ 5 . 5 \ e x t r a \ m a n \ t O
V 1+`D8# /names /ncb/targetinfo /ncb/moduleinfo /ncb/modulecommandlines /ncb/iinstdefs /ncb/auxnamemap /ncb/directorywatch /ncb/targetmap /ncb/filenameimodmap /ncb/moduleinfofreelist /ncb/versioninfo R
' ? r N ^
4
/D_M_X86 > /ACWDd:\LP_SOLVE\lp_solve_5.5\extra\man\ -IC:\Program Files\Microsoft Visual Studio 9.0\VC\include -IC:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include -IC:\Program Files\Microsoft SDKs\Windows\v6.0A\\include -IC:\Program Files\Microsoft SDKs\Windows\v6.0A\include -AIC:\Windows\Microsoft.NET\Framework\v2.0.50727 -AIC:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\lib -AIC:\Program Files\Microsoft Visual Studio 9.0\VC\lib sual Studio 9.0\VC\lib" H D : \ L P _ S O L V E \ l p _ s o l v e _ 5 . 5 \ e x t r a \ m a n \ d : \ L P _ S O L V E \ l p _ s o l v e _ 5 . 5 \ e x t r a \ m a n \ D:\LP_SOLVE\lp_solve_5.5\extra\man\HTMLHelp.vcproj /D_M_X86 /ACWD "d:\LP_SOLVE\lp_solve_5.5\extra\man\" -I "C:\Program Files\Microsoft Visual Studio 9.0\VC\include" -I "C:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include" -I "C:\Program Files\Microsoft SDKs\Windows\v6.0A\\include" -I "C:\Program Files\Microsoft SDKs\Windows\v6.0A\include" -AI "C:\Windows\Microsoft.NET\Framework\v2.0.50727" -AI "C:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\lib" -AI "C:\Program Files\Microsoft Visual Studio 9.0\VC\lib" D:\LP_SOLVE\lp_solve_5.5\extra\man\;d:\LP_SOLVE\lp_solve_5.5\extra\man\ penohomevista d:\lp_solve\lp_solve_5.5\extra\man\man.ncb Y g 4 > Y g 4
/D_M_X86 > /ACWDd:\LP_SOLVE\lp_solve_5.5\extra\man\ -IC:\Program Files\Microsoft Visual Studio 9.0\VC\include -IC:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include -IC:\Program Files\Microsoft SDKs\Windows\v6.0A\\include -IC:\Program Files\Microsoft SDKs\Windows\v6.0A\include -AIC:\Windows\Microsoft.NET\Framework\v2.0.50727 -AIC:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\lib -AIC:\Program Files\Microsoft Visual Studio 9.0\VC\lib sual Studio 9.0\VC\lib" H D : \ L P _ S O L V E \ l p _ s o l v e _ 5 . 5 \ e x t r a \ m a n \ d : \ L P _ S O L V E \ l p _ s o l v e _ 5 . 5 \ e x t r a \ m a n \ O
D:\LP_SOLVE\lp_solve_5.5\extra\man\HTMLHelp.vcproj /D_M_X86 /ACWD "d:\LP_SOLVE\lp_solve_5.5\extra\man\" -I "C:\Program Files\Microsoft Visual Studio 9.0\VC\include" -I "C:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include" -I "C:\Program Files\Microsoft SDKs\Windows\v6.0A\\include" -I "C:\Program Files\Microsoft SDKs\Windows\v6.0A\include" -AI "C:\Windows\Microsoft.NET\Framework\v2.0.50727" -AI "C:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\lib" -AI "C:\Program Files\Microsoft Visual Studio 9.0\VC\lib" D:\LP_SOLVE\lp_solve_5.5\extra\man\;d:\LP_SOLVE\lp_solve_5.5\extra\man\ penohomevista d:\lp_solve\lp_solve_5.5\extra\man\man.ncb Y g 4 > Y g .1V 1+`D8# /names /ncb/targetinfo /ncb/moduleinfo /ncb/modulecommandlines /ncb/iinstdefs /ncb/auxnamemap /ncb/directorywatch /ncb/targetmap /ncb/filenameimodmap /ncb/moduleinfofreelist /ncb/versioninfo R
' ? r N ^
t O doc/get_solutioncount.htm 0000664 0001750 0001750 00000004711 14777273331 014610 0 ustar rene rene
get_solutioncount
get_solutioncount
Returns 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.
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char lag_trace;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
lag_trace = is_lag_trace(lp); /* Will return FALSE */
delete_lp(lp);
return(0);
}
The routines return TRUE (1) if the operation was
successful. A return value of FALSE (0) indicates an error.
write_LP and write_lp write in a file. write_lpex calls routine write_modeldata_routine to pass the data to that must be written.
In this routine you can do anything you want with the data. Note that data is provided in undefined shrunks.
Note that row entry mode must be off, else this function also fails. See set_add_rowmode
Routine to write the lp model to. The routine has following definition:
typedef int (__WINAPI write_modeldata_func)(void *userhandle, char *buf);
userhandle is the second parameter passed to write_lpex
buf is a shrunk of data.
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 is_obj_in_basis function returns if the objective is in the matrix or not.
The default is that the objective is in the matrix (TRUE).
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char obj_in_basis;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
obj_in_basis = is_obj_in_basis(lp); /* Will return 1 (TRUE) */
delete_lp(lp);
return(0);
}
typedef void (__WINAPI lphandlestr_func)(lprec *lp, void *userhandle, char *buf);
Note the __WINAPI attribute. This is important under Windows. It ensures __stdcall calling
convention which is required.
loghandle
A parameter that will be provided to the log routine.
Remarks
The put_logfunc function sets a log routine.
When set, the log routine is called when lp_solve has someting to report.
The return value of this routine should be 0. The log
routine can be cleared by specifying NULL as log routine.
This function is called at the same time as something is written to file set via
set_outputstream, set_outputfile.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
void __WINAPI logfunction(lprec *lp, void *userhandle, char *buf)
{
/* do something with buf (the message) */
}
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
put_logfunc(lp, logfunction, NULL);
set_verbose(lp, FULL);
del_column(lp, 1); /* Will generate an error because column 1 does not exist */
/* Note that del_column returns FALSE (0) to indicate an error */
delete_lp(lp);
return(0);
}
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.
Floating-point calculations always result in loss of precision and rounding
errors. Therefore a very small value (example 1e-99) could be the result of
such errors and should be considered as 0 for the algorithm. epspivot specifies
the tolerance to determine if a pivot element should be considered as 0. If
abs(value) is less than this epspivot value it is considered as 0 and at
first instance rejected as pivot element. Only when no larger other pivot
element can be found and the value is different from 0 it will be used as pivot
element.
The default epspivot value is 2e-7
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL epspivot;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
epspivot = get_epspivot(lp);
delete_lp(lp);
return(0);
}
del_column returns TRUE (1) if the operation was successful. A return
value of FALSE (0) indicates an error.
An error occurs when column is not between 1 and the number of columns
in the lp.
Note that row entry mode must be off, else this function also fails. See set_add_rowmode
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.
Note that column 0 (the right hand side (RHS)) cannot be deleted. There is
always a RHS.
Note that if you can also delete multiple columns by a call to
resize_lp.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(1, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
del_column(lp, 1);
delete_lp(lp);
return(0);
}
Copy 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.
A NULL return value indicates an error. Specifically not enough memory
available to setup an lprec structure.
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int spx_status;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
/* Model created */
/*
.
.
.
*/
spx_status = get_status(lp);
return(0);
}
Specifies which branch to take first in branch-and-bound
algorithm. Can by any of the following values:
BRANCH_CEILING (0)
Take ceiling branch first
BRANCH_FLOOR (1)
Take floor branch first
BRANCH_AUTOMATIC (2)
Algorithm decides which branch being taken first
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.
The default is BRANCH_AUTOMATIC (2).
Note that this setting can be overruled by a user routine to choose the branch. See
put_bb_branchfunc.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_bb_floorfirst(lp, BRANCH_AUTOMATIC);
delete_lp(lp);
return(0);
}
The get_epsel function returns the value that is used for rounding values
to zero. epsel is used on all other places where epsint, epsb, epsd, epspivot,
epsperturb are not used.
The default value for epsel is 1e-12
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL epsel;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
epsel = get_epsel(lp); /* will return 1e-12 */
delete_lp(lp);
return(0);
}
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.
Names are used by default.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int ret;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
ret = is_use_names(lp); /* will return TRUE */
delete_lp(lp);
return(0);
}
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.
The default value is (-) infinity.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL break_at_value;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
break_at_value = get_break_at_value(lp); /* Will return -1e30 */
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_scalelimit(lp, 3.1);
delete_lp(lp);
return(0);
}
doc/Scilab.htm 0000664 0001750 0001750 00000352434 14777273331 012231 0 ustar rene rene
Using lpsolve from Scilab
Using lpsolve from Scilab
Scilab?
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:
To have data types which are varied and flexible with
a syntax which is natural and easy to use.
To provide a reasonable set of primitives which serve
as a basis for a wide variety of calculations.
To have an open programming environment where new primitives are easily
added. A useful tool distributed with Scilab is intersci which is a tool for building interface
programs to add new primitives i.e. to add new modules of Fortran or C code
into Scilab.
To support library development through ``toolboxes'' of functions devoted to
specific applications (linear control, signal processing, network analysis,
non-linear control, etc.)
We will not discuss the specifics of Scilab here but instead refer the reader to the
Scilab website and
documentation.
Scilab and lpsolve
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.
Quickstart
Compile and build sclpsolve:
----------------------------
Get the needed sources and libraries:
Archive lp_solve_5.5.2.14_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.2.14_dev.zip (Windows) or lp_solve_5.5.2.14_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.
Under Windows, the lpsolve library lpsolve55.lib must be available in the lpsolve55 directory.
However older version of scilab (<=3.0) require that this file is called lpsolve55.ilib
In that case copy lpsolve55.lib to lpsolve55.ilib
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.
Start Scilab
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')
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:
-----------------------------------------------------
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.2.14_dev.zip/lp_solve_5.5.2.14_dev.tar.gz and were
installed in the lp_solve_5.5 directory of step 1 of the previous procedure.
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'
Start Scilab
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')
Enter the following command in Scilab:
-->exec loader.sce
Installation
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.2.14_dev.zip/lp_solve_5.5.2.14_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.6
using lpsolve version 5.5.2.14
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).
Solve an lp model from Scilab via sclpsolve
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:
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
An example
(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.)
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:
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:
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);
Using model name instead of handle
From driver version 5.5.0.2, it is possible to use the model name instead of the handle. From the moment the model
has a name, you can use this name instead of the handle. This is best shown by an example. Above example would look
like this:
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.
Matrices
In Scilab, all numerical data is stored in matrices; even a scalar variable. Scilab also supports complex numbers
(a + b * %i with %i=SQRT(-1)). sclpsolve can only work with real numbers.
Scilab also supports sparse matrices. Sparse matrices are matrices where only the non-zero elements are provided
and stored. This results in both less storage and faster calculation if there are a sufficient number of zero values
in the matrix and there usually are. The sclpsolve driver supports both dense and sparse matrices and their use
is totally transparent to the user. Everywhere a matrix can be provided, it can be dense or sparse. However, Scilab
requires for interface programs that sparse matrixes are converted to MATLAB sparse matrices via the function mtlb_sparse(mat).
In the above example all matrices were dense. For example:
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:
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.
Sets
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: cellstr([element1; element1; ...]).
Note the cellstr() function and the ; between each element.
An alternative is the Scilab makecell() function. For example makecell([1,3], element1, element2, element3).
Another alternative is the Scilab cell() function. For example x=cell(1,3); x(1).entries=element1; x(2).entries=element2; x(3).entries=element3
Don't forget that a set of strings must be provided. Don't make the mistake of using the syntax {element1, element2, ...}
because then the following error occurs:
!--error 9999
Invalid string matrix (at most one column!)
!--error 999
SIGSTP: aborting current computation
And also not {element1; element2; ...} because then the following error is given:
!--error 9999
invalid vector
!--error 999
SIGSTP: aborting current computation
This is not an error generated by the sclpsolve driver, but from the Scilab parser because both are not sets.
Maximum usage of matrices/sets with sclpsolve
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.)
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:
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:
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.
Using string constants
From driver version 5.5.2.14 on, it is possible to use string constants
everywhere an lp_solve constant is needed or returned. This is best shown by an example.
In the above code we had:
Note the 3rd parameter on set_verbose and the 4th on add_constraint. These are
lp_solve constants. One could define all the possible constants in Scilab and
then use them in the calls, but that has several disadvantages. First there
stays the possibility to provide a constant that is not intended for that
particular call. Another issue is that calls that return a constant are still
returning it numerical.
Both issues can now be handled by string constants. The above code can be done as
following with string constants:
This is not only more readable, there is much lesser chance that mistakes are
being made. The calling routine knows which constants are possible and only
allows these. So unknown constants or constants that are intended for other
calls are not accepted. For example:
Note the difference between the two error messages. The first says that the
constant is not known, the second that the constant cannot be used at that
place.
Constants are case insensitive. Internally they are always translated to upper
case. Also when returned they will always be in upper case.
The constant names are the ones as specified in the documentation of each API
routine. There are only 3 exceptions, extensions actually. 'LE', 'GE' and 'EQ' in
add_constraint and is_constr_type
can also be '<', '<=', '>', '>=', '='. When returned however, 'GE', 'LE', 'EQ'
will be used.
Also in the matrix version of calls, string constants are possible (hm). For example:
| is the OR operator used to combine multiple constants. There may optinally be
spaces before and after the |.
Not all OR combinations are legal. For example in set_scaling, a choice must be
made between SCALE_EXTREME, SCALE_RANGE, SCALE_MEAN, SCALE_GEOMETRIC or
SCALE_CURTISREID. They may not be combined with each other. This is also tested:
-->sclpsolve('set_scaling', lp, 'SCALE_MEAN|SCALE_RANGE');
SCALE_RANGE cannot be combined with SCALE_MEAN
Everywhere constants must be provided, numeric or string values may be provided.
The routine automatically interpretes them.
Returning constants is a different
story. The user must let lp_solve know how to return it. Numerical or as string.
The default is numerical:
-->sclpsolve('get_scaling', lp)
ans =
131.
To let lp_solve return a constant as string, a call to a new function must be
made: return_constants
-->sclpsolve('return_constants', 1);
From now on, all returned constants are returned as string:
-->sclpsolve('get_scaling', lp)
ans =
SCALE_MEAN|SCALE_INTEGERS
Also when an array of constants is returned, they are returned as string when
return_constants is set:
-->sclpsolve('get_constr_type', lp)
ans =
!"LE" "EQ" "GE" !
This for all routines until return_constants is again called with 0:
-->sclpsolve('return_constants', 0);
The (new) current setting of return_constants is always returned by the call.
Even when set:
-->sclpsolve('return_constants', 1)
ans =
1.
To get the value without setting it, don't provide the second argument:
-->sclpsolve('return_constants')
ans =
1.
In the next part of this documentation, return_constants is the default, 0, so all
constants are returned numerical and provided constants are also numerical. This
to keep the documentation as compatible as possible with older versions. But
don't let you hold that back to use string constants in your code.
Script files
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.
example1.sce
Contains the commands as shown in the first example of this article. Execute via exec example1.sce
example2.sce
Contains the commands as shown in the second example of this article. Execute via exec example2.sce
example3.sce
Contains the commands of a practical example. See further in this article.
example4.sce
Contains the commands of a practical example. See further in this article.
example5.sce
Contains the commands of a practical example. See further in this article.
example6.sce
Contains the commands of a practical example. See further in this article.
lp_solve.sci
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:
Note that you can also provide sparse matrices to this function without having to use mtlb_sparse.
The script is taking care of this.
lp_maker.sci
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.
-->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.
lpdemo.sce
Contains several examples to build and solve lp models. Execute via exec lpdemo.sce
ex.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
A practical example
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.
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:
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.
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:
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:
Availability of seed.This might lead to constraint inequalities like xj < k.
Personal preferences. Thus the farmer's spouse might have a preference
for one variety over another and insist on a corresponding planting,
or something similar with a collection of crops; thus constraint inequalities
like xi < xj or x1 + x2 > x3.
Government subsidies. It may take a moment's reflection on the reader's part,
but this could lead to inequalities like xj > k.
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:
How many crops are under consideration?
What are the corresponding expenses? How much is available for expenses?
What are the yields in each case? What is the storage capacity?
How many acres are available?
What crops are constrained by seed limitations? To what extent?
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.
Another, more theoretical, example
Suppose we want to solve the following linear program using Scilab:
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:
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:
The count argument in the API documentation is not needed in Scilab since the number of elements is derived from the size of the sosvars and weights matrices. These must have the same size.
The bascolumn argument in the API documentation is here the return value. The nonbasic argument is optional in Scilab. If not provided, then 0 is used.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix in the first return value.
If sparse is different from zero then the returned matrix is a sparse matrix.
The return code of the call is the second return value.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
The objfrom, objtill, objfromvalue, objtillvalue arguments in the API documentation
are here the return values. Note that Scilab allows the return of fewer
variables. For example if only objfrom and objtill are needed then the
call can be [objfrom, objtill] = sclpsolve('get_sensitivity_obj',
lp). The unrequested values are even not calculated.
Since the API routine doesn't calculate the objtillvalue value at this time, Scilab always
returns a zero vector for this.
The return code of the call is the last value.
get_sensitivity_obj and get_sensitivity_objex are both implemented, but have the same functionality.
The duals, dualsfrom, dualstill
arguments in the API documentation are here the return values. Note that
Scilab allows the return of fewer variables. For example if only duals is
needed then the call can be [duals] = sclpsolve('get_sensitivity_rhs',
lp). The unrequested values are even not calculated.
The return code of the call is the last value.
get_sensitivity_rhs and get_sensitivity_rhsex are both implemented, but have the same functionality.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Scilab matrix.
The sclpsolve API routine returns the version information in 4 provided argument variables while the Scilab version returns the information as a string in the format major.minor.release.build
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Scilab (Windows) this means
that the output is not shown.
The same information can also be obtained via sclpsolve('get_constraints', lp). This shows the result on screen.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Scilab (Windows) this means
that the output is not shown.
The same information can be obtained via sclpsolve('get_dual_solution', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Scilab (Windows) this means that the output is not shown.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Scilab (Windows) this means
that the output is not shown.
The same information can be obtained via sclpsolve('get_objective', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Scilab (Windows) this means that the output is not shown.
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Scilab (Windows) this means
that the output is not shown.
The same information can also be obtained via sclpsolve('get_variables', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Scilab (Windows) this means that the output is not shown.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Scilab (Windows) this means that the output is not shown.
However, the sclpsolve driver sets a log function to redirect the output of lpsolve from stdout (which is not visible in Windows Scilab) to the command window of Scilab.
As such, all reported output can be seen in Scilab. How much output is seen is controlled by the verbose level that can be defined by set_verbose or can be specified in the read_ routines.
In Scilab, when you name a model, this name can be used everywhere where lp is specified.
This to access the model via the name instead of via a handle.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows to set the whole matrix (all rows/columns) at once.
This is the most performant way to provide the constraint matrix. Consider using a Scilab sparse matrix for maximum performance and least memory usage.
The matrix must be two-dimentional.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all variables. It is then the same as set_obj_fn
In the API description it says that setting filename to NULL results in writing output back to stdout.
In Scilab under Windows, output to stdout it not shown. However it results in closing the file.
Use '' to have the effect of NULL.
In Scilab, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all rows. Note that in this case, the value of row 0 is not specified in the matrix.
Returns the setting of return_constants and optionally sets its value.
Compile the sclpsolve driver
Windows, Unix/Linux
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.2.14_dev.zip/lp_solve_5.5.2.14_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
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.
The get_Nrows function returns the number of rows (constraints) in the lp.
Note that the number of rows can change when a presolve is done.
Therefore it is advisable to use this function to determine how many rows there
are in the lp instead of relying on an own count.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int Nrows;
/* Create a new LP model */
lp = make_lp(1, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
Nrows = get_Nrows(lp); /* Will return 1 */
set_presolve(lp, PRESOLVE_ROWS);
solve(lp);
Nrows = get_Nrows(lp); /* Will return 0 */
delete_lp(lp);
return(0);
}
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.
Note that add_column, add_columnex, str_add_columnadd a column to the model, making the number of columns one larger. These functions change an existing column.
Note that for set_column (and set_columnex when rowno is
NULL) element 0 of the array is row 0 (the objective function), element 1 is row 1, ...
set_columnex has the possibility to specify only the non-zero elements.
In that case rowno specifies the row numbers of the non-zero elements.
And in contrary to set_column,
set_columnex reads the arrays starting from element 0.
This will speed up building the model considerably if there are a lot of zero values.
In most cases the matrix is sparse and has many zero value.
Thus it is almost always
better to use set_columnex instead of set_column. set_columnex
is always at least as performant as set_column.
It is more performant to call these functions than multiple times set_mat.
Note that unspecified values by set_columnex are set to zero.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL column[1+3]; /* must be 1 more than number of rows ! */
REAL sparsecolumn[2]; /* must be the number of non-zero values */
int rowno[2];
/* Create a new LP model */
lp = make_lp(3, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
column[0] = 1.0; /* the objective value */
column[1] = 2.0;
column[2] = 0.0;
column[3] = 3.0;
set_column(lp, 1, column); /* changes the values of existing column 1 */
rowno[0] = 0; sparsecolumn[0] = 1.0; /* the objective value */
rowno[1] = 1; sparsecolumn[1] = 2.0;
rowno[2] = 3; sparsecolumn[2] = 3.0;
set_columnex(lp, 2, 3, sparsecolumn, rowno); /* changes the values of existing column 2 */
delete_lp(lp);
return(0);
}
When TRUE, the simplex strategy is set to SIMPLEX_DUAL_DUAL.
When FALSE, the simplex strategy is set to SIMPLEX_PRIMAL_PRIMAL.
See also get_simplextype
Remarks
The set_preferdual function sets the desired combination of primal and dual simplex algorithms.
set_preferdual with dodual = TRUE is a shortcut for set_simplextype(SIMPLEX_DUAL_DUAL)
set_preferdual with dodual = FALSE is a shortcut for set_simplextype(SIMPLEX_PRIMAL_PRIMAL)
The default is SIMPLEX_DUAL_PRIMAL (6).
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_preferdual(lp, TRUE);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL weights[2];
int priority;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
weights[0] = 2;
weights[1] = 1;
set_var_weights(lp, weights);
priority = get_var_priority(lp, 1); /* will return 2 */
priority = get_var_priority(lp, 2); /* will return 1 */
delete_lp(lp);
return(0);
}
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.
These values are only valid after a successful solve or
lag_solve. Function get_variables needs an array that is already
dimensioned with get_Ncolumns elements. get_ptr_variables
returns a pointer to an array already dimensioned by lp_solve. Element 0 will
contain the value of the first variable, element 1 of the second variable, ...
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL var[2], *ptr_var;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
solve(lp);
get_variables(lp, var);
get_ptr_variables(lp, &ptr_var);
delete_lp(lp);
return(0);
}
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.
Setting a bound on a variable is the way to go instead of adding an extra
constraint (row) to the model. Setting a bound doesn't increase the model size
that means that the model stays smaller and will be solved faster.
Note that the default lower bound of each variable is 0. So variables will
never take negative values if no negative lower bound is set.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL a;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
a = get_lowbo(lp, 1); /* will return 0 since no lower bound was set */
delete_lp(lp);
return(0);
}
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.
The default is not (FALSE) stop at first found solution.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_break_at_first(lp, TRUE);
delete_lp(lp);
return(0);
}
Zimpl 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.
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 can read/write and solve these Zimpl models directly via the xli_Zimpl XLI driver (see External Language Interfaces).
It reads such a model in above format and can solve it then.
Also note that the XLI driver depends on an external dll: zlib1.dll. When it cannot be found on the system, an appropriate
message will be given. This dll must be in a directory specified by the Path environment variable. A common place
is c:\windows\system32. The dll is distributed with the package. The latest version can be found at http://www.zlib.net/
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
Options
The 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.
The 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:
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:
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.
Gets 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.
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.
Note that row can also be 0 with this function. In that case it returns
the initial value of the objective function.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL a;
/* Create a new LP model */
lp = make_lp(2, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
a = get_rh(lp, 1); /* will return 0 since no value was previously set */
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int integer;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
integer = is_int(lp, 1); /* will return 0 since the variable is not set as integer at this point */
delete_lp(lp);
return(0);
}
DIMACS (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:
Given a directed network with upper and lower capacities on each of its arcs, and given a set of external flows
(positive or negative) that need to be routed through this network, find the minimal cost routing of the given flows
through this network. Here, the cost per unit of flow on each arc is assumed to be known.
Network Structure
A network is a directed graph with n nodes and m arcs.
Nodes are identified by integers 1...n.
Graphs do not have to be symmetric: if an arc (v,w) is in the graph,
the reverse arc (w,v) does not have to be in the graph.
Parallel arcs are not allowed.
Self-loops are not allowed.
Arc capacities are 32-bit signed integers.
The source and the sink are distinct.
The sink may be unreachable from the source.
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:
comment lines
problem line
node descriptors
arc descriptors
As noted above, information is collected into lines, which begin with
one-character designators. We describe each type of information line in turn.
Comment Lines: Comment lines give human-readable information about the file and
are ignored by programs. Comment lines can appear anywhere in the file. Each comment line
begins with a lower-case character c.
c This is an example of a comment line.
Problem Line: There is one problem line per input file. The problem line must
appear before any node or arc descriptor lines. For minimum-cost flow network instances
the problem line has the following format:
p min NODES ARCS
The lower-case character p signifies that this is a problem line. The
three-character problem designator min identifies the file as containing
specification information for a minimum-cost flow problem. The NODES field
contains an integer value specifying n, the number of nodes in the network. The ARCS
field contains an integer value specifying m, the number of arcs in the network.
Node Descriptors: All node descriptor lines must appear before all arc descriptor
lines. For minimum-cost flow instances, the node descriptor lines describe supply and
demand nodes, but not transshipment nodes. That is, only nodes with nonzero node supply
values appear. There is one node descriptor line for each such node, with the following
format.
n ID FLOW
The lower-case character n signifies that this is a node descriptor line. The ID
field gives a node identification number, an integer between 1 and n. The FLOW
field gives the amount of supply at node ID.
Arc Descriptors: There is one arc descriptor line for each arc in the network.
For a minimum-cost flow instance, arc descriptor lines are of the following form.
a SRC DST LOW CAP COST
The lower-case character a signifies that this is an arc descriptor line. For
a directed arc (v,w) the SRC field gives the identification number for the
source vertex v, and the DST field gives the destination vertex w.
Identification numbers are integers between 1 and n. The LOW field
specifies the minimum abount of flow that can be sent along arc (v,w), and the CAP
field gives the maximum amount of flow that can be sent along arc (v,w) in a
feasible flow. The COST field contains the per-unit cost of flow sent along arc (v,w).
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.
For example:
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]
This must be interpreted as follows:
There are as many variables as there are arc descriptor lines in the input file and
they appear in the same order. So:
C1 specifies how much flow there is for the first arc definition, in this case from 1 -> 2
C2 specifies how much flow there is for the second arc definition, in this case from 1 -> 3
C3 specifies how much flow there is for the third arc definition, in this case from 2 -> 3
C4 specifies how much flow there is for the fourth arc definition, in this case from 2 -> 4
C5 specifies how much flow there is for the fifth arc definition, in this case from 3 -> 4
This means there is a flow of 2 from node 1 to 2, a flow of 2 from node 1 to 3, a flow of 2 from node
2 to 3, a flow of 0 from node 2 to 4 and a flow of 4 from node 3 to 4.
The value of the objective is the cost of the flow: 2 * 2 + 2 * 2 + 2 * 1 + 0 * 3 + 4 * 1 = 14
Output :
The solution of the model can also be written in a DIMACS format:
comment lines
solution lines
flow assignments
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.
Comment Lines: Comment lines give human-readable information about the file and
are ignored by programs. Comment lines can appear anywhere in the file. Each comment line
begins with a lower-case character c.
c This is an example of a comment line.
Solution line.
The solution line contains the flow value and has the following format:
s VALUE
The lower-case character s signifies that this is a solution line.
The VALUE field
contains the value of the objective.
Flow assignments.
There is one flow assignment line for each arc in the input network.
These lines have the following format:
f SRC DST FLOW
The lower-case character f signifies that this is a flow assignment line. For arc (u,v), the SRC and DST fields give v and w, respectively. The FLOW field gives the amount of flow assigned to arc (u,v).
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.
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
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
unsigned char trace;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
trace = is_trace(lp); /* Will return FALSE */
delete_lp(lp);
return(0);
}
doc/octave.htm 0000664 0001750 0001750 00000326651 14777273331 012317 0 ustar rene rene
Using lpsolve from Octave
Using lpsolve from Octave
Octave?
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.
Octave and lpsolve
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:
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.
Installation
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.2.14_dev.zip/lp_solve_5.5.2.14_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.6
using lpsolve version 5.5.2.14
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.
Solve an lp model from Octave via octlpsolve
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:
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
An example
(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)
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:
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:
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);
Using model name instead of handle
From driver version 5.5.0.2, it is possible to use the model name instead of the handle. From the moment the model
has a name, you can use this name instead of the handle. This is best shown by an example. Above example would look
like this:
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.
Matrices
In Octave, all numerical data is stored in matrices; even a scalar variable. Octave also supports complex numbers
(a + b * i with i=sqrt(-1)). octlpsolve can only work with real numbers.
For example:
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:
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.
Sets
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.
Maximum usage of matrices/sets with octlpsolve
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)
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.
Using string constants
From driver version 5.5.2.14 on, it is possible to use string constants
everywhere an lp_solve constant is needed or returned. This is best shown by an example.
In the above code we had:
Note the 3rd parameter on set_verbose and the 4th on add_constraint. These are
lp_solve constants. One could define all the possible constants in Octave and
then use them in the calls, but that has several disadvantages. First there
stays the possibility to provide a constant that is not intended for that
particular call. Another issue is that calls that return a constant are still
returning it numerical.
Both issues can now be handled by string constants. The above code can be done as
following with string constants:
This is not only more readable, there is much lesser chance that mistakes are
being made. The calling routine knows which constants are possible and only
allows these. So unknown constants or constants that are intended for other
calls are not accepted. For example:
Note the difference between the two error messages. The first says that the
constant is not known, the second that the constant cannot be used at that
place.
Constants are case insensitive. Internally they are always translated to upper
case. Also when returned they will always be in upper case.
The constant names are the ones as specified in the documentation of each API
routine. There are only 3 exceptions, extensions actually. 'LE', 'GE' and 'EQ' in
add_constraint and is_constr_type
can also be '<', '<=', '>', '>=', '='. When returned however, 'GE', 'LE', 'EQ'
will be used.
Also in the matrix version of calls, string constants are possible. For example:
| is the OR operator used to combine multiple constants. There may optinally be
spaces before and after the |.
Not all OR combinations are legal. For example in set_scaling, a choice must be
made between SCALE_EXTREME, SCALE_RANGE, SCALE_MEAN, SCALE_GEOMETRIC or
SCALE_CURTISREID. They may not be combined with each other. This is also tested:
octave:> octlpsolve('set_scaling', lp, 'SCALE_MEAN|SCALE_RANGE');
error: SCALE_RANGE cannot be combined with SCALE_MEAN
Everywhere constants must be provided, numeric or string values may be provided.
The routine automatically interpretes them.
Returning constants is a different
story. The user must let lp_solve know how to return it. Numerical or as string.
The default is numerical:
octave:> octlpsolve('get_scaling', lp)
ans = 131
To let lp_solve return a constant as string, a call to a new function must be
made: return_constants
octave:> octlpsolve('return_constants', 1);
From now on, all returned constants are returned as string:
octave:> octlpsolve('get_scaling', lp)
ans = SCALE_MEAN|SCALE_INTEGERS
Also when an array of constants is returned, they are returned as string when
return_constants is set:
octave:> octlpsolve('get_constr_type', lp)
ans =
{
[1,1] = LE
[1,2] = EQ
[1,3] = GE
}
This for all routines until return_constants is again called with 0:
octave:> octlpsolve('return_constants', 0);
The (new) current setting of return_constants is always returned by the call.
Even when set:
octave:> octlpsolve('return_constants', 1)
ans = 1
To get the value without setting it, don't provide the second argument:
octave:> octlpsolve('return_constants')
ans = 1
In the next part of this documentation, return_constants is the default, 0, so all
constants are returned numerical and provided constants are also numerical. This
to keep the documentation as compatible as possible with older versions. But
don't let you hold that back to use string constants in your code.
Script files
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).
example1.m
Contains the commands as shown in the first example of this article.
example2.m
Contains the commands as shown in the second example of this article.
example3.m
Contains the commands of a practical example. See further in this article.
example4.m
Contains the commands of a practical example. See further in this article.
example5.m
Contains the commands of a practical example. See further in this article.
example6.m
lp_solve.m
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:
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.
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);
lpdemo.m
Contains several examples to build and solve lp models.
ex.m
Contains several examples to build and solve lp models.
Also solves the lp_examples from the lp_solve distribution.
A practical example
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.
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.
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:
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:
Availability of seed.This might lead to constraint inequalities like xj < k.
Personal preferences. Thus the farmer's spouse might have a preference
for one variety over another and insist on a corresponding planting,
or something similar with a collection of crops; thus constraint inequalities
like xi < xj or x1 + x2 > x3.
Government subsidies. It may take a moment's reflection on the reader's part,
but this could lead to inequalities like xj > k.
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:
How many crops are under consideration?
What are the corresponding expenses? How much is available for expenses?
What are the yields in each case? What is the storage capacity?
How many acres are available?
What crops are constrained by seed limitations? To what extent?
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.
Another, more theoretical, example
Suppose we want to solve the following linear program using Octave:
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
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:
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.
The count argument in the API documentation is not needed in Octave since the number of elements is derived from the size of the sosvars and weights matrices. These must have the same size.
The bascolumn argument in the API documentation is here the return value. The nonbasic argument is optional in Octave. If not provided, then 0 is used.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix in the first return value.
The return code of the call is the second return value.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
The objfrom, objtill, objfromvalue, objtillvalue arguments in the API documentation
are here the return values. Note that Octave allows the return of fewer
variables. For example if only objfrom and objtill are needed then the
call can be [objfrom, objtill] = octlpsolve('get_sensitivity_obj',
lp). The unrequested values are even not calculated.
Since the API routine doesn't calculate the objtillvalue value at this time, Octave always
returns a zero vector for this.
The return code of the call is the last value.
get_sensitivity_obj and get_sensitivity_objex are both implemented, but have the same functionality.
The duals, dualsfrom, dualstill
arguments in the API documentation are here the return values. Note that
Octave allows the return of fewer variables. For example if only duals is
needed then the call can be [duals] = octlpsolve('get_sensitivity_rhs',
lp). The unrequested values are even not calculated.
The return code of the call is the last value.
get_sensitivity_rhs and get_sensitivity_rhsex are both implemented, but have the same functionality.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into an Octave matrix.
The octlpsolve API routine returns the version information in 4 provided argument variables while the Octave version returns the information as a string in the format major.minor.release.build
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Octave (Windows) this means
that the output is not shown.
The same information can also be obtained via octlpsolve('get_constraints', lp). This shows the result on screen.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Octave (Windows) this means
that the output is not shown.
The same information can be obtained via octlpsolve('get_dual_solution', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Octave (Windows) this means that the output is not shown.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Octave (Windows) this means
that the output is not shown.
The same information can be obtained via octlpsolve('get_objective', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Octave (Windows) this means that the output is not shown.
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Octave (Windows) this means
that the output is not shown.
The same information can also be obtained via octlpsolve('get_variables', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Octave (Windows) this means that the output is not shown.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Octave (Windows) this means that the output is not shown.
However, the octlpsolve driver sets a log function to redirect the output of lpsolve from stdout (which is not visible in Windows Octave) to the command window of Octave.
As such, all reported output can be seen in Octave. How much output is seen is controlled by the verbose level that can be defined by set_verbose or can be specified in the read_ routines.
In Octave, when you name a model, this name can be used everywhere where lp is specified.
This to access the model via the name instead of via a handle.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows to set the whole matrix (all rows/columns) at once.
This is the most performant way to provide the constraint matrix.
The matrix must be two-dimentional.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all variables. It is then the same as set_obj_fn
In the API description it says that setting filename to NULL results in writing output back to stdout.
In Octave under Windows, output to stdout it not shown. However it results in closing the file.
Use '' to have the effect of NULL.
In Octave, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all rows. Note that in this case, the value of row 0 is not specified in the matrix.
Returns the setting of return_constants and optionally sets its value.
Compile the octlpsolve driver
Windows
To compile the Octave driver under Windows, the cygwin environment is needed. The following document describes
what is needed for this: README.Windows. It may not
be needed to build the Octave sources to compile the binary file, but the proposed cygwin and octave packages
are needed to build a .oct file.
The build must be done from the cygwin prompt from the directory where the lpsolve octave files are located.
To make the compilation process easier, a script file can be used: ccc.win32
To make for release, just enter ./ccc.win32 and everything is build.
Unix/Linux
The build must be done from a shell prompt from the directory where the lpsolve octave files are located.
To make the compilation process easier, a script file can be used: ccc
To make for release, just enter sh ccc and everything is build.
All platforms
This compiles three source files: lpsolve.cpp, octave.cpp and hash.cpp
Then these are linked together to generate the octlpsolve.oct file.
The optional arguments to ccc are used for development. Source files can be provided
and then only these are compiled. For example hash.cpp should only be compiled
once while developing. So specifying lpsolve.cpp 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
octlpsolve. Should only be used for debugging purposes.
The 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.
In some cases, negative variables must be split in a positive part and a
negative part. This is when a negative lower or upper bound is set on a
variable. If a bound is less than this value, it is possibly split.
The default is -1e6.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
REAL negrange;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
negrange = get_negrange(lp);
delete_lp(lp);
return(0);
}
If the phase 1 solution process finds that a constraint is redundant then this constraint is deleted.
This is no longer active since it is very rare that this is effective, and also that it adds code complications and delayed presolve effects that are not captured properly.
PRESOLVE_KNAPSACK (128)
Simplification of knapsack-type constraints through addition of an extra variable, which also helps bound the OF
PRESOLVE_ELIMEQ2 (256)
Direct substitution of one variable in 2-element equality constraints; this requires changes to the constraint matrix.
Elimeq2 simply eliminates a variable by substitution when you have 2-element equality constraints. This can sometimes cause fill-in of the constraint matrix, and also be a source of rounding errors which can lead to problems in the simplex.
PRESOLVE_IMPLIEDFREE (512)
Identify implied free variables (releasing their explicit bounds)
PRESOLVE_REDUCEGCD (1024)
Reduce (tighten) coefficients in integer models based on GCD argument.
Reduce GCD is for mixed integer programs where it is possible to adjust the constraint coefficies due to integrality. This can cause the dual objective ("lower bound") to increase and may make it easier to prove optimality.
PRESOLVE_PROBEFIX (2048)
Attempt to fix binary variables at one of their bounds
PRESOLVE_PROBEREDUCE (4096)
Attempt to reduce coefficients in binary models
PRESOLVE_ROWDOMINATE (8192)
Idenfify and delete qualifying constraints that are dominated by others, also fixes variables at a bound
PRESOLVE_COLDOMINATE (16384)
Deletes variables (mainly binary), that are dominated by others (only one can be non-zero)
PRESOLVE_MERGEROWS (32768)
Merges neighboring >= or <= constraints when the vectors are otherwise relatively identical into a single ranged constraint
PRESOLVE_IMPLIEDSLK (65536)
Converts qualifying equalities to inequalities by converting a column singleton variable to slack. The routine also detects implicit duplicate slacks from inequality constraints, fixes and removes the redundant variable.This latter removal also tends to reduce the risk of degeneracy.The combined function of this option can have a dramatic simplifying effect on some models.
Implied slacks is when, for example, there is a column singleton (with zero OF) in an equality constraint. In this case, the column can be deleted and the constraint converted to a LE constraint.
PRESOLVE_COLFIXDUAL (131072)
Variable fixing and removal based on considering signs of the associated dual constraint.
Dual fixing is when the (primal) variable can be fixed due to the implied value of the dual being infinite.
PRESOLVE_BOUNDS (262144)
Does bound tightening based on full-row constraint information. This can assist in tightening the OF bound, eliminate variables and constraints. At the end of presolve, it is checked if any variables can be deemed free, thereby reducing any chance that degeneracy is introduced via this presolve option.
PRESOLVE_DUALS (524288)
Calculate duals
PRESOLVE_SENSDUALS (1048576)
Calculate sensitivity if there are integer variables
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.
The default is not (FALSE) doing a presolve.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int presolve;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
presolve = is_presolve(lp, PRESOLVE_ROWS | PRESOLVE_COLS); /* Will return FALSE */
delete_lp(lp);
return(0);
}
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.
The default mip_gap value is 1e-11
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_mip_gap(lp, TRUE, 1.0e-8); /* sets absolute mip_gap to 1e-8 */
delete_lp(lp);
return(0);
}
The get_max_level function returns the deepest Branch-and-bound level of
the last solution.
Is only applicable if the model contains integer variables.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int max_level;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
max_level = get_max_level(lp);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int isSOS;
/* Create a new LP model */
lp = make_lp(0, 1);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
isSOS = is_SOS_var(lp, 1); /* will return 0 since the variable is not an SOS var at this point */
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_int(lp, 1, TRUE); /* sets variable 1 to integer */
delete_lp(lp);
return(0);
}
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.
lower
The lower bound on the variable identified by column.
upper
The upper bound on the variable identified by column.
Remarks
The set_bounds function sets a lower and upper bound on the variable
identified by column.
Setting a bound on a variable is the way to go instead of adding an extra
constraint (row) to the model. Setting a bound doesn't increase the model size
that means that the model stays smaller and will be solved faster.
Note that the default lower bound of each variable is 0. So variables will
never take negative values if no negative lower bound is set. The default upper
bound of a variable is infinity (well not quite. It is a very big number, the value of get_infinite).
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 2);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_bounds(lp, 1, 1.0, 2.0);
delete_lp(lp);
return(0);
}
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.
This can only be done after a successful solve. If the model is not successively solved then
the function will return FALSE.
The array receives the basic variables and if nonbasic is TRUE, then
also the non-basic variables. If an element is less then zero then it means on
lower bound, else on upper bound.
Element 0 of the array is set to 0.
The default initial basis is bascolumn[x] = -x.
Each element represents a basis variable. If the absolute value is between 1
and get_Nrows, it represents a slack variable and
if it is between get_Nrows+1 and
get_Nrows+get_Ncolumns then it
represents a regular variable. If the value is negative, then the variable is
on its lower bound. If positive it is on its upper bound.
Setting an initial basis can speed up the solver considerably. It is the
starting point from where the algorithm continues to find an optimal solution.
When a restart is done, lp_solve continues at the last basis, except if
set_basis, default_basis, guess_basis or read_basis is called.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int bascolumn[1+2]; /* must be 1 more then number of rows ! */
/* Create a new LP model */
lp = make_lp(2, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
/* build model
.
.
.
*/
solve(lp);
get_basis(lp, bascolumn, FALSE);
delete_lp(lp);
return(0);
}
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.
However, the function does not add rows/columns to the model if the new number
of rows/columns is larger. It does however changes internal memory allocations to the new
specified sizes. This to make the
add_constraint, add_constraintex, str_add_constraint and
add_column, add_columnex, str_add_column routines faster.
Without resize_lp, these functions have to reallocated memory at each call for the new
dimensions. However if resize_lp is used, then memory reallocation must be done only once
resulting in better performance. So if the number of rows/columns that will be added is known
in advance, then performance can be improved by using this function.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 3);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
/* Model created */
/* 1000 constraints will be added, so allocate memory for it in advance to make things faster */
resize_lp(lp, 1000, get_Ncolumns(lp));
/* Now add the 1000 constraints */
delete_lp(lp);
return(0);
}
doc/Sysquake.htm 0000664 0001750 0001750 00000346331 14777273331 012640 0 ustar rene rene
Using lpsolve from Sysquake
Using lpsolve from Sysquake
Sysquake?
Sysquake is an interactive design CAD tool for getting insight into complicated scientific problems and designing
advanced technical devices.
To design technical devices, or to understand the physical and mathematical
laws which describe their behavior, engineers and scientists frequently use
computers to calculate and represent graphically different quantities, such as
the sample sequence and the frequency response of a digital audio filter,
or the trajectory and the mass of a rocket flying to Mars.
Usually, these quantities are related to each other; they are different
views of the same reality. Understanding these relationships is the key to a
good design. In some cases, especially for simple systems, an intuitive
understanding can be acquired. For more complicated systems, it is often
difficult or impossible to "guess", for instance, whether increasing the
thickness of a robot arm will increase or decrease the frequency of the oscillations.
Traditionally, the design of a complicated system is performed in several
iterations. Specifications can seldom be used directly to calculate the value
of the parameters of the system, because there is no explicit formula to link
them. Hence each iteration is made of two phases. The first one, often called
synthesis, consists in calculating the unknown parameters of the system
based on a set of design variables. The design variables are more or
less loosely related to the specifications. During the second phase, called
analysis, the performance of the system is evaluated and compared
to the specifications. If it does not match them, the design variables are
modified and a new iteration is carried out.
When the relationship between the criteria used for evaluating the performance
and the design parameters is not very well known, modifications of the design
parameters might lead as well to poorer performance as to better one. Manual
trial and error may work but is cumbersome. This is where interactive design
may help. Instead of splitting each iteration between synthesis and analysis,
both phases are merged into a single one where the effect of modifying a parameter
results immediately in the update of graphics. The whole design procedure
becomes really dynamic; the engineer perceives the gradient of the change of
performance criteria with respect to what he manipulates, and the compromises
which can be obtained are easily identified.
Sysquake's purpose is to support this kind of design in fields such as automatic
control and signal processing. Several graphics are displayed simultaneously,
and some of them contain elements which can be manipulated with the mouse.
During the manipulation, all the graphics are updated to reflect the change.
What the graphics show and how their update is performed are not fixed, but
depend on programs written in an easy-to-learn language specialized for numerical
computation. Several programs are included with Sysquake for common tasks, such
as the design of PID controllers; but you are free to modify
them to better suit your needs and to write new ones for other design methods or
new applications.
Another area where Sysquake shines is teaching. Replacing the static figures
you find in books or the animations you see on the Web with interactive graphics,
where the student can manipulate himself the curves to acquire an intuitive
understanding of the theory they represent, accelerates and improves the learning
process tremendously.
We will not discuss the specifics of Sysquake here but instead refer the reader to the
Sysquake website and
documentation.
Sysquake and lpsolve
lpsolve is callable from Sysquake via an external interface or external code. As such, it looks like lpsolve is fully integrated
with Sysquake. Matrices can directly be transferred between Sysquake 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
Sysquake (especially for matrix support). So you have full control to the complete lpsolve functionality via the sqlpsolve
Sysquake driver. If you find that this involves too much work to solve an lp model then you can also work via a higher-level
library that can make things a lot easier. See further in this article.
Sysquake 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
Sysquake is required to effect a solution.
Although there is a free version of Sysquake (Sysquake LE), it does not support to call
external library code as needed by lpsolve. As such, the lpsolve link to Sysquake only works
with the commercial version.
Installation
To make this possible, a driver program is needed: sqlpsolve (sqlpsolvext.dll under Windows, sqlpsolvext.so under Unix/Linux).
This driver must be put in a directory known to Sysquake (LMEExt under Windows, sys under Unix/Linux) and Sysquake can call the sqlpsolve 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.2.14_dev.zip/lp_solve_5.5.2.14_dev.tar.gz). This has the advantage that the sqlpsolve 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 Sysquake lpsolve driver that is called sqlpsolve, its physical name on disk (sqlpsolvext.*) and the lpsolve library that implements the
API that is named lpsolve55.* on disk.
There is also the sqlpsolve.lml higher level library file and some example library files (.lml) as a quick start.
To test if everything is installed correctly, enter sqlpsolve(); in the Sysquake command window.
If it gives the following, then everything is ok:
sqlpsolve Sysquake Interface version 5.5.0.7
using lpsolve version 5.5.2.14
Usage: ret = sqlpsolve('functionname', arg1, arg2, ...)
However, if you get the following:
Undefined function 'sqlpsolve'
Then Sysquake cannot find either sqlpsolve.dll/sqlpsolve.so or lpsolve55.dll/liblpsolve55.so.
On Unix/Linux, if liblpsolve55.so cannot be found, then an error message is also displayed when Sysquake is started
when all external libraries are loaded:
liblpsolve55.so: cannot open shared object file: No such file or directory
Unfortunately, under Windows no message at all is shown and you can't know if the problem
is that sqlpsolveext.dll cannot be found or lpsolve55.dll.
Note that it is necessary to restart Sysquake after having put the files in the specified directory.
Sysquake loads the libraries only at startup. When started, a list of loaded extensions is given.
Make sure that between the list, there is also:
lpsolve extension: sqlpsolve
You can also use the following Sysquake command:
info b
A list of loaded extension functions is given. LME/sqlpsolve must be in the list to be ok.
All this is developed and tested with Sysquake version 4.1 Pro.
Solve an lp model from Sysquake via sqlpsolve
In the following text, > before the Sysquake commands is the Sysquake prompt.
Only the text after > must be entered.
To call an lpsolve function, the following syntax must be used:
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 Sysquake specific functions.
Most of the lpsolve API routines use or return an lprec structure. To make things more robust in Sysquake, 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 Sysquake 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 Sysquake, nothing must
be dimensioned in advance. The sqlpsolve driver takes care of dimensioning all return variables and they are
always returned as return value of the call to sqlpsolve. Never as argument to the routine. This can be a single
value as for get_objective (although Sysquake 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.
Constants
Some API calls needs constant arguments. For example add_constraint has the constants
LE, GE, EQ to define if the added constraint is a less than, greater than, equal to the RHS.
Although it is legal and possible to use the constant numbers itself, it is easier, clearer and much readable to use labels.
In this documentation these are used everywere. They are not defined in the external library sqlpsolveext.dll/so.
They are however defined in the library sqlpsolve.lml. To use these, the library must first be loaded in Sysquaqe via a use statement:
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:
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:
It is always possible to show the contents of a variable by just giving it as command:
> x
x =
28.6000
0.0000
0.0000
31.8276
Don't forget to free the handle and its associated memory when you are done:
> sqlpsolve('delete_lp', lp);
Using model name instead of handle
From driver version 5.5.0.2, it is possible to use the model name instead of the handle. From the moment the model
has a name, you can use this name instead of the handle. This is best shown by an example. Above example would look
like this:
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 Sysquake routine to get the handle from the model name: get_handle.
For example:
> sqlpsolve('get_handle', 'mymodel')
ans =
0
Don't forget to free the handle and its associated memory when you are done:
> sqlpsolve('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.
Matrices
In Sysquake, all numerical data is stored in matrices; even a scalar variable. Sysquake also supports complex numbers
(a + b * i with i=SQRT(-1)). sqlpsolve can only work with real numbers.
Most of the time, variables are used to provide the data:
Note that if a matrix is provided, the dimension must exactly match the dimension that is expected by
sqlpsolve. Matrices with too few or too much elements gives an 'invalid vector.' error.
Most of the time, sqlpsolve 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:
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 Sysquake 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 Sysquake matrix.
Sets
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, Sysquake 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.
Maximum usage of matrices/sets with sqlpsolve
Because Sysquake 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 sqlpsolve Sysquake 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 sqlpsolve Sysquake driver however also allows specifying a vector to set the integer
status of all variables at once. The API call is: return = sqlpsolve('set_int', lp, column, must_be_int). The
matrix version of this call is: return = sqlpsolve('set_int', lp, [must_be_int]).
The API call to return the integer status of a variable is: return = sqlpsolve('is_int', lp, column). The
matrix version of this call is: [is_int] = sqlpsolve('is_int', lp)
Also note the get_mat and set_mat routines. In Sysquake 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 executing the
command from example2.lml as follows:
use example2; example2;
This will execute example2.lml. It will also echo the executes commands. See also libraries)
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:
> A=sqlpsolve('get_mat', lp);
> X=sqlpsolve('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:
> sqlpsolve('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=sqlpsolve('get_obj_fn', lp);
> X=sqlpsolve('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:
> sqlpsolve('get_objective', lp)
ans =
31.7828
Again exactly the same as the calculated obj value, as expected.
Using string constants
From driver version 5.5.2.14 on, it is possible to use string constants
everywhere an lp_solve constant is needed or returned. This is best shown by an example.
In the above code we had:
Note the 3rd parameter on set_verbose and the 4th on add_constraint. These are
lp_solve constants. One can define all the possible constants in Sysquake as is
done in the sqlpsolve library and
then use them in the calls, but that has several disadvantages. First there
stays the possibility to provide a constant that is not intended for that
particular call. Another issue is that calls that return a constant are still
returning it numerical.
Both issues can now be handled by string constants. The above code can be done as
following with string constants:
This is not only more readable, there is much lesser chance that mistakes are
being made. The calling routine knows which constants are possible and only
allows these. So unknown constants or constants that are intended for other
calls are not accepted. For example:
Note the difference between the two error messages. The first says that the
constant is not known, the second that the constant cannot be used at that
place.
Constants are case insensitive. Internally they are always translated to upper
case. Also when returned they will always be in upper case.
The constant names are the ones as specified in the documentation of each API
routine. There are only 3 exceptions, extensions actually. 'LE', 'GE' and 'EQ' in
add_constraint and is_constr_type
can also be '<', '<=', '>', '>=', '='. When returned however, 'GE', 'LE', 'EQ'
will be used.
Also in the matrix version of calls, string constants are possible. For example:
| is the OR operator used to combine multiple constants. There may optinally be
spaces before and after the |.
Not all OR combinations are legal. For example in set_scaling, a choice must be
made between SCALE_EXTREME, SCALE_RANGE, SCALE_MEAN, SCALE_GEOMETRIC or
SCALE_CURTISREID. They may not be combined with each other. This is also tested:
> sqlpsolve('set_scaling', lp, 'SCALE_MEAN|SCALE_RANGE');
SCALE_RANGE cannot be combined with SCALE_MEAN
Everywhere constants must be provided, numeric or string values may be provided.
The routine automatically interpretes them.
Returning constants is a different
story. The user must let lp_solve know how to return it. Numerical or as string.
The default is numerical:
> sqlpsolve('get_scaling', lp)
ans =
131
To let lp_solve return a constant as string, a call to a new function must be
made: return_constants
> sqlpsolve('return_constants', 1);
From now on, all returned constants are returned as string:
> sqlpsolve('get_scaling', lp)
ans =
SCALE_MEAN|SCALE_INTEGERS
Also when an array of constants is returned, they are returned as string when
return_constants is set:
> sqlpsolve('get_constr_type', lp)
ans =
{'LE','EQ','GE'}
This for all routines until return_constants is again called with 0:
> sqlpsolve('return_constants', 0);
The (new) current setting of return_constants is always returned by the call.
Even when set:
> sqlpsolve('return_constants', 1)
ans =
1
To get the value without setting it, don't provide the second argument:
> sqlpsolve('return_constants')
ans =
1
In the next part of this documentation, return_constants is the default, 0, so all
constants are returned numerical and provided constants are also numerical. This
to keep the documentation as compatible as possible with older versions. But
don't let you hold that back to use string constants in your code.
libraries
Sysquake can execute a sequence of statements stored in diskfiles. Such files are called
"libraries". They must have the file type of ".lml" as the last part of their filename (extension).
These files are usually created using your local editor.
Note that for Sysquake to be able to find these libraries that they must be put in a special directory named Lib
under the Sysquake directory or the file path where the libraries are put must be identified to Sysquake.
If you are working with the GUI version of Sysquake, this can be done via the menu option Edit, Preferences and then
'Set SQ File Path' or 'Path'. In that input multiple directories can be specified, line per line.
This path can also be seen and changed via the Sysquake path command.
To use a library, it must first be loaded via the following command in Sysquake:
use libraryname
With libraryname the name of the library, without its extension.
From that moment on, functions defined in it can be called directly from Sysquake.
All lpsolve examples use as functionname the same name as the libraryname.
The sqlpsolve Sysquake distribution contains some example library files to demonstrate this.
To see the contents of such a file also edit these files with your
favourite text editor (or notepad).
example1.lml
Contains the commands as shown in the first example of this article.
example2.lml
Contains the commands as shown in the second example of this article.
example3.lml
Contains the commands of a practical example. See further in this article.
example4.lml
Contains the commands of a practical example. See further in this article.
example5.lml
Contains the commands of a practical example. See further in this article.
example6.lml
Contains the commands of a practical example. See further in this article.
sqlpsolve.lml
This library contains some higher-level functions to simplify things. To use it, first give following Sysquake command:
use sqlpsolve;
lp_solve
The first function herein is called lp_solve.
It 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:
> use sqlpsolve
> 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:
A second function in sqlpsolve.lml is lp_maker. It is analog to lp_solve and also uses the API to create the higher-level function.
This function accepts as arguments some matrices and options to create an lp model. Note that this function only
creates a model and returns a handle.
type help lp_maker or just lp_maker to see its usage:
> use sqlpsolve
> 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.
> sqlpsolve('solve', lp)
ans =
0
> sqlpsolve('get_objective', lp)
ans =
3
> sqlpsolve('get_variables', lp)
ans =
1
2
Don't forget to free the handle and its associated memory when you are done:
> sqlpsolve('delete_lp', lp);
lpdemo.lml
Contains several examples to build and solve lp models.
ex.lml
Contains several examples to build and solve lp models.
Also solves the lp_examples from the lp_solve distribution.
A practical example
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 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 example3.lml
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:
> use sqlpsolve
> 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:
> use sqlpsolve
> 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 = sqlpsolve('solve', lp)
solvestat =
0.00
> format bank
> obj = sqlpsolve('get_objective', lp)
obj =
6315.63
> format short
> x = sqlpsolve('get_variables', lp)
x =
21.8750
53.1250
> sqlpsolve('delete_lp', lp);
Note that these command are in example4.lml
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:
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:
> use sqlpsolve
> 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 = sqlpsolve('solve', lp)
solvestat =
0
> format bank
> obj = sqlpsolve('get_objective', lp)
obj =
6986.84
> format short
> x = sqlpsolve('get_variables', lp)
x =
0.0000
56.5789
18.4211
> sqlpsolve('delete_lp', lp);
Note that these command are in example5.lml
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 Sysquake 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 Sysquake 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:
Availability of seed.This might lead to constraint inequalities like xj < k.
Personal preferences. Thus the farmer's spouse might have a preference
for one variety over another and insist on a corresponding planting,
or something similar with a collection of crops; thus constraint inequalities
like xi < xj or x1 + x2 > x3.
Government subsidies. It may take a moment's reflection on the reader's part,
but this could lead to inequalities like xj > k.
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:
How many crops are under consideration?
What are the corresponding expenses? How much is available for expenses?
What are the yields in each case? What is the storage capacity?
How many acres are available?
What crops are constrained by seed limitations? To what extent?
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.
Another, more theoretical, example
Suppose we want to solve the following linear program using Sysquake:
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 Sysquake:
> use sqlpsolve
> 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 Sysquake: Type the commands
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 Sysquake 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:
> use sqlpsolve
> lp = lp_maker(f, A, b, [-1; -1; -1], l, u, [], 1, 0);
> solvestat = sqlpsolve('solve', lp)
solvestat =
0
> obj = sqlpsolve('get_objective', lp)
obj =
2.6667
> x = sqlpsolve('get_variables', lp)
x =
0.6667
-0.3333
0.6667
> sqlpsolve('delete_lp', lp);
Overview of API routines
Note that everwhere where lp is used as argument that this can be a handle (lp_handle) or the models name.
The count argument in the API documentation is not needed in Sysquake since the number of elements is derived from the size of the sosvars and weights matrices. These must have the same size.
The bascolumn argument in the API documentation is here the return value. The nonbasic argument is optional in Sysquake. If not provided, then 0 is used.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix in the first return value.
sparse is ignored in Sysquake.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
The objfrom, objtill, objfromvalue, objtillvalue arguments in the API documentation
are here the return values. Note that Sysquake allows the return of fewer
variables. For example if only objfrom and objtill are needed then the
call can be [objfrom, objtill] = sqlpsolve('get_sensitivity_obj',
lp). The unrequested values are even not calculated.
Since the API routine doesn't calculate the objtillvalue value at this time, Sysquake always
returns a zero vector for this.
The return code of the call is the last value.
get_sensitivity_obj and get_sensitivity_objex are both implemented, but have the same functionality.
The duals, dualsfrom, dualstill
arguments in the API documentation are here the return values. Note that
Sysquake allows the return of fewer variables. For example if only duals is
needed then the call can be [duals] = sqlpsolve('get_sensitivity_rhs',
lp). The unrequested values are even not calculated.
The return code of the call is the last value.
get_sensitivity_rhs and get_sensitivity_rhsex are both implemented, but have the same functionality.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a Sysquake matrix.
The sqlpsolve API routine returns the version information in 4 provided argument variables while the Sysquake version returns the information as a string in the format major.minor.release.build
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Sysquake (Windows) this means
that the output is not shown.
The same information can also be obtained via sqlpsolve('get_constraints', lp). This shows the result on screen.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Sysquake (Windows) this means
that the output is not shown.
The same information can be obtained via sqlpsolve('get_dual_solution', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Sysquake (Windows) this means that the output is not shown.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Sysquake (Windows) this means
that the output is not shown.
The same information can be obtained via sqlpsolve('get_objective', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Sysquake (Windows) this means that the output is not shown.
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under Sysquake (Windows) this means
that the output is not shown.
The same information can also be obtained via sqlpsolve('get_variables', lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Sysquake (Windows) this means that the output is not shown.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under Sysquake (Windows) this means that the output is not shown.
However, the sqlpsolve driver sets a log function to redirect the output of lpsolve from stdout (which is not visible in Windows Sysquake) to the command window of Sysquake.
As such, all reported output can be seen in Sysquake. How much output is seen is controlled by the verbose level that can be defined by set_verbose or can be specified in the read_ routines.
In Sysquake, when you name a model, this name can be used everywhere where lp is specified.
This to access the model via the name instead of via a handle.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows to set the whole matrix (all rows/columns) at once.
This is the most performant way to provide the constraint matrix.
The matrix must be two-dimentional.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all variables. It is then the same as set_obj_fn
In the API description it says that setting filename to NULL results in writing output back to stdout.
In Sysquake under Windows, output to stdout it not shown. However it results in closing the file.
Use '' to have the effect of NULL.
In Sysquake, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all rows. Note that in this case, the value of row 0 is not specified in the matrix.
Returns the setting of return_constants and optionally sets its value.
Compile the sqlpsolve driver
Under Windows, the sqlpsolve Sysquake driver is a dll: sqlpsolvext.dll
Under Unix/Linux, the sqlpsolve Sysquake driver is a shared library.: sqlpsolvext.so
This driver is an interface to the lpsolve library lpsolve55.dll/liblpsolve55.so that contains the implementation of lp_solve.
lpsolve55.dll/liblpsolve55.so is distributed with the lp_solve package (archive lp_solve_5.5.2.14_dev.zip/lp_solve_5.5.2.14_dev.tar.gz).
The sqlpsolve Sysquake driver is just a wrapper between Sysquake and lp_solve to translate the input/output to/from Sysquake and the lp_solve library.
Compilation
The sqlpsolve Sysquake driver is written in C. To compile this code, under Windows the Microsoft visual C compiler is needed and under Unix/Linux the standard cc compiler.
The needed commands are in a batch file/script.
Under Windows it is called cvc.bat, under Unix/Linux ccc.
In a command prompt/shell, go to the lpsolve Sysquake directory and enter cvc.bat/sh ccc
and the compilation is done. The result is sqlpsolvext.dll/sqlpsolvext.so.
Enter keyword(s) or phrase for which to search
https://lp-solve.github.io/:
doc/O-Matrix.htm 0000664 0001750 0001750 00000335274 14777273331 012477 0 ustar rene rene
Using lpsolve from O-Matrix
Using lpsolve from O-Matrix
O-Matrix?
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.
O-Matrix and lpsolve
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.
Quickstart
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.2.14_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.
Installation
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.6
using lpsolve version 5.5.2.14
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.
Solve an lp model from O-Matrix via omlpsolve
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:
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.
An example
(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.)
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:
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);
Using model name instead of handle
From driver version 5.5.0.2, it is possible to use the model name instead of the handle. From the moment the model
has a name, you can use this name instead of the handle. This is best shown by an example. Above example would look
like this:
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.
Matrices
In O-Matrix, all numerical data is stored in matrices; even a scalar variable. O-Matrix also supports complex numbers.
omlpsolve can only work with real numbers.
For example:
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:
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.
Maximum usage of matrices with omlpsolve
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.)
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:
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.
Using string constants
From driver version 5.5.2.14 on, it is possible to use string constants
everywhere an lp_solve constant is needed or returned. This is best shown by an example.
In the above code we had:
Note the 3rd parameter on set_verbose and the 4th on add_constraint. These are
lp_solve constants. One could define all the possible constants in O-Matrix and
then use them in the calls, but that has several disadvantages. First there
stays the possibility to provide a constant that is not intended for that
particular call. Another issue is that calls that return a constant are still
returning it numerical.
Both issues can now be handled by string constants. The above code can be done as
following with string constants:
This is not only more readable, there is much lesser chance that mistakes are
being made. The calling routine knows which constants are possible and only
allows these. So unknown constants or constants that are intended for other
calls are not accepted. For example:
Note the difference between the two error messages. The first says that the
constant is not known, the second that the constant cannot be used at that
place.
Constants are case insensitive. Internally they are always translated to upper
case. Also when returned they will always be in upper case.
The constant names are the ones as specified in the documentation of each API
routine. There are only 3 exceptions, extensions actually. "LE", "GE" and "EQ" in
add_constraint and is_constr_type
can also be "<", "<=", ">", ">=", "=". When returned however, "GE", "LE", "EQ"
will be used.
Also in the matrix version of calls, string constants are possible. For example:
| is the OR operator used to combine multiple constants. There may optinally be
spaces before and after the |.
Not all OR combinations are legal. For example in set_scaling, a choice must be
made between SCALE_EXTREME, SCALE_RANGE, SCALE_MEAN, SCALE_GEOMETRIC or
SCALE_CURTISREID. They may not be combined with each other. This is also tested:
O> omlpsolve("set_scaling", lp, "SCALE_MEAN|SCALE_RANGE");
SCALE_RANGE cannot be combined with SCALE_MEAN
Everywhere constants must be provided, numeric or string values may be provided.
The routine automatically interpretes them.
Returning constants is a different
story. The user must let lp_solve know how to return it. Numerical or as string.
The default is numerical:
O> omlpsolve("get_scaling", lp)
131
To let lp_solve return a constant as string, a call to a new function must be
made: return_constants
O> omlpsolve("return_constants", 1);
From now on, all returned constants are returned as string:
Also when an array of constants is returned, they are returned as string when
return_constants is set:
O> omlpsolve("get_constr_type", lp)
LE
EQ
GE
This for all routines until return_constants is again called with 0:
O> omlpsolve("return_constants", 0);
The (new) current setting of return_constants is always returned by the call.
Even when set:
O> omlpsolve("return_constants", 1)
1
To get the value without setting it, don"t provide the second argument:
O> omlpsolve("return_constants")
1
In the next part of this documentation, return_constants is the default, 0, so all
constants are returned numerical and provided constants are also numerical. This
to keep the documentation as compatible as possible with older versions. But
don"t let you hold that back to use string constants in your code.
oms scripts
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).
example1.oms
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.
example2.oms
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.
example3.oms
Contains the commands of a practical example. See further in this article.
example4.oms
Contains the commands of a practical example. See further in this article.
example5.oms
Contains the commands of a practical example. See further in this article.
example6.oms
Contains the commands of a practical example. See further in this article.
lp_solve.oms
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:
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.
Don't forget to free the handle and its associated memory when you are done:
O> omlpsolve("delete_lp", lp);
lpdemo.oms
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.
ex.oms
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.
A practical example
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.
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.
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:
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:
Availability of seed.This might lead to constraint inequalities like xj < k.
Personal preferences. Thus the farmer's spouse might have a preference
for one variety over another and insist on a corresponding planting,
or something similar with a collection of crops; thus constraint inequalities
like xi < xj or x1 + x2 > x3.
Government subsidies. It may take a moment's reflection on the reader's part,
but this could lead to inequalities like xj > k.
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:
How many crops are under consideration?
What are the corresponding expenses? How much is available for expenses?
What are the yields in each case? What is the storage capacity?
How many acres are available?
What crops are constrained by seed limitations? To what extent?
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.
Another, more theoretical, example
Suppose we want to solve the following linear program using O-Matrix:
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
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:
The count argument in the API documentation is not needed in O-Matrix since the number of elements is derived from the size of the sosvars and weights matrices. These must have the same size.
The bascolumn argument in the API documentation is here the return value. The nonbasic argument is optional in O-Matrix. If not provided, then 0 is used.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix in the first return value.
The return code of the call is the second return value.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
The objfrom, objtill, objfromvalue, objtillvalue arguments in the API documentation
are here the return values. Note that O-Matrix allows the return of fewer
variables. For example if only objfrom and objtill are needed then the
call can be [objfrom, objtill] = omlpsolve("get_sensitivity_obj",
lp). The unrequested values are even not calculated.
Since the API routine doesn't calculate the objtillvalue value at this time, O-Matrix always
returns a zero vector for this.
The return code of the call is the last value.
get_sensitivity_obj and get_sensitivity_objex are both implemented, but have the same functionality.
The duals, dualsfrom, dualstill
arguments in the API documentation are here the return values. Note that
O-Matrix allows the return of fewer variables. For example if only duals is
needed then the call can be [duals] = omlpsolve("get_sensitivity_rhs",
lp). The unrequested values are even not calculated.
The return code of the call is the last value.
get_sensitivity_rhs and get_sensitivity_rhsex are both implemented, but have the same functionality.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows retrieving the values into a O-Matrix matrix.
The omlpsolve API routine returns the version information in 4 provided argument variables while the O-Matrix version returns the information as a string in the format major.minor.release.build
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under O-Matrix (Windows) this means
that the output is not shown.
The same information can also be obtained via omlpsolve("get_constraints", lp). This shows the result on screen.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under O-Matrix (Windows) this means
that the output is not shown.
The same information can be obtained via omlpsolve("get_dual_solution", lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under O-Matrix (Windows) this means that the output is not shown.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under O-Matrix (Windows) this means
that the output is not shown.
The same information can be obtained via omlpsolve("get_objective", lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under O-Matrix (Windows) this means that the output is not shown.
columns is optional. If not specified, then 1 is
used.
First call set_outputfile to specify where the
information is written to. In the API documentation it is written that by
default, the output goes to stdout, but under O-Matrix (Windows) this means
that the output is not shown.
The same information can also be obtained via omlpsolve("get_variables", lp). This shows the result on screen.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under O-Matrix (Windows) this means that the output is not shown.
First call set_outputfile to specify where the information is written to.
In the API documentation it is written that by default, the output goes to stdout, but under O-Matrix (Windows) this means that the output is not shown.
However, the omlpsolve driver sets a log function to redirect the output of lpsolve from stdout (which is not visible in Windows O-Matrix) to the command window of O-Matrix.
As such, all reported output can be seen in O-Matrix. How much output is seen is controlled by the verbose level that can be defined by set_verbose or can be specified in the read_ routines.
Note that at least O-Matrix version 5.8 is needed to see this information on the command window. Older versions will not print information on the command window.
In O-Matrix, when you name a model, this name can be used everywhere where lp is specified.
This to access the model via the name instead of via a handle.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows to set the whole matrix (all rows/columns) at once.
This is the most performant way to provide the constraint matrix.
The matrix must be two-dimentional.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all variables. It is then the same as set_obj_fn
In the API description it says that setting filename to NULL results in writing output back to stdout.
In O-Matrix under Windows, output to stdout it not shown. However it results in closing the file.
Use "" to have the effect of NULL.
In O-Matrix, this routine has two formats. The first format is identical to the API.
The second format allows setting a matrix of all rows. Note that in this case, the value of row 0 is not specified in the matrix.
Returns the setting of return_constants and optionally sets its value.
Compile the omlpsolve driver
Windows
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.2.14_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.
Unix/Linux
At this moment, there is no O-Matrix version for this platform.
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.
The array receives the basic variables and if nonbasic is TRUE, then
also the non-basic variables. If an element is less then zero then it means on
lower bound, else on upper bound.
Element 0 of the array is unused.
The default initial basis is bascolumn[x] = -x.
Each element represents a basis variable. If the absolute value is between 1
and get_Nrows, it represents a slack variable and
if it is between get_Nrows+1 and
get_Nrows+get_Ncolumns then it
represents a regular variable. If the value is negative, then the variable is
on its lower bound. If positive it is on its upper bound.
Setting an initial basis can speed up the solver considerably. It is the
starting point from where the algorithm continues to find an optimal solution.
When a restart is done, lp_solve continues at the last basis, except if
set_basis, default_basis or read_basis is called.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int bascolumn[1+2]; /* must be 1 more then number of rows ! */
/* Create a new LP model */
lp = make_lp(2, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
bascolumn[0] = 0;
bascolumn[1] = -1;
bascolumn[2] = -2;
set_basis(lp, bascolumn, FALSE);
delete_lp(lp);
return(0);
}
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
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
/* Create a new LP model */
lp = make_lp(0, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
set_print_sol(lp, TRUE);
delete_lp(lp);
return(0);
}
The get_Norig_rows function returns the number of original rows (constraints) in the lp.
Note that the number of rows (get_Nrows) can change when a presolve is done. get_Norig_rows does not change and thus returns the original number of rows in the lp.
Example
#include <stdio.h>
#include <stdlib.h>
#include "lp_lib.h"
int main(void)
{
lprec *lp;
int Norig_rows;
/* Create a new LP model */
lp = make_lp(1, 0);
if(lp == NULL) {
fprintf(stderr, "Unable to create new LP model\n");
return(1);
}
Norig_rows = get_Norig_rows(lp); /* Will return 1 */
set_presolve(lp, PRESOLVE_ROWS);
solve(lp);
Norig_rows = get_Norig_rows(lp); /* Will return 1 */
delete_lp(lp);
return(0);
}
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 variables
The 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.
doc/Semi-ContinuousVariables_files/ 0000775 0001750 0001750 00000000000 14777273331 016363 5 ustar rene rene doc/Semi-ContinuousVariables_files/img00340.gif 0000664 0001750 0001750 00000004302 14777273331 020214 0 ustar rene rene GIF89a ! , H*\ȰÇ#JHŋ3jȱǏ C Iɓ(S\ɲ˗0cʜI͛8sɳϟ@
JѣH*]ʴӧPJJիXjʵׯ`Ê KٳhӪ]˶۷pʝKݻx˷߿ , È{0c K22˘?.g MzaҨS YάEM96ےc{ݽ-pƓZsK}uկkO}wݿ~yϫ~{_}'Mh d&ȟjmZ RjFnUhSMu8ڇ *܈%nR"z$6V㌊h#蘏<\p@ Ӑi$KH(5iܓP$erTV ҕe%G\:ܘd&lidukЛ)'Btjgݞ| m
_* P*: A:j 3Jz %Z j
z * : J$*
ٺ%x%Z*{b2;NBl) V&Ur[-lNjnXn;&adi 0u + ++5 q/{i r<{ %Ϯ.eNIsDޜG rE<@64Ev4IS4N38--uY}5֙i5QMd^L jvIe"-ܾM`_v]qWD'];8t_]BK\yo ţVWqg-::\mN{Kh;^;[ ?<5g;7ԉѿű[ˏ=8yw6'Zr
|d09I(FT$'BMjgdOYT,gIZ̥.w^d\(72ʩGD'8Fͬ+C=1T4 OcV2,CB3m9րr~\';g"Ow&VEM1GE ՇyJR,0z>)ԙJ(Y2h F4GR`c% Avepդ::=r24M 3R]+d~
T4C9*L NtOERBEuWeOV2Um<_m(r*Җ E<ֶ$ ; doc/Semi-ContinuousVariables_files/bsscdhtm.js 0000664 0001750 0001750 00000207742 14777273331 020544 0 ustar rene rene //////////BSSCDHTML Section 1//////////
// RoboHELP Dynamic HTML Effects Script
// Copyright 1998-2000 eHelp Corporation. All rights reserved.
// Version=3.72
// Warning: Do not modify this file. It is generated by RoboHELP and changes will be overwritten.
//{{HH_SYMBOL_SECTION
var HH_ChmFilename = "";
var HH_WindowName = "";
var HH_GlossaryFont = "";
var HH_Glossary = "";
var HH_Avenue = "";
var HH_ActiveX = false;
//}}HH_SYMBOL_SECTION
var gbNav4 = false;
var gbIE4 = false;
var gbIE = false;
var gbIE5 = false;
var gbIE55 = false;
var gAgent = navigator.userAgent.toLowerCase();
var gbMac = (gAgent.indexOf("mac") != -1);
var gbWindows = ((gAgent.indexOf("win") != -1) || (gAgent.indexOf("16bit") != -1));
var error_count = 0;
gbIE = (navigator.appName.indexOf("Microsoft") != -1);
if (parseInt(navigator.appVersion) >= 4) {
gbNav4 = (navigator.appName == "Netscape");
gbIE4 = (navigator.appName.indexOf("Microsoft") != -1);
if (gbIE4) {
if (gAgent.indexOf("msie 5.0") != -1) {
gbIE5 = true;
}
if (gAgent.indexOf("msie 5.5") != -1) { // curently IE 5.5 has some buggy stuff. we need do some remedy to our code.
gbIE55 = true;
}
}
}
function HHActivateComponents()
{
if (HH_ActiveX && (HH_ChmFilename != "") && ((self == top) || (self == top.frames[0])))
{
var objBody = document.all.tags("BODY")[0];
if( typeof(objBody) == "object" )
{
objBody.insertAdjacentHTML("beforeEnd", '');
if (HHComponentActivator.object)
{
HHComponentActivator.Activate(HH_ChmFilename, HH_WindowName, HH_GlossaryFont, HH_Glossary, HH_Avenue);
}
}
}
}
var gAmc = new Array();
var BSSCSequenceIndex = 0;
function animationContext(el, progressAnimation, finishAnimiation, animationDuration, animationPeriod)
{
this.el = el;
this.progressAnimation = progressAnimation;
this.finishAnimiation = finishAnimiation;
this.animationDuration = parseFloat(animationDuration);
this.animationPeriod = animationPeriod;
this.animationStartTime = (new Date()).getTime();
this.continueAnimation = true;
}
function progressFade(ndx)
{
if( typeof( gAmc[ndx].el.filters.alpha ) != "object" )
return;
percent = ((new Date()).getTime() - gAmc[ndx].animationStartTime)/gAmc[ndx].animationDuration;
if (percent > 1.0){
percent = 1.0;
gAmc[ndx].continueAnimation = false;
}
gAmc[ndx].el.filters.alpha.opacity = gAmc[ndx].initialOpacity*(1.0-percent) + gAmc[ndx].finalOpacity*percent;
}
function finishFade(ndx)
{
if( typeof( gAmc[ndx].el.filters.alpha ) == "object" )
gAmc[ndx].el.filters.alpha.opacity = parseInt(gAmc[ndx].finalOpacity);
}
function progressTranslation(ndx)
{
percent = ((new Date()).getTime() - gAmc[ndx].animationStartTime)/gAmc[ndx].animationDuration;
if (percent > 1.0) {
percent = 1.0;
gAmc[ndx].continueAnimation = false;
}
gAmc[ndx].el.style.pixelLeft = gAmc[ndx].startX*(1.0-percent) + gAmc[ndx].finalX*percent;
gAmc[ndx].el.style.pixelTop = gAmc[ndx].startY*(1.0-percent) + gAmc[ndx].finalY*percent;
}
function progressSpiral(ndx)
{
percent = ((new Date()).getTime() - gAmc[ndx].animationStartTime)/gAmc[ndx].animationDuration;
if (percent > 1.0) {
percent = 1.0;
gAmc[ndx].continueAnimation = false;
}
rf = 1.0 - percent
t = percent * 2.0*Math.PI
rx = Math.max(Math.abs(gAmc[ndx].el.initLeft), 200)
ry = Math.max(Math.abs(gAmc[ndx].el.initTop), 200)
gAmc[ndx].el.style.pixelLeft = Math.ceil(-rf*Math.cos(t)*rx)
gAmc[ndx].el.style.pixelTop = Math.ceil(-rf*Math.sin(t)*ry)
gAmc[ndx].el.style.visibility="visible"
}
function progressElasticFromRight(ndx)
{
percent = ((new Date()).getTime() - gAmc[ndx].animationStartTime)/gAmc[ndx].animationDuration;
if (percent > 1.0) {
percent = 1.0;
gAmc[ndx].continueAnimation = false;
}
rf=Math.exp(-percent*7)
t = percent * 1.5*Math.PI
rx =Math.abs(gAmc[ndx].el.initLeft)
gAmc[ndx].el.style.pixelLeft = rf*Math.cos(t)*rx
gAmc[ndx].el.style.pixelTop = 0
gAmc[ndx].el.style.visibility="visible"
}
function progressElasticFromBottom(ndx)
{
percent = ((new Date()).getTime() - gAmc[ndx].animationStartTime)/gAmc[ndx].animationDuration;
if (percent > 1.0) {
percent = 1.0;
gAmc[ndx].continueAnimation = false;
}
rf=Math.exp(-percent*7)
t = percent * 1.5*Math.PI
rx =Math.abs(gAmc[ndx].el.initTop)
gAmc[ndx].el.style.pixelLeft = 0
gAmc[ndx].el.style.pixelTop = rf*Math.cos(t)*rx
gAmc[ndx].el.style.visibility="visible"
}
function progressZoomIn(ndx)
{
percent = ((new Date()).getTime() - gAmc[ndx].animationStartTime)/gAmc[ndx].animationDuration;
if (percent > 1.0) {
percent = 1;
gAmc[ndx].continueAnimation = false;
}
for (var index=0; index= 1.0) {
finishZoom(ndx);
}
}
function progressZoomOut(ndx)
{
percent = ((new Date()).getTime() - gAmc[ndx].animationStartTime)/gAmc[ndx].animationDuration;
if (percent > 1.0) {
percent = 1.0;
gAmc[ndx].continueAnimation = false;
}
for (var index=0; index= 1.0) {
finishZoom(ndx);
}
}
function finishTranslation(ndx)
{
gAmc[ndx].el.style.pixelLeft = parseInt(gAmc[ndx].finalX);
gAmc[ndx].el.style.pixelTop = parseInt(gAmc[ndx].finalY);
}
function finishZoom(ndx)
{
for (i=0; i BSSCSequenceIndex && (!bFound || objectOrder < minBSSCSequenceIndexFound))
{
minBSSCSequenceIndexFound = objectOrder;
bFound = true;
}
}
}
if (bFound)
{
BSSCSequenceIndex = minBSSCSequenceIndexFound;
bStarted = startAnimationSet(BSSCSequenceIndex);
}
}
function getOffsetFromTopOfBrowser(el)
{
if (null == el.offsetParent)
return el.offsetTop;
else
return el.offsetTop + getOffsetFromTopOfBrowser(el.offsetParent);
}
function startAnimationSet(ndx)
{
var m = 0;
bStarted = false;
// Find document elements with "BSSCAnimationType" attribute
divElements = document.all.tags("DIV");
for (var index = 0; index < divElements.length; index++)
{
el = divElements[index];
animationType = el.getAttribute("BSSCAnimationType", false);
if(null != animationType)
{
framePeriod = el.getAttribute("BSSCFramePeriod", false);
frameCount = el.getAttribute("BSSCFrameCount", false);
sequenceIndex = el.getAttribute("BSSCObjectOrder", false);
// Stop any currently running RevealTrans filters
if ("RevealTrans" == animationType && parseInt(sequenceIndex) == ndx-1 && gbWindows)
el.filters.RevealTrans.stop();
// Filter on ndx
if (0 == ndx && null == sequenceIndex ||
ndx == parseInt(sequenceIndex))
{
if ("FlyInFromRight" == animationType)
{
animationDuration = el.getAttribute("BSSCDuration", false);
if (null == animationDuration)
animationDuration = 1000; // default to 1s
gAmc[m] = new animationContext(el, progressTranslation, finishTranslation, animationDuration, 10);
gAmc[m].startX = document.body.clientWidth + document.body.scrollLeft;
gAmc[m].startY = 0;
gAmc[m].finalX = 0;
gAmc[m].finalY = 0;
animationPump(m++);
bStarted = true;
}
if ("FlyOutToRight" == animationType)
{
animationDuration = el.getAttribute("BSSCDuration", false);
if (null == animationDuration)
animationDuration = 1000; // default to 1s
gAmc[m] = new animationContext(el, progressTranslation, finishTranslation, animationDuration, 10);
gAmc[m].startX = 0;
gAmc[m].startY = 0;
gAmc[m].finalX = document.body.clientWidth + document.body.scrollWidth;
gAmc[m].finalY = 0;
animationPump(m++);
bStarted = true;
}
if ("FlyInFromLeft" == animationType)
{
animationDuration = el.getAttribute("BSSCDuration", false);
if (null == animationDuration)
animationDuration = 1000; // default to 1s
for (childIndex=0; childIndex 0) && (document.images[0].src.indexOf('bsscnav1.gif') != -1)) {
document.links[0].href = "javascript:void(null);";
}
}
}
return;
}
//////////////////////////////////////////////////////////////////////////////////////////////
//
// Begin DHTML Popup Functions
//
//////////////////////////////////////////////////////////////////////////////////////////////
//variables used to isolate the browser type
var gBsDoc = null;
var gBsSty = null;
var gBsHtm = null;
var gBsStyVisShow = null;
var gBsStyVisHide = null;
var gBsClientWidth = 640;
var gBsClientHeight = 480;
var gBsBrowser = null;
// here is the varible for judge popup windows size. these parameter is for IE5.0, it may need adjust for others.
var gBRateH_W = 0.618; // 1.618 Golden cut.
var gBMaxXOfParent = 0.8;
var gBMaxYOfParent = 0.8;
var gBscrollHeight = 16;
var gBscrollWidth = 16;
var gBpermitXDelta = 3;
var gBpermitYDelta = 3;
//the browser information itself
function _BSPSBrowserItself()
{
var agent = navigator.userAgent.toLowerCase();
this.major = parseInt(navigator.appVersion);
this.minor = parseFloat(navigator.appVersion);
this.ns = ((agent.indexOf('mozilla') != -1) && ((agent.indexOf('spoofer') == -1) && (agent.indexOf('compatible') == -1)));
this.ns2 = ((this.ns) && (this.major == 2));
this.ns3 = ((this.ns) && (this.major == 3));
this.ns4 = ((this.ns) && (this.major >= 4));
this.ie = (agent.indexOf("msie") != -1);
this.ie3 = ((this.ie) && (this.major == 2));
this.ie4 = ((this.ie) && (this.major >= 4));
this.op3 = (agent.indexOf("opera") != -1);
if (this.ns4)
{
gBsDoc = "document";
gBsSty = "";
gBsHtm = ".document";
gBsStyVisShow = "show";
gBsStyVisHide = "hide";
}
else if (this.ie4)
{
gBsDoc = "document.all";
gBsSty = ".style";
gBsHtm = "";
gBsStyVisShow = "visible";
gBsStyVisHide = "hidden";
}
}
//Here is the browser type
function _BSPSGetBrowserInfo()
{
gBsBrowser = new _BSPSBrowserItself();
}
//Get client size info
function _BSPSGetClientSize()
{
if (gBsBrowser.ns4)
{
gBsClientWidth = innerWidth;
gBsClientHeight = innerHeight;
}
else if (gBsBrowser.ie4)
{
gBsClientWidth = document.body.clientWidth;
gBsClientHeight = document.body.clientHeight;
}
}
var gstrPopupID = 'BSSCPopup';
var gstrPopupShadowID = 'BSSCPopupShadow';
var gstrPopupTopicID = 'BSSCPopupTopic';
var gstrPopupIFrameID = 'BSSCPopupIFrame';
var gstrPopupIFrameName = 'BSSCPopupIFrameName';
var gstrPopupSecondWindowName = 'BSSCPopup';
var gPopupDiv = null;
var gPopupDivStyle = null;
var gPopupShadow = null;
var gPopupTopic = null;
var gPopupIFrame = null;
var gPopupIFrameStyle = null;
var gPopupWindow = null;
var gnPopupClickX = 0;
var gnPopupClickY = 0;
var gnPopupScreenClickX = 0;
var gnPopupScreenClickY = 0;
var gbPopupTimeoutExpired = false;
var gbScriptName = "EHELP_DHTM";
var gbPathofJS = "";
if (gbIE4) {
var aScripts = document.scripts;
var aScript = null;
var i = 0;
for (i = 0; i < aScripts.length ; i ++ )
{
if (aScripts[i].name == gbScriptName) {
aScript = aScripts[i];
break;
}
}
if (aScript != null) {
var nPathPos = 0;
var strCurrentSrc = "";
strCurrentSrc = aScript.src;
var nPathPos1 = strCurrentSrc.lastIndexOf("\\");
var nPathPos2 = strCurrentSrc.lastIndexOf("/");
if (nPathPos1 > nPathPos2)
nPathPos = nPathPos1 + 1;
else
nPathPos = nPathPos2 + 1;
gbPathofJS = strCurrentSrc.substring(0, nPathPos);
}
}
// Replace point - Used by SingleSource
// var gbBlankPageForIFrame = gbPathofJS + "_blank.htm";
var gbBlankPageForIFrame = "about:blank";
if (BSSCPopup_IsPopup()) {
document.write("");
}
function DHTMLPopupSupport()
{
if ((gbIE4) && (!gbMac)) {
return true;
}
return false;
}
function BSSCPopup_IsPopup()
{
if (DHTMLPopupSupport() && (this.name == gstrPopupIFrameName)) {
return true;
} else if ((gbNav4 || gbIE4) && (this.name == gstrPopupID)) {
return true;
} else {
return false;
}
}
function _BSSCCreatePopupDiv()
{
if (gPopupDiv == null) {
if (DHTMLPopupSupport()) {
document.write("
");
document.write("");
document.write("
");
document.write("");
document.write("
");
var tempColl = document.all.tags("DIV");
for (var iDiv = 0; iDiv < tempColl.length; iDiv++) {
if (tempColl(iDiv).id == gstrPopupID) {
gPopupDiv = tempColl(iDiv);
}
if (tempColl(iDiv).id == gstrPopupShadowID) {
gPopupShadow = tempColl(iDiv);
}
if (tempColl(iDiv).id == gstrPopupTopicID) {
gPopupTopic = tempColl(iDiv);
}
}
gPopupIFrame = eval("gPopupDiv.document.frames['" + gstrPopupIFrameName + "']");
gPopupDivStyle = eval("gPopupDiv" + gBsSty);
gPopupIFrameStyle = eval(gBsDoc + "['" + gstrPopupIFrameName + "']" + gBsSty);
}
}
}
function BSSCPopup_Timeout()
{
if ((gPopupIFrame.document.readyState == "complete") &&
(gPopupIFrame.document.body != null) &&
(gPopupIFrame.location.href.indexOf(gbBlankPageForIFrame) == -1)) {
BSSCPopup_TimeoutReal();
} else {
setTimeout("BSSCPopup_Timeout()", 100);
}
}
function BSSCPopup_TimeoutReal()
{
window.gbPopupTimeoutExpired = true;
if (gPopupIFrame.document) {
BSSCPopup_ChangeTargettoParent(gPopupIFrame.document);
gPopupIFrame.document.body.onclick = BSSCPopupClicked;
}
document.onmousedown = BSSCPopupParentClicked;
}
function BSSCPopup_ChangeTargettoParent(tagsObject)
{
var collA = tagsObject.all.tags("A");
var j = 0;
if (collA != null) {
for (j = 0; j < collA.length; j ++ )
{
collA[j].target = "_parent";
}
}
}
function BSPSPopupTopicWinHelp(strURL)
{
_BSSCPopup(strURL);
return;
}
function _BSSCPopup(strURL)
{
if (DHTMLPopupSupport()) {
// If we are already in a popup, replace the contents
if (BSSCPopup_IsPopup()) {
location.href = strURL;
parent.window.gbPopupTimeoutExpired = false;
if (gbMac) {
setTimeout("BSSCPopup_AfterLoad('" + strURL + "')", 400);
} else {
setTimeout("BSSCPopup_AfterLoad('" + strURL + "')", 100);
}
} else {
// Load the requested URL into the IFRAME
gPopupIFrame.location.href = strURL;
window.gbPopupTimeoutExpired = false;
if (gbMac) {
setTimeout("BSSCPopup_AfterLoad('" + strURL + "')", 400);
} else {
setTimeout("BSSCPopup_AfterLoad('" + strURL + "')", 100);
}
}
} else {
_BSSCPopup2(strURL);
}
return;
}
function _BSSCPopup2(strURL)
{
if (window.name == gstrPopupSecondWindowName) {
window.location = strURL;
} else {
BSSCHidePopupWindow();
var nX = 0;
var nY = 0;
var nHeight = 300;
var nWidth = 400;
_BSPSGetClientSize();
if (gBsBrowser.ns4) {
nX = window.screenX + (window.outerWidth - window.innerWidth) + window.gnPopupClickX;
nY = window.screenY + (window.outerHeight - window.innerHeight) + window.gnPopupClickY;
if (nY + nHeight + 40 > screen.availHeight) {
nY = screen.availHeight - nHeight - 40;
}
if (nX + nWidth + 40 > screen.availWidth) {
nX = screen.availWidth - nWidth - 40;
}
} else {
nX = window.gnPopupScreenClickX;
nY = window.gnPopupScreenClickY;
}
// Launch a separate window
var strParam = "titlebar=no,toolbar=no,status=no,location=no,menubar=no,resizable=yes,scrollbars=yes";
if (gBsBrowser.ns) {
strParam += ",OuterHeight=" + nHeight + ",OuterWidth=" + nWidth;
strParam += ",screenX=" + nX + ",screenY=" + nY;
strParam += ",dependent=yes";
}
else {
strParam += ",height=" + nHeight + ",width=" + nWidth;
strParam += ",left=" + nX + ",top=" + nY;
}
window.gPopupWindow = window.open(strURL, gstrPopupSecondWindowName, strParam);
if (gBsBrowser.ns4) {
window.gPopupWindow.captureEvents(Event.CLICK | Event.BLUE);
window.gPopupWindow.onclick = NonIEPopup_HandleClick;
window.gPopupWindow.onblur = NonIEPopup_HandleBlur;
}
else if (gBsBrowser.ie4)
{
window.gPopupWindow.focus();
}
}
return;
}
function NonIEPopup_HandleBlur(e)
{
window.gPopupWindow.focus();
}
function NonIEPopup_HandleClick(e)
{
// Because navigator will give the event to the handler before the hyperlink, let's
// first route the event to see if we are clicking on a Popup menu in a popup.
document.routeEvent(e);
// If a popup menu is active then don't do anything with the click
if (window.gPopupWindow.gbInPopupMenu) {
window.gPopupWindow.captureEvents(Event.CLICK);
window.gPopupWindow.onclick = NonIEPopup_HandleClick;
return false;
}
// Close the popup window
if (e.target.href != null) {
window.location.href = e.target.href;
if (e.target.href.indexOf("BSSCPopup") == -1) {
this.close();
}
} else {
this.close();
}
return false;
}
function BSSCPopup_AfterLoad(strURL)
{
if (typeof(window.gPopupIFrame.document) == "unknown") {
_BSSCPopup2(strURL);
return;
}
if ((window.gPopupIFrame.document.readyState == "complete") &&
(window.gPopupIFrame.document.body != null) &&
(window.gPopupIFrame.location.href.indexOf(gbBlankPageForIFrame) == -1)) {
BSSCPopup_ResizeAfterLoad(strURL);
} else {
setTimeout("BSSCPopup_AfterLoad('" + strURL + "')", 200);
}
}
function BSSCPopup_ResizeAfterLoad(strURL)
{
window.gPopupDivStyle.visibility = gBsStyVisHide;
// Determine the width and height for the window
//var size = new BSSCSize(0, 0);
//BSSCGetContentSize(window.gPopupIFrame, size);
//var nWidth = size.x;
//var nHeight = size.y;
_BSPSGetClientSize();
var size = new BSSCSize(0, 0);
BSSCGetContentSize(window.gPopupIFrame, size);
// Determine the width and height for the window
var nWidth = size.x;
var nHeight = size.y;
window.gPopupDivStyle.width = nWidth;
window.gPopupDivStyle.height = nHeight;
// Determine the position of the window
var nClickX = window.gnPopupClickX;
var nClickY = window.gnPopupClickY;
var nTop = 0;
var nLeft = 0;
if (nClickY + nHeight + 20 < gBsClientHeight + document.body.scrollTop) {
nTop = nClickY + 10;
} else {
nTop = (document.body.scrollTop + gBsClientHeight) - nHeight - 20;
}
if (nClickX + nWidth < gBsClientWidth + document.body.scrollLeft) {
nLeft = nClickX;
} else {
nLeft = (document.body.scrollLeft + gBsClientWidth) - nWidth - 8;
}
if (nTop < document.body.scrollTop ) nTop = document.body.scrollTop + 1;
if (nLeft< document.body.scrollLeft) nLeft = document.body.scrollLeft + 1;
window.gPopupDivStyle.left = nLeft;
window.gPopupDivStyle.top = nTop;
// Set the location of the background blocks
window.gPopupShadow.style.left = 6;
window.gPopupShadow.style.top = 6;
if (gbIE55)
{
window.gPopupShadow.style.left = 4;
window.gPopupShadow.style.top = 4;
}
window.gPopupShadow.style.width = nWidth;
window.gPopupShadow.style.height = nHeight;
window.gPopupTopic.style.width = nWidth;
window.gPopupTopic.style.height = nHeight;
if (gbIE55)
{
window.gPopupShadow.style.width = nWidth + 2;
window.gPopupShadow.style.height = nHeight + 2;
window.gPopupTopic.style.width = nWidth + 2;
window.gPopupTopic.style.height = nHeight + 2;
}
if (gbMac) {
// Total hack on the iMac to get the IFrame to position properly
window.gPopupIFrameStyle.pixelLeft = 100;
window.gPopupIFrameStyle.pixelLeft = 0;
// Explicitly call BSSCOnLoad because the Mac doesn't seem to do it
window.gPopupIFrame.window.BSSCOnLoad();
}
//var nOriWidth = window.gPopupIFrameStyle.width
window.gPopupIFrameStyle.width = nWidth;
window.gPopupIFrameStyle.height = nHeight;
if (gbIE55)
{
window.gPopupIFrameStyle.top = 0;
window.gPopupIFrameStyle.left = 0;
}
gPopupIFrame.location.href = strURL; // reload again, this will fix the bookmark misunderstand in IE5.
window.gPopupDivStyle.visibility = gBsStyVisShow;
setTimeout("BSSCPopup_Timeout();", 100);
return false;
}
function BSSCSize(x, y)
{
this.x = x;
this.y = y;
}
function BSSCGetContentSize(thisWindow, size)
{
if (!((gBsBrowser.ie4) || (gBsBrowser.ns4)))
return;
if (gbMac) {
size.x = 300;
size.y = 300;
return;
}
// Resize the width until it is wide enough to handle the content
// The trick is to start wide and determine when the scrollHeight changes
// because then we know a scrollbar is necessary. We can then go back
// to the next widest size (for no scrollbar)
var ClientRate = gBsClientHeight / gBsClientWidth;
var GoldenSize = new BSSCSize(0,0);
GoldenSize.x = gBsClientWidth * gBMaxXOfParent;
GoldenSize.y = gBsClientHeight *gBMaxYOfParent ;
if (ClientRate > gBRateH_W) {
GoldenSize.y = GoldenSize.x * gBRateH_W;
}
else {
GoldenSize.x = GoldenSize.y / gBRateH_W;
}
// Try to using parent specified max x.
var x = 0;
var maxgoldx = GoldenSize.x;
var maxx = gBsClientWidth * gBMaxXOfParent;
// This double resize causes the document to re-render (and we need it to)
thisWindow.moveTo(10000,10000); // this is used to fix the flash on IE4.
thisWindow.resizeTo(1, 1);
thisWindow.resizeTo(1, 1);
thisWindow.resizeTo(maxgoldx, thisWindow.document.body.scrollHeight + gBscrollHeight);
thisWindow.resizeTo(maxgoldx, thisWindow.document.body.scrollHeight + gBscrollHeight);
var miny = thisWindow.document.body.scrollHeight + gBscrollHeight;
if (miny > GoldenSize.y) // the popup does not fix in the parent wanted golden area. so try to expand itself as large as it can
{
thisWindow.resizeTo(maxx , thisWindow.document.body.scrollHeight + gBscrollHeight);
thisWindow.resizeTo(maxx , thisWindow.document.body.scrollHeight + gBscrollHeight);
miny = thisWindow.document.body.scrollHeight + gBscrollHeight;
maxy = gBsClientHeight * gBMaxYOfParent;
if (miny > maxy) { // the popup must have a scroll, OK let it be.
miny = maxy;
size.x = maxx;
size.y = maxy;
}
else { // popup still can fit in the parent area by someway. now we choose the same h/w rate as parent.
size.y = miny;
// downsize from maxx , now I try to using binary divide.
x = maxx;
deltax = -maxx/2;
//j = 0;
while (true) {
x = x + deltax;
thisWindow.resizeTo(x, miny);
thisWindow.resizeTo(x, miny);
diffy = thisWindow.document.body.scrollHeight + gBscrollHeight - x * ClientRate;
if (diffy > gBpermitYDelta ) // it is higher than wanted, so x need to be wide a little bitter
deltax = Math.abs(deltax) /2;
else if (diffy < -gBpermitYDelta) // it is shorter than wanted, so x need to be narrow a little bitter
deltax = -Math.abs(deltax) /2;
else
// the y is close enough to wanted.
break;
if (Math.abs(deltax) < gBpermitXDelta) // the next change is too slight and it can be ignore.
break;
//j ++;
}
size.x = thisWindow.document.body.scrollWidth; //+ gBscrollWidth;
size.y = thisWindow.document.body.scrollHeight;// + gBscrollHeight;
thisWindow.document.body.scroll = 'no'; // At this time we do not want to show scroll any more. so it will looks better a little.
// Handle absurd cases just in case IE flakes
// if (size.y < 100) {
// size.y = 100;
// }
}
}
else {
// downsize from maxgoldx , now I try to using binary divide.
x = maxgoldx;
deltax = -maxgoldx/2;
//i = 0;
while (true) {
x = x + deltax;
thisWindow.resizeTo(x, miny);
thisWindow.resizeTo(x, miny);
diffy = thisWindow.document.body.scrollHeight + gBscrollHeight - x * gBRateH_W;
if (diffy > gBpermitYDelta ) // it is higher than wanted, so x need to be wide a little bitter
deltax = Math.abs(deltax) /2;
else if (diffy < -gBpermitYDelta) // it is shorter than wanted, so x need to be narrow a little bitter
deltax = -Math.abs(deltax) /2;
else
// the y is close enough to wanted.
break;
if (Math.abs(deltax) < gBpermitXDelta) // the next change is too slight and it can be ignore.
break;
//i ++;
}
size.x = thisWindow.document.body.scrollWidth ;//+ gBscrollWidth;
size.y = thisWindow.document.body.scrollHeight ;//+ gBscrollHeight;
thisWindow.document.body.scroll = 'no'; // At this time we do not want to show scroll any more. so it will looks better a little.
}
if ((gbIE4) && (!gbIE5))
{
size.x = size.x + 16; //reserve a width for scrollbar (IE 4.0 only)
}
thisWindow.resizeTo(size.x, size.y);
thisWindow.resizeTo(size.x, size.y);
return;
}
function BSSCPopupParentClicked()
{
BSSCPopupClicked();
return;
}
function BSSCPopupClicked()
{
if (!window.gbPopupTimeoutExpired) {
return false;
}
if (gPopupIFrame.window.gbInPopupMenu) {
return false;
}
// Give the user a message about javascript calls through objects.
if ((gPopupIFrame.window.event != null) &&
(gPopupIFrame.window.event.srcElement != null) &&
(gPopupIFrame.window.event.srcElement.tagName == "A") &&
(gPopupIFrame.window.event.srcElement.href.indexOf("javascript:") == 0) &&
(gPopupIFrame.window.event.srcElement.href.indexOf(".") != -1)) {
gPopupIFrame.window.event.cancelBubble = true;
alert('Hyperlinks to objects do not work in popups.');
return false;
}
if (gPopupIFrame.document) {
gPopupIFrame.document.body.onclick = null;
}
document.onclick = null;
document.onmousedown = null;
// Simply hide the popup
gPopupDivStyle.visibility = gBsStyVisHide;
gPopupIFrame.location.href = gbBlankPageForIFrame;
return true;
}
//trace the mouse over's position for hotspot
function BSPSPopupOnMouseOver(event)
{
if (gBsBrowser.ie4) {
window.gnPopupClickX = event.clientX + document.body.scrollLeft;
window.gnPopupClickY = event.clientY + document.body.scrollTop;
window.gnPopupScreenClickX = event.screenX;
window.gnPopupScreenClickY = event.screenY;
} else if (gBsBrowser.ns4) {
window.gnPopupClickX = event.pageX;
window.gnPopupClickY = event.pageY;
}
}
function BSSCHidePopupWindow()
{
if (window.gPopupWindow != null) {
if (gBsBrowser.ns4) {
if ((typeof window.gPopupWindow != "undefined") && (!window.gPopupWindow.closed)) {
window.gPopupWindow.close();
window.gPopupWindow = null;
}
}
}
return;
}
var gbPopupMenuTimeoutExpired = false;
var gbInPopupMenu = false;
var gbPopupMenuTopicList = null;
//////////////////////////////////////////////////////////////////////////////////////////
//
// Popup Menu code
//
//////////////////////////////////////////////////////////////////////////////////////////
function _WritePopupMenuLayer()
{
if (gbNav4) {
//Do not try to write ininle styles for NS! NS can not handle it and will not stop downloading the html page...
document.write("");
} else {
document.write("");
if (gbIE4) {
document.write("");
}
}
}
//Define variable arguments as: strTitle, strUrl
function PopupMenuTopicEntry()
{
this.strTitle = PopupMenuTopicEntry.arguments[0];
this.strURL = PopupMenuTopicEntry.arguments[1];
}
// If the topic list is set, it is an array of TopicEntry objects (defined in WebHelp3.js)
function PopupMenu_SetTopicList(aPopupTopicArray)
{
gbPopupMenuTopicList = aPopupTopicArray;
}
//Seek for the bsscright frame
function _SeekFrameByName( cRoot, strName )
{
if( cRoot == null ) return null;
if( cRoot.frames == null ) return null;
if( cRoot.frames[strName] != null ) return cRoot.frames[strName];
for (var i=0; i");
wndPopupLinks.document.write("");
var strParaLine = "";
for (var i = 0; i < (argLen - 2) / 2; i++) {
strParaLine = "";
strParaLine += "");
wndPopupLinks.document.close();
window.gbInPopupMenu = true;
if (!gbIE) {
wndPopupLinks.focus();
}
return false;
}
// Make sure we have reasonable arguments
var argLen = fn_arguments.length;
if (argLen < 3) {
return false;
}
// Check to see if we only have one target
var strTarget = "";
if (((argLen < 5) && ((isNaN(fn_arguments[2])) || (gbPopupMenuTopicList == null))) ||
((argLen < 4) && ((!isNaN(fn_arguments[2])) && (gbPopupMenuTopicList != null)))) {
// Get the place that we will be putting the topic into
var targetDoc = null;
if (fn_arguments[1] == '') {
targetDoc = window.document;
} else {
targetDoc = _GetFrameByName( parent, fn_arguments[1] );
if (targetDoc == null) {
targetDoc = window.document;
}
//if (gbIE4) {
// targetDoc = eval("top.document.frames['" + fn_arguments[1] + "']");
// } else if (gbNav4) {
// targetDoc = eval("window.top." + fn_arguments[1] + ".document");
//}
strTarget = "TARGET='" + fn_arguments[1] + "'";
}
if (isNaN(fn_arguments[2]) || (gbPopupMenuTopicList == null)) {
targetDoc.location.href = fn_arguments[3];
} else {
targetDoc.location.href = gbPopupMenuTopicList[fn_arguments[2]].strURL;
}
return false;
}
var strMenu = "";
if (gbNav4) {
strMenu = '
";
if (gbMac) {
// totally hack. because ie5 in mac need something.
is one of them. mac is mad.
strMenu +="
";
}
var layerPopup = null;
var stylePopup = null;
var nEventX = 0;
var nEventY = 0;
var nWindowWidth = 0;
if (gbIE4) {
layerPopup = document.all["PopupMenu"];
layerPopup.innerHTML = strMenu;
stylePopup = layerPopup.style;
_BSPSGetClientSize();
// Get the position of the item causing the event (relative to its parent)
//if (gbMac) {
if (true) {
nEventX = window.event.clientX;
nEventY = window.event.clientY;
} else {
//??? YJ: Can not remember why we calculate envent position by following code...
//but it is wrong in a case like: CENTER->P->TABLE:
//the offset positions of TABLE, P and CENTER are same (same offsetTop,offsetLeft)
//so we get triple times of offset of x and y as we expect...
nEventX = window.event.srcElement.offsetLeft - document.body.scrollLeft;
nEventY = window.event.srcElement.offsetTop - document.body.scrollTop;
// Get the location of the parent
var nParentLocX = 0;
var nParentLocY = 0;
var ParentItem = window.event.srcElement.offsetParent;
while (ParentItem != null) {
if (ParentItem.offsetLeft) {
nParentLocX += ParentItem.offsetLeft;
nParentLocY += ParentItem.offsetTop;
}
ParentItem = ParentItem.parentElement;
}
// Adjust the location of the item using the location of the parent(s)
nEventX += nParentLocX;
nEventY += nParentLocY;
}
if (nEventY + layerPopup.scrollHeight + 10 < gBsClientHeight) {
nEventY += document.body.scrollTop + 10;
} else {
nEventY = (document.body.scrollTop + gBsClientHeight) - layerPopup.scrollHeight - 20;
}
stylePopup.top = nEventY;
if (nEventX + layerPopup.scrollWidth + 20 > gBsClientWidth) {
if (gBsClientWidth - layerPopup.scrollWidth < 5) {
stylePopup.left = 5;
} else {
stylePopup.left = gBsClientWidth - layerPopup.scrollWidth - 5;
}
} else {
stylePopup.left = nEventX + document.body.scrollLeft + 20;
}
stylePopup.visibility = "visible";
document.onclick = PopupMenu_HandleClick;
} else if (gbNav4) {
layerPopup = document.layers.PopupMenu;
layerPopup.visibility = "hide";
stylePopup = layerPopup.document;
stylePopup.write(strMenu);
stylePopup.close();
var e = fn_arguments[0];
nEventX = e.pageX;
nEventY = e.pageY;
_BSPSGetClientSize();
if (nEventY + layerPopup.clip.height + 20 < window.pageYOffset + gBsClientHeight) {
nEventY += 20;
} else {
nEventY = gBsClientHeight + window.pageYOffset- layerPopup.clip.height - 20;
}
layerPopup.top = nEventY;
if (nEventX + layerPopup.clip.width + 20 > gBsClientWidth + window.pageXOffset) {
if (gBsClientWidth + window.pageXOffset - layerPopup.clip.width < 20) {
nEventX = 5;
} else {
nEventX = gBsClientWidth + window.pageXOffset - layerPopup.clip.width - 20;
}
} else {
nEventX += 20;
}
layerPopup.left = nEventX;
layerPopup.visibility = "show";
// window.captureEvents(Event.CLICK | Event.MOUSEDOWN);
window.captureEvents(Event.MOUSEDOWN);
// window.onclick = PopupMenu_HandleClick;
window.onmousedown = PopupMenu_HandleClick;
}
window.gbInPopupMenu = true;
window.gbPopupMenuTimeoutExpired = false;
setTimeout("PopupMenu_Timeout();", 100);
return false;
}
function PopupMenu_Timeout()
{
window.gbPopupMenuTimeoutExpired = true;
}
function PopupMenu_Over(e)
{
if (gbIE4) {
e.srcElement.className = "PopupOver";
} else if (gbNav4) {
// this.bgColor = "red";
// e.target.document.className = "PopupOver";
}
return;
}
function PopupMenu_Out(e)
{
if (gbIE4) {
e.srcElement.className = "PopupNotOver";
} else if (gbNav4) {
this.bgColor = "#f0f0f0";
}
return;
}
function PopupMenu_HandleClick(e)
{
if (!window.gbPopupMenuTimeoutExpired) {
return;
}
window.gbInPopupMenu = false;
if (gbNav4) {
// window.releaseEvents(Event.CLICK);
window.releaseEvents(Event.MOUSEDOWN);
}
var layerPopup = null;
var stylePopup = null;
if (gbIE4) {
layerPopup = document.all["PopupMenu"];
stylePopup = layerPopup.style;
stylePopup.visibility = "hidden";
} else if (gbNav4) {
layerPopup = document.layers.PopupMenu;
layerPopup.visibility = "hide";
}
return;
}
// This function should be deleted when all old projects are cleaned up
function BSPSWritePopupFrameForIE4()
{
return false;
}
/////////////////////////////////////////////////////////////////////
function BSSCPopup_ClickMac()
{
if ((!DHTMLPopupSupport()) && (gbIE4))
{
var bClickOnAnchor = false;
var el;
if ((window.event != null) &&
(window.event.srcElement != null))
{
el = window.event.srcElement;
while (el != null)
{
if ((el.tagName == "A") || (el.tagName == "AREA")) {
bClickOnAnchor = true;
break;
}
if (el.tagName == "BODY") {
break;
}
el = el.parentElement;
}
}
if (BSSCPopup_IsPopup())
{
if (!bClickOnAnchor) {
parent.window.gPopupWindow = null;
self.close();
}
}
else
{
bClosePopupWindow = true;
if ((bClickOnAnchor) &&
(el.href) &&
(el.href.indexOf("javascript:BSSCPopup") != -1))
{
bClosePopupWindow = false;
}
if (bClosePopupWindow)
{
if (window.gPopupWindow != null)
{
var strParam = "titlebar=no,toolbar=no,status=no,location=no,menubar=no,resizable=yes,scrollbars=yes,height=300,width=400";
window.gPopupWindow = window.open("", gstrPopupSecondWindowName,strParam);
window.gPopupWindow.close();
window.gPopupWindow = null;
}
}
}
}
}
//////////////////////////////////////////////////////////////////////
_BSPSGetBrowserInfo();
function _BSSCOnLoad()
{
if (!gbIE4 && !gbNav4)
return;
// Make everything visible in navigator
if (gbNav4) {
// Make some special effects items visible
for (var iLayer = 0; iLayer < document.layers.length; iLayer++) {
document.layers[iLayer].visibility = gBsStyVisShow;
document.layers[iLayer].left = 0;
}
}
// Remove the NavBar if necessary
RemoveNavBar();
// Don't continue without IE4
if (gbIE4) {
HHActivateComponents();
doStaticEffects();
startAnimationSet(0);
}
}
function _BSSCOnUnload()
{
}
function _BSSCOnClick()
{
if (!gbIE4)
return;
BSSCPopup_ClickMac();
startNextAnimationSet();
}
function _BSSCOnError(message)
{
if(-1 != message.indexOf("denied")
|| -1 != message.indexOf("Object required"))
return true;
}
function ResizeBasedonRate(thisWindow, size, rate, maxx, maxy)
{
x = maxx;
y = maxy;
deltax = -maxx/2;
while (true) {
x = x + deltax;
thisWindow.resizeTo(x, y);
thisWindow.resizeTo(x, y);
diffy = thisWindow.document.body.scrollHeight + gBscrollHeight - x * rate;
if (diffy > gBpermitYDelta ) // it is higher than wanted, so x need to be wide a little bitter
deltax = Math.abs(deltax) /2;
else if (diffy < -permitYDelta) // it is shorter than wanted, so x need to be narrow a little bitter
deltax = -Math.abs(deltax) /2;
else
// the y is close enough to wanted.
break;
if (Math.abs(deltax) < gBpermitXDelta) // the next change is too slight and it can be ignore.
break;
//j ++;
}
size.x = thisWindow.document.body.scrollWidth; //+ gBscrollWidth;
size.y = thisWindow.document.body.scrollHeight;// + gBscrollHeight;
thisWindow.document.body.scroll = 'no'; // At this time we do not want to show scroll any more. so it will looks better a little.
}
//////////BSSCDHTML Section Embedded Code//////////
var s_strAgent = navigator.userAgent.toLowerCase();
var s_nVer = parseInt(navigator.appVersion);
var s_bIE = (s_strAgent.indexOf('msie') != -1);
var s_bNS = (s_strAgent.indexOf('mozilla') != -1) && ((s_strAgent.indexOf('spoofer') == -1) && (s_strAgent.indexOf('compatible') == -1));
var s_bOpera = (s_strAgent.indexOf('opera') != -1);
var s_bIE3Before = ((s_bIE) && (s_nVer <= 2));
var s_bNS3Before = ((s_bNS) && (s_nVer <= 3));
var s_bNS2 = ((s_bNS) && (s_nVer <= 2));
var s_bNS3 = ((s_bNS) && (s_nVer == 3));
var s_bIE300301 = ((s_bIE) && (s_nVer == 2) && ((s_strAgent.indexOf("3.00") != -1)||(s_strAgent.indexOf("3.0a") != -1)||(s_strAgent.indexOf("3.0b")!=-1)||(s_strAgent.indexOf("3.01")!=-1)));
var s_bIE302 = ((s_bIE) && (s_nVer == 2) && (s_strAgent.indexOf("3.02") != -1));
function HasExtJs()
{
if (s_bIE3Before) { return false;}
if (s_bNS3Before) { return false;}
if (typeof (_BSSCOnLoad) == "undefined"){ return false; }
return true;
}
function BSSCOnLoad()
{
if (HasExtJs()) { _BSSCOnLoad(); }
}
function BSSCOnUnload()
{
if (HasExtJs()) { _BSSCOnUnload(); }
}
function BSSCOnClick()
{
if (HasExtJs()) { _BSSCOnClick(); }
}
function BSSCOnError(message)
{
if (HasExtJs()) { return _BSSCOnError(message); }
}
function WritePopupMenuLayer()
{
if (HasExtJs()) {_WritePopupMenuLayer();}
}
function BSSCCreatePopupDiv()
{
if (HasExtJs()) {_BSSCCreatePopupDiv(); }
}
function BSSCPopup(strURL)
{
if (HasExtJs()) {
_BSSCPopup(strURL);
}else{
//Create a temporary window first to ensure the real popup comes up on top
var wndTemp = null;
if (!s_bNS3) {
wndTemp = window.open("", "temp", "titlebar=no,toolbar=no,status=no,location=no,menubar=no,resizable=yes,scrollbars=yes,height=3,width=4");
}
// Create the real popup window
var wndPopup = window.open(strURL, "BSSCPopup", "titlebar=no,toolbar=no,status=no,location=no,menubar=no,resizable=yes,scrollbars=yes,height=300,width=400");
// Close the temporary
if (!s_bNS3) {
wndTemp.close();
} else {
wndPopup.focus();
}
}
}
var gbWndTemp = null, gbWndPopupLinks = null;
var gbstrParaTotal = "";
function PopupMenu_Invoke()
{
if (HasExtJs()) {
return _PopupMenu_Invoke(PopupMenu_Invoke.arguments);
}
if (s_bNS3Before || s_bIE3Before ) {
var argLen = PopupMenu_Invoke.arguments.length;
if (argLen < 5) {
window.document.location.href = PopupMenu_Invoke.arguments[3];
return false;
}
gbWndTemp = null;
gbWndPopupLinks = null;
gbstrParatotal = "";
for (var i = 0; i < (argLen - 2) / 2; i++) {
var strParaLine = "";
if (s_bNS2 || s_bOpera){
strParaLine += ""
strParaLine += PopupMenu_Invoke.arguments[2 * i + 2];
strParaLine += "";
} else {
strParaLine += "");
if (s_bNS2 || s_bOpera) {
gbWndPopupLinks.document.write("");
} else {
//YJ: IE301,302 and NS3.x works fine
gbWndPopupLinks.document.write("<");
gbWndPopupLinks.document.write("script>");
gbWndPopupLinks.document.write("function gotoUrl(aUrl) {opener.window.location=aUrl; close();}");
gbWndPopupLinks.document.write("<");
gbWndPopupLinks.document.write("/script>");
}
gbWndPopupLinks.document.write("");
gbWndPopupLinks.document.write(gbstrParaTotal);
gbWndPopupLinks.document.write("
