SubState.cpp
No OneTemporary
Actions

Size

9 KB

Referenced Files

None

Subscribers

None

SubState.cpp
View Options

	#include "rosa/agent/experimental/SubState.hpp"

	//#include "printError.h"
	#include "rosa/agent/experimental/relationChecker.hpp"

	#include "rosa/agent/experimental/minmaxzeug.hpp"
	#include <iostream>
	#include <vector>
	#include <algorithm>

	SubState::SubState() {
	confidenceValidState = 0;
	confidenceInvalidState = 1;
	}

	void SubState::setSlot(SlaveAgentSlotOfAgent* slot) {
	this->slot = slot;
	}

	SlaveAgentSlotOfAgent* SubState::getSlot() {
	return slot;
	}

	bool SubState::addNewDiscreteAverage() {

	AverageValue* averageValue = new (nothrow) AverageValue();
	if (averageValue != NULL) {
	//try {
	vDiscreteAverage.push_back(averageValue);

	//printf("vDiscreteAverage size = %u\n", vDiscreteAverage.size());

	return true;
	/*}
	catch (bad_alloc& error) {
	printf("bad_alloc caught: %s", error.what());
	delete averageValue;
	}*/
	}
	return false;
	}


	bool SubState::injectValue() {
	float value;

	if (slot->get_slaveAgentValue(&value)) {
	statisticValue.injectAndCalculateStatisticValue(value);

	if (!vDiscreteAverage.empty()) {
	vDiscreteAverage.back()->injectAndCalculateAverageValue(value);
	return true;
	}
	}

	return false;
	}


	bool SubState::valueIsRelated(float thresholdToBeRelated) {
	float value;
	if (slot->get_slaveAgentValue(&value)) {
	return valueIsRelatedToReferenceValueOrBetweenMinAndMax(statisticValue.getAverageValue(), statisticValue.getMinimumValue(), statisticValue.getMaximumValue(), value, thresholdToBeRelated);
	}

	return false;
	}

	unsigned int SubState::getNumOfInjections() {
	return statisticValue.getInjectedValuesCounter();
	}

	bool SubState::lastDiscreteAverageBlockIsCompleted(unsigned int discreteAveragePartitionSize) {
	if (!vDiscreteAverage.empty()) {
	if (vDiscreteAverage.back()->getInjectedValuesCounter() < discreteAveragePartitionSize) {
	return false;
	}
	}
	return true;
	}

	unsigned int SubState::getNumberOfCompletedDiscreteAverageBlocks(unsigned int discreteAveragePartitionSize) {

	unsigned int numberOfDiscreteAverageBlocks = vDiscreteAverage.size();

	//printf("vDiscreteAverage.size() = %u\n", numberOfDiscreteAverageBlocks);

	if (!lastDiscreteAverageBlockIsCompleted(discreteAveragePartitionSize)) {
	numberOfDiscreteAverageBlocks--;
	}

	return vDiscreteAverage.size();
	}


	float SubState::getDiscreteAverageOfFirstBlock(unsigned int discreteAveragePartitionSize) {

	if (getNumberOfCompletedDiscreteAverageBlocks(discreteAveragePartitionSize) > 0) {
	return vDiscreteAverage.front()->getAverageValue();
	}
	//TODO: error handling - return 0 is not acceptable
	return 0;
	}

	float SubState::getDiscreteAverageOfLastBlock(unsigned int discreteAveragePartitionSize) {

	if (lastDiscreteAverageBlockIsCompleted(discreteAveragePartitionSize)) {
	return vDiscreteAverage.back()->getAverageValue();
	}
	else if (vDiscreteAverage.size() > 1) {
	return vDiscreteAverage.at(vDiscreteAverage.size()-1)->getAverageValue();
	}
	//TODO: error handling - return 0 is not acceptable
	return 0;
	}

	float SubState::getDiscreteAverageOfBlockBeforeLastBlock(unsigned int discreteAveragePartitionSize, unsigned int jumpBackDistance) {


	if (getNumberOfCompletedDiscreteAverageBlocks(discreteAveragePartitionSize) > jumpBackDistance) {

	if (lastDiscreteAverageBlockIsCompleted(discreteAveragePartitionSize)) {
	return vDiscreteAverage.at(vDiscreteAverage.size() - jumpBackDistance)->getAverageValue();
	}
	else {
	return vDiscreteAverage.at(vDiscreteAverage.size() - (jumpBackDistance + 1))->getAverageValue();
	}

	}
	else {
	return vDiscreteAverage.front()->getAverageValue();
	}
	}

	void SubState::deleteLastDiscreteAverageBlockIfNotCompleted(unsigned int discreteAveragePartitionSize) {
	if (!vDiscreteAverage.empty()) {
	if (vDiscreteAverage.back()->getInjectedValuesCounter() < discreteAveragePartitionSize) {
	vDiscreteAverage.pop_back();
	}
	}
	}

	//DATE18
	float SubState::valueIsRelatedFuzzy(LinearFunctionBlock* SameState) {

	//XXX - Original war: valueIsRelatedToReferenceValueOrBetweenMinAndMax!
	float sampleValue;
	if (slot->get_slaveAgentValue(&sampleValue)) {
	printf("geht hinein - sample: %f, average: %f\n", sampleValue, statisticValue.getAverageValue());
	return SameState->getY(deviationValueReferenceValue(sampleValue, statisticValue.getAverageValue()));
	}

	printf("leider hier\n");

	//todo: isn't the best error handling
	return 0;
	}

	bool SubState::insertValueInSubState(LinearFunctionBlock* FuncBlockConfValStateDev, LinearFunctionBlock* FuncBlockConfInvStateDev, LinearFunctionBlock* FuncBlockConfValStateTime, LinearFunctionBlock* FuncBlockConfInvStateTime, unsigned int historySize) {

	bool insertionWorked = true;

	float sampleValue;
	if (slot->get_slaveAgentValue(&sampleValue)) {

	//statistic value
	statisticValue.injectAndCalculateStatisticValue(sampleValue);

	//DABs
	if (vDiscreteAverage.empty())
	insertionWorked = false;
	else
	vDiscreteAverage.back()->injectAndCalculateAverageValue(sampleValue);

	float worstConfidenceDeviation = 1;
	float bestConfidenceDeviation = 0;
	for (auto &historyValue : lSampleHistory) {
	bestConfidenceDeviation = maxValueOf2Values(bestConfidenceDeviation, FuncBlockConfInvStateDev->getY(deviationValueReferenceValue(sampleValue, historyValue)));
	worstConfidenceDeviation = minValueOf2Values(worstConfidenceDeviation, FuncBlockConfValStateDev->getY(deviationValueReferenceValue(sampleValue, historyValue)));
	}
	lBestConfidencesDeviation.push_front(bestConfidenceDeviation);
	lWorstConfidencesDeviation.push_front(worstConfidenceDeviation);

	//save actual value in history
	//try {
	lSampleHistory.push_front(sampleValue);
	/*}
	catch (bad_alloc& error) {
	printf("bad_alloc caught: %s", error.what());
	insertionWorked = false;
	}*/

	//delete last history- and deviation entry if history is full
	while (lSampleHistory.size() > historySize) {
	lSampleHistory.pop_back();
	lBestConfidencesDeviation.pop_back();
	lWorstConfidencesDeviation.pop_back();
	}


	//calculate the confidence with that the actual value fits to all of the history values
	bestConfidenceDeviation = 0;
	worstConfidenceDeviation = 1;
	for (auto &confDev : lBestConfidencesDeviation)
	bestConfidenceDeviation = minValueOf2Values(bestConfidenceDeviation, confDev);
	for (auto &confDev : lWorstConfidencesDeviation)
	worstConfidenceDeviation = maxValueOf2Values(worstConfidenceDeviation, confDev);


	//printf("confidence invalid time: %f\n", FuncBlockConfInvStateTime->getY((float)lSampleHistory.size()));


	confidenceValidState = minValueOf2Values(worstConfidenceDeviation, FuncBlockConfValStateTime->getY((float)lSampleHistory.size()));
	confidenceInvalidState = maxValueOf2Values(bestConfidenceDeviation, FuncBlockConfInvStateTime->getY((float)lSampleHistory.size()));
	}

	return insertionWorked;


	/*
	float value;

	if (slot->get_slaveAgentValue(&value)) {
	statisticValue.injectAndCalculateStatisticValue(value);

	if (!vDiscreteAverage.empty()) {
	vDiscreteAverage.back()->injectAndCalculateAverageValue(value);
	return true;
	}
	}

	return false;
	*/


	}


	float SubState::getConfidenceValidState() {
	return confidenceValidState;
	}

	float SubState::getConfidenceInvalidState() {
	return confidenceInvalidState;
	}

	float SubState::getConfVarIsSim2State(LinearFunctionBlock* FuncBlockConfSim2StateDev, LinearFunctionBlock* FuncBlockConfSim2StateTime) {

	float highestConfOf1Var = 0;
	float sampleValue;
	if (slot->get_slaveAgentValue(&sampleValue)) {

	vector<float> vDeviations;

	for (auto &h : lSampleHistory)
	vDeviations.push_back(deviationValueReferenceValue(sampleValue, h));

	sort(begin(vDeviations), end(vDeviations));

	//all adaptabilities within the history of one variable
	for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) {

	float lowestConfOfSamplesIncluded = 1;
	unsigned int histSampleCounter = 0;

	for (auto &deviation : vDeviations) {
	if (histSampleCounter >= numOfHistSamplesIncluded)
	break;
	lowestConfOfSamplesIncluded = fuzzyAND(lowestConfOfSamplesIncluded, FuncBlockConfSim2StateDev->getY(deviation));
	histSampleCounter++;
	}

	highestConfOf1Var = fuzzyOR(highestConfOf1Var, fuzzyAND(lowestConfOfSamplesIncluded, FuncBlockConfSim2StateTime->getY((float)histSampleCounter)));
	}
	}

	return highestConfOf1Var;
	}

	//Sorting with bigger Value in Front
	struct descending
	{
	template<class T>
	bool operator()(T const &a, T const &b) const { return a > b; }
	};

	float SubState::getConfVarIsDif2State(LinearFunctionBlock* FuncBlockConfDif2StateDev, LinearFunctionBlock* FuncBlockConfDif2StateTime) {

	//float highestConfOf1Var = 0;
	float highestConfOf1Var = 1;
	float sampleValue;
	if (slot->get_slaveAgentValue(&sampleValue)) {

	vector<float> vDeviations;

	for (auto &h : lSampleHistory)
	vDeviations.push_back(deviationValueReferenceValue(sampleValue, h));

	sort(begin(vDeviations), end(vDeviations), descending());

	//all adaptabilities within the history of one variable
	for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) {

	float highestConfOfSamplesIncluded = 0;
	unsigned int histSampleCounter = 0;

	for (auto &deviation : vDeviations) {
	if (histSampleCounter >= numOfHistSamplesIncluded)
	break;
	highestConfOfSamplesIncluded = fuzzyOR(highestConfOfSamplesIncluded, FuncBlockConfDif2StateDev->getY(deviation));
	histSampleCounter++;
	}

	//highestConfOf1Var = fuzzyOR(highestConfOf1Var, fuzzyOR(highestConfOfSamplesIncluded, FuncBlockConfDif2StateTime->getY((float)histSampleCounter)));
	highestConfOf1Var = fuzzyAND(highestConfOf1Var, fuzzyOR(highestConfOfSamplesIncluded, FuncBlockConfDif2StateTime->getY((float)histSampleCounter)));

	}
	}

	return highestConfOf1Var;
	}

	unsigned int SubState::getSampleHistoryLength() {
	return lSampleHistory.size();
	}

File Metadata

Mime Type: text/x-c
Expires: Sun, Jun 21, 1:09 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 334231
Default Alt Text: SubState.cpp (9 KB)

SubState.cppNo OneTemporaryActions

SubState.cppView Options

File Metadata

Event Timeline

SubState.cpp
No OneTemporary
Actions

SubState.cpp
View Options