No OneTemporary
Actions

Size

33 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/examples/agent-functionalities/agent-functionalities.cpp b/examples/agent-functionalities/agent-functionalities.cpp
	index b09b72e..c1d77a1 100644
	--- a/examples/agent-functionalities/agent-functionalities.cpp
	+++ b/examples/agent-functionalities/agent-functionalities.cpp
	@@ -1,169 +1,183 @@
	//===-- examples/agent-functionalities/agent-functionalities.cpp -- C++--===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file examples/agent-functionalities/agent-functionalities.cpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017
	///
	/// \brief A simple example on defining \c rosa::Agent instances using
	/// \c rosa::agent::Functionality object as components.
	///
	//===----------------------------------------------------------------------===//

	#include "rosa/agent/Abstraction.hpp"
	-#include "rosa/agent/LinearFunctions.hpp"
	+#include "rosa/agent/FunctionAbstractions.hpp"
	+#include "rosa/agent/RangeConfidence.hpp"
	#include "rosa/agent/Confidence.hpp"

	#include "rosa/config/version.h"

	#include "rosa/core/Agent.hpp"
	#include "rosa/core/MessagingSystem.hpp"

	#include "rosa/support/log.h"
	#include "rosa/support/terminal_colors.h"

	#include <vector>

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

	/// A dummy wrapper for testing \c rosa::MessagingSystem.
	///
	/// \note Since we test \c rosa::MessagingSystem directly here, we need to get
	/// access to its protected members. That we do by imitating to be a decent
	/// subclass of \c rosa::MessagingSystem, while calling protected member
	/// functions on an object of a type from which we actually don't inherit.
	struct SystemTester : protected MessagingSystem {
	template <typename T, typename... Funs>
	static AgentHandle createMyAgent(MessagingSystem *S, const std::string &Name,
	Funs &&... Fs) {
	return ((SystemTester *)S)->createAgent<T>(Name, std::move(Fs)...);
	}

	static void destroyMyAgent(MessagingSystem *S, const AgentHandle &H) {
	((SystemTester *)S)->destroyUnit(unwrapAgent(H));
	}
	};

	/// A special \c rosa::Agent with its own state.
	class MyAgent : public Agent {
	public:
	using Tick = AtomConstant<atom("tick")>;

	private:
	enum class Categories { Bad, Normal, Good };

	static const std::map<Categories, const char *> CategoryNames;
	History<uint8_t, 10, HistoryPolicy::FIFO> H;
	Confidence<uint8_t> C;
	RangeAbstraction<uint8_t, Categories> A;
	PartialFunction<int, int> L;
	- RangeConfidence<float, float> RCL;
	- RangeConfidence<float, float> RCS;
	+ RangeConfidence<float, Categories, float> RCL;
	+ RangeConfidence<float, Categories, float> RCS;

	public:
	void handler(Tick, uint8_t V) noexcept {
	// Record \p V to the \c rosa::agent::History, then print state info.
	H << V;
	ASSERT(H.entry() == V); // Sanity check.
	LOG_INFO_STREAM << "\nNext value: " << PRINTABLE(V)
	<< ", confidence: " << C(H)
	<< ", category: " << CategoryNames.at(A(H.entry()))
	<< ", partial: " << int(L(H.entry()))
	<< ", range-confidence-linear: ";
	- std::vector<float> res_lin = RCL(H.entry());
	+
	+ std::map<Categories, float> res_lin = RCL(H.entry());
	for (auto i : res_lin){
	- LOG_INFO_STREAM << " " << i;
	+ LOG_INFO_STREAM << " " << CategoryNames.at(i.first)
	+ << " " << i.second << "," ;
	}
	- LOG_INFO_STREAM << ", range-confidence-sine: ";
	- std::vector<float> res_sine = RCS(H.entry());
	+ LOG_INFO_STREAM << " range-confidence-sine: ";
	+ std::map<Categories, float> res_sine = RCS(H.entry());
	for (auto i : res_sine){
	- LOG_INFO_STREAM << " " << i;
	+ LOG_INFO_STREAM << " " << CategoryNames.at(i.first)
	+ << " " << i.second << "," ;
	}
	LOG_INFO_STREAM << '\n';
	+
	}

	MyAgent(const AtomValue Kind, const rosa::id_t Id, const std::string &Name,
	MessagingSystem &S)
	: Agent(Kind, Id, Name, S, THISMEMBER(handler)), H(), C(5, 20, 1),
	A({{{(uint8_t)10, (uint8_t)14}, Categories::Normal},
	{{(uint8_t)15, (uint8_t)17}, Categories::Good},
	{{(uint8_t)18, (uint8_t)19}, Categories::Normal}},
	Categories::Bad),
	- L({{{0, 2}, new LinearFunction<int,int>(0, 1)},
	- {{2, 4}, new LinearFunction<int,int>(2, 0)},
	- {{4, 6}, new LinearFunction<int,int>(6, -1)}},
	+ L({{{0, 2}, std::make_shared<LinearFunction<int, int>>(0, 1)},
	+ {{2, 4}, std::make_shared<LinearFunction<int, int>>(2, 0)},
	+ {{4, 6}, std::make_shared<LinearFunction<int, int>>(6, -1)}},
	0),
	RCL({
	- PartialFunction<float, float>({
	- {{0, 3}, new LinearFunction<float, float>(0, 1.0/3)},
	- {{3, 6}, new LinearFunction<float, float>(1, 0)},
	- {{6, 9}, new LinearFunction<float, float>(3.0, -1.0/3)},
	- },0),
	- PartialFunction<float, float>({
	- {{6, 9}, new LinearFunction<float, float>(-2, 1.0/3)},
	- {{9, 12}, new LinearFunction<float, float>(1, 0)},
	- {{12, 15}, new LinearFunction<float, float>(5, -1.0/3)},
	- },0),
	- PartialFunction<float, float>({
	- {{12, 15}, new LinearFunction<float, float>(-4, 1.0/3)},
	- {{15, 18}, new LinearFunction<float, float>(1, 0)},
	- {{18, 21}, new LinearFunction<float, float>(7, -1.0/3)},
	- },0)
	+ {Categories::Bad, PartialFunction<float, float>({
	+ {{0, 3}, std::make_shared<LinearFunction<float, float>>
	+ (0, 1.0/3)},
	+ {{3, 6}, std::make_shared<LinearFunction<float, float>>
	+ (1, 0)},
	+ {{6, 9}, std::make_shared<LinearFunction<float, float>>
	+ (3.0, -1.0/3)},
	+ },0)},
	+ {Categories::Normal, PartialFunction<float, float>({
	+ {{6, 9}, std::make_shared<LinearFunction<float, float>>
	+ (-2, 1.0/3)},
	+ {{9, 12}, std::make_shared<LinearFunction<float, float>>
	+ (1, 0)},
	+ {{12, 15}, std::make_shared<LinearFunction<float, float>>
	+ (5, -1.0/3)},
	+ },0)},
	+ {Categories::Good, PartialFunction<float, float>({
	+ {{12, 15}, std::make_shared<LinearFunction<float, float>>
	+ (-4, 1.0/3)},
	+ {{15, 18}, std::make_shared<LinearFunction<float, float>>
	+ (1, 0)},
	+ {{18, 21}, std::make_shared<LinearFunction<float, float>>
	+ (7, -1.0/3)},
	+ },0)}
	}),
	RCS({
	- PartialFunction<float, float>({
	- {{0, 3}, new SineFunction<float, float>
	+ {Categories::Bad, PartialFunction<float, float>({
	+ {{0, 3}, std::make_shared<SineFunction<float, float>>
	(M_PI/3, 0.5, -M_PI/2, 0.5)},
	- {{3, 6}, new LinearFunction<float, float>(1, 0)},
	- {{6, 9}, new SineFunction<float, float>
	+ {{3, 6}, std::make_shared<LinearFunction<float, float>>(1, 0)},
	+ {{6, 9}, std::make_shared<SineFunction<float, float>>
	(M_PI/3, 0.5, -M_PI/2 + 3, 0.5)},
	- },0),
	- PartialFunction<float, float>({
	- {{6, 9}, new SineFunction<float, float>
	+ },0)},
	+ {Categories::Normal, PartialFunction<float, float>({
	+ {{6, 9}, std::make_shared<SineFunction<float, float>>
	(M_PI/3, 0.5, -M_PI/2, 0.5)},
	- {{9, 12}, new LinearFunction<float, float>(1, 0)},
	- {{12, 15}, new SineFunction<float, float>
	+ {{9, 12}, std::make_shared<LinearFunction<float, float>>(1, 0)},
	+ {{12, 15}, std::make_shared<SineFunction<float, float>>
	(M_PI/3, 0.5, -M_PI/2 + 3, 0.5)},
	- },0),
	- PartialFunction<float, float>({
	- {{12, 15}, new SineFunction<float, float>
	+ },0)},
	+ {Categories::Good, PartialFunction<float, float>({
	+ {{12, 15}, std::make_shared<SineFunction<float, float>>
	(M_PI/3, 0.5, -M_PI/2, 0.5)},
	- {{15, 18}, new LinearFunction<float, float>(1, 0)},
	- {{18, 21}, new SineFunction<float, float>
	+ {{15, 18}, std::make_shared<LinearFunction<float, float>>(1, 0)},
	+ {{18, 21}, std::make_shared<SineFunction<float, float>>
	(M_PI/3, 0.5, -M_PI/2 + 3, 0.5)},
	- },0)
	- }){}
	+ },0)}
	+ }, true){}
	};

	const std::map<MyAgent::Categories, const char *> MyAgent::CategoryNames{
	{Categories::Bad, "Bad"},
	{Categories::Normal, "Normal"},
	{Categories::Good, "Good"}};

	int main(void) {
	LOG_INFO_STREAM << library_string() << " -- " << Color::Red
	<< "agent-functionalities example" << Color::Default
	<< '\n';

	std::unique_ptr<MessagingSystem> S = MessagingSystem::createSystem("Sys");
	MessagingSystem *SP = S.get();

	AgentHandle A = SystemTester::createMyAgent<MyAgent>(SP, "MyAgent");

	std::vector<uint8_t> Vs{0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 13,
	15, 14, 15, 16, 19, 20, 21};
	for (auto I = Vs.begin(); I != Vs.end(); ++I) {
	A.send<MyAgent::Tick, uint8_t>(MyAgent::Tick::Value, *I);
	}

	SystemTester::destroyMyAgent(SP, A);

	return 0;
	}
	diff --git a/include/rosa/agent/Abstraction.hpp b/include/rosa/agent/Abstraction.hpp
	index fa9e03e..032c970 100644
	--- a/include/rosa/agent/Abstraction.hpp
	+++ b/include/rosa/agent/Abstraction.hpp
	@@ -1,193 +1,225 @@
	//===-- rosa/agent/Abstraction.hpp ------------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/agent/Abstraction.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017
	///
	/// \brief Definition of abstraction functionality.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_AGENT_ABSTRACTION_HPP
	#define ROSA_AGENT_ABSTRACTION_HPP

	#include "rosa/agent/Functionality.h"

	#include "rosa/support/debug.hpp"

	#include <algorithm>
	#include <map>

	namespace rosa {
	namespace agent {

	/// Abstracts values from a type to another one.
	///
	/// \tparam T type to abstract from
	/// \tparam A type to abstract to
	template <typename T, typename A> class Abstraction : public Functionality {
	protected:
	/// Value to abstract to by default.
	const A Default;
	-
	public:
	/// Creates an instance.
	///
	/// \param Default value to abstract to by default
	Abstraction(const A Default) noexcept : Default(Default) {}

	/// Destroys \p this object.
	~Abstraction(void) = default;

	+ /// Checks wether the Abstraction evaluates to default at the given position
	+ bool isDefaultAt(const T &V) const{
	+ (void)V;
	+ return true;
	+ }
	+
	/// Abstracts a value from type \p T to type \p A.
	///
	/// \note The default implementation always returns
	/// \c rosa::agent::Abstraction::Default, hence the actual argument is
	/// ignored.
	///
	/// \return the abstracted value
	virtual A operator()(const T &) const noexcept { return Default; }
	};

	/// Implements \c rosa::agent::Abstraction as a \c std::map from a type to
	/// another one.
	///
	/// \note This implementation is supposed to be used to abstract between
	/// enumeration types, which is statically enforced.
	///
	/// \tparam T type to abstract from
	/// \tparam A type to abstract to
	template <typename T, typename A>
	class MapAbstraction : public Abstraction<T, A>, private std::map<T, A> {
	// Make sure the actual type arguments are enumerations.
	STATIC_ASSERT((std::is_enum<T>::value && std::is_enum<A>::value),
	"mapping not enumerations");

	// Bringing into scope inherited members.
	using Abstraction<T, A>::Default;
	using std::map<T, A>::end;
	using std::map<T, A>::find;

	public:
	/// Creates an instance by initializing the underlying \c std::map.
	///
	/// \param Map the mapping to do abstraction according to
	/// \param Default value to abstract to by default
	MapAbstraction(const std::map<T, A> &Map, const A Default) noexcept
	: Abstraction<T, A>(Default),
	std::map<T, A>(Map) {}

	/// Destroys \p this object.
	~MapAbstraction(void) = default;

	+ /// Checks wether the Abstraction evaluates to default at the given position
	+ bool isDefaultAt(const T &V) const {
	+ const auto I = find(V);
	+ return I == end() ? true : false;
	+ }
	+
	/// Abstracts a value from type \p T to type \p A based on the set mapping.
	///
	/// Results in the value associated by the set mapping to the argument, or
	/// \c rosa::agent::MapAbstraction::Default if the actual argument is not
	/// associated with anything by the set mapping.
	///
	/// \param V value to abstract
	///
	/// \return the abstracted value based on the set mapping
	A operator()(const T &V) const noexcept override {
	const auto I = find(V);
	return I == end() ? Default : *I;
	}
	};

	/// Implements \c rosa::agent::Abstraction as a \c std::map from ranges of a
	/// type to values of another type.
	///
	/// \note This implementation is supposed to be used to abstract ranges of
	/// arithmetic types into enumerations, which is statically enforced.
	///
	/// \invariant The keys in the underlying \c std::map define valid ranges
	/// such that `first <= second` and there are no overlapping ranges defined by
	/// the keys.
	///
	/// \tparam T type to abstract from
	/// \tparam A type to abstract to
	template <typename T, typename A>
	class RangeAbstraction : public Abstraction<T, A>,
	private std::map<std::pair<T, T>, A> {
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<T>::value), "abstracting not arithmetic");
	/// \todo check if this compiles with the definition of abstractions as
	/// self-aware properties
	//STATIC_ASSERT((std::is_enum<A>::value), "abstracting not to enumeration");

	// Bringing into scope inherited members.
	using Abstraction<T, A>::Default;
	using std::map<std::pair<T, T>, A>::begin;
	using std::map<std::pair<T, T>, A>::end;
	using std::map<std::pair<T, T>, A>::find;

	public:
	/// Creates an instance by Initializing the unserlying \c std::map.
	///
	/// \param Map the mapping to do abstraction according to
	/// \param Default value to abstract to by default
	///
	/// \pre Each key defines a valid range such that `first <= second` and
	/// there are no overlapping ranges defined by the keys.
	RangeAbstraction(const std::map<std::pair<T, T>, A> &Map, const A &Default)
	: Abstraction<T, A>(Default), std::map<std::pair<T, T>, A>(Map) {
	// Sanity check.
	ASSERT(std::all_of(
	begin(), end(), [this](const std::pair<std::pair<T, T>, A> &P) {
	return P.first.first <= P.first.second &&
	std::all_of(++find(P.first), end(),
	[&P](const std::pair<std::pair<T, T>, A> &R) {
	// \note Values in \c Map are sorted.
	return P.first.first < P.first.second &&
	P.first.second <= R.first.first \|\|
	P.first.first == P.first.second &&
	P.first.second < R.first.first;
	});
	}));
	}

	/// Destroys \p this object.
	~RangeAbstraction(void) = default;

	+ /// Checks wether the Abstraction evaluates to default at the given position
	+ bool isDefaultAt(const T &V) const{
	+ auto I = begin();
	+ bool Found = false; // Indicates if \c I refers to a matching range.
	+ bool Failed = false; // Indicates if it is pointless to continue searching.
	+ while (!Found && !Failed && I != end()) {
	+ if (V < I->first.first) {
	+ // No match so far and \p V is below the next range, never will match.
	+ // \note Keys are sorted in the map.
	+ return true;
	+ } else if (I->first.first <= V && V < I->first.second) {
	+ // Matching range found.
	+ return false;
	+ } else {
	+ // Cannot conclude in this step, move to the next range.
	+ ++I;
	+ }
	+ }
	+ return true;
	+ }
	+
	/// Abstracts a value from type \p T to type \p A based on the set mapping.
	///
	/// Results in the value associated by the set mapping to the argument, or
	/// \c rosa::agent::RangeAbstraction::Default if the actual argument is not
	/// included in any of the ranges in the set mapping.
	///
	/// \param V value to abstract
	///
	/// \return the abstracted value based on the set mapping
	A operator()(const T &V) const noexcept override {
	auto I = begin();
	bool Found = false; // Indicates if \c I refers to a matching range.
	bool Failed = false; // Indicates if it is pointless to continue searching.
	while (!Found && !Failed && I != end()) {
	if (V < I->first.first) {
	// No match so far and \p V is below the next range, never will match.
	// \note Keys are sorted in the map.
	Failed = true;
	} else if (I->first.first <= V && V < I->first.second) {
	// Matching range found.
	Found = true;
	} else {
	// Cannot conclude in this step, move to the next range.
	++I;
	}
	}
	ASSERT(!Found \|\| I != end());
	return Found ? I->second : Default;
	}
	};

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

	#endif // ROSA_AGENT_ABSTRACTION_HPP
	diff --git a/include/rosa/agent/LinearFunctions.hpp b/include/rosa/agent/FunctionAbstractions.hpp
	similarity index 66%
	rename from include/rosa/agent/LinearFunctions.hpp
	rename to include/rosa/agent/FunctionAbstractions.hpp
	index b0eceaa..606125a 100644
	--- a/include/rosa/agent/LinearFunctions.hpp
	+++ b/include/rosa/agent/FunctionAbstractions.hpp
	@@ -1,224 +1,194 @@
	-//===-- rosa/agent/LinearAbstractions.hpp --------------------------- C++ --===//
	+//===-- rosa/agent/FunctionAbstractions.hpp ---------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	-/// \file rosa/agent/LinearAbstractions.hpp
	+/// \file rosa/agent/FunctionAbstractions.hpp
	///
	/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
	///
	/// \date 2019
	///
	-/// \brief Definition of LinearFunction functionality.
	+/// \brief Definition of FunctionAbstractions functionality.
	///
	//===----------------------------------------------------------------------===//

	-#ifndef ROSA_AGENT_LINEARFUNCTIONS_HPP
	-#define ROSA_AGENT_LINEARFUNCTIONS_HPP
	+#ifndef ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP
	+#define ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP

	#include "rosa/agent/Functionality.h"
	#include "rosa/agent/Abstraction.hpp"

	#include "rosa/support/debug.hpp"

	#include <algorithm>
	#include <vector>
	#include <cmath>
	+#include <memory>

	namespace rosa {
	namespace agent {

	/// Evaluates a linear function at a given value.
	///
	/// \tparam T type of the functions domain
	/// \tparam A type of the functions range
	template <typename T, typename A> class LinearFunction :
	public Abstraction<T, A>{
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<T>::value),
	"LinearFunction not arithmetic T");
	STATIC_ASSERT((std::is_arithmetic<A>::value),
	"LinearFunction not to arithmetic");
	protected:
	const T Intercept;
	const T Coefficient;

	public:
	/// Creates an instance.
	///
	/// \param Intercept the intercept of the linear function
	/// \param Coefficient the coefficient of the linear function
	/// domain
	LinearFunction(T Intercept, T Coefficient) noexcept
	: Abstraction<T, A>(Intercept),
	Intercept(Intercept),
	Coefficient(Coefficient) {}

	/// Destroys \p this object.
	~LinearFunction(void) = default;

	+ /// Checks wether the Abstraction evaluates to default at the given position
	+ /// As LinearFunctions can be evaluated everythwere, this is always false
	+ bool isDefaultAt(const T &V) const{
	+ (void)V;
	+ return false;
	+ }
	+
	/// Evaluates the linear function
	///
	/// \param X the value at which to evaluate the function
	/// \return the result
	virtual A operator()(const T &X) const noexcept override {
	return Intercept + X*Coefficient;
	}
	};

	/// Evaluates a sine function at a given value.
	///
	/// \tparam T type of the functions domain
	/// \tparam A type of the functions range
	template <typename T, typename A> class SineFunction :
	public Abstraction<T, A>{
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<T>::value),
	"SineFunction not arithmetic T");
	STATIC_ASSERT((std::is_arithmetic<A>::value),
	"SineFunction not to arithmetic");
	protected:
	const T Frequency;
	const T Amplitude;
	const T Phase;
	const T Average;

	public:
	/// Creates an instance.
	///
	/// \param Frequency the frequency of the sine wave
	/// \param Amplitude the amplitude of the sine wave
	/// \param Phase the phase of the sine wave
	/// \param Average the average of the sine wave
	/// domain
	SineFunction(T Frequency, T Amplitude, T Phase, T Average) noexcept
	: Abstraction<T, A>(Average),
	Frequency(Frequency),
	Amplitude(Amplitude),
	Phase(Phase),
	Average(Average) {}

	/// Destroys \p this object.
	~SineFunction(void) = default;

	+ /// Checks wether the Abstraction evaluates to default at the given position
	+ /// As SineFunctions can be evaluated everythwere, this is always false
	+ bool isDefaultAt(const T &V) const{
	+ (void)V;
	+ return false;
	+ }
	+
	/// Evaluates the linear function
	///
	/// \param X the value at which to evaluate the function
	/// \return the result
	virtual A operator()(const T &X) const noexcept override {
	return Amplitudesin(Frequency X + Phase) + Average;
	}
	};

	/// Implements \c rosa::agent::RangeAbstraction as an abstraction from
	/// \c std::map from ranges of a type to abstractions of that type to another
	/// type. The resulting abstractions are evaluated for the given values.
	///
	/// \note This implementation is supposed to be used to abstract ranges of
	/// arithmetic types into abstractions from that type to another arithmetic
	/// type, which is statically enforced.
	///
	/// \invariant The keys in the underlying \c std::map define valid ranges
	/// such that `first <= second` and there are no overlapping ranges defined by
	/// the keys.
	///
	/// \tparam T type to abstract from
	/// \tparam A type to abstract to
	template <typename T, typename A>
	-class PartialFunction : private Abstraction<T, A> {
	+class PartialFunction : public Abstraction<T, A> {
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<T>::value), "abstracting not arithmetic");
	STATIC_ASSERT((std::is_arithmetic<A>::value),
	"abstracting not to arithmetic");

	private:
	- RangeAbstraction<T, Abstraction<T, A>*> RA;
	+ RangeAbstraction<T, std::shared_ptr<Abstraction<T, A>>> RA;

	public:
	/// Creates an instance by Initializing the underlying \c RangeAbstraction.
	///
	/// \param Map the mapping to do abstraction according to
	/// \param Default abstraction to abstract to by default
	///
	/// \pre Each key defines a valid range such that `first <= second` and
	/// there are no overlapping ranges defined by the keys.
	- PartialFunction(const std::map<std::pair<T, T>, Abstraction<T, A>*> &Map,
	+ PartialFunction(const std::map<std::pair<T, T>,
	+ std::shared_ptr<Abstraction<T, A>>> &Map,
	const A Default)
	- : Abstraction<T, A>(Default), RA(Map, new Abstraction<T, A>(Default)) {
	+ : Abstraction<T, A>(Default),
	+ RA(Map, std::shared_ptr<Abstraction<T, A>>
	+ (new Abstraction<T, A>(Default))) {
	}

	/// Destroys \p this object.
	~PartialFunction(void) = default;

	- /// Evaluates an Abstraction from type \p T to type \p A based on the set
	- /// mapping.
	- ///
	- /// Results in the value associated by the set mapping to the argument, or
	- /// \c rosa::agent::RangeAbstraction::Default if the actual argument is not
	- /// included in any of the ranges in the set mapping.
	- ///
	- /// \param V value to abstract
	- ///
	- /// \return the abstracted value based on the set mapping
	- A operator()(const T &V) const noexcept override {
	- return (*RA(V))(V);
	+ /// Checks wether the Abstraction evaluates to default at the given position
	+ bool isDefaultAt(const T &V) const{
	+ return RA.isDefaultAt(V);
	}
	-};
	-
	-/// Evaluates a vector of Abstractions at a given value and returns the results
	-/// as a vector
	-///
	-/// \note This implementation is supposed to be used to abstract ranges of
	-/// arithmetic types into vectors of another arithmetic type, which is
	-/// statically enforced.
	-///
	-/// \tparam T type to abstract from
	-/// \tparam A type to abstract a vector of to
	-template <typename T, typename A>
	-class RangeConfidence : public Abstraction<T, std::vector<A>>,
	- private std::vector<PartialFunction<T, A>>{
	- // Make sure the actual type arguments are matching our expectations.
	- STATIC_ASSERT((std::is_arithmetic<T>::value), "abstracting not arithmetic");
	- STATIC_ASSERT((std::is_arithmetic<A>::value),
	- "abstracting not to arithmetic");
	-
	- // Bringing into scope inherited members.
	- using std::vector<PartialFunction<T, A>>::size;
	- using std::vector<PartialFunction<T, A>>::begin;
	- using std::vector<PartialFunction<T, A>>::end;
	-
	-public:
	- /// Creates an instance by Initializing the underlying \c RangeAbstraction.
	- ///
	- /// \param Abstractions the Abstractions to be evaluated
	- RangeConfidence(const std::vector<PartialFunction<T, A>> &Abstractions)
	- : Abstraction<T, std::vector<A>>({}),
	- std::vector<PartialFunction<T, A>>(Abstractions) {
	- }
	-
	- /// Destroys \p this object.
	- ~RangeConfidence(void) = default;

	/// Evaluates an Abstraction from type \p T to type \p A based on the set
	/// mapping.
	///
	/// Results in the value associated by the set mapping to the argument, or
	/// \c rosa::agent::RangeAbstraction::Default if the actual argument is not
	/// included in any of the ranges in the set mapping.
	///
	/// \param V value to abstract
	///
	/// \return the abstracted value based on the set mapping
	- std::vector<A> operator()(const T &V) const noexcept override {
	- std::vector<A> ret;
	- for (auto const& func : ((std::vector<PartialFunction<T, A>>)*this)){
	- ret.push_back(func(V));
	- }
	- return ret;
	+ A operator()(const T &V) const noexcept override {
	+ return RA(V)->operator()(V);
	}
	};
	} // End namespace agent
	} // End namespace rosa

	-#endif // ROSA_AGENT_ABSTRACTION_HPP
	+#endif // ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP
	diff --git a/include/rosa/agent/RangeConfidence.hpp b/include/rosa/agent/RangeConfidence.hpp
	new file mode 100644
	index 0000000..83ba518
	--- /dev/null
	+++ b/include/rosa/agent/RangeConfidence.hpp
	@@ -0,0 +1,90 @@
	+//===-- rosa/agent/RangeConfidence.hpp --------------------------- C++ --===//
	+//
	+// The RoSA Framework
	+//
	+//===----------------------------------------------------------------------===//
	+///
	+/// \file rosa/agent/RangeConfidence.hpp
	+///
	+/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
	+///
	+/// \date 2019
	+///
	+/// \brief Definition of RangeConfidence functionality.
	+///
	+//===----------------------------------------------------------------------===//
	+
	+#ifndef ROSA_AGENT_RANGECONFIDENCE_HPP
	+#define ROSA_AGENT_RANGECONFIDENCE_HPP
	+
	+#include "rosa/agent/Functionality.h"
	+#include "rosa/agent/Abstraction.hpp"
	+#include "rosa/agent/FunctionAbstractions.hpp"
	+
	+#include "rosa/support/debug.hpp"
	+
	+#include <algorithm>
	+#include <vector>
	+#include <cmath>
	+#include <memory>
	+
	+namespace rosa {
	+namespace agent {
	+
	+/// Evaluates a vector of Abstractions at a given value and returns the results
	+/// as a vector
	+///
	+/// \note This implementation is supposed to be used to abstract ranges of
	+/// arithmetic types into vectors of another arithmetic type, which is
	+/// statically enforced.
	+///
	+/// \tparam T type to abstract from
	+/// \tparam A type to abstract a vector of to
	+template <typename T, typename A, typename B>
	+class RangeConfidence : protected Abstraction<T, std::map<A, B>>,
	+ private std::map<A, PartialFunction<T, B>>{
	+ // Make sure the actual type arguments are matching our expectations.
	+ STATIC_ASSERT((std::is_arithmetic<T>::value), "abstracting not arithmetic");
	+ STATIC_ASSERT((std::is_arithmetic<B>::value),
	+ "abstracting not to arithmetic");
	+
	+private:
	+ bool IgnoreDefaults;
	+
	+public:
	+ /// Creates an instance by Initializing the underlying \c RangeAbstraction.
	+ ///
	+ /// \param Abstractions the Abstractions to be evaluated
	+ RangeConfidence(const std::map<A, PartialFunction<T, B>> &Abstractions,
	+ bool IgnoreDefaults = false)
	+ : Abstraction<T, std::map<A, B>>({}),
	+ std::map<A, PartialFunction<T, B>>(Abstractions),
	+ IgnoreDefaults(IgnoreDefaults){
	+ }
	+
	+ /// Destroys \p this object.
	+ ~RangeConfidence(void) = default;
	+
	+ /// Evaluates an Abstraction from type \p T to type \p A based on the set
	+ /// mapping.
	+ ///
	+ /// Results in the value associated by the set mapping to the argument, or
	+ /// \c rosa::agent::RangeAbstraction::Default if the actual argument is not
	+ /// included in any of the ranges in the set mapping.
	+ ///
	+ /// \param V value to abstract
	+ ///
	+ /// \return the abstracted value based on the set mapping
	+ std::map<A, B> operator()(const T &V) const noexcept override {
	+ std::map<A, B> ret;
	+ for (auto const& p : ((std::map<A, PartialFunction<T, B>>)*this)){
	+ if(!IgnoreDefaults \|\| !p.second.isDefaultAt(V))
	+ ret.insert(std::pair<A, B>(p.first, p.second(V)));
	+ }
	+ return ret;
	+ }
	+};
	+} // End namespace agent
	+} // End namespace rosa
	+
	+#endif // ROSA_AGENT_RANGECONFIDENCE_HPP
	diff --git a/lib/agent/CMakeLists.txt b/lib/agent/CMakeLists.txt
	index 38b5f83..d4bdebc 100644
	--- a/lib/agent/CMakeLists.txt
	+++ b/lib/agent/CMakeLists.txt
	@@ -1,18 +1,20 @@
	set(LIB_INCLUDE_DIR ${ROSA_MAIN_INCLUDE_DIR}/rosa/agent)

	add_library(ROSAAgent
	${LIB_INCLUDE_DIR}/namespace.h
	namespace.cpp
	${LIB_INCLUDE_DIR}/Functionality.h
	Functionality.cpp
	${LIB_INCLUDE_DIR}/Abstraction.hpp
	Abstraction.cpp
	- ${LIB_INCLUDE_DIR}/LinearFunctions.hpp
	- LinearFunctions.cpp
	+ ${LIB_INCLUDE_DIR}/FunctionAbstractions.hpp
	+ FunctionAbstractions.cpp
	+ ${LIB_INCLUDE_DIR}/RangeConfidence.hpp
	+ RangeConfidence.cpp
	${LIB_INCLUDE_DIR}/History.hpp
	History.cpp
	${LIB_INCLUDE_DIR}/Confidence.hpp
	Confidence.cpp
	${LIB_INCLUDE_DIR}/CrossReliability.h
	CrossReliability.cpp
	)
	diff --git a/lib/agent/LinearFunctions.cpp b/lib/agent/FunctionAbstractions.cpp
	similarity index 60%
	copy from lib/agent/LinearFunctions.cpp
	copy to lib/agent/FunctionAbstractions.cpp
	index 0b43abe..0206760 100644
	--- a/lib/agent/LinearFunctions.cpp
	+++ b/lib/agent/FunctionAbstractions.cpp
	@@ -1,20 +1,20 @@
	-//===-- agent/LinearFunctions.cpp -------------------------------- C++ --===//
	+//===-- agent/FunctionAbstractions.cpp --------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	-/// \file agent/LinearFunctions.cpp
	+/// \file agent/FunctionAbstractions.cpp
	///
	/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
	///
	/// \date 2019
	///
	-/// \brief Implementation for rosa/agent/LinearFunctions.hpp.
	+/// \brief Implementation for rosa/agent/FunctionAbstractions.hpp.
	///
	/// \note Empty implementation, source file here to have a compile database
	-/// entry for rosa/agent/LinearFunctions.hpp.
	+/// entry for rosa/agent/FunctionAbstractions.hpp.
	///
	//===----------------------------------------------------------------------===//

	-#include "rosa/agent/LinearFunctions.hpp"
	+#include "rosa/agent/FunctionAbstractions.hpp"
	diff --git a/lib/agent/LinearFunctions.cpp b/lib/agent/RangeConfidence.cpp
	similarity index 61%
	rename from lib/agent/LinearFunctions.cpp
	rename to lib/agent/RangeConfidence.cpp
	index 0b43abe..415f11f 100644
	--- a/lib/agent/LinearFunctions.cpp
	+++ b/lib/agent/RangeConfidence.cpp
	@@ -1,20 +1,20 @@
	-//===-- agent/LinearFunctions.cpp -------------------------------- C++ --===//
	+//===-- agent/RangeConfidence.cpp -------------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	-/// \file agent/LinearFunctions.cpp
	+/// \file agent/RangeConfidence.cpp
	///
	/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
	///
	/// \date 2019
	///
	-/// \brief Implementation for rosa/agent/LinearFunctions.hpp.
	+/// \brief Implementation for rosa/agent/RangeConfidence.hpp.
	///
	/// \note Empty implementation, source file here to have a compile database
	-/// entry for rosa/agent/LinearFunctions.hpp.
	+/// entry for rosa/agent/RangeConfidence.hpp.
	///
	//===----------------------------------------------------------------------===//

	-#include "rosa/agent/LinearFunctions.hpp"
	+#include "rosa/agent/RangeConfidence.hpp"

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 10:00 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157219
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions