1 | /// this is a module included into neuroimpl-fuzzy |
---|
2 | /// it converts string parameters - fuzzy sets and fuzzy rules - into appropriate variables |
---|
3 | |
---|
4 | #include "neuroimpl-fuzzy-f0.h" |
---|
5 | // nonstd z powodu max() |
---|
6 | #include "nonstd.h" |
---|
7 | |
---|
8 | //this part concerns fuzzy sets transformation |
---|
9 | |
---|
10 | /** This function converts given string into numbers representing fuzzy sets */ |
---|
11 | int FuzzyF0String::convertStrToSets(const SString& str, double numbers[], int nrOfSets) |
---|
12 | { |
---|
13 | int pos=0; |
---|
14 | SString t; |
---|
15 | int have=0; |
---|
16 | int maxnumbers=4*nrOfSets; //number of semicolons should be equal 4*nrOfSets |
---|
17 | |
---|
18 | while (str.getNextToken(pos,t,';')) |
---|
19 | if (have>=maxnumbers) |
---|
20 | break; |
---|
21 | else |
---|
22 | numbers[have++]=atof(t); |
---|
23 | |
---|
24 | //check if number of read numbers (separated with semicolon) is equal to declared |
---|
25 | if (have != 4*nrOfSets) |
---|
26 | return -1; //number of sets found is lower than declared! |
---|
27 | |
---|
28 | //check corectness of sets - must not be decreasing |
---|
29 | for(int i=0;i<nrOfSets;i++) |
---|
30 | if((numbers[4*i]>numbers[4*i+1])||(numbers[4*i+1]>numbers[4*i+2])||(numbers[4*i+2]>numbers[4*i+3])) |
---|
31 | return -2; //error |
---|
32 | |
---|
33 | return 0; |
---|
34 | } |
---|
35 | |
---|
36 | //this part concerns fuzzy rules transformation |
---|
37 | |
---|
38 | /** This function counts number of inputs and outputs given in string consisting fuzzy rules. |
---|
39 | It counts number of separators: |
---|
40 | ; between inputs/outputs and fuzzy sets number |
---|
41 | : between conditional and decision part of a rule |
---|
42 | / end of rule |
---|
43 | */ |
---|
44 | int FuzzyF0String::countInputsOutputs(const char* str, int ruldef[], int rulesNr) |
---|
45 | { //ruledef will remember counted number of inputs and outputs for every rule |
---|
46 | const char* t; |
---|
47 | int separators=0, inouts=0; |
---|
48 | |
---|
49 | for(t=str;*t;t++) |
---|
50 | { |
---|
51 | while(isdigit(*t)) |
---|
52 | t++; //only count, does not care about numbers now |
---|
53 | if (!*t) |
---|
54 | break; //end of the string - get out of 'for' loop |
---|
55 | if ( (*t==';')||(*t==':')||(*t=='/') ) //found sth different than digit - it must be a separator |
---|
56 | { |
---|
57 | separators++; //one of separators |
---|
58 | if (*t!=';') // end of [conditional part of] rule |
---|
59 | { |
---|
60 | if (inouts >= 2*rulesNr) //more rules declared in string than declared in rulesNr |
---|
61 | return -2; |
---|
62 | ruldef[inouts]=(separators+1)/2; //cause fuzzy sets - for 1 in/out there are 2 semicolons |
---|
63 | separators=0; //begin counting number of in/out from zero |
---|
64 | inouts++; //next part of rule / or next rule |
---|
65 | } |
---|
66 | } |
---|
67 | else // illegal character |
---|
68 | return -1; |
---|
69 | } |
---|
70 | |
---|
71 | //check, if nr of found rules is equal to declared |
---|
72 | if (inouts == 2*rulesNr) //each rule has a conditional part (inputs) and decisional part (outputs) |
---|
73 | return 0; |
---|
74 | else |
---|
75 | return -5; // ShowMessage("Inconsistent number of rules!"); |
---|
76 | } |
---|
77 | |
---|
78 | /** This function converts given string into variable 'rules' that remembers all inputs/outputs and fuzzy set. |
---|
79 | The procedure is conduct according to ruledef, calculated earlier.*/ |
---|
80 | int FuzzyF0String::convertStrToRules(const SString& str, const int ruledef[], int **rules, int setsNr, int rulesNr, int &maxOutputNr) |
---|
81 | { |
---|
82 | int pos=0, j, k, len=str.len(); |
---|
83 | int dNr=0, sNr=0; |
---|
84 | int inNr, outNr; //number of inputs/outputs and corresponding fuzzy sets |
---|
85 | SString t; |
---|
86 | bool conditional=true; //which part of rule: conditional or decisional |
---|
87 | |
---|
88 | maxOutputNr=0; //sets maximum output nr found in rules string |
---|
89 | |
---|
90 | //check corectness of the string: number semicolon ... separated with colon or slash |
---|
91 | while(pos<len) |
---|
92 | { |
---|
93 | while((pos<len)&&(isdigit(str.charAt(pos)))) pos++; |
---|
94 | if(!(pos<len)) |
---|
95 | break; //end of the string |
---|
96 | if(str.charAt(pos)!=';') |
---|
97 | if((str.charAt(pos)==':')&&(conditional)) |
---|
98 | {sNr++; conditional=false;} |
---|
99 | else if((str.charAt(pos)=='/')&&(!conditional)) |
---|
100 | {dNr++; conditional=true;} |
---|
101 | else |
---|
102 | return -4; //error - illegal character |
---|
103 | pos++; |
---|
104 | } |
---|
105 | if( (dNr!=sNr) || (dNr!=rulesNr) ) |
---|
106 | return -5; //error - wrong number of rules |
---|
107 | |
---|
108 | pos=0; |
---|
109 | |
---|
110 | for(j=0;j<rulesNr;j++) |
---|
111 | { //sum of inputs and outputs |
---|
112 | inNr = 2*ruledef[2*j]; |
---|
113 | outNr = 2*ruledef[2*j+1]; |
---|
114 | for(k=0;k<inNr+outNr;k++) |
---|
115 | { |
---|
116 | t = ""; //clear previous value |
---|
117 | //cuts next integer values |
---|
118 | while ( (pos<len)&&(isdigit(str.charAt(pos))) ) |
---|
119 | t += str.charAt(pos++); |
---|
120 | pos++; |
---|
121 | rules[j][k]=atol(t); //convert cut out string into number |
---|
122 | //fuzzy sets - odd index table - are counted from 0, |
---|
123 | //so if 5 fuzzy sets declared, values acceptable are 0,1,2,3,4 |
---|
124 | if ( ((k%2)!=0) && (rules[j][k] >= setsNr) ) |
---|
125 | return -1; |
---|
126 | if((k>=inNr)&&((k%2)==0)) |
---|
127 | maxOutputNr=max(maxOutputNr,rules[j][k]); |
---|
128 | } |
---|
129 | } |
---|
130 | return 0; |
---|
131 | }; |
---|
132 | |
---|