X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/a08ebc700e22f6aee8147cb5b5323a6c040b12db..f422e08c7a7758cd1e084a5cf042f5ddb3701ffc:/doc/reference.rst?ds=inline diff --git a/doc/reference.rst b/doc/reference.rst index 8184c43..af5cd4d 100644 --- a/doc/reference.rst +++ b/doc/reference.rst @@ -12,7 +12,7 @@ They correspond to mathematical variables. Return a symbol with the name string given in argument. Alternatively, the function :func:`symbols` allows to create several symbols at once. - Symbols are instances of class :class:`LinExpr` and, as such, inherit its functionalities. + Symbols are instances of class :class:`LinExpr` and inherit its functionalities. >>> x = Symbol('x') >>> x @@ -46,12 +46,12 @@ They correspond to mathematical variables. >>> x, y = symbols(['x', 'y']) -Sometimes, you need to have a unique symbol, for example as a temporary one in some calculation, which is going to be substituted for something else at the end anyway. +Sometimes you need to have a unique symbol. For example, you might need a temporary one in some calculation, which is going to be substituted for something else at the end anyway. This is achieved using ``Dummy('x')``. .. class:: Dummy(name=None) - A variation of :class:`Symbol` which are all unique, identified by an internal count index. + A variation of :class:`Symbol` in which all symbols are unique and identified by an internal count index. If a name is not supplied then a string value of the count index will be used. This is useful when a unique, temporary variable is needed and the name of the variable used in the expression is not important. @@ -79,8 +79,8 @@ For example, if ``x`` is a :class:`Symbol`, then ``x + 1`` is an instance of :cl .. class:: LinExpr(coefficients=None, constant=0) 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 must be rational numbers. + 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: @@ -88,7 +88,7 @@ For example, if ``x`` is a :class:`Symbol`, then ``x + 1`` is an instance of :cl >>> LinExpr({x: 1, y: 2}, 1) >>> LinExpr([(x, 1), (y, 2)], 1) - although it may be easier to use overloaded operators: + However, it may be easier to use overloaded operators: >>> x, y = symbols('x y') >>> x + 2*y + 1 @@ -148,11 +148,11 @@ For example, if ``x`` is a :class:`Symbol`, then ``x + 1`` is an instance of :cl .. method:: __mul__(value) - Return the product of the linear expression by a rational. + Return the product of the linear expression as a rational. .. method:: __truediv__(value) - Return the quotient of the linear expression by a rational. + Return the quotient of the linear expression as a rational. .. method:: __eq__(expr) @@ -181,7 +181,7 @@ For example, if ``x`` is a :class:`Symbol`, then ``x + 1`` is an instance of :cl subs(pairs) Substitute the given symbol by an expression and return the resulting expression. - Raise :exc:`TypeError` is the resulting expression is not linear. + Raise :exc:`TypeError` if the resulting expression is not linear. >>> x, y = symbols('x y') >>> e = x + 2*y + 1 @@ -216,14 +216,14 @@ They are implemented by the :class:`Rational` class, that inherits from both :cl .. class:: Rational(numerator, denominator=1) Rational(string) - The first version requires that *numerator* and *denominator* are instances of :class:`numbers.Rational` and returns a new :class:`Rational` instance with value ``numerator/denominator``. - If denominator is ``0``, it raises a :exc:`ZeroDivisionError`. + 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`. The other version of the constructor expects a string. The usual form for this instance is:: [sign] numerator ['/' denominator] - where the optional ``sign`` may be either '+' or '-' and ``numerator`` and ``denominator`` (if present) are strings of decimal digits. + where the optional ``sign`` may be either '+' or '-' and the ``numerator`` and ``denominator`` (if present) are strings of decimal digits. See the documentation of :class:`fractions.Fraction` for more information and examples. @@ -260,7 +260,7 @@ This space can be unbounded. >>> square2 = Polyhedron('2 <= x <= 4, 2 <= y <= 4') >>> Polyhedron(square | square2) - A polyhedron is a :class:`Domain` instance, and, as such, inherits the functionalities of this class. + A polyhedron is a :class:`Domain` instance, and, therefore, inherits the functionalities of this class. It is also a :class:`GeometricObject` instance. .. attribute:: equalities @@ -476,7 +476,7 @@ Unlike polyhedra, domains allow exact computation of union and complementary ope Comparison and Logic Operators ------------------------------ -The following functions allow to create :class:`Polyhedron` or :class:`Domain` instances by comparison of :class:`LinExpr` instances: +The following functions create :class:`Polyhedron` or :class:`Domain` instances by comparison of :class:`LinExpr` instances: .. function:: Lt(expr1, expr2[, expr3, ...]) @@ -503,15 +503,15 @@ The following functions allow to create :class:`Polyhedron` or :class:`Domain` i Create the polyhedron with constraints ``expr1 > expr2 > expr3 ...``. -The following functions allow to combine :class:`Polyhedron` or :class:`Domain` instances using logic operators: +The following functions combine :class:`Polyhedron` or :class:`Domain` instances using logic operators: .. function:: Or(domain1, domain2[, ...]) - Create the union domain of domains given in arguments. + Create the union domain of the domains given in arguments. .. function:: And(domain1, domain2[, ...]) - Create the intersection domain of domains given in arguments. + Create the intersection domain of the domains given in arguments. .. function:: Not(domain) @@ -545,7 +545,7 @@ Geometric Objects .. class:: Point(coordinates) - Create a point from a dictionnary or a sequence that maps symbols to their coordinates. + Create a point from a dictionary or a sequence that maps the symbols to their coordinates. Coordinates must be rational numbers. For example, the point ``(x: 1, y: 2)`` can be constructed using one of the following instructions: @@ -554,7 +554,7 @@ Geometric Objects >>> p = Point({x: 1, y: 2}) >>> p = Point([(x, 1), (y, 2)]) - :class:`Point` instances are hashable, and should be treated as immutable. + :class:`Point` instances are hashable and should be treated as immutable. A point is a :class:`GeometricObject` instance. @@ -595,7 +595,7 @@ Geometric Objects .. method:: __sub__(point) __sub__(vector) - The first version substract a point from another and return the resulting vector. + The first version substracts a point from another and returns the resulting vector. The second version translates the point by the opposite vector of *vector* and returns the resulting point. .. method:: __eq__(point) @@ -605,10 +605,10 @@ Geometric Objects .. class:: Vector(coordinates) - Create a point from a dictionnary or a sequence that maps symbols to their coordinates, similarly to :meth:`Point`. + Create a point from a dictionary or a sequence that maps the symbols to their coordinates, similar to :meth:`Point`. Coordinates must be rational numbers. - :class:`Vector` instances are hashable, and should be treated as immutable. + :class:`Vector` instances are hashable and should be treated as immutable. .. attribute:: symbols