No OneTemporary
Actions

Size

62 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/rosa/agent/CrossCombinator.h b/include/rosa/agent/CrossCombinator.h
	index 679cbc1..9f612a4 100644
	--- a/include/rosa/agent/CrossCombinator.h
	+++ b/include/rosa/agent/CrossCombinator.h
	@@ -1,558 +1,560 @@
	//===-- rosa/delux/CrossCombinator.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/CrossCombinator.h
	///
	/// \author Daniel Schnoell
	///
	/// \date 2019
	/// \note based on Maximilian Goetzinger(maxgot @utu.fi) code in
	/// CAM_Dirty_include SA-EWS2_Version... inside Agent.cpp
	///
	/// \brief
	///
	/// \todo there is 1 exception that needs to be handled correctly.
	/// \note the default search function is extremely slow maybe this could be done
	/// via template for storage class and the functions/methods to efficiently find
	/// the correct LinearFunction
	//===----------------------------------------------------------------------===//
	#ifndef ROSA_AGENT_CROSSCOMBINATOR_H
	#define ROSA_AGENT_CROSSCOMBINATOR_H

	#include "rosa/agent/Abstraction.hpp"
	#include "rosa/agent/Functionality.h"
	-#include "rosa/agent/ReliabilityConfidenceCombinator.h"
	+#include "rosa/agent/LikelinessConfidenceCombinator.h"
	#include "rosa/core/forward_declarations.h" // needed for id_t
	#include "rosa/support/log.h" // needed for error "handling"

	// nedded headers

	#include <string>
	#include <type_traits> //assert
	#include <vector>
	// for static methods
	#include <algorithm>
	#include <numeric>

	namespace rosa {
	namespace agent {

	-template <typename id, typename IdentifierType, typename ReliabilityType>
	+template <typename id, typename IdentifierType, typename LikelinessType>
	std::vector<std::pair<id_t, IdentifierType>> &operator<<(
	std::vector<std::pair<id_t, IdentifierType>> &me,
	- std::vector<std::tuple<id, IdentifierType, ReliabilityType>> Values) {
	+ std::vector<std::tuple<id, IdentifierType, LikelinessType>> Values) {
	for (auto tmp : Values) {
	std::pair<id, IdentifierType> tmp2;
	tmp2.first = std::get<0>(tmp);
	tmp2.second = std::get<1>(tmp);
	me.push_back(tmp2);
	}
	return me;
	}

	/// This is the Combinator class for cross Reliabilities. It has many functions
	/// with different purposes
	/// \brief It takes the Identifiers and Reliabilities of all given ids and
	-/// calculates the Reliability of them together. Also it can creates the
	-/// feedback that is needed by the \c ReliabilityAndConfidenceCombinator, which
	+/// calculates the Likeliness of them together. Also it can creates the
	+/// feedback that is needed by the \c LikelinessAndConfidenceCombinator, which
	/// is a kind of confidence.
	///
	/// \tparam IdentifierType Data type of the Identifier ( Typically double
	-/// or float) \tparam ReliabilityType Data type of the Reliability ( Typically
	+/// or float) \tparam LikelinessType Data type of the Likeliness ( Typically
	/// long or int)
	///
	/// \note This class is commonly in a master slave relationship as master with
	-/// \c ReliabilityAndConfidenceCombinator. The \c operator()() combines the
	-/// Reliability of all connected Slaves and uses that as its own Reliability
	+/// \c LikelinessAndConfidenceCombinator. The \c operator()() combines the
	+/// Likeliness of all connected Slaves and uses that as its own Likeliness
	/// also creates the feedback for the Slaves.
	///
	-/// \note more information about how the Reliability and feedback is
	-/// created at \c operator()() , \c getCombinedCrossReliability() , \c
	-/// getCombinedInputReliability() , \c getOutputReliability() [ this is the
	-/// used Reliability ], \c getCrossConfidence() [ this is the feedback
	-/// for all Slaves ]
	+/// \note more information about how the Likeliness and feedback is
	+/// created at \c operator()() , \c getCombinedCrossLikeliness() , \c
	+/// getCombinedInputLikeliness() , \c getOutputLikeliness() [ this is the
	+/// used Likeliness ], \c getCrossConfidence() [ this is the feedback
	+/// for all Compares ]
	///
	-/// a bit more special Methods \c CrossConfidence() ,\c CrossReliability()
	-template <typename IdentifierType, typename ReliabilityType>
	+/// a bit more special Methods \c CrossConfidence() ,\c CrossLikeliness()
	+template <typename IdentifierType, typename LikelinessType>
	class CrossCombinator {
	public:
	static_assert(std::is_arithmetic<IdentifierType>::value,
	"HighLevel: IdentifierType has to be an arithmetic type\n");
	- static_assert(std::is_arithmetic<ReliabilityType>::value,
	- "HighLevel: ReliabilityType has to be an arithmetic type\n");
	+ static_assert(std::is_arithmetic<LikelinessType>::value,
	+ "HighLevel: LikelinessType has to be an arithmetic type\n");

	// ---------------------------------------------------------------------------
	// useful definitions
	// ---------------------------------------------------------------------------
	/// typedef To shorten the writing.
	- /// \c ConfOrRel
	- using ConfOrRel = ConfOrRel<IdentifierType, ReliabilityType>;
	+ /// \c Symbol
	+ using Symbol = Symbol<IdentifierType, LikelinessType>;

	/// To shorten the writing.
	using Abstraction =
	- typename rosa::agent::Abstraction<IdentifierType, ReliabilityType>;
	+ typename rosa::agent::Abstraction<IdentifierType, LikelinessType>;

	/// The return type for the \c operator()() Method
	struct returnType {
	- ReliabilityType CrossReliability;
	- std::map<id_t, std::vector<ConfOrRel>> CrossConfidence;
	+ LikelinessType CrossLikeliness;
	+ std::map<id_t, std::vector<Symbol>> Likeliness;
	};

	// -------------------------------------------------------------------------
	// Relevant Methods
	// -------------------------------------------------------------------------
	- /// Calculates the Reliability and the CrossConfidences for each id for all
	+ /// Calculates the CrossLikeliness and the Likeliness for each id for all
	/// of there Identifiers.
	///
	/// \param Values It gets the Identifiers and Reliabilities of
	- /// all connected Slaves inside a vector.
	+ /// all connected Compare Agentss inside a vector.
	///
	/// \return it returns a struct \c returnType containing the \c
	- /// getCombinedCrossReliability() and \c getCrossConfidence()
	+ /// getCombinedCrossLikeliness() and \c getCrossConfidence()
	returnType operator()(
	- std::vector<std::tuple<id_t, IdentifierType, ReliabilityType>> Values) {
	- return {getOutputReliability(Values), getCrossConfidence(Values)};
	+ std::vector<std::tuple<id_t, IdentifierType, LikelinessType>> Values) {
	+ return {getOutputLikeliness(Values), getCrossConfidence(Values)};
	}

	- /// returns the combined Cross Reliability via \c
	+ /// returns the combined Cross Likeliness via \c
	/// CombinedCrossRelCombinationMethod \c
	/// setCombinedCrossRelCombinationMethod() for all ids \c
	- /// CrossReliability() \param Values the used Values
	- ReliabilityType getCombinedCrossReliability(
	- const std::vector<std::tuple<id_t, IdentifierType, ReliabilityType>>
	+ /// CrossLikeliness() \param Values the used Values
	+ LikelinessType getCombinedCrossLikeliness(
	+ const std::vector<std::tuple<id_t, IdentifierType, LikelinessType>>
	&Values) noexcept {

	- ReliabilityType combinedCrossRel = -1;
	+ LikelinessType combinedCrossRel = -1;

	std::vector<std::pair<id_t, IdentifierType>> Agents;

	Agents << Values;

	for (auto Value : Values) {
	id_t id = std::get<0>(Value);
	IdentifierType sc = std::get<1>(Value);

	- // calculate the cross reliability for this slave agent
	- ReliabilityType realCrossReliabilityOfSlaveAgent =
	- CrossReliability({id, sc}, Agents);
	+ // calculate the cross Likeliness for this Compare agent
	+ LikelinessType realCrossLikelinessOfCompareInput =
	+ CrossLikeliness({id, sc}, Agents);

	if (combinedCrossRel != -1)
	combinedCrossRel = CombinedCrossRelCombinationMethod(
	- combinedCrossRel, realCrossReliabilityOfSlaveAgent);
	+ combinedCrossRel, realCrossLikelinessOfCompareInput);
	else
	- combinedCrossRel = realCrossReliabilityOfSlaveAgent;
	+ combinedCrossRel = realCrossLikelinessOfCompareInput;
	}
	return combinedCrossRel;
	}

	/// returns the combined via \c CombinedInputRelCombinationMethod \c
	- /// setCombinedInputRelCombinationMethod() input reliability \param Values
	+ /// setCombinedInputRelCombinationMethod() input Likeliness \param Values
	/// the used Values
	- ReliabilityType getCombinedInputReliability(
	- const std::vector<std::tuple<id_t, IdentifierType, ReliabilityType>>
	+ LikelinessType getCombinedInputLikeliness(
	+ const std::vector<std::tuple<id_t, IdentifierType, LikelinessType>>
	&Values) noexcept {
	- ReliabilityType combinedInputRel = -1;
	+ LikelinessType combinedInputRel = -1;

	std::vector<std::pair<id_t, IdentifierType>> Agents;

	Agents << Values;

	for (auto Value : Values) {
	- ReliabilityType rel = std::get<2>(Value);
	+ LikelinessType rel = std::get<2>(Value);

	if (combinedInputRel != -1)
	combinedInputRel =
	CombinedInputRelCombinationMethod(combinedInputRel, rel);
	else
	combinedInputRel = rel;
	}
	return combinedInputRel;
	}

	- /// returns the combination via \c OutputReliabilityCombinationMethod \c
	- /// setOutputReliabilityCombinationMethod() of the Cross reliability and
	- /// input reliability \param Values the used Values
	- ReliabilityType getOutputReliability(
	- const std::vector<std::tuple<id_t, IdentifierType, ReliabilityType>>
	+ /// returns the combination via \c OutputLikelinessCombinationMethod \c
	+ /// setOutputLikelinessCombinationMethod() of the Cross Likeliness and
	+ /// input Likeliness \param Values the used Values
	+ LikelinessType getOutputLikeliness(
	+ const std::vector<std::tuple<id_t, IdentifierType, LikelinessType>>
	&Values) noexcept {
	- return OutputReliabilityCombinationMethod(
	- getCombinedInputReliability(Values),
	- getCombinedCrossReliability(Values));
	+ return OutputLikelinessCombinationMethod(
	+ getCombinedInputLikeliness(Values),
	+ getCombinedCrossLikeliness(Values));
	}

	/// returns the crossConfidence for all ids \c CrossConfidence()
	/// \param Values the used Values
	- std::map<id_t, std::vector<ConfOrRel>> getCrossConfidence(
	- const std::vector<std::tuple<id_t, IdentifierType, ReliabilityType>>
	+ std::map<id_t, std::vector<Symbol>> getCrossConfidence(
	+ const std::vector<std::tuple<id_t, IdentifierType, LikelinessType>>
	&Values) noexcept {

	std::vector<std::pair<id_t, IdentifierType>> Agents;
	- std::map<id_t, std::vector<ConfOrRel>> output;
	- std::vector<ConfOrRel> output_temporary;
	+ std::map<id_t, std::vector<Symbol>> output;
	+ std::vector<Symbol> output_temporary;

	Agents << Values;

	for (auto Value : Values) {
	id_t id = std::get<0>(Value);

	output_temporary.clear();
	for (IdentifierType thoIdentifier : Identifiers[id]) {
	- ConfOrRel data;
	+ Symbol data;
	data.Identifier = thoIdentifier;
	- data.Reliability = CrossConfidence(id, thoIdentifier, Agents);
	+ data.Likeliness = CrossConfidence(id, thoIdentifier, Agents);
	output_temporary.push_back(data);
	}

	output.insert({id, output_temporary});
	}

	return output;
	}

	/// Calculates the Cross Confidence
	/// \brief it uses the Identifier value and calculates
	/// the Confidence of a given agent( represented by their id ) for a given
	/// Identifiers in connection to all other given agents
	///
	- /// \note all combination of agents and there corresponding Cross Reliability
	+ /// \note all combination of agents and there corresponding Cross Likeliness
	/// function have to be specified
	- ReliabilityType
	+ LikelinessType
	CrossConfidence(const id_t &MainAgent, const IdentifierType &TheoreticalValue,
	const std::vector<std::pair<id_t, IdentifierType>>
	- &SlaveAgents) noexcept {
	+ &CompareInputs) noexcept {

	- ReliabilityType crossReliabiability;
	+ LikelinessType crossReliabiability;

	- std::vector<ReliabilityType> values;
	+ std::vector<LikelinessType> values;

	- for (std::pair<id_t, IdentifierType> SlaveAgent : SlaveAgents) {
	+ for (std::pair<id_t, IdentifierType> CompareInput : CompareInputs) {

	- if (SlaveAgent.first == MainAgent)
	+ if (CompareInput.first == MainAgent)
	continue;

	- if (TheoreticalValue == SlaveAgent.second)
	+ if (TheoreticalValue == CompareInput.second)
	crossReliabiability = 1;
	else
	crossReliabiability =
	- 1 / (crossReliabilityParameter *
	- std::abs(TheoreticalValue - SlaveAgent.second));
	-
	- // profile reliability
	- ReliabilityType crossReliabilityFromProfile =
	- getCrossReliabilityFromProfile(
	- MainAgent, SlaveAgent.first,
	- std::abs(TheoreticalValue - SlaveAgent.second));
	+ 1 / (crossLikelinessParameter *
	+ std::abs(TheoreticalValue - CompareInput.second));
	+
	+ // profile Likeliness
	+ LikelinessType crossLikelinessFromProfile =
	+ getCrossLikelinessFromProfile(
	+ MainAgent, CompareInput.first,
	+ std::abs(TheoreticalValue - CompareInput.second));
	values.push_back(
	- std::max(crossReliabiability, crossReliabilityFromProfile));
	+ std::max(crossReliabiability, crossLikelinessFromProfile));
	}
	return Method(values);
	}

	- /// Calculates the Cross Reliability
	+ /// Calculates the Cross Likeliness
	/// \brief it uses the Identifier value and calculates
	- /// the Reliability of a given agent( represented by their id ) in connection
	+ /// the Likeliness of a given agent( represented by their id ) in connection
	/// to all other given agents
	///
	- /// \note all combination of agents and there corresponding Cross Reliability
	+ /// \note all combination of agents and there corresponding Cross Likeliness
	/// function have to be specified
	- ReliabilityType
	- CrossReliability(const std::pair<id_t, IdentifierType> &MainAgent,
	+ LikelinessType
	+ CrossLikeliness(const std::pair<id_t, IdentifierType> &MainAgent,
	const std::vector<std::pair<id_t, IdentifierType>>
	- &SlaveAgents) noexcept {
	+ &CompareInputs) noexcept {

	- ReliabilityType crossReliabiability;
	- std::vector<ReliabilityType> values;
	+ LikelinessType crossReliabiability;
	+ std::vector<LikelinessType> values;

	- for (std::pair<id_t, IdentifierType> SlaveAgent : SlaveAgents) {
	+ for (std::pair<id_t, IdentifierType> CompareInput : CompareInputs) {

	- if (SlaveAgent.first == MainAgent.first)
	+ if (CompareInput.first == MainAgent.first)
	continue;

	- if (MainAgent.second == SlaveAgent.second)
	+ if (MainAgent.second == CompareInput.second)
	crossReliabiability = 1;
	else
	crossReliabiability =
	- 1 / (crossReliabilityParameter *
	- std::abs(MainAgent.second - SlaveAgent.second));
	-
	- // profile reliability
	- ReliabilityType crossReliabilityFromProfile =
	- getCrossReliabilityFromProfile(
	- MainAgent.first, SlaveAgent.first,
	- std::abs(MainAgent.second - SlaveAgent.second));
	+ 1 / (crossLikelinessParameter *
	+ std::abs(MainAgent.second - CompareInput.second));
	+
	+ // profile Likeliness
	+ LikelinessType crossLikelinessFromProfile =
	+ getCrossLikelinessFromProfile(
	+ MainAgent.first, CompareInput.first,
	+ std::abs(MainAgent.second - CompareInput.second));
	values.push_back(
	- std::max(crossReliabiability, crossReliabilityFromProfile));
	+ std::max(crossReliabiability, crossLikelinessFromProfile));
	}
	return Method(values);
	}

	// --------------------------------------------------------------------------
	// Defining the class
	// --------------------------------------------------------------------------

	- /// adds a Cross Reliability Profile used to get the Reliability of the
	+ /// adds a Cross Likeliness Profile used to get the Likeliness of the
	/// Identifier difference
	///
	/// \param idA The id of the one \c Agent ( ideally the id of \c Unit to make
	/// it absolutely unique )
	///
	/// \param idB The id of the other \c Agent
	///
	/// \param Function A shared pointer to an \c Abstraction it would use the
	/// difference in Identifier for its input
	- void addCrossReliabilityProfile(
	+ void addCrossLikelinessProfile( //conf
	const id_t &idA, const id_t &idB,
	const std::shared_ptr<Abstraction> &Function) noexcept {
	- Functions.push_back({true, idA, idB, Function});
	+ Functions.push_back({true, idA, idB, Function}); //confidence Profiles
	}

	- /// sets the cross reliability parameter
	- void setCrossReliabilityParameter(const ReliabilityType &val) noexcept {
	- crossReliabilityParameter = val;
	+ /// sets the cross Likeliness parameter
	+ void setCrossLikelinessParameter(const LikelinessType &val) noexcept {
	+ crossLikelinessParameter = val;
	}

	/// This is the adder for the Identifiers
	/// \param id The id of the Agent of the Identifiers
	/// \param _Identifiers id specific Identifiers. This will be copied So that if
	- /// Slaves have different Identifiers they can be used correctly. \brief The
	- /// Identifiers of all connected slave Agents has to be known to be able to
	+ /// Compares have different Identifiers they can be used correctly. \brief The
	+ /// Identifiers of all connected Compare Agents has to be known to be able to
	/// iterate over them
	void
	- addIdentifiers(const id_t &id,
	+ addIdentifiers(const id_t &id, //add IdentifierIdentifiers
	const std::vector<IdentifierType> &_Identifiers) noexcept {
	Identifiers.insert({id, _Identifiers});
	}

	// -------------------------------------------------------------------------
	// Combinator Settings
	// -------------------------------------------------------------------------

	+ // remove Method
	+
	/// sets the used method to combine the values
	/// \param Meth the method which should be used. predefined functions in the
	/// struct \c predefinedMethods \c
	/// CONJUNCTION() \c AVERAGE() \c DISJUNCTION()
	- void setCrossReliabilityCombinatorMethod(
	- const std::function<ReliabilityType(std::vector<ReliabilityType> values)>
	+ void setCrossLikelinessCombinatorMethod(
	+ const std::function<LikelinessType(std::vector<LikelinessType> values)>
	&Meth) noexcept {
	Method = Meth;
	}

	- /// sets the combination method for the combined cross reliability
	+ /// sets the combination method for the combined cross Likeliness
	/// \param Meth the method which should be used. predefined functions in the
	/// struct \c predefinedMethods CombinedCrossRelCombinationMethod<method>()
	void setCombinedCrossRelCombinationMethod(
	- const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
	+ const std::function<LikelinessType(LikelinessType, LikelinessType)>
	&Meth) noexcept {
	CombinedCrossRelCombinationMethod = Meth;
	}

	/// sets the combined input rel method
	/// \param Meth the method which should be used. predefined functions in the
	/// struct \c predefinedMethods CombinedInputRelCombinationMethod<method>()
	void setCombinedInputRelCombinationMethod(
	- const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
	+ const std::function<LikelinessType(LikelinessType, LikelinessType)>
	&Meth) noexcept {
	CombinedInputRelCombinationMethod = Meth;
	}

	- /// sets the used OutputReliabilityCombinationMethod
	+ /// sets the used OutputLikelinessCombinationMethod
	/// \param Meth the method which should be used. predefined functions in the
	- /// struct \c predefinedMethods OutputReliabilityCombinationMethod<method>()
	- void setOutputReliabilityCombinationMethod(
	- const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
	+ /// struct \c predefinedMethods OutputLikelinessCombinationMethod<method>()
	+ void setOutputLikelinessCombinationMethod(
	+ const std::function<LikelinessType(LikelinessType, LikelinessType)>
	&Meth) noexcept {
	- OutputReliabilityCombinationMethod = Meth;
	+ OutputLikelinessCombinationMethod = Meth;
	}

	// -------------------------------------------------------------------------
	// Predefined Functions
	// -------------------------------------------------------------------------
	/// 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 combination method
	- static ReliabilityType CONJUNCTION(std::vector<ReliabilityType> values) {
	+ static LikelinessType CONJUNCTION(std::vector<LikelinessType> values) {
	return *std::min_element(values.begin(), values.end());
	}

	/// predefined combination method
	- static ReliabilityType AVERAGE(std::vector<ReliabilityType> values) {
	+ static LikelinessType AVERAGE(std::vector<LikelinessType> values) {
	return std::accumulate(values.begin(), values.end(), 0.0) / values.size();
	}

	/// predefined combination method
	- static ReliabilityType DISJUNCTION(std::vector<ReliabilityType> values) {
	+ static LikelinessType DISJUNCTION(std::vector<LikelinessType> values) {
	return *std::max_element(values.begin(), values.end());
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedCrossRelCombinationMethodMin(ReliabilityType A, ReliabilityType B) {
	+ static LikelinessType
	+ CombinedCrossRelCombinationMethodMin(LikelinessType A, LikelinessType B) {
	return std::min(A, B);
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedCrossRelCombinationMethodMax(ReliabilityType A, ReliabilityType B) {
	+ static LikelinessType
	+ CombinedCrossRelCombinationMethodMax(LikelinessType A, LikelinessType B) {
	return std::max(A, B);
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedCrossRelCombinationMethodMult(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ CombinedCrossRelCombinationMethodMult(LikelinessType A,
	+ LikelinessType B) {
	return A * B;
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedCrossRelCombinationMethodAverage(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ CombinedCrossRelCombinationMethodAverage(LikelinessType A,
	+ LikelinessType B) {
	return (A + B) / 2;
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedInputRelCombinationMethodMin(ReliabilityType A, ReliabilityType B) {
	+ static LikelinessType
	+ CombinedInputRelCombinationMethodMin(LikelinessType A, LikelinessType B) {
	return std::min(A, B);
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedInputRelCombinationMethodMax(ReliabilityType A, ReliabilityType B) {
	+ static LikelinessType
	+ CombinedInputRelCombinationMethodMax(LikelinessType A, LikelinessType B) {
	return std::max(A, B);
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedInputRelCombinationMethodMult(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ CombinedInputRelCombinationMethodMult(LikelinessType A,
	+ LikelinessType B) {
	return A * B;
	}

	/// predefined combination Method
	- static ReliabilityType
	- CombinedInputRelCombinationMethodAverage(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ CombinedInputRelCombinationMethodAverage(LikelinessType A,
	+ LikelinessType B) {
	return (A + B) / 2;
	}

	/// predefined combination method
	- static ReliabilityType
	- OutputReliabilityCombinationMethodMin(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ OutputLikelinessCombinationMethodMin(LikelinessType A,
	+ LikelinessType B) {
	return std::min(A, B);
	}

	/// predefined combination method
	- static ReliabilityType
	- OutputReliabilityCombinationMethodMax(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ OutputLikelinessCombinationMethodMax(LikelinessType A,
	+ LikelinessType B) {
	return std::max(A, B);
	}

	/// predefined combination method
	- static ReliabilityType
	- OutputReliabilityCombinationMethodMult(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ OutputLikelinessCombinationMethodMult(LikelinessType A,
	+ LikelinessType B) {
	return A * B;
	}

	/// predefined combination method
	- static ReliabilityType
	- OutputReliabilityCombinationMethodAverage(ReliabilityType A,
	- ReliabilityType B) {
	+ static LikelinessType
	+ OutputLikelinessCombinationMethodAverage(LikelinessType A,
	+ LikelinessType B) {
	return (A + B) / 2;
	}
	};

	// -------------------------------------------------------------------------
	// Cleanup
	// -------------------------------------------------------------------------

	~CrossCombinator() { Functions.clear(); }

	// --------------------------------------------------------------------------
	// Parameters
	// --------------------------------------------------------------------------
	private:
	struct Functionblock {
	bool exists = false;
	id_t A;
	id_t B;
	std::shared_ptr<Abstraction> Funct;
	};

	std::map<id_t, std::vector<IdentifierType>> Identifiers;

	/// From Maxi in his code defined as 1 can be changed by set
	- ReliabilityType crossReliabilityParameter = 1;
	+ LikelinessType crossLikelinessParameter = 1;

	- /// Stored Cross Reliability Functions
	+ /// Stored Cross Likeliness Functions
	std::vector<Functionblock> Functions;

	/// Method which is used to combine the generated values
	- std::function<ReliabilityType(std::vector<ReliabilityType>)> Method =
	+ std::function<LikelinessType(std::vector<LikelinessType>)> Method =
	predefinedMethods::AVERAGE;

	- std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
	+ std::function<LikelinessType(LikelinessType, LikelinessType)>
	CombinedCrossRelCombinationMethod =
	predefinedMethods::CombinedCrossRelCombinationMethodMin;

	- std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
	+ std::function<LikelinessType(LikelinessType, LikelinessType)>
	CombinedInputRelCombinationMethod =
	predefinedMethods::CombinedInputRelCombinationMethodMin;

	- std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
	- OutputReliabilityCombinationMethod =
	- predefinedMethods::OutputReliabilityCombinationMethodMin;
	+ std::function<LikelinessType(LikelinessType, LikelinessType)>
	+ OutputLikelinessCombinationMethod =
	+ predefinedMethods::OutputLikelinessCombinationMethodMin;

	//--------------------------------------------------------------------------------
	// helper function

	/// very inefficient searchFunction
	Functionblock (*searchFunction)(std::vector<Functionblock> vect,
	const id_t nameA, const id_t nameB) =
	[](std::vector<Functionblock> vect, const id_t nameA,
	const id_t nameB) -> Functionblock {
	for (Functionblock tmp : vect) {
	if (tmp.A == nameA && tmp.B == nameB)
	return tmp;
	if (tmp.A == nameB && tmp.B == nameA)
	return tmp;
	}
	return Functionblock();
	};

	/// evaluates the corresponding LinearFunction with the Identifier difference
	- /// \param nameA these two parameters are the unique identifiers
	- /// \param nameB these two parameters are the unique identifiers
	+ /// \param nameA these two parameters are the unique Identifiers
	+ /// \param nameB these two parameters are the unique Identifiers
	/// for the LinerFunction
	///
	/// \note it doesn't matter if they are swapped
	- ReliabilityType getCrossReliabilityFromProfile(
	+ LikelinessType getCrossLikelinessFromProfile(
	const id_t &nameA, const id_t &nameB,
	const IdentifierType &IdentifierDifference) noexcept {
	Functionblock block = searchFunction(Functions, nameA, nameB);
	if (!block.exists) {
	- LOG_ERROR(("CrossReliability: Block:" + std::to_string(nameA) + "," +
	+ LOG_ERROR(("CrossLikeliness: Block:" + std::to_string(nameA) + "," +
	std::to_string(nameB) + "doesn't exist returning 0"));
	return 0;
	}
	return block.Funct->operator()(IdentifierDifference);
	}
	};

	} // End namespace agent
	} // End namespace rosa

	#endif // ROSA_AGENT_CROSSCOMBINATOR_H
	\ No newline at end of file
	diff --git a/include/rosa/agent/ReliabilityConfidenceCombinator.h b/include/rosa/agent/ReliabilityConfidenceCombinator.h
	index f8a2074..d9b8a61 100644
	--- a/include/rosa/agent/ReliabilityConfidenceCombinator.h
	+++ b/include/rosa/agent/ReliabilityConfidenceCombinator.h
	@@ -1,761 +1,761 @@
	//===-- rosa/agent/ReliabilityConfidenceCombinator.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/ReliabilityConfidenceCombinator.h
	///
	/// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at)
	///
	/// \date 2019
	///
	/// \brief Definition of ReliabilityConfidenceCombinator 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_ReliabilityConfidenceCombinator_H
	#define ROSA_AGENT_ReliabilityConfidenceCombinator_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(){};

	/// 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 ---\| PossibleIdentifierCombinationMethod -> next line
	+/// Sensor Value ---\| ReliabilityAndConfidenceCombinator -> next line
	/// \| A \|
	/// \| \| V
	-/// ->ConfidenceFunction--- getPossibleIdentifiers()
	+/// ->ConfidenceFunction getPossibleIdentifiers()
	///
	///-----------------------------------------------------------------------------------
	///
	/// feedback
	/// \|
	/// V
	/// FeedbackSymbols
	-/// \| -> History ---\|
	-/// V \| V
	-/// here -> LikelinessFeedbackCombinator -------->LikelinessHistoryCombinator->next line
	+/// \| -> History -------\|
	+/// V \| V
	+/// here -> LikelinessFeedbackCombinator ------>LikelinessHistoryCombinator->next line
	/// \| \|
	/// V V
	-/// getpossibleIdentifiersWithMasterFeedback()SymbolsWithHistory()
	+/// 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:
	-/// InputReliabilityCombinator = combinationMin;
	-/// PossibleIdentifierCombinationMethod=PossibleIdentifierCombinationMethodMin;
	+/// 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():
	-/// -InputReliabilityCombinator
	+/// -AbsoluteAndSlopeReliabilityCombinationMethod
	/// \c getPossibleIdentifiers():
	-/// -InputReliabilityCombinator
	-/// -PossibleIdentifierCombinationMethod
	+/// -AbsoluteAndSlopeReliabilityCombinationMethod
	+/// -ReliabilityAndConfidenceCombinator
	/// \c getpossibleIdentifiersWithMasterFeedback():
	-/// -InputReliabilityCombinator
	-/// -PossibleIdentifierCombinationMethod
	+/// -AbsoluteAndSlopeReliabilityCombinationMethod
	+/// -ReliabilityAndConfidenceCombinator
	/// -LikelinessFeedbackCombinator
	/// \c SymbolsWithHistory():
	-/// -InputReliabilityCombinator
	-/// -PossibleIdentifierCombinationMethod
	+/// -AbsoluteAndSlopeReliabilityCombinationMethod
	+/// -ReliabilityAndConfidenceCombinator
	/// -LikelinessFeedbackCombinator
	/// -LikelinessHistoryCombinator
	/// \c bestSymbol():
	-/// -InputReliabilityCombinator
	-/// -PossibleIdentifierCombinationMethod
	+/// -AbsoluteAndSlopeReliabilityCombinationMethod
	+/// -ReliabilityAndConfidenceCombinator
	/// -LikelinessFeedbackCombinator
	/// -LikelinessHistoryCombinator
	/// </pre>
	template <typename ValueType, typename IdentifierType,
	typename ReliabilityType>
	class ReliabilityAndConfidenceCombinator {
	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 setInputReliabilityCombinator()
	+ /// 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
	- /// setPossibleIdentifierCombinationMethod()
	+ /// 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 = PossibleIdentifierCombinationMethod(
	+ 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 = PossibleIdentifierCombinationMethod(
	+ 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 = PossibleIdentifierCombinationMethod(
	+ 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 = PossibleIdentifierCombinationMethod(
	+ 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 _Confidence 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 PossibleIdentifierCombinationMethod<method>()
	- void setPossibleIdentifierCombinationMethod(
	+ /// predefinedMethods struct setReliabilityAndConfidenceCombinator<method>()
	+ void setReliabilityAndConfidenceCombinator(
	const std::function<std::vector<Symbol>(
	std::vector<Symbol>, ReliabilityType)> &Meth) noexcept {
	- PossibleIdentifierCombinationMethod = Meth;
	+ 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 setInputReliabilityCombinator(
	+ void setAbsoluteAndSlopeReliabilityCombinationMethod(
	const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
	&&method) noexcept {
	- InputReliabilityCombinator = method;
	+ 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>
	- PossibleIdentifierCombinationMethodMin(std::vector<Symbol> A,
	+ 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>
	- PossibleIdentifierCombinationMethodMax(std::vector<Symbol> A,
	+ 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>
	- PossibleIdentifierCombinationMethodAverage(std::vector<Symbol> A,
	+ 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>
	- PossibleIdentifierCombinationMethodMult(std::vector<Symbol> A,
	+ 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)>
	- InputReliabilityCombinator = predefinedMethods::combinationMin;
	+ AbsoluteAndSlopeReliabilityCombinationMethod = predefinedMethods::combinationMin;

	std::function<std::vector<Symbol>(std::vector<Symbol>, ReliabilityType)>
	- PossibleIdentifierCombinationMethod =
	- predefinedMethods::PossibleIdentifierCombinationMethodMin;
	+ 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) / (ValueType)_timeStep);

	- return InputReliabilityCombinator(relAbs, relSlo);
	+ 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 timeStep = History.begin(); timeStep < History.end();
	timeStep++, posInHistory++) {

	// iterate through all possible Identifiers of each history entry
	for (Symbol &symbol : *timeStep) {

	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_ReliabilityConfidenceCombinator_H

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 29, 10:39 PM (3 h, 13 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 242477
Default Alt Text: (62 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions