Format files

Co-authored-by: Pratik Nayak <pratikvn@pm.me>

Author: ginkgo-bot

include/ginkgo/core/distributed/index_map.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -34,19 +34,19 @@ enum class index_space {
  * disjoint subsets \f$I_k, k = 1, \dots, P\f$, this class defines for each
  * subset an extended global index set \f$\hat{I}_k \supset I_K\f$. The extended
  * index set contains the global indices owned by part \f$k\f$, as well as
- * remote indices \f$R_k = \hat{I}_k \setminus I_k\f$, which are also accessed by
- * part \f$k\f$, but owned by parts \f$l \neq k\f$.
- * At the core, this class provides mappings from the global index space \f$I\f$
- * into different local index spaces. The combined local index space
- * (index_space::combined) is then defined as
+ * remote indices \f$R_k = \hat{I}_k \setminus I_k\f$, which are also accessed
+ * by part \f$k\f$, but owned by parts \f$l \neq k\f$. At the core, this class
+ * provides mappings from the global index space \f$I\f$ into different local
+ * index spaces. The combined local index space (index_space::combined) is then
+ * defined as
  * $[0, \dots, |\hat{I}_k|)$. Additionally, the combined index space can be
  * separated into locally owned (index_space::local) and non-locally owned
  * (index_space::non_local). The locally owned indices are defined as
  * $[0, \dots, |I_k|)$, and the non-locally owned as $[0, \dots, |R_k|)$.
  * With these index sets, the following mappings are defined:
  *
- * - \f$c_k : \hat{I}_k \mapsto [0, \dots, |\hat{I}_k|)\f$ which maps global indices
- *   into the combined/full local index space (denoted as
+ * - \f$c_k : \hat{I}_k \mapsto [0, \dots, |\hat{I}_k|)\f$ which maps global
+ * indices into the combined/full local index space (denoted as
  *   index_space::combined),
  * - \f$l_k: I_k \mapsto [0, \dots, |I_k|)\f$ which maps global indices into the
  *   locally owned index space (denoted as index_space::local),
@@ -57,9 +57,9 @@ enum class index_space {
  * index_space.
  *
  * The index map for \f$I_k\f$ has no knowledge about any other index maps for
- * \f$I_l, l \neq k\f$. In particular, any global index passed to the `map_to_local`
- * map that is not part of the specified index space, will be mapped to an
- * invalid_index.
+ * \f$I_l, l \neq k\f$. In particular, any global index passed to the
+ * `map_to_local` map that is not part of the specified index space, will be
+ * mapped to an invalid_index.
  *
  * \tparam LocalIndexType  type for local indices
  * \tparam GlobalIndexType  type for global indices
@@ -148,12 +148,13 @@ class index_map {
      * The indices are grouped by their owning rank and sorted according to
      * their global index within each group.
      *
-     * The set \f$R_k = \hat{I}_k \setminus I_k\f$ can also be written as the union
-     * of the intersection of \f$\hat{I}_k\f$ with other disjoint sets
+     * The set \f$R_k = \hat{I}_k \setminus I_k\f$ can also be written as the
+     * union of the intersection of \f$\hat{I}_k\f$ with other disjoint sets
      * \f$I_l, l \neq k\f$, i.e.
      * $R_k = \bigcup_{j \neq k} \hat{I}_k \cap I_j = \bigcup_{j \neq k}
-     * R_{k,j}$. The set \f$R_{k,j}\f$ can then be mapped by \f$l_j\f$ to get the local
-     * indices wrt. part \f$j\f$. The indices here are mapped by \f$l_j\f$.
+     * R_{k,j}$. The set \f$R_{k,j}\f$ can then be mapped by \f$l_j\f$ to get
+     * the local indices wrt. part \f$j\f$. The indices here are mapped by
+     * \f$l_j\f$.
      */
     const segmented_array<LocalIndexType>& get_remote_local_idxs() const;
 

include/ginkgo/core/distributed/vector.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 

include/ginkgo/core/factorization/ic.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 

include/ginkgo/core/factorization/ilu.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 

include/ginkgo/core/factorization/par_ic.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -28,9 +28,9 @@ namespace factorization {
 /**
  * ParIC is an incomplete Cholesky factorization which is computed in parallel.
  *
- * \f$L\f$ is a lower triangular matrix, which approximates a given matrix \f$A\f$ with
- * \f$A \approx LL^H\f$. Here, \f$L + L^H\f$ has the same sparsity pattern as \f$A\f$, which
- * is also called IC(0).
+ * \f$L\f$ is a lower triangular matrix, which approximates a given matrix
+ * \f$A\f$ with \f$A \approx LL^H\f$. Here, \f$L + L^H\f$ has the same sparsity
+ * pattern as \f$A\f$, which is also called IC(0).
  *
  * The ParIC algorithm generates the incomplete factors iteratively, using a
  * fixed-point iteration of the form
@@ -46,9 +46,9 @@ namespace factorization {
  * In general, the entries of \f$L\f$ can be iterated in parallel and in
  * asynchronous fashion, the algorithm asymptotically converges to the
  * incomplete factors \f$L\f$ and \f$L^H\f$ fulfilling $\left(R = A - L \cdot
- * L^H\right)\vert_\mathcal{S} = 0\vert_\mathcal{S}$ where \f$\mathcal{S}\f$ is the
- * pre-defined sparsity pattern (in case of IC(0) the sparsity pattern of the
- * system matrix \f$A\f$). The number of ParIC sweeps needed for convergence
+ * L^H\right)\vert_\mathcal{S} = 0\vert_\mathcal{S}$ where \f$\mathcal{S}\f$ is
+ * the pre-defined sparsity pattern (in case of IC(0) the sparsity pattern of
+ * the system matrix \f$A\f$). The number of ParIC sweeps needed for convergence
  * depends on the parallelism level: For sequential execution, a single sweep
  * is sufficient, for fine-grained parallelism, the number of sweeps necessary
  * to get a good approximation of the incomplete factors depends heavily on the

include/ginkgo/core/factorization/par_ict.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -30,9 +30,10 @@ namespace factorization {
  * computed in parallel.
  *
  * \f$L\f$ is a lower triangular matrix which approximates a given symmetric
- * positive definite matrix \f$A\f$ with \f$A \approx LL^T\f$. Here, \f$L\f$ has a sparsity
- * pattern that is improved iteratively based on its element-wise magnitude.
- * The initial sparsity pattern is chosen based on the lower triangle of \f$A\f$.
+ * positive definite matrix \f$A\f$ with \f$A \approx LL^T\f$. Here, \f$L\f$ has
+ * a sparsity pattern that is improved iteratively based on its element-wise
+ * magnitude. The initial sparsity pattern is chosen based on the lower triangle
+ * of \f$A\f$.
  *
  * One iteration of the ParICT algorithm consists of the following steps:
  *

include/ginkgo/core/factorization/par_ilu.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -28,9 +28,10 @@ namespace factorization {
 /**
  * ParILU is an incomplete LU factorization which is computed in parallel.
  *
- * \f$L\f$ is a lower unitriangular, while \f$U\f$ is an upper triangular matrix, which
- * approximate a given matrix \f$A\f$ with \f$A \approx LU\f$. Here, \f$L\f$ and \f$U\f$ have
- * the same sparsity pattern as \f$A\f$, which is also called ILU(0).
+ * \f$L\f$ is a lower unitriangular, while \f$U\f$ is an upper triangular
+ * matrix, which approximate a given matrix \f$A\f$ with \f$A \approx LU\f$.
+ * Here, \f$L\f$ and \f$U\f$ have the same sparsity pattern as \f$A\f$, which is
+ * also called ILU(0).
  *
  * The ParILU algorithm generates the incomplete factors iteratively, using a
  * fixed-point iteration of the form
@@ -44,17 +45,18 @@ namespace factorization {
  * \end{cases}
  * $
  *
- * In general, the entries of \f$L\f$ and \f$U\f$ can be iterated in parallel and in
- * asynchronous fashion, the algorithm asymptotically converges to the
+ * In general, the entries of \f$L\f$ and \f$U\f$ can be iterated in parallel
+ * and in asynchronous fashion, the algorithm asymptotically converges to the
  * incomplete factors \f$L\f$ and \f$U\f$ fulfilling $\left(R = A - L \cdot
- * U\right)\vert_\mathcal{S} = 0\vert_\mathcal{S}$ where \f$\mathcal{S}\f$ is the
- * pre-defined sparsity pattern (in case of ILU(0) the sparsity pattern of the
- * system matrix \f$A\f$). The number of ParILU sweeps needed for convergence
- * depends on the parallelism level: For sequential execution, a single sweep
- * is sufficient, for fine-grained parallelism, the number of sweeps necessary
- * to get a good approximation of the incomplete factors depends heavily on the
- * problem. On the OpenMP executor, 3 sweeps usually give a decent approximation
- * in our experiments, while GPU executors can take 10 or more iterations.
+ * U\right)\vert_\mathcal{S} = 0\vert_\mathcal{S}$ where \f$\mathcal{S}\f$ is
+ * the pre-defined sparsity pattern (in case of ILU(0) the sparsity pattern of
+ * the system matrix \f$A\f$). The number of ParILU sweeps needed for
+ * convergence depends on the parallelism level: For sequential execution, a
+ * single sweep is sufficient, for fine-grained parallelism, the number of
+ * sweeps necessary to get a good approximation of the incomplete factors
+ * depends heavily on the problem. On the OpenMP executor, 3 sweeps usually give
+ * a decent approximation in our experiments, while GPU executors can take 10 or
+ * more iterations.
  *
  * The ParILU algorithm in Ginkgo follows the design of E. Chow and A. Patel,
  * Fine-grained Parallel Incomplete LU Factorization, SIAM Journal on Scientific

include/ginkgo/core/factorization/par_ilut.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -29,11 +29,11 @@ namespace factorization {
  * ParILUT is an incomplete threshold-based LU factorization which is computed
  * in parallel.
  *
- * \f$L\f$ is a lower unitriangular, while \f$U\f$ is an upper triangular matrix, which
- * approximate a given matrix \f$A\f$ with \f$A \approx LU\f$. Here, \f$L\f$ and \f$U\f$ have
- * a sparsity pattern that is improved iteratively based on their element-wise
- * magnitude. The initial sparsity pattern is chosen based on the \f$ILU(0)\f$
- * factorization of \f$A\f$.
+ * \f$L\f$ is a lower unitriangular, while \f$U\f$ is an upper triangular
+ * matrix, which approximate a given matrix \f$A\f$ with \f$A \approx LU\f$.
+ * Here, \f$L\f$ and \f$U\f$ have a sparsity pattern that is improved
+ * iteratively based on their element-wise magnitude. The initial sparsity
+ * pattern is chosen based on the \f$ILU(0)\f$ factorization of \f$A\f$.
  *
  * One iteration of the ParILUT algorithm consists of the following steps:
  *

include/ginkgo/core/matrix/csr.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -1088,14 +1088,15 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
         permute_mode mode = permute_mode::symmetric) const;
 
     /**
-     * Creates a non-symmetrically permuted copy \f$A'\f$ of this matrix \f$A\f$ with
-     * the given row and column permutations \f$P\f$ and \f$Q\f$. The operation will
-     * compute \f$A'(i, j) = A(p[i], q[j])\f$, or \f$A' = P A Q^T\f$ if `invert` is
-     * `false`, and \f$A'(p[i], q[j]) = A(i,j)\f$, or \f$A' = P^{-1} A Q^{-T}\f$ if
-     * `invert` is `true`.
+     * Creates a non-symmetrically permuted copy \f$A'\f$ of this matrix \f$A\f$
+     * with the given row and column permutations \f$P\f$ and \f$Q\f$. The
+     * operation will compute \f$A'(i, j) = A(p[i], q[j])\f$, or \f$A' = P A
+     * Q^T\f$ if `invert` is `false`, and \f$A'(p[i], q[j]) = A(i,j)\f$, or
+     * \f$A' = P^{-1} A Q^{-T}\f$ if `invert` is `true`.
      *
      * @param row_permutation  The permutation \f$P\f$ to apply to the rows
-     * @param column_permutation  The permutation \f$Q\f$ to apply to the columns
+     * @param column_permutation  The permutation \f$Q\f$ to apply to the
+     * columns
      * @param invert  If set to `false`, uses the input permutations, otherwise
      *                uses their inverses \f$P^{-1}, Q^{-1}\f$
      * @return  The permuted matrix.
@@ -1141,7 +1142,8 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
      * reuse->update_values(matrix, permuted);
      * ```
      * @param row_permutation  The permutation \f$P\f$ to apply to the rows
-     * @param column_permutation  The permutation \f$Q\f$ to apply to the columns
+     * @param column_permutation  The permutation \f$Q\f$ to apply to the
+     * columns
      * @param invert  If set to `false`, uses the input permutations, otherwise
      *                uses their inverses \f$P^{-1}, Q^{-1}\f$
      * @return an std::pair consisting of the permuted matrix and the reuse info

include/ginkgo/core/matrix/dense.hpp

@@ -452,14 +452,15 @@ class Dense
                  ptr_param<Dense> output, permute_mode mode) const;
 
     /**
-     * Creates a non-symmetrically permuted copy \f$A'\f$ of this matrix \f$A\f$ with
-     * the given row and column permutations \f$P\f$ and \f$Q\f$. The operation will
-     * compute \f$A'(i, j) = A(p[i], q[j])\f$, or \f$A' = P A Q^T\f$ if `invert` is
-     * `false`, and \f$A'(p[i], q[j]) = A(i,j)\f$, or \f$A' = P^{-1} A Q^{-T}\f$ if
-     * `invert` is `true`.
+     * Creates a non-symmetrically permuted copy \f$A'\f$ of this matrix \f$A\f$
+     * with the given row and column permutations \f$P\f$ and \f$Q\f$. The
+     * operation will compute \f$A'(i, j) = A(p[i], q[j])\f$, or \f$A' = P A
+     * Q^T\f$ if `invert` is `false`, and \f$A'(p[i], q[j]) = A(i,j)\f$, or
+     * \f$A' = P^{-1} A Q^{-T}\f$ if `invert` is `true`.
      *
      * @param row_permutation  The permutation \f$P\f$ to apply to the rows
-     * @param column_permutation  The permutation \f$Q\f$ to apply to the columns
+     * @param column_permutation  The permutation \f$Q\f$ to apply to the
+     * columns
      * @param invert  If set to `false`, uses the input permutations, otherwise
      *                uses their inverses \f$P^{-1}, Q^{-1}\f$
      * @return  The permuted matrix.