Merge branch 'andful/add-formatting-ci' into 'main'

Enforce formatting

See merge request computational-modeling/maxpluslib!3

Author: MarcG-TUE

.gitlab-ci.yml

@@ -2,7 +2,7 @@ before_script:
     - apt-get update
     - apt-get install --force-yes -y python lcov
     - apt remove --purge --auto-remove cmake
-    - apt install -y software-properties-common lsb-release cmake
+    - apt install -y software-properties-common lsb-release cmake clang-format
 
 build:
     tags:
@@ -17,3 +17,10 @@ build:
       when: always
       paths:
       - ./build/coverage/
+
+format:
+    tags:
+        - Ubuntu2004-64bit
+    script:
+        - clang-format --dry-run --Werror `find ./ -type f -name "*.h" -o -name "*.cc" -o -name "*.cpp"`
+        

include/maxplus/algebra/maxplus.h

@@ -21,20 +21,20 @@
  *
  *  Permission is hereby granted, free of charge, to any person obtaining
  *  a copy of this software and associated documentation files (the “Software”),
- *  to deal in the Software without restriction, including without limitation 
- *  the rights to use, copy, modify, merge, publish, distribute, sublicense, 
- *  and/or sell copies of the Software, and to permit persons to whom the 
+ *  to deal in the Software without restriction, including without limitation
+ *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ *  and/or sell copies of the Software, and to permit persons to whom the
  *  Software is furnished to do so, subject to the following conditions:
  *
- *  The above copyright notice and this permission notice shall be included 
+ *  The above copyright notice and this permission notice shall be included
  *  in all copies or substantial portions of the Software.
  *
  *  THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  *  SOFTWARE.
  */
 

include/maxplus/algebra/mpmatrix.h

@@ -88,13 +88,13 @@ class Vector {
 
     [[nodiscard]] Vector add(MPTime increase) const;
 
-    void add(MPTime increase, Vector& result) const;
+    void add(MPTime increase, Vector &result) const;
 
-    void maximum(const Vector& vecB, Vector& result) const;
+    void maximum(const Vector &vecB, Vector &result) const;
 
-    [[nodiscard]] Vector add(const Vector& vecB) const;
+    [[nodiscard]] Vector add(const Vector &vecB) const;
 
-    void add(const Vector& vecB, Vector& res) const;
+    void add(const Vector &vecB, Vector &res) const;
 
     Vector &operator+=(MPTime increase) {
         this->add(increase, *this);
@@ -109,7 +109,7 @@ class Vector {
 
     [[nodiscard]] bool compare(const Vector &v) const;
 
-    Vector &incrementalMaximum(const Vector& vec) {
+    Vector &incrementalMaximum(const Vector &vec) {
         this->maximum(vec, *this);
         return *this;
     }
@@ -149,7 +149,7 @@ class Matrix {
 
     Matrix(Matrix &&) = default;
     Matrix &operator=(Matrix &&) = default;
-    Matrix(const Matrix &)=default;
+    Matrix(const Matrix &) = default;
 
     Matrix &operator=(const Matrix &);
 
@@ -175,14 +175,16 @@ class Matrix {
     [[nodiscard]] Matrix transpose() const;
 
     [[nodiscard]] virtual Matrix getSubMatrix(const std::list<unsigned int> &rowIndices,
-                                               const std::list<unsigned int> &colIndices) const;
+                                              const std::list<unsigned int> &colIndices) const;
 
-    [[nodiscard]] virtual std::shared_ptr<Matrix> getSubMatrixPtr(const std::list<unsigned int> &rowIndices,
-                                               const std::list<unsigned int> &colIndices) const;
+    [[nodiscard]] virtual std::shared_ptr<Matrix>
+    getSubMatrixPtr(const std::list<unsigned int> &rowIndices,
+                    const std::list<unsigned int> &colIndices) const;
 
     [[nodiscard]] Matrix getSubMatrix(const std::list<unsigned int> &indices) const;
 
-    [[nodiscard]] virtual std::shared_ptr<Matrix> getSubMatrixPtr(const std::list<unsigned int> &indices) const;
+    [[nodiscard]] virtual std::shared_ptr<Matrix>
+    getSubMatrixPtr(const std::list<unsigned int> &indices) const;
 
     [[nodiscard]] Matrix getSubMatrixNonSquare(const std::list<unsigned int> &indices) const;
 
@@ -198,13 +200,13 @@ class Matrix {
     // Algebraic operations.
     [[nodiscard]] Matrix add(MPTime increase) const;
 
-    void add(MPTime increase, Matrix& result) const;
+    void add(MPTime increase, Matrix &result) const;
 
     [[nodiscard]] Matrix mp_sub(const Matrix &m) const;
 
     [[nodiscard]] Matrix mp_maximum(const Matrix &m) const;
 
-    void maximum(const Matrix& matB, Matrix& result) const;
+    void maximum(const Matrix &matB, Matrix &result) const;
 
     [[nodiscard]] Vector mp_multiply(const Vector &v) const;
 
@@ -231,9 +233,7 @@ class Matrix {
         return *this;
     }
 
-    void incrementalMaximum(const Matrix& matrix) {
-        this->maximum(matrix, *this);
-    }
+    void incrementalMaximum(const Matrix &matrix) { this->maximum(matrix, *this); }
 
     bool operator==(const Matrix &other);
 
@@ -249,7 +249,7 @@ class Matrix {
     [[nodiscard]] Matrix starClosureMatrix(MPTime posCycleThreshold = MP_EPSILON) const;
 
     [[nodiscard]] Matrix allPairLongestPathMatrix(MPTime posCycleThreshold,
-                                                   bool implyZeroSelfEdges) const;
+                                                  bool implyZeroSelfEdges) const;
     bool
     allPairLongestPathMatrix(MPTime posCycleThreshold, bool implyZeroSelfEdges, Matrix &res) const;
 
@@ -259,7 +259,6 @@ class Matrix {
     // [[nodiscard]] virtual Matrix *makeMatrix(unsigned int nr_rows, unsigned int nr_cols) const;
 
 private:
-
     void init(MatrixFill fill);
     void init();
 
@@ -270,7 +269,6 @@ class Matrix {
     unsigned int szCols;
 };
 
-
 /****************************************************
  * VectorList: usually represents a set of eigenvectors
  * More efficient than vector<MaxPlus::Vector>

include/maxplus/algebra/mptype.h

@@ -87,7 +87,9 @@ using MPDelay = MPTime;
 // MP_MAX()
 //==============================
 
-inline MPTime MP_MAX(MPTime a, MPTime b) { return (static_cast<CDouble>(a)) > (static_cast<CDouble>(b)) ? (a) : (b); }
+inline MPTime MP_MAX(MPTime a, MPTime b) {
+    return (static_cast<CDouble>(a)) > (static_cast<CDouble>(b)) ? (a) : (b);
+}
 
 inline MPTime MP_MAX(CDouble a, MPTime b) { return MP_MAX(MPTime(a), b); }
 
@@ -99,7 +101,9 @@ inline CDouble MP_MAX(CDouble a, CDouble b) { return CDouble(MP_MAX(MPTime(a), M
 // MP_MIN()
 //==============================
 
-inline MPTime MP_MIN(MPTime a, MPTime b) { return (static_cast<CDouble>(a)) < (static_cast<CDouble>(b)) ? (a) : (b); }
+inline MPTime MP_MIN(MPTime a, MPTime b) {
+    return (static_cast<CDouble>(a)) < (static_cast<CDouble>(b)) ? (a) : (b);
+}
 
 inline MPTime MP_MIN(CDouble a, MPTime b) { return MP_MIN(MPTime(a), b); }
 
@@ -119,17 +123,14 @@ inline bool MP_ISMINUSINFINITY(CDouble a) { return a <= MPTIME_MIN_INF_VALPTHR;
 inline bool MP_ISMINUSINFINITY(MPTime a) { return a <= MP_MINUSINFINITY_THR; }
 
 inline MPTime MP_PLUS(CDouble a, CDouble b) {
-    return (MP_ISMINUSINFINITY(a) || MP_ISMINUSINFINITY(b)) ? MP_MINUSINFINITY
-                                                                    : MPTime(static_cast<CDouble>(a) + static_cast<CDouble>(b));
+    return (MP_ISMINUSINFINITY(a) || MP_ISMINUSINFINITY(b))
+                   ? MP_MINUSINFINITY
+                   : MPTime(static_cast<CDouble>(a) + static_cast<CDouble>(b));
 }
 
-inline MPTime MP_PLUS(MPTime a, CDouble b) {
-    return MP_PLUS(static_cast<CDouble>(a), b);
-}
+inline MPTime MP_PLUS(MPTime a, CDouble b) { return MP_PLUS(static_cast<CDouble>(a), b); }
 
-inline MPTime MP_PLUS(CDouble a, MPTime b) {
-    return MP_PLUS(a, static_cast<CDouble>(b));
-}
+inline MPTime MP_PLUS(CDouble a, MPTime b) { return MP_PLUS(a, static_cast<CDouble>(b)); }
 
 inline MPTime MP_PLUS(MPTime a, MPTime b) {
     return MP_PLUS(static_cast<CDouble>(a), static_cast<CDouble>(b));
@@ -185,37 +186,21 @@ inline MPTime &MPTime::operator-=(MPTime a) {
     return *this;
 }
 
-inline bool MPTime::operator==(MPTime a) const {
-    return this->myVal == a.myVal;
-}
+inline bool MPTime::operator==(MPTime a) const { return this->myVal == a.myVal; }
 
-inline bool MPTime::operator!=(MPTime a) const {
-    return this->myVal != a.myVal;
-}
+inline bool MPTime::operator!=(MPTime a) const { return this->myVal != a.myVal; }
 
-inline bool MPTime::operator<(MPTime a) const {
-    return this->myVal < a.myVal;
-}
+inline bool MPTime::operator<(MPTime a) const { return this->myVal < a.myVal; }
 
-inline bool MPTime::operator>(MPTime a) const {
-    return this->myVal > a.myVal;
-}
+inline bool MPTime::operator>(MPTime a) const { return this->myVal > a.myVal; }
 
-inline bool MPTime::operator<=(MPTime a) const {
-    return this->myVal <= a.myVal;
-}
+inline bool MPTime::operator<=(MPTime a) const { return this->myVal <= a.myVal; }
 
-inline bool MPTime::operator>=(MPTime a) const {
-    return this->myVal >= a.myVal;
-}
+inline bool MPTime::operator>=(MPTime a) const { return this->myVal >= a.myVal; }
 
-inline bool MPTime::isMinusInfinity() const {
-    return MP_ISMINUSINFINITY(this->myVal);
-}
+inline bool MPTime::isMinusInfinity() const { return MP_ISMINUSINFINITY(this->myVal); }
 
-inline MPTime MPTime::fabs() const {
-    return MPTime(std::fabs(this->myVal));
-}
+inline MPTime MPTime::fabs() const { return MPTime(std::fabs(this->myVal)); }
 
 //==============================
 // toString
@@ -225,7 +210,7 @@ inline CString timeToString(MPTime val) {
     // We intentionally dont use isMinusInfinity() here,
     // so that we can expose the unwanted "impure" infinities here.
     //
-    if (static_cast<CDouble>(val)==MPTIME_MIN_INF_VAL) {
+    if (static_cast<CDouble>(val) == MPTIME_MIN_INF_VAL) {
         return CString("-mp_inf");
     }
     return CString(static_cast<CDouble>(val));

include/maxplus/base/analysis/mcm/mcm.h

@@ -57,15 +57,16 @@ namespace Graphs {
 /// </summary>
 /// <param name="g">graph to analyse</param>
 /// <returns>The maximum cycle mean of the graph.</returns>
-CDouble maximumCycleMeanKarp(MCMgraph& g);
+CDouble maximumCycleMeanKarp(MCMgraph &g);
 
 /// <summary>
 ///		The function computes the maximum cycle mean of an MCMgraph using Karp's
 ///		algorithm.
 /// </summary>
 /// <param name="g">graph to analyse</param>
-/// <param name="criticalNodeg">optional, will point to an arbitrary node on the cycle with the maximum cycle mean.</param>
-/// <returns>The maximum cycle mean of the graph and optionally a critical node.</returns>
+/// <param name="criticalNodeg">optional, will point to an arbitrary node on the cycle with the
+/// maximum cycle mean.</param> <returns>The maximum cycle mean of the graph and optionally a
+/// critical node.</returns>
 CDouble maximumCycleMeanKarpDouble(MCMgraph &g, const MCMnode **criticalNode = nullptr);
 
 /// <summary>
@@ -84,18 +85,21 @@ CDouble maximumCycleMeanKarpGeneral(MCMgraph &g);
 /// 	Does not require that all nodes of the graph have an outgoing edge.
 /// </summary>
 /// <param name="g">graph to analyse</param>
-/// <param name="criticalNodeg">optional, will point to an arbitrary node on the cycle with the maximum cycle mean.</param>
-/// <returns>The maximum cycle mean of the graph and optionally a critical node.</returns>
+/// <param name="criticalNodeg">optional, will point to an arbitrary node on the cycle with the
+/// maximum cycle mean.</param> <returns>The maximum cycle mean of the graph and optionally a
+/// critical node.</returns>
 CDouble maximumCycleMeanKarpDoubleGeneral(MCMgraph &g, const MCMnode **criticalNode = nullptr);
 
-
 /**
  * mcmGetAdjacentActors ()
  * The function returns a list with actors directly reachable from
  * actor a.
  */
-v_uint
-mcmGetAdjacentActors(uint a, const v_uint &nodeId, const v_uint &actorId, const std::vector<v_uint> &graph, uint nrNodes);
+v_uint mcmGetAdjacentActors(uint a,
+                            const v_uint &nodeId,
+                            const v_uint &actorId,
+                            const std::vector<v_uint> &graph,
+                            uint nrNodes);
 
 } // namespace Graphs
 #endif

include/maxplus/base/analysis/mcm/mcmdg.h

@@ -60,7 +60,7 @@ namespace Graphs {
  * The function computes the maximum cycle mean of an MCM graph using
  * Dasdan-Gupta's algorithm.
  * Note: this algorithm assumes that edge weights are integer valued !
- * 
+ *
  * @todo
  * check if algorithm can be generalized to float edge weights
  */