diff --git a/include/rosa/agent/ReliabilityConfidenceCombination.h b/include/rosa/agent/ReliabilityConfidenceCombination.h
index 7a5a4d9..f81b02f 100644
--- a/include/rosa/agent/ReliabilityConfidenceCombination.h
+++ b/include/rosa/agent/ReliabilityConfidenceCombination.h
@@ -1,773 +1,771 @@
 //===-- rosa/agent/ReliabilityConfidenceCombination.h -----------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 // Distributed under the terms and conditions of the Boost Software License 1.0.
 // See accompanying file LICENSE.
 //
 // If you did not receive a copy of the license file, see
 // http://www.boost.org/LICENSE_1_0.txt.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/ReliabilityConfidenceCombination.h
 ///
 /// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief  Definition of *ReliabilityConfidenceCombination* *functionality*.
 ///
 /// \note based on Maximilian Goetzinger (maxgot@utu.fi) code in
 /// CAM_Dirty_include SA-EWS2_Version... inside Agent.cpp
 ///
 /// \note By defining and setting Reliability_trace_level it is possible to
 /// change the level to which it should be traced. \note All classes throw
 /// runtime errors if not all things are set
 ///
 /// \note should the Reliability be capped?
 ///
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_ReliabilityConfidenceCombination_H
 #define ROSA_AGENT_ReliabilityConfidenceCombination_H
 
 #include "rosa/core/forward_declarations.h" // needed for id_t
 #include "rosa/support/log.h"
 
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include "rosa/agent/Functionality.h"
 #include "rosa/agent/RangeConfidence.hpp"
 
 #include <algorithm>
 #include <functional>
 #include <type_traits>
 #include <vector>
 
 /// 0 everything
 /// 1 vectors
 /// 2 outputs
 #define trace_everything 0
 #define trace_vectors 1
 #define trace_outputs 2
 
 #ifndef Reliability_trace_level
 #define Reliability_trace_level 0
 #endif
 #define trace_end "\n\n\n"
 
 namespace rosa {
 namespace agent {
 /// This is a struct with a few methods that make Likeliness Combinator
 /// more readable \tparam IdentifierType The Data-type of the Identifiers
 /// \tparam LikelinessType The Data-type of the Likeliness \note this
 /// should/will be changed into a std::pair because it isn't needed anymore
 template <typename IdentifierType, typename LikelinessType> struct Symbol {
   /// making both Template Arguments readable to make a few things easier
   using _IdentifierType = IdentifierType;
   /// making both Template Arguments readable to make a few things easier
   using _LikelinessType = LikelinessType;
 
   /// The actual place where the data is stored
   IdentifierType Identifier;
   /// The actual place where the data is stored
   LikelinessType Likeliness;
 
   Symbol(IdentifierType _Identifier, LikelinessType _Likeliness)
       : Identifier(_Identifier), Likeliness(_Likeliness) {}
   Symbol() = default;
 
   /// Pushes the Data in a Human readable form
   /// \param out The stream where it is written to
   /// \param c The struct itself
   friend std::ostream &operator<<(std::ostream &out, const Symbol &c) {
     out << "Identifier: " << c.Identifier << "\t Likeliness: " << c.Likeliness
         << " ";
     return out;
   }
 
   /// needed or it throws an clang diagnosic error
   using map =
       std::map<IdentifierType, LikelinessType>; // needed or it throws an
                                                 // clang diagnosic error
   /// Filles the vector with the data inside the map
   /// \param me The vector to be filled
   /// \param data The data wich is to be pushed into the vector
   friend std::vector<Symbol> &operator<<(std::vector<Symbol> &me, map &&data) {
     for (auto tmp : data) {
       me.push_back(Symbol(tmp.first, tmp.second));
 #if Reliability_trace_level <= trace_everything
       LOG_TRACE_STREAM << "\n" << Symbol(tmp.first, tmp.second) << trace_end;
 #endif
     }
     return me;
   }
 
   /// This is to push the data inside a vector in a human readable way into the
   /// ostream \param out The ostream \param c The vector which is read
   friend std::ostream &operator<<(std::ostream &out,
                                   const std::vector<Symbol> &c) {
     std::size_t index = 0;
     for (Symbol data : c) {
       out << index << " : " << data << "\n";
       index++;
     }
     return out;
   }
 };
 
 /// This is the combinator for Reliability and confidences it takes the
 /// Value, its "History" and feedback from \c
 /// CrossCombinator to calculate different Reliabilities.
 /// \tparam ValueType Data-type of the Value	( Typically
 /// double or float) \tparam IdentifierType Data-type of the Identifier (
 /// Typically long or int)
 ///	\tparam ReliabilityType Data-type of the Reliability		(
 /// Typically double	or float)
 ///
 /// \note more information about how it calculates
 /// the Reliabilities it should be considered feedback is a sort of Confidence
 /// \verbatim
 ///----------------------------------------------------------------------------------
 ///
 ///
 ///                  ->AbsoluteReliabilityFunction---> getInputReliability()
 ///                  |             |
 ///                  |             V
 ///  Sensor Value ---|       ReliabilityAndConfidenceCombinator -> next line
 ///                  |             A					|
 ///                  |             |					V
 ///                  ->ConfidenceFunction
 ///                  getPossibleIdentifiers()
 ///
 ///-----------------------------------------------------------------------------------
 ///
 ///           feedback
 ///               |
 ///               V
 ///           FeedbackSymbols
 ///               |               -> History -------|
 ///               V               |                 V
 /// here -> LikelinessFeedbackCombinator
 /// ------>LikelinessHistoryCombinator->next line
 ///                   |                                   |
 ///                   V                                   V
 /// getpossibleIdentifiersWithMasterFeedback()      SymbolsWithHistory()
 ///
 ///----------------------------------------------------------------------------------
 ///
 /// here -> sort -> most likely -> bestSymbol()
 ///
 ///---------------------------------------------------------------------------------
 /// \endverbatim
 /// the mentioned methods are early outs so if two ore more of them are run in
 /// the same step they will be interpreted as different time steps
 /// <pre>
 /// Default values for Combinators:
 ///	AbsoluteAndSlopeReliabilityCombinationMethod		=
 /// combinationMin;
 ///	ReliabilityAndConfidenceCombinator=ReliabilityAndConfidenceCombinatorMin;
 /// LikelinessFeedbackCombinator		=
 /// LikelinessFeedbackCombinatorAverage; LikelinessHistoryCombinator
 /// = LikelinessHistoryCombinatorMax;
 ///	</pre>
 /// To understand the place where the combinator methods come into play a list
 /// for each early exit and which Methods are used.
 ///
 /// <pre>
 /// \c getInputReliability():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 /// \c getPossibleIdentifiers():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 /// \c getpossibleIdentifiersWithMasterFeedback():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 ///		-LikelinessFeedbackCombinator
 /// \c SymbolsWithHistory():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 ///		-LikelinessFeedbackCombinator
 ///		-LikelinessHistoryCombinator
 /// \c bestSymbol():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 ///		-LikelinessFeedbackCombinator
 ///		-LikelinessHistoryCombinator
 /// </pre>
 template <typename ValueType, typename IdentifierType, typename ReliabilityType>
 class ReliabilityAndConfidenceCombination {
 public:
   static_assert(std::is_arithmetic<ValueType>::value,
                 "LowLevel: ValueType has to an arithmetic type\n");
-  static_assert(std::is_arithmetic<IdentifierType>::value,
-                "LowLevel: IdentifierType has to an arithmetic type\n");
   static_assert(std::is_arithmetic<ReliabilityType>::value,
                 "LowLevel: ReliabilityType has to an arithmetic type\n");
 
   /// Typedef to shorten the writing.
   /// \c Symbol
   using Symbol = Symbol<IdentifierType, ReliabilityType>;
 
   /// Calculates the input Reliability by combining Reliability of the Sensor
   /// and the Slope Reliability \param SensorValue The sensor Value \note to set
   /// the combination method \c
   /// setAbsoluteAndSlopeReliabilityCombinationMethod()
   ReliabilityType getInputReliability(const ValueType &SensorValue) noexcept {
     ReliabilityType inputReliability =
         getReliability(SensorValue, previousSensorValue, timeStep);
     previousSensorValue = SensorValue;
     PreviousSensorValueExists = true;
     return inputReliability;
   }
 
   /// Calculates the possible Identifiers
   /// \param SensorValue the Sensor Value
   /// \brief it combines the input reliability and the confidence of the Sensor.
   /// The use combination method can be set using \c
   /// setReliabilityAndConfidenceCombinator()
   std::vector<Symbol>
   getPossibleIdentifiers(const ValueType &SensorValue) noexcept {
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
     return possibleIdentifiers;
   }
 
   /// return the Possible Values with the feedback in mind
   /// \param SensorValue The sensor Value
   /// \brief it combines the input reliability and the confidence of the Sensor.
   /// The combines them with LikelinessFeedbackCombinator and returns the
   /// result.
   std::vector<Symbol> getpossibleIdentifiersWithMasterFeedback(
       const ValueType &SensorValue) noexcept {
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
 
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
 
     possibleIdentifiers =
         LikelinessFeedbackCombinator(possibleIdentifiers, FeedbackSymbols);
     return possibleIdentifiers;
   }
 
   /// returns all possible Identifiers and Reliabilities with the History in
   /// mind \param SensorValue the Sensor value how this is done is described at
   /// the class.
   std::vector<Symbol>
   SymbolsWithHistory(const ValueType &SensorValue) noexcept {
     std::vector<Symbol> ActuallPossibleIdentifiers;
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
 
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
     possibleIdentifiers =
         LikelinessFeedbackCombinator(possibleIdentifiers, FeedbackSymbols);
 
     saveInHistory(possibleIdentifiers);
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\nActuallPossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
     LOG_TRACE_STREAM << "\npossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
 #endif
     possibleIdentifiers.clear();
 
     return SymbolsFromHistory();
   }
 
   /// Calculates the Reliability
   /// \param SensorValue The current Values of the Sensor
   ///
   /// \return Reliability and Identifier of the current SensorValue
   ///
   Symbol bestSymbol(const ValueType &SensorValue) noexcept {
 #if Reliability_trace_level <= trace_outputs
     LOG_TRACE_STREAM << "\nTrace level is set to: " << Reliability_trace_level
                      << "\n"
                      << "Will trace: "
                      << ((Reliability_trace_level == trace_outputs)
                              ? "outputs"
                              : (Reliability_trace_level == trace_vectors)
                                    ? "vectors"
                                    : (Reliability_trace_level ==
                                       trace_everything)
                                          ? "everything"
                                          : "undefined")
                      << trace_end;
 #endif
 
     std::vector<Symbol> ActuallPossibleIdentifiers;
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
 
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
     possibleIdentifiers =
         LikelinessFeedbackCombinator(possibleIdentifiers, FeedbackSymbols);
 
     saveInHistory(possibleIdentifiers);
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\nActuallPossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
     LOG_TRACE_STREAM << "\npossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
 #endif
     possibleIdentifiers.clear();
 
     possibleIdentifiers = SymbolsFromHistory();
 
     std::sort(
         possibleIdentifiers.begin(), possibleIdentifiers.end(),
         [](Symbol A, Symbol B) -> bool { return A.Likeliness > B.Likeliness; });
 
 #if Reliability_trace_level <= trace_outputs
     LOG_TRACE_STREAM << "\noutput lowlevel: " << possibleIdentifiers.at(0)
                      << trace_end;
 #endif
     return possibleIdentifiers.at(0);
   }
 
   /// feedback for this functionality most commonly it comes from a Master Agent
   /// \param _FeedbackSymbols The Identifiers + Reliability for the feedback
   /// \brief This input kind of resembles a confidence but not
   /// directly it more or less says: compared to the other Identifiers inside
   /// the System these are the Identifiers with the Reliability that you have.
   void feedback(
       const std::vector<Symbol>
           &_FeedbackSymbols) noexcept // it is being copied internally anyway
   {
     FeedbackSymbols = _FeedbackSymbols;
   }
 
   //
   // ----------------------Reliability and Confidence Function setters----------
   //
   /// This is the setter for Confidence Function
   /// \param _ConfidenceFunction A pointer to the Functional for the
   /// \c Confidence of the Sensor value
   void setConfidenceFunction(
       std::shared_ptr<
           RangeConfidence<ReliabilityType, IdentifierType, ValueType>>
           &_ConfidenceFunction) noexcept {
     ConfidenceFunction = _ConfidenceFunction;
   }
 
   /// This is the setter for AbsoluteReliabilityFunction
   /// \param _AbsoluteReliabilityFunction A pointer to the Functional for the
   /// AbsoluteReliabilityFunction \brief The AbsoluteReliabilityFunction takes
   /// the current Sensor value and return the AbsoluteReliabilityFunction of the
   /// value.
   void setAbsoluteReliabilityFunction(
       std::shared_ptr<Abstraction<ValueType, ReliabilityType>>
           &_AbsoluteReliabilityFunction) noexcept {
     AbsoluteReliabilityFunction = _AbsoluteReliabilityFunction;
   }
 
   /// This is the setter for ReliabilitySlopeFunction Function
   /// \param _ReliabilitySlopeFunction A pointer to the Functional for the
   /// ReliabilitySlopeFunction
   /// \brief The ReliabilitySlopeFunction takes the difference of the current
   /// Sensor Value to the last one and tells you how likely the change is.
   void setReliabilitySlopeFunction(
       std::shared_ptr<Abstraction<ValueType, ReliabilityType>>
           &_ReliabilitySlopeFunction) noexcept {
     ReliabilitySlopeFunction = _ReliabilitySlopeFunction;
   }
 
   /// This is the setter for TimeFunctionForLikeliness Function
   /// \param _TimeFunctionForLikeliness A pointer to the Functional for the
   /// TimeFunctionForLikeliness \brief The time function takes the position in
   /// the History with greater equals older and return a Reliability of how
   /// "relevant" it is.
   void setTimeFunctionForLikelinessFunction(
       std::shared_ptr<Abstraction<std::size_t, ReliabilityType>>
           &_TimeFunctionForLikeliness) noexcept {
     TimeFunctionForLikeliness = _TimeFunctionForLikeliness;
   }
 
   /// This is the setter for all possible Identifiers
   /// \param _Identifiers A vector containing all Identifiers
   /// \brief This exists even though \c Identifier Type is an arithmetic Type
   /// because the Identifiers do not need to be "next" to each other ( ex.
   /// Identifiers={ 1 7 24 })
   void setIdentifiers(const std::vector<IdentifierType> &_Identifiers) noexcept {
     this->Identifiers = _Identifiers;
   }
 
   /// This sets the Maximum length of the History
   /// \param length The length
   void setHistoryLength(const std::size_t &length) noexcept {
     this->HistoryMaxSize = length;
   }
 
   /// This sets the Value set Counter
   /// \param _timeStep the new Value
   /// \note This might actually be only an artifact. It is only used to get the
   /// reliability from the \c ReliabilitySlopeFunction [
   /// ReliabilitySlopeFunction->operator()( (lastValue - actualValue) /
   /// (ValueType)timeStep) ]
   void setTimeStep(const unsigned int &_timeStep) noexcept {
     this->timeStep = _timeStep;
   }
 
   //
   // ----------------combinator setters-----------------------------------------
   //
 
   /// This sets the combination method used by the History
   /// \param Meth the method which should be used. predefined inside the  \c
   /// predefinedMethods struct LikelinessHistoryCombinator<method>()
   void setLikelinessHistoryCombinator(
       const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
           &Meth) noexcept {
     LikelinessHistoryCombinator = Meth;
   }
 
   /// sets the predefined method for the combination of the possible Identifiers
   /// and the master
   /// \param Meth the method which should be used. predefined inside the  \c
   /// predefinedMethods struct LikelinessFeedbackCombinator<method>()
   void setLikelinessFeedbackCombinator(
       const std::function<std::vector<Symbol>(
           std::vector<Symbol>, std::vector<Symbol>)> &Meth) noexcept {
     LikelinessFeedbackCombinator = Meth;
   }
 
   /// Sets the used combination method for Possible Identifiers
   /// \param Meth the method which should be used. predefined inside the  \c
   /// predefinedMethods struct setReliabilityAndConfidenceCombinator<method>()
   void setReliabilityAndConfidenceCombinator(
       const std::function<std::vector<Symbol>(
           std::vector<Symbol>, ReliabilityType)> &Meth) noexcept {
     ReliabilityAndConfidenceCombinator = Meth;
   }
 
   /// sets the input reliability combinator method
   /// \param method the method which should be used. predefined inside the  \c
   /// predefinedMethods struct combination<method>()
   void setAbsoluteAndSlopeReliabilityCombinationMethod(
       const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
           &&method) noexcept {
     AbsoluteAndSlopeReliabilityCombinationMethod = method;
   }
 
   //
   // ----------------predefined combinators------------------------------------
   //
   /// This struct is a pseudo name space to have easier access to all predefined
   /// methods while still not overcrowding the class it self
   struct predefinedMethods {
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorMin(ReliabilityType A,
                                    ReliabilityType B) noexcept {
       return std::min(A, B);
     }
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorMax(ReliabilityType A,
                                    ReliabilityType B) noexcept {
       return std::max(A, B);
     }
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorMult(ReliabilityType A,
                                     ReliabilityType B) noexcept {
       return A * B;
     }
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorAverage(ReliabilityType A,
                                        ReliabilityType B) noexcept {
       return (A + B) / 2;
     }
 
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorAverage(std::vector<Symbol> A,
                                         std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness = (tmp_me.Likeliness + tmp_other.Likeliness) / 2;
           }
         }
       return A;
     }
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorMin(std::vector<Symbol> A,
                                     std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness =
                 std::min(tmp_me.Likeliness + tmp_other.Likeliness);
           }
         }
       return A;
     }
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorMax(std::vector<Symbol> A,
                                     std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness =
                 std::max(tmp_me.Likeliness + tmp_other.Likeliness);
           }
         }
       return A;
     }
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorMult(std::vector<Symbol> A,
                                      std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness = tmp_me.Likeliness * tmp_other.Likeliness;
           }
         }
       return A;
     }
 
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorMin(std::vector<Symbol> A,
                                           ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = std::min(tmp.Likeliness, B);
       return A;
     }
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorMax(std::vector<Symbol> A,
                                           ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = std::max(tmp.Likeliness, B);
       return A;
     }
 
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorAverage(std::vector<Symbol> A,
                                               ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = (tmp.Likeliness + B) / 2;
       return A;
     }
 
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorMult(std::vector<Symbol> A,
                                            ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = tmp.Likeliness * B / 2;
       return A;
     }
 
     /// The predefined min combinator method
     static ReliabilityType combinationMin(ReliabilityType A,
                                           ReliabilityType B) noexcept {
       return std::min(A, B);
     }
 
     /// The predefined max combinator method
     static ReliabilityType combinationMax(ReliabilityType A,
                                           ReliabilityType B) noexcept {
       return std::max(A, B);
     }
 
     /// The predefined average combinator method
     static ReliabilityType combinationAverage(ReliabilityType A,
                                               ReliabilityType B) noexcept {
       return (A + B) / 2;
     }
 
     /// The predefined average combinator method
     static ReliabilityType combinationMult(ReliabilityType A,
                                            ReliabilityType B) noexcept {
       return A * B;
     }
   };
 
   // ----------------------------------------------------------------
   //			Stored Values
   // ----------------------------------------------------------------
 private:
   std::vector<std::vector<Symbol>> History;
   std::size_t HistoryMaxSize;
   std::vector<Symbol> FeedbackSymbols;
 
   ValueType previousSensorValue;
   unsigned int timeStep;
   std::vector<IdentifierType> Identifiers;
   bool PreviousSensorValueExists = false;
 
   std::shared_ptr<RangeConfidence<ReliabilityType, IdentifierType, ValueType>>
       ConfidenceFunction;
   std::shared_ptr<Abstraction<ValueType, ReliabilityType>>
       AbsoluteReliabilityFunction;
   std::shared_ptr<Abstraction<ValueType, ReliabilityType>>
       ReliabilitySlopeFunction;
   std::shared_ptr<Abstraction<std::size_t, ReliabilityType>>
       TimeFunctionForLikeliness;
 
   // combination functions
   std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
       AbsoluteAndSlopeReliabilityCombinationMethod =
           predefinedMethods::combinationMin;
 
   std::function<std::vector<Symbol>(std::vector<Symbol>, ReliabilityType)>
       ReliabilityAndConfidenceCombinator =
           predefinedMethods::ReliabilityAndConfidenceCombinatorMin;
 
   std::function<std::vector<Symbol>(std::vector<Symbol>, std::vector<Symbol>)>
       LikelinessFeedbackCombinator =
           predefinedMethods::LikelinessFeedbackCombinatorAverage;
 
   std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
       LikelinessHistoryCombinator =
           predefinedMethods::LikelinessHistoryCombinatorMax;
 
   // ---------------------------------------------------------------------------
   //			needed Functions
   // ---------------------------------------------------------------------------
 
   /// returns the Reliability
   /// \param actualValue The Value of the Sensor
   /// \param lastValue of the Sensor this is stored in the class
   /// \param _timeStep It has an effect on the difference of the current
   /// and last value This might not be needed anymore
   /// \brief it returns the combination the \c Reliability function and \c
   /// ReliabilitySlopeFunction if the previous value exists. if it doesn't it
   /// only returns the \c Reliability function value.
   ReliabilityType getReliability(const ValueType &actualValue,
                                  const ValueType &lastValue,
                                  const unsigned int &_timeStep) noexcept {
     ReliabilityType relAbs =
         AbsoluteReliabilityFunction->operator()(actualValue);
     if (PreviousSensorValueExists) {
       ReliabilityType relSlo = ReliabilitySlopeFunction->operator()(
           (lastValue - actualValue) / static_cast<ValueType>(_timeStep)); //
 
       return AbsoluteAndSlopeReliabilityCombinationMethod(relAbs, relSlo);
     } else
       return relAbs;
   }
 
   /// adapts the possible Identifiers by checking the History and combines those
   /// values.
   /// \brief combines the historic values with the \c TimeFunctionForLikeliness
   /// function and returns the maximum Reliability for all Identifiers.
   std::vector<Symbol> SymbolsFromHistory() noexcept {
     // iterate through all history entries
     std::size_t posInHistory = 0;
     std::vector<Symbol> symbolFromHistory; // History Symbols
     for (auto step = History.begin(); step < History.end();
          step++, posInHistory++) {
 
       // iterate through all possible Identifiers of each history entry
       for (Symbol &symbol : *step) {
 
         IdentifierType historyIdentifier = symbol.Identifier;
         ReliabilityType historyConf = symbol.Likeliness;
 
         historyConf =
             historyConf * TimeFunctionForLikeliness->operator()(posInHistory);
 
         bool foundIdentifier = false;
         for (Symbol &pS : symbolFromHistory) {
 
           if (pS.Identifier == historyIdentifier) {
 
             pS.Likeliness =
                 LikelinessHistoryCombinator(pS.Likeliness, historyConf);
 
             foundIdentifier = true;
           }
         }
 
         if (foundIdentifier == false) {
 
           Symbol possibleIdentifier; // Symbol
           possibleIdentifier.Identifier = historyIdentifier;
           possibleIdentifier.Likeliness = historyConf;
 
           symbolFromHistory.push_back(possibleIdentifier);
         }
       }
     }
 
     return symbolFromHistory;
   }
 
   /// saves the Identifiers in the History
   /// \brief It checks the incoming Identifiers if any have a Reliability
   /// greater than 0.5 all of them get saved inside the History and then the
   /// History get shortened to the maximal length. It only saves the Value if
   /// the History is empty.
   ///
   /// \param actualPossibleIdentifiers The Identifiers which should be saved
   ///
   /// \note Does the History really make sense if the values are to small it
   /// only stores something if it's empty and not if it isn't completely filled
   void saveInHistory(const std::vector<Symbol>
                          &actualPossibleIdentifiers) noexcept { // Symbols
 
     // check if the reliability of at least one possible Identifier is high
     // enough
     bool atLeastOneRelIsHigh = false;
     for (Symbol pS : actualPossibleIdentifiers) {
       if (pS.Likeliness > 0.5) {
         atLeastOneRelIsHigh = true;
       }
     }
     // save possible Identifiers if at least one possible Identifier is high
     // enough (or if the history is empty)
     if (History.size() < 1 || atLeastOneRelIsHigh == true) {
       History.insert(History.begin(), actualPossibleIdentifiers);
 
       // if history size is higher than allowed, save oldest element
       while (History.size() > HistoryMaxSize) {
         // delete possibleIdentifierHistory.back();
         History.pop_back();
       }
     }
   }
 };
 
 } // namespace agent
 } // namespace rosa
 #endif // !ROSA_AGENT_ReliabilityConfidenceCombination_H