Changeset 791 for cpp/frams/neuro/impl/neuroimpl-fuzzy-f0.cpp

Timestamp:

05/29/18 16:24:39 (6 years ago)

Author:

Maciej Komosinski

Message:

Code formatting

File:

• cpp/frams/neuro/impl/neuroimpl-fuzzy-f0.cpp (modified) (3 diffs)

cpp/frams/neuro/impl/neuroimpl-fuzzy-f0.cpp

@@ -14 +14 @@
 int FuzzyF0String::convertStrToSets(const SString& str, double numbers[], int nrOfSets)
 {
-  int pos=0;
-  SString t;
-  int have=0;
-  int maxnumbers=4*nrOfSets; //number of semicolons should be equal 4*nrOfSets
+        int pos = 0;
+        SString t;
+        int have = 0;
+        int maxnumbers = 4 * nrOfSets; //number of semicolons should be equal 4*nrOfSets
 
-  while (str.getNextToken(pos,t,';'))
-    if (have>=maxnumbers)
-      break;
-    else
-      numbers[have++]=atof(t.c_str());
+        while (str.getNextToken(pos, t, ';'))
+                if (have >= maxnumbers)
+                        break;
+                else
+                        numbers[have++] = atof(t.c_str());
 
-  //check if number of read numbers (separated with semicolon) is equal to declared
-  if (have != 4*nrOfSets)
-    return -1; //number of sets found is lower than declared!
+        //check if number of read numbers (separated with semicolon) is equal to declared
+        if (have != 4 * nrOfSets)
+                return -1; //number of sets found is lower than declared!
 
-  //check corectness of sets - must not be decreasing
-  for(int i=0;i<nrOfSets;i++)
-    if((numbers[4*i]>numbers[4*i+1])||(numbers[4*i+1]>numbers[4*i+2])||(numbers[4*i+2]>numbers[4*i+3]))
-      return -2; //error
+        //check corectness of sets - must not be decreasing
+        for (int i = 0; i < nrOfSets; i++)
+                if ((numbers[4 * i] > numbers[4 * i + 1]) || (numbers[4 * i + 1] > numbers[4 * i + 2]) || (numbers[4 * i + 2] > numbers[4 * i + 3]))
+                        return -2; //error
 
-  return 0;
+        return 0;
 }
 
@@ -47 +47 @@
 int FuzzyF0String::countInputsOutputs(const char* str, int ruldef[], int rulesNr)
 { //ruledef will remember counted number of inputs and outputs for every rule
-  const char* t;
-  int separators=0, inouts=0;
+        const char* t;
+        int separators = 0, inouts = 0;
 
-  for(t=str;*t;t++)
-  {
-    while(isdigit(*t))
-      t++; //only count, does not care about numbers now
-    if (!*t)
-      break; //end of the string - get out of 'for' loop
-    if ( (*t==';')||(*t==':')||(*t=='/') ) //found sth different than digit - it must be a separator
-    {
-      separators++; //one of separators
-      if (*t!=';') // end of [conditional part of] rule
-      {
-        if (inouts >= 2*rulesNr) //more rules declared in string than declared in rulesNr
-          return -2;
-        ruldef[inouts]=(separators+1)/2; //cause fuzzy sets - for 1 in/out there are 2 semicolons
-        separators=0;  //begin counting number of in/out from zero
-        inouts++; //next part of rule / or next rule
-      }
-    }
-    else // illegal character
-      return -1;
-  }
+        for (t = str; *t; t++)
+        {
+                while (isdigit(*t))
+                        t++; //only count, does not care about numbers now
+                if (!*t)
+                        break; //end of the string - get out of 'for' loop
+                if ((*t == ';') || (*t == ':') || (*t == '/')) //found sth different than digit - it must be a separator
+                {
+                        separators++; //one of separators
+                        if (*t != ';') // end of [conditional part of] rule
+                        {
+                                if (inouts >= 2 * rulesNr) //more rules declared in string than declared in rulesNr
+                                        return -2;
+                                ruldef[inouts] = (separators + 1) / 2; //cause fuzzy sets - for 1 in/out there are 2 semicolons
+                                separators = 0;  //begin counting number of in/out from zero
+                                inouts++; //next part of rule / or next rule
+                        }
+                }
+                else // illegal character
+                        return -1;
+        }
 
-  //check, if nr of found rules is equal to declared
-  if (inouts == 2*rulesNr) //each rule has a conditional part (inputs) and decisional part (outputs)
-    return 0;
-  else
-    return -5; // ShowMessage("Inconsistent number of rules!");
+        //check, if nr of found rules is equal to declared
+        if (inouts == 2 * rulesNr) //each rule has a conditional part (inputs) and decisional part (outputs)
+                return 0;
+        else
+                return -5; // ShowMessage("Inconsistent number of rules!");
 }
 
@@ -83 +83 @@
 int FuzzyF0String::convertStrToRules(const SString& str, const int ruledef[], int **rules, int setsNr, int rulesNr, int &maxOutputNr)
 {
-  int pos=0, j, k, len=str.len();
-  int dNr=0, sNr=0;
-  int inNr, outNr; //number of inputs/outputs and corresponding fuzzy sets
-  SString t;
-  bool conditional=true; //which part of rule: conditional or decisional
+        int pos = 0, j, k, len = str.len();
+        int dNr = 0, sNr = 0;
+        int inNr, outNr; //number of inputs/outputs and corresponding fuzzy sets
+        SString t;
+        bool conditional = true; //which part of rule: conditional or decisional
 
-  maxOutputNr=0; //sets maximum output nr found in rules string
+        maxOutputNr = 0; //sets maximum output nr found in rules string
 
-  //check corectness of the string: number semicolon ... separated with colon or slash
-  while(pos<len)
-  {
-    while((pos<len)&&(isdigit(str.charAt(pos)))) pos++;
-    if(!(pos<len))
-      break; //end of the string
-    if(str.charAt(pos)!=';')
-      if((str.charAt(pos)==':')&&(conditional))
-        {sNr++; conditional=false;}
-      else if((str.charAt(pos)=='/')&&(!conditional))
-        {dNr++; conditional=true;}
-      else
-        return -4; //error - illegal character
-    pos++;
-  }
-  if( (dNr!=sNr) || (dNr!=rulesNr) )
-    return -5; //error - wrong number of rules
+        //check corectness of the string: number semicolon ... separated with colon or slash
+        while (pos < len)
+        {
+                while ((pos < len) && (isdigit(str.charAt(pos)))) pos++;
+                if (!(pos < len))
+                        break; //end of the string
+                if (str.charAt(pos) != ';')
+                        if ((str.charAt(pos) == ':') && (conditional))
+                        {
+                        sNr++; conditional = false;
+                        }
+                        else if ((str.charAt(pos) == '/') && (!conditional))
+                        {
+                                dNr++; conditional = true;
+                        }
+                        else
+                                return -4; //error - illegal character
+                        pos++;
+        }
+        if ((dNr != sNr) || (dNr != rulesNr))
+                return -5; //error - wrong number of rules
 
-  pos=0;
+        pos = 0;
 
-  for(j=0;j<rulesNr;j++)
-  { //sum of inputs and outputs
-    inNr = 2*ruledef[2*j];
-    outNr = 2*ruledef[2*j+1];
-    for(k=0;k<inNr+outNr;k++)
-    {
-      t = ""; //clear previous value
-      //cuts next integer values
-      while ( (pos<len)&&(isdigit(str.charAt(pos))) )
-        t += str.charAt(pos++);
-      pos++;
-      rules[j][k]=atol(t.c_str()); //convert cut out string into number
-      //fuzzy sets - odd index table - are counted from 0,
-      //so if 5 fuzzy sets declared, values acceptable are 0,1,2,3,4
-      if ( ((k%2)!=0) && (rules[j][k] >= setsNr) )
-        return -1;
-      if((k>=inNr)&&((k%2)==0))
-        maxOutputNr=max(maxOutputNr,rules[j][k]);
-    }
-  }
-  return 0;
+        for (j = 0; j < rulesNr; j++)
+        { //sum of inputs and outputs
+                inNr = 2 * ruledef[2 * j];
+                outNr = 2 * ruledef[2 * j + 1];
+                for (k = 0; k < inNr + outNr; k++)
+                {
+                        t = ""; //clear previous value
+                        //cuts next integer values
+                        while ((pos < len) && (isdigit(str.charAt(pos))))
+                                t += str.charAt(pos++);
+                        pos++;
+                        rules[j][k] = atol(t.c_str()); //convert cut out string into number
+                        //fuzzy sets - odd index table - are counted from 0,
+                        //so if 5 fuzzy sets declared, values acceptable are 0,1,2,3,4
+                        if (((k % 2) != 0) && (rules[j][k] >= setsNr))
+                                return -1;
+                        if ((k >= inNr) && ((k % 2) == 0))
+                                maxOutputNr = max(maxOutputNr, rules[j][k]);
+                }
+        }
+        return 0;
 }
-