LinearFunctions.hpp
No OneTemporary
Actions

Size

7 KB

Referenced Files

None

Subscribers

None

LinearFunctions.hpp
View Options

	//===-- rosa/agent/LinearAbstractions.hpp --------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/agent/LinearAbstractions.hpp
	///
	/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
	///
	/// \date 2019
	///
	/// \brief Definition of LinearFunction functionality.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_AGENT_LINEARFUNCTIONS_HPP
	#define ROSA_AGENT_LINEARFUNCTIONS_HPP

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

	#include "rosa/support/debug.hpp"

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

	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;

	/// 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;

	/// 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> {
	// 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;

	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,
	const A Default)
	: Abstraction<T, A>(Default), RA(Map, 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);
	}
	};

	/// 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;
	}
	};
	} // End namespace agent
	} // End namespace rosa

	#endif // ROSA_AGENT_ABSTRACTION_HPP

File Metadata

Mime Type: text/x-c++
Expires: Sun, May 31, 5:21 PM (18 h, 8 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 328457
Default Alt Text: LinearFunctions.hpp (7 KB)

LinearFunctions.hppNo OneTemporaryActions

LinearFunctions.hppView Options

File Metadata

Event Timeline

LinearFunctions.hpp
No OneTemporary
Actions

LinearFunctions.hpp
View Options