Page MenuHomePhorge
Files F386352

CrossReliability.h
No OneTemporary
Actions

Size
12 KB
Referenced Files
None
Subscribers
None

CrossReliability.h
View Options

//===-- rosa/delux/CrossReliability.h ---------------------------*- C++ -*-===//
//
// The RoSA Framework
//
// Distributed under the terms and conditions of the Boost Software License 1.0.
// See accompanying file LICENSE.
//
// If you did not receive a copy of the license file, see
// http://www.boost.org/LICENSE_1_0.txt.
//
//===----------------------------------------------------------------------===//
///
/// \file rosa/delux/CrossReliability.h
///
/// \author Daniel Schnoell
///
/// \date 2019
///
/// \brief
///
/// \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
// FIXME: ROSA_LOG_LEVEL is defined by the build system, this should be
// removed.
//#define ROSA_LOG_LEVEL 100
#include "rosa/agent/Abstraction.hpp"
#include "rosa/agent/Functionality.h"
#include "rosa/core/forward_declarations.h" // needed for id_t
#include "rosa/support/log.h" // needed for error "handling"
// nedded headers
#include <string>
#include <type_traits> //assert
#include <vector>
// for static methods
#include <algorithm>
#include <numeric>
namespace rosa {
namespace agent {
/// Calculates the Cross Reliability
/// \brief it uses the state represented by a numerical value and calculates the
/// Reliability of a given agent( represented by there id ) in connection to all
/// other given agents
///
/// \note all combination of agents and there coresponding Cross Reliability
/// function have to be specified
template <typename StateType, typename Type>
class CrossReliability : public Abstraction<StateType, Type> {
using Abstraction = typename rosa::agent::Abstraction<StateType, Type>;
struct Functionblock {
bool exists = false;
id_t A;
id_t B;
Abstraction *Funct;
};
/// From Maxi in his code defined as 1 can be changed by set
Type crossReliabilityParameter = 1;
/// Stored Cross Reliability Functions
std::vector<Functionblock> Functions;
/// Method which is used to combine the generated values
Type (*Method)(std::vector<Type> values) = AVERAGE;
//--------------------------------------------------------------------------------
// helper function
/// evalues the absolute distance between two values
/// \note this is actually the absolute distance but to ceep it somewhat
/// conform with maxis code
template <typename Type_t> Type_t AbsuluteValue(Type_t A, Type_t B) {
static_assert(std::is_arithmetic<Type_t>::value);
return ((A - B) < 0) ? B - A : A - B;
}
/// verry inefficient searchFunction
Functionblock (*searchFunction)(std::vector<Functionblock> vect,
const id_t nameA, const id_t nameB) =
[](std::vector<Functionblock> 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 these two parameters are the unique identifiers
/// \param nameB these two parameters are the unique identifiers
/// for the LinerFunction
///
/// \note If the block nameA nameB doesn't exist it logs the error and returns
/// 0
/// \note it doesn't matter if they are swapped
Type getCrossReliabilityFromProfile(id_t nameA, id_t nameB,
StateType scoreDifference) {
Functionblock block = searchFunction(Functions, nameA, nameB);
if (!block.exists) {
LOG_ERROR(("CrossReliability: Block:" + std::to_string(nameA) + "," +
std::to_string(nameB) + "doesn't exist returning 0"));
return 0;
}
return block.Funct->operator()(scoreDifference);
}
public:
/// adds a Cross Reliability Profile used to get the Reliability of the state
/// difference
void addCrossReliabilityProfile(id_t idA, id_t idB, Abstraction *Function) {
Functions.push_back({true, idA, idB, Function});
}
/// sets the cross reliability parameter
void setCrossReliabilityParameter(Type val) {
crossReliabilityParameter = val;
}
/// sets the used method to combine the values
void setCrossReliabilityMethod(Type (*Meth)(std::vector<Type> values)) {
Method = Meth;
}
~CrossReliability() {
for (auto tmp : Functions)
delete tmp.Funct;
Functions.clear();
}
/// 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 it
/// doesn't matter if Main agent exists inside this vector
Type operator()(std::pair<id_t, StateType> &MainAgent,
std::vector<std::pair<id_t, StateType>> &SlaveAgents);
/// predefined combination method
static Type CONJUNCTION(std::vector<Type> values) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
return *std::min_element(values.begin(), values.end());
}
/// predefined combination method
static Type AVERAGE(std::vector<Type> values) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
return std::accumulate(values.begin(), values.end(), 0.0) / values.size();
}
/// predefined combination method
static Type DISJUNCTION(std::vector<Type> values) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
return *std::max_element(values.begin(), values.end());
}
};
template <typename StateType, typename Type>
inline Type CrossReliability<StateType, Type>::
operator()(std::pair<id_t, StateType> &MainAgent,
std::vector<std::pair<id_t, StateType>> &SlaveAgents) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
static_assert(std::is_arithmetic<StateType>::value); // sanitny check
Type crossReliabiability;
std::vector<Type> values;
for (std::pair<id_t, StateType> 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);
}
/// Calculates the Cross Confidence
/// \brief It uses the a theoretical state represented by a numerical value and
/// calculates the Reliability of a given agent( represented by there id ) in
/// connection to all other given agents this can be used to get a Confidence of
/// the current state
///
/// \note all combination of agents and there coresponding Cross Reliability
/// function have to be specified
template <typename StateType, typename Type>
class CrossConfidence : public Abstraction<StateType, Type> {
using Abstraction = typename rosa::agent::Abstraction<StateType, Type>;
struct Functionblock {
bool exists = false;
id_t A;
id_t B;
Abstraction *Funct;
};
/// From Maxi in his code defined as 1 can be changed by set
Type crossReliabilityParameter = 1;
/// Stored Cross Reliability Functions
std::vector<Functionblock> Functions;
/// Method which is used to combine the generated values
Type (*Method)(std::vector<Type> values) = AVERAGE;
//--------------------------------------------------------------------------------
// helper function
/// evalues the absolute distance between two values
/// \note this is actually the absolute distance but to ceep it somewhat
/// conform with maxis code
template <typename Type_t> Type_t AbsuluteValue(Type_t A, Type_t B) {
static_assert(std::is_arithmetic<Type_t>::value);
return ((A - B) < 0) ? B - A : A - B;
}
/// verry inefficient searchFunction
Functionblock (*searchFunction)(std::vector<Functionblock> vect,
const id_t nameA, const id_t nameB) =
[](std::vector<Functionblock> 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 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,
StateType scoreDifference) {
Functionblock block = searchFunction(Functions, nameA, nameB);
if (!block.exists) {
LOG_ERROR(("CrossReliability: Block:" + std::to_string(nameA) + "," +
std::to_string(nameB) + "doesn't exist returning 0"));
return 0;
}
return block.Funct->operator()(scoreDifference);
}
public:
/// adds a Cross Reliability Profile used to get the Reliability of the state
/// difference
void addCrossReliabilityProfile(id_t idA, id_t idB, Abstraction *Function) {
Functions.push_back({true, idA, idB, Function});
}
/// sets the cross reliability parameter
void setCrossReliabilityParameter(Type val) {
crossReliabilityParameter = val;
}
/// sets the used method to combine the values
void setCrossReliabilityMethod(Type (*Meth)(std::vector<Type> values)) {
Method = Meth;
}
~CrossConfidence() {
for (auto tmp : Functions)
delete tmp.Funct;
Functions.clear();
}
Type operator()(id_t MainAgent, StateType TheoreticalValue,
std::vector<std::pair<id_t, StateType>> &SlaveAgents);
/// predefined combination method
static Type CONJUNCTION(std::vector<Type> values) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
return *std::min_element(values.begin(), values.end());
}
/// predefined combination method
static Type AVERAGE(std::vector<Type> values) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
return std::accumulate(values.begin(), values.end(), 0.0) / values.size();
}
/// predefined combination method
static Type DISJUNCTION(std::vector<Type> values) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
return *std::max_element(values.begin(), values.end());
}
};
template <typename StateType, typename Type>
inline Type CrossConfidence<StateType, Type>::
operator()(id_t MainAgent, StateType TheoreticalValue,
std::vector<std::pair<id_t, StateType>> &SlaveAgents) {
static_assert(std::is_arithmetic<Type>::value); // sanitny check
static_assert(std::is_arithmetic<StateType>::value); // sanitny check
Type crossReliabiability;
std::vector<Type> values;
for (std::pair<id_t, StateType> 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

File Metadata

Mime Type
text/x-c++
Expires
Thu, Jul 3, 6:51 AM (1 d, 15 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
157196
Default Alt Text
CrossReliability.h (12 KB)

Event Timeline