Page MenuHomePhorge
Files F1497306

Reliability-functionality.cpp
No OneTemporary
Actions

Size
9 KB
Referenced Files
None
Subscribers
None

Reliability-functionality.cpp
View Options

//===- examples/agent-functionalities/Reliability-functionality.cpp *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 examples/agent-functionalities/Reliability-functionality.cpp
///
/// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at )
///
/// \date 2019
///
/// \brief A simple example on defining Relianility Functionalities.
///
//===----------------------------------------------------------------------===//
#define Reliability_trace_level 5
#include "rosa/config/version.h"
#include "rosa/support/log.h"
#include "rosa/agent/CrossCombinator.h"
#include "rosa/agent/RangeConfidence.hpp"
#include "rosa/agent/ReliabilityConfidenceCombinator.h"
#include <map>
#include <vector>
using namespace rosa::agent;
int main(void) {
typedef double SensorValueType;
typedef long StateType;
typedef double ReliabilityType;
std::shared_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
Confidence(new RangeConfidence<ReliabilityType, StateType,
SensorValueType>(
{{0, PartialFunction<double, double>(
{
{{0, 3},
std::make_shared<LinearFunction<double, double>>(
0, 1.0 / 3)},
{{3, 6},
std::make_shared<LinearFunction<double, double>>(1, 0)},
{{6, 9},
std::make_shared<LinearFunction<double, double>>(
3.0, -1.0 / 3)},
},
0)},
{1, PartialFunction<double, double>(
{
{{6, 9},
std::make_shared<LinearFunction<double, double>>(
-2, 1.0 / 3)},
{{9, 12},
std::make_shared<LinearFunction<double, double>>(1, 0)},
{{12, 15},
std::make_shared<LinearFunction<double, double>>(
5, -1.0 / 3)},
},
0)},
{2, PartialFunction<double, double>(
{
{{12, 15},
std::make_shared<LinearFunction<double, double>>(
-4, 1.0 / 3)},
{{15, 18},
std::make_shared<LinearFunction<double, double>>(1, 0)},
{{18, 21},
std::make_shared<LinearFunction<double, double>>(
7, -1.0 / 3)},
},
0)}}));
std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>>
ReliabilitySlope(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
std::shared_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence(
new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 3));
auto lowlevel =
new ReliabilityAndConfidenceCombinator<SensorValueType, StateType,
ReliabilityType>();
std::vector<long> states;
states.push_back(0);
states.push_back(1);
states.push_back(2);
lowlevel->setConfidenceFunction(Confidence);
lowlevel->setAbsoluteReliabilityFunction(Reliability);
lowlevel->setReliabilitySlopeFunction(ReliabilitySlope);
lowlevel->setTimeFunctionForLikelinessFunction(TimeConfidence);
lowlevel->setIdentifiers(states);
lowlevel->setHistoryLength(2);
lowlevel->setTimeStep(1);
/* ----------------------------- Do Something
* ---------------------------------------------------------------- */
std::cout << "Testing the lowlevel component with static feedback telling it "
"that the most lickely state is 2.\n";
for (int a = 0; a < 30; a++)
std::cout << "a: " << a << "\n"
<< (lowlevel->feedback({{0, 0}, {1, 0.3}, {2, 0.8}}),
lowlevel->bestSymbol(a))
<< "\n";
std::cout << "---------------------------------------------------------------"
"---------------------------------\n";
std::cout << "------------------------------------High level "
"Test---------------------------------------------\n";
std::cout
<< "Configured in a way that the Master thinks that both Sensors "
"should have the same State.\n While feeding both the \"opposite\" "
"values one acending the other decending from the maximum.\n";
std::shared_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
Confidence2(new RangeConfidence<ReliabilityType, StateType,
SensorValueType>(
{{0, PartialFunction<double, double>(
{
{{0, 3},
std::make_shared<LinearFunction<double, double>>(
0, 1.0 / 3)},
{{3, 6},
std::make_shared<LinearFunction<double, double>>(1, 0)},
{{6, 9},
std::make_shared<LinearFunction<double, double>>(
3.0, -1.0 / 3)},
},
0)},
{1, PartialFunction<double, double>(
{
{{6, 9},
std::make_shared<LinearFunction<double, double>>(
-2, 1.0 / 3)},
{{9, 12},
std::make_shared<LinearFunction<double, double>>(1, 0)},
{{12, 15},
std::make_shared<LinearFunction<double, double>>(
5, -1.0 / 3)},
},
0)},
{2, PartialFunction<double, double>(
{
{{12, 15},
std::make_shared<LinearFunction<double, double>>(
-4, 1.0 / 3)},
{{15, 18},
std::make_shared<LinearFunction<double, double>>(1, 0)},
{{18, 21},
std::make_shared<LinearFunction<double, double>>(
7, -1.0 / 3)},
},
0)}}));
std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability2(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>>
ReliabilitySlope2(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
std::shared_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence2(
new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 9));
auto lowlevel2 =
new ReliabilityAndConfidenceCombinator<SensorValueType, StateType,
ReliabilityType>();
std::vector<long> states2;
states2.push_back(0);
states2.push_back(1);
states2.push_back(2);
lowlevel2->setConfidenceFunction(Confidence2);
lowlevel2->setAbsoluteReliabilityFunction(Reliability2);
lowlevel2->setReliabilitySlopeFunction(ReliabilitySlope2);
lowlevel2->setTimeFunctionForLikelinessFunction(TimeConfidence2);
lowlevel2->setIdentifiers(states2);
lowlevel2->setHistoryLength(2);
lowlevel2->setTimeStep(1);
CrossCombinator<StateType, ReliabilityType> *highlevel =
new CrossCombinator<StateType, ReliabilityType>();
std::shared_ptr<Abstraction<long, double>> func1(new PartialFunction<long, double>(
{
{{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
{{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
},
0));
highlevel->addCrossLikelinessProfile(0, 1, func1);
highlevel->setCrossLikelinessCombinatorMethod(
CrossCombinator<StateType, ReliabilityType>::predefinedMethods::AVERAGE);
highlevel->setCrossLikelinessParameter(1);
highlevel->addIdentifiers(0, states);
highlevel->addIdentifiers(1, states);
for (int a = 0; a < 21; a++) {
auto out1 = lowlevel->bestSymbol(a),
out2 = lowlevel2->bestSymbol((int)21 - a);
std::cout << "s1: " << out1 << "\ns2:" << out2 << "\n";
std::vector<std::tuple<rosa::id_t, StateType, ReliabilityType>> tmp2;
tmp2.push_back({0, out1.Identifier, out1.Likeliness});
tmp2.push_back({1, out2.Identifier, out2.Likeliness});
auto out_o = highlevel->operator()(tmp2);
std::cout << "it: " << a << "\t rel: " << out_o.CrossLikeliness << "\n";
std::cout << "\t subs:\n";
for (auto q : out_o.Likeliness) {
std::cout << "\t\t id:" << q.first << "\n";
/*
for(auto z: q.second)
{
std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Likeliness
<< "\n"; tmp.push_back({z.Identifier,z.Likeliness});
}
*/
for (auto z : q.second) {
std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Likeliness
<< "\n";
}
if (q.first == 0)
lowlevel->feedback(q.second);
else
lowlevel2->feedback(q.second);
}
}
/* ----------------------------- Cleanup
* --------------------------------------------------------------------- */
delete highlevel;
delete lowlevel;
delete lowlevel2;
}

File Metadata

Mime Type
text/x-c
Expires
Sun, Mar 1, 9:31 PM (1 d, 4 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
283008
Default Alt Text
Reliability-functionality.cpp (9 KB)

Event Timeline