<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>A Dive-in Tutorial on PyMathProg — pymprog v0.5.0 documentation</title>
<link rel="stylesheet" href="_static/default.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '0.5.0',
COLLAPSE_MODINDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<link rel="top" title="pymprog v0.5.0 documentation" href="index.html" />
<link rel="next" title="More Advanced Examples" href="advanced.html" />
<link rel="prev" title="How to Setup PyMathProg" href="setup.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="advanced.html" title="More Advanced Examples"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="setup.html" title="How to Setup PyMathProg"
accesskey="P">previous</a> |</li>
<li><a href="index.html">pymprog v0.5.0 documentation</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="a-dive-in-tutorial-on-pymathprog">
<h1>A Dive-in Tutorial on PyMathProg<a class="headerlink" href="#a-dive-in-tutorial-on-pymathprog" title="Permalink to this headline">¶</a></h1>
<div class="section" id="a-dive-in-example">
<span id="divin"></span><h2>A dive-in example<a class="headerlink" href="#a-dive-in-example" title="Permalink to this headline">¶</a></h2>
<p>Let’s start with a simple problem. Suppose you
are given an easy linear program, which has <em>3</em>
variables and <em>3</em> constraints. The data is given
as a <em>3x3</em> matrix for the constraints, and <em>2</em>
vectors of length <em>3</em> for the objective function
and the right-hand-side of the constraints.
You need to solve the problem and report the
optimal solution. Very basic. Here is how
to get it done with PyMathProg:</p>
<div class="highlight-python"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39</pre></div></td><td class="code"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">pymprog</span> <span class="kn">import</span> <span class="o">*</span> <span class="c"># Import the module</span>
<span class="c"># index and data</span>
<span class="n">xid</span><span class="p">,</span> <span class="n">rid</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="n">c</span> <span class="o">=</span> <span class="p">(</span><span class="mf">10.0</span><span class="p">,</span> <span class="mf">6.0</span><span class="p">,</span> <span class="mf">4.0</span><span class="p">)</span>
<span class="n">mat</span> <span class="o">=</span> <span class="p">[</span> <span class="p">(</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">),</span>
<span class="p">(</span><span class="mf">10.0</span><span class="p">,</span> <span class="mf">4.0</span><span class="p">,</span> <span class="mf">5.0</span><span class="p">),</span>
<span class="p">(</span><span class="mf">2.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">,</span> <span class="mf">6.0</span><span class="p">)]</span>
<span class="n">b</span> <span class="o">=</span> <span class="p">(</span><span class="mf">100.0</span><span class="p">,</span> <span class="mf">600.0</span><span class="p">,</span> <span class="mf">300.0</span><span class="p">)</span>
<span class="c">#problem definition</span>
<span class="n">beginModel</span><span class="p">(</span><span class="s">'basic'</span><span class="p">)</span>
<span class="n">verbose</span><span class="p">(</span><span class="bp">True</span><span class="p">)</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">var</span><span class="p">(</span><span class="n">xid</span><span class="p">,</span> <span class="s">'X'</span><span class="p">)</span> <span class="c">#create variables</span>
<span class="n">maximize</span><span class="p">(</span> <span class="c">#set objective</span>
<span class="nb">sum</span><span class="p">(</span><span class="n">c</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">xid</span><span class="p">),</span> <span class="s">'myobj'</span>
<span class="p">)</span>
<span class="n">r</span><span class="o">=</span><span class="n">st</span><span class="p">(</span> <span class="c">#set constraints</span>
<span class="nb">sum</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">*</span><span class="n">mat</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="n">xid</span><span class="p">)</span> <span class="o"><=</span> <span class="n">b</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">rid</span>
<span class="p">)</span>
<span class="n">solve</span><span class="p">()</span> <span class="c">#solve and report</span>
<span class="k">print</span> <span class="s">"Solver status:"</span><span class="p">,</span> <span class="n">status</span><span class="p">()</span>
<span class="k">print</span> <span class="s">'Z = </span><span class="si">%g</span><span class="s">;'</span> <span class="o">%</span> <span class="n">vobj</span><span class="p">()</span> <span class="c"># print obj value</span>
<span class="c">#Print variable names and primal values</span>
<span class="k">print</span> <span class="s">';</span><span class="se">\n</span><span class="s">'</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s">'</span><span class="si">%s</span><span class="s"> = </span><span class="si">%g</span><span class="s"> {dual: </span><span class="si">%g</span><span class="s">}'</span> <span class="o">%</span> <span class="p">(</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">primal</span><span class="p">,</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">dual</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">xid</span><span class="p">)</span>
<span class="k">print</span> <span class="s">';</span><span class="se">\n</span><span class="s">'</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s">'</span><span class="si">%s</span><span class="s"> = </span><span class="si">%g</span><span class="s"> {dual: </span><span class="si">%g</span><span class="s">}'</span> <span class="o">%</span> <span class="p">(</span>
<span class="n">r</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">r</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">primal</span><span class="p">,</span> <span class="n">r</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">dual</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">rid</span><span class="p">)</span>
<span class="c"># Since version 0.3.0</span>
<span class="k">print</span> <span class="n">reportKKT</span><span class="p">()</span>
<span class="k">print</span> <span class="s">"Environment:"</span><span class="p">,</span> <span class="n">env</span>
<span class="k">for</span> <span class="n">pn</span> <span class="ow">in</span> <span class="nb">dir</span><span class="p">(</span><span class="n">env</span><span class="p">):</span>
<span class="k">if</span> <span class="n">pn</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span><span class="o">==</span><span class="s">'__'</span><span class="o">==</span><span class="n">pn</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:]:</span> <span class="k">continue</span>
<span class="k">print</span> <span class="n">pn</span><span class="p">,</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">env</span><span class="p">,</span> <span class="n">pn</span><span class="p">)</span>
<span class="c"># Since version 0.4.2</span>
<span class="k">print</span> <span class="n">evaluate</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="p">(</span><span class="n">i</span><span class="o">+</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">])</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">xid</span><span class="p">))</span>
<span class="k">print</span> <span class="nb">sum</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">primal</span><span class="o">*</span><span class="p">(</span><span class="n">i</span><span class="o">+</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">primal</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">xid</span><span class="p">)</span>
<span class="n">endModel</span><span class="p">()</span> <span class="c">#Good habit: do away with the problem</span>
</pre></div>
</td></tr></table></div>
<p>I suppose the code above is not very hard to understand
if you know a little bit about programming.
Basically, there are three logical building blocks:
it starts with a data block, followed by a modelling
block, and ends with a solution report block.</p>
<p>Data block ( <strong>lines 3-8</strong> ): the matrix and the vectors
are defined in it (of course, you can also read data from
some external database, as Python can do that easily).
Also, in line <strong>3</strong> the index for variables ‘xid’ and
the index for constraints ‘rid’ are defined to be
integers in the range from 0 to 3: [0, 3). These
index sets are used later in defining the model.
Indices can be almost anything: strings,
numbers (yes, numbers, not just integers!), etc.
In Python terminology, they can be any <em>immutable</em>
objects (so that they have a well-defined hash).</p>
<p>Modelling block: ( <strong>lines 10-18</strong> ): It all starts by
a function:</p>
<dl class="function">
<dt id="beginModel">
<tt class="descname">beginModel</tt><big>(</big><em>model_name</em><big>)</big><a class="headerlink" href="#beginModel" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>
<p>that declare the beginning of a problem with the given name.
This basically creates a problem instance and put in a
hidden place, which you can only access through
other functions provided by PyMathProg,
as the rest of this example illustrates.
However, if you prefer explicitly handling the problem directly,
PyMathProg also provides that for you, and we will come to that later.</p>
<p>Line 11 turns on the verbosity option, which enables the
PyMathProg to output the actually model you are defining
(the actual output will be provided later).</p>
<p>Line 12 defines the variable: you simply provide the index
set and the name of the variable. The name is optional, and
PyMathProg can supply default names. It is usually a good
habbit to explicitly specify the name of variables.</p>
<p>Lines 13-15 define the objective: maximize the summation
of the terms b[i]*x[i], where i goes from 0 to 3.</p>
<p>Line 16-18 define the constraints. the function <em>st(...)</em>
adds the provided constraints to the current model, the
returned constraints are kept in the variable ‘r’.</p>
<dl class="function">
<dt>
<tt class="descname">st(expr, name=None, ndx=None) --> constraints</tt></dt>
<dd><p>Add some constraint(s) to the model.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><em>expr</em> – expression(s) of your constraint(s)</li>
<li><em>name</em> – name of your constraint(s) – index will be automatically appended.</li>
<li><em>ndx</em> – index of your constraint(s) – default is 0, 1, 2, ...</li>
</ul>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<p>OK, we are done with model definition, and we can actually
do it with three calls in three lines for three components:
the variables, the objective, and the constraints.</p>
<p>Solution and Report ( <strong>lines 19-39</strong> ):</p>
<p>Line 19 issues a call <em>solve()</em> to solve the model. This
function can take an optional argument, indicating what
kind of program to deal with:</p>
<dl class="function">
<dt>
<tt class="descname">solve([kind]) --> None</tt></dt>
<dd><p>Solve as an LP problem or as a MIP problem</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameter:</th><td class="field-body"><em>kind</em> – can only be either <em>float</em> (LP) or <em>int</em> (MIP)</td>
</tr>
</tbody>
</table>
</dd></dl>
<p>Since GLPK provides different methods to solve a problem,
PyMathProg provides solver options to choose which method
you would use. Use global function <em>solvopt(...)</em> to set
your options. For example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">solvopt</span><span class="p">(</span><span class="n">method</span><span class="o">=</span><span class="s">'exact'</span><span class="p">,</span> <span class="n">integer</span><span class="o">=</span><span class="s">'advanced'</span><span class="p">)</span>
</pre></div>
</div>
<p>will enable you to access the exact arithmetic provided by
GLPK to solve the LP problem first, then use the advanced
branch and bound method for the integer problem. For LP
problems, you can choose from ‘simplex’ (default), ‘exact’,
‘interior’; for integer problems, ‘plain’ (default) or ‘advanced’.</p>
<p>Line 20 reports the solution status.</p>
<p>Line 21 printss the optimal objective function value. You can also
check the status of the solver by call the <em>status()</em> function.</p>
<p>Line 23-25 reports the actual solution. Notice how the solutions are
conveniently accessed by <em>x[i].primal</em> and <em>x[i].name</em>. You can
also access the dual values by <em>x[i].dual</em>. Similar syntax holds
for <em>constraints</em> as returned from the <em>st(...)</em> function call.</p>
<p>Line 31 reports the KKT optimality condition. For more details
you may refer to PYGLPK and GLPK documentation. You can also
access the environment to set some environment variables for
the solver ( line 32 ), which is documented in PYGLPK.</p>
<p>Line 37 evaluates an expression containing variables,
which yields the same result as Line 38. The function
<em>evaluate(.)</em> saves you from typing ‘.primal’s after
the variables.</p>
<p>Finally, line 39 calls the function <em>endModel()</em> to do away
with the problem.</p>
<p>And we are finished! Here is the output (with the verbosity turned on):</p>
<div class="highlight-python"><pre>MAX 'myobj': 10 X[0]+ 6 X[1]+ 4 X[2]
s.t. R0[0]: X[0]+ X[1]+ X[2] <= 100.0
s.t. R0[1]: 10 X[0]+ 4 X[1]+ 5 X[2] <= 600.0
s.t. R0[2]: 2 X[0]+ 2 X[1]+ 6 X[2] <= 300.0
Solver status: opt
Z = 733.333;
X[0] = 33.3333 {dual: 0};
X[1] = 66.6667 {dual: 0};
X[2] = 0 {dual: -2.66667}
R0[0] = 100 {dual: 3.33333};
R0[1] = 600 {dual: 0.666667};
R0[2] = 200 {dual: 0}
Karush-Kuhn-Tucker optimality conditions:
=========================================
1) Error in Primal Solutions:
-----------------------------
Largest absolute error: 0.000000 (row id: 1)
Largest relative error: 0.000000 (row id: 1)
Quality of primal solution: H
2) Error in Satisfying Primal Bounds:
-------------------------------------
Largest absolute error: 0.000000 (var id: 0)
Largest relative error: 0.000000 (var id: 0)
Quality of primal feasibility: H
3) Error in Dual Solutions:
-----------------------------
Largest absolute error: 0.000000 (col id: 0)
Largest relative error: 0.000000 (col id: 2)
Quality of dual solution: H
4) Error in Satisfying Dual Bounds:
-------------------------------------
Largest absolute error: 0.000000 (var id: 0)
Largest relative error: 0.000000 (var id: 0)
Quality of dual feasibility: H
Environment: <glpk.Environment object at 0xb7cf66bc></pre>
</div>
</div>
<div class="section" id="a-parallel-example">
<span id="parallel"></span><h2>A parallel example<a class="headerlink" href="#a-parallel-example" title="Permalink to this headline">¶</a></h2>
<p>In the above example, we use global function calls to create and manipulate
a hidden model – we did not directly handle it. PyMathProg also provides
another set of means to allow you direct handling of the model. We now
take a look at an equivalent example with direct model handling:</p>
<div class="highlight-python"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30</pre></div></td><td class="code"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">pymprog</span> <span class="c"># Import the module</span>
<span class="c"># index and data</span>
<span class="n">cid</span><span class="p">,</span> <span class="n">rid</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="n">c</span> <span class="o">=</span> <span class="p">(</span><span class="mf">10.0</span><span class="p">,</span> <span class="mf">6.0</span><span class="p">,</span> <span class="mf">4.0</span><span class="p">)</span>
<span class="n">mat</span> <span class="o">=</span> <span class="p">[</span> <span class="p">(</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">),</span>
<span class="p">(</span><span class="mf">10.0</span><span class="p">,</span> <span class="mf">4.0</span><span class="p">,</span> <span class="mf">5.0</span><span class="p">),</span>
<span class="p">(</span><span class="mf">2.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">,</span> <span class="mf">6.0</span><span class="p">)]</span>
<span class="n">b</span> <span class="o">=</span> <span class="p">(</span><span class="mf">100.0</span><span class="p">,</span> <span class="mf">600.0</span><span class="p">,</span> <span class="mf">300.0</span><span class="p">)</span>
<span class="c"># Create empty problem instance</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">pymprog</span><span class="o">.</span><span class="n">model</span><span class="p">(</span><span class="s">'sample'</span><span class="p">)</span>
<span class="c">#create variables: </span>
<span class="n">x</span> <span class="o">=</span> <span class="n">p</span><span class="o">.</span><span class="n">var</span><span class="p">(</span><span class="n">cid</span><span class="p">,</span> <span class="s">'X'</span><span class="p">)</span> <span class="c"># x: dict with keys in 'cid'</span>
<span class="n">p</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">c</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">cid</span><span class="p">),</span> <span class="s">'myobj'</span><span class="p">)</span>
<span class="n">r</span><span class="o">=</span><span class="n">p</span><span class="o">.</span><span class="n">st</span><span class="p">(</span>
<span class="nb">sum</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">*</span><span class="n">mat</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="n">cid</span><span class="p">)</span> <span class="o"><=</span> <span class="n">b</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">rid</span><span class="p">)</span>
<span class="c">#solve and report</span>
<span class="n">p</span><span class="o">.</span><span class="n">solve</span><span class="p">()</span>
<span class="k">print</span> <span class="s">'Z = </span><span class="si">%g</span><span class="s">;'</span> <span class="o">%</span> <span class="n">p</span><span class="o">.</span><span class="n">vobj</span><span class="p">()</span> <span class="c"># print obj value</span>
<span class="c"># Print struct variable names and primal values</span>
<span class="k">print</span> <span class="s">';</span><span class="se">\n</span><span class="s">'</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s">'</span><span class="si">%s</span><span class="s"> = </span><span class="si">%g</span><span class="s"> {dual: </span><span class="si">%g</span><span class="s">}'</span> <span class="o">%</span> <span class="p">(</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">primal</span><span class="p">,</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">dual</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">cid</span><span class="p">)</span>
<span class="k">print</span> <span class="s">';</span><span class="se">\n</span><span class="s">'</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s">'</span><span class="si">%s</span><span class="s"> = </span><span class="si">%g</span><span class="s"> {dual: </span><span class="si">%g</span><span class="s">}'</span> <span class="o">%</span> <span class="p">(</span>
<span class="n">r</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">r</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">primal</span><span class="p">,</span> <span class="n">r</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">dual</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">rid</span><span class="p">)</span>
<span class="c"># Since version 0.3.0</span>
<span class="k">print</span> <span class="n">p</span><span class="o">.</span><span class="n">reportKKT</span><span class="p">()</span>
<span class="k">print</span> <span class="s">"Environment:"</span><span class="p">,</span> <span class="n">pymprog</span><span class="o">.</span><span class="n">env</span>
</pre></div>
</td></tr></table></div>
</div>
<div class="section" id="zero-sum-two-player-game">
<span id="game2p"></span><h2>Zero-sum Two-player Game<a class="headerlink" href="#zero-sum-two-player-game" title="Permalink to this headline">¶</a></h2>
<p>Here this example intends to show the use
of the ‘primal’ and ‘dual’ properties.
A zero-sum two-player game is a game
between two players, where the gain
of one player is the loss of the other,
hence their pay-offs always sums up to zero.
The pay-off of player one under his own
strategy <em>i</em> and player two’s strategy <em>j</em>
is given as a(i,j), which gives the pay-off
matrix when all strategy combinations are
taken into consideration.</p>
<p>Here is an LP formulation to find the
equilibrium mixed strategies and the value
of the game.</p>
<div class="highlight-python"><table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34</pre></div></td><td class="code"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">pymprog</span> <span class="kn">import</span> <span class="o">*</span>
<span class="c">#####Solve this 2-player 0-sum game:</span>
<span class="c">##</span>
<span class="c">## Gain for player 1 </span>
<span class="c">## (Loss for player 2)</span>
<span class="c">## </span>
<span class="c">## || Player 2</span>
<span class="c">## Player 1 || B1 B2</span>
<span class="c">## A1 || 5 9</span>
<span class="c">## A2 || 8 6</span>
<span class="c">##</span>
<span class="c">##############################</span>
<span class="n">beginModel</span><span class="p">(</span><span class="s">'game'</span><span class="p">)</span>
<span class="c"># the gain of player 1</span>
<span class="n">v</span> <span class="o">=</span> <span class="n">var</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'game_value'</span><span class="p">,</span>
<span class="n">bounds</span><span class="o">=</span><span class="p">(</span><span class="bp">None</span><span class="p">,</span><span class="bp">None</span><span class="p">))</span> <span class="c">#free</span>
<span class="c"># mixed strategy of player 2</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">var</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">],</span> <span class="s">'prob'</span><span class="p">)</span>
<span class="c"># player 2 wants to minimize v</span>
<span class="n">minimize</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="c"># probability sums to 1</span>
<span class="n">st</span><span class="p">(</span><span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="n">p</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span>
<span class="c"># player 1 plays the best strat.</span>
<span class="n">r1</span><span class="o">=</span><span class="n">st</span><span class="p">(</span><span class="n">v</span> <span class="o">>=</span> <span class="mi">5</span><span class="o">*</span><span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="mi">9</span><span class="o">*</span><span class="n">p</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
<span class="n">r2</span><span class="o">=</span><span class="n">st</span><span class="p">(</span><span class="n">v</span> <span class="o">>=</span> <span class="mi">8</span><span class="o">*</span><span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="mi">6</span><span class="o">*</span><span class="n">p</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
<span class="n">solve</span><span class="p">()</span>
<span class="k">print</span> <span class="n">v</span>
<span class="k">print</span> <span class="s">"Player 1's mixed Strategy:"</span>
<span class="k">print</span> <span class="s">"A1:"</span><span class="p">,</span> <span class="n">r1</span><span class="o">.</span><span class="n">dual</span><span class="p">,</span> <span class="s">"A2:"</span><span class="p">,</span> <span class="n">r2</span><span class="o">.</span><span class="n">dual</span>
<span class="k">print</span> <span class="s">"Player 2's mixed strategy:"</span>
<span class="k">print</span> <span class="n">p</span>
<span class="n">endModel</span><span class="p">()</span>
</pre></div>
</td></tr></table></div>
<p>And the output is as follows:</p>
<div class="highlight-python"><pre>game_value=7.000000
Player 1's mixed Strategy:
A1: 0.333333333333 A2: 0.666666666667
Player 2's mixed strategy:
{1: prob[1]=0.500000, 2: prob[2]=0.500000}</pre>
</div>
</div>
<div class="section" id="customized-algorithms">
<span id="custom"></span><h2>Customized algorithms<a class="headerlink" href="#customized-algorithms" title="Permalink to this headline">¶</a></h2>
<p>It is possible to write your customized algorithms
using row/column generation and warm start your
simplex method(that is, start the simplex method with
the optimal basis from your last invocation,
which is often used when employing row/column generation
– just remember not to turn on the ‘presolve’ option).
If your row/column generation algorithm is computation
intensive and you need to write them in C and invoke
from Python, you can consider EXPY (<a class="reference external" href="http://expy.sf.net">http://expy.sf.net</a>),
ctypes, SWIG (Sip for C++), and Boost.Python.</p>
<p>It is also possible to have a callback hooked into
the Branch & Bound method of GLPK, by passing a
callback function object as an option to the solver.
For how to manipulate options, please refer to the
other documents of pymathprog.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference external" href="">A Dive-in Tutorial on PyMathProg</a><ul>
<li><a class="reference external" href="#a-dive-in-example">A dive-in example</a></li>
<li><a class="reference external" href="#a-parallel-example">A parallel example</a></li>
<li><a class="reference external" href="#zero-sum-two-player-game">Zero-sum Two-player Game</a></li>
<li><a class="reference external" href="#customized-algorithms">Customized algorithms</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="setup.html"
title="previous chapter">How to Setup PyMathProg</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="advanced.html"
title="next chapter">More Advanced Examples</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/tutorial.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="advanced.html" title="More Advanced Examples"
>next</a> |</li>
<li class="right" >
<a href="setup.html" title="How to Setup PyMathProg"
>previous</a> |</li>
<li><a href="index.html">pymprog v0.5.0 documentation</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2009, Yingjie Lan.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.3.
</div>
</body>
</html>
