No OneTemporary
Actions

Size

28 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/apps/ccam/ccam.cpp b/apps/ccam/ccam.cpp
	index 8acea3f..e1668e6 100644
	--- a/apps/ccam/ccam.cpp
	+++ b/apps/ccam/ccam.cpp
	@@ -1,383 +1,383 @@
	//===-- apps/ccam/ccam.cpp --------------------------------------- C++ --===//
	//
	// The RoSA Framework -- Application CCAM
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file apps/ccam/ccam.cpp
	///
	/// \author Maximilian Goetzinger (maximilian.goetzinger@tuwien.ac.at)
	/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
	///
	/// \date 2019
	///
	/// \brief The application CCAM implements the case study from the paper:
	/// M. Goetzinger, N. TaheriNejad, H. A. Kholerdi, A. Jantsch, E. Willegger,
	/// T. Glatzl, A.M. Rahmani, T.Sauter, P. Liljeberg: Model - Free Condition
	/// Monitoring with Confidence
	//===----------------------------------------------------------------------===//
	#include "rosa/agent/Abstraction.hpp"
	#include "rosa/agent/Confidence.hpp"
	#include "rosa/agent/FunctionAbstractions.hpp"
	#include <iostream>

	#include "rosa/config/version.h"

	#include "rosa/agent/SignalStateDetector.hpp"
	#include "rosa/agent/SystemStateDetector.hpp"
	#include "rosa/deluxe/DeluxeContext.hpp"

	#include "rosa/support/csv/CSVReader.hpp"
	#include "rosa/support/csv/CSVWriter.hpp"

	#include <fstream>
	#include <limits>
	#include <memory>
	#include <streambuf>

	#include "configuration.h"

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

	const std::string AppName = "CCAM";

	//@maxi I don't know what you want to do but if you want to have the agent be a
	//"lowlevel" agent which gives its master a tuple with all of that info you have
	// to do it as it is done in the #else. To be fair I don't know if the return
	// SignalStateTuple(); is allowed
	#if false
	using SignalStateTuple =
	std::tuple<Optional<float>, Optional<unsigned int>, Optional<float>,
	Optional<uint8_t>, Optional<unsigned int>, Optional<bool>,
	Optional<bool>, Optional<bool>, Optional<bool>>;

	AgentHandle createSignalStateDetectorAgent(
	std::unique_ptr<DeluxeContext> &C, const std::string &Name,
	std::shared_ptr<
	SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>
	SigSD) {
	(void)SigSD;

	using Handler = std::function<SignalStateTuple(std::pair<float, bool>)>;

	return C->createAgent(
	Name,
	Handler([&Name, &SigSD](std::pair<float, bool> I) -> SignalStateTuple {
	LOG_INFO_STREAM << "\n******\n"
	<< Name << " " << (I.second ? "<New>" : "<Old>")
	<< " value: " << I.first << "\n******\n";
	auto StateInfo = SigSD->detectSignalState(I.first);

	if (I.second)
	return std::make_tuple(
	Optional<float>(I.first),
	Optional<unsigned int>(StateInfo.SignalStateID),
	Optional<float>(StateInfo.SignalStateConfidence),
	Optional<uint8_t>(StateInfo.SignalStateCondition),
	Optional<unsigned int>(
	StateInfo.NumberOfInsertedSamplesAfterEntrance),
	Optional<bool>(StateInfo.SignalStateIsValid),
	Optional<bool>(StateInfo.SignalStateJustGotValid),
	Optional<bool>(StateInfo.SignalStateIsValidAfterReentrance),
	Optional<bool>(StateInfo.SignalIsStable));
	return SignalStateTuple();
	}));
	}
	#else

	using tup = DeluxeTuple<float, unsigned int, float, uint8_t, unsigned int, bool,
	bool, bool, bool>;
	using SignalStateTuple = Optional<tup>;

	AgentHandle createSignalStateDetectorAgent(
	std::unique_ptr<DeluxeContext> &C, const std::string &Name,
	std::shared_ptr<
	SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>
	SigSD) {
	(void)SigSD;
	using Handler =
	std::function<SignalStateTuple(std::pair<DeluxeTuple<float>, bool>)>;
	return C->createAgent(
	Name,
	Handler([&Name, &SigSD](
	std::pair<DeluxeTuple<float>, bool> I) -> SignalStateTuple {
	LOG_INFO_STREAM << "\n******\n"
	<< Name << " " << (I.second ? "<New>" : "<Old>")
	<< " value: " << std::get<0>(I.first) << "\n******\n";
	auto StateInfo = SigSD->detectSignalState(std::get<0>(I.first));
	if (I.second)
	return {tup(
	std::get<0>(I.first), StateInfo.SignalStateID,
	StateInfo.SignalStateConfidence, StateInfo.SignalStateCondition,
	StateInfo.NumberOfInsertedSamplesAfterEntrance,
	StateInfo.SignalStateIsValid, StateInfo.SignalStateJustGotValid,
	StateInfo.SignalStateIsValidAfterReentrance,
	StateInfo.SignalIsStable)};
	return SignalStateTuple();
	}));
	}

	#endif

	int main(int argc, char **argv) {

	LOG_INFO_STREAM << '\n'
	<< library_string() << " -- " << Color::Red << AppName
	<< "app" << Color::Default << '\n';

	if (argc < 2) {
	LOG_ERROR("Specify config File!\nUsage:\n\tccam config.json");
	return 1;
	}
	std::string ConfigPath = argv[1];

	if (!readConfigFile(ConfigPath)) {
	LOG_ERROR_STREAM << "Could not read config from \"" << ConfigPath << "\"\n";
	return 2;
	}

	std::string InputFilePath, OutputFilePath;

	LOG_INFO("Creating Context");
	std::unique_ptr<DeluxeContext> C = DeluxeContext::create(AppName);

	LOG_INFO("Creating sensors, SignalStateDetector functionalities and their "
	"Abstractions.");
	std::vector<AgentHandle> Sensors;
	std::vector<std::shared_ptr<PartialFunction<float, float>>>
	SampleMatchesFunctions;
	std::vector<std::shared_ptr<PartialFunction<float, float>>>
	SampleMismatchesFunctions;
	std::vector<std::shared_ptr<PartialFunction<float, float>>>
	SignalIsStableFunctions;
	std::vector<std::shared_ptr<PartialFunction<float, float>>>
	SignalIsDriftingFunctions;
	std::vector<std::shared_ptr<StepFunction<float, float>>>
	NumOfSamplesMatchFunctions;
	std::vector<std::shared_ptr<StepFunction<float, float>>>
	NumOfSamplesMismatchFunctions;
	std::vector<SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>
	SignalStateDetectors;
	std::vector<AgentHandle> SignalStateDetectorAgents;
	for (auto SignalConfiguration : AppConfig.SignalConfigurations) {
	//
	// Create deluxe sensors.
	//
	Sensors.emplace_back(C->createSensor<float>(SignalConfiguration.Name));

	//
	// Create functionalities for SignalStateDetector.
	//
	SampleMatchesFunctions.emplace_back(new PartialFunction<float, float>(
	{
	{{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound},
	std::make_shared<LinearFunction<float, float>>(
	-SignalConfiguration.OuterBound, 0.f,
	-SignalConfiguration.InnerBound, 1.f)},
	{{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound},
	std::make_shared<LinearFunction<float, float>>(1.f, 0.f)},
	{{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound},
	std::make_shared<LinearFunction<float, float>>(
	SignalConfiguration.InnerBound, 1.f,
	SignalConfiguration.OuterBound, 0.f)},
	},
	0));

	SampleMismatchesFunctions.emplace_back(new PartialFunction<float, float>(
	{
	{{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound},
	std::make_shared<LinearFunction<float, float>>(
	-SignalConfiguration.OuterBound, 1.f,
	-SignalConfiguration.InnerBound, 0.f)},
	{{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound},
	std::make_shared<LinearFunction<float, float>>(0.f, 0.f)},
	{{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound},
	std::make_shared<LinearFunction<float, float>>(
	SignalConfiguration.InnerBound, 0.f,
	SignalConfiguration.OuterBound, 1.f)},
	},
	1));

	SignalIsStableFunctions.emplace_back(new PartialFunction<float, float>(
	{
	{{-SignalConfiguration.OuterBoundDrift,
	-SignalConfiguration.InnerBoundDrift},
	std::make_shared<LinearFunction<float, float>>(
	-SignalConfiguration.OuterBoundDrift, 0.f,
	-SignalConfiguration.InnerBoundDrift, 1.f)},
	{{-SignalConfiguration.InnerBoundDrift,
	SignalConfiguration.InnerBoundDrift},
	std::make_shared<LinearFunction<float, float>>(1.f, 0.f)},
	{{SignalConfiguration.InnerBoundDrift,
	SignalConfiguration.OuterBoundDrift},
	std::make_shared<LinearFunction<float, float>>(
	SignalConfiguration.InnerBoundDrift, 1.f,
	SignalConfiguration.OuterBoundDrift, 0.f)},
	},
	0));

	SignalIsDriftingFunctions.emplace_back(new PartialFunction<float, float>(
	{
	{{-SignalConfiguration.OuterBoundDrift,
	-SignalConfiguration.InnerBoundDrift},
	std::make_shared<LinearFunction<float, float>>(
	-SignalConfiguration.OuterBoundDrift, 1.f,
	-SignalConfiguration.InnerBoundDrift, 0.f)},
	{{-SignalConfiguration.InnerBoundDrift,
	SignalConfiguration.InnerBoundDrift},
	std::make_shared<LinearFunction<float, float>>(0.f, 0.f)},
	{{SignalConfiguration.InnerBoundDrift,
	SignalConfiguration.OuterBoundDrift},
	std::make_shared<LinearFunction<float, float>>(
	SignalConfiguration.InnerBoundDrift, 0.f,
	SignalConfiguration.OuterBoundDrift, 1.f)},
	},
	1));

	NumOfSamplesMatchFunctions.emplace_back(new StepFunction<float, float>(
	1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepUp));

	NumOfSamplesMismatchFunctions.emplace_back(new StepFunction<float, float>(
	1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepDown));

	//
	// Create SignalStateDetector functionality
	//
	SignalStateDetectors.emplace_back(
	std::numeric_limits<int>::max(), SampleMatchesFunctions.back(),
	SampleMismatchesFunctions.back(), NumOfSamplesMatchFunctions.back(),
	NumOfSamplesMismatchFunctions.back(), SignalIsDriftingFunctions.back(),
	SignalIsStableFunctions.back(), SignalConfiguration.SampleHistorySize,
	SignalConfiguration.DABSize, SignalConfiguration.DABHistorySize);

	//
	// Create low-level deluxe agents
	//
	// SignalStateDetectorAgents.push_back(createSignalStateDetectorAgent(
	// C, SignalConfiguration.Name, SignalStateDetectors.back()));

	//
	// Connect sensors to low-level agents.
	//
	LOG_INFO("Connect sensors to their corresponding low-level agents.");

	C->connectSensor(SignalStateDetectorAgents.back(), 0, Sensors.back(),
	"HR Sensor Channel");
	}

	- std::shared_ptr<PartialFunction<float, float>> BrokenDelayFunction(
	- new PartialFunction<float, float>(
	+ std::shared_ptr<PartialFunction<uint32_t, float>> BrokenDelayFunction(
	+ new PartialFunction<uint32_t, float>(
	{{{0, AppConfig.BrokenCounter},
	- std::make_shared<LinearFunction<float, float>>(
	+ std::make_shared<LinearFunction<uint32_t, float>>(
	0, 0.f, AppConfig.BrokenCounter, 1.f)},
	- {{AppConfig.BrokenCounter, std::numeric_limits<float>::max()},
	- std::make_shared<LinearFunction<float, float>>(1.f, 0.f)}},
	- 0));
	+ {{AppConfig.BrokenCounter, std::numeric_limits<uint32_t>::max()},
	+ std::make_shared<LinearFunction<uint32_t, float>>(1.f, 0.f)}},
	+ 0.f));

	- std::shared_ptr<PartialFunction<float, float>> OkDelayFunction(
	- new PartialFunction<float, float>(
	+ std::shared_ptr<PartialFunction<uint32_t, float>> OkDelayFunction(
	+ new PartialFunction<uint32_t, float>(
	{{{0, AppConfig.BrokenCounter},
	- std::make_shared<LinearFunction<float, float>>(
	+ std::make_shared<LinearFunction<uint32_t, float>>(
	0, 1.f, AppConfig.BrokenCounter, 0.f)},
	- {{AppConfig.BrokenCounter, std::numeric_limits<float>::max()},
	- std::make_shared<LinearFunction<float, float>>(0.f, 0.f)}},
	- 1));
	+ {{AppConfig.BrokenCounter, std::numeric_limits<uint32_t>::max()},
	+ std::make_shared<LinearFunction<uint32_t, float>>(0.f, 0.f)}},
	+ 1.f));

	std::shared_ptr<
	- SystemStateDetector<float, float, float, HistoryPolicy::FIFO, 5, 5>>
	+ SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO, 5, 5>>
	SystemStateDetectorF(
	- new SystemStateDetector<float, float, float, HistoryPolicy::FIFO, 5, 5>(
	- std::numeric_limits<uint32_t>::max(), BrokenDelayFunction,
	- OkDelayFunction));
	+ new SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO, 5,
	+ 5>(std::numeric_limits<uint32_t>::max(),
	+ BrokenDelayFunction, OkDelayFunction));

	//
	// Create a high-level deluxe agent.
	//
	LOG_INFO("Create high-level agent.");

	// The new agent logs its input values and results in the the sum of them.
	/** AgentHandle BodyAgent = C->createAgent(
	"Body Agent",
	DeluxeAgent::D<uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
	uint32_t>(
	[](std::pair<uint32_t, bool> HR, std::pair<uint32_t, bool> BR,
	std::pair<uint32_t, bool> SpO2, std::pair<uint32_t, bool> BPSys,
	std::pair<uint32_t, bool> BodyTemp) -> Optional<uint32_t> {
	LOG_INFO_STREAM << "\n*******\nBody Agent trigged with values:\n"
	<< (HR.second ? "<New>" : "<Old>")
	<< " HR warning score: " << HR.first << "\n"
	<< (BR.second ? "<New>" : "<Old>")
	<< " BR warning score: " << BR.first << "\n"
	<< (SpO2.second ? "<New>" : "<Old>")
	<< " SpO2 warning score: " << SpO2.first << "\n"
	<< (BPSys.second ? "<New>" : "<Old>")
	<< " BPSys warning score: " << BPSys.first << "\n"
	<< (BodyTemp.second ? "<New>" : "<Old>")
	<< " BodyTemp warning score: " << BodyTemp.first
	<< "\n******\n";
	return {HR.first + BR.first + SpO2.first + BPSys.first +
	BodyTemp.first};
	}));
	*/
	//
	// Connect low-level agents to the high-level agent.
	//
	LOG_INFO("Connect low-level agents to the high-level agent.");

	/// C->connectAgents(BodyAgent, 0, HRAgent, "HR Agent Channel");

	//
	// For simulation output, create a logger agent writing the output of the
	// high-level agent into a CSV file.
	//
	LOG_INFO("Create a logger agent.");

	// Create CSV writer.
	/// std::ofstream ScoreCSV(ScoreCSVPath);
	/// csv::CSVWriter<uint32_t> ScoreWriter(ScoreCSV);

	// The agent writes each new input value into a CSV file and produces nothing.
	/** AgentHandle LoggerAgent = C->createAgent(
	"Logger Agent",
	DeluxeAgent::D<unit_t, uint32_t>(
	[&ScoreWriter](std::pair<uint32_t, bool> Score) -> Optional<unit_t> {
	if (Score.second) {
	// The state of \p ScoreWriter is not checked, expecting good.
	ScoreWriter << Score.first;
	}
	return {};
	}));
	*/
	//
	// Connect the high-level agent to the logger agent.
	//
	LOG_INFO("Connect the high-level agent to the logger agent.");

	/// C->connectAgents(LoggerAgent, 0, BodyAgent, "Body Agent Channel");

	//
	// Do simulation.
	//
	LOG_INFO("Setting up and performing simulation.");

	//
	// Initialize deluxe context for simulation.
	//

	// C->initializeSimulation();

	//
	// Open CSV files and register them for their corresponding sensors.
	//

	//
	// Simulate.
	//

	/// C->simulate(NumberOfSimulationCycles);

	return 0;
	}
	diff --git a/include/rosa/agent/FunctionAbstractions.hpp b/include/rosa/agent/FunctionAbstractions.hpp
	index a7442c6..c2e681e 100644
	--- a/include/rosa/agent/FunctionAbstractions.hpp
	+++ b/include/rosa/agent/FunctionAbstractions.hpp
	@@ -1,360 +1,360 @@
	//===-- rosa/agent/FunctionAbstractions.hpp ---------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/agent/FunctionAbstractions.hpp
	///
	/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
	///
	/// \date 2019
	///
	/// \brief Definition of FunctionAbstractions functionality.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP
	#define ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP

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

	#include "rosa/support/debug.hpp"

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

	namespace rosa {
	namespace agent {

	//@benedikt: check if your partialfunctions can take infinity as
	// argument

	/// Implements \c rosa::agent::Abstraction as a linear function,
	/// y = Coefficient * X + Intercept.
	///
	/// \note This implementation is supposed to be used to represent a linear
	/// function from an arithmetic domain to an arithmetic range. This is enforced
	/// statically.
	///
	/// \tparam D type of the functions domain
	/// \tparam R type of the functions range
	template <typename D, typename R>
	class LinearFunction : public Abstraction<D, R> {
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<D>::value),
	"LinearFunction not arithmetic T");
	STATIC_ASSERT((std::is_arithmetic<R>::value),
	"LinearFunction not to arithmetic");

	protected:
	/// The Intercept of the linear function
	- const D Intercept;
	+ const R Intercept;
	/// The Coefficient of the linear function
	- const D Coefficient;
	+ const R Coefficient;

	public:
	/// Creates an instance.
	///
	/// \param Intercept the intercept of the linear function
	/// \param Coefficient the coefficient of the linear function
	- LinearFunction(D Intercept, D Coefficient) noexcept
	+ LinearFunction(R Intercept, R Coefficient) noexcept
	: Abstraction<D, R>(Intercept), Intercept(Intercept),
	Coefficient(Coefficient) {}

	/// Creates an instance given the two points on a linear function.
	///
	/// \param x1 The x-value of the first point
	/// \param y1 The x-value of the first point
	/// \param x2 The y-value of the second point
	/// \param y2 The y-value of the second point
	LinearFunction(D x1, R y1, D x2, R y2) noexcept
	: LinearFunction<D, R>(y1 - x1 * (y1 - y2) / (x1 - x2),
	(y1 - y2) / (x1 - x2)) {}

	/// Creates an instance given the two points on a linear function.
	///
	/// \param p1 The coordinates of the first point
	/// \param p2 The coordinates of the second point
	LinearFunction(std::pair<D, R> p1, std::pair<D, R> p2) noexcept
	: LinearFunction<D, R>(p1.first, p1.second, p2.first, p2.second) {}

	/// 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
	///
	/// \param V the value at which to check if the function falls back to it's
	/// default value.
	///
	/// \return false
	bool isDefaultAt(const D &V) const noexcept override {
	(void)V;
	return false;
	}

	/// Getter for member variable Intercept
	///
	/// \return Intercept
	D getIntercept() const { return Intercept; }

	/// Setter for member variable Intercept
	///
	/// \param Intercept the new Intercept
	void setIntercept(const D &Intercept) { this->Intercept = Intercept; }

	/// Getter for member variable Coefficient
	///
	/// \return Coefficient
	D getCoefficient() const { return Coefficient; }

	/// Setter for member variable Coefficient
	///
	/// \param Coefficient the new Intercept
	void setCoefficient(const D &Coefficient) { this->Coefficient = Coefficient; }

	/// Set Intercept and Coefficient from two points on the linear function
	///
	/// \param x1 The x-value of the first point
	/// \param y1 The x-value of the first point
	/// \param x2 The y-value of the second point
	/// \param y2 The y-value of the second point
	void setFromPoints(D x1, R y1, D x2, R y2) {
	Coefficient = (y1 - y2) / (x1 - x2);
	Intercept = y1 - Coefficient * x1;
	}

	/// Set Intercept and Coefficient from two points on the linear function
	///
	/// \param p1 The coordinates of the first point
	/// \param p2 The coordinates of the second point
	inline void setFromPoints(std::pair<D, R> p1, std::pair<D, R> p2) {
	setFromPoints(p1.first, p1.second, p2.first, p2.second);
	}

	/// Evaluates the linear function
	///
	/// \param X the value at which to evaluate the function
	///
	/// \return Coefficient*X + Intercept
	virtual R operator()(const D &X) const noexcept override {
	return Intercept + X * Coefficient;
	}
	};

	/// Implements \c rosa::agent::Abstraction as a sine function,
	/// y = Amplitude * sin(Frequency * X + Phase) + Average.
	///
	/// \note This implementation is supposed to be used to represent a sine
	/// function from an arithmetic domain to an arithmetic range. This is enforced
	/// statically.
	///
	/// \tparam D type of the functions domain
	/// \tparam R type of the functions range
	template <typename D, typename R>
	class SineFunction : public Abstraction<D, R> {
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<D>::value),
	"SineFunction not arithmetic T");
	STATIC_ASSERT((std::is_arithmetic<R>::value),
	"SineFunction not to arithmetic");

	protected:
	/// The frequency of the sine wave
	const D Frequency;
	/// The Ampiltude of the sine wave
	const D Amplitude;
	/// The Phase-shift of the sine wave
	const D Phase;
	/// The y-shift of the sine wave
	const D 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
	SineFunction(D Frequency, D Amplitude, D Phase, D Average) noexcept
	: Abstraction<D, R>(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
	///
	/// \param V the value at which to check if the function falls back to it's
	/// default value.
	///
	/// \return false
	bool isDefaultAt(const D &V) const noexcept override {
	(void)V;
	return false;
	}

	/// Evaluates the sine function
	///
	/// \param X the value at which to evaluate the function
	/// \return the value of the sine-function at X
	virtual R operator()(const D &X) const noexcept override {
	return Amplitude * sin(Frequency * X + Phase) + Average;
	}
	};

	enum StepDirection { StepUp, StepDown };

	/// Implements \c rosa::agent::PartialFunction as a step function from 0 to 1
	/// with a ramp in between
	///
	/// \tparam D type of the functions domain
	/// \tparam R type of the functions range
	template <typename D, typename R>
	class StepFunction : public Abstraction<D, R> {
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<D>::value), "abstracting not arithmetic");
	STATIC_ASSERT((std::is_arithmetic<R>::value),
	"abstracting not to arithmetic");

	private:
	D Coefficient;
	D RightLimit;
	StepDirection Direction;

	public:
	/// Creates an instance by Initializing the underlying \c Abstraction.
	///
	/// \param Coefficient Coefficient of the ramp
	/// \param Direction wether to step up or down
	///
	/// \pre Coefficient > 0
	StepFunction(D Coefficient, StepDirection Direction = StepUp)
	: Abstraction<D, R>(0), Coefficient(Coefficient),
	RightLimit(1.0f / Coefficient), Direction(Direction) {
	ASSERT(Coefficient > 0);
	}

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

	/// Setter for Coefficient
	///
	/// \param Coefficient the new Coefficient
	void setCoefficient(const D &Coefficient) {
	ASSERT(Coefficient > 0);
	this->Coefficient = Coefficient;
	this->RightLimit = 1 / Coefficient;
	}

	/// Setter for RightLimit
	///
	/// \param _RightLimit the new RightLimit
	void setRightLimit(const D &_RightLimit) {
	ASSERT(_RightLimit > 0);
	this->RightLimit = _RightLimit;
	this->Coefficient = 1 / _RightLimit;
	}

	/// Checks wether the Abstraction evaluates to default at the given position
	///
	/// \param V the value at which to check if the function falls back to it's
	/// default value.
	///
	/// \return false if the is negative, true otherwise
	bool isDefaultAt(const D &V) const noexcept override { return V > 0; }

	/// Executes the Abstraction
	///
	/// \param V value to abstract
	///
	/// \return the abstracted value
	R operator()(const D &V) const noexcept override {
	R ret = 0;
	if (V <= 0)
	ret = 0;
	else if (V >= RightLimit)
	ret = 1;
	else
	ret = V * Coefficient;
	return Direction == StepDirection::StepUp ? ret : 1 - ret;
	}
	};

	/// Implements \c rosa::agent::Abstraction as a partial function from a domain
	/// to a range.
	///
	/// \note This implementation is supposed to be used to represent a partial
	/// function from an arithmetic domain to an arithmetic range. This is enforced
	/// statically.
	///
	/// A partial function is defined as a list of abstractions, where each
	/// abstraction is associated a range in which it is defined. These ranges must
	/// be mutually exclusive.
	///
	/// \tparam D type of the functions domain
	/// \tparam R type of the functions range
	template <typename D, typename R>
	class PartialFunction : public Abstraction<D, R> {
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<D>::value), "abstracting not arithmetic");
	STATIC_ASSERT((std::is_arithmetic<R>::value),
	"abstracting not to arithmetic");

	private:
	/// A \c rosa::agent::RangeAbstraction RA is used to represent the association
	/// from ranges to Abstractions.
	/// This returns the Abstraction that is defined for any given value, or
	/// a default Abstraction if no Abstraction is defined for that value.
	RangeAbstraction<D, std::shared_ptr<Abstraction<D, R>>> RA;

	public:
	/// Creates an instance by Initializing the underlying \c Abstraction.
	///
	/// \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<D, D>, std::shared_ptr<Abstraction<D, R>>> &Map,
	const R Default)
	: Abstraction<D, R>(Default),
	RA(Map,
	std::shared_ptr<Abstraction<D, R>>(new Abstraction<D, R>(Default))) {
	}

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

	/// Checks wether the Abstraction evaluates to default at the given position
	///
	/// \param V the value at which to check if the function falls back to it's
	/// default value.
	///
	/// \return false if the value falls into a defined range and the Abstraction
	/// defined for that range does not fall back to it's default value.
	bool isDefaultAt(const D &V) const noexcept override {
	return RA.isDefaultAt(V) ? true : RA(V)->isDefaultAt(V);
	}

	/// Searches for an Abstraction for the given value and executes it for that
	/// value, if such an Abstraction is found. The default Abstraction is
	/// evaluated otherwise.
	///
	/// \param V value to abstract
	///
	/// \return the abstracted value based on the set mapping
	R operator()(const D &V) const noexcept override {
	return RA(V)->operator()(V);
	}
	};
	} // End namespace agent
	} // End namespace rosa

	#endif // ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 10:28 PM (15 h, 32 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157384
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions