author Vivien Maisonneuve Wed, 20 Aug 2014 11:42:22 +0000 (13:42 +0200) committer Vivien Maisonneuve Wed, 20 Aug 2014 11:42:22 +0000 (13:42 +0200)
 doc/reference.rst patch | blob | history doc/tutorial.rst patch | blob | history examples/squares.py patch | blob | history

index ae82aca..e6f291d 100644 (file)
@@ -84,12 +84,12 @@ Linear expressions are generally built using overloaded operators.
For example, if ``x`` is a :class:`Symbol`, then ``x + 1`` is an instance of :class:`LinExpr`.

.. class:: LinExpr(coefficients=None, constant=0)
-              LinExpr(string)
+           LinExpr(string)

Return a linear expression from a dictionary or a sequence, that maps symbols to their coefficients, and a constant term.
The coefficients and the constant term must be rational numbers.

-    For example, the linear expression ``x + 2y + 1`` can be constructed using one of the following instructions:
+    For example, the linear expression ``x + 2*y + 1`` can be constructed using one of the following instructions:

>>> x, y = symbols('x y')
>>> LinExpr({x: 1, y: 2}, 1)
@@ -102,7 +102,7 @@ For example, if ``x`` is a :class:`Symbol`, then ``x + 1`` is an instance of :cl

Alternatively, linear expressions can be constructed from a string:

-    >>> LinExpr('x + 2*y + 1')
+    >>> LinExpr('x + 2y + 1')

:class:`LinExpr` instances are hashable, and should be treated as immutable.

@@ -177,7 +177,7 @@ For example, if ``x`` is a :class:`Symbol`, then ``x + 1`` is an instance of :cl

>>> x, y = symbols('x y')
>>> x < y
-        Le(x - y + 1, 0)
+        x + 1 <= y

.. method:: scaleint()

@@ -220,7 +220,7 @@ Apart from :mod:`Symbol`, a particular case of linear expressions are rational v
They are implemented by the :class:`Rational` class, that inherits from both :class:`LinExpr` and :class:`fractions.Fraction` classes.

.. class:: Rational(numerator, denominator=1)
-              Rational(string)
+           Rational(string)

The first version requires that the *numerator* and *denominator* are instances of :class:`numbers.Rational` and returns a new :class:`Rational` instance with the value ``numerator/denominator``.
If the denominator is ``0``, it raises a :exc:`ZeroDivisionError`.
@@ -243,14 +243,16 @@ A *convex polyhedron* (or simply "polyhedron") is the space defined by a system
This space can be unbounded.

.. class:: Polyhedron(equalities, inequalities)
-              Polyhedron(string)
-              Polyhedron(geometric object)
+           Polyhedron(string)
+           Polyhedron(geometric object)

Return a polyhedron from two sequences of linear expressions: *equalities* is a list of expressions equal to ``0``, and *inequalities* is a list of expressions greater or equal to ``0``.
For example, the polyhedron ``0 <= x <= 2, 0 <= y <= 2`` can be constructed with:

>>> x, y = symbols('x y')
>>> square = Polyhedron([], [x, 2 - x, y, 2 - y])
+    >>> square
+    And(0 <= x, x <= 2, 0 <= y, y <= 2)

It may be easier to use comparison operators :meth:`LinExpr.__lt__`, :meth:`LinExpr.__le__`, :meth:`LinExpr.__ge__`, :meth:`LinExpr.__gt__`, or functions :func:`Lt`, :func:`Le`, :func:`Eq`, :func:`Ge` and :func:`Gt`, using one of the following instructions:

@@ -268,6 +270,7 @@ This space can be unbounded.
>>> square = Polyhedron('0 <= x <= 2, 0 <= y <= 2')
>>> square2 = Polyhedron('2 <= x <= 4, 2 <= y <= 4')
>>> Polyhedron(square | square2)
+    And(x <= 4, 0 <= x, y <= 4, 0 <= y, x <= y + 2, y <= x + 2)

A polyhedron is a :class:`Domain` instance, and, therefore, inherits the functionalities of this class.
It is also a :class:`GeometricObject` instance.
@@ -320,14 +323,16 @@ A *domain* is a union of polyhedra.
Unlike polyhedra, domains allow exact computation of union, subtraction and complementary operations.

.. class:: Domain(*polyhedra)
-              Domain(string)
-              Domain(geometric object)
+           Domain(string)
+           Domain(geometric object)

Return a domain from a sequence of polyhedra.

>>> square = Polyhedron('0 <= x <= 2, 0 <= y <= 2')
>>> square2 = Polyhedron('2 <= x <= 4, 2 <= y <= 4')
-    >>> dom = Domain([square, square2])
+    >>> dom = Domain(square, square2)
+    >>> dom
+    Or(And(x <= 2, 0 <= x, y <= 2, 0 <= y), And(x <= 4, 2 <= x, y <= 4, 2 <= y))

It is also possible to build domains from polyhedra using arithmetic operators :meth:`Domain.__and__`, :meth:`Domain.__or__` or functions :func:`And` and :func:`Or`, using one of the following instructions:

index 9b55a03..b13a22e 100644 (file)
@@ -24,31 +24,32 @@ Then, we can build the :class:`Polyhedron` object ``square1`` from its constrain

>>> square1 = Le(0, x, 2) & Le(0, y, 2)
>>> square1
-And(Ge(x, 0), Ge(-x + 2, 0), Ge(y, 0), Ge(-y + 2, 0))
+And(0 <= x, x <= 2, 0 <= y, y <= 2)

LinPy provides comparison functions :func:`Lt`, :func:`Le`, :func:`Eq`, :func:`Ne`, :func:`Ge` and :func:`Gt` to build constraints, and logical operators :func:`And`, :func:`Or`, :func:`Not` to combine them.
Alternatively, a polyhedron can be built from a string:

>>> square2 = Polyhedron('1 <= x <= 3, 1 <= y <= 3')
>>> square2
-And(Ge(x - 1, 0), Ge(-x + 3, 0), Ge(y - 1, 0), Ge(-y + 3, 0))
+And(1 <= x, x <= 3, 1 <= y, y <= 3)

The usual polyhedral operations are available, including intersection:

->>> inter = square1.intersection(square2)
+>>> inter = square1.intersection(square2) # or square1 & square2
>>> inter
-And(Ge(x - 1, 0), Ge(-x + 2, 0), Ge(y - 1, 0), Ge(-y + 2, 0))
+And(1 <= x, x <= 2, 1 <= y, y <= 2)

convex union:

>>> hull = square1.convex_union(square2)
>>> hull
-And(Ge(x, 0), Ge(y, 0), Ge(-x + y + 2, 0), Ge(x - y + 2, 0), Ge(-x + 3, 0), Ge(-y + 3, 0))
+And(0 <= x, 0 <= y, x <= y + 2, y <= x + 2, x <= 3, y <= 3)

and projection:

->>> square1.project([y])
-And(Ge(x, 0), Ge(-x + 2, 0))
+>>> proj = square1.project([y])
+>>> proj
+And(0 <= x, x <= 2)

Equality and inclusion tests are also provided.
Special values :data:`Empty` and :data:`Universe` represent the empty and universe polyhedra.
@@ -68,19 +69,19 @@ LinPy is also able to manipulate polyhedral *domains*, that is, unions of polyhe
An example of domain is the set union (as opposed to convex union) of polyhedra ``square1`` and ``square2``.
The result is a :class:`Domain` object.

->>> union = square1 | square2
+>>> union = square1.union(square2) # or square1 | square2
>>> union
-Or(And(Ge(-x + 2, 0), Ge(x, 0), Ge(-y + 2, 0), Ge(y, 0)), And(Ge(-x + 3, 0), Ge(x - 1, 0), Ge(-y + 3, 0), Ge(y - 1, 0)))
+Or(And(x <= 2, 0 <= x, y <= 2, 0 <= y), And(x <= 3, 1 <= x, y <= 3, 1 <= y))
>>> union <= hull
True

Unlike polyhedra, domains allow exact computation of union, subtraction and complementary operations.

->>> diff = square1 - square2
+>>> diff = square1.difference(square2) # or square1 - square2
>>> diff
-Or(And(Eq(x, 0), Ge(y, 0), Ge(-y + 2, 0)), And(Eq(y, 0), Ge(x - 1, 0), Ge(-x + 2, 0)))
+Or(And(x == 0, 0 <= y, y <= 2), And(y == 0, 1 <= x, x <= 2))
>>> ~square1
-Or(Ge(-x - 1, 0), Ge(x - 3, 0), And(Ge(x, 0), Ge(-x + 2, 0), Ge(-y - 1, 0)), And(Ge(x, 0), Ge(-x + 2, 0), Ge(y - 3, 0)))
+Or(x + 1 <= 0, 3 <= x, And(0 <= x, x <= 2, y + 1 <= 0), And(0 <= x, x <= 2, 3 <= y))

.. _tutorial_plot:
index 15aed16..1a0cedb 100755 (executable)
@@ -31,7 +31,7 @@ if __name__ == '__main__':
shell.push('square2')
shell.push()

-    shell.push('inter = square1.intersection(square2)')
+    shell.push('inter = square1.intersection(square2) # or square1 & square2')
shell.push('inter')
shell.push()

@@ -39,18 +39,19 @@ if __name__ == '__main__':
shell.push('hull')
shell.push()

-    shell.push('square1.project([y])')
+    shell.push('proj = square1.project([y])')
+    shell.push('proj')
shell.push()

shell.push('inter <= square1')
shell.push('inter == Empty')
shell.push()

-    shell.push('union = square1 | square2')
+    shell.push('union = square1.union(square2) # or square1 | square2')
shell.push('union')
shell.push('union <= hull')
shell.push()

-    shell.push('diff = square1 - square2')
+    shell.push('diff = square1.difference(square2) # or square1 - square2')
shell.push('diff')
shell.push('~square1')