Page MenuHomePhorge
Files F332194

No OneTemporary
Actions

Size
27 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp b/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp
index 6fe7775..b509b8d 100644
--- a/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp
+++ b/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp
@@ -1,304 +1,315 @@
//===- examples/agent-functionalities/Reliability-functionality.cpp *C++-*-===//
//
// The RoSA Framework
//
//===----------------------------------------------------------------------===//
///
/// \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 inside a
/// master slave context.
///
//===----------------------------------------------------------------------===//
#define Reliability_trace_level 5
#include "rosa/config/version.h"
#include "rosa/support/log.h"
#include "rosa/agent/CrossReliability.h"
#include "rosa/agent/RangeConfidence.hpp"
#include "rosa/agent/Reliability.h"
#include "rosa/deluxe/DeluxeContext.hpp"
#include <map>
#include <vector>
+typedef double SensorValueType;
+typedef long StateType;
+typedef double ReliabilityType;
+
#include "./helper.h" // just stuff from Rel-func to increase readability
using namespace rosa::agent;
using namespace rosa;
using namespace rosa::deluxe;
using namespace rosa::terminal;
/// Helper structs for conversion
template <std::size_t, typename... types> struct conversion;
template <std::size_t size, typename... TypesA, template <typename...> class A,
typename... TypesB, template <typename...> class B>
struct conversion<size, A<TypesA...>, B<TypesB...>> {
using type = typename conversion<size - 1, std::tuple<TypesA...>,
std::tuple<TypesB..., TypesA...>>::type;
};
template <typename... TypesA, template <typename...> class A,
typename... TypesB, template <typename...> class B>
struct conversion<0, A<TypesA...>, B<TypesB...>> {
using type = DeluxeTuple<TypesB...>;
};
template <std::size_t size, typename... Types>
using unrolled_data_type =
typename conversion<size, std::tuple<Types...>, std::tuple<>>::type;
+template <std::size_t max, std::size_t at>
+struct __convert_to_vector {
+void operator()(
+ std::vector<ConfOrRel<StateType, ReliabilityType>> &feedback,
+ unrolled_data_type<max/2, StateType, ReliabilityType> I) {
+ __convert_to_vector<max, at - 2>(feedback, I);
+ feedback.push_back({std::get<at>(I.first), std::get<at + 1>(I.first)});
+}
+}
+;
+template <std::size_t max> struct __convert_to_vector<max, 0> {
+ void operator()(std::vector<ConfOrRel<StateType, ReliabilityType>> &feedback,
+ unrolled_data_type<max / 2, StateType, ReliabilityType> I) {
+ feedback.push_back({std::get<0>(I.first), std::get<1>(I.first)});
+ }
+};
+
+template <std::size_t number>
+void convert_to_vector(
+ std::vector<ConfOrRel<StateType, ReliabilityType>> &feedback,
+ unrolled_data_type<number, StateType, ReliabilityType> I) {
+ __convert_to_vector<number*2, number*2-2>()(feedback, I);
+}
+
+
int main(void) {
- typedef double SensorValueType;
- typedef long StateType;
- typedef double ReliabilityType;
const std::size_t number_of_states = 3;
std::unique_ptr<DeluxeContext> C = DeluxeContext::create("Deluxe");
//---------------------- Sensors -------------------------------------
//--------------------------------------------------------------------
const std::string SensorName1 = "Sensor1";
const std::string SensorName2 = "Sensor2";
const std::string SensorName3 = "Sensor3";
AgentHandle Sensor1 = C->createSensor<uint32_t, SensorValueType>(
SensorName1, [&SensorName1](std::pair<uint32_t, bool> I) {
LOG_INFO_STREAM << "\n******\n"
<< SensorName1 << " master-input "
<< (I.second ? "<New>" : "<Old>")
<< " value: " << I.first << "\n******\n";
});
AgentHandle Sensor2 = C->createSensor<uint32_t, SensorValueType>(
SensorName2, [&SensorName2](std::pair<uint32_t, bool> I) {
LOG_INFO_STREAM << "\n******\n"
<< SensorName2 << " master-input "
<< (I.second ? "<New>" : "<Old>")
<< " value: " << I.first << "\n******\n";
});
AgentHandle Sensor3 = C->createSensor<uint32_t, SensorValueType>(
SensorName3, [&SensorName3](std::pair<uint32_t, bool> I) {
LOG_INFO_STREAM << "\n******\n"
<< SensorName3 << " master-input "
<< (I.second ? "<New>" : "<Old>")
<< " value: " << I.first << "\n******\n";
});
//------------------------- lowlevel agents --------------------------------
//--------------------------------------------------------------------------
const std::string LowLevelAgentName1 = "LowLevelAgent1";
const std::string LowLevelAgentName2 = "LowLevelAgent2";
const std::string LowLevelAgentName3 = "LowLevelAgent3";
using conf = unrolled_data_type<
number_of_states, StateType,
- ReliabilityType>; // this is the confidence expressed as one tuple it uses
- // the format (first.state,first.rel,second.sate...)
+ ReliabilityType>; // this is the confidence expressed as one tuple it
+ // uses the format
+ // (first.state,first.rel,second.sate...)
using LowLevelAgentMasterResult = void; // no return
using LowLevelReturnFromMaster = std::pair<conf, bool>;
using FloatMasterHandler =
std::function<LowLevelAgentMasterResult(LowLevelReturnFromMaster)>;
using FloatResult = Optional<DeluxeTuple<StateType, ReliabilityType>>;
using FloatHandler =
std::function<FloatResult(std::pair<DeluxeTuple<SensorValueType>, bool>)>;
auto lowlevel1 = create_lowlevel_func();
+ auto lowlevel2 = create_lowlevel_func();
+ auto lowlevel3 = create_lowlevel_func();
- AgentHandle FloatAgent = C->createAgent(
+ AgentHandle SlaveAgent = C->createAgent(
LowLevelAgentName1,
// Master-input handler.
- FloatMasterHandler([&LowLevelAgentName1](LowLevelReturnFromMaster I)
- -> LowLevelAgentMasterResult {
-
- }),
+ FloatMasterHandler(
+ [&LowLevelAgentName1,
+ lowlevel1](LowLevelReturnFromMaster I) -> LowLevelAgentMasterResult {
+ LOG_INFO_STREAM << "inside: " << LowLevelAgentName1 << "feedback\n";
+ if (I.second) {
+ std::vector<ConfOrRel<StateType, ReliabilityType>> feedback;
+ convert_to_vector<number_of_states>(feedback, I.first);
+ lowlevel1->feedback(feedback);
+ }
+ }),
// Slave-input handler.
FloatHandler(
- [&LowLevelAgentName1](
+ [&LowLevelAgentName1, lowlevel1](
std::pair<DeluxeTuple<SensorValueType>, bool> I) -> FloatResult {
LOG_INFO_STREAM
<< "\n******\n"
<< LowLevelAgentName1 << " " << (I.second ? "<New>" : "<Old>")
<< " value: " << std::get<0>(I.first) << "\n******\n";
- DeluxeTuple<long, double> ret(0, std::get<0>(I.first));
+
+ auto tmp = lowlevel1->operator()(std::get<0>(I.first));
+ DeluxeTuple<long, double> ret(tmp.score, tmp.Reliability);
return {ret};
}));
- //------------------------- lookup copy of rel------------------------------
- //--------------------------------------------------------------------------
-
+ AgentHandle SlaveAgent2 = C->createAgent(
+ LowLevelAgentName2,
+ // Master-input handler.
+ FloatMasterHandler(
+ [&LowLevelAgentName2,
+ lowlevel2](LowLevelReturnFromMaster I) -> LowLevelAgentMasterResult {
+ LOG_INFO_STREAM << "inside: " << LowLevelAgentName2 << "feedback\n";
+ if (I.second) {
+ std::vector<ConfOrRel<StateType, ReliabilityType>> feedback;
+ convert_to_vector<number_of_states>(feedback, I.first);
+ lowlevel2->feedback(feedback);
+ }
+ }),
+ // Slave-input handler.
+ FloatHandler(
+ [&LowLevelAgentName2, lowlevel2](
+ std::pair<DeluxeTuple<SensorValueType>, bool> I) -> FloatResult {
+ LOG_INFO_STREAM
+ << "\n******\n"
+ << LowLevelAgentName2 << " " << (I.second ? "<New>" : "<Old>")
+ << " value: " << std::get<0>(I.first) << "\n******\n";
- /* ----------------------------- 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->operator()(a))
- << "\n";
+ auto tmp = lowlevel2->operator()(std::get<0>(I.first));
+ DeluxeTuple<long, double> ret(tmp.score, tmp.Reliability);
+ return {ret};
+ }));
+
+ AgentHandle SlaveAgent3 = C->createAgent(
+ LowLevelAgentName3,
+ // Master-input handler.
+ FloatMasterHandler(
+ [&LowLevelAgentName3,
+ lowlevel3](LowLevelReturnFromMaster I) -> LowLevelAgentMasterResult {
+ LOG_INFO_STREAM << "inside: " << LowLevelAgentName3 << "feedback\n";
+ if (I.second) {
+ std::vector<ConfOrRel<StateType, ReliabilityType>> feedback;
+ convert_to_vector<number_of_states>(feedback, I.first);
+ lowlevel3->feedback(feedback);
+ }
+ }),
+ // Slave-input handler.
+ FloatHandler(
+ [&LowLevelAgentName3, lowlevel3](
+ std::pair<DeluxeTuple<SensorValueType>, bool> I) -> FloatResult {
+ LOG_INFO_STREAM
+ << "\n******\n"
+ << LowLevelAgentName3 << " " << (I.second ? "<New>" : "<Old>")
+ << " value: " << std::get<0>(I.first) << "\n******\n";
+
+ auto tmp = lowlevel3->operator()(std::get<0>(I.first));
+ DeluxeTuple<long, double> ret(tmp.score, tmp.Reliability);
+ return {ret};
+ }));
- /* ----------------------------- Cleanup
- * --------------------------------------------------------------------- */
+ //------------------------- lookup copy of rel------------------------------
+ //--------------------------------------------------------------------------
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::unique_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::unique_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability2(
- new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
-
- std::unique_ptr<Abstraction<SensorValueType, ReliabilityType>>
- ReliabilitySlope2(
- new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
-
- std::unique_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence2(
- new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 9));
-
- auto lowlevel2 = new ReliabilityForLowLevelAgents<SensorValueType, StateType,
- ReliabilityType>();
-
- std::vector<long> states2;
- states2.push_back(0);
- states2.push_back(1);
- states2.push_back(2);
-
- lowlevel2->setConfidenceFunction(Confidence2);
- lowlevel2->setReliabilityFunction(Reliability2);
- lowlevel2->setReliabilitySlopeFunction(ReliabilitySlope2);
- lowlevel2->setTimeConfidenceFunction(TimeConfidence2);
- lowlevel2->setStates(states2);
- lowlevel2->setHistoryLength(2);
- lowlevel2->setValueSetCounter(1);
-
ReliabilityForHighLevelAgents<StateType, ReliabilityType> *highlevel =
new ReliabilityForHighLevelAgents<StateType, ReliabilityType>();
std::unique_ptr<CrossReliability<StateType, ReliabilityType>>
CrossReliability1(new CrossReliability<StateType, ReliabilityType>());
std::unique_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));
CrossReliability1->addCrossReliabilityProfile(0, 1, func1);
CrossReliability1->setCrossReliabilityMethod(
CrossReliability<StateType, ReliabilityType>::AVERAGE);
CrossReliability1->setCrossReliabilityParameter(1);
std::unique_ptr<CrossConfidence<StateType, ReliabilityType>> CrossConfidence1(
new CrossConfidence<StateType, ReliabilityType>());
std::unique_ptr<Abstraction<long, double>> func2(
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));
CrossConfidence1->addCrossReliabilityProfile(0, 1, func2);
CrossConfidence1->setCrossReliabilityMethod(
CrossConfidence<StateType, ReliabilityType>::AVERAGE);
CrossConfidence1->setCrossReliabilityParameter(1);
highlevel->setCrossConfidence(CrossConfidence1);
highlevel->setCrossReliability(CrossReliability1);
highlevel->addStates(0, states);
highlevel->addStates(1, states);
for (int a = 0; a < 21; a++) {
auto out1 = lowlevel->operator()(a),
out2 = lowlevel2->operator()((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.score, out1.Reliability});
tmp2.push_back({1, out2.score, out2.Reliability});
auto out_o = highlevel->operator()(tmp2);
std::cout << "it: " << a << "\t rel: " << out_o.CrossReliability << "\n";
std::cout << "\t subs:\n";
for (auto q : out_o.CrossConfidence) {
std::cout << "\t\t id:" << q.first << "\n";
/*
for(auto z: q.second)
{
std::cout << "\t\t\t score: " << z.score << "\tRel: " << z.Reliability
<< "\n"; tmp.push_back({z.score,z.Reliability});
}
*/
for (auto z : q.second) {
std::cout << "\t\t\t score: " << z.score << "\tRel: " << z.Reliability
<< "\n";
}
if (q.first == 0)
lowlevel->feedback(q.second);
else
lowlevel2->feedback(q.second);
}
}
- delete lowlevel;
+ delete lowlevel1;
delete lowlevel2;
}
\ No newline at end of file
diff --git a/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp b/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
index a80318a..1e1ae48 100644
--- a/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
+++ b/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
@@ -1,263 +1,264 @@
//===- examples/agent-functionalities/Reliability-functionality.cpp *C++-*-===//
//
// The RoSA Framework
//
//===----------------------------------------------------------------------===//
///
/// \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/CrossReliability.h"
#include "rosa/agent/RangeConfidence.hpp"
#include "rosa/agent/Reliability.h"
#include <map>
#include <vector>
using namespace rosa::agent;
int main(void) {
typedef double SensorValueType;
typedef long StateType;
typedef double ReliabilityType;
std::unique_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::unique_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
std::unique_ptr<Abstraction<SensorValueType, ReliabilityType>>
ReliabilitySlope(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
std::unique_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence(
new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 3));
auto lowlevel = new ReliabilityForLowLevelAgents<SensorValueType, StateType, ReliabilityType>();
std::vector<long> states;
states.push_back(0);
states.push_back(1);
states.push_back(2);
lowlevel->setConfidenceFunction(Confidence);
lowlevel->setReliabilityFunction(Reliability);
lowlevel->setReliabilitySlopeFunction(ReliabilitySlope);
lowlevel->setTimeConfidenceFunction(TimeConfidence);
lowlevel->setStates(states);
lowlevel->setHistoryLength(2);
lowlevel->setValueSetCounter(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->operator()(a))
<< "\n";
- /* ----------------------------- Cleanup
- * --------------------------------------------------------------------- */
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::unique_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::unique_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability2(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
std::unique_ptr<Abstraction<SensorValueType, ReliabilityType>>
ReliabilitySlope2(
new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
std::unique_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence2(
new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 9));
auto lowlevel2 = new ReliabilityForLowLevelAgents<SensorValueType, StateType,
ReliabilityType>();
std::vector<long> states2;
states2.push_back(0);
states2.push_back(1);
states2.push_back(2);
lowlevel2->setConfidenceFunction(Confidence2);
lowlevel2->setReliabilityFunction(Reliability2);
lowlevel2->setReliabilitySlopeFunction(ReliabilitySlope2);
lowlevel2->setTimeConfidenceFunction(TimeConfidence2);
lowlevel2->setStates(states2);
lowlevel2->setHistoryLength(2);
lowlevel2->setValueSetCounter(1);
ReliabilityForHighLevelAgents<StateType, ReliabilityType> *highlevel =
new ReliabilityForHighLevelAgents<StateType, ReliabilityType>();
std::unique_ptr<CrossReliability<StateType, ReliabilityType>>
CrossReliability1(new CrossReliability<StateType, ReliabilityType>());
std::unique_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));
CrossReliability1->addCrossReliabilityProfile(0, 1, func1);
CrossReliability1->setCrossReliabilityMethod(
CrossReliability<StateType, ReliabilityType>::AVERAGE);
CrossReliability1->setCrossReliabilityParameter(1);
std::unique_ptr<CrossConfidence<StateType, ReliabilityType>> CrossConfidence1(
new CrossConfidence<StateType, ReliabilityType>());
std::unique_ptr<Abstraction<long, double>> func2(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));
CrossConfidence1->addCrossReliabilityProfile(0, 1, func2);
CrossConfidence1->setCrossReliabilityMethod(
CrossConfidence<StateType, ReliabilityType>::AVERAGE);
CrossConfidence1->setCrossReliabilityParameter(1);
highlevel->setCrossConfidence(CrossConfidence1);
highlevel->setCrossReliability(CrossReliability1);
highlevel->addStates(0, states);
highlevel->addStates(1, states);
for (int a = 0; a < 21; a++) {
auto out1 = lowlevel->operator()(a), out2 = lowlevel2->operator()((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.score, out1.Reliability});
tmp2.push_back({1, out2.score, out2.Reliability});
auto out_o = highlevel->operator()(tmp2);
std::cout << "it: " << a << "\t rel: " << out_o.CrossReliability << "\n";
std::cout << "\t subs:\n";
for (auto q : out_o.CrossConfidence) {
std::cout << "\t\t id:" << q.first << "\n";
/*
for(auto z: q.second)
{
std::cout << "\t\t\t score: " << z.score << "\tRel: " << z.Reliability
<< "\n"; tmp.push_back({z.score,z.Reliability});
}
*/
for (auto z : q.second) {
std::cout << "\t\t\t score: " << z.score << "\tRel: " << z.Reliability
<< "\n";
}
if (q.first == 0)
lowlevel->feedback(q.second);
else
lowlevel2->feedback(q.second);
}
}
+ /* ----------------------------- Cleanup
+ * --------------------------------------------------------------------- */
+ delete highlevel;
delete lowlevel;
delete lowlevel2;
}
\ No newline at end of file

File Metadata

Mime Type
text/x-diff
Expires
Sun, Mar 16, 10:44 AM (1 d, 20 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
129107
Default Alt Text
(27 KB)

Event Timeline