diff --git a/examples/agent-functionalities/agent-functionalities.cpp b/examples/agent-functionalities/agent-functionalities.cpp index 7e4cf9b..b09b72e 100644 --- a/examples/agent-functionalities/agent-functionalities.cpp +++ b/examples/agent-functionalities/agent-functionalities.cpp @@ -1,109 +1,169 @@ //===-- 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/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 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 static AgentHandle createMyAgent(MessagingSystem *S, const std::string &Name, Funs &&... Fs) { return ((SystemTester *)S)->createAgent(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; private: enum class Categories { Bad, Normal, Good }; static const std::map CategoryNames; History H; Confidence C; RangeAbstraction A; + PartialFunction L; + RangeConfidence RCL; + RangeConfidence 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())) << '\n'; + << ", category: " << CategoryNames.at(A(H.entry())) + << ", partial: " << int(L(H.entry())) + << ", range-confidence-linear: "; + std::vector res_lin = RCL(H.entry()); + for (auto i : res_lin){ + LOG_INFO_STREAM << " " << i; + } + LOG_INFO_STREAM << ", range-confidence-sine: "; + std::vector res_sine = RCS(H.entry()); + for (auto i : res_sine){ + LOG_INFO_STREAM << " " << i; + } + 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) {} + Categories::Bad), + L({{{0, 2}, new LinearFunction(0, 1)}, + {{2, 4}, new LinearFunction(2, 0)}, + {{4, 6}, new LinearFunction(6, -1)}}, + 0), + RCL({ + PartialFunction({ + {{0, 3}, new LinearFunction(0, 1.0/3)}, + {{3, 6}, new LinearFunction(1, 0)}, + {{6, 9}, new LinearFunction(3.0, -1.0/3)}, + },0), + PartialFunction({ + {{6, 9}, new LinearFunction(-2, 1.0/3)}, + {{9, 12}, new LinearFunction(1, 0)}, + {{12, 15}, new LinearFunction(5, -1.0/3)}, + },0), + PartialFunction({ + {{12, 15}, new LinearFunction(-4, 1.0/3)}, + {{15, 18}, new LinearFunction(1, 0)}, + {{18, 21}, new LinearFunction(7, -1.0/3)}, + },0) + }), + RCS({ + PartialFunction({ + {{0, 3}, new SineFunction + (M_PI/3, 0.5, -M_PI/2, 0.5)}, + {{3, 6}, new LinearFunction(1, 0)}, + {{6, 9}, new SineFunction + (M_PI/3, 0.5, -M_PI/2 + 3, 0.5)}, + },0), + PartialFunction({ + {{6, 9}, new SineFunction + (M_PI/3, 0.5, -M_PI/2, 0.5)}, + {{9, 12}, new LinearFunction(1, 0)}, + {{12, 15}, new SineFunction + (M_PI/3, 0.5, -M_PI/2 + 3, 0.5)}, + },0), + PartialFunction({ + {{12, 15}, new SineFunction + (M_PI/3, 0.5, -M_PI/2, 0.5)}, + {{15, 18}, new LinearFunction(1, 0)}, + {{18, 21}, new SineFunction + (M_PI/3, 0.5, -M_PI/2 + 3, 0.5)}, + },0) + }){} }; const std::map MyAgent::CategoryNames{ {Categories::Bad, "Bad"}, {Categories::Normal, "Normal"}, {Categories::Good, "Good"}}; int main(void) { - LOG_INFO_STREAM << library_string() << " -- " << Color::Red + LOG_INFO_STREAM << library_string() << " -- " << Color::Red << "agent-functionalities example" << Color::Default << '\n'; std::unique_ptr S = MessagingSystem::createSystem("Sys"); MessagingSystem *SP = S.get(); AgentHandle A = SystemTester::createMyAgent(SP, "MyAgent"); - std::vector Vs{4, 5, 6, 7, 9, 10, 11, 13, + std::vector 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::Value, *I); } SystemTester::destroyMyAgent(SP, A); return 0; } diff --git a/include/rosa/agent/Abstraction.hpp b/include/rosa/agent/Abstraction.hpp index c9c4fa2..fa9e03e 100644 --- a/include/rosa/agent/Abstraction.hpp +++ b/include/rosa/agent/Abstraction.hpp @@ -1,191 +1,193 @@ //===-- 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 #include 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 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; /// 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 class MapAbstraction : public Abstraction, private std::map { // Make sure the actual type arguments are enumerations. STATIC_ASSERT((std::is_enum::value && std::is_enum::value), "mapping not enumerations"); // Bringing into scope inherited members. using Abstraction::Default; using std::map::end; using std::map::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 &Map, const A Default) noexcept : Abstraction(Default), std::map(Map) {} /// Destroys \p this object. ~MapAbstraction(void) = default; /// 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 class RangeAbstraction : public Abstraction, private std::map, A> { // Make sure the actual type arguments are matching our expectations. STATIC_ASSERT((std::is_arithmetic::value), "abstracting not arithmetic"); - STATIC_ASSERT((std::is_enum::value), "abstracting not to enumeration"); + /// \todo check if this compiles with the definition of abstractions as + /// self-aware properties + //STATIC_ASSERT((std::is_enum::value), "abstracting not to enumeration"); // Bringing into scope inherited members. using Abstraction::Default; using std::map, A>::begin; using std::map, A>::end; using std::map, 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, A> &Map, const A &Default) : Abstraction(Default), std::map, A>(Map) { // Sanity check. ASSERT(std::all_of( begin(), end(), [this](const std::pair, A> &P) { return P.first.first <= P.first.second && std::all_of(++find(P.first), end(), [&P](const std::pair, 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; /// 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/LinearFunctions.hpp new file mode 100644 index 0000000..b0eceaa --- /dev/null +++ b/include/rosa/agent/LinearFunctions.hpp @@ -0,0 +1,224 @@ +//===-- 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 +#include +#include + +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 class LinearFunction : + public Abstraction{ + // Make sure the actual type arguments are matching our expectations. + STATIC_ASSERT((std::is_arithmetic::value), + "LinearFunction not arithmetic T"); + STATIC_ASSERT((std::is_arithmetic::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(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 class SineFunction : + public Abstraction{ + // Make sure the actual type arguments are matching our expectations. + STATIC_ASSERT((std::is_arithmetic::value), + "SineFunction not arithmetic T"); + STATIC_ASSERT((std::is_arithmetic::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(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 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 +class PartialFunction : private Abstraction { + // Make sure the actual type arguments are matching our expectations. + STATIC_ASSERT((std::is_arithmetic::value), "abstracting not arithmetic"); + STATIC_ASSERT((std::is_arithmetic::value), + "abstracting not to arithmetic"); + +private: + RangeAbstraction*> 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, Abstraction*> &Map, + const A Default) + : Abstraction(Default), RA(Map, new Abstraction(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 +class RangeConfidence : public Abstraction>, + private std::vector>{ + // Make sure the actual type arguments are matching our expectations. + STATIC_ASSERT((std::is_arithmetic::value), "abstracting not arithmetic"); + STATIC_ASSERT((std::is_arithmetic::value), + "abstracting not to arithmetic"); + + // Bringing into scope inherited members. + using std::vector>::size; + using std::vector>::begin; + using std::vector>::end; + +public: + /// Creates an instance by Initializing the underlying \c RangeAbstraction. + /// + /// \param Abstractions the Abstractions to be evaluated + RangeConfidence(const std::vector> &Abstractions) + : Abstraction>({}), + std::vector>(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 operator()(const T &V) const noexcept override { + std::vector ret; + for (auto const& func : ((std::vector>)*this)){ + ret.push_back(func(V)); + } + return ret; + } +}; +} // End namespace agent +} // End namespace rosa + +#endif // ROSA_AGENT_ABSTRACTION_HPP diff --git a/lib/agent/CMakeLists.txt b/lib/agent/CMakeLists.txt index 81a33f5..3d6e5ab 100644 --- a/lib/agent/CMakeLists.txt +++ b/lib/agent/CMakeLists.txt @@ -1,14 +1,16 @@ 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}/History.hpp History.cpp ${LIB_INCLUDE_DIR}/Confidence.hpp Confidence.cpp ) diff --git a/lib/agent/LinearFunctions.cpp b/lib/agent/LinearFunctions.cpp new file mode 100644 index 0000000..0b43abe --- /dev/null +++ b/lib/agent/LinearFunctions.cpp @@ -0,0 +1,20 @@ +//===-- agent/LinearFunctions.cpp -------------------------------*- C++ -*-===// +// +// The RoSA Framework +// +//===----------------------------------------------------------------------===// +/// +/// \file agent/LinearFunctions.cpp +/// +/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at) +/// +/// \date 2019 +/// +/// \brief Implementation for rosa/agent/LinearFunctions.hpp. +/// +/// \note Empty implementation, source file here to have a compile database +/// entry for rosa/agent/LinearFunctions.hpp. +/// +//===----------------------------------------------------------------------===// + +#include "rosa/agent/LinearFunctions.hpp"