diff --git a/.gitignore b/.gitignore index f5de720..600d2d3 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1 @@ -.vscode -/.vs -out \ No newline at end of file +.vscode \ No newline at end of file diff --git a/include/rosa/agent/CrossReliability.h b/include/rosa/agent/CrossReliability.h index c2681da..8442566 100644 --- a/include/rosa/agent/CrossReliability.h +++ b/include/rosa/agent/CrossReliability.h @@ -1,289 +1,286 @@ //===-- rosa/delux/CrossReliability.h ---------------------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file rosa/delux/CrossReliability.h /// /// \author Daniel Schnoell /// /// \date 2019 /// -/// \brief This file is temporarly for the functions/methods CrossConfidence and -/// CrossReliability. -/// \todo As soon as a Delux Reliabl Agent exist modify to this or add it to the -/// Agent. +/// /// \todo there is 1 exception that needs to be handled correctly. /// \note the default search function is extremely slow maby this could be done /// via template for storage class and the functions/methods to efficiently find /// the correct LinearFunction //===----------------------------------------------------------------------===// #ifndef ROSA_AGENT_CROSSRELIABILITY_H #define ROSA_AGENT_CROSSRELIABILITY_H #include "rosa/agent/Functionality.h" #include "rosa/agent/LinearFunctions.hpp" #include "rosa/core/forward_declarations.h" // needed for id_t // nedded headers #include //assert #include // for static methods #include #include namespace rosa { namespace agent { template class CrossReliability : public Functionality { using PartialFunction = typename rosa::agent::PartialFunction; struct Functionblock { bool exists = false; id_t A; id_t B; PartialFunction *Funct; }; Type crossReliabilityParameter = 1; std::vector Functions; Type (*Method)(std::vector values) = AVERAGE; //-------------------------------------------------------------------------------- // helper functions /// evalues the absolute distance between two values Type AbsuluteValue(Type A, Type B) { return ((A - B) < 0) ? B - A : A - B; } - /// verry inefficient searchFunction Functionblock (*searchFunction)(std::vector vect, - const id_t nameA, - const id_t nameB) = + const id_t nameA, const id_t nameB) = [](std::vector vect, const id_t nameA, const id_t nameB) -> Functionblock { for (Functionblock tmp : vect) { if (tmp.A == nameA && tmp.B == nameB) return tmp; if (tmp.A == nameB && tmp.B == nameA) return tmp; } return Functionblock(); }; /// evaluest the corisponding LinearFunction thith the score difference - /// \param nameA + /// \param nameA these two parameters are the unique identifiers /// \param nameB these two parameters are the unique identifiers /// for the LinerFunction \note it doesn't matter if they are swapped Type getCrossReliabilityFromProfile(id_t nameA, id_t nameB, Type scoreDifference) { Functionblock block = searchFunction(Functions, nameA, nameB); if (!block.exists) - throw "does not exist"; // exceptions are disabled in rosa Todo : handle - // this right - return block.Funct->operator()(scoreDifference); + // throw "does not exist"; // exceptions are disabled in rosa Todo : + // handle + // this right + return block.Funct->operator()(scoreDifference); } public: void addCrossReliabilityProfile(id_t idA, id_t idB, PartialFunction *Function) { Functions.push_back({true, idA, idB, Function}); } void setCrossReliabilityParameter(Type val) { crossReliabilityParameter = val; } void setCrossReliabilityMethod(Type (*Meth)(std::vector values)) { Method = Meth; } ~CrossReliability() { for (auto tmp : Functions) delete tmp.Funct; } /// Calculets the CrossReliability /// \note both Main and Slaveagents are represented by there data and an /// unique identifier /// /// \param MainAgent defines the value pair around which the Cross Reliability /// is calculated /// \param SlaveAgents defines all value pairs of the connected Agents Type operator()(std::pair &MainAgent, std::vector> &SlaveAgents); /// predefined combination method static Type CONJUNCTION(std::vector values) { static_assert(std::is_arithmetic::value); // sanitny check return *std::min_element(values.begin(), values.end()); } /// predefined combination method static Type AVERAGE(std::vector values) { static_assert(std::is_arithmetic::value); // sanitny check return std::accumulate(values.begin(), values.end(), 0.0) / values.size(); } /// predefined combination method static Type DISJUNCTION(std::vector values) { static_assert(std::is_arithmetic::value); // sanitny check return *std::max_element(values.begin(), values.end()); } }; template inline Type CrossReliability:: operator()(std::pair &MainAgent, std::vector> &SlaveAgents) { static_assert(std::is_arithmetic::value); // sanitny check Type crossReliabiability; std::vector values; for (std::pair SlaveAgent : SlaveAgents) { if (SlaveAgent.first == MainAgent.first) continue; if (MainAgent.second == SlaveAgent.second) crossReliabiability = 1; else crossReliabiability = 1 / (crossReliabilityParameter * AbsuluteValue(MainAgent.second, SlaveAgent.second)); // profile reliability Type crossReliabilityFromProfile = getCrossReliabilityFromProfile( MainAgent.first, SlaveAgent.first, AbsuluteValue(MainAgent.second, SlaveAgent.second)); values.push_back( std::max(crossReliabiability, crossReliabilityFromProfile)); } return Method(values); } template class CrossConfidence : public Functionality { using PartialFunction = typename rosa::agent::PartialFunction; struct Functionblock { bool exists = false; id_t A; id_t B; PartialFunction *Funct; }; Type crossReliabilityParameter = 1; std::vector Functions; Type (*Method)(std::vector values) = AVERAGE; //-------------------------------------------------------------------------------- // helper functions /// evalues the absolute distance between two values Type AbsuluteValue(Type A, Type B) { return ((A - B) < 0) ? B - A : A - B; } /// verry inefficient searchFunction Functionblock (*searchFunction)(std::vector vect, const id_t nameA, const id_t nameB) = [](std::vector vect, const id_t nameA, const id_t nameB) -> Functionblock { for (Functionblock tmp : vect) { if (tmp.A == nameA && tmp.B == nameB) return tmp; if (tmp.A == nameB && tmp.B == nameA) return tmp; } return Functionblock(); }; /// evaluest the corisponding LinearFunction thith the score difference - /// \param nameA + /// \param nameA these two parameters are the unique identifiers /// \param nameB these two parameters are the unique identifiers /// for the LinerFunction \note it doesn't matter if they are swapped Type getCrossReliabilityFromProfile(id_t nameA, id_t nameB, Type scoreDifference) { Functionblock block = searchFunction(Functions, nameA, nameB); if (!block.exists) - throw "does not exist"; // exceptions are disabled in rosa Todo : handle - // this right - return block.Funct->operator()(scoreDifference); + // throw "does not exist"; // exceptions are disabled in rosa Todo : + // handle + // this right + return block.Funct->operator()(scoreDifference); } public: void addCrossReliabilityProfile(id_t idA, id_t idB, PartialFunction *Function) { Functions.push_back({true, idA, idB, Function}); } void setCrossReliabilityParameter(Type val) { crossReliabilityParameter = val; } void setCrossReliabilityMethod(Type (*Meth)(std::vector values)) { Method = Meth; } - ~CrossReliabilityModule() { + ~CrossConfidence() { for (auto tmp : Functions) delete tmp.Funct; } Type operator()(id_t MainAgent, Type TheoreticalValue, std::vector> &SlaveAgents); /// predefined combination method static Type CONJUNCTION(std::vector values) { static_assert(std::is_arithmetic::value); // sanitny check return *std::min_element(values.begin(), values.end()); } /// predefined combination method static Type AVERAGE(std::vector values) { static_assert(std::is_arithmetic::value); // sanitny check return std::accumulate(values.begin(), values.end(), 0.0) / values.size(); } /// predefined combination method static Type DISJUNCTION(std::vector values) { static_assert(std::is_arithmetic::value); // sanitny check return *std::max_element(values.begin(), values.end()); } }; template inline Type CrossConfidence:: operator()(id_t MainAgent, Type TheoreticalValue, std::vector> &SlaveAgents) { Type crossReliabiability; std::vector values; - for (std::pair SlaveAgent : SlaveAgents) { + for (std::pair SlaveAgent : SlaveAgents) { if (SlaveAgent.first == MainAgent) continue; if (TheoreticalValue == SlaveAgent.second) crossReliabiability = 1; else crossReliabiability = 1 / (crossReliabilityParameter * AbsuluteValue(TheoreticalValue, SlaveAgent.second)); // profile reliability Type crossReliabilityFromProfile = getCrossReliabilityFromProfile( MainAgent, SlaveAgent.first, AbsuluteValue(TheoreticalValue, SlaveAgent.second)); values.push_back( std::max(crossReliabiability, crossReliabilityFromProfile)); } return Method(values); } } // End namespace agent } // End namespace rosa #endif // ROSA_AGENT_CROSSRELIABILITY_H \ No newline at end of file