From 13d687bca9c24d838563f5b48fb3c2091e8b9b9e Mon Sep 17 00:00:00 2001
From: Nick Le Large <nick.lelarge@kit.edu>
Date: Mon, 8 Apr 2024 13:55:05 +0200
Subject: [PATCH 1/6] Add random arbitrator and corresponding unit test

---
 .../internal/random_arbitrator_io.hpp         |  38 ++++
 .../arbitration_graphs/random_arbitrator.hpp  | 115 ++++++++++
 test/random_arbitrator.cpp                    | 207 ++++++++++++++++++
 3 files changed, 360 insertions(+)
 create mode 100644 include/arbitration_graphs/internal/random_arbitrator_io.hpp
 create mode 100644 include/arbitration_graphs/random_arbitrator.hpp
 create mode 100644 test/random_arbitrator.cpp

diff --git a/include/arbitration_graphs/internal/random_arbitrator_io.hpp b/include/arbitration_graphs/internal/random_arbitrator_io.hpp
new file mode 100644
index 0000000..b6e9127
--- /dev/null
+++ b/include/arbitration_graphs/internal/random_arbitrator_io.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "../random_arbitrator.hpp"
+
+
+namespace arbitration_graphs {
+
+
+//////////////////////////////////////
+//    RandomArbitrator::Option    //
+//////////////////////////////////////
+
+template <typename CommandT, typename SubCommandT, typename VerifierT, typename VerificationResultT>
+std::ostream& RandomArbitrator<CommandT, SubCommandT, VerifierT, VerificationResultT>::Option::to_stream(
+    std::ostream& output,
+    const Time& time,
+    const int& option_index,
+    const std::string& prefix,
+    const std::string& suffix) const {
+
+    output << option_index + 1 << ". ";
+    ArbitratorBase::Option::to_stream(output, time, option_index, prefix, suffix);
+    return output;
+}
+
+
+//////////////////////////////////////
+//        RandomArbitrator        //
+//////////////////////////////////////
+
+template <typename CommandT, typename SubCommandT, typename VerifierT, typename VerificationResultT>
+YAML::Node RandomArbitrator<CommandT, SubCommandT, VerifierT, VerificationResultT>::toYaml(const Time& time) const {
+    YAML::Node node = ArbitratorBase::toYaml(time);
+    node["type"] = "RandomArbitrator";
+    return node;
+}
+
+} // namespace arbitration_graphs
diff --git a/include/arbitration_graphs/random_arbitrator.hpp b/include/arbitration_graphs/random_arbitrator.hpp
new file mode 100644
index 0000000..d558578
--- /dev/null
+++ b/include/arbitration_graphs/random_arbitrator.hpp
@@ -0,0 +1,115 @@
+#pragma once
+
+#include <memory>
+#include <random>
+
+#include <yaml-cpp/yaml.h>
+
+#include "arbitrator.hpp"
+
+namespace arbitration_graphs {
+
+template <typename CommandT,
+          typename SubCommandT = CommandT,
+          typename VerifierT = verification::PlaceboVerifier<SubCommandT>,
+          typename VerificationResultT = typename decltype(std::function{VerifierT::analyze})::result_type>
+class RandomArbitrator : public Arbitrator<CommandT, SubCommandT, VerifierT, VerificationResultT> {
+public:
+    using ArbitratorBase = Arbitrator<CommandT, SubCommandT, VerifierT, VerificationResultT>;
+
+    using Ptr = std::shared_ptr<RandomArbitrator>;
+    using ConstPtr = std::shared_ptr<const RandomArbitrator>;
+
+    struct Option : public ArbitratorBase::Option {
+    public:
+        using Ptr = std::shared_ptr<Option>;
+        using FlagsT = typename ArbitratorBase::Option::FlagsT;
+        using ConstPtr = std::shared_ptr<const Option>;
+
+        enum Flags { NO_FLAGS = 0b0, INTERRUPTABLE = 0b1, FALLBACK = 0b10 };
+
+        Option(const typename Behavior<SubCommandT>::Ptr& behavior, const FlagsT& flags, const double& weight)
+                : ArbitratorBase::Option(behavior, flags), weight_(weight) {
+        }
+
+        /*!
+         * \brief Writes a string representation of the behavior option and its
+         * current state to the output stream.
+         *
+         * \param output        Output stream to write into, will be returned also
+         * \param time          Expected execution time point of this behaviors command
+         * \param option_index  Position index of this option within behaviorOptions_
+         * \param prefix        A string that should be prepended to each line that is written to the output stream
+         * \param suffix        A string that should be appended to each line that is written to the output stream
+         * \return              The same given input stream (signature similar to std::ostream& operator<<())
+         *
+         * \see Arbitrator::to_stream()
+         */
+        virtual std::ostream& to_stream(std::ostream& output,
+                                        const Time& time,
+                                        const int& option_index,
+                                        const std::string& prefix = "",
+                                        const std::string& suffix = "") const;
+
+        double weight_;
+    };
+    using Options = std::vector<typename Option::Ptr>;
+
+    RandomArbitrator(const std::string& name = "RandomArbitrator", const VerifierT& verifier = VerifierT())
+            : ArbitratorBase(name, verifier){};
+
+    void addOption(const typename Behavior<SubCommandT>::Ptr& behavior,
+                   const typename Option::FlagsT& flags,
+                   const double& weight = 1) {
+        typename Option::Ptr option = std::make_shared<Option>(behavior, flags, weight);
+        this->behaviorOptions_.push_back(option);
+    }
+
+    /*!
+     * \brief Returns a yaml representation of the arbitrator object with its current state
+     *
+     * \param time  Expected execution time point of this behaviors command
+     * \return      Yaml representation of this behavior
+     */
+    virtual YAML::Node toYaml(const Time& time) const override;
+
+protected:
+    /*!
+     * @brief   Sort behavior options randomly considering their respective weights
+     *
+     * @return  Behavior options sorted randomly considering their respective weights
+     */
+    typename ArbitratorBase::Options sortOptionsByGivenPolicy(const typename ArbitratorBase::Options& options,
+                                                              const Time& time) const override {
+        return weightedShuffle(options);
+    }
+
+    static typename ArbitratorBase::Options weightedShuffle(const typename ArbitratorBase::Options& options) {
+        typename ArbitratorBase::Options shuffledOptions;
+        shuffledOptions.reserve(options.size());
+
+        std::vector<double> weights;
+        weights.reserve(options.size());
+        for (const auto& optionBase : options) {
+            typename Option::Ptr option = std::dynamic_pointer_cast<Option>(optionBase);
+            weights.push_back(option->weight_);
+        }
+
+        std::random_device randomDevice;
+        std::mt19937 randomGenerator(randomDevice());
+
+        while (!weights.empty()) {
+            std::discrete_distribution<int> discreteDistribution(weights.begin(), weights.end());
+            auto index = discreteDistribution(randomGenerator);
+
+            shuffledOptions.push_back(options.at(index));
+            weights.erase(weights.begin() + index);
+        }
+
+        return shuffledOptions;
+    }
+
+}; // namespace arbitration_graphs
+} // namespace arbitration_graphs
+
+#include "internal/random_arbitrator_io.hpp"
diff --git a/test/random_arbitrator.cpp b/test/random_arbitrator.cpp
new file mode 100644
index 0000000..90c10b5
--- /dev/null
+++ b/test/random_arbitrator.cpp
@@ -0,0 +1,207 @@
+// google test docs
+// wiki page: https://code.google.com/p/googletest/w/list
+// primer: https://code.google.com/p/googletest/wiki/V1_7_Primer
+// FAQ: https://code.google.com/p/googletest/wiki/FAQ
+// advanced guide: https://code.google.com/p/googletest/wiki/V1_7_AdvancedGuide
+// samples: https://code.google.com/p/googletest/wiki/V1_7_Samples
+//
+// List of some basic tests fuctions:
+// Fatal assertion                      Nonfatal assertion Verifies /
+// Description
+//-------------------------------------------------------------------------------------------------------------------------------------------------------
+// ASSERT_EQ(expected, actual);         EXPECT_EQ(expected, actual); expected ==
+// actual ASSERT_NE(val1, val2);               EXPECT_NE(val1, val2); val1 !=
+// val2 ASSERT_LT(val1, val2);               EXPECT_LT(val1, val2); val1 < val2
+// ASSERT_LE(val1, val2);               EXPECT_LE(val1, val2); val1 <= val2
+// ASSERT_GT(val1, val2);               EXPECT_GT(val1, val2); val1 > val2
+// ASSERT_GE(val1, val2);               EXPECT_GE(val1, val2); val1 >= val2
+//
+// ASSERT_FLOAT_EQ(expected, actual);   EXPECT_FLOAT_EQ(expected, actual);   the
+// two float values are almost equal (4 ULPs) ASSERT_DOUBLE_EQ(expected,
+// actual); EXPECT_DOUBLE_EQ(expected, actual);  the two double values are
+// almost equal (4 ULPs) ASSERT_NEAR(val1, val2, abs_error);  EXPECT_NEAR(val1,
+// val2, abs_error); the difference between val1 and val2 doesn't exceed the
+// given absolute error
+//
+// Note: more information about ULPs can be found here:
+// http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
+//
+// Example of two unit test:
+// TEST(Math, Add) {
+//    ASSERT_EQ(10, 5+ 5);
+//}
+//
+// TEST(Math, Float) {
+//	  ASSERT_FLOAT_EQ((10.0f + 2.0f) * 3.0f, 10.0f * 3.0f + 2.0f * 3.0f)
+//}
+//=======================================================================================================================================================
+#include <map>
+#include <memory>
+#include <string>
+#include "gtest/gtest.h"
+
+#include "behavior.hpp"
+#include "random_arbitrator.hpp"
+
+#include "dummy_types.hpp"
+
+
+using namespace arbitration_graphs;
+using namespace arbitration_graphs_tests;
+
+
+class RandomArbitratorTest : public ::testing::Test {
+protected:
+    using OptionFlags = RandomArbitrator<DummyCommand>::Option::Flags;
+
+    DummyBehavior::Ptr testBehaviorUnavailable = std::make_shared<DummyBehavior>(false, false, "Unavailable");
+    DummyBehavior::Ptr testBehaviorHighWeight = std::make_shared<DummyBehavior>(true, false, "HighWeight");
+    DummyBehavior::Ptr testBehaviorMidWeight = std::make_shared<DummyBehavior>(true, false, "MidWeight");
+    DummyBehavior::Ptr testBehaviorLowWeight = std::make_shared<DummyBehavior>(true, false, "LowWeight");
+
+
+    RandomArbitrator<DummyCommand> testRandomArbitrator;
+
+    Time time{Clock::now()};
+};
+
+
+TEST_F(RandomArbitratorTest, BasicFunctionality) {
+    // if there are no options yet -> the invocationCondition should be false
+    EXPECT_FALSE(testRandomArbitrator.checkInvocationCondition(time));
+    EXPECT_FALSE(testRandomArbitrator.checkCommitmentCondition(time));
+
+    // otherwise the invocationCondition is true if any of the option has true invocationCondition
+    testRandomArbitrator.addOption(testBehaviorUnavailable, OptionFlags::NO_FLAGS);
+    EXPECT_FALSE(testRandomArbitrator.checkInvocationCondition(time));
+    EXPECT_FALSE(testRandomArbitrator.checkCommitmentCondition(time));
+
+    testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS, 2.5);
+    testRandomArbitrator.addOption(testBehaviorMidWeight, OptionFlags::NO_FLAGS);
+    testRandomArbitrator.addOption(testBehaviorLowWeight, OptionFlags::NO_FLAGS, 0.5);
+    double weightSumOfAvailableOptions = 2.5 + 1.0 + 0.5;
+
+    EXPECT_TRUE(testRandomArbitrator.checkInvocationCondition(time));
+    EXPECT_FALSE(testRandomArbitrator.checkCommitmentCondition(time));
+
+    testRandomArbitrator.gainControl(time);
+
+    int sampleSize = 1000;
+    std::map<std::string, int> commandCounter{
+        {"Unavailable", 0}, {"HighWeight", 0}, {"MidWeight", 0}, {"LowWeight", 0}};
+
+    for (int i = 0; i < sampleSize; i++) {
+        std::string command = testRandomArbitrator.getCommand(time);
+        commandCounter[command]++;
+    }
+
+    EXPECT_EQ(0, commandCounter["Unavailable"]);
+    EXPECT_NEAR(2.5 / weightSumOfAvailableOptions, commandCounter["HighWeight"] / static_cast<double>(sampleSize), 0.1);
+    EXPECT_NEAR(1.0 / weightSumOfAvailableOptions, commandCounter["MidWeight"] / static_cast<double>(sampleSize), 0.1);
+    EXPECT_NEAR(0.5 / weightSumOfAvailableOptions, commandCounter["LowWeight"] / static_cast<double>(sampleSize), 0.1);
+}
+
+TEST_F(RandomArbitratorTest, Printout) {
+    // Force midWeight behavior by setting all applicable behavior's weights to 0
+    testRandomArbitrator.addOption(testBehaviorUnavailable, OptionFlags::NO_FLAGS);
+    testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS, 0);
+    testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS, 0);
+    testRandomArbitrator.addOption(testBehaviorMidWeight, OptionFlags::NO_FLAGS);
+    testRandomArbitrator.addOption(testBehaviorLowWeight, OptionFlags::NO_FLAGS, 0);
+
+    // clang-format off
+    std::string expected_printout = invocationTrueString + commitmentFalseString + "RandomArbitrator\n"
+                                    "    1. " + invocationFalseString + commitmentFalseString + "Unavailable\n"
+                                    "    2. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                                    "    3. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                                    "    4. " + invocationTrueString + commitmentFalseString + "MidWeight\n"
+                                    "    5. " + invocationTrueString + commitmentFalseString + "LowWeight";
+    // clang-format on
+    std::string actual_printout = testRandomArbitrator.to_str(time);
+    std::cout << actual_printout << std::endl;
+
+    EXPECT_EQ(expected_printout, actual_printout);
+
+
+    testRandomArbitrator.gainControl(time);
+    EXPECT_EQ("MidWeight", testRandomArbitrator.getCommand(time));
+
+    // clang-format off
+    expected_printout = invocationTrueString + commitmentTrueString + "RandomArbitrator\n"
+                        "    1. " + invocationFalseString + commitmentFalseString + "Unavailable\n"
+                        "    2. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                        "    3. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                        " -> 4. " + invocationTrueString + commitmentFalseString + "MidWeight\n"
+                        "    5. " + invocationTrueString + commitmentFalseString + "LowWeight";
+    // clang-format on
+    actual_printout = testRandomArbitrator.to_str(time);
+    std::cout << actual_printout << std::endl;
+
+    EXPECT_EQ(expected_printout, actual_printout);
+}
+
+TEST_F(RandomArbitratorTest, ToYaml) {
+    testRandomArbitrator.addOption(testBehaviorUnavailable, OptionFlags::NO_FLAGS);
+    testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS, 0);
+    testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS, 0);
+    testRandomArbitrator.addOption(testBehaviorMidWeight, OptionFlags::INTERRUPTABLE);
+    testRandomArbitrator.addOption(testBehaviorLowWeight, OptionFlags::NO_FLAGS, 0);
+
+    YAML::Node yaml = testRandomArbitrator.toYaml(time);
+
+    EXPECT_EQ("RandomArbitrator", yaml["type"].as<std::string>());
+    EXPECT_EQ("RandomArbitrator", yaml["name"].as<std::string>());
+    EXPECT_EQ(true, yaml["invocationCondition"].as<bool>());
+    EXPECT_EQ(false, yaml["commitmentCondition"].as<bool>());
+
+    ASSERT_EQ(5, yaml["options"].size());
+    EXPECT_EQ("Option", yaml["options"][0]["type"].as<std::string>());
+    EXPECT_EQ("Option", yaml["options"][1]["type"].as<std::string>());
+    EXPECT_EQ("Option", yaml["options"][2]["type"].as<std::string>());
+    EXPECT_EQ("Option", yaml["options"][3]["type"].as<std::string>());
+    EXPECT_EQ("Option", yaml["options"][4]["type"].as<std::string>());
+    EXPECT_EQ("Unavailable", yaml["options"][0]["behavior"]["name"].as<std::string>());
+    EXPECT_EQ("HighWeight", yaml["options"][1]["behavior"]["name"].as<std::string>());
+    EXPECT_EQ("HighWeight", yaml["options"][2]["behavior"]["name"].as<std::string>());
+    EXPECT_EQ("MidWeight", yaml["options"][3]["behavior"]["name"].as<std::string>());
+    EXPECT_EQ("LowWeight", yaml["options"][4]["behavior"]["name"].as<std::string>());
+    EXPECT_EQ(false, yaml["options"][0]["flags"].IsDefined());
+    EXPECT_EQ(false, yaml["options"][1]["flags"].IsDefined());
+    EXPECT_EQ(false, yaml["options"][2]["flags"].IsDefined());
+    ASSERT_EQ(true, yaml["options"][3]["flags"].IsDefined());
+    EXPECT_EQ(false, yaml["options"][4]["flags"].IsDefined());
+
+    EXPECT_EQ(false, yaml["activeBehavior"].IsDefined());
+
+    testRandomArbitrator.gainControl(time);
+    testRandomArbitrator.getCommand(time);
+
+    yaml = testRandomArbitrator.toYaml(time);
+
+    EXPECT_EQ(true, yaml["invocationCondition"].as<bool>());
+    EXPECT_EQ(true, yaml["commitmentCondition"].as<bool>());
+
+    ASSERT_EQ(true, yaml["activeBehavior"].IsDefined());
+    EXPECT_EQ(3, yaml["activeBehavior"].as<int>());
+}
+
+TEST(PriorityArbitrator, SubCommandTypeDiffersFromCommandType) {
+    Time time{Clock::now()};
+
+    using OptionFlags = RandomArbitrator<DummyCommandInt, DummyCommand>::Option::Flags;
+
+    DummyBehavior::Ptr testBehaviorHighWeight = std::make_shared<DummyBehavior>(false, false, "___HighWeight___");
+    DummyBehavior::Ptr testBehaviorMidWeight = std::make_shared<DummyBehavior>(true, false, "__MidWeight__");
+    DummyBehavior::Ptr testBehaviorLowWeight = std::make_shared<DummyBehavior>(true, true, "_LowWeight_");
+
+    RandomArbitrator<DummyCommandInt, DummyCommand> testRandomArbitrator;
+
+    testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS);
+    testRandomArbitrator.addOption(testBehaviorMidWeight, OptionFlags::NO_FLAGS);
+    testRandomArbitrator.addOption(testBehaviorLowWeight, OptionFlags::NO_FLAGS, 0);
+
+    testRandomArbitrator.gainControl(time);
+
+    std::string expected = "__MidWeight__";
+    EXPECT_EQ(expected.length(), testRandomArbitrator.getCommand(time));
+}

From 3a59ff052a45baecea96c2b3314c21c24e0ac681 Mon Sep 17 00:00:00 2001
From: ll-nick <68419636+ll-nick@users.noreply.github.com>
Date: Mon, 22 Apr 2024 11:57:11 +0200
Subject: [PATCH 2/6] Use consistent doxygen tags

As we say in Germany: Ordnung muss sein!

Co-authored-by: Piotr Spieker <orzechow@posteo.de>
---
 include/arbitration_graphs/random_arbitrator.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/arbitration_graphs/random_arbitrator.hpp b/include/arbitration_graphs/random_arbitrator.hpp
index d558578..ab86889 100644
--- a/include/arbitration_graphs/random_arbitrator.hpp
+++ b/include/arbitration_graphs/random_arbitrator.hpp
@@ -75,9 +75,9 @@ class RandomArbitrator : public Arbitrator<CommandT, SubCommandT, VerifierT, Ver
 
 protected:
     /*!
-     * @brief   Sort behavior options randomly considering their respective weights
+     * \brief   Sort behavior options randomly considering their respective weights
      *
-     * @return  Behavior options sorted randomly considering their respective weights
+     * \return  Behavior options sorted randomly considering their respective weights
      */
     typename ArbitratorBase::Options sortOptionsByGivenPolicy(const typename ArbitratorBase::Options& options,
                                                               const Time& time) const override {

From 888b796cd642271b211a1056ae6a1b759132958f Mon Sep 17 00:00:00 2001
From: ll-nick <68419636+ll-nick@users.noreply.github.com>
Date: Mon, 22 Apr 2024 13:34:25 +0200
Subject: [PATCH 3/6] Add the weight of the option to the formatted output

Co-authored-by: Piotr Spieker <orzechow@posteo.de>

Adjust expected printout to new format in unit test.
---
 .../internal/random_arbitrator_io.hpp         |  2 +-
 test/random_arbitrator.cpp                    | 22 +++++++++----------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/include/arbitration_graphs/internal/random_arbitrator_io.hpp b/include/arbitration_graphs/internal/random_arbitrator_io.hpp
index b6e9127..587ba3e 100644
--- a/include/arbitration_graphs/internal/random_arbitrator_io.hpp
+++ b/include/arbitration_graphs/internal/random_arbitrator_io.hpp
@@ -18,7 +18,7 @@ std::ostream& RandomArbitrator<CommandT, SubCommandT, VerifierT, VerificationRes
     const std::string& prefix,
     const std::string& suffix) const {
 
-    output << option_index + 1 << ". ";
+    output << std::fixed << std::setprecision(3) << "- (weight: " << weight_ << ") ";
     ArbitratorBase::Option::to_stream(output, time, option_index, prefix, suffix);
     return output;
 }
diff --git a/test/random_arbitrator.cpp b/test/random_arbitrator.cpp
index 90c10b5..a75603d 100644
--- a/test/random_arbitrator.cpp
+++ b/test/random_arbitrator.cpp
@@ -106,16 +106,16 @@ TEST_F(RandomArbitratorTest, Printout) {
     testRandomArbitrator.addOption(testBehaviorUnavailable, OptionFlags::NO_FLAGS);
     testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS, 0);
     testRandomArbitrator.addOption(testBehaviorHighWeight, OptionFlags::NO_FLAGS, 0);
-    testRandomArbitrator.addOption(testBehaviorMidWeight, OptionFlags::NO_FLAGS);
+    testRandomArbitrator.addOption(testBehaviorMidWeight, OptionFlags::NO_FLAGS, 2.5);
     testRandomArbitrator.addOption(testBehaviorLowWeight, OptionFlags::NO_FLAGS, 0);
 
     // clang-format off
     std::string expected_printout = invocationTrueString + commitmentFalseString + "RandomArbitrator\n"
-                                    "    1. " + invocationFalseString + commitmentFalseString + "Unavailable\n"
-                                    "    2. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
-                                    "    3. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
-                                    "    4. " + invocationTrueString + commitmentFalseString + "MidWeight\n"
-                                    "    5. " + invocationTrueString + commitmentFalseString + "LowWeight";
+                                    "    - (weight: 1.000) " + invocationFalseString + commitmentFalseString + "Unavailable\n"
+                                    "    - (weight: 0.000) " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                                    "    - (weight: 0.000) " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                                    "    - (weight: 2.500) " + invocationTrueString + commitmentFalseString + "MidWeight\n"
+                                    "    - (weight: 0.000) " + invocationTrueString + commitmentFalseString + "LowWeight";
     // clang-format on
     std::string actual_printout = testRandomArbitrator.to_str(time);
     std::cout << actual_printout << std::endl;
@@ -128,11 +128,11 @@ TEST_F(RandomArbitratorTest, Printout) {
 
     // clang-format off
     expected_printout = invocationTrueString + commitmentTrueString + "RandomArbitrator\n"
-                        "    1. " + invocationFalseString + commitmentFalseString + "Unavailable\n"
-                        "    2. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
-                        "    3. " + invocationTrueString + commitmentFalseString + "HighWeight\n"
-                        " -> 4. " + invocationTrueString + commitmentFalseString + "MidWeight\n"
-                        "    5. " + invocationTrueString + commitmentFalseString + "LowWeight";
+                        "    - (weight: 1.000) " + invocationFalseString + commitmentFalseString + "Unavailable\n"
+                        "    - (weight: 0.000) " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                        "    - (weight: 0.000) " + invocationTrueString + commitmentFalseString + "HighWeight\n"
+                        " -> - (weight: 2.500) " + invocationTrueString + commitmentFalseString + "MidWeight\n"
+                        "    - (weight: 0.000) " + invocationTrueString + commitmentFalseString + "LowWeight";
     // clang-format on
     actual_printout = testRandomArbitrator.to_str(time);
     std::cout << actual_printout << std::endl;

From 2e319790413f91c857f97a4f98a805796fdbc57c Mon Sep 17 00:00:00 2001
From: Nick Le Large <nick.lelarge@kit.edu>
Date: Mon, 22 Apr 2024 11:07:46 +0000
Subject: [PATCH 4/6] Add documentation about weight_ parameter.

---
 include/arbitration_graphs/random_arbitrator.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/arbitration_graphs/random_arbitrator.hpp b/include/arbitration_graphs/random_arbitrator.hpp
index ab86889..c9af152 100644
--- a/include/arbitration_graphs/random_arbitrator.hpp
+++ b/include/arbitration_graphs/random_arbitrator.hpp
@@ -51,6 +51,7 @@ class RandomArbitrator : public Arbitrator<CommandT, SubCommandT, VerifierT, Ver
                                         const std::string& prefix = "",
                                         const std::string& suffix = "") const;
 
+        //! The option has a chance of weight_ divided by the sum of all options' weights to be selected.
         double weight_;
     };
     using Options = std::vector<typename Option::Ptr>;

From 7006a9e2e85b8083898bb726aea5c676c72b7962 Mon Sep 17 00:00:00 2001
From: Nick Le Large <nick.lelarge@kit.edu>
Date: Mon, 22 Apr 2024 11:30:56 +0000
Subject: [PATCH 5/6] Merge weightedShuffle and sortOpionsByGivenPolicy

---
 include/arbitration_graphs/random_arbitrator.hpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/include/arbitration_graphs/random_arbitrator.hpp b/include/arbitration_graphs/random_arbitrator.hpp
index c9af152..1e41aac 100644
--- a/include/arbitration_graphs/random_arbitrator.hpp
+++ b/include/arbitration_graphs/random_arbitrator.hpp
@@ -82,10 +82,6 @@ class RandomArbitrator : public Arbitrator<CommandT, SubCommandT, VerifierT, Ver
      */
     typename ArbitratorBase::Options sortOptionsByGivenPolicy(const typename ArbitratorBase::Options& options,
                                                               const Time& time) const override {
-        return weightedShuffle(options);
-    }
-
-    static typename ArbitratorBase::Options weightedShuffle(const typename ArbitratorBase::Options& options) {
         typename ArbitratorBase::Options shuffledOptions;
         shuffledOptions.reserve(options.size());
 

From 86946a71eb303cac0a2795004280d3e497ece5d4 Mon Sep 17 00:00:00 2001
From: Nick Le Large <nick.lelarge@kit.edu>
Date: Mon, 22 Apr 2024 11:31:16 +0000
Subject: [PATCH 6/6] Add explanatory comment about the weighted shuffle.

---
 include/arbitration_graphs/random_arbitrator.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/arbitration_graphs/random_arbitrator.hpp b/include/arbitration_graphs/random_arbitrator.hpp
index 1e41aac..918c41c 100644
--- a/include/arbitration_graphs/random_arbitrator.hpp
+++ b/include/arbitration_graphs/random_arbitrator.hpp
@@ -95,6 +95,7 @@ class RandomArbitrator : public Arbitrator<CommandT, SubCommandT, VerifierT, Ver
         std::random_device randomDevice;
         std::mt19937 randomGenerator(randomDevice());
 
+        // A weighted shuffle is equivalent to a weighted sampling of options without replacement.
         while (!weights.empty()) {
             std::discrete_distribution<int> discreteDistribution(weights.begin(), weights.end());
             auto index = discreteDistribution(randomGenerator);