sage.coding: Wrap some long lines

Author: Matthias Koeppe

src/sage/coding/abstract_code.py

@@ -197,9 +197,9 @@ class AbstractCode(Parent):
       ``MyDecoderClass``.
 
 
-    As the class :class:`AbstractCode` is not designed to be instantiated, it does not have any
-    representation methods. You should implement ``_repr_`` and ``_latex_``
-    methods in the subclass.
+    As the class :class:`AbstractCode` is not designed to be instantiated, it
+    does not have any representation methods. You should implement ``_repr_``
+    and ``_latex_`` methods in the subclass.
     """
 
     def __init__(self, length, default_encoder_name=None,

src/sage/coding/binary_code.pyx

@@ -162,29 +162,31 @@ def test_word_perms(t_limit=5.0):
     These are structures written in pure C for speed, and are tested from this
     function, which performs the following tests:
 
-    1.  Tests :func:`create_word_perm`, which creates a :class:`WordPermutation` from a Python
-        list `L` representing a permutation `i \mapsto L[i]`. Takes a random word and
-        permutes it by a random list permutation, and tests that the result
-        agrees with doing it the slow way.
-
-    1b. Tests :func:`create_array_word_perm`, which creates a :class:`WordPermutation` from a
-        C array. Does the same as above.
-
-    2.  Tests :func:`create_comp_word_perm`, which creates a :class:`WordPermutation` as a
-        composition of two :class:`WordPermutation` objects. Takes a random word and
-        two random permutations, and tests that the result of permuting by the
-        composition is correct.
-
-    3.  Tests :func:`create_inv_word_perm` and :func:`create_id_word_perm`, which create a
-        :class:`WordPermutation` as the inverse and identity permutations, resp.
-        Takes a random word and a random permutation, and tests that the result
-        permuting by the permutation and its inverse in either order, and
-        permuting by the identity both return the original word.
+    1.  Tests :func:`create_word_perm`, which creates a :class:`WordPermutation`
+        from a Python list `L` representing a permutation `i \mapsto
+        L[i]`. Takes a random word and permutes it by a random list permutation,
+        and tests that the result agrees with doing it the slow way.
+
+    1b. Tests :func:`create_array_word_perm`, which creates a
+        :class:`WordPermutation` from a C array. Does the same as above.
+
+    2.  Tests :func:`create_comp_word_perm`, which creates a
+        :class:`WordPermutation` as a composition of two
+        :class:`WordPermutation` objects. Takes a random word and two random
+        permutations, and tests that the result of permuting by the composition
+        is correct.
+
+    3.  Tests :func:`create_inv_word_perm` and :func:`create_id_word_perm`,
+        which create a :class:`WordPermutation` as the inverse and identity
+        permutations, resp.  Takes a random word and a random permutation, and
+        tests that the result permuting by the permutation and its inverse in
+        either order, and permuting by the identity both return the original
+        word.
 
     .. NOTE::
 
-        The functions :func:`permute_word_by_wp` and :func:`dealloc_word_perm` are implicitly
-        involved in each of the above tests.
+        The functions :func:`permute_word_by_wp` and :func:`dealloc_word_perm`
+        are implicitly involved in each of the above tests.
 
     TESTS::
 
@@ -866,8 +868,8 @@ cdef class BinaryCode:
 
     def matrix(self):
         """
-        Returns the generator matrix of the :class:`BinaryCode`, i.e. the code is the
-        rowspace of ``B.matrix()``.
+        Return the generator matrix of the :class:`BinaryCode`, i.e. the code is
+        the rowspace of ``B.matrix()``.
 
         EXAMPLES::
 
@@ -3910,9 +3912,9 @@ cdef class BinaryCodeClassifier:
 
         - ``n`` -- limit on the degree of the code
 
-        - ``d`` -- test whether new vector has weight divisible by `d`. If `d=4`, this
-          ensures that all doubly-even canonically augmented children are
-          generated.
+        - ``d`` -- test whether new vector has weight divisible by `d`. If
+          `d=4`, this ensures that all doubly-even canonically augmented
+          children are generated.
 
         EXAMPLES::
 

src/sage/coding/channel.py

@@ -446,8 +446,8 @@ class ErrorErasureChannel(Channel):
     r"""
     Channel which adds errors and erases several positions in any message it transmits.
 
-    The output space of this channel is a Cartesian product
-    between its input space and a VectorSpace of the same dimension over `\GF{2}`.
+    The output space of this channel is a Cartesian product between its input
+    space and a VectorSpace of the same dimension over `\GF{2}`.
 
     INPUT:
 
@@ -561,8 +561,8 @@ def _latex_(self):
 
     def transmit_unsafe(self, message):
         r"""
-        Return ``message`` with as many errors as ``self._number_errors`` in it, and as many erasures
-        as ``self._number_erasures`` in it.
+        Return ``message`` with as many errors as ``self._number_errors`` in it,
+        and as many erasures as ``self._number_erasures`` in it.
 
         If ``self._number_errors`` was passed as an tuple for the number of errors, it will
         pick a random integer between the bounds of the tuple and use it as the number of errors.
@@ -583,9 +583,10 @@ def transmit_unsafe(self, message):
 
         - a couple of vectors, namely:
 
-          - the transmitted message, which is ``message`` with erroneous and erased positions
-          - the erasure vector, which contains ``1`` at the erased positions of the transmitted message
-            and ``0`` elsewhere.
+          - the transmitted message, which is ``message`` with erroneous and
+            erased positions
+          - the erasure vector, which contains ``1`` at the erased positions of
+            the transmitted message and ``0`` elsewhere.
 
         EXAMPLES::
 
@@ -672,14 +673,15 @@ class QarySymmetricChannel(Channel):
 
     EXAMPLES:
 
-    We construct a :class:`QarySymmetricChannel` which corrupts 30% of all transmitted
-    symbols::
+    We construct a :class:`QarySymmetricChannel` which corrupts 30% of all
+    transmitted symbols::
 
         sage: epsilon = 0.3
         sage: Chan = channels.QarySymmetricChannel(GF(59)^50, epsilon)
         sage: Chan
         q-ary symmetric channel with error probability 0.300000000000000,
-        of input and output space Vector space of dimension 50 over Finite Field of size 59
+         of input and output space
+          Vector space of dimension 50 over Finite Field of size 59
     """
 
     def __init__(self, space, epsilon):

src/sage/coding/code_bounds.py

@@ -152,8 +152,8 @@
 
 -  Delsarte (a.k.a. Linear Programming (LP)) upper bounds.
 
-PROBLEM: In this module we shall typically either (a) seek bounds
-on `k`, given `n`, `d`, `q`, (b) seek bounds on `R`, `\delta`, `q` (assuming `n` is
+PROBLEM: In this module we shall typically either (a) seek bounds on `k`, given
+`n`, `d`, `q`, (b) seek bounds on `R`, `\delta`, `q` (assuming `n` is
 "infinity").
 
 .. TODO::
@@ -300,10 +300,11 @@ def dimension_upper_bound(n, d, q, algorithm=None):
     Return an upper bound for the dimension of a linear code.
 
     Return an upper bound `B(n,d) = B_q(n,d)` for the
-    dimension of a linear code of length n, minimum distance d over a
-    field of size q.
+    dimension of a linear code of length `n`, minimum distance `d` over a
+    field of size `q`.
 
-    Parameter ``algorithm`` has the same meaning as in :func:`codesize_upper_bound`
+    Parameter ``algorithm`` has the same meaning as in
+    :func:`codesize_upper_bound`
 
     EXAMPLES::
 

src/sage/coding/code_constructions.py

@@ -502,8 +502,8 @@ def QuadraticResidueCode(n,F):
     `n`'th root of unity; `i` ranges over the set of
     quadratic residues modulo `n`).
 
-    See :class:`QuadraticResidueCodeEvenPair` and :class:`QuadraticResidueCodeOddPair`
-    for a more general construction.
+    See :class:`QuadraticResidueCodeEvenPair` and
+    :class:`QuadraticResidueCodeOddPair` for a more general construction.
 
     INPUT:
 

src/sage/coding/guruswami_sudan/gs_decoder.py

@@ -37,9 +37,9 @@
 
 def n_k_params(C, n_k):
     r"""
-    Internal helper function for the :class:`GRSGuruswamiSudanDecoder` class for allowing to
-    specify either a GRS code `C` or the length and dimensions `n, k` directly,
-    in all the static functions.
+    Internal helper function for the :class:`GRSGuruswamiSudanDecoder` class for
+    allowing to specify either a GRS code `C` or the length and dimensions `n,
+    k` directly, in all the static functions.
 
     If neither `C` or `n,k` were specified to those functions, an appropriate
     error should be raised. Otherwise, `n, k` of the code or the supplied tuple
@@ -49,7 +49,8 @@ def n_k_params(C, n_k):
 
     - ``C`` -- A GRS code or ``None``
 
-    - ``n_k`` -- A tuple `(n,k)` being length and dimension of a GRS code, or ``None``.
+    - ``n_k`` -- A tuple `(n,k)` being length and dimension of a GRS code, or
+      ``None``.
 
     OUTPUT:
 
@@ -164,7 +165,8 @@ class GRSGuruswamiSudanDecoder(Decoder):
       that will be used. The following possibilities are currently available:
 
       * ``"LinearAlgebra"`` -- uses a linear system solver.
-      * ``"LeeOSullivan"`` -- uses Lee O'Sullivan method based on row reduction of a matrix
+      * ``"LeeOSullivan"`` -- uses Lee O'Sullivan method based on row reduction
+        of a matrix
       * ``None`` -- one of the above will be chosen based on the size of the
         code and the parameters.
 

src/sage/coding/guruswami_sudan/interpolation.py

@@ -242,7 +242,8 @@ def gs_interpolation_linalg(points, tau, parameters, wy):
 
     - ``parameters`` -- (default: ``None``) a pair of integers, where:
 
-      - the first integer is the multiplicity parameter of Guruswami-Sudan algorithm and
+      - the first integer is the multiplicity parameter of Guruswami-Sudan
+        algorithm and
       - the second integer is the list size parameter.
 
     - ``wy`` -- an integer, the `y`-weight, where we seek `Q` of low
@@ -314,7 +315,8 @@ def lee_osullivan_module(points, parameters, wy):
 
     - ``parameters`` -- (default: ``None``) a pair of integers, where:
 
-      - the first integer is the multiplicity parameter `s` of Guruswami-Sudan algorithm and
+      - the first integer is the multiplicity parameter `s` of Guruswami-Sudan
+        algorithm and
       - the second integer is the list size parameter.
 
     - ``wy`` -- an integer, the `y`-weight, where we seek `Q` of low
@@ -368,7 +370,8 @@ def gs_interpolation_lee_osullivan(points, tau, parameters, wy):
     - ``tau`` -- an integer, the number of errors one wants to decode.
 
     - ``parameters`` -- (default: ``None``) a pair of integers, where:
-      - the first integer is the multiplicity parameter of Guruswami-Sudan algorithm and
+      - the first integer is the multiplicity parameter of Guruswami-Sudan
+        algorithm and
       - the second integer is the list size parameter.
 
     - ``wy`` -- an integer, the `y`-weight, where we seek ``Q`` of low

src/sage/coding/linear_code_no_metric.py

@@ -77,9 +77,9 @@ class AbstractLinearCodeNoMetric(AbstractCode, Module):
     :class:`sage.coding.linear_code.LinearCode`.
 
 
-    As the class :class:`AbstractLinearCodeNoMetric` is not designed to be instantiated, it does not
-    have any representation methods. You should implement ``_repr_`` and ``_latex_``
-    methods in the subclass.
+    As the class :class:`AbstractLinearCodeNoMetric` is not designed to be
+    instantiated, it does not have any representation methods. You should
+    implement ``_repr_`` and ``_latex_`` methods in the subclass.
 
     .. WARNING::
 

src/sage/coding/punctured_code.py

@@ -69,8 +69,9 @@ def _insert_punctured_positions(l, punctured_points, value = None):
 
     - ``punctured_points`` -- a set of integers
 
-    - ``value`` -- (default: ``None``) an element to insert in every position given in``punctured_points``.
-      If it is let to ``None``, a random value will be chosen for each insertion.
+    - ``value`` -- (default: ``None``) an element to insert in every position
+      given in``punctured_points``.  If it is let to ``None``, a random value
+      will be chosen for each insertion.
 
     EXAMPLES::
 
@@ -121,13 +122,15 @@ def __init__(self, C, positions):
         r"""
         TESTS:
 
-        If one of the positions to puncture is bigger than the length of ``C``, an exception will be raised::
+        If one of the positions to puncture is bigger than the length of ``C``,
+        an exception will be raised::
 
             sage: C = codes.random_linear_code(GF(7), 11, 5)
             sage: Cp = codes.PuncturedCode(C, {4,8,15})
             Traceback (most recent call last):
             ...
-            ValueError: Positions to puncture must be positive integers smaller than the length of the provided code
+            ValueError: Positions to puncture must be positive integers smaller
+            than the length of the provided code
         """
         if not isinstance(positions, (Integer, int, set, list)):
             raise TypeError("positions must be either a Sage Integer, a Python int, a set or a list")
@@ -439,18 +442,19 @@ class PuncturedCodeOriginalCodeDecoder(Decoder):
     - ``strategy`` -- (default: ``None``) the strategy used to decode.
       The available strategies are:
 
-      * ``'error-erasure'`` -- uses an error-erasure decoder over the original code if available,
-        fails otherwise.
+      * ``'error-erasure'`` -- uses an error-erasure decoder over the original
+        code if available, fails otherwise.
 
       * ``'random-values'`` -- fills the punctured positions with random elements
         in ``code``'s base field and tries to decode using
         the default decoder of the original code
 
-      * ``'try-all'`` -- fills the punctured positions with every possible combination of
-        symbols until decoding succeeds, or until every combination have been tried
+      * ``'try-all'`` -- fills the punctured positions with every possible
+        combination of symbols until decoding succeeds, or until every
+        combination have been tried
 
-      * ``None`` -- uses ``error-erasure`` if an error-erasure decoder is available,
-        switch to ``random-values`` behaviour otherwise
+      * ``None`` -- uses ``error-erasure`` if an error-erasure decoder is
+        available, switch to ``random-values`` behaviour otherwise
 
     - ``original_decoder`` -- (default: ``None``) the decoder that will be used over the original code.
       It has to be a decoder object over the original code.
@@ -468,19 +472,20 @@ class PuncturedCodeOriginalCodeDecoder(Decoder):
         Decoder of Puncturing of [15, 7, 9] Reed-Solomon Code over GF(16) on position(s) [3]
          through Error-Erasure decoder for [15, 7, 9] Reed-Solomon Code over GF(16)
 
-    As seen above, if all optional are left blank, and if an error-erasure decoder is
-    available, it will be chosen as the original decoder.
-    Now, if one forces ``strategy`` to ``'try-all'`` or ``'random-values'``, the
-    default decoder of the original code will be chosen, even if an error-erasure is available::
+    As seen above, if all optional are left blank, and if an error-erasure
+    decoder is available, it will be chosen as the original decoder.  Now, if
+    one forces ``strategy`` to ``'try-all'`` or ``'random-values'``, the default
+    decoder of the original code will be chosen, even if an error-erasure is
+    available::
 
         sage: C = codes.GeneralizedReedSolomonCode(GF(16, 'a').list()[:15], 7)
         sage: Cp = codes.PuncturedCode(C, 3)
         sage: D = codes.decoders.PuncturedCodeOriginalCodeDecoder(Cp, strategy="try-all")
         sage: "error-erasure" in D.decoder_type()
         False
 
-    And if one fills ``original_decoder`` and ``strategy`` fields with contradictory
-    elements, the ``original_decoder`` takes precedence::
+    And if one fills ``original_decoder`` and ``strategy`` fields with
+    contradictory elements, the ``original_decoder`` takes precedence::
 
         sage: C = codes.GeneralizedReedSolomonCode(GF(16, 'a').list()[:15], 7)
         sage: Cp = codes.PuncturedCode(C, 3)