diff --git a/docs/source/api/accumulating_functions.rst b/docs/source/api/accumulating_functions.rst
index 64ed2bdbf..282df5c31 100644
--- a/docs/source/api/accumulating_functions.rst
+++ b/docs/source/api/accumulating_functions.rst
@@ -11,16 +11,14 @@ Accumulating functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _cumsum-function-reference:
 .. doxygenfunction:: cumsum(E&&)
    :project: xtensor
 
 .. doxygenfunction:: cumsum(E&&, std::ptrdiff_t)
    :project: xtensor
 
-.. _cumprod-function-reference:
 .. doxygenfunction:: cumprod(E&&)
    :project: xtensor
 
 .. doxygenfunction:: cumprod(E&&, std::ptrdiff_t)
-   :project: xtensor
\ No newline at end of file
+   :project: xtensor
diff --git a/docs/source/api/basic_functions.rst b/docs/source/api/basic_functions.rst
index 6fc54a6c1..9bf7c2f60 100644
--- a/docs/source/api/basic_functions.rst
+++ b/docs/source/api/basic_functions.rst
@@ -11,51 +11,39 @@ Basic functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _abs-function-reference:
 .. doxygenfunction:: abs(E&&)
    :project: xtensor
 
-.. _fabs-function-reference:
 .. doxygenfunction:: fabs(E&&)
    :project: xtensor
 
-.. _fmod-function-reference:
 .. doxygenfunction:: fmod(E1&&, E2&&)
    :project: xtensor
 
-.. _remainder-func-ref:
 .. doxygenfunction:: remainder(E1&&, E2&&)
    :project: xtensor
 
-.. _fma-function-reference:
 .. doxygenfunction:: fma(E1&&, E2&&, E3&&)
    :project: xtensor
 
-.. _maximum-func-ref:
 .. doxygenfunction:: maximum(E1&&, E2&&)
    :project: xtensor
 
-.. _minimum-func-ref:
 .. doxygenfunction:: minimum(E1&&, E2&&)
    :project: xtensor
 
-.. _fmax-function-reference:
 .. doxygenfunction:: fmax(E1&&, E2&&)
    :project: xtensor
 
-.. _fmin-function-reference:
 .. doxygenfunction:: fmin(E1&&, E2&&)
    :project: xtensor
 
-.. _fdim-function-reference:
 .. doxygenfunction:: fdim(E1&&, E2&&)
    :project: xtensor
 
-.. _clip-function-reference:
 .. doxygenfunction:: clip(E1&&, E2&&, E3&&)
    :project: xtensor
 
-.. _sign-function-reference:
 .. doxygenfunction:: sign(E&&)
    :project: xtensor
 
diff --git a/docs/source/api/classif_functions.rst b/docs/source/api/classif_functions.rst
index 6cbf6a7cb..3ffdf163b 100644
--- a/docs/source/api/classif_functions.rst
+++ b/docs/source/api/classif_functions.rst
@@ -11,23 +11,18 @@ Classification functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _isfinite-func-ref:
 .. doxygenfunction:: isfinite(E&&)
    :project: xtensor
 
-.. _isinf-func-ref:
 .. doxygenfunction:: isinf(E&&)
    :project: xtensor
 
-.. _isnan-func-ref:
 .. doxygenfunction:: isnan(E&&)
    :project: xtensor
 
-.. _isclose-func-ref:
 .. doxygenfunction:: isclose(E1&&, E2&&, double, double, bool)
    :project: xtensor
 
-.. _allclose-func-ref:
 .. doxygenfunction:: allclose(E1&&, E2&, double, double)
    :project: xtensor
 
diff --git a/docs/source/api/error_functions.rst b/docs/source/api/error_functions.rst
index 350d9cb0b..dd620f167 100644
--- a/docs/source/api/error_functions.rst
+++ b/docs/source/api/error_functions.rst
@@ -11,19 +11,15 @@ Error and gamma functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _erf-function-reference:
 .. doxygenfunction:: erf(E&&)
    :project: xtensor
 
-.. _erfc-function-reference:
 .. doxygenfunction:: erfc(E&&)
    :project: xtensor
 
-.. _tgamma-func-ref:
 .. doxygenfunction:: tgamma(E&&)
    :project: xtensor
 
-.. _lgamma-func-ref:
 .. doxygenfunction:: lgamma(E&&)
    :project: xtensor
 
diff --git a/docs/source/api/exponential_functions.rst b/docs/source/api/exponential_functions.rst
index ce082d3c1..85548081c 100644
--- a/docs/source/api/exponential_functions.rst
+++ b/docs/source/api/exponential_functions.rst
@@ -11,31 +11,24 @@ Exponential functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _exp-function-reference:
 .. doxygenfunction:: exp(E&&)
    :project: xtensor
 
-.. _exp2-function-reference:
 .. doxygenfunction:: exp2(E&&)
    :project: xtensor
 
-.. _expm1-func-ref:
 .. doxygenfunction:: expm1(E&&)
    :project: xtensor
 
-.. _log-function-reference:
 .. doxygenfunction:: log(E&&)
    :project: xtensor
 
-.. _log2-function-reference:
 .. doxygenfunction:: log2(E&&)
    :project: xtensor
 
-.. _log10-func-ref:
 .. doxygenfunction:: log10(E&&)
    :project: xtensor
 
-.. _log1p-func-ref:
 .. doxygenfunction:: log1p(E&&)
    :project: xtensor
 
diff --git a/docs/source/api/index_related.rst b/docs/source/api/index_related.rst
index 8205b9b72..7e3428fe3 100644
--- a/docs/source/api/index_related.rst
+++ b/docs/source/api/index_related.rst
@@ -9,18 +9,14 @@ Index related functions
 
 Defined in ``xtensor/xoperation.hpp``
 
-.. _wherec-op-ref:
 .. doxygenfunction:: where(const T&)
    :project: xtensor
 
-.. _nonzero-op-ref:
 .. doxygenfunction:: nonzero(const T&)
    :project: xtensor
 
-.. _argwhere-op-ref:
 .. doxygenfunction:: argwhere
    :project: xtensor
 
-.. _frindices-op-ref:
 .. doxygenfunction:: from_indices
    :project: xtensor
diff --git a/docs/source/api/nan_functions.rst b/docs/source/api/nan_functions.rst
index 2cc41db02..2ea203523 100644
--- a/docs/source/api/nan_functions.rst
+++ b/docs/source/api/nan_functions.rst
@@ -11,46 +11,36 @@ NaN functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _nan-to-num-function-reference:
 .. doxygenfunction:: nan_to_num(E&&)
    :project: xtensor
 
-.. _nanmin-function-reference:
 .. doxygenfunction:: nanmin(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nanmax-function-reference:
 .. doxygenfunction:: nanmax(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nansum-function-reference:
 .. doxygenfunction:: nansum(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nanmean-function-reference:
 .. doxygenfunction:: nanmean(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nanvar-function-reference:
 .. doxygenfunction:: nanvar(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nanstd-function-reference:
 .. doxygenfunction:: nanstd(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nanprod-function-reference:
 .. doxygenfunction:: nanprod(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nancumsum-function-reference:
 .. doxygenfunction:: nancumsum(E&&)
    :project: xtensor
 
 .. doxygenfunction:: nancumsum(E&&, std::ptrdiff_t)
    :project: xtensor
 
-.. _nancumprod-function-reference:
 .. doxygenfunction:: nancumprod(E&&)
    :project: xtensor
 
diff --git a/docs/source/api/nearint_operations.rst b/docs/source/api/nearint_operations.rst
index 02340039a..5998dd61a 100644
--- a/docs/source/api/nearint_operations.rst
+++ b/docs/source/api/nearint_operations.rst
@@ -11,27 +11,21 @@ Nearest integer floating point operations
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _ceil-function-reference:
 .. doxygenfunction:: ceil(E&&)
    :project: xtensor
 
-.. _floor-func-ref:
 .. doxygenfunction:: floor(E&&)
    :project: xtensor
 
-.. _trunc-func-ref:
 .. doxygenfunction:: trunc(E&&)
    :project: xtensor
 
-.. _round-func-ref:
 .. doxygenfunction:: round(E&&)
    :project: xtensor
 
-.. _nearbyint-func-ref:
 .. doxygenfunction:: nearbyint(E&&)
    :project: xtensor
 
-.. _rint-function-reference:
 .. doxygenfunction:: rint(E&&)
    :project: xtensor
 
diff --git a/docs/source/api/operators.rst b/docs/source/api/operators.rst
index a8129d28d..b11cb6676 100644
--- a/docs/source/api/operators.rst
+++ b/docs/source/api/operators.rst
@@ -9,134 +9,101 @@ Operators and related functions
 
 Defined in ``xtensor/xmath.hpp`` and ``xtensor/xoperation.hpp``
 
-.. _identity-op-ref:
 .. doxygenfunction:: operator+(E&&)
    :project: xtensor
 
-.. _neg-op-ref:
 .. doxygenfunction:: operator-(E&&)
    :project: xtensor
 
-.. _plus-op-ref:
 .. doxygenfunction:: operator+(E1&&, E2&&)
    :project: xtensor
 
-.. _minus-op-ref:
 .. doxygenfunction:: operator-(E1&&, E2&&)
    :project: xtensor
 
-.. _mul-op-ref:
 .. doxygenfunction:: operator*(E1&&, E2&&)
    :project: xtensor
 
-.. _div-op-ref:
 .. doxygenfunction:: operator/(E1&&, E2&&)
    :project: xtensor
 
-.. _or-op-ref:
 .. doxygenfunction:: operator||(E1&&, E2&&)
    :project: xtensor
 
-.. _and-op-ref:
 .. doxygenfunction:: operator&&(E1&&, E2&&)
    :project: xtensor
 
-.. _not-op-ref:
 .. doxygenfunction:: operator!(E&&)
    :project: xtensor
 
-.. _where-op-ref:
 .. doxygenfunction:: where(E1&&, E2&&, E3&&)
    :project: xtensor
 
-.. _any-op-ref:
 .. doxygenfunction:: any(E&&)
    :project: xtensor
 
-.. _all-op-ref:
 .. doxygenfunction:: all(E&&)
    :project: xtensor
 
-.. _less-op-ref:
 .. doxygenfunction:: operator<(E1&&, E2&&)
    :project: xtensor
 
-.. _less-eq-op-ref:
 .. doxygenfunction:: operator<=(E1&&, E2&&)
    :project: xtensor
 
-.. _greater-op-ref:
 .. doxygenfunction:: operator>(E1&&, E2&&)
    :project: xtensor
 
-.. _greater-eq-op-ref:
 .. doxygenfunction:: operator>=(E1&&, E2&&)
    :project: xtensor
 
-.. _equal-op-ref:
 .. doxygenfunction:: operator==(const xexpression<E1>&, const xexpression<E2>&)
    :project: xtensor
 
-.. _nequal-op-ref:
 .. doxygenfunction:: operator!=(const xexpression<E1>&, const xexpression<E2>&)
    :project: xtensor
 
-.. _equal-fn-ref:
 .. doxygenfunction:: equal(E1&&, E2&&)
    :project: xtensor
 
-.. _nequal-fn-ref:
 .. doxygenfunction:: not_equal(E1&&, E2&&)
    :project: xtensor
 
-.. _less-fn-ref:
 .. doxygenfunction:: less(E1&& e1, E2&& e2)
    :project: xtensor
 
-.. _less-eq-fn-ref:
 .. doxygenfunction:: less_equal(E1&& e1, E2&& e2)
    :project: xtensor
 
-.. _greater-fn-ref:
 .. doxygenfunction:: greater(E1&& e1, E2&& e2)
    :project: xtensor
 
-.. _greate-eq-fn-ref:
 .. doxygenfunction:: greater_equal(E1&& e1, E2&& e2)
    :project: xtensor
 
-.. _bitwise-and-op-ref:
 .. doxygenfunction:: operator&(E1&&, E2&&)
    :project: xtensor
 
-.. _bitwise-or-op-ref:
 .. doxygenfunction:: operator|(E1&&, E2&&)
    :project: xtensor
 
-.. _bitwise-xor-op-ref:
 .. doxygenfunction:: operator^(E1&&, E2&&)
    :project: xtensor
 
-.. _bitwise-not-op-ref:
 .. doxygenfunction:: operator~(E&&)
    :project: xtensor
 
-.. _left-shift-fn-ref:
 .. doxygenfunction:: left_shift(E1&&, E2&&)
    :project: xtensor
 
-.. _right-shift-fn-ref:
 .. doxygenfunction:: right_shift(E1&&, E2&&)
    :project: xtensor
 
-.. _left-sh-op-ref:
 .. doxygenfunction:: operator<<(E1&&, E2&&)
    :project: xtensor
 
-.. _right-sh-op-ref:
 .. doxygenfunction:: operator>>(E1&&, E2&&)
    :project: xtensor
 
-.. _cast-ref:
 .. doxygenfunction:: cast(E&&)
    :project: xtensor
diff --git a/docs/source/api/power_functions.rst b/docs/source/api/power_functions.rst
index 45d53e95f..783715642 100644
--- a/docs/source/api/power_functions.rst
+++ b/docs/source/api/power_functions.rst
@@ -12,7 +12,6 @@ Power functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _pow-function-reference:
 .. doxygenfunction:: pow(E1&&, E2&&)
    :project: xtensor
 
@@ -25,15 +24,12 @@ Defined in ``xtensor/xmath.hpp``
 .. doxygenfunction:: cube(E1&&)
    :project: xtensor
 
-.. _sqrt-function-reference:
 .. doxygenfunction:: sqrt(E&&)
    :project: xtensor
 
-.. _cbrt-function-reference:
 .. doxygenfunction:: cbrt(E&&)
    :project: xtensor
 
-.. _hypot-func-ref:
 .. doxygenfunction:: hypot(E1&&, E2&&)
    :project: xtensor
 
diff --git a/docs/source/api/reducing_functions.rst b/docs/source/api/reducing_functions.rst
index 643cf7b13..e6bf42313 100644
--- a/docs/source/api/reducing_functions.rst
+++ b/docs/source/api/reducing_functions.rst
@@ -14,101 +14,85 @@ Defined in ``xtensor/xmath.hpp``
 .. doxygenfunction:: sum(E&&, EVS)
    :project: xtensor
 
-.. _sum-function-reference:
 .. doxygenfunction:: sum(E&&, X&&, EVS)
    :project: xtensor
 
 .. doxygenfunction:: prod(E&&, EVS)
    :project: xtensor
 
-.. _prod-function-reference:
 .. doxygenfunction:: prod(E&&, X&&, EVS)
    :project: xtensor
 
 .. doxygenfunction:: mean(E&&, EVS)
    :project: xtensor
 
-.. _mean-function-reference:
 .. doxygenfunction:: mean(E&&, X&&, EVS)
    :project: xtensor
 
+.. doxygenfunction:: average(E&&, EVS)
+   :project: xtensor
+
 .. doxygenfunction:: variance(E&&, EVS)
    :project: xtensor
 
 .. doxygenfunction:: variance(E&&, X&&, EVS)
    :project: xtensor
 
-.. _variance-function-reference:
 .. doxygenfunction:: variance(E&&, X&&, const D&, EVS)
    :project: xtensor
 
 .. doxygenfunction:: stddev(E&&, EVS)
    :project: xtensor
 
-.. _stddev-function-reference:
 .. doxygenfunction:: stddev(E&&, X&&, EVS)
    :project: xtensor
 
-.. _diff-function-reference:
 .. doxygenfunction:: diff(const xexpression<T>&, unsigned int, std::ptrdiff_t)
    :project: xtensor
 
 .. doxygenfunction:: amax(E&&, EVS)
    :project: xtensor
 
-.. _amax-function-reference:
 .. doxygenfunction:: amax(E&&, X&&, EVS)
    :project: xtensor
 
 .. doxygenfunction:: amin(E&&, EVS)
    :project: xtensor
 
-.. _amin-function-reference:
 .. doxygenfunction:: amin(E&&, X&&, EVS)
    :project: xtensor
 
-.. _trapz-function-reference:
 .. doxygenfunction:: trapz(const xexpression<T>&, double, std::ptrdiff_t)
    :project: xtensor
 
-.. _trapz-function-reference2:
 .. doxygenfunction:: trapz(const xexpression<T>&, const xexpression<E>&, std::ptrdiff_t)
    :project: xtensor
 
 Defined in ``xtensor/xnorm.hpp``
 
-.. _norm-l0-func-ref:
 .. doxygenfunction:: norm_l0(E&&, X&&, EVS)
    :project: xtensor
 
-.. _norm-l1-func-ref:
 .. doxygenfunction:: norm_l1(E&&, X&&, EVS)
    :project: xtensor
 
-.. _norm-sq-func-ref:
 .. doxygenfunction:: norm_sq(E&&, X&&, EVS)
    :project: xtensor
 
-.. _norm-l2-func-ref:
 .. doxygenfunction:: norm_l2(E&&, X&&, EVS)
    :project: xtensor
 
-.. _norm-linf-func-ref:
 .. doxygenfunction:: norm_linf(E&&, X&&, EVS)
    :project: xtensor
 
-.. _nlptop-func-ref:
 .. doxygenfunction:: norm_lp_to_p(E&&, double, X&&, EVS)
    :project: xtensor
 
-.. _norm-lp-func-ref:
 .. doxygenfunction:: norm_lp(E&&, double, X&&, EVS)
    :project: xtensor
 
-.. _nind-l1-ref:
 .. doxygenfunction:: norm_induced_l1(E&&, EVS)
    :project: xtensor
 
-.. _nilinf-ref:
 .. doxygenfunction:: norm_induced_linf(E&&, EVS)
    :project: xtensor
diff --git a/docs/source/api/trigonometric_functions.rst b/docs/source/api/trigonometric_functions.rst
index 84ae190c2..8aa138965 100644
--- a/docs/source/api/trigonometric_functions.rst
+++ b/docs/source/api/trigonometric_functions.rst
@@ -11,31 +11,24 @@ Trigonometric functions
 
 Defined in ``xtensor/xmath.hpp``
 
-.. _sin-function-reference:
 .. doxygenfunction:: sin(E&&)
    :project: xtensor
 
-.. _cos-function-reference:
 .. doxygenfunction:: cos(E&&)
    :project: xtensor
 
-.. _tan-function-reference:
 .. doxygenfunction:: tan(E&&)
    :project: xtensor
 
-.. _asin-function-reference:
 .. doxygenfunction:: asin(E&&)
    :project: xtensor
 
-.. _acos-function-reference:
 .. doxygenfunction:: acos(E&&)
    :project: xtensor
 
-.. _atan-function-reference:
 .. doxygenfunction:: atan(E&&)
    :project: xtensor
 
-.. _atan2-func-ref:
 .. doxygenfunction:: atan2(E1&&, E2&&)
    :project: xtensor
 
diff --git a/docs/source/api/xmath.rst b/docs/source/api/xmath.rst
index d2b8ef0fa..7df6626f6 100644
--- a/docs/source/api/xmath.rst
+++ b/docs/source/api/xmath.rst
@@ -33,304 +33,343 @@ Mathematical functions
 
    operators
 
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator+ <identity-op-ref>`      | identity                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator- <neg-op-ref>`           | opposite                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator+ <plus-op-ref>`          | addition                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator- <minus-op-ref>`         | substraction                             |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator* <mul-op-ref>`           | multiplication                           |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator/ <div-op-ref>`           | division                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator|| <or-op-ref>`           | logical or                               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator&& <and-op-ref>`          | logical and                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator! <not-op-ref>`           | logical not                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`where <where-op-ref>`             | ternary selection                        |
-+-----------------------------------------+------------------------------------------+
-| :ref:`any <any-op-ref>`                 | return true if any value is truthy       |
-+-----------------------------------------+------------------------------------------+
-| :ref:`all <all-op-ref>`                 | return true if all the values are truthy |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator\< <less-op-ref>`         | element-wise lesser than                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator\<= <less-eq-op-ref>`     | element-wise less or equal               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator> <greater-op-ref>`       | element-wise greater than                |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator>= <greater-eq-op-ref>`   | element-wise greater or equal            |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator== <equal-op-ref>`        | expression equality                      |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator!= <nequal-op-ref>`       | expression inequality                    |
-+-----------------------------------------+------------------------------------------+
-| :ref:`equal <equal-fn-ref>`             | element-wise equality                    |
-+-----------------------------------------+------------------------------------------+
-| :ref:`not_equal <nequal-fn-ref>`        | element-wise inequality                  |
-+-----------------------------------------+------------------------------------------+
-| :ref:`less <less-fn-ref>`               | element-wise lesser than                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`less_equal <less-eq-fn-ref>`      | element-wise less or equal               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`greater <greater-fn-ref>`         | element-wise greater than                |
-+-----------------------------------------+------------------------------------------+
-| :ref:`greater_equal <greate-eq-fn-ref>` | element-wise greater or equal            |
-+-----------------------------------------+------------------------------------------+
-| :ref:`cast <cast-ref>`                  | element-wise `static_cast`               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator& <bitwise-and-op-ref>`   | bitwise and                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator| <bitwise-or-op-ref>`    | bitwise or                               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator^ <bitwise-xor-op-ref>`   | bitwise xor                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator~ <bitwise-not-op-ref>`   | bitwise not                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`left_shift <left-shift-fn-ref>`   | bitwise shift left                       |
-+-----------------------------------------+------------------------------------------+
-| :ref:`right_shift <right-shift-fn-ref>` | bitwise shift right                      |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator\<\< <left-sh-op-ref>`    | bitwise shift left                       |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator\>\> <right-sh-op-ref>`   | bitwise shift right                      |
-+-----------------------------------------+------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator+`     | identity                                 |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator-`     | opposite                                 |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator+`     | addition                                 |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator-`     | substraction                             |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator*`     | multiplication                           |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator/`     | division                                 |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator||`    | logical or                               |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator&&`    | logical and                              |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator!`     | logical not                              |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::where`         | ternary selection                        |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::any`           | return true if any value is truthy       |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::all`           | return true if all the values are truthy |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator\<`    | element-wise lesser than                 |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator\<=`   | element-wise less or equal               |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator>`     | element-wise greater than                |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator>=`    | element-wise greater or equal            |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator==`    | expression equality                      |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator!=`    | expression inequality                    |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::equal`         | element-wise equality                    |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::not_equal`     | element-wise inequality                  |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::less`          | element-wise lesser than                 |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::less_equal`    | element-wise less or equal               |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::greater`       | element-wise greater than                |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::greater_equal` | element-wise greater or equal            |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::cast`          | element-wise `static_cast`               |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator&`     | bitwise and                              |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator|`     | bitwise or                               |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator^`     | bitwise xor                              |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator~`     | bitwise not                              |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::left_shift`    | bitwise shift left                       |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::right_shift`   | bitwise shift right                      |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator\<\<`  | bitwise shift left                       |
+   +-------------------------------+------------------------------------------+
+   | :cpp:func:`xt::operator\>\>`  | bitwise shift right                      |
+   +-------------------------------+------------------------------------------+
 
 .. toctree::
 
    index_related
 
-+-----------------------------------------+------------------------------------------+
-| :ref:`where <wherec-op-ref>`            | indices selection                        |
-+-----------------------------------------+------------------------------------------+
-| :ref:`nonzero <nonzero-op-ref>`         | indices selection                        |
-+-----------------------------------------+------------------------------------------+
-| :ref:`argwhere <argwhere-op-ref>`       | indices selection                        |
-+-----------------------------------------+------------------------------------------+
-| :ref:`from_indices <frindices-op-ref>`  | biulder from indices                     |
-+-----------------------------------------+------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------------+----------------------+
+   | :cpp:func:`xt::where`        | indices selection    |
+   +------------------------------+----------------------+
+   | :cpp:func:`xt::nonzero`      | indices selection    |
+   +------------------------------+----------------------+
+   | :cpp:func:`xt::argwhere`     | indices selection    |
+   +------------------------------+----------------------+
+   | :cpp:func:`xt::from_indices` | biulder from indices |
+   +------------------------------+----------------------+
 
 .. toctree::
 
    basic_functions
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`abs <abs-function-reference>`   | absolute value                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fabs <fabs-function-reference>` | absolute value                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fmod <fmod-function-reference>` | remainder of the floating point division operation |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`remainder <remainder-func-ref>` | signed remainder of the division operation         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fma <fma-function-reference>`   | fused multiply-add operation                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`minimum <minimum-func-ref>`     | element-wise minimum                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`maximum <maximum-func-ref>`     | element-wise maximum                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fmin <fmin-function-reference>` | element-wise minimum for floating point values     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fmax <fmax-function-reference>` | element-wise maximum for floating point values     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fdim <fdim-function-reference>` | element-wise positive difference                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`clip <clip-function-reference>` | element-wise clipping operation                    |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sign <sign-function-reference>` | element-wise indication of the sign                |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::abs`       | absolute value                                     |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::fabs`      | absolute value                                     |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::fmod`      | remainder of the floating point division operation |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::remainder` | signed remainder of the division operation         |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::fma`       | fused multiply-add operation                       |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::minimum`   | element-wise minimum                               |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::maximum`   | element-wise maximum                               |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::fmin`      | element-wise minimum for floating point values     |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::fmax`      | element-wise maximum for floating point values     |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::fdim`      | element-wise positive difference                   |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::clip`      | element-wise clipping operation                    |
+   +---------------------------+----------------------------------------------------+
+   | :cpp:func:`xt::sign`      | element-wise indication of the sign                |
+   +---------------------------+----------------------------------------------------+
 
 .. toctree::
 
    exponential_functions
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`exp <exp-function-reference>`   | natural exponential function                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`exp2 <exp2-function-reference>` | base 2 exponential function                        |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`expm1 <expm1-func-ref>`         | natural exponential function, minus one            |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log <log-function-reference>`   | natural logarithm function                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log2 <log2-function-reference>` | base 2 logarithm function                          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log10 <log10-func-ref>`         | base 10 logarithm function                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log1p <log1p-func-ref>`         | natural logarithm of one plus function             |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------+-----------------------------------------+
+   | :cpp:func:`xt::exp`   | natural exponential function            |
+   +-----------------------+-----------------------------------------+
+   | :cpp:func:`xt::exp2`  | base 2 exponential function             |
+   +-----------------------+-----------------------------------------+
+   | :cpp:func:`xt::expm1` | natural exponential function, minus one |
+   +-----------------------+-----------------------------------------+
+   | :cpp:func:`xt::log`   | natural logarithm function              |
+   +-----------------------+-----------------------------------------+
+   | :cpp:func:`xt::log2`  | base 2 logarithm function               |
+   +-----------------------+-----------------------------------------+
+   | :cpp:func:`xt::log10` | base 10 logarithm function              |
+   +-----------------------+-----------------------------------------+
+   | :cpp:func:`xt::log1p` | natural logarithm of one plus function  |
+   +-----------------------+-----------------------------------------+
 
 .. toctree::
 
    power_functions
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`pow <pow-function-reference>`   | power function                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sqrt <sqrt-function-reference>` | square root function                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`cbrt <cbrt-function-reference>` | cubic root function                                |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`hypot <hypot-func-ref>`         | hypotenuse function                                |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------+----------------------+
+   | :cpp:func:`xt::pow`   | power function       |
+   +-----------------------+----------------------+
+   | :cpp:func:`xt::sqrt`  | square root function |
+   +-----------------------+----------------------+
+   | :cpp:func:`xt::cbrt`  | cubic root function  |
+   +-----------------------+----------------------+
+   | :cpp:func:`xt::hypot` | hypotenuse function  |
+   +-----------------------+----------------------+
 
 .. toctree::
 
    trigonometric_functions
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sin <sin-function-reference>`   | sine function                                      |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`cos <cos-function-reference>`   | cosine function                                    |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`tan <tan-function-reference>`   | tangent function                                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`asin <asin-function-reference>` | arc sine function                                  |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`acos <acos-function-reference>` | arc cosine function                                |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`atan <atan-function-reference>` | arc tangent function                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`atan2 <atan2-func-ref>`         | arc tangent function, determining quadrants        |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------+---------------------------------------------+
+   | :cpp:func:`xt::sin`   | sine function                               |
+   +-----------------------+---------------------------------------------+
+   | :cpp:func:`xt::cos`   | cosine function                             |
+   +-----------------------+---------------------------------------------+
+   | :cpp:func:`xt::tan`   | tangent function                            |
+   +-----------------------+---------------------------------------------+
+   | :cpp:func:`xt::asin`  | arc sine function                           |
+   +-----------------------+---------------------------------------------+
+   | :cpp:func:`xt::acos`  | arc cosine function                         |
+   +-----------------------+---------------------------------------------+
+   | :cpp:func:`xt::atan`  | arc tangent function                        |
+   +-----------------------+---------------------------------------------+
+   | :cpp:func:`xt::atan2` | arc tangent function, determining quadrants |
+   +-----------------------+---------------------------------------------+
 
 .. toctree::
 
    hyperbolic_functions
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sinh <sinh-function-reference>` | hyperbolic sine function                           |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`cosh <cosh-function-reference>` | hyperbolic cosine function                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`tanh <tanh-function-reference>` | hyperbolic tangent function                        |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`asinh <asinh-func-ref>`         | inverse hyperbolic sine function                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`acosh <acosh-func-ref>`         | inverse hyperbolic cosine function                 |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`atanh <atanh-func-ref>`         | inverse hyperbolic tangent function                |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------+-------------------------------------+
+   | :cpp:func:`xt::sinh`  | hyperbolic sine function            |
+   +-----------------------+-------------------------------------+
+   | :cpp:func:`xt::cosh`  | hyperbolic cosine function          |
+   +-----------------------+-------------------------------------+
+   | :cpp:func:`xt::tanh`  | hyperbolic tangent function         |
+   +-----------------------+-------------------------------------+
+   | :cpp:func:`xt::asinh` | inverse hyperbolic sine function    |
+   +-----------------------+-------------------------------------+
+   | :cpp:func:`xt::acosh` | inverse hyperbolic cosine function  |
+   +-----------------------+-------------------------------------+
+   | :cpp:func:`xt::atanh` | inverse hyperbolic tangent function |
+   +-----------------------+-------------------------------------+
 
 .. toctree::
 
    error_functions
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`erf <erf-function-reference>`   | error function                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`erfc <erfc-function-reference>` | complementary error function                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`tgamma <tgamma-func-ref>`       | gamma function                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`lgamma <lgamma-func-ref>`       | natural logarithm of the gamma function            |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------+-----------------------------------------+
+   | :cpp:func:`xt::erf`    | error function                          |
+   +------------------------+-----------------------------------------+
+   | :cpp:func:`xt::erfc`   | complementary error function            |
+   +------------------------+-----------------------------------------+
+   | :cpp:func:`xt::tgamma` | gamma function                          |
+   +------------------------+-----------------------------------------+
+   | :cpp:func:`xt::lgamma` | natural logarithm of the gamma function |
+   +------------------------+-----------------------------------------+
 
 .. toctree::
 
    nearint_operations
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`ceil <ceil-function-reference>` | nearest integers not less                          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`floor <floor-func-ref>`         | nearest integers not greater                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`trunc <trunc-func-ref>`         | nearest integers not greater in magnitude          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`round <round-func-ref>`         | nearest integers, rounding away from zero          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`nearbyint <nearbyint-func-ref>` | nearest integers using current rounding mode       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`rint <rint-function-reference>` | nearest integers using current rounding mode       |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +---------------------------+----------------------------------------------+
+   | :cpp:func:`xt::ceil`      | nearest integers not less                    |
+   +---------------------------+----------------------------------------------+
+   | :cpp:func:`xt::floor`     | nearest integers not greater                 |
+   +---------------------------+----------------------------------------------+
+   | :cpp:func:`xt::trunc`     | nearest integers not greater in magnitude    |
+   +---------------------------+----------------------------------------------+
+   | :cpp:func:`xt::round`     | nearest integers, rounding away from zero    |
+   +---------------------------+----------------------------------------------+
+   | :cpp:func:`xt::nearbyint` | nearest integers using current rounding mode |
+   +---------------------------+----------------------------------------------+
+   | :cpp:func:`xt::rint`      | nearest integers using current rounding mode |
+   +---------------------------+----------------------------------------------+
 
 .. toctree::
 
    classif_functions
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isfinite <isfinite-func-ref>`   | checks for finite values                           |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isinf <isinf-func-ref>`         | checks for infinite values                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isnan <isnan-func-ref>`         | checks for NaN values                              |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isclose <isclose-func-ref>`     | element-wise closeness detection                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`allclose <allclose-func-ref>`   | closeness reduction                                |
-+---------------------------------------+----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +--------------------------+----------------------------------+
+   | :cpp:func:`xt::isfinite` | checks for finite values         |
+   +--------------------------+----------------------------------+
+   | :cpp:func:`xt::isinf`    | checks for infinite values       |
+   +--------------------------+----------------------------------+
+   | :cpp:func:`xt::isnan`    | checks for NaN values            |
+   +--------------------------+----------------------------------+
+   | :cpp:func:`xt::isclose`  | element-wise closeness detection |
+   +--------------------------+----------------------------------+
+   | :cpp:func:`xt::allclose` | closeness reduction              |
+   +--------------------------+----------------------------------+
 
 .. toctree::
 
    reducing_functions
 
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`sum <sum-function-reference>`           | sum of elements over given axes                                     |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`prod <prod-function-reference>`         | product of elements over given axes                                 |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`mean <mean-function-reference>`         | mean of elements over given axes                                    |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`average <average-function-reference>`   | weighted average along the specified axis                           |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`variance <variance-function-reference>` | variance of elements over given axes                                |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`stddev <stddev-function-reference>`     | standard deviation of elements over given axes                      |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`diff <diff-function-reference>`         | Calculate the n-th discrete difference along the given axis         |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`amax <amax-function-reference>`         | amax of elements over given axes                                    |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`amin <amin-function-reference>`         | amin of elements over given axes                                    |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`trapz <trapz-function-reference>`       | Integrate along the given axis using the composite trapezoidal rule |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_l0 <norm-l0-func-ref>`             | L0 pseudo-norm over given axes                                      |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_l1 <norm-l1-func-ref>`             | L1 norm over given axes                                             |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_sq <norm-sq-func-ref>`             | Squared L2 norm over given axes                                     |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_l2 <norm-l2-func-ref>`             | L2 norm over given axes                                             |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_linf <norm-linf-func-ref>`         | Infinity norm over given axes                                       |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_lp_to_p <nlptop-func-ref>`         | p_th power of Lp norm over given axes                               |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_lp <norm-lp-func-ref>`             | Lp norm over given axes                                             |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_induced_l1 <nind-l1-ref>`          | Induced L1 norm of a matrix                                         |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_induced_linf <nilinf-ref>`         | Induced L-infinity norm of a matrix                                 |
-+-----------------------------------------------+---------------------------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::sum`               | sum of elements over given axes                                     |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::prod`              | product of elements over given axes                                 |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::mean`              | mean of elements over given axes                                    |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::average`           | weighted average along the specified axis                           |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::variance`          | variance of elements over given axes                                |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::stddev`            | standard deviation of elements over given axes                      |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::diff`              | Calculate the n-th discrete difference along the given axis         |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::amax`              | amax of elements over given axes                                    |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::amin`              | amin of elements over given axes                                    |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::trapz`             | Integrate along the given axis using the composite trapezoidal rule |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_l0`           | L0 pseudo-norm over given axes                                      |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_l1`           | L1 norm over given axes                                             |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_sq`           | Squared L2 norm over given axes                                     |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_l2`           | L2 norm over given axes                                             |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_linf`         | Infinity norm over given axes                                       |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_lp_to_p`      | p_th power of Lp norm over given axes                               |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_lp`           | Lp norm over given axes                                             |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_induced_l1`   | Induced L1 norm of a matrix                                         |
+   +-----------------------------------+---------------------------------------------------------------------+
+   | :cpp:func:`xt::norm_induced_linf` | Induced L-infinity norm of a matrix                                 |
+   +-----------------------------------+---------------------------------------------------------------------+
 
 .. toctree::
 
    accumulating_functions
 
-+---------------------------------------------+-------------------------------------------------+
-| :ref:`cumsum <cumsum-function-reference>`   | cumulative sum of elements over a given axis    |
-+---------------------------------------------+-------------------------------------------------+
-| :ref:`cumprod <cumprod-function-reference>` | cumulative product of elements over given axes  |
-+---------------------------------------------+-------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-------------------------+------------------------------------------------+
+   | :cpp:func:`xt::cumsum`  | cumulative sum of elements over a given axis   |
+   +-------------------------+------------------------------------------------+
+   | :cpp:func:`xt::cumprod` | cumulative product of elements over given axes |
+   +-------------------------+------------------------------------------------+
 
 .. toctree::
 
    nan_functions
 
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nan_to_num <nan-to-num-function-reference>` | convert NaN and +/- inf to finite numbers                  |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nansum <nansum-function-reference>`         | sum of elements over a given axis, replacing NaN with 0    |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nanprod <nanprod-function-reference>`       | product of elements over given axes, replacing NaN with 1  |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nancumsum <nancumsum-function-reference>`   | cumsum of elements over a given axis, replacing NaN with 0 |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nancumprod <nancumprod-function-reference>` | cumprod of elements over given axes, replacing NaN with 1  |
-+---------------------------------------------------+------------------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +----------------------------+------------------------------------------------------------+
+   | :cpp:func:`xt::nan_to_num` | convert NaN and +/- inf to finite numbers                  |
+   +----------------------------+------------------------------------------------------------+
+   | :cpp:func:`xt::nansum`     | sum of elements over a given axis, replacing NaN with 0    |
+   +----------------------------+------------------------------------------------------------+
+   | :cpp:func:`xt::nanprod`    | product of elements over given axes, replacing NaN with 1  |
+   +----------------------------+------------------------------------------------------------+
+   | :cpp:func:`xt::nancumsum`  | cumsum of elements over a given axis, replacing NaN with 0 |
+   +----------------------------+------------------------------------------------------------+
+   | :cpp:func:`xt::nancumprod` | cumprod of elements over given axes, replacing NaN with 1  |
+   +----------------------------+------------------------------------------------------------+