Eric-Butcher · Eric-Butcher · Jul 13, 2025 · Jul 13, 2025 · Jul 13, 2025 · Jul 13, 2025
diff --git a/.clang-format b/.clang-format
@@ -0,0 +1,11 @@
+---
+AlignEscapedNewlines: Left
+BasedOnStyle: WebKit
+BraceWrapping:
+    AfterFunction: true
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: true
+BreakConstructorInitializers: BeforeComma
+NamespaceIndentation: None
+QualifierAlignment: Right
+# find include src \( -name '*.cpp' -o -name '*.hpp' \) -exec clang-format -i {} +
diff --git a/.github/workflows/testing.yml → .github/workflows/jobs.yml b/.github/workflows/testing.yml → .github/workflows/jobs.yml
@@ -1,4 +1,4 @@
-name: Test and Lint
+name: Jobs
 
 on:
   push:
@@ -45,6 +45,19 @@ jobs:
       - name: run-tests
         run: ctest --test-dir build --output-on-failure
 
+  format:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Install clang-format
+        run: sudo apt update && sudo apt-get install -y clang clang-format-14
+
+      - name: Run clang-format
+        run: find include src \( -name '*.cpp' -o -name '*.hpp' \) -exec clang-format-14 --dry-run --Werror {} +
+
   lint:
     needs: build
     runs-on: ubuntu-latest
@@ -58,7 +71,7 @@ jobs:
           name: built
           path: ./build
 
-      - name: Get clang-tidy
+      - name: Install clang-tidy
         run: sudo apt-get update && sudo apt-get install -y cmake clang clang-tidy g++
 
       - name: lint

diff --git a/include/linear_congruential_generator.hpp b/include/linear_congruential_generator.hpp
@@ -1,8 +1,8 @@
 #ifndef LINEAR_CONGRUENTIAL_GENERATOR_H
 #define LINEAR_CONGRUENTIAL_GENERATOR_H
 
-#include <cstdint>
 #include "prng.hpp"
+#include <cstdint>
 
 class LinearCongruentialGenerator : public PseudoRandomNumberGenerator {
     // https://en.wikipedia.org/wiki/Linear_congruential_generator#
@@ -15,11 +15,10 @@ class LinearCongruentialGenerator : public PseudoRandomNumberGenerator {
         a is the multiplier
         c is the increment
 
-        glibc uses m=2^{31} a=1103515245 c=12345 and masks the result with 0x3FFFFFFF 
+        glibc uses m=2^{31} a=1103515245 c=12345 and masks the result with 0x3FFFFFFF
         which is what is used for the default implementation here
     */
 private:
-
     // Defaults used from the glibc implementation, see:
     /* @misc{ enwiki:1280426923,
         author = "{Wikipedia contributors}",
@@ -29,17 +28,16 @@ class LinearCongruentialGenerator : public PseudoRandomNumberGenerator {
         note = "[Online; accessed 10-May-2025]"
     } */
 
-    static constexpr uint64_t DefaultModulus = 0x7FFFFFFF;      
+    static constexpr uint64_t DefaultModulus = 0x7FFFFFFF;
     static constexpr uint64_t DefaultMultiplier = 1103515245;
     static constexpr uint64_t DefaultIncrement = 12345;
-    static constexpr uint64_t DefaultMask = 0x7FFFFFFF;          // bits 0 through 30
+    static constexpr uint64_t DefaultMask = 0x7FFFFFFF; // bits 0 through 30
 
     const uint64_t m_modulus;
     const uint64_t m_multiplier;
     const uint64_t m_increment;
     const uint64_t m_mask;
-    uint64_t m_current_value = 0; 
-
+    uint64_t m_current_value = 0;
 
     static uint64_t getMinimumValue(const std::uint64_t mask);
     static uint64_t getMaximumValue(const uint64_t modulus, const uint64_t mask);

diff --git a/include/mersenne_twister.hpp b/include/mersenne_twister.hpp
@@ -1,14 +1,13 @@
 #ifndef MERSENNE_TWISTER_H
 #define MERSENNE_TWISTER_H
 
+#include "prng.hpp"
 #include <cstdint>
 #include <vector>
-#include "prng.hpp"
 
 class MersenneTwister : public PseudoRandomNumberGenerator {
 
 private:
-
     /* MT19937-64 coefficients:
     w = 64 , word size in bits
     n = 312, degree of recurrence
@@ -45,7 +44,7 @@ class MersenneTwister : public PseudoRandomNumberGenerator {
     static constexpr uint64_t Default_c = 0xfff7eee000000000;
     static constexpr uint64_t Default_l = 43;
     static constexpr uint64_t Default_f = 6364136223846793005;
-    
+
     // word size
     int m_w;
 
@@ -89,7 +88,6 @@ class MersenneTwister : public PseudoRandomNumberGenerator {
     uint64_t m_lower_bit_mask;
     std::vector<uint64_t> m_recurrence_state;
     int m_state_index = 0;
-
 
     std::vector<uint64_t> initializeRecurrenceState(const uint64_t seed) const;
     uint64_t generateNextStateValue();

diff --git a/include/prng.hpp b/include/prng.hpp
@@ -3,27 +3,25 @@
 
 #include <cstdint>
 
-class PseudoRandomNumberGenerator 
-{
-    protected:
-        const uint64_t m_seed;
-        const uint64_t m_minimum_value;
-        const uint64_t m_maximum_value;
+class PseudoRandomNumberGenerator {
+protected:
+    const uint64_t m_seed;
+    const uint64_t m_minimum_value;
+    const uint64_t m_maximum_value;
 
+public:
+    PseudoRandomNumberGenerator();
+    PseudoRandomNumberGenerator(const uint64_t seed);
+    PseudoRandomNumberGenerator(const uint64_t minimum_value, const uint64_t maximum_value);
+    PseudoRandomNumberGenerator(const uint64_t seed, const uint64_t minimum_value, const uint64_t maximum_value);
+    virtual ~PseudoRandomNumberGenerator() { }
 
-    public:
-        PseudoRandomNumberGenerator();
-        PseudoRandomNumberGenerator(const uint64_t seed);
-        PseudoRandomNumberGenerator(const uint64_t minimum_value, const uint64_t maximum_value);
-        PseudoRandomNumberGenerator(const uint64_t seed, const uint64_t minimum_value, const uint64_t maximum_value);
-        virtual ~PseudoRandomNumberGenerator() {}
+    static uint64_t generateCryptographicallyInsecureSeed();
 
-        static uint64_t generateCryptographicallyInsecureSeed();
-
-        virtual uint64_t generateRandomValue() = 0;
-        double generateUnitNormalRandomValue();
-        double generateFloatingPointRandomValue(float min, float max);
-        int64_t generateIntegerRandomValue(int32_t min, int32_t max);
+    virtual uint64_t generateRandomValue() = 0;
+    double generateUnitNormalRandomValue();
+    double generateFloatingPointRandomValue(float min, float max);
+    int64_t generateIntegerRandomValue(int32_t min, int32_t max);
 };
 
 #endif
diff --git a/include/program_runner.hpp b/include/program_runner.hpp
@@ -1,18 +1,18 @@
 #ifndef PROGRAM_RUNNER_H
 #define PROGRAM_RUNNER_H
 
+#include "prng.hpp"
 #include <cstdint>
-#include <iostream>
 #include <cstdlib>
-#include <optional>
-#include <variant>
+#include <iostream>
 #include <map>
 #include <memory>
-#include "prng.hpp"
+#include <optional>
+#include <variant>
 
-class ProgramRunner {   
+class ProgramRunner {
 public:
-    ProgramRunner(int argc, char **argv, uint64_t warmup_iterations = 0);
+    ProgramRunner(int argc, char** argv, uint64_t warmup_iterations = 0);
 
     struct ProgramStatus {
         std::optional<std::string> stdout_message;
@@ -33,12 +33,7 @@ class ProgramRunner {
     const std::string version = "0.1";
     const std::string program_name = "randomizer";
 
-
-
-
-
 private:
-
     enum class Algorithm {
         XORShift,
         LinearCongruentialGenerator,
@@ -47,17 +42,15 @@ class ProgramRunner {
     };
 
     const std::map<std::string, Algorithm> algorithm_choices {
-        {"xorshift", Algorithm::XORShift},
-        {"xor", Algorithm::XORShift},
-        {"linear-congruential-generator", Algorithm::LinearCongruentialGenerator},
-        {"lcg", Algorithm::LinearCongruentialGenerator},
-        {"mersenne", Algorithm::MersenneTwister},
-        {"mersenne-twister", Algorithm::MersenneTwister},
-        {"mt", Algorithm::MersenneTwister}
+        { "xorshift", Algorithm::XORShift },
+        { "xor", Algorithm::XORShift },
+        { "linear-congruential-generator", Algorithm::LinearCongruentialGenerator },
+        { "lcg", Algorithm::LinearCongruentialGenerator },
+        { "mersenne", Algorithm::MersenneTwister },
+        { "mersenne-twister", Algorithm::MersenneTwister },
+        { "mt", Algorithm::MersenneTwister }
     };
 
-
-
     enum class ProgramBehaviour {
         Error,
         Help,
@@ -68,16 +61,16 @@ class ProgramRunner {
     };
 
     const std::map<std::string, ProgramBehaviour> generation_types {
-        {"unit", ProgramBehaviour::GenerateUnitNormal},
-        {"normal", ProgramBehaviour::GenerateUnitNormal},
-        {"unit-normal", ProgramBehaviour::GenerateUnitNormal},
-        {"normalized", ProgramBehaviour::GenerateUnitNormal},
-        {"float", ProgramBehaviour::GenerateFloating},
-        {"floating", ProgramBehaviour::GenerateFloating},
-        {"decimal", ProgramBehaviour::GenerateFloating},
-        {"floating-point", ProgramBehaviour::GenerateFloating},
-        {"int", ProgramBehaviour::GenerateInteger},
-        {"integer", ProgramBehaviour::GenerateInteger}
+        { "unit", ProgramBehaviour::GenerateUnitNormal },
+        { "normal", ProgramBehaviour::GenerateUnitNormal },
+        { "unit-normal", ProgramBehaviour::GenerateUnitNormal },
+        { "normalized", ProgramBehaviour::GenerateUnitNormal },
+        { "float", ProgramBehaviour::GenerateFloating },
+        { "floating", ProgramBehaviour::GenerateFloating },
+        { "decimal", ProgramBehaviour::GenerateFloating },
+        { "floating-point", ProgramBehaviour::GenerateFloating },
+        { "int", ProgramBehaviour::GenerateInteger },
+        { "integer", ProgramBehaviour::GenerateInteger }
     };
 
     struct RawArguments {
@@ -96,23 +89,21 @@ class ProgramRunner {
         std::optional<std::string> count_str;
     };
 
-
     // Defaults
 
     static constexpr uint32_t DefaultCount = 1;
     static constexpr ProgramBehaviour DefaultGenerationType = ProgramBehaviour::GenerateInteger;
 
-    static RawArguments parse_args(int argc, char **argv);
-    void determine_program_configuration(const RawArguments &raw_args);
-    void determine_user_message_configuration(const bool error, const bool show_version, const bool show_help);
-    void determine_generation_range_configuration(const std::optional<std::string> &min_str, const std::optional<std::string> &max_str);
-    void determine_generation_type_configuration(const std::optional<std::string> &generation_type);
-    void determine_count_configuration(const std::optional<std::string> &count_str);
-    void determine_algorithm_configuration(const std::optional<std::string> &alg_str);
+    static RawArguments parse_args(int argc, char** argv);
+    void determine_program_configuration(RawArguments const& raw_args);
+    void determine_user_message_configuration(bool const error, bool const show_version, bool const show_help);
+    void determine_generation_range_configuration(std::optional<std::string> const& min_str, std::optional<std::string> const& max_str);
+    void determine_generation_type_configuration(std::optional<std::string> const& generation_type);
+    void determine_count_configuration(std::optional<std::string> const& count_str);
+    void determine_algorithm_configuration(std::optional<std::string> const& alg_str);
     void create_prng();
     void warmup(uint64_t iterations);
 
-
     std::string error_string();
     std::string help_string();
     std::string version_string();
@@ -131,9 +122,6 @@ class ProgramRunner {
     // Exit codes
     static constexpr int ExitCodeSuccess = 0;
     static constexpr int ExitCodeError = 1;
-
-
-
 };
 
 #endif
diff --git a/include/xorshift.hpp b/include/xorshift.hpp
@@ -1,38 +1,35 @@
 #ifndef XOR_SHIFT_H
 #define XOR_SHIFT_H
 
-#include <cstdint>
 #include "prng.hpp"
+#include <cstdint>
 
 class XORShift : public PseudoRandomNumberGenerator {
 
-//     @misc{ enwiki:1287473197,
-//     author = "{Wikipedia contributors}",
-//     title = "Xorshift --- {Wikipedia}{,} The Free Encyclopedia",
-//     year = "2025",
-//     url = "https://en.wikipedia.org/w/index.php?title=Xorshift&oldid=1287473197",
-//     note = "[Online; accessed 11-May-2025]"
-//   }
+    //     @misc{ enwiki:1287473197,
+    //     author = "{Wikipedia contributors}",
+    //     title = "Xorshift --- {Wikipedia}{,} The Free Encyclopedia",
+    //     year = "2025",
+    //     url = "https://en.wikipedia.org/w/index.php?title=Xorshift&oldid=1287473197",
+    //     note = "[Online; accessed 11-May-2025]"
+    //   }
 private:
-
-
     // Default values from https://en.wikipedia.org/wiki/Xorshift
-    static constexpr uint64_t DefaultA = 13;      
+    static constexpr uint64_t DefaultA = 13;
     static constexpr uint64_t DefaultB = 7;
     static constexpr uint64_t DefaultC = 17;
 
     // XORShift has 3 constants that are used for shifting
     const uint64_t m_a;
     const uint64_t m_b;
     const uint64_t m_c;
-    uint64_t m_current_value = 0; 
+    uint64_t m_current_value = 0;
 
 public:
     XORShift();
     XORShift(const uint64_t seed);
     XORShift(const uint64_t seed, const uint64_t a, const uint64_t b, const uint64_t c);
 
-
     uint64_t generateRandomValue() override;
 };
 

diff --git a/src/main.cpp b/src/main.cpp
@@ -1,11 +1,12 @@
-#include <iostream>
-#include <getopt.h>
-#include "prng.hpp"
 #include "linear_congruential_generator.hpp"
-#include "xorshift.hpp"
+#include "prng.hpp"
 #include "program_runner.hpp"
+#include "xorshift.hpp"
+#include <getopt.h>
+#include <iostream>
 
-int main(int argc, char *argv[]){
+int main(int argc, char* argv[])
+{
     ProgramRunner runner = ProgramRunner(argc, argv, 1000);
     ProgramRunner::ProgramStatus status;
     while (!runner.is_finished()) {