No OneTemporary
Actions

Size

48 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h b/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h
	index 2bab293..0abef5d 100644
	--- a/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h
	+++ b/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h
	@@ -1,170 +1,170 @@
	#include "rosa/config/version.h"

	#include "rosa/support/log.h"

	#include "rosa/agent/CrossReliability.h"
	#include "rosa/agent/RangeConfidence.hpp"
	#include "rosa/agent/Reliability.h"
	#include "rosa/app/Application.hpp"

	#include <map>
	#include <vector>

	using namespace rosa::agent;
	using namespace rosa;
	using namespace rosa::app;
	using namespace rosa::terminal;


	auto create_lowlevel_func() {
	- std::unique_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
	- Confidence(new RangeConfidence<ReliabilityType, StateType,
	- SensorValueType>(
	+ std::unique_ptr<RangeConfidence<SensorValueType, StateType, ReliabilityType>>
	+ Confidence(new RangeConfidence<SensorValueType, StateType,
	+ ReliabilityType>(
	{{0, PartialFunction<double, double>(
	{
	{{0, 3},
	std::make_shared<LinearFunction<double, double>>(
	0, 1.0 / 3)},
	{{3, 6},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{6, 9},
	std::make_shared<LinearFunction<double, double>>(
	3.0, -1.0 / 3)},
	},
	0)},
	{1, PartialFunction<double, double>(
	{
	{{6, 9},
	std::make_shared<LinearFunction<double, double>>(
	-2, 1.0 / 3)},
	{{9, 12},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{12, 15},
	std::make_shared<LinearFunction<double, double>>(
	5, -1.0 / 3)},
	},
	0)},
	{2, PartialFunction<double, double>(
	{
	{{12, 15},
	std::make_shared<LinearFunction<double, double>>(
	-4, 1.0 / 3)},
	{{15, 18},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{18, 21},
	std::make_shared<LinearFunction<double, double>>(
	7, -1.0 / 3)},
	},
	0)}}));

	std::unique_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability(
	new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));

	std::unique_ptr<Abstraction<SensorValueType, ReliabilityType>>
	ReliabilitySlope(
	new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));

	std::unique_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence(
	new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 3));

	auto lowlevel = new ReliabilityForLowLevelAgents<SensorValueType, StateType,
	ReliabilityType>();

	std::vector<long> states;
	states.push_back(0);
	states.push_back(1);
	states.push_back(2);

	lowlevel->setConfidenceFunction(Confidence);
	lowlevel->setAbsoluteReliabilityFunction(Reliability);
	lowlevel->setReliabilitySlopeFunction(ReliabilitySlope);
	lowlevel->setTimeFunctionForLikelinessFunction(TimeConfidence);
	lowlevel->setIdentifiers(states);
	lowlevel->setHistoryLength(2);
	lowlevel->setTimeStep(1);

	return lowlevel;
	}

	auto create_highlevel_func(){
	std::vector<long> states;
	states.push_back(0);
	states.push_back(1);
	states.push_back(2);

	ReliabilityForHighLevelAgents<StateType, ReliabilityType> *highlevel =
	new ReliabilityForHighLevelAgents<StateType, ReliabilityType>();

	std::unique_ptr<CrossReliability<StateType, ReliabilityType>>
	CrossReliability1(new CrossReliability<StateType, ReliabilityType>());

	std::unique_ptr<Abstraction<long, double>> func1(
	new PartialFunction<long, double>(
	{
	{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
	{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
	},
	0));
	std::unique_ptr<Abstraction<long, double>> func2(
	new PartialFunction<long, double>(
	{
	{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
	{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
	},
	0));
	std::unique_ptr<Abstraction<long, double>> func3(
	new PartialFunction<long, double>(
	{
	{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
	{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
	},
	0));

	CrossReliability1->addCrossLikelinessProfile(0, 1, func1);
	CrossReliability1->addCrossLikelinessProfile(0, 2, func2);
	CrossReliability1->addCrossLikelinessProfile(2, 1, func3);
	CrossReliability1->setCrossReliabilityMethod(
	CrossReliability<StateType, ReliabilityType>::AVERAGE);
	CrossReliability1->setCrossLikelinessParameter(1);

	std::unique_ptr<CrossConfidence<StateType, ReliabilityType>> CrossConfidence1(
	new CrossConfidence<StateType, ReliabilityType>());

	std::unique_ptr<Abstraction<long, double>> func4(
	new PartialFunction<long, double>(
	{
	{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
	{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
	},
	0));
	std::unique_ptr<Abstraction<long, double>> func5(
	new PartialFunction<long, double>(
	{
	{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
	{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
	},
	0));
	std::unique_ptr<Abstraction<long, double>> func6(
	new PartialFunction<long, double>(
	{
	{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
	{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
	},
	0));

	CrossConfidence1->addCrossLikelinessProfile(0, 1, func4);
	CrossConfidence1->addCrossLikelinessProfile(0, 2, func5);
	CrossConfidence1->addCrossLikelinessProfile(2, 1, func6);
	CrossConfidence1->setCrossReliabilityMethod(
	CrossConfidence<StateType, ReliabilityType>::AVERAGE);
	CrossConfidence1->setCrossLikelinessParameter(1);

	highlevel->setCrossConfidence(CrossConfidence1);
	highlevel->setCrossReliability(CrossReliability1);

	highlevel->addStates(0, states);
	highlevel->addStates(1, states);
	highlevel->addStates(2, states);

	return highlevel;
	}
	diff --git a/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp b/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
	index 3f88ffa..5d7ce85 100644
	--- a/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
	+++ b/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
	@@ -1,253 +1,253 @@
	//===- examples/agent-functionalities/Reliability-functionality.cpp 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 examples/agent-functionalities/Reliability-functionality.cpp
	///
	/// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at )
	///
	/// \date 2019
	///
	/// \brief A simple example on defining Relianility Functionalities.
	///
	//===----------------------------------------------------------------------===//

	#define Reliability_trace_level 5

	#include "rosa/config/version.h"

	#include "rosa/support/log.h"

	#include "rosa/agent/CrossCombinator.h"
	#include "rosa/agent/RangeConfidence.hpp"
	#include "rosa/agent/ReliabilityConfidenceCombination.h"

	#include <map>
	#include <vector>

	using namespace rosa::agent;

	int main(void) {
	typedef double SensorValueType;
	typedef long StateType;
	typedef double ReliabilityType;

	- std::shared_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
	- Confidence(new RangeConfidence<ReliabilityType, StateType,
	- SensorValueType>(
	+ std::shared_ptr<RangeConfidence<SensorValueType, StateType, ReliabilityType>>
	+ Confidence(new RangeConfidence<SensorValueType, StateType,
	+ ReliabilityType>(
	{{0, PartialFunction<double, double>(
	{
	{{0, 3},
	std::make_shared<LinearFunction<double, double>>(
	0, 1.0 / 3)},
	{{3, 6},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{6, 9},
	std::make_shared<LinearFunction<double, double>>(
	3.0, -1.0 / 3)},
	},
	0)},
	{1, PartialFunction<double, double>(
	{
	{{6, 9},
	std::make_shared<LinearFunction<double, double>>(
	-2, 1.0 / 3)},
	{{9, 12},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{12, 15},
	std::make_shared<LinearFunction<double, double>>(
	5, -1.0 / 3)},
	},
	0)},
	{2, PartialFunction<double, double>(
	{
	{{12, 15},
	std::make_shared<LinearFunction<double, double>>(
	-4, 1.0 / 3)},
	{{15, 18},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{18, 21},
	std::make_shared<LinearFunction<double, double>>(
	7, -1.0 / 3)},
	},
	0)}}));

	std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability(
	new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));

	std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>>
	ReliabilitySlope(
	new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));

	std::shared_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence(
	new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 3));

	auto lowlevel =
	new ReliabilityAndConfidenceCombination<SensorValueType, StateType,
	ReliabilityType>();

	std::vector<long> states;
	states.push_back(0);
	states.push_back(1);
	states.push_back(2);

	lowlevel->setConfidenceFunction(Confidence);
	lowlevel->setAbsoluteReliabilityFunction(Reliability);
	lowlevel->setReliabilitySlopeFunction(ReliabilitySlope);
	lowlevel->setTimeFunctionForLikelinessFunction(TimeConfidence);
	lowlevel->setIdentifiers(states);
	lowlevel->setHistoryLength(2);
	lowlevel->setTimeStep(1);

	/* ----------------------------- Do Something
	* ---------------------------------------------------------------- */
	std::cout << "Testing the lowlevel component with static feedback telling it "
	"that the most lickely state is 2.\n";
	for (int a = 0; a < 30; a++)
	std::cout << "a: " << a << "\n"
	<< (lowlevel->feedback({{0, 0}, {1, 0.3}, {2, 0.8}}),
	lowlevel->bestSymbol(a))
	<< "\n";


	std::cout << "---------------------------------------------------------------"
	"---------------------------------\n";
	std::cout << "------------------------------------High level "
	"Test---------------------------------------------\n";

	std::cout
	<< "Configured in a way that the Master thinks that both Sensors "
	"should have the same State.\n While feeding both the \"opposite\" "
	"values one acending the other decending from the maximum.\n";

	- std::shared_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
	- Confidence2(new RangeConfidence<ReliabilityType, StateType,
	- SensorValueType>(
	+ std::shared_ptr<RangeConfidence<SensorValueType, StateType, ReliabilityType>>
	+ Confidence2(new RangeConfidence<SensorValueType, StateType,
	+ ReliabilityType>(
	{{0, PartialFunction<double, double>(
	{
	{{0, 3},
	std::make_shared<LinearFunction<double, double>>(
	0, 1.0 / 3)},
	{{3, 6},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{6, 9},
	std::make_shared<LinearFunction<double, double>>(
	3.0, -1.0 / 3)},
	},
	0)},
	{1, PartialFunction<double, double>(
	{
	{{6, 9},
	std::make_shared<LinearFunction<double, double>>(
	-2, 1.0 / 3)},
	{{9, 12},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{12, 15},
	std::make_shared<LinearFunction<double, double>>(
	5, -1.0 / 3)},
	},
	0)},
	{2, PartialFunction<double, double>(
	{
	{{12, 15},
	std::make_shared<LinearFunction<double, double>>(
	-4, 1.0 / 3)},
	{{15, 18},
	std::make_shared<LinearFunction<double, double>>(1, 0)},
	{{18, 21},
	std::make_shared<LinearFunction<double, double>>(
	7, -1.0 / 3)},
	},
	0)}}));

	std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability2(
	new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));

	std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>>
	ReliabilitySlope2(
	new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));

	std::shared_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence2(
	new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 9));

	auto lowlevel2 =
	new ReliabilityAndConfidenceCombination<SensorValueType, StateType,
	ReliabilityType>();

	std::vector<long> states2;
	states2.push_back(0);
	states2.push_back(1);
	states2.push_back(2);

	lowlevel2->setConfidenceFunction(Confidence2);
	lowlevel2->setAbsoluteReliabilityFunction(Reliability2);
	lowlevel2->setReliabilitySlopeFunction(ReliabilitySlope2);
	lowlevel2->setTimeFunctionForLikelinessFunction(TimeConfidence2);
	lowlevel2->setIdentifiers(states2);
	lowlevel2->setHistoryLength(2);
	lowlevel2->setTimeStep(1);

	CrossCombinator<StateType, ReliabilityType> *highlevel =
	new CrossCombinator<StateType, ReliabilityType>();

	std::shared_ptr<Abstraction<long, double>> func1(new PartialFunction<long, double>(
	{
	{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
	{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
	},
	0));

	highlevel->addCrossLikelinessProfile(0, 1, func1);
	highlevel->setCrossLikelinessCombinatorMethod(
	CrossCombinator<StateType, ReliabilityType>::predefinedMethods::AVERAGE);
	highlevel->setCrossLikelinessParameter(1);

	highlevel->addIdentifiers(0, states);
	highlevel->addIdentifiers(1, states);

	for (int a = 0; a < 21; a++) {
	auto out1 = lowlevel->bestSymbol(a),
	out2 = lowlevel2->bestSymbol((int)21 - a);
	std::cout << "s1: " << out1 << "\ns2:" << out2 << "\n";
	std::vector<std::tuple<rosa::id_t, StateType, ReliabilityType>> tmp2;
	tmp2.push_back({0, out1.Identifier, out1.Likeliness});
	tmp2.push_back({1, out2.Identifier, out2.Likeliness});

	auto out_o = highlevel->operator()(tmp2);
	std::cout << "it: " << a << "\t rel: " << out_o.CrossLikeliness << "\n";
	std::cout << "\t subs:\n";
	for (auto q : out_o.Likeliness) {
	std::cout << "\t\t id:" << q.first << "\n";
	/*
	for(auto z: q.second)
	{
	std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Likeliness
	<< "\n"; tmp.push_back({z.Identifier,z.Likeliness});
	}
	*/
	for (auto z : q.second) {
	std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Likeliness
	<< "\n";
	}

	if (q.first == 0)
	lowlevel->feedback(q.second);
	else
	lowlevel2->feedback(q.second);
	}
	}
	/* ----------------------------- Cleanup
	* --------------------------------------------------------------------- */

	delete highlevel;
	delete lowlevel;
	delete lowlevel2;
	}
	diff --git a/include/rosa/agent/ReliabilityConfidenceCombination.h b/include/rosa/agent/ReliabilityConfidenceCombination.h
	index f81b02f..ec0175f 100644
	--- a/include/rosa/agent/ReliabilityConfidenceCombination.h
	+++ b/include/rosa/agent/ReliabilityConfidenceCombination.h
	@@ -1,771 +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<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>>
	+ RangeConfidence<ValueType, IdentifierType, ReliabilityType>>
	&_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>>
	+ std::shared_ptr<RangeConfidence<ValueType, IdentifierType, ReliabilityType>>
	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

File Metadata

Mime Type: text/x-diff
Expires: Mon, Oct 20, 1:22 PM (16 h, 19 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 199725
Default Alt Text: (48 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions