From f422e08c7a7758cd1e084a5cf042f5ddb3701ffc Mon Sep 17 00:00:00 2001
From: Danielle Bolan
Date: Mon, 18 Aug 2014 10:10:11 +0200
Subject: [PATCH] Fix small grammar mistakes in doc
---
doc/index.rst | 2 +-
doc/install.rst | 2 +-
doc/reference.rst | 44 ++++++++++++++++++++++----------------------
3 files changed, 24 insertions(+), 24 deletions(-)
diff --git a/doc/index.rst b/doc/index.rst
index ad985bf..a1809d6 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -3,7 +3,7 @@ Welcome to LinPyâs documentation!
=================================
LinPy is a polyhedral library for Python based on `isl `_.
-isl (Integer Set Library) is a C library for manipulating sets and relations of integer points bounded by linear constraints.
+Integer Set Library (isl) is a C library for manipulating sets and relations of integer points bounded by linear constraints.
LinPy is a free software, licensed under the `GPLv3 license `_.
Its source code is available `here `_.
diff --git a/doc/install.rst b/doc/install.rst
index 635e9c0..3a56000 100644
--- a/doc/install.rst
+++ b/doc/install.rst
@@ -37,7 +37,7 @@ LinPy can be installed using pip with the command::
Source
------
-Alternatively, LinPy can be installed from source.
+Alternatively, LinPy can be installed from the source.
First, clone the public git repository::
git clone https://scm.cri.ensmp.fr/git/linpy.git
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
--
2.20.1