FunctionAbstractions.hpp
No OneTemporary
Actions

Authored By

Unknown

Size

5 KB

Referenced Files

None

Subscribers

None

FunctionAbstractions.hpp
View Options

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

	/// 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, 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>,
	std::shared_ptr<Abstraction<T, A>>> &Map,
	const 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)->operator()(V);
	}
	};
	} // End namespace agent
	} // End namespace rosa

	#endif // ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP

File Metadata

Mime Type: text/x-c++
Expires: Tue, Oct 27, 8:50 PM (4 h, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 410382
Default Alt Text: FunctionAbstractions.hpp (5 KB)

FunctionAbstractions.hppNo OneTemporaryActions

FunctionAbstractions.hppView Options

File Metadata

Event Timeline

FunctionAbstractions.hpp
No OneTemporary
Actions

FunctionAbstractions.hpp
View Options