Merge pull request scipy#8291 from rgommers/fix-nonascii

DOC: fix non-ascii characters in docstrings which broke the doc build.

scipy/integrate/_ivp/bdf.py

@@ -97,7 +97,7 @@ class BDF(OdeSolver):
     y0 : array_like, shape (n,)
         Initial state.
     t_bound : float
-        Boundary time – the integration won't continue beyond it. It also
+        Boundary time - the integration won't continue beyond it. It also
         determines the direction of the integration.
     max_step : float, optional
         Maximum allowed step size. Default is np.inf, i.e. the step size is not

scipy/integrate/_ivp/ivp.py

@@ -208,10 +208,10 @@ def solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False,
               extrapolation is done). A cubic Hermite polynomial is used for the
               dense output. Can be applied in the complex domain.
             * 'Radau': Implicit Runge-Kutta method of the Radau IIA family of
-              order 5 [4]_. The error is controlled with a third-order accurate
+              order 5 [4]_. The error is controlled with a third-order accurate
               embedded formula. A cubic polynomial which satisfies the
               collocation conditions is used for the dense output.
-            * 'BDF': Implicit multi-step variable-order (1 to 5) method based
+            * 'BDF': Implicit multi-step variable-order (1 to 5) method based
               on a backward differentiation formula for the derivative
               approximation [5]_. The implementation follows the one described
               in [6]_. A quasi-constant step scheme is used and accuracy is
@@ -378,7 +378,7 @@ def solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False,
     Examples
     --------
     Basic exponential decay showing automatically chosen time points.
-    
+
     >>> from scipy.integrate import solve_ivp
     >>> def exponential_decay(t, y): return -0.5 * y
     >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])
@@ -392,10 +392,10 @@ def solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False,
        0.05858998  0.02701876]
      [ 8.          7.5534414   4.25308709  1.73277247  0.7059579   0.287618
        0.11717996  0.05403753]]
-       
+
     Specifying points where the solution is desired.
-    
-    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8], 
+
+    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],
     ...                 t_eval=[0, 1, 2, 4, 10])
     >>> print(sol.t)
     [ 0  1  2  4 10]
@@ -404,12 +404,12 @@ def solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False,
      [ 4.          2.42610739  1.47068043  0.54133472  0.02701876]
      [ 8.          4.85221478  2.94136085  1.08266944  0.05403753]]
 
-    Cannon fired upward with terminal event upon impact. The ``terminal`` and 
+    Cannon fired upward with terminal event upon impact. The ``terminal`` and
     ``direction`` fields of an event are applied by monkey patching a function.
     Here ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts at
     position 0 with velocity +10. Note that the integration never reaches t=100
     because the event is terminal.
-    
+
     >>> def upward_cannon(t, y): return [y[1], -0.5]
     >>> def hit_ground(t, y): return y[1]
     >>> hit_ground.terminal = True

scipy/integrate/_ivp/lsoda.py

@@ -28,7 +28,7 @@ class LSODA(OdeSolver):
     y0 : array_like, shape (n,)
         Initial state.
     t_bound : float
-        Boundary time – the integration won't continue beyond it. It also
+        Boundary time - the integration won't continue beyond it. It also
         determines the direction of the integration.
     first_step : float or None, optional
         Initial step size. Default is ``None`` which means that the algorithm

scipy/integrate/_ivp/radau.py

@@ -201,7 +201,7 @@ class Radau(OdeSolver):
     y0 : array_like, shape (n,)
         Initial state.
     t_bound : float
-        Boundary time – the integration won't continue beyond it. It also
+        Boundary time - the integration won't continue beyond it. It also
         determines the direction of the integration.
     max_step : float, optional
         Maximum allowed step size. Default is np.inf, i.e. the step size is not

scipy/integrate/_ivp/rk.py

@@ -169,7 +169,7 @@ def _dense_output_impl(self):
 class RK23(RungeKutta):
     """Explicit Runge-Kutta method of order 3(2).
 
-    This uses the Bogacki–Shampine pair of formulas [1]_. The error is controlled
+    This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled
     assuming accuracy of the second-order method, but steps are taken using the
     third-order accurate formula (local extrapolation is done). A cubic Hermite
     polynomial is used for the dense output.
@@ -191,7 +191,7 @@ class RK23(RungeKutta):
     y0 : array_like, shape (n,)
         Initial state.
     t_bound : float
-        Boundary time – the integration won't continue beyond it. It also
+        Boundary time - the integration won't continue beyond it. It also
         determines the direction of the integration.
     max_step : float, optional
         Maximum allowed step size. Default is np.inf, i.e. the step size is not
@@ -277,7 +277,7 @@ class RK45(RungeKutta):
     y0 : array_like, shape (n,)
         Initial state.
     t_bound : float
-        Boundary time – the integration won't continue beyond it. It also
+        Boundary time - the integration won't continue beyond it. It also
         determines the direction of the integration.
     max_step : float, optional
         Maximum allowed step size. Default is np.inf, i.e. the step size is not