pre-commit autoupdate (#2754)

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.4.0
+  rev: v4.5.0
   hooks:
   - id: check-added-large-files
   - id: check-case-conflict
@@ -24,14 +24,14 @@ repos:
   - id: remove-tabs
     args: [--whitespaces-count, '4']
 - repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks
-  rev: v2.10.0
+  rev: v2.11.0
   hooks:
   - id: pretty-format-yaml
     args: [--autofix, --indent, '2']
     types: [file]
     files: \.(yaml|yml|clang-format)
 - repo: https://github.com/tdegeus/cpp_comment_format
-  rev: v0.2.0
+  rev: v0.2.1
   hooks:
   - id: cpp_comment_format
 - repo: https://github.com/tdegeus/conda_envfile
@@ -41,7 +41,7 @@ repos:
     files: environment.yaml
 # Externally provided executables (so we can use them with editors as well).
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v16.0.6
+  rev: v17.0.6
   hooks:
   - id: clang-format
     files: .*\.[hc]pp$

include/xtensor/xadapt.hpp

@@ -664,7 +664,7 @@ namespace xt
     /**
      * Adapt a smart pointer to a typed memory block (unique_ptr or shared_ptr)
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * #include <xtensor/xadapt.hpp>
      * #include <xtensor/xio.hpp>
      *
@@ -674,7 +674,7 @@ namespace xt
      * auto xptr = adapt_smart_ptr(sptr, shape);
      * xptr(1, 3) = 123.;
      * std::cout << xptr;
-     * \endcode
+     * @endcode
      *
      * @ingroup xt_xadapt
      * @param smart_ptr a smart pointer to a memory block of T[]
@@ -701,7 +701,7 @@ namespace xt
      * a given shape and operate naturally on it. Memory will be automatically
      * handled by the smart pointer implementation.
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * #include <xtensor/xadapt.hpp>
      * #include <xtensor/xio.hpp>
      *
@@ -733,7 +733,7 @@ namespace xt
      *                                shape, std::move(unique_buf));
      *     std::cout << obj << std::endl;
      * }
-     * \endcode
+     * @endcode
      *
      * @ingroup xt_xadapt
      * @param data_ptr A pointer to a typed data block (e.g. double*)
@@ -763,7 +763,7 @@ namespace xt
     /**
      * Adapt a smart pointer to a typed memory block (unique_ptr or shared_ptr)
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * #include <xtensor/xadapt.hpp>
      * #include <xtensor/xio.hpp>
      *
@@ -772,7 +772,7 @@ namespace xt
      * auto xptr = adapt_smart_ptr(sptr, {4, 2});
      * xptr(1, 3) = 123.;
      * std::cout << xptr;
-     * \endcode
+     * @endcode
      *
      * @ingroup xt_xadapt
      * @param smart_ptr a smart pointer to a memory block of T[]
@@ -802,7 +802,7 @@ namespace xt
      * a given shape and operate naturally on it. Memory will be automatically
      * handled by the smart pointer implementation.
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * #include <xtensor/xadapt.hpp>
      * #include <xtensor/xio.hpp>
      *
@@ -832,7 +832,7 @@ namespace xt
      *                                {2, 4}, std::move(unique_buf));
      *     std::cout << obj << std::endl;
      * }
-     * \endcode
+     * @endcode
      *
      * @ingroup xt_xadapt
      * @param data_ptr A pointer to a typed data block (e.g. double*)
@@ -868,14 +868,14 @@ namespace xt
      *
      * Construct for example with:
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * #include <xtensor/xadapt.hpp>
      *
      * std::array<size_t, 2> shape = {2, 2};
      * std::vector<double> data = {1, 2, 3, 4};
      *
      * xt::xtensor_pointer<double, 2> a = xt::adapt(data.data(), 4, xt::no_ownership(), shape);
-     * \endcode
+     * @endcode
      *
      * @ingroup xt_xadapt
      * @tparam T The data type (e.g. ``double``).
@@ -893,14 +893,14 @@ namespace xt
      *
      * Construct for example with:
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * #include <xtensor/xadapt.hpp>
      *
      * std::vector<int> data(4, 0);
      * xt::svector<size_t> shape({2, 2});
      *
      * xt::xarray_pointer<int> a = xt::adapt(data.data(), data.size(), xt::no_ownership(), shape);
-     * \endcode
+     * @endcode
      *
      * @ingroup xt_xadapt
      * @tparam T The data type (e.g. ``double``).

include/xtensor/xblockwise_reducer.hpp

@@ -213,7 +213,8 @@ namespace xt
         }
         return input_chunk_range_type{
             multiindex_iterator_begin<input_chunk_index_type>(input_chunks_begin, input_chunks_end),
-            multiindex_iterator_end<input_chunk_index_type>(input_chunks_begin, input_chunks_end)};
+            multiindex_iterator_end<input_chunk_index_type>(input_chunks_begin, input_chunks_end)
+        };
     }
 
     template <class CT, class F, class X, class O>

include/xtensor/xbroadcast.hpp

@@ -351,12 +351,12 @@ namespace xt
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class CT, class X>
     template <class... Args>

include/xtensor/xbuilder.hpp

@@ -772,13 +772,13 @@ namespace xt
      * @param axis axis along which elements are concatenated
      * @returns xgenerator evaluating to concatenated elements
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{1, 2, 3}};
      * xt::xarray<double> b = {{2, 3, 4}};
      * xt::xarray<double> c = xt::concatenate(xt::xtuple(a, b)); // => {{1, 2, 3},
      *                                                           //     {2, 3, 4}}
      * xt::xarray<double> d = xt::concatenate(xt::xtuple(a, b), 1); // => {{1, 2, 3, 2, 3, 4}}
-     * \endcode
+     * @endcode
      */
     template <class... CT>
     inline auto concatenate(std::tuple<CT...>&& t, std::size_t axis = 0)
@@ -823,15 +823,15 @@ namespace xt
      * @param axis axis along which elements are stacked
      * @returns xgenerator evaluating to stacked elements
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {1, 2, 3};
      * xt::xarray<double> b = {5, 6, 7};
      * xt::xarray<double> s = xt::stack(xt::xtuple(a, b)); // => {{1, 2, 3},
      *                                                     //     {5, 6, 7}}
      * xt::xarray<double> t = xt::stack(xt::xtuple(a, b), 1); // => {{1, 5},
      *                                                        //     {2, 6},
      *                                                        //     {3, 7}}
-     * \endcode
+     * @endcode
      */
     template <class... CT>
     inline auto stack(std::tuple<CT...>&& t, std::size_t axis = 0)
@@ -1093,12 +1093,12 @@ namespace xt
      *               from which the diagonals should be taken.
      * @returns xexpression with values of the diagonal
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{1, 2, 3},
      *                         {4, 5, 6}
      *                         {7, 8, 9}};
      * auto b = xt::diagonal(a); // => {1, 5, 9}
-     * \endcode
+     * @endcode
      */
     template <class E>
     inline auto diagonal(E&& arr, int offset = 0, std::size_t axis_1 = 0, std::size_t axis_2 = 1)
@@ -1145,12 +1145,12 @@ namespace xt
      * @param k the offset of the considered diagonal
      * @returns xexpression function with shape n x n and arr on the diagonal
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {1, 5, 9};
      * auto b = xt::diag(a); // => {{1, 0, 0},
      *                       //     {0, 5, 0},
      *                       //     {0, 0, 9}}
-     * \endcode
+     * @endcode
      */
     template <class E>
     inline auto diag(E&& arr, int k = 0)

include/xtensor/xcontainer.hpp

@@ -476,12 +476,12 @@ namespace xt
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>
@@ -506,12 +506,12 @@ namespace xt
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>
@@ -1080,11 +1080,11 @@ namespace xt
      * Reshapes the container and keeps old elements. The `shape` argument can have one of its value
      * equal to `-1`, in this case the value is inferred from the number of elements in the container
      * and the remaining values in the `shape`.
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<int> a = { 1, 2, 3, 4, 5, 6, 7, 8 };
      * a.reshape({-1, 4});
      * //a.shape() is {2, 4}
-     * \endcode
+     * @endcode
      * @param shape the new shape (has to have same number of elements as the original container)
      * @param layout the layout to compute the strides (defaults to static layout of the container,
      *               or for a container with dynamic layout to XTENSOR_DEFAULT_LAYOUT)

include/xtensor/xeval.hpp

@@ -33,11 +33,11 @@ namespace xt
     /**
      * Force evaluation of xexpression.
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {1, 2, 3, 4};
      * auto&& b = xt::eval(a); // b is a reference to a, no copy!
      * auto&& c = xt::eval(a + b); // c is xarray<double>, not an xexpression
-     * \endcode
+     * @endcode
      *
      * @ingroup xt_xeval
      * @return xt::xarray or xt::xtensor depending on shape type
@@ -120,7 +120,7 @@ namespace xt
      * Force evaluation of xexpression not providing a data interface
      * and convert to the required layout.
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double, xt::layout_type::row_major> a = {1, 2, 3, 4};
      *
      * // take reference to a (no copy!)
@@ -137,7 +137,7 @@ namespace xt
      *
      * // xarray<int> with the required layout
      * auto&& e = xt::as_strided<xt::layout_type::column_major>(a_cast);
-     * \endcode
+     * @endcode
      *
      * @warning This function should be used in a local context only.
      *          Returning the value returned by this function could lead to a dangling reference.

include/xtensor/xexpression.hpp

@@ -409,16 +409,16 @@ namespace xt
     {
     };
 
-#define XTENSOR_FORWARD_CONST_METHOD(name)                                 \
-    auto name() const->decltype(std::declval<xtl::constify_t<E>>().name()) \
-    {                                                                      \
-        return m_ptr->name();                                              \
+#define XTENSOR_FORWARD_CONST_METHOD(name)                                   \
+    auto name() const -> decltype(std::declval<xtl::constify_t<E>>().name()) \
+    {                                                                        \
+        return m_ptr->name();                                                \
     }
 
-#define XTENSOR_FORWARD_METHOD(name)                \
-    auto name()->decltype(std::declval<E>().name()) \
-    {                                               \
-        return m_ptr->name();                       \
+#define XTENSOR_FORWARD_METHOD(name)                  \
+    auto name() -> decltype(std::declval<E>().name()) \
+    {                                                 \
+        return m_ptr->name();                         \
     }
 
 #define XTENSOR_FORWARD_CONST_ITERATOR_METHOD(name)                                               \
@@ -489,7 +489,7 @@ namespace xt
      * For example, when a temporary expression needs to be used twice in another
      * expression, shared expressions can come to the rescue:
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * template <class E>
      * auto cos_plus_sin(xexpression<E>&& expr)
      * {
@@ -502,7 +502,7 @@ namespace xt
      *     std::cout << shared_expr.use_count() << std::endl; // Will print 3 because used twice in expression
      *     return result; // all valid because expr lifetime managed by xshared_expression / shared_ptr.
      * }
-     * \endcode
+     * @endcode
      */
     template <class E>
     class xshared_expression : public xexpression<xshared_expression<E>>

include/xtensor/xfunction.hpp

@@ -637,12 +637,12 @@ namespace xt
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.unchecked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class F, class... CT>
     template <class... Args>

include/xtensor/xfunctor_view.hpp

@@ -786,12 +786,12 @@ namespace xt
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.unchecked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>
@@ -842,12 +842,12 @@ namespace xt
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>