/usr/share/doc/swi-prolog-doc/Manual/simplex.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

<HTML>
<HEAD>
<TITLE>SWI-Prolog 5.6.59 Reference Manual: Section A.22</TITLE><LINK REL=home HREF="index.html">
<LINK REL=contents HREF="Contents.html">
<LINK REL=index HREF="DocIndex.html">
<LINK REL=previous HREF="registry.html">
<LINK REL=next HREF="threadpool.html">
<STYLE type="text/css">
/* Style sheet for SWI-Prolog latex2html
*/

dd.defbody
{ margin-bottom: 1em;
}

dt.pubdef
{ background-color: #c5e1ff;
}

pre.code
{ margin-left: 1.5em;
margin-right: 1.5em;
border: 1px dotted;
padding-top: 5px;
padding-left: 5px;
padding-bottom: 5px;
background-color: #f8f8f8;
}

div.navigate
{ text-align: center;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
}

div.title
{ text-align: center;
padding-bottom: 1em;
font-size: 200%;
font-weight: bold;
}

div.author
{ text-align: center;
font-style: italic;
}

div.abstract
{ margin-top: 2em;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
margin-left: 10%; margin-right:10%;
}

div.abstract-title
{ text-align: center;
padding: 5px;
font-size: 120%;
font-weight: bold;
}

div.toc-h1
{ font-size: 200%;
font-weight: bold;
}

div.toc-h2
{ font-size: 120%;
font-weight: bold;
margin-left: 2em;
}

div.toc-h3
{ font-size: 100%;
font-weight: bold;
margin-left: 4em;
}

div.toc-h4
{ font-size: 100%;
margin-left: 6em;
}

span.sec-nr
{ 
}

span.sec-title
{ 
}

span.pred-ext
{ font-weight: bold;
}

span.pred-tag
{ float: right;
font-size: 80%;
font-style: italic;
color: #202020;
}

/* Footnotes */

sup.fn { color: blue; text-decoration: underline; }
span.fn-text { display: none; }
sup.fn span {display: none;}
sup:hover span 
{ display: block !important;
position: absolute; top: auto; left: auto; width: 80%;
color: #000; background: white;
border: 2px solid;
padding: 5px; margin: 10px; z-index: 100;
font-size: smaller;
}
</STYLE>
</HEAD>
<BODY BGCOLOR="white">
<DIV class="navigate"><A class="nav" href="index.html"><IMG SRC="home.gif" BORDER=0 ALT="Home"></A>
<A class="nav" href="Contents.html"><IMG SRC="index.gif" BORDER=0 ALT="Contents"></A>
<A class="nav" href="DocIndex.html"><IMG SRC="yellow_pages.gif" BORDER=0 ALT="Index"></A>
<A class="nav" href="registry.html"><IMG SRC="prev.gif" BORDER=0 ALT="Previous"></A>
<A class="nav" href="threadpool.html"><IMG SRC="next.gif" BORDER=0 ALT="Next"></A>
</DIV>

<H2><A NAME="sec:A.22"><SPAN class="sec-nr">A.22</SPAN> <SPAN class="sec-title">library( 
simplex ): Solve linear programming problems</SPAN></A></H2>

<A NAME="simplex"></A>
<A NAME="sec:lib:simplex"></A>

<P>Author: <EM>Markus Triska</EM>

<P>A linear programming problem consists of a set of (linear) 
constraints, a number of variables and a linear objective function. The 
goal is to assign values to the variables so as to maximize (or 
minimize) the value of the objective function while satisfying all 
constraints.

<P>Many optimization problems can be modeled in this way. Consider 
having a knapsack with fixed capacity C, and a number of items with 
sizes s(i) and values v(i). The goal is to put as many items as possible 
in the knapsack (not exceeding its capacity) while maximizing the sum of 
their values.

<P>As another example, suppose you are given a set of coins with certain 
values, and you are to find the minimum number of coins such that their 
values sum up to a fixed amount. Instances of these problems are solved 
below.

<P>The <CODE>library(simplex)</CODE> module provides the following 
predicates:

<DL>
<DT class="pubdef"><A NAME="assignment/2"><STRONG>assignment</STRONG>(<VAR>+Cost, 
-Assignment</VAR>)</A></DT>
<DD class="defbody">
<VAR>Cost</VAR> is a list of lists representing the quadratic cost 
matrix, where element (i,j) denotes the cost of assigning entity <VAR>i</VAR> 
to entity <VAR>j</VAR>. An assignment with minimal cost is computed and 
unified with <VAR>Assignment</VAR> as a list of lists, representing an 
adjacency matrix.</DD>
<DT class="pubdef"><A NAME="constraint/3"><STRONG>constraint</STRONG>(<VAR>+Constraint, 
+S0, -S</VAR>)</A></DT>
<DD class="defbody">
Adds a linear or integrality constraint to the linear program 
corresponding to state <VAR>S0</VAR>. A linear constraint is of the form 
"Left Op C", where "Left" is a list of Coefficient*Variable terms 
(variables in the context of linear programs can be atoms or compound 
terms) and C is a non-negative numeric constant. The list represents the 
sum of its elements. <VAR>Op</VAR> can be =, =&lt; or &gt;=. The 
coefficient "1" can be omitted. An integrality constraint is of the form 
integral(Variable) and constrains Variable to an integral value.</DD>
<DT class="pubdef"><A NAME="constraint/4"><STRONG>constraint</STRONG>(<VAR>+Name, 
+Constraint, +S0, -S</VAR>)</A></DT>
<DD class="defbody">
Like <A NAME="idx:constraint3:1533"></A><A class="pred" href="simplex.html#constraint/3">constraint/3</A>, 
and attaches the name <VAR>Name</VAR> (an atom or compound term) to the 
new constraint.</DD>
<DT class="pubdef"><A NAME="constraint_add/4"><STRONG>constraint_add</STRONG>(<VAR>+Name, 
+Left, +S0, -S</VAR>)</A></DT>
<DD class="defbody">
<VAR>Left</VAR> is a list of Coefficient*Variable terms. The terms are 
added to the left-hand side of the constraint named
<VAR>Name</VAR>. <VAR>S</VAR> is unified with the resulting state.</DD>
<DT class="pubdef"><A NAME="gen_state/1"><STRONG>gen_state</STRONG>(<VAR>-State</VAR>)</A></DT>
<DD class="defbody">
Generates an initial state corresponding to an empty linear program.</DD>
<DT class="pubdef"><A NAME="maximize/3"><STRONG>maximize</STRONG>(<VAR>+Objective, 
+S0, -S</VAR>)</A></DT>
<DD class="defbody">
Maximizes the objective function, stated as a list of 
"Coefficient*Variable" terms that represents the sum of its elements, 
with respect to the linear program corresponding to state <VAR>S0</VAR>. <VAR>S</VAR> 
is unified with an internal representation of the solved instance.</DD>
<DT class="pubdef"><A NAME="minimize/3"><STRONG>minimize</STRONG>(<VAR>+Objective, 
+S0, -S</VAR>)</A></DT>
<DD class="defbody">
Analogous to <A NAME="idx:maximize3:1534"></A><A class="pred" href="simplex.html#maximize/3">maximize/3</A>.</DD>
<DT class="pubdef"><A NAME="objective/2"><STRONG>objective</STRONG>(<VAR>+State, 
-Objective</VAR>)</A></DT>
<DD class="defbody">
Unifies <VAR>Objective</VAR> with the result of the objective function 
at the obtained extremum. <VAR>State</VAR> must correspond to a solved 
instance.</DD>
<DT class="pubdef"><A NAME="shadow_price/3"><STRONG>shadow_price</STRONG>(<VAR>+State, 
+Name, -Value</VAR>)</A></DT>
<DD class="defbody">
Unifies <VAR>Value</VAR> with the shadow price corresponding to the 
linear constraint whose name is <VAR>Name</VAR>. <VAR>State</VAR> must 
correspond to a solved instance.</DD>
<DT class="pubdef"><A NAME="transportation/4"><STRONG>transportation</STRONG>(<VAR>+Supplies, 
+Demands, +Costs, -Transport</VAR>)</A></DT>
<DD class="defbody">
<VAR>Supplies</VAR> and <VAR>Demands</VAR> are both lists of positive 
numbers. Their respective sums must be equal. <VAR>Costs</VAR> is a list 
of lists representing the cost matrix, where an entry (i,j) denotes the 
cost of transporting one unit from <VAR>i</VAR> to <VAR>j</VAR>. A 
transportation plan having minimum cost is computed and unified with <VAR>Transport</VAR> 
in the form of a list of lists that represents the transportation 
matrix, where element (i,j) denotes how many units to ship from <VAR>i</VAR> 
to <VAR>j</VAR>.</DD>
<DT class="pubdef"><A NAME="variable_value/3"><STRONG>variable_value</STRONG>(<VAR>+State, 
+Variable, -Value</VAR>)</A></DT>
<DD class="defbody">
<VAR>Value</VAR> is unified with the value obtained for
<VAR>Variable</VAR>. <VAR>State</VAR> must correspond to a solved 
instance.

<P></DD>
</DL>

All numeric quantities are converted to rationals via <A NAME="idx:rationalize1:1535"></A><A class="pred" href="arith.html#rationalize/1">rationalize/1</A>, 
and rational arithmetic is used throughout solving linear programs. In 
the current implementation, all variables are implicitly constrained to 
be non-negative. This may change in future versions, and non-negativity 
constraints should therefore be stated explicitly.

<H3><A NAME="sec:A.22.1"><SPAN class="sec-nr">A.22.1</SPAN> <SPAN class="sec-title">Example 
1</SPAN></A></H3>

This is the "radiation therapy" example, taken from "Introduction to 
Operations Research" by Hillier and Lieberman. DCG notation is used to 
implicitly thread the state through posting the constraints:

<PRE class="code">
:- use_module(library(simplex)).

post_constraints --&gt;
        constraint([0.3*x1, 0.1*x2] =&lt; 2.7),
        constraint([0.5*x1, 0.5*x2] = 6),
        constraint([0.6*x1, 0.4*x2] &gt;= 6),
        constraint([x1] &gt;= 0),
        constraint([x2] &gt;= 0).

radiation(S) :-
        gen_state(S0),
        post_constraints(S0, S1),
        minimize([0.4*x1, 0.5*x2], S1, S).
</PRE>

<P>An example query:

<PRE class="code">
?- radiation(S), variable_value(S, x1, Val1), variable_value(S, x2, Val2).

Val1 = 15 rdiv 2
Val2 = 9 rdiv 2 ;
</PRE>

<H3><A NAME="sec:A.22.2"><SPAN class="sec-nr">A.22.2</SPAN> <SPAN class="sec-title">Example 
2</SPAN></A></H3>

Here is an instance of the knapsack problem described above, where C = 
8, and we have two types of items: One item with value 7 and size 6, and 
2 items each having size 4 and value 4. We introduce two variables, x(1) 
and x(2) that denote how many items to take of each type.

<PRE class="code">
knapsack_constrain(S) :-
        gen_state(S0),
        constraint([6*x(1), 4*x(2)] =&lt; 8, S0, S1),
        constraint([x(1)] =&lt; 1, S1, S2),
        constraint([x(2)] =&lt; 2, S2, S).

knapsack(S) :-
        knapsack_constrain(S0),
        maximize([7*x(1), 4*x(2)], S0, S).
</PRE>

<P>An example query yields:

<PRE class="code">
?- knapsack(S), variable_value(S, x(1), X1), variable_value(S, x(2), X2).

X1 = 1
X2 = 1 rdiv 2 ;
</PRE>

<P>That is, we are to take the one item of the first type, and half of 
one of the items of the other type to maximize the total value of items 
in the knapsack.

<P>If items can not be split, integrality constraints have to be 
imposed:

<PRE class="code">
knapsack_integral(S) :-
        knapsack_constrain(S0),
        constraint(integral(x(1)), S0, S1),
        constraint(integral(x(2)), S1, S2),
        maximize([7*x(1), 4*x(2)], S2, S).
</PRE>

<P>Now the result is different:

<PRE class="code">
?- knapsack_integral(S), variable_value(S, x(1), X1), variable_value(S, x(2), X2).

X1 = 0
X2 = 2
</PRE>

<P>That is, we are to take only the two items of the second type. Notice 
in particular that always choosing the remaining item with best 
performance (ratio of value to size) that still fits in the knapsack 
does not necessarily yield an optimal solution in the presence of 
integrality constraints.

<H3><A NAME="sec:A.22.3"><SPAN class="sec-nr">A.22.3</SPAN> <SPAN class="sec-title">Example 
3</SPAN></A></H3>

We are given 3 coins each worth 1, 20 coins each worth 5, and 10 coins 
each worth 20 units of money. The task is to find a minimal number of 
these coins that amount to 111 units of money. We introduce variables 
c(1), c(5) and c(20) denoting how many coins to take of the respective 
type:

<PRE class="code">
coins --&gt;
        constraint([c(1), 5*c(5), 20*c(20)] = 111),
        constraint([c(1)] =&lt; 3),
        constraint([c(5)] =&lt; 20),
        constraint([c(20)] =&lt; 10),
        constraint([c(1)] &gt;= 0),
        constraint([c(5)] &gt;= 0),
        constraint([c(20)] &gt;= 0),
        constraint(integral(c(1))),
        constraint(integral(c(5))),
        constraint(integral(c(20))),
        minimize([c(1), c(5), c(20)]).

coins(S) :-
        gen_state(S0),
        coins(S0, S).
</PRE>

<P>An example query:

<PRE class="code">
?- coins(S), variable_value(S, c(1), C1), variable_value(S, c(5), C5), variable_value(S, c(20), C20).

C1 = 1
C5 = 2
C20 = 5
</PRE>

<P></BODY></HTML>
swi-prolog-doc 5.6.59-1 / usr / share / doc / swi-prolog-doc / Manual / simplex.html
