Merge pull request sympy#20242 from Soumi7/GSoD_simplify_1

sylee957 · web-flow · commit 54abb0f1aeec · 2020-10-18T03:06:44.000+09:00
Added required sections in sympy.simplify
diff --git a/sympy/simplify/combsimp.py b/sympy/simplify/combsimp.py
@@ -15,6 +15,9 @@ def combsimp(expr):
     r"""
     Simplify combinatorial expressions.
 
+    Explanation
+    ===========
+
     This function takes as input an expression containing factorials,
     binomials, Pochhammer symbol and other "combinatorial" functions,
     and tries to minimize the number of those functions and reduce
diff --git a/sympy/simplify/cse_main.py b/sympy/simplify/cse_main.py
@@ -35,7 +35,7 @@
 
 
 def reps_toposort(r):
-    """Sort replacements `r` so (k1, v1) appears before (k2, v2)
+    """Sort replacements ``r`` so (k1, v1) appears before (k2, v2)
     if k2 is in v1's free symbols. This orders items in the
     way that cse returns its results (hence, in order to use the
     replacements in a substitution option it would make sense
@@ -196,8 +196,8 @@ def stop_arg_tracking(self, func_i):
     def get_common_arg_candidates(self, argset, min_func_i=0):
         """Return a dict whose keys are function numbers. The entries of the dict are
         the number of arguments said function has in common with
-        `argset`. Entries have at least 2 items in common.  All keys have
-        value at least `min_func_i`.
+        ``argset``. Entries have at least 2 items in common.  All keys have
+        value at least ``min_func_i``.
         """
         from collections import defaultdict
         count_map = defaultdict(lambda: 0)
@@ -309,9 +309,9 @@ def match_common_args(func_class, funcs, opt_subs):
     func_class: class
         The function class (e.g. Add, Mul)
     funcs: list of functions
-        A list of function calls
+        A list of function calls.
     opt_subs: dict
-        A dictionary of substitutions which this function may update
+        A dictionary of substitutions which this function may update.
     """
 
     # Sort to ensure that whole-function subexpressions come before the items
@@ -384,7 +384,7 @@ def match_common_args(func_class, funcs, opt_subs):
 
 def opt_cse(exprs, order='canonical'):
     """Find optimization opportunities in Adds, Muls, Pows and negative
-    coefficient Muls
+    coefficient Muls.
 
     Parameters
     ==========
diff --git a/sympy/simplify/epathtools.py b/sympy/simplify/epathtools.py
@@ -284,6 +284,9 @@ def epath(path, expr=None, func=None, args=None, kwargs=None):
     r"""
     Manipulate parts of an expression selected by a path.
 
+    Explanation
+    ===========
+
     This function allows to manipulate large nested expressions in single
     line of code, utilizing techniques to those applied in XML processing
     standards (e.g. XPath).
diff --git a/sympy/simplify/fu.py b/sympy/simplify/fu.py
@@ -378,7 +378,7 @@ def TR6(rv, max=4, pow=False):
 
 
 def TR7(rv):
-    """Lowering the degree of cos(x)**2
+    """Lowering the degree of cos(x)**2.
 
     Examples
     ========
@@ -928,7 +928,7 @@ def f(rv):
 
 def TR12i(rv):
     """Combine tan arguments as
-    (tan(y) + tan(x))/(tan(x)*tan(y) - 1) -> -tan(x + y)
+    (tan(y) + tan(x))/(tan(x)*tan(y) - 1) -> -tan(x + y).
 
     Examples
     ========
@@ -1153,7 +1153,7 @@ def TRmorrie(rv):
     References
     ==========
 
-    https://en.wikipedia.org/wiki/Morrie%27s_law
+    .. [1] https://en.wikipedia.org/wiki/Morrie%27s_law
 
     """
 
@@ -1475,7 +1475,7 @@ def TRpower(rv):
     References
     ==========
 
-    https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Power-reduction_formulae
+    .. [1] https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Power-reduction_formulae
 
     """
 
@@ -1623,8 +1623,8 @@ def fu(rv, measure=lambda x: (L(x), x.count_ops())):
 
     References
     ==========
-    http://rfdz.ph-noe.ac.at/fileadmin/Mathematik_Uploads/ACDCA/
-    DESTIME2006/DES_contribs/Fu/simplification.pdf
+
+    .. [1] https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.657.2478&rep=rep1&type=pdf
     """
     fRL1 = greedy(RL1, measure)
     fRL2 = greedy(RL2, measure)
@@ -1648,7 +1648,7 @@ def fu(rv, measure=lambda x: (L(x), x.count_ops())):
 
 
 def process_common_addends(rv, do, key2=None, key1=True):
-    """Apply ``do`` to addends of ``rv`` that (if key1=True) share at least
+    """Apply ``do`` to addends of ``rv`` that (if ``key1=True``) share at least
     a common absolute value of their coefficient and the value of ``key2`` when
     applied to the argument. If ``key1`` is False ``key2`` must be supplied and
     will be the only key applied.
@@ -1956,7 +1956,7 @@ def _osborne(e, d):
     References
     ==========
 
-    https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
     """
 
     def f(rv):
@@ -1995,7 +1995,7 @@ def _osbornei(e, d):
     References
     ==========
 
-    https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
     """
 
     def f(rv):
@@ -2045,7 +2045,7 @@ def hyper_as_trig(rv):
     References
     ==========
 
-    https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
     """
     from sympy.simplify.simplify import signsimp
     from sympy.simplify.radsimp import collect
@@ -2067,6 +2067,9 @@ def hyper_as_trig(rv):
 def sincos_to_sum(expr):
     """Convert products and powers of sin and cos to sums.
 
+    Explanation
+    ===========
+
     Applied power reduction TRpower first, then expands products, and
     converts products to sums with TR8.
 
diff --git a/sympy/simplify/gammasimp.py b/sympy/simplify/gammasimp.py
@@ -14,6 +14,9 @@ def gammasimp(expr):
     r"""
     Simplify expressions with gamma functions.
 
+    Explanation
+    ===========
+
     This function takes as input an expression containing gamma
     functions or functions that can be rewritten in terms of gamma
     functions and tries to minimize the number of those functions and
@@ -39,8 +42,8 @@ def gammasimp(expr):
 
     All transformation rules can be found (or was derived from) here:
 
-    1. http://functions.wolfram.com/GammaBetaErf/Pochhammer/17/01/02/
-    2. http://functions.wolfram.com/GammaBetaErf/Pochhammer/27/01/0005/
+    .. [1] http://functions.wolfram.com/GammaBetaErf/Pochhammer/17/01/02/
+    .. [2] http://functions.wolfram.com/GammaBetaErf/Pochhammer/27/01/0005/
 
     Examples
     ========
@@ -65,6 +68,9 @@ def _gammasimp(expr, as_comb):
     """
     Helper function for gammasimp and combsimp.
 
+    Explanation
+    ===========
+
     Simplifies expressions written in terms of gamma function. If
     as_comb is True, it tries to preserve integer arguments. See
     docstring of gammasimp for more information. This was part of
diff --git a/sympy/simplify/hyperexpand.py b/sympy/simplify/hyperexpand.py
@@ -514,6 +514,9 @@ def build_invariants(self):
         """
         Compute the invariant vector.
 
+        Explanation
+        ===========
+
         The invariant vector is:
             (gamma, ((s1, n1), ..., (sk, nk)), ((t1, m1), ..., (tr, mr)))
         where gamma is the number of integer a < 0,
@@ -581,6 +584,9 @@ def _is_suitable_origin(self):
         """
         Decide if ``self`` is a suitable origin.
 
+        Explanation
+        ===========
+
         A function is a suitable origin iff:
         * none of the ai equals bj + n, with n a non-negative integer
         * none of the ai is zero
@@ -628,6 +634,9 @@ def compute_buckets(self):
         """
         Compute buckets for the fours sets of parameters.
 
+        Explanation
+        ===========
+
         We guarantee that any two equal Mod objects returned are actually the
         same, and that the buckets are sorted by real part (an and bq
         descendending, bm and ap ascending).
@@ -670,6 +679,9 @@ class Formula(object):
     """
     This class represents hypergeometric formulae.
 
+    Explanation
+    ===========
+
     Its data members are:
     - z, the argument
     - closed_form, the closed form expression
@@ -944,6 +956,9 @@ class Operator(object):
     """
     Base class for operators to be applied to our functions.
 
+    Explanation
+    ===========
+
     These operators are differential operators. They are by convention
     expressed in the variable D = z*d/dz (although this base class does
     not actually care).
@@ -1438,6 +1453,9 @@ def reduce_order(func):
     Given the hypergeometric function ``func``, find a sequence of operators to
     reduces order as much as possible.
 
+    Explanation
+    ===========
+
     Return (newfunc, [operators]), where applying the operators to the
     hypergeometric function newfunc yields func.
 
@@ -1960,9 +1978,12 @@ def _hyperexpand(func, z, ops0=[], z0=Dummy('z0'), premult=1, prem=0,
     """
     Try to find an expression for the hypergeometric function ``func``.
 
-    The result is expressed in terms of a dummy variable z0. Then it
-    is multiplied by premult. Then ops0 is applied.
-    premult must be a*z**prem for some a independent of z.
+    Explanation
+    ===========
+
+    The result is expressed in terms of a dummy variable ``z0``. Then it
+    is multiplied by ``premult``. Then ``ops0`` is applied.
+    ``premult`` must be a*z**prem for some a independent of ``z``.
     """
 
     if z.is_zero:
@@ -2062,12 +2083,15 @@ def devise_plan_meijer(fro, to, z):
     """
     Find operators to convert G-function ``fro`` into G-function ``to``.
 
-    It is assumed that fro and to have the same signatures, and that in fact
+    Explanation
+    ===========
+
+    It is assumed that ``fro`` and ``to`` have the same signatures, and that in fact
     any corresponding pair of parameters differs by integers, and a direct path
     is possible. I.e. if there are parameters a1 b1 c1  and a2 b2 c2 it is
     assumed that a1 can be shifted to a2, etc. The only thing this routine
     determines is the order of shifts to apply, nothing clever will be tried.
-    It is also assumed that fro is suitable.
+    It is also assumed that ``fro`` is suitable.
 
     Examples
     ========
diff --git a/sympy/simplify/powsimp.py b/sympy/simplify/powsimp.py
@@ -18,13 +18,13 @@ def powsimp(expr, deep=False, combine='all', force=False, measure=count_ops):
     """
     reduces expression by combining powers with similar bases and exponents.
 
-    Notes
-    =====
+    Explanation
+    ===========
 
-    If deep is True then powsimp() will also simplify arguments of
-    functions. By default deep is set to False.
+    If ``deep`` is ``True`` then powsimp() will also simplify arguments of
+    functions. By default ``deep`` is set to ``False``.
 
-    If force is True then bases will be combined without checking for
+    If ``force`` is ``True`` then bases will be combined without checking for
     assumptions, e.g. sqrt(x)*sqrt(y) -> sqrt(x*y) which is not true
     if x and y are both negative.
 
@@ -490,6 +490,9 @@ def powdenest(eq, force=False, polar=False):
     r"""
     Collect exponents on powers as assumptions allow.
 
+    Explanation
+    ===========
+
     Given ``(bb**be)**e``, this can be simplified as follows:
         * if ``bb`` is positive, or
         * ``e`` is an integer, or
@@ -506,11 +509,11 @@ def powdenest(eq, force=False, polar=False):
       of the exponent can be removed from any term and the gcd of such
       integers can be joined with e
 
-    Setting ``force`` to True will make symbols that are not explicitly
+    Setting ``force`` to ``True`` will make symbols that are not explicitly
     negative behave as though they are positive, resulting in more
     denesting.
 
-    Setting ``polar`` to True will do simplifications on the Riemann surface of
+    Setting ``polar`` to ``True`` will do simplifications on the Riemann surface of
     the logarithm, also resulting in more denestings.
 
     When there are sums of logs in exp() then a product of powers may be
diff --git a/sympy/simplify/radsimp.py b/sympy/simplify/radsimp.py
