call clang-format

niclaurenti · Apr 17, 2024 · 773b88d · 773b88d
1 parent a079fe7
commit 773b88d
Show file tree

Hide file tree

Showing 7 changed files with 29 additions and 12 deletions.
diff --git a/format.sh b/format.sh
@@ -0,0 +1,3 @@
+clang-format -i inc/adani/*.h
+clang-format -i src/*.cc
+clang-format -i pywrap/pywrap.cc
diff --git a/inc/adani/MatchingCondition.h b/inc/adani/MatchingCondition.h
@@ -6,7 +6,8 @@
  *    Description:  Header file for the
  * MatchingCondition.cc file.
  *
- *         Author:  Non credo esista una persona che analizzi il calcio meglio di me.
+ *         Author:  Non credo esista una persona che analizzi il calcio meglio
+ * di me.
  *
  *  In this file there are the matching conditions.
  *
@@ -34,10 +35,10 @@ class MatchingCondition {
         );
         ~MatchingCondition(){};
 
-        int GetOrder() const {return order_;};
-        char GetEntry1() const {return entry1_;};
-        char GetEntry2() const {return entry2_;};
-        string GetVersion() const {return version_;};
+        int GetOrder() const { return order_; };
+        char GetEntry1() const { return entry1_; };
+        char GetEntry2() const { return entry2_; };
+        string GetVersion() const { return version_; };
 
         Value MuIndependentNfIndependentTerm(double x) const;
         vector<double> NotOrdered(double x) const;

diff --git a/src/CoefficientFunction.cc b/src/CoefficientFunction.cc
@@ -9,7 +9,8 @@ using std::endl;
 
 CoefficientFunction::CoefficientFunction(
     const int &order, const char &kind, const char &channel
-) : order_(order), kind_(kind), channel_(channel) {
+)
+    : order_(order), kind_(kind), channel_(channel) {
 
     // check order
     if (order < 1 || order > 3) {

diff --git a/src/Convolution.cc b/src/Convolution.cc
@@ -16,7 +16,8 @@ using std::endl;
 AbstractConvolution::AbstractConvolution(
     CoefficientFunction *coefffunc, AbstractSplittingFunction *splitfunc,
     const double &abserr, const double &relerr, const int &dim
-) : dim_(dim) {
+)
+    : dim_(dim) {
 
     SetAbserr(abserr);
     SetRelerr(relerr);
@@ -267,7 +268,8 @@ DoubleConvolution::DoubleConvolution(
     const double &abserr, const double &relerr, const int &dim,
     const bool &MCintegral, const int &MCcalls
 )
-    : AbstractConvolution(coefffunc, splitfunc, abserr, relerr, dim), MCintegral_(MCintegral) {
+    : AbstractConvolution(coefffunc, splitfunc, abserr, relerr, dim),
+      MCintegral_(MCintegral) {
 
     SetMCcalls(MCcalls);
 

diff --git a/src/HighEnergyCoefficientFunction.cc b/src/HighEnergyCoefficientFunction.cc
@@ -14,7 +14,7 @@ using std::endl;
 AbstractHighEnergyCoefficientFunction::AbstractHighEnergyCoefficientFunction(
     const int &order, const char &kind, const char &channel, const bool &NLL
 )
-    : CoefficientFunction(order, kind, channel), NLL_(NLL) {};
+    : CoefficientFunction(order, kind, channel), NLL_(NLL){};
 
 //==========================================================================================//
 //  HighEnergyCoefficientFunction: constructor

diff --git a/src/MatchingCondition.cc b/src/MatchingCondition.cc
@@ -15,7 +15,8 @@ using std::endl;
 MatchingCondition::MatchingCondition(
     const int &order, const char &entry1, const char &entry2,
     const string &version
-) : order_(order), entry1_(entry1), entry2_(entry2), version_(version) {
+)
+    : order_(order), entry1_(entry1), entry2_(entry2), version_(version) {
     // check order
     if (order != 3) {
         cout << "Error: only order = 3 is implemented. Got " << order << endl;

diff --git a/src/SplittingFunction.cc b/src/SplittingFunction.cc
@@ -21,7 +21,10 @@ AbstractSplittingFunction::~AbstractSplittingFunction(){};
 SplittingFunction::SplittingFunction(
     const int &order, const char &entry1, const char &entry2
 )
-    : AbstractSplittingFunction(), order_(order), entry1_(entry1), entry2_(entry2) {
+    : AbstractSplittingFunction(),
+      order_(order),
+      entry1_(entry1),
+      entry2_(entry2) {
 
     // check order
     if (order != 0 && order != 1) {
@@ -184,7 +187,13 @@ ConvolutedSplittingFunctions::ConvolutedSplittingFunctions(
     const int &order1, const char &entry1, const char &entry2,
     const int &order2, const char &entry3, const char &entry4
 )
-    : AbstractSplittingFunction() , order1_(order1), entry1_(entry1), entry2_(entry2), order2_(order2), entry3_(entry3), entry4_(entry4){
+    : AbstractSplittingFunction(),
+      order1_(order1),
+      entry1_(entry1),
+      entry2_(entry2),
+      order2_(order2),
+      entry3_(entry3),
+      entry4_(entry4) {
 
     // check order
     if (order1 != 0 && order1 != 1) {