Add newlines where required in .rst files

code/approx/approx.c

@@ -42,6 +42,7 @@ STATIC mp_float_t approx_python_call(const mp_obj_type_t *type, mp_obj_t fun, mp
 //|     :param float b: The right side of the interval
 //|     :param float xtol: The tolerance value
 //|     :param float maxiter: The maximum number of iterations to perform
+//|
 //|     Find a solution (zero) of the function ``f(x)`` on the interval
 //|     (``a``..``b``) using the bisection method.  The result is accurate to within
 //|     ``xtol`` unless more than ``maxiter`` steps are required."""
@@ -100,6 +101,7 @@ MP_DEFINE_CONST_FUN_OBJ_KW(approx_bisect_obj, 3, approx_bisect);
 //|     :param float xtol: The absolute tolerance value
 //|     :param float rtol: The relative tolerance value
 //|     :param float maxiter: The maximum number of iterations to perform
+//|
 //|     Find a solution (zero) of the function ``f(x)`` using Newton's Method.
 //|     The result is accurate to within ``xtol * rtol * |f(x)|`` unless more than
 //|     ``maxiter`` steps are requried."""
@@ -150,6 +152,7 @@ MP_DEFINE_CONST_FUN_OBJ_KW(approx_newton_obj, 2, approx_newton);
 //|    :param float x0: The initial x value
 //|    :param float xatol: The absolute tolerance value
 //|    :param float fatol: The relative tolerance value
+//|
 //|    Find a minimum of the function ``f(x)`` using the downhill simplex method.
 //|    The located ``x`` is within ``fxtol`` of the actual minimum, and ``f(x)``
 //|    is within ``fatol`` of the actual minimum unless more than ``maxiter``

code/fft/fft.c

@@ -154,6 +154,7 @@ mp_obj_t fft_fft_ifft_spectrum(size_t n_args, mp_obj_t arg_re, mp_obj_t arg_im,
 //|    :param ulab.array r: A 1-dimension array of values whose size is a power of 2
 //|    :param ulab.array c: An optional 1-dimension array of values whose size is a power of 2, giving the complex part of the value
 //|    :return tuple (r, c): The real and complex parts of the FFT
+//|
 //|    Perform a Fast Fourier Transform from the time domain into the frequency domain
 //|    See also ~ulab.extras.spectrum, which computes the magnitude of the fft,
 //|    rather than separately returning its real and imaginary parts."""
@@ -175,6 +176,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fft_fft_obj, 1, 2, fft_fft);
 //|     :param ulab.array r: A 1-dimension array of values whose size is a power of 2
 //|     :param ulab.array c: An optional 1-dimension array of values whose size is a power of 2, giving the complex part of the value
 //|     :return tuple (r, c): The real and complex parts of the inverse FFT
+//|
 //|     Perform an Inverse Fast Fourier Transform from the frequeny domain into the time domain"""
 //|     ...
 //| 
@@ -192,6 +194,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fft_ifft_obj, 1, 2, fft_ifft);
 //| def spectrogram(r):
 //|    """
 //|    :param ulab.array r: A 1-dimension array of values whose size is a power of 2
+//|
 //|    Computes the spectrum of the input signal.  This is the absolute value of the (complex-valued) fft of the signal.
 //|    This function is similar to scipy's ``scipy.signal.spectrogram``."""
 //|    ...

code/filter/filter.c

@@ -27,6 +27,7 @@
 //|    """
 //|    :param ulab.array a:
 //|    :param ulab.array v:
+//|
 //|    Returns the discrete, linear convolution of two one-dimensional sequences.
 //|    The result is always an array of float.  Only the ``full`` mode is supported,
 //|    and the ``mode`` named parameter of numpy is not accepted. Note that all other
@@ -122,6 +123,7 @@ static void filter_sosfilt_array(mp_float_t *x, const mp_float_t *coeffs, mp_flo
 //|     :param ulab.array x: The data to be filtered
 //|     :param ulab.array zi: Optional initial conditions for the filter
 //|     :return: If ``xi`` is not specified, the filter result alone is returned.  If ``xi`` is specified, the return value is a 2-tuple of the filter result and the final filter conditions.
+//|
 //|     Filter data along one dimension using cascaded second-order sections.
 //|     Filter a data sequence, x, using a digital IIR filter defined by sos.
 //|     The filter function is implemented as a series of second-order filters with direct-form II transposed structure. It is designed to minimize numerical precision errors for high-order filters.

code/linalg/linalg.c

@@ -163,8 +163,8 @@ MP_DEFINE_CONST_FUN_OBJ_1(linalg_inv_obj, linalg_inv);
 //|    """
 //|    :param ~ulab.array m1: a matrix, or a vector
 //|    :param ~ulab.array m2: a matrix, or a vector
-//|    Computes the product of two matrices, or two vectors. In the letter case, the inner product is returned."""
 //|
+//|    Computes the product of two matrices, or two vectors. In the letter case, the inner product is returned."""
 //|    ...
 //|
 

code/ndarray.c

@@ -41,6 +41,7 @@ mp_uint_t ndarray_print_edgeitems = NDARRAY_PRINT_EDGEITEMS;
 //|     def __init__(self, values, *, dtype=float):
 //|         """:param sequence values: Sequence giving the initial content of the array.
 //|           :param dtype: The type of array values, ``int8``, ``uint8``, ``int16``, ``uint16``, or ``float``
+//|
 //|           The `values` sequence can either be another ~ulab.array, sequence of numbers
 //|           (in which case a 1-dimensional array is created), or a sequence where each
 //|           subsequence has the same length (in which case a 2-dimensional array is
@@ -64,6 +65,7 @@ mp_uint_t ndarray_print_edgeitems = NDARRAY_PRINT_EDGEITEMS;
 //| 
 //|     def flatten(self, *, order='C'):
 //|         """:param order: Whether to flatten by rows ('C') or columns ('F')
+//|
 //|            Returns a new `ulab.array` object which is always 1 dimensional.
 //|            If order is 'C' (the default", then the data is ordered in rows;
 //|            If it is 'F', then the data is ordered in columns.  "C" and "F" refer

code/ulab.c

@@ -76,6 +76,7 @@ const mp_obj_type_t ulab_ndarray_type = {
 //|      Difference between consecutive elements, optional, defaults to 1.0
 //|    .. param: dtype
 //|      Type of values in the array
+//|
 //|    Return a new 1-D array with elements ranging from ``start`` to ``stop``, with step size ``step``."""
 //|    ...
 //|
@@ -98,6 +99,7 @@ const mp_obj_type_t ulab_ndarray_type = {
 //|      Whether the ``stop`` value is included.  Note that even when
 //|      endpoint=True, the exact ``stop`` value may not be included due to the
 //|      inaccuracy of floating point arithmetic.
+//|
 //|    Return a new 1-D array with ``num`` elements ranging from ``start`` to ``stop`` linearly."""
 //|    ...
 //|
@@ -107,6 +109,7 @@ const mp_obj_type_t ulab_ndarray_type = {
 //|       Shape of the array, either an integer (for a 1-D array) or a tuple of 2 integers (for a 2-D array)
 //|    .. param: dtype
 //|       Type of values in the array
+//|
 //|    Return a new array of the given shape with all elements set to 1."""
 //|    ...
 //|    
@@ -116,6 +119,7 @@ const mp_obj_type_t ulab_ndarray_type = {
 //|       Shape of the array, either an integer (for a 1-D array) or a tuple of 2 integers (for a 2-D array)
 //|    .. param: dtype
 //|       Type of values in the array
+//|
 //|    Return a new array of the given shape with all elements set to 0."""
 //|    ...
 //|

code/vector/vectorise.c

@@ -406,6 +406,7 @@ const mp_obj_type_t vectorise_function_type = {
 //|    """
 //|    :param callable f: The function to wrap
 //|    :param otypes: List of array types that may be returned by the function.  None is interpreted to mean the return value is float.
+//|
 //|    Wrap a Python function ``f`` so that it can be applied to arrays.
 //|    The callable must return only values of the types specified by ``otypes``, or the result is undefined."""
 //|    ...