1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
/*
fuzzylite (R), a fuzzy logic control library in C++.
Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
This file is part of fuzzylite.
fuzzylite is free software: you can redistribute it and/or modify it under
the terms of the FuzzyLite License included with the software.
You should have received a copy of the FuzzyLite License along with
fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
fuzzylite is a registered trademark of FuzzyLite Limited.
*/
#include "fl/activation/First.h"
#include "fl/rule/RuleBlock.h"
#include "fl/rule/Rule.h"
#include "fl/Operation.h"
namespace fl {
First::First(int numberOfRules, scalar threshold) : Activation(),
_numberOfRules(numberOfRules), _threshold(threshold) { }
First::~First() { }
std::string First::className() const {
return "First";
}
std::string First::parameters() const {
return Op::str(getNumberOfRules()) + " " + Op::str(getThreshold());
}
void First::configure(const std::string& parameters) {
if (parameters.empty()) return;
std::vector<std::string> values = Op::split(parameters, " ");
std::size_t required = 2;
if (values.size() < required) {
std::ostringstream ex;
ex << "[configuration error] activation <" << className() << ">"
<< " requires <" << required << "> parameters";
throw Exception(ex.str(), FL_AT);
}
setNumberOfRules((int) Op::toScalar(values.at(0)));
setThreshold(Op::toScalar(values.at(1)));
}
Complexity First::complexity(const RuleBlock* ruleBlock) const {
Complexity result;
const TNorm* conjunction = ruleBlock->getConjunction();
const SNorm* disjunction = ruleBlock->getDisjunction();
const TNorm* implication = ruleBlock->getImplication();
Complexity meanFiring;
for (std::size_t i = 0; i < ruleBlock->numberOfRules(); ++i) {
result.comparison(1 + 3);
const Rule* rule = ruleBlock->getRule(i);
result += rule->complexityOfActivation(conjunction, disjunction);
meanFiring += rule->complexityOfFiring(implication);
}
meanFiring.divide(scalar(ruleBlock->numberOfRules()));
result += meanFiring.multiply(getNumberOfRules());
result += Complexity().arithmetic(1).multiply(getNumberOfRules());
return result;
}
void First::activate(RuleBlock* ruleBlock) {
FL_DBG("Activation: " << className() << " " << parameters());
const TNorm* conjunction = ruleBlock->getConjunction();
const SNorm* disjunction = ruleBlock->getDisjunction();
const TNorm* implication = ruleBlock->getImplication();
int activated = 0;
for (std::vector<Rule*>::const_iterator it = ruleBlock->rules().begin();
it != ruleBlock->rules().end(); ++it) {
Rule* rule = (*it);
rule->deactivate();
if (rule->isLoaded()) {
scalar activationDegree = rule->activateWith(conjunction, disjunction);
if (activated < _numberOfRules
and Op::isGt(activationDegree, 0.0)
and Op::isGE(activationDegree, _threshold)) {
rule->trigger(implication);
++activated;
}
}
}
}
void First::setNumberOfRules(int numberOfRules) {
this->_numberOfRules = numberOfRules;
}
int First::getNumberOfRules() const {
return this->_numberOfRules;
}
void First::setThreshold(scalar threshold) {
this->_threshold = threshold;
}
scalar First::getThreshold() const {
return this->_threshold;
}
First* First::clone() const {
return new First(*this);
}
Activation* First::constructor() {
return new First;
}
}
|
