Reformat code

Author: mscuttari

include/marco/Runtime/Solvers/IDA/Instance.h

@@ -32,12 +32,13 @@ using ResidualFunction = double (*)(double, const int64_t *);
 /// The 6th argument is a pointer to the list of AD seed identifiers
 /// The result is the Jacobian value.
 using JacobianFunction = double (*)(double, const int64_t *, const uint64_t *,
-                                    double, uint64_t, const uint64_t*);
+                                    double, uint64_t, const uint64_t *);
 
 /// A descriptor of a Jacobian function is a pair of value consisting in:
 ///  - the function pointer
 ///  - the number of elements of each AD seed
-using JacobianFunctionDescriptor = std::pair<JacobianFunction, std::vector<uint64_t>>;
+using JacobianFunctionDescriptor =
+    std::pair<JacobianFunction, std::vector<uint64_t>>;
 
 /// A map indicating the IDs of the buffers living inside the memory pool to
 /// be used as AD seeds for each Jacobian function.
@@ -51,8 +52,8 @@ using JacobianSeedsMap = std::map<JacobianFunction, std::vector<uint64_t>>;
 ///   - the end indices (excluded)
 ///   - the map indicating the buffer IDs to be used when computing the
 ///     partial derivatives
-using ThreadEquationsChunk =
-    std::tuple<Equation, std::vector<int64_t>, std::vector<int64_t>, JacobianSeedsMap>;
+using ThreadEquationsChunk = std::tuple<Equation, std::vector<int64_t>,
+                                        std::vector<int64_t>, JacobianSeedsMap>;
 
 class IDAInstance {
 public:
@@ -94,7 +95,7 @@ class IDAInstance {
   /// equation.
   void addJacobianFunction(Equation equationIndex, Variable variableIndex,
                            JacobianFunction jacobianFunction,
-                           uint64_t numOfSeeds, uint64_t* seedSizes);
+                           uint64_t numOfSeeds, uint64_t *seedSizes);
 
   /// Instantiate and initialize all the classes needed by IDA in order to
   /// solve the given system of equations. It also sets optional simulation
@@ -162,7 +163,9 @@ class IDAInstance {
 
   [[nodiscard]] uint64_t getVariableRank(Variable variable) const;
 
-  void iterateAccessedArrayVariables(Equation equation, std::function<void(Variable)> callback) const;
+  void
+  iterateAccessedArrayVariables(Equation equation,
+                                std::function<void(Variable)> callback) const;
 
   std::vector<JacobianColumn>
   computeJacobianColumns(Equation eq, const int64_t *equationIndices) const;
@@ -180,7 +183,7 @@ class IDAInstance {
   void equationsParallelIteration(
       std::function<void(Equation equation,
                          const std::vector<int64_t> &equationIndices,
-                         const JacobianSeedsMap& jacobianSeedsMap)>
+                         const JacobianSeedsMap &jacobianSeedsMap)>
           processFn);
 
   void getVariableBeginIndices(Variable variable,

include/marco/Runtime/Support/MemoryManagement.h

@@ -7,61 +7,60 @@
 #include <memory>
 #include <vector>
 
-extern "C"
-{
-  void* marco_malloc(int64_t size);
-  void* marco_realloc(void* ptr, int64_t size);
-  void marco_free(void* ptr);
+extern "C" {
+void *marco_malloc(int64_t size);
+void *marco_realloc(void *ptr, int64_t size);
+void marco_free(void *ptr);
 };
 
 namespace marco::runtime {
 class MemoryPool {
 public:
   MemoryPool() = default;
 
-  MemoryPool(const MemoryPool& other) = delete;
+  MemoryPool(const MemoryPool &other) = delete;
 
-  MemoryPool(MemoryPool&& other) = default;
+  MemoryPool(MemoryPool &&other) = default;
 
   ~MemoryPool();
 
-  MemoryPool& operator=(const MemoryPool& other) = delete;
+  MemoryPool &operator=(const MemoryPool &other) = delete;
 
-  MemoryPool& operator=(MemoryPool&& other) = default;
+  MemoryPool &operator=(MemoryPool &&other) = default;
 
-  double* get(uint64_t id) const;
+  double *get(uint64_t id) const;
 
   uint64_t create(size_t numOfElements);
 
 private:
-  std::vector<double*> buffers;
+  std::vector<double *> buffers;
 };
 
 class MemoryPoolManager {
 private:
   MemoryPoolManager() = default;
 
 public:
-  static MemoryPoolManager& getInstance();
+  static MemoryPoolManager &getInstance();
 
-  MemoryPoolManager(const MemoryPoolManager& other) = delete;
+  MemoryPoolManager(const MemoryPoolManager &other) = delete;
 
-  MemoryPoolManager(MemoryPoolManager&& other) = default;
+  MemoryPoolManager(MemoryPoolManager &&other) = default;
 
   ~MemoryPoolManager() = default;
 
-  MemoryPoolManager& operator=(const MemoryPoolManager& other) = delete;
+  MemoryPoolManager &operator=(const MemoryPoolManager &other) = delete;
 
-  MemoryPoolManager& operator=(MemoryPoolManager&& other) = default;
+  MemoryPoolManager &operator=(MemoryPoolManager &&other) = default;
 
-  MemoryPool& get(uint64_t pool) const;
+  MemoryPool &get(uint64_t pool) const;
 
   uint64_t create();
 
 private:
   std::vector<std::unique_ptr<MemoryPool>> pools{};
 };
-}
+} // namespace marco::runtime
 
 RUNTIME_FUNC_DECL(memoryPoolGet, PTR(void), int64_t, int64_t)