DOC: Tweak markup in a few docstrings.

Author: WarrenWeckesser

mpsci/fun/_debye.py

@@ -6,13 +6,13 @@ def debye(x, *, n, method='quad'):
     """
     Compute the Debye function D_n(x).
 
-    If `method == 'quad'`,  `mp.quad` is used to evaluate the integral form
-    of the function, so it might be necessary to set mp.dps to a value
-    much larger than the desired output precision.  For example, mp.dps=150
+    If ``method == 'quad'``,  ``mp.quad`` is used to evaluate the integral form
+    of the function, so it might be necessary to set ``mp.dps`` to a value
+    much larger than the desired output precision.  For example, ``mp.dps = 150``
     is required to get an accurate double precision result from
-    mp_debye1(1e100, 1).
+    ``mp_debye1(1e100, 1)``.
 
-    If `method == 'nsum'`, `mp.nsum` is used to evalute the series form
+    If ``method == 'nsum'``, ``mp.nsum`` is used to evalute the series form
     of the function.
     """
     try:

mpsci/fun/_digammainv.py

@@ -11,10 +11,11 @@ def digammainv(y):
     The `digamma function` [1]_ [2]_ is the logarithmic derivative of the
     gamma function.
 
-    For real y, digammainv(y) returns the positive x such that digamma(x) = y.
+    For real ``y``, ``digammainv(y)`` returns the positive ``x`` such that
+    ``digamma(x) = y``.
 
-    The digamma function is also known as psi_0; `mpmath.digamma(x)` is the
-    same as `mpmath.psi(0, x)`.
+    The digamma function is also known as psi_0; ``mpmath.digamma(x)`` is the
+    same as ``mpmath.psi(0, x)``.
 
     References
     ----------

mpsci/fun/_inv_reg_inc_beta.py

@@ -31,29 +31,29 @@ def betaincinv(a, b, y, method='findroot', complement=False):
     """
     Inverse of the regularized incomplete beta function.
 
-    If `complement` is True, the inverse of the complement of the
+    If ``complement`` is True, the inverse of the complement of the
     regularized incomplete beta function is computed.
 
     The function name and first three parameters match those of
-    `scipy.special.betaincinv`.  With `complement=True`, the function
-    computes the equivalent of `scipy.special.betainccinv`.
+    ``scipy.special.betaincinv``.  With ``complement=True``, the function
+    computes the equivalent of ``scipy.special.betainccinv``.
 
-    The `method` parameter has several options:
+    The ``method`` parameter has several options:
 
-    * `"findroot"`:
-        Use `mpmath.mp.findroot`, with initial guess 0.5.
-    * `("findroot", x0)`:
-        Use `mpmath.mp.findroot`, with initial guess `x0`.
-    * `"bisect"`:
+    * ``"findroot"``:
+        Use ``mpmath.mp.findroot``, with initial guess 0.5.
+    * ``("findroot", x0)``:
+        Use ``mpmath.mp.findroot``, with initial guess ``x0``.
+    * ``"bisect"``:
         Use a bisection method, starting with the root bracket
         [0, 1].
-    * `("bisect", [xa, xb])`:
+    * ``("bisect", [xa, xb])``:
         Use a bisection method; start the bisection with the
-        bracket `[xa, xb]`.  `xa` and `xb` must be chosen so that
-        the inverse is in the interval `[xa, xb]`.
+        bracket ``[xa, xb]``.  ``xa`` and ``xb`` must be chosen so that
+        the inverse is in the interval ``[xa, xb]``.
 
     The numerical method that is used to find the root (either
-    `mpmath.mp.findroot` or the bisection method) might fail for some
+    ``mpmath.mp.findroot`` or the bisection method) might fail for some
     inputs. If that happens, try changing the method, or try changing
     the initial guess or initial bracket.
 

mpsci/fun/_wright_bessel.py

@@ -22,10 +22,10 @@ def wright_bessel(z, rho, beta):
 
     but here the `z` parameter is given first.
 
-    z and beta can be complex.
-    rho must be real and greater than -1.
+    ``z`` and ``beta`` can be complex.
+    ``rho`` must be real and greater than -1.
 
-    *Warning*: In the general case, this function uses `mpmath.mp.nsum`
+    *Warning*: In the general case, this function uses ``mpmath.mp.nsum``
     to compute the approximate sum of the Wright-Bessel series.  This
     might require setting the mpmath precision very high to ensure that
     the result is accurate.

mpsci/fun/_xlogy.py

@@ -30,10 +30,10 @@ def xlog1py(x, y):
     """
     x*log(1+y)
 
-    If x is 0 and y is not nan, 0 is returned.
+    If ``x`` is 0 and ``y`` is not ``nan``, 0 is returned.
 
-    This function is mathematically equivalent to `mpsci.fun.xlogy(1 + y)`.
-    It avoids the loss of precision that can result if y is very small.
+    This function is mathematically equivalent to ``mpsci.fun.xlogy(1 + y)``.
+    It avoids the loss of precision that can result if ``y`` is very small.
 
     *See also:* :func:`xlogy`
     """