Page MenuHomePhorge
Files F386414

No OneTemporary
Actions

Size
12 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/include/rosa/agent/FunctionAbstractions.hpp b/include/rosa/agent/FunctionAbstractions.hpp
index 606125a..51801f0 100644
--- a/include/rosa/agent/FunctionAbstractions.hpp
+++ b/include/rosa/agent/FunctionAbstractions.hpp
@@ -1,194 +1,194 @@
//===-- 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>{
+/// \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<T>::value),
+ STATIC_ASSERT((std::is_arithmetic<D>::value),
"LinearFunction not arithmetic T");
- STATIC_ASSERT((std::is_arithmetic<A>::value),
+ STATIC_ASSERT((std::is_arithmetic<R>::value),
"LinearFunction not to arithmetic");
protected:
- const T Intercept;
- const T Coefficient;
+ const D Intercept;
+ const D 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),
+ LinearFunction(D Intercept, D Coefficient) noexcept
+ : Abstraction<D, R>(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{
+ bool isDefaultAt(const D &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 {
+ virtual R operator()(const D &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>{
+/// \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<T>::value),
+ STATIC_ASSERT((std::is_arithmetic<D>::value),
"SineFunction not arithmetic T");
- STATIC_ASSERT((std::is_arithmetic<A>::value),
+ STATIC_ASSERT((std::is_arithmetic<R>::value),
"SineFunction not to arithmetic");
protected:
- const T Frequency;
- const T Amplitude;
- const T Phase;
- const T Average;
+ const D Frequency;
+ const D Amplitude;
+ const D Phase;
+ 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
/// domain
- SineFunction(T Frequency, T Amplitude, T Phase, T Average) noexcept
- : Abstraction<T, A>(Average),
+ 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
- bool isDefaultAt(const T &V) const{
+ bool isDefaultAt(const D &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 {
+ virtual R operator()(const D &X) const noexcept override {
return Amplitude*sin(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 : public Abstraction<T, A> {
+/// \tparam D type to abstract from
+/// \tparam R type to abstract to
+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<T>::value), "abstracting not arithmetic");
- STATIC_ASSERT((std::is_arithmetic<A>::value),
+ STATIC_ASSERT((std::is_arithmetic<D>::value), "abstracting not arithmetic");
+ STATIC_ASSERT((std::is_arithmetic<R>::value),
"abstracting not to arithmetic");
private:
- RangeAbstraction<T, std::shared_ptr<Abstraction<T, A>>> RA;
+ RangeAbstraction<D, std::shared_ptr<Abstraction<D, R>>> 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))) {
+ 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
- bool isDefaultAt(const T &V) const{
+ bool isDefaultAt(const D &V) const{
return RA.isDefaultAt(V);
}
/// 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 {
+ R operator()(const D &V) const noexcept override {
return RA(V)->operator()(V);
}
};
} // End namespace agent
} // End namespace rosa
#endif // ROSA_AGENT_FUNCTIONABSTRACTIONS_HPP
diff --git a/include/rosa/agent/RangeConfidence.hpp b/include/rosa/agent/RangeConfidence.hpp
index 83ba518..d93c00d 100644
--- a/include/rosa/agent/RangeConfidence.hpp
+++ b/include/rosa/agent/RangeConfidence.hpp
@@ -1,90 +1,91 @@
//===-- 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>>{
+/// \tparam D type to abstract from
+/// \tparam I type
+/// \tparam R type to abstract a vector of to
+template <typename D, typename I, typename R>
+class RangeConfidence : protected Abstraction<D, std::map<I, R>>,
+ private std::map<I, PartialFunction<D, R>>{
// 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),
+ STATIC_ASSERT((std::is_arithmetic<D>::value), "abstracting not arithmetic");
+ STATIC_ASSERT((std::is_arithmetic<R>::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,
+ RangeConfidence(const std::map<I, PartialFunction<D, R>> &Abstractions,
bool IgnoreDefaults = false)
- : Abstraction<T, std::map<A, B>>({}),
- std::map<A, PartialFunction<T, B>>(Abstractions),
+ : Abstraction<D, std::map<I, R>>({}),
+ std::map<I, PartialFunction<D, R>>(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)){
+ std::map<I, R> operator()(const D &V) const noexcept override {
+ std::map<I, R> ret;
+ for (auto const& p : ((std::map<I, PartialFunction<D, R>>)*this)){
if(!IgnoreDefaults || !p.second.isDefaultAt(V))
- ret.insert(std::pair<A, B>(p.first, p.second(V)));
+ ret.insert(std::pair<I, R>(p.first, p.second(V)));
}
return ret;
}
};
} // End namespace agent
} // End namespace rosa
#endif // ROSA_AGENT_RANGECONFIDENCE_HPP

File Metadata

Mime Type
text/x-diff
Expires
Thu, Jul 3, 11:58 AM (1 d, 15 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
157238
Default Alt Text
(12 KB)

Event Timeline