API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 12th, 2017
73
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 42.54 KB | None | 0 0
raw download clone embed print report
  1. #include <FuzzyRule.h>
  2. #include <FuzzyComposition.h>
  3. #include <Fuzzy.h>
  4. #include <FuzzyRuleConsequent.h>
  5. #include <FuzzyOutput.h>
  6. #include <FuzzyInput.h>
  7. #include <FuzzyIO.h>
  8. #include <FuzzySet.h>
  9. #include <FuzzyRuleAntecedent.h>
  10.  
  11. Fuzzy* fuzzy = new Fuzzy();
  12. // for BMI
  13. FuzzySet* BMI_L = new FuzzySet(0, 0, 0, 25);
  14. FuzzySet* BMI_O = new FuzzySet(25, 27.5, 27.5, 30);
  15. FuzzySet* BMI_H = new FuzzySet(30, 40, 40, 40);
  16. // for CHO
  17. FuzzySet* CHO_L = new FuzzySet(340, 340, 340, 390);
  18. FuzzySet* CHO_O = new FuzzySet(390, 415, 415, 440);
  19. FuzzySet* CHO_H = new FuzzySet(440, 490, 490, 490);
  20. // for Weight
  21. FuzzySet* WEIGHT_VL = new FuzzySet(71, 71, 71, 75);
  22. FuzzySet* WEIGHT_L = new FuzzySet(75, 77.5, 77.5, 80);
  23. FuzzySet* WEIGHT_O1 = new FuzzySet(80, 82.5, 82.5, 85);
  24. FuzzySet* WEIGHT_O2 = new FuzzySet(85, 87.5, 87.5, 90);
  25. FuzzySet* WEIGHT_H = new FuzzySet(90, 92.5, 92.5, 95);
  26. FuzzySet* WEIGHT_VH = new FuzzySet(95, 97.5, 97.5, 100);
  27. // for Insulin
  28. FuzzySet* insulin_A = new FuzzySet(25, 25, 25, 30.5);
  29. FuzzySet* insulin_B = new FuzzySet(30.5, 33, 33, 35.5);
  30. FuzzySet* insulin_C = new FuzzySet(35.5, 39.5, 39.5, 43.5);
  31. FuzzySet* insulin_D = new FuzzySet(43.5, 46.5, 46.5, 49.5);
  32. FuzzySet* insulin_E = new FuzzySet(49.5, 55, 55, 55);
  33.  
  34. void setup()
  35. {
  36.     Serial.begin(9600);
  37.     // ==================================================
  38.     // Fuzzy input for BMI
  39.     FuzzyInput* BMI = new FuzzyInput(1);
  40.     BMI->addFuzzySet(BMI_L);
  41.     BMI->addFuzzySet(BMI_O);
  42.     BMI->addFuzzySet(BMI_H);
  43.  
  44.     fuzzy->addFuzzyInput(BMI);
  45.  
  46.     // Fuzzy input for CHO
  47.     FuzzyInput* CHO = new FuzzyInput(2);
  48.     CHO->addFuzzySet(CHO_L);
  49.     CHO->addFuzzySet(CHO_O);
  50.     CHO->addFuzzySet(CHO_H);
  51.  
  52.     fuzzy->addFuzzyInput(CHO);
  53.  
  54.     // Fuzzy input for weight
  55.     FuzzyInput* WEIGHT = new FuzzyInput(3);
  56.     WEIGHT->addFuzzySet(WEIGHT_VL);
  57.     WEIGHT->addFuzzySet(WEIGHT_L);
  58.     WEIGHT->addFuzzySet(WEIGHT_O1);
  59.     WEIGHT->addFuzzySet(WEIGHT_O2);
  60.     WEIGHT->addFuzzySet(WEIGHT_H);
  61.     WEIGHT->addFuzzySet(WEIGHT_VH);
  62.  
  63.     fuzzy->addFuzzyInput(WEIGHT);
  64.  
  65.     // ==================================================
  66.  
  67.     // Fuzzy output insulin
  68.     FuzzyOutput* insuline = new FuzzyOutput(1);
  69.  
  70.     FuzzySet* insulin_A = new FuzzySet(25, 25, 25, 30.5); // add values
  71.     insuline->addFuzzySet(insulin_A);
  72.  
  73.     FuzzySet* insulin_B = new FuzzySet(30.5, 33, 33, 35.5); // add values
  74.     insuline->addFuzzySet(insulin_B);
  75.  
  76.     FuzzySet* insulin_C = new FuzzySet(35.5, 39.5, 39.5, 43.5); // add values
  77.     insuline->addFuzzySet(insulin_C);
  78.  
  79.     FuzzySet* insulin_D = new FuzzySet(43.5, 46.5, 46.5, 49.5); // add values
  80.     insuline->addFuzzySet(insulin_D);
  81.  
  82.     FuzzySet* insulin_E = new FuzzySet(49.5, 55, 55, 55); // add values
  83.     insuline->addFuzzySet(insulin_E);
  84.  
  85.     fuzzy->addFuzzyOutput(insuline);
  86.  
  87.     //================================= rule - 1 ==============================
  88.  
  89.     FuzzyRuleAntecedent* ID01_BMIandCHO = new FuzzyRuleAntecedent();
  90.     ID01_BMIandCHO->joinWithAND(BMI_L, CHO_L);
  91.     FuzzyRuleAntecedent* ID01_WEIGHT = new FuzzyRuleAntecedent();
  92.     ID01_WEIGHT->joinSingle(WEIGHT_VL);
  93.     FuzzyRuleAntecedent* ID01_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  94.     ID01_IF_BMIandCHOandWEIGHT->joinWithAND(ID01_BMIandCHO, ID01_WEIGHT);
  95.  
  96.     FuzzyRuleConsequent* ID01_THEN_INSULIN = new FuzzyRuleConsequent();
  97.     ID01_THEN_INSULIN->addOutput(insulin_A);
  98.  
  99.     FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ID01_IF_BMIandCHOandWEIGHT, ID01_THEN_INSULIN);
  100.     fuzzy->addFuzzyRule(fuzzyRule1);
  101.  
  102.     //================================= rule - 2 ==============================
  103.  
  104.     FuzzyRuleAntecedent* ID02_BMIandCHO = new FuzzyRuleAntecedent();
  105.     ID02_BMIandCHO->joinWithAND(BMI_L, CHO_O);
  106.     FuzzyRuleAntecedent* ID02_WEIGHT = new FuzzyRuleAntecedent();
  107.     ID02_WEIGHT->joinSingle(WEIGHT_VL);
  108.     FuzzyRuleAntecedent* ID02_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  109.     ID02_IF_BMIandCHOandWEIGHT->joinWithAND(ID02_BMIandCHO, ID02_WEIGHT);
  110.  
  111.     FuzzyRuleConsequent* ID02_THEN_INSULIN = new FuzzyRuleConsequent();
  112.     ID02_THEN_INSULIN->addOutput(insulin_C);
  113.  
  114.     FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ID02_IF_BMIandCHOandWEIGHT, ID02_THEN_INSULIN);
  115.     fuzzy->addFuzzyRule(fuzzyRule2);
  116.  
  117.     //================================= rule - 3 ==============================
  118.  
  119.     FuzzyRuleAntecedent* ID03_BMIandCHO = new FuzzyRuleAntecedent();
  120.     ID03_BMIandCHO->joinWithAND(BMI_L, CHO_H);
  121.     FuzzyRuleAntecedent* ID03_WEIGHT = new FuzzyRuleAntecedent();
  122.     ID03_WEIGHT->joinSingle(WEIGHT_VL);
  123.     FuzzyRuleAntecedent* ID03_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  124.     ID03_IF_BMIandCHOandWEIGHT->joinWithAND(ID03_BMIandCHO, ID03_WEIGHT);
  125.  
  126.     FuzzyRuleConsequent* ID03_THEN_INSULIN = new FuzzyRuleConsequent();
  127.     ID03_THEN_INSULIN->addOutput(insulin_C);
  128.  
  129.     FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ID03_IF_BMIandCHOandWEIGHT, ID03_THEN_INSULIN);
  130.     fuzzy->addFuzzyRule(fuzzyRule3);
  131.  
  132.     //================================= rule - 4 ==============================
  133.  
  134.     FuzzyRuleAntecedent* ID04_BMIandCHO = new FuzzyRuleAntecedent();
  135.     ID04_BMIandCHO->joinWithAND(BMI_O, CHO_L);
  136.     FuzzyRuleAntecedent* ID04_WEIGHT = new FuzzyRuleAntecedent();
  137.     ID04_WEIGHT->joinSingle(WEIGHT_VL);
  138.     FuzzyRuleAntecedent* ID04_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  139.     ID04_IF_BMIandCHOandWEIGHT->joinWithAND(ID04_BMIandCHO, ID04_WEIGHT);
  140.  
  141.     FuzzyRuleConsequent* ID04_THEN_INSULIN = new FuzzyRuleConsequent();
  142.     ID04_THEN_INSULIN->addOutput(insulin_B);
  143.  
  144.     FuzzyRule* fuzzyRule4 = new FuzzyRule(4, ID04_IF_BMIandCHOandWEIGHT, ID04_THEN_INSULIN);
  145.     fuzzy->addFuzzyRule(fuzzyRule4);
  146.  
  147.     //================================= rule - 5 ==============================
  148.  
  149.     FuzzyRuleAntecedent* ID05_BMIandCHO = new FuzzyRuleAntecedent();
  150.     ID05_BMIandCHO->joinWithAND(BMI_O, CHO_O);
  151.     FuzzyRuleAntecedent* ID05_WEIGHT = new FuzzyRuleAntecedent();
  152.     ID05_WEIGHT->joinSingle(WEIGHT_VL);
  153.     FuzzyRuleAntecedent* ID05_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  154.     ID05_IF_BMIandCHOandWEIGHT->joinWithAND(ID05_BMIandCHO, ID05_WEIGHT);
  155.  
  156.     FuzzyRuleConsequent* ID05_THEN_INSULIN = new FuzzyRuleConsequent();
  157.     ID05_THEN_INSULIN->addOutput(insulin_C);
  158.  
  159.     FuzzyRule* fuzzyRule5 = new FuzzyRule(5, ID05_IF_BMIandCHOandWEIGHT, ID05_THEN_INSULIN);
  160.     fuzzy->addFuzzyRule(fuzzyRule5);
  161.  
  162.     //================================= rule - 6 ==============================
  163.  
  164.     FuzzyRuleAntecedent* ID06_BMIandCHO = new FuzzyRuleAntecedent();
  165.     ID06_BMIandCHO->joinWithAND(BMI_O, CHO_H);
  166.     FuzzyRuleAntecedent* ID06_WEIGHT = new FuzzyRuleAntecedent();
  167.     ID06_WEIGHT->joinSingle(WEIGHT_VL);
  168.     FuzzyRuleAntecedent* ID06_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  169.     ID06_IF_BMIandCHOandWEIGHT->joinWithAND(ID06_BMIandCHO, ID06_WEIGHT);
  170.  
  171.     FuzzyRuleConsequent* ID06_THEN_INSULIN = new FuzzyRuleConsequent();
  172.     ID06_THEN_INSULIN->addOutput(insulin_C);
  173.  
  174.     FuzzyRule* fuzzyRule6 = new FuzzyRule(6, ID06_IF_BMIandCHOandWEIGHT, ID06_THEN_INSULIN);
  175.     fuzzy->addFuzzyRule(fuzzyRule6);
  176.  
  177.     //================================= rule - 7 ==============================
  178.  
  179.     FuzzyRuleAntecedent* ID07_BMIandCHO = new FuzzyRuleAntecedent();
  180.     ID07_BMIandCHO->joinWithAND(BMI_H, CHO_L);
  181.     FuzzyRuleAntecedent* ID07_WEIGHT = new FuzzyRuleAntecedent();
  182.     ID07_WEIGHT->joinSingle(WEIGHT_VL);
  183.     FuzzyRuleAntecedent* ID07_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  184.     ID07_IF_BMIandCHOandWEIGHT->joinWithAND(ID07_BMIandCHO, ID07_WEIGHT);
  185.  
  186.     FuzzyRuleConsequent* ID07_THEN_INSULIN = new FuzzyRuleConsequent();
  187.     ID07_THEN_INSULIN->addOutput(insulin_C);
  188.  
  189.     FuzzyRule* fuzzyRule7 = new FuzzyRule(7, ID07_IF_BMIandCHOandWEIGHT, ID07_THEN_INSULIN);
  190.     fuzzy->addFuzzyRule(fuzzyRule7);
  191.  
  192.     //================================= rule - 8 ==============================
  193.  
  194.     FuzzyRuleAntecedent* ID08_BMIandCHO = new FuzzyRuleAntecedent();
  195.     ID08_BMIandCHO->joinWithAND(BMI_H, CHO_O);
  196.     FuzzyRuleAntecedent* ID08_WEIGHT = new FuzzyRuleAntecedent();
  197.     ID08_WEIGHT->joinSingle(WEIGHT_VL);
  198.     FuzzyRuleAntecedent* ID08_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  199.     ID08_IF_BMIandCHOandWEIGHT->joinWithAND(ID08_BMIandCHO, ID08_WEIGHT);
  200.  
  201.     FuzzyRuleConsequent* ID08_THEN_INSULIN = new FuzzyRuleConsequent();
  202.     ID08_THEN_INSULIN->addOutput(insulin_C);
  203.  
  204.     FuzzyRule* fuzzyRule8 = new FuzzyRule(8, ID08_IF_BMIandCHOandWEIGHT, ID08_THEN_INSULIN);
  205.     fuzzy->addFuzzyRule(fuzzyRule8);
  206.  
  207.     //================================= rule - 9 ==============================
  208.  
  209.     FuzzyRuleAntecedent* ID09_BMIandCHO = new FuzzyRuleAntecedent();
  210.     ID09_BMIandCHO->joinWithAND(BMI_H, CHO_H);
  211.     FuzzyRuleAntecedent* ID09_WEIGHT = new FuzzyRuleAntecedent();
  212.     ID09_WEIGHT->joinSingle(WEIGHT_VL);
  213.     FuzzyRuleAntecedent* ID09_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  214.     ID09_IF_BMIandCHOandWEIGHT->joinWithAND(ID09_BMIandCHO, ID09_WEIGHT);
  215.  
  216.     FuzzyRuleConsequent* ID09_THEN_INSULIN = new FuzzyRuleConsequent();
  217.     ID09_THEN_INSULIN->addOutput(insulin_D);
  218.  
  219.     FuzzyRule* fuzzyRule9 = new FuzzyRule(9, ID09_IF_BMIandCHOandWEIGHT, ID09_THEN_INSULIN);
  220.     fuzzy->addFuzzyRule(fuzzyRule9);
  221.  
  222.     //================================= rule - 10 ==============================
  223.  
  224.     FuzzyRuleAntecedent* ID10_BMIandCHO = new FuzzyRuleAntecedent();
  225.     ID10_BMIandCHO->joinWithAND(BMI_L, CHO_L);
  226.     FuzzyRuleAntecedent* ID10_WEIGHT = new FuzzyRuleAntecedent();
  227.     ID10_WEIGHT->joinSingle(WEIGHT_L);
  228.     FuzzyRuleAntecedent* ID10_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  229.     ID10_IF_BMIandCHOandWEIGHT->joinWithAND(ID10_BMIandCHO, ID10_WEIGHT);
  230.  
  231.     FuzzyRuleConsequent* ID10_THEN_INSULIN = new FuzzyRuleConsequent();
  232.     ID10_THEN_INSULIN->addOutput(insulin_B);
  233.  
  234.     FuzzyRule* fuzzyRule10 = new FuzzyRule(10, ID10_IF_BMIandCHOandWEIGHT, ID10_THEN_INSULIN);
  235.     fuzzy->addFuzzyRule(fuzzyRule10);
  236.  
  237.     //================================= rule - 11 ==============================
  238.  
  239.     FuzzyRuleAntecedent* ID11_BMIandCHO = new FuzzyRuleAntecedent();
  240.     ID11_BMIandCHO->joinWithAND(BMI_L, CHO_O);
  241.     FuzzyRuleAntecedent* ID11_WEIGHT = new FuzzyRuleAntecedent();
  242.     ID11_WEIGHT->joinSingle(WEIGHT_L);
  243.     FuzzyRuleAntecedent* ID11_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  244.     ID11_IF_BMIandCHOandWEIGHT->joinWithAND(ID11_BMIandCHO, ID11_WEIGHT);
  245.  
  246.     FuzzyRuleConsequent* ID11_THEN_INSULIN = new FuzzyRuleConsequent();
  247.     ID11_THEN_INSULIN->addOutput(insulin_C);
  248.  
  249.     FuzzyRule* fuzzyRule11 = new FuzzyRule(11, ID11_IF_BMIandCHOandWEIGHT, ID11_THEN_INSULIN);
  250.     fuzzy->addFuzzyRule(fuzzyRule11);
  251.  
  252.     //================================= rule - 12 ==============================
  253.  
  254.     FuzzyRuleAntecedent* ID12_BMIandCHO = new FuzzyRuleAntecedent();
  255.     ID12_BMIandCHO->joinWithAND(BMI_L, CHO_H);
  256.     FuzzyRuleAntecedent* ID12_WEIGHT = new FuzzyRuleAntecedent();
  257.     ID12_WEIGHT->joinSingle(WEIGHT_L);
  258.     FuzzyRuleAntecedent* ID12_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  259.     ID12_IF_BMIandCHOandWEIGHT->joinWithAND(ID12_BMIandCHO, ID12_WEIGHT);
  260.  
  261.     FuzzyRuleConsequent* ID12_THEN_INSULIN = new FuzzyRuleConsequent();
  262.     ID12_THEN_INSULIN->addOutput(insulin_C);
  263.  
  264.     FuzzyRule* fuzzyRule12 = new FuzzyRule(12, ID12_IF_BMIandCHOandWEIGHT, ID12_THEN_INSULIN);
  265.     fuzzy->addFuzzyRule(fuzzyRule12);
  266.  
  267.     //================================= rule - 13 ==============================
  268.  
  269.     FuzzyRuleAntecedent* ID13_BMIandCHO = new FuzzyRuleAntecedent();
  270.     ID13_BMIandCHO->joinWithAND(BMI_O, CHO_L);
  271.     FuzzyRuleAntecedent* ID13_WEIGHT = new FuzzyRuleAntecedent();
  272.     ID13_WEIGHT->joinSingle(WEIGHT_L);
  273.     FuzzyRuleAntecedent* ID13_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  274.     ID13_IF_BMIandCHOandWEIGHT->joinWithAND(ID13_BMIandCHO, ID13_WEIGHT);
  275.  
  276.     FuzzyRuleConsequent* ID13_THEN_INSULIN = new FuzzyRuleConsequent();
  277.     ID13_THEN_INSULIN->addOutput(insulin_C);
  278.  
  279.     FuzzyRule* fuzzyRule13 = new FuzzyRule(13, ID13_IF_BMIandCHOandWEIGHT, ID13_THEN_INSULIN);
  280.     fuzzy->addFuzzyRule(fuzzyRule13);
  281.  
  282.     //================================= rule - 14 ==============================
  283.  
  284.     FuzzyRuleAntecedent* ID14_BMIandCHO = new FuzzyRuleAntecedent();
  285.     ID14_BMIandCHO->joinWithAND(BMI_O, CHO_O);
  286.     FuzzyRuleAntecedent* ID14_WEIGHT = new FuzzyRuleAntecedent();
  287.     ID14_WEIGHT->joinSingle(WEIGHT_L);
  288.     FuzzyRuleAntecedent* ID14_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  289.     ID14_IF_BMIandCHOandWEIGHT->joinWithAND(ID14_BMIandCHO, ID14_WEIGHT);
  290.  
  291.     FuzzyRuleConsequent* ID14_THEN_INSULIN = new FuzzyRuleConsequent();
  292.     ID14_THEN_INSULIN->addOutput(insulin_C);
  293.  
  294.     FuzzyRule* fuzzyRule14 = new FuzzyRule(14, ID14_IF_BMIandCHOandWEIGHT, ID14_THEN_INSULIN);
  295.     fuzzy->addFuzzyRule(fuzzyRule14);
  296.  
  297.     //================================= rule - 15 ==============================
  298.  
  299.     FuzzyRuleAntecedent* ID15_BMIandCHO = new FuzzyRuleAntecedent();
  300.     ID15_BMIandCHO->joinWithAND(BMI_O, CHO_H);
  301.     FuzzyRuleAntecedent* ID15_WEIGHT = new FuzzyRuleAntecedent();
  302.     ID15_WEIGHT->joinSingle(WEIGHT_L);
  303.     FuzzyRuleAntecedent* ID15_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  304.     ID15_IF_BMIandCHOandWEIGHT->joinWithAND(ID15_BMIandCHO, ID15_WEIGHT);
  305.  
  306.     FuzzyRuleConsequent* ID15_THEN_INSULIN = new FuzzyRuleConsequent();
  307.     ID15_THEN_INSULIN->addOutput(insulin_D);
  308.  
  309.     FuzzyRule* fuzzyRule15 = new FuzzyRule(15, ID15_IF_BMIandCHOandWEIGHT, ID15_THEN_INSULIN);
  310.     fuzzy->addFuzzyRule(fuzzyRule15);
  311.  
  312.     //================================= rule - 16 ==============================
  313.  
  314.     FuzzyRuleAntecedent* ID16_BMIandCHO = new FuzzyRuleAntecedent();
  315.     ID16_BMIandCHO->joinWithAND(BMI_H, CHO_L);
  316.     FuzzyRuleAntecedent* ID16_WEIGHT = new FuzzyRuleAntecedent();
  317.     ID16_WEIGHT->joinSingle(WEIGHT_L);
  318.     FuzzyRuleAntecedent* ID16_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  319.     ID16_IF_BMIandCHOandWEIGHT->joinWithAND(ID16_BMIandCHO, ID16_WEIGHT);
  320.  
  321.     FuzzyRuleConsequent* ID16_THEN_INSULIN = new FuzzyRuleConsequent();
  322.     ID16_THEN_INSULIN->addOutput(insulin_C);
  323.  
  324.     FuzzyRule* fuzzyRule16 = new FuzzyRule(16, ID16_IF_BMIandCHOandWEIGHT, ID16_THEN_INSULIN);
  325.     fuzzy->addFuzzyRule(fuzzyRule16);
  326.  
  327.     //================================= rule - 17 ==============================
  328.  
  329.     FuzzyRuleAntecedent* ID17_BMIandCHO = new FuzzyRuleAntecedent();
  330.     ID17_BMIandCHO->joinWithAND(BMI_H, CHO_O);
  331.     FuzzyRuleAntecedent* ID17_WEIGHT = new FuzzyRuleAntecedent();
  332.     ID17_WEIGHT->joinSingle(WEIGHT_L);
  333.     FuzzyRuleAntecedent* ID17_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  334.     ID17_IF_BMIandCHOandWEIGHT->joinWithAND(ID17_BMIandCHO, ID17_WEIGHT);
  335.  
  336.     FuzzyRuleConsequent* ID17_THEN_INSULIN = new FuzzyRuleConsequent();
  337.     ID17_THEN_INSULIN->addOutput(insulin_D);
  338.  
  339.     FuzzyRule* fuzzyRule17 = new FuzzyRule(17, ID17_IF_BMIandCHOandWEIGHT, ID17_THEN_INSULIN);
  340.     fuzzy->addFuzzyRule(fuzzyRule17);
  341.  
  342.     //================================= rule - 18 ==============================
  343.  
  344.     FuzzyRuleAntecedent* ID18_BMIandCHO = new FuzzyRuleAntecedent();
  345.     ID18_BMIandCHO->joinWithAND(BMI_H, CHO_H);
  346.     FuzzyRuleAntecedent* ID18_WEIGHT = new FuzzyRuleAntecedent();
  347.     ID18_WEIGHT->joinSingle(WEIGHT_L);
  348.     FuzzyRuleAntecedent* ID18_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  349.     ID18_IF_BMIandCHOandWEIGHT->joinWithAND(ID18_BMIandCHO, ID18_WEIGHT);
  350.  
  351.     FuzzyRuleConsequent* ID18_THEN_INSULIN = new FuzzyRuleConsequent();
  352.     ID18_THEN_INSULIN->addOutput(insulin_D);
  353.  
  354.     FuzzyRule* fuzzyRule18 = new FuzzyRule(18, ID18_IF_BMIandCHOandWEIGHT, ID18_THEN_INSULIN);
  355.     fuzzy->addFuzzyRule(fuzzyRule18);
  356.  
  357.     //================================= rule - 19 ==============================
  358.  
  359.     FuzzyRuleAntecedent* ID19_BMIandCHO = new FuzzyRuleAntecedent();
  360.     ID19_BMIandCHO->joinWithAND(BMI_L, CHO_L);
  361.     FuzzyRuleAntecedent* ID19_WEIGHT = new FuzzyRuleAntecedent();
  362.     ID19_WEIGHT->joinSingle(WEIGHT_O1);
  363.     FuzzyRuleAntecedent* ID19_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  364.     ID19_IF_BMIandCHOandWEIGHT->joinWithAND(ID19_BMIandCHO, ID19_WEIGHT);
  365.  
  366.     FuzzyRuleConsequent* ID19_THEN_INSULIN = new FuzzyRuleConsequent();
  367.     ID19_THEN_INSULIN->addOutput(insulin_A);
  368.  
  369.     FuzzyRule* fuzzyRule19 = new FuzzyRule(19, ID19_IF_BMIandCHOandWEIGHT, ID19_THEN_INSULIN);
  370.     fuzzy->addFuzzyRule(fuzzyRule19);
  371.  
  372.     //================================= rule - 20 ==============================
  373.  
  374.     FuzzyRuleAntecedent* ID20_BMIandCHO = new FuzzyRuleAntecedent();
  375.     ID20_BMIandCHO->joinWithAND(BMI_L, CHO_O);
  376.     FuzzyRuleAntecedent* ID20_WEIGHT = new FuzzyRuleAntecedent();
  377.     ID20_WEIGHT->joinSingle(WEIGHT_O1);
  378.     FuzzyRuleAntecedent* ID20_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  379.     ID20_IF_BMIandCHOandWEIGHT->joinWithAND(ID20_BMIandCHO, ID20_WEIGHT);
  380.  
  381.     FuzzyRuleConsequent* ID20_THEN_INSULIN = new FuzzyRuleConsequent();
  382.     ID20_THEN_INSULIN->addOutput(insulin_B);
  383.  
  384.     FuzzyRule* fuzzyRule20 = new FuzzyRule(20, ID20_IF_BMIandCHOandWEIGHT, ID20_THEN_INSULIN);
  385.     fuzzy->addFuzzyRule(fuzzyRule20);
  386.  
  387.     //================================= rule - 21 ==============================
  388.  
  389.     FuzzyRuleAntecedent* ID21_BMIandCHO = new FuzzyRuleAntecedent();
  390.     ID21_BMIandCHO->joinWithAND(BMI_L, CHO_H);
  391.     FuzzyRuleAntecedent* ID21_WEIGHT = new FuzzyRuleAntecedent();
  392.     ID21_WEIGHT->joinSingle(WEIGHT_O1);
  393.     FuzzyRuleAntecedent* ID21_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  394.     ID21_IF_BMIandCHOandWEIGHT->joinWithAND(ID21_BMIandCHO, ID21_WEIGHT);
  395.  
  396.     FuzzyRuleConsequent* ID21_THEN_INSULIN = new FuzzyRuleConsequent();
  397.     ID21_THEN_INSULIN->addOutput(insulin_C);
  398.  
  399.     FuzzyRule* fuzzyRule21 = new FuzzyRule(21, ID21_IF_BMIandCHOandWEIGHT, ID21_THEN_INSULIN);
  400.     fuzzy->addFuzzyRule(fuzzyRule21);
  401.  
  402.     //================================= rule - 22 ==============================
  403.  
  404.     FuzzyRuleAntecedent* ID22_BMIandCHO = new FuzzyRuleAntecedent();
  405.     ID22_BMIandCHO->joinWithAND(BMI_O, CHO_L);
  406.     FuzzyRuleAntecedent* ID22_WEIGHT = new FuzzyRuleAntecedent();
  407.     ID22_WEIGHT->joinSingle(WEIGHT_O1);
  408.     FuzzyRuleAntecedent* ID22_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  409.     ID22_IF_BMIandCHOandWEIGHT->joinWithAND(ID22_BMIandCHO, ID22_WEIGHT);
  410.  
  411.     FuzzyRuleConsequent* ID22_THEN_INSULIN = new FuzzyRuleConsequent();
  412.     ID22_THEN_INSULIN->addOutput(insulin_B);
  413.  
  414.     FuzzyRule* fuzzyRule22 = new FuzzyRule(22, ID22_IF_BMIandCHOandWEIGHT, ID22_THEN_INSULIN);
  415.     fuzzy->addFuzzyRule(fuzzyRule22);
  416.  
  417.     //================================= rule - 23 ==============================
  418.  
  419.     FuzzyRuleAntecedent* ID23_BMIandCHO = new FuzzyRuleAntecedent();
  420.     ID23_BMIandCHO->joinWithAND(BMI_O, CHO_O);
  421.     FuzzyRuleAntecedent* ID23_WEIGHT = new FuzzyRuleAntecedent();
  422.     ID23_WEIGHT->joinSingle(WEIGHT_O1);
  423.     FuzzyRuleAntecedent* ID23_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  424.     ID23_IF_BMIandCHOandWEIGHT->joinWithAND(ID23_BMIandCHO, ID23_WEIGHT);
  425.  
  426.     FuzzyRuleConsequent* ID23_THEN_INSULIN = new FuzzyRuleConsequent();
  427.     ID23_THEN_INSULIN->addOutput(insulin_B);
  428.  
  429.     FuzzyRule* fuzzyRule23 = new FuzzyRule(23, ID23_IF_BMIandCHOandWEIGHT, ID23_THEN_INSULIN);
  430.     fuzzy->addFuzzyRule(fuzzyRule23);
  431.  
  432.     //================================= rule - 24 ==============================
  433.  
  434.     FuzzyRuleAntecedent* ID24_BMIandCHO = new FuzzyRuleAntecedent();
  435.     ID24_BMIandCHO->joinWithAND(BMI_O, CHO_H);
  436.     FuzzyRuleAntecedent* ID24_WEIGHT = new FuzzyRuleAntecedent();
  437.     ID24_WEIGHT->joinSingle(WEIGHT_O1);
  438.     FuzzyRuleAntecedent* ID24_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  439.     ID24_IF_BMIandCHOandWEIGHT->joinWithAND(ID24_BMIandCHO, ID24_WEIGHT);
  440.  
  441.     FuzzyRuleConsequent* ID24_THEN_INSULIN = new FuzzyRuleConsequent();
  442.     ID24_THEN_INSULIN->addOutput(insulin_D);
  443.  
  444.     FuzzyRule* fuzzyRule24 = new FuzzyRule(24, ID24_IF_BMIandCHOandWEIGHT, ID24_THEN_INSULIN);
  445.     fuzzy->addFuzzyRule(fuzzyRule24);
  446.  
  447.     //================================= rule - 25 ==============================
  448.  
  449.     FuzzyRuleAntecedent* ID25_BMIandCHO = new FuzzyRuleAntecedent();
  450.     ID25_BMIandCHO->joinWithAND(BMI_H, CHO_L);
  451.     FuzzyRuleAntecedent* ID25_WEIGHT = new FuzzyRuleAntecedent();
  452.     ID25_WEIGHT->joinSingle(WEIGHT_O1);
  453.     FuzzyRuleAntecedent* ID25_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  454.     ID25_IF_BMIandCHOandWEIGHT->joinWithAND(ID25_BMIandCHO, ID25_WEIGHT);
  455.  
  456.     FuzzyRuleConsequent* ID25_THEN_INSULIN = new FuzzyRuleConsequent();
  457.     ID25_THEN_INSULIN->addOutput(insulin_C);
  458.  
  459.     FuzzyRule* fuzzyRule25 = new FuzzyRule(25, ID25_IF_BMIandCHOandWEIGHT, ID25_THEN_INSULIN);
  460.     fuzzy->addFuzzyRule(fuzzyRule25);
  461.  
  462.     //================================= rule - 26 ==============================
  463.  
  464.     FuzzyRuleAntecedent* ID26_BMIandCHO = new FuzzyRuleAntecedent();
  465.     ID26_BMIandCHO->joinWithAND(BMI_H, CHO_O);
  466.     FuzzyRuleAntecedent* ID26_WEIGHT = new FuzzyRuleAntecedent();
  467.     ID26_WEIGHT->joinSingle(WEIGHT_O1);
  468.     FuzzyRuleAntecedent* ID26_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  469.     ID26_IF_BMIandCHOandWEIGHT->joinWithAND(ID26_BMIandCHO, ID26_WEIGHT);
  470.  
  471.     FuzzyRuleConsequent* ID26_THEN_INSULIN = new FuzzyRuleConsequent();
  472.     ID26_THEN_INSULIN->addOutput(insulin_D);
  473.  
  474.     FuzzyRule* fuzzyRule26 = new FuzzyRule(26, ID26_IF_BMIandCHOandWEIGHT, ID26_THEN_INSULIN);
  475.     fuzzy->addFuzzyRule(fuzzyRule26);
  476.  
  477.     //================================= rule - 27 ==============================
  478.  
  479.     FuzzyRuleAntecedent* ID27_BMIandCHO = new FuzzyRuleAntecedent();
  480.     ID27_BMIandCHO->joinWithAND(BMI_H, CHO_H);
  481.     FuzzyRuleAntecedent* ID27_WEIGHT = new FuzzyRuleAntecedent();
  482.     ID27_WEIGHT->joinSingle(WEIGHT_O1);
  483.     FuzzyRuleAntecedent* ID27_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  484.     ID27_IF_BMIandCHOandWEIGHT->joinWithAND(ID27_BMIandCHO, ID27_WEIGHT);
  485.  
  486.     FuzzyRuleConsequent* ID27_THEN_INSULIN = new FuzzyRuleConsequent();
  487.     ID27_THEN_INSULIN->addOutput(insulin_E);
  488.  
  489.     FuzzyRule* fuzzyRule27 = new FuzzyRule(27, ID27_IF_BMIandCHOandWEIGHT, ID27_THEN_INSULIN);
  490.     fuzzy->addFuzzyRule(fuzzyRule27);
  491.  
  492.     //================================= rule - 28 ==============================
  493.  
  494.     FuzzyRuleAntecedent* ID28_BMIandCHO = new FuzzyRuleAntecedent();
  495.     ID28_BMIandCHO->joinWithAND(BMI_L, CHO_L);
  496.     FuzzyRuleAntecedent* ID28_WEIGHT = new FuzzyRuleAntecedent();
  497.     ID28_WEIGHT->joinSingle(WEIGHT_O2);
  498.     FuzzyRuleAntecedent* ID28_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  499.     ID28_IF_BMIandCHOandWEIGHT->joinWithAND(ID28_BMIandCHO, ID28_WEIGHT);
  500.  
  501.     FuzzyRuleConsequent* ID28_THEN_INSULIN = new FuzzyRuleConsequent();
  502.     ID28_THEN_INSULIN->addOutput(insulin_A);
  503.  
  504.     FuzzyRule* fuzzyRule28 = new FuzzyRule(28, ID28_IF_BMIandCHOandWEIGHT, ID28_THEN_INSULIN);
  505.     fuzzy->addFuzzyRule(fuzzyRule28);
  506.  
  507.     //================================= rule - 29 ==============================
  508.  
  509.     FuzzyRuleAntecedent* ID29_BMIandCHO = new FuzzyRuleAntecedent();
  510.     ID29_BMIandCHO->joinWithAND(BMI_L, CHO_L);
  511.     FuzzyRuleAntecedent* ID29_WEIGHT = new FuzzyRuleAntecedent();
  512.     ID29_WEIGHT->joinSingle(WEIGHT_O2);
  513.     FuzzyRuleAntecedent* ID29_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  514.     ID29_IF_BMIandCHOandWEIGHT->joinWithAND(ID29_BMIandCHO, ID29_WEIGHT);
  515.  
  516.     FuzzyRuleConsequent* ID29_THEN_INSULIN = new FuzzyRuleConsequent();
  517.     ID29_THEN_INSULIN->addOutput(insulin_B);
  518.  
  519.     FuzzyRule* fuzzyRule29 = new FuzzyRule(29, ID29_IF_BMIandCHOandWEIGHT, ID29_THEN_INSULIN);
  520.     fuzzy->addFuzzyRule(fuzzyRule29);
  521.  
  522.     //================================= rule - 30 ==============================
  523.  
  524.     FuzzyRuleAntecedent* ID30_BMIandCHO = new FuzzyRuleAntecedent();
  525.     ID30_BMIandCHO->joinWithAND(BMI_L, CHO_H);
  526.     FuzzyRuleAntecedent* ID30_WEIGHT = new FuzzyRuleAntecedent();
  527.     ID30_WEIGHT->joinSingle(WEIGHT_O2);
  528.     FuzzyRuleAntecedent* ID30_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  529.     ID30_IF_BMIandCHOandWEIGHT->joinWithAND(ID30_BMIandCHO, ID30_WEIGHT);
  530.  
  531.     FuzzyRuleConsequent* ID30_THEN_INSULIN = new FuzzyRuleConsequent();
  532.     ID30_THEN_INSULIN->addOutput(insulin_C);
  533.  
  534.     FuzzyRule* fuzzyRule30 = new FuzzyRule(30, ID30_IF_BMIandCHOandWEIGHT, ID30_THEN_INSULIN);
  535.     fuzzy->addFuzzyRule(fuzzyRule30);
  536.  
  537.     //================================= rule - 31 ==============================
  538.  
  539.     FuzzyRuleAntecedent* ID31_BMIandCHO = new FuzzyRuleAntecedent();
  540.     ID31_BMIandCHO->joinWithAND(BMI_O, CHO_L);
  541.     FuzzyRuleAntecedent* ID31_WEIGHT = new FuzzyRuleAntecedent();
  542.     ID31_WEIGHT->joinSingle(WEIGHT_O2);
  543.     FuzzyRuleAntecedent* ID31_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  544.     ID31_IF_BMIandCHOandWEIGHT->joinWithAND(ID31_BMIandCHO, ID31_WEIGHT);
  545.  
  546.     FuzzyRuleConsequent* ID31_THEN_INSULIN = new FuzzyRuleConsequent();
  547.     ID31_THEN_INSULIN->addOutput(insulin_B);
  548.  
  549.     FuzzyRule* fuzzyRule31 = new FuzzyRule(31, ID31_IF_BMIandCHOandWEIGHT, ID31_THEN_INSULIN);
  550.     fuzzy->addFuzzyRule(fuzzyRule31);
  551.  
  552.     //================================= rule - 32 ==============================
  553.  
  554.     FuzzyRuleAntecedent* ID32_BMIandCHO = new FuzzyRuleAntecedent();
  555.     ID32_BMIandCHO->joinWithAND(BMI_O, CHO_O);
  556.     FuzzyRuleAntecedent* ID32_WEIGHT = new FuzzyRuleAntecedent();
  557.     ID32_WEIGHT->joinSingle(WEIGHT_O2);
  558.     FuzzyRuleAntecedent* ID32_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  559.     ID32_IF_BMIandCHOandWEIGHT->joinWithAND(ID32_BMIandCHO, ID32_WEIGHT);
  560.  
  561.     FuzzyRuleConsequent* ID32_THEN_INSULIN = new FuzzyRuleConsequent();
  562.     ID32_THEN_INSULIN->addOutput(insulin_C);
  563.  
  564.     FuzzyRule* fuzzyRule32 = new FuzzyRule(32, ID32_IF_BMIandCHOandWEIGHT, ID32_THEN_INSULIN);
  565.     fuzzy->addFuzzyRule(fuzzyRule32);
  566.  
  567.     //================================= rule - 33 ==============================
  568.  
  569.     FuzzyRuleAntecedent* ID33_BMIandCHO = new FuzzyRuleAntecedent();
  570.     ID33_BMIandCHO->joinWithAND(BMI_O, CHO_H);
  571.     FuzzyRuleAntecedent* ID33_WEIGHT = new FuzzyRuleAntecedent();
  572.     ID33_WEIGHT->joinSingle(WEIGHT_O2);
  573.     FuzzyRuleAntecedent* ID33_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  574.     ID33_IF_BMIandCHOandWEIGHT->joinWithAND(ID33_BMIandCHO, ID33_WEIGHT);
  575.  
  576.     FuzzyRuleConsequent* ID33_THEN_INSULIN = new FuzzyRuleConsequent();
  577.     ID33_THEN_INSULIN->addOutput(insulin_D);
  578.  
  579.     FuzzyRule* fuzzyRule33 = new FuzzyRule(33, ID33_IF_BMIandCHOandWEIGHT, ID33_THEN_INSULIN);
  580.     fuzzy->addFuzzyRule(fuzzyRule33);
  581.  
  582.     //================================= rule - 34 ==============================
  583.  
  584.     FuzzyRuleAntecedent* ID34_BMIandCHO = new FuzzyRuleAntecedent();
  585.     ID34_BMIandCHO->joinWithAND(BMI_H, CHO_L);
  586.     FuzzyRuleAntecedent* ID34_WEIGHT = new FuzzyRuleAntecedent();
  587.     ID34_WEIGHT->joinSingle(WEIGHT_O2);
  588.     FuzzyRuleAntecedent* ID34_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  589.     ID34_IF_BMIandCHOandWEIGHT->joinWithAND(ID34_BMIandCHO, ID34_WEIGHT);
  590.  
  591.     FuzzyRuleConsequent* ID34_THEN_INSULIN = new FuzzyRuleConsequent();
  592.     ID34_THEN_INSULIN->addOutput(insulin_C);
  593.  
  594.     FuzzyRule* fuzzyRule34 = new FuzzyRule(34, ID34_IF_BMIandCHOandWEIGHT, ID34_THEN_INSULIN);
  595.     fuzzy->addFuzzyRule(fuzzyRule34);
  596.  
  597.     //================================= rule - 35 ==============================
  598.  
  599.     FuzzyRuleAntecedent* ID35_BMIandCHO = new FuzzyRuleAntecedent();
  600.     ID35_BMIandCHO->joinWithAND(BMI_H, CHO_O);
  601.     FuzzyRuleAntecedent* ID35_WEIGHT = new FuzzyRuleAntecedent();
  602.     ID35_WEIGHT->joinSingle(WEIGHT_O2);
  603.     FuzzyRuleAntecedent* ID35_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  604.     ID35_IF_BMIandCHOandWEIGHT->joinWithAND(ID35_BMIandCHO, ID35_WEIGHT);
  605.  
  606.     FuzzyRuleConsequent* ID35_THEN_INSULIN = new FuzzyRuleConsequent();
  607.     ID35_THEN_INSULIN->addOutput(insulin_D);
  608.  
  609.     FuzzyRule* fuzzyRule35 = new FuzzyRule(35, ID35_IF_BMIandCHOandWEIGHT, ID35_THEN_INSULIN);
  610.     fuzzy->addFuzzyRule(fuzzyRule35);
  611.  
  612.     //================================= rule - 36 ==============================
  613.  
  614.     FuzzyRuleAntecedent* ID36_BMIandCHO = new FuzzyRuleAntecedent();
  615.     ID36_BMIandCHO->joinWithAND(BMI_H, CHO_H);
  616.     FuzzyRuleAntecedent* ID36_WEIGHT = new FuzzyRuleAntecedent();
  617.     ID36_WEIGHT->joinSingle(WEIGHT_O2);
  618.     FuzzyRuleAntecedent* ID36_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  619.     ID36_IF_BMIandCHOandWEIGHT->joinWithAND(ID36_BMIandCHO, ID36_WEIGHT);
  620.  
  621.     FuzzyRuleConsequent* ID36_THEN_INSULIN = new FuzzyRuleConsequent();
  622.     ID36_THEN_INSULIN->addOutput(insulin_E);
  623.  
  624.     FuzzyRule* fuzzyRule36 = new FuzzyRule(36, ID36_IF_BMIandCHOandWEIGHT, ID36_THEN_INSULIN);
  625.     fuzzy->addFuzzyRule(fuzzyRule36);
  626.  
  627.     //================================= rule - 37 ==============================
  628.  
  629.     FuzzyRuleAntecedent* ID37_BMIandCHO = new FuzzyRuleAntecedent();
  630.     ID37_BMIandCHO->joinWithAND(BMI_L, CHO_L);
  631.     FuzzyRuleAntecedent* ID37_WEIGHT = new FuzzyRuleAntecedent();
  632.     ID37_WEIGHT->joinSingle(WEIGHT_H);
  633.     FuzzyRuleAntecedent* ID37_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  634.     ID37_IF_BMIandCHOandWEIGHT->joinWithAND(ID37_BMIandCHO, ID37_WEIGHT);
  635.  
  636.     FuzzyRuleConsequent* ID37_THEN_INSULIN = new FuzzyRuleConsequent();
  637.     ID37_THEN_INSULIN->addOutput(insulin_B);
  638.  
  639.     FuzzyRule* fuzzyRule37 = new FuzzyRule(37, ID37_IF_BMIandCHOandWEIGHT, ID37_THEN_INSULIN);
  640.     fuzzy->addFuzzyRule(fuzzyRule37);
  641.  
  642.     //================================= rule - 38 ==============================
  643.  
  644.     FuzzyRuleAntecedent* ID38_BMIandCHO = new FuzzyRuleAntecedent();
  645.     ID38_BMIandCHO->joinWithAND(BMI_L, CHO_O);
  646.     FuzzyRuleAntecedent* ID38_WEIGHT = new FuzzyRuleAntecedent();
  647.     ID38_WEIGHT->joinSingle(WEIGHT_H);
  648.     FuzzyRuleAntecedent* ID38_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  649.     ID38_IF_BMIandCHOandWEIGHT->joinWithAND(ID38_BMIandCHO, ID38_WEIGHT);
  650.  
  651.     FuzzyRuleConsequent* ID38_THEN_INSULIN = new FuzzyRuleConsequent();
  652.     ID38_THEN_INSULIN->addOutput(insulin_C);
  653.  
  654.     FuzzyRule* fuzzyRule38 = new FuzzyRule(38, ID38_IF_BMIandCHOandWEIGHT, ID38_THEN_INSULIN);
  655.     fuzzy->addFuzzyRule(fuzzyRule38);
  656.  
  657.     //================================= rule - 39 ==============================
  658.  
  659.     FuzzyRuleAntecedent* ID39_BMIandCHO = new FuzzyRuleAntecedent();
  660.     ID39_BMIandCHO->joinWithAND(BMI_L, CHO_H);
  661.     FuzzyRuleAntecedent* ID39_WEIGHT = new FuzzyRuleAntecedent();
  662.     ID39_WEIGHT->joinSingle(WEIGHT_H);
  663.     FuzzyRuleAntecedent* ID39_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  664.     ID39_IF_BMIandCHOandWEIGHT->joinWithAND(ID39_BMIandCHO, ID39_WEIGHT);
  665.  
  666.     FuzzyRuleConsequent* ID39_THEN_INSULIN = new FuzzyRuleConsequent();
  667.     ID39_THEN_INSULIN->addOutput(insulin_C);
  668.  
  669.     FuzzyRule* fuzzyRule39 = new FuzzyRule(39, ID39_IF_BMIandCHOandWEIGHT, ID39_THEN_INSULIN);
  670.     fuzzy->addFuzzyRule(fuzzyRule39);
  671.  
  672.     //================================= rule - 40 ==============================
  673.  
  674.     FuzzyRuleAntecedent* ID40_BMIandCHO = new FuzzyRuleAntecedent();
  675.     ID40_BMIandCHO->joinWithAND(BMI_O, CHO_L);
  676.     FuzzyRuleAntecedent* ID40_WEIGHT = new FuzzyRuleAntecedent();
  677.     ID40_WEIGHT->joinSingle(WEIGHT_H);
  678.     FuzzyRuleAntecedent* ID40_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  679.     ID40_IF_BMIandCHOandWEIGHT->joinWithAND(ID40_BMIandCHO, ID40_WEIGHT);
  680.  
  681.     FuzzyRuleConsequent* ID40_THEN_INSULIN = new FuzzyRuleConsequent();
  682.     ID40_THEN_INSULIN->addOutput(insulin_B);
  683.  
  684.     FuzzyRule* fuzzyRule40 = new FuzzyRule(40, ID40_IF_BMIandCHOandWEIGHT, ID40_THEN_INSULIN);
  685.     fuzzy->addFuzzyRule(fuzzyRule40);
  686.  
  687.     //================================= rule - 41 ==============================
  688.  
  689.     FuzzyRuleAntecedent* ID41_BMIandCHO = new FuzzyRuleAntecedent();
  690.     ID41_BMIandCHO->joinWithAND(BMI_O, CHO_O);
  691.     FuzzyRuleAntecedent* ID41_WEIGHT = new FuzzyRuleAntecedent();
  692.     ID41_WEIGHT->joinSingle(WEIGHT_H);
  693.     FuzzyRuleAntecedent* ID41_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  694.     ID41_IF_BMIandCHOandWEIGHT->joinWithAND(ID41_BMIandCHO, ID41_WEIGHT);
  695.  
  696.     FuzzyRuleConsequent* ID41_THEN_INSULIN = new FuzzyRuleConsequent();
  697.     ID41_THEN_INSULIN->addOutput(insulin_D);
  698.  
  699.     FuzzyRule* fuzzyRule41 = new FuzzyRule(41, ID41_IF_BMIandCHOandWEIGHT, ID41_THEN_INSULIN);
  700.     fuzzy->addFuzzyRule(fuzzyRule41);
  701.  
  702.     //================================= rule - 42 ==============================
  703.  
  704.     FuzzyRuleAntecedent* ID42_BMIandCHO = new FuzzyRuleAntecedent();
  705.     ID42_BMIandCHO->joinWithAND(BMI_O, CHO_H);
  706.     FuzzyRuleAntecedent* ID42_WEIGHT = new FuzzyRuleAntecedent();
  707.     ID42_WEIGHT->joinSingle(WEIGHT_H);
  708.     FuzzyRuleAntecedent* ID42_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  709.     ID42_IF_BMIandCHOandWEIGHT->joinWithAND(ID42_BMIandCHO, ID42_WEIGHT);
  710.  
  711.     FuzzyRuleConsequent* ID42_THEN_INSULIN = new FuzzyRuleConsequent();
  712.     ID42_THEN_INSULIN->addOutput(insulin_D);
  713.  
  714.     FuzzyRule* fuzzyRule42 = new FuzzyRule(42, ID42_IF_BMIandCHOandWEIGHT, ID42_THEN_INSULIN);
  715.     fuzzy->addFuzzyRule(fuzzyRule42);
  716.  
  717.     //================================= rule - 43 ==============================
  718.  
  719.     FuzzyRuleAntecedent* ID43_BMIandCHO = new FuzzyRuleAntecedent();
  720.     ID43_BMIandCHO->joinWithAND(BMI_H, CHO_L);
  721.     FuzzyRuleAntecedent* ID43_WEIGHT = new FuzzyRuleAntecedent();
  722.     ID43_WEIGHT->joinSingle(WEIGHT_H);
  723.     FuzzyRuleAntecedent* ID43_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  724.     ID43_IF_BMIandCHOandWEIGHT->joinWithAND(ID43_BMIandCHO, ID43_WEIGHT);
  725.  
  726.     FuzzyRuleConsequent* ID43_THEN_INSULIN = new FuzzyRuleConsequent();
  727.     ID43_THEN_INSULIN->addOutput(insulin_C);
  728.  
  729.     FuzzyRule* fuzzyRule43 = new FuzzyRule(43, ID43_IF_BMIandCHOandWEIGHT, ID43_THEN_INSULIN);
  730.     fuzzy->addFuzzyRule(fuzzyRule43);
  731.  
  732.     //================================= rule - 44 ==============================
  733.  
  734.     FuzzyRuleAntecedent* ID44_BMIandCHO = new FuzzyRuleAntecedent();
  735.     ID44_BMIandCHO->joinWithAND(BMI_H, CHO_O);
  736.     FuzzyRuleAntecedent* ID44_WEIGHT = new FuzzyRuleAntecedent();
  737.     ID44_WEIGHT->joinSingle(WEIGHT_H);
  738.     FuzzyRuleAntecedent* ID44_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  739.     ID44_IF_BMIandCHOandWEIGHT->joinWithAND(ID44_BMIandCHO, ID44_WEIGHT);
  740.  
  741.     FuzzyRuleConsequent* ID44_THEN_INSULIN = new FuzzyRuleConsequent();
  742.     ID44_THEN_INSULIN->addOutput(insulin_D);
  743.  
  744.     FuzzyRule* fuzzyRule44 = new FuzzyRule(44, ID44_IF_BMIandCHOandWEIGHT, ID44_THEN_INSULIN);
  745.     fuzzy->addFuzzyRule(fuzzyRule44);
  746.  
  747.     //================================= rule - 45 ==============================
  748.  
  749.     FuzzyRuleAntecedent* ID45_BMIandCHO = new FuzzyRuleAntecedent();
  750.     ID45_BMIandCHO->joinWithAND(BMI_H, CHO_H);
  751.     FuzzyRuleAntecedent* ID45_WEIGHT = new FuzzyRuleAntecedent();
  752.     ID45_WEIGHT->joinSingle(WEIGHT_H);
  753.     FuzzyRuleAntecedent* ID45_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  754.     ID45_IF_BMIandCHOandWEIGHT->joinWithAND(ID45_BMIandCHO, ID45_WEIGHT);
  755.  
  756.     FuzzyRuleConsequent* ID45_THEN_INSULIN = new FuzzyRuleConsequent();
  757.     ID45_THEN_INSULIN->addOutput(insulin_E);
  758.  
  759.     FuzzyRule* fuzzyRule45 = new FuzzyRule(45, ID45_IF_BMIandCHOandWEIGHT, ID45_THEN_INSULIN);
  760.     fuzzy->addFuzzyRule(fuzzyRule45);
  761.  
  762.     //================================= rule - 46 ==============================
  763.  
  764.     FuzzyRuleAntecedent* ID46_BMIandCHO = new FuzzyRuleAntecedent();
  765.     ID46_BMIandCHO->joinWithAND(BMI_L, CHO_L);
  766.     FuzzyRuleAntecedent* ID46_WEIGHT = new FuzzyRuleAntecedent();
  767.     ID46_WEIGHT->joinSingle(WEIGHT_VH);
  768.     FuzzyRuleAntecedent* ID46_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  769.     ID46_IF_BMIandCHOandWEIGHT->joinWithAND(ID46_BMIandCHO, ID46_WEIGHT);
  770.  
  771.     FuzzyRuleConsequent* ID46_THEN_INSULIN = new FuzzyRuleConsequent();
  772.     ID46_THEN_INSULIN->addOutput(insulin_B);
  773.  
  774.     FuzzyRule* fuzzyRule46 = new FuzzyRule(46, ID46_IF_BMIandCHOandWEIGHT, ID46_THEN_INSULIN);
  775.     fuzzy->addFuzzyRule(fuzzyRule46);
  776.  
  777.     //================================= rule - 47 ==============================
  778.  
  779.     FuzzyRuleAntecedent* ID47_BMIandCHO = new FuzzyRuleAntecedent();
  780.     ID47_BMIandCHO->joinWithAND(BMI_L, CHO_O);
  781.     FuzzyRuleAntecedent* ID47_WEIGHT = new FuzzyRuleAntecedent();
  782.     ID47_WEIGHT->joinSingle(WEIGHT_VH);
  783.     FuzzyRuleAntecedent* ID47_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  784.     ID47_IF_BMIandCHOandWEIGHT->joinWithAND(ID47_BMIandCHO, ID47_WEIGHT);
  785.  
  786.     FuzzyRuleConsequent* ID47_THEN_INSULIN = new FuzzyRuleConsequent();
  787.     ID47_THEN_INSULIN->addOutput(insulin_C);
  788.  
  789.     FuzzyRule* fuzzyRule47 = new FuzzyRule(47, ID47_IF_BMIandCHOandWEIGHT, ID47_THEN_INSULIN);
  790.     fuzzy->addFuzzyRule(fuzzyRule47);
  791.  
  792.     //================================= rule - 48 ==============================
  793.  
  794.     FuzzyRuleAntecedent* ID48_BMIandCHO = new FuzzyRuleAntecedent();
  795.     ID48_BMIandCHO->joinWithAND(BMI_L, CHO_H);
  796.     FuzzyRuleAntecedent* ID48_WEIGHT = new FuzzyRuleAntecedent();
  797.     ID48_WEIGHT->joinSingle(WEIGHT_VH);
  798.     FuzzyRuleAntecedent* ID48_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  799.     ID48_IF_BMIandCHOandWEIGHT->joinWithAND(ID48_BMIandCHO, ID48_WEIGHT);
  800.  
  801.     FuzzyRuleConsequent* ID48_THEN_INSULIN = new FuzzyRuleConsequent();
  802.     ID48_THEN_INSULIN->addOutput(insulin_D);
  803.  
  804.     FuzzyRule* fuzzyRule48 = new FuzzyRule(48, ID48_IF_BMIandCHOandWEIGHT, ID48_THEN_INSULIN);
  805.     fuzzy->addFuzzyRule(fuzzyRule48);
  806.  
  807.     //================================= rule - 49 ==============================
  808.  
  809.     FuzzyRuleAntecedent* ID49_BMIandCHO = new FuzzyRuleAntecedent();
  810.     ID49_BMIandCHO->joinWithAND(BMI_O, CHO_L);
  811.     FuzzyRuleAntecedent* ID49_WEIGHT = new FuzzyRuleAntecedent();
  812.     ID49_WEIGHT->joinSingle(WEIGHT_VH);
  813.     FuzzyRuleAntecedent* ID49_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  814.     ID49_IF_BMIandCHOandWEIGHT->joinWithAND(ID49_BMIandCHO, ID49_WEIGHT);
  815.  
  816.     FuzzyRuleConsequent* ID49_THEN_INSULIN = new FuzzyRuleConsequent();
  817.     ID49_THEN_INSULIN->addOutput(insulin_D);
  818.  
  819.     FuzzyRule* fuzzyRule49 = new FuzzyRule(49, ID49_IF_BMIandCHOandWEIGHT, ID49_THEN_INSULIN);
  820.     fuzzy->addFuzzyRule(fuzzyRule49);
  821.  
  822.     //================================= rule - 50 ==============================
  823.  
  824.     FuzzyRuleAntecedent* ID50_BMIandCHO = new FuzzyRuleAntecedent();
  825.     ID50_BMIandCHO->joinWithAND(BMI_O, CHO_O);
  826.     FuzzyRuleAntecedent* ID50_WEIGHT = new FuzzyRuleAntecedent();
  827.     ID50_WEIGHT->joinSingle(WEIGHT_VH);
  828.     FuzzyRuleAntecedent* ID50_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  829.     ID50_IF_BMIandCHOandWEIGHT->joinWithAND(ID50_BMIandCHO, ID50_WEIGHT);
  830.  
  831.     FuzzyRuleConsequent* ID50_THEN_INSULIN = new FuzzyRuleConsequent();
  832.     ID50_THEN_INSULIN->addOutput(insulin_D);
  833.  
  834.     FuzzyRule* fuzzyRule50 = new FuzzyRule(50, ID50_IF_BMIandCHOandWEIGHT, ID50_THEN_INSULIN);
  835.     fuzzy->addFuzzyRule(fuzzyRule50);
  836.  
  837.     //================================= rule - 51 ==============================
  838.  
  839.     FuzzyRuleAntecedent* ID51_BMIandCHO = new FuzzyRuleAntecedent();
  840.     ID51_BMIandCHO->joinWithAND(BMI_O, CHO_H);
  841.     FuzzyRuleAntecedent* ID51_WEIGHT = new FuzzyRuleAntecedent();
  842.     ID51_WEIGHT->joinSingle(WEIGHT_VH);
  843.     FuzzyRuleAntecedent* ID51_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  844.     ID51_IF_BMIandCHOandWEIGHT->joinWithAND(ID51_BMIandCHO, ID51_WEIGHT);
  845.  
  846.     FuzzyRuleConsequent* ID51_THEN_INSULIN = new FuzzyRuleConsequent();
  847.     ID51_THEN_INSULIN->addOutput(insulin_E);
  848.  
  849.     FuzzyRule* fuzzyRule51 = new FuzzyRule(51, ID51_IF_BMIandCHOandWEIGHT, ID51_THEN_INSULIN);
  850.     fuzzy->addFuzzyRule(fuzzyRule51);
  851.  
  852.     //================================= rule - 52 ==============================
  853.  
  854.     FuzzyRuleAntecedent* ID52_BMIandCHO = new FuzzyRuleAntecedent();
  855.     ID52_BMIandCHO->joinWithAND(BMI_H, CHO_L);
  856.     FuzzyRuleAntecedent* ID52_WEIGHT = new FuzzyRuleAntecedent();
  857.     ID52_WEIGHT->joinSingle(WEIGHT_VH);
  858.     FuzzyRuleAntecedent* ID52_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  859.     ID52_IF_BMIandCHOandWEIGHT->joinWithAND(ID52_BMIandCHO, ID52_WEIGHT);
  860.  
  861.     FuzzyRuleConsequent* ID52_THEN_INSULIN = new FuzzyRuleConsequent();
  862.     ID52_THEN_INSULIN->addOutput(insulin_D);
  863.  
  864.     FuzzyRule* fuzzyRule52 = new FuzzyRule(52, ID52_IF_BMIandCHOandWEIGHT, ID52_THEN_INSULIN);
  865.     fuzzy->addFuzzyRule(fuzzyRule52);
  866.  
  867.     //================================= rule - 53 ==============================
  868.  
  869.     FuzzyRuleAntecedent* ID53_BMIandCHO = new FuzzyRuleAntecedent();
  870.     ID53_BMIandCHO->joinWithAND(BMI_H, CHO_O);
  871.     FuzzyRuleAntecedent* ID53_WEIGHT = new FuzzyRuleAntecedent();
  872.     ID53_WEIGHT->joinSingle(WEIGHT_VH);
  873.     FuzzyRuleAntecedent* ID53_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  874.     ID53_IF_BMIandCHOandWEIGHT->joinWithAND(ID53_BMIandCHO, ID53_WEIGHT);
  875.  
  876.     FuzzyRuleConsequent* ID53_THEN_INSULIN = new FuzzyRuleConsequent();
  877.     ID53_THEN_INSULIN->addOutput(insulin_E);
  878.  
  879.     FuzzyRule* fuzzyRule53 = new FuzzyRule(53, ID53_IF_BMIandCHOandWEIGHT, ID53_THEN_INSULIN);
  880.     fuzzy->addFuzzyRule(fuzzyRule53);
  881.  
  882.     //================================= rule - 54 ==============================
  883.  
  884.     FuzzyRuleAntecedent* ID54_BMIandCHO = new FuzzyRuleAntecedent();
  885.     ID54_BMIandCHO->joinWithAND(BMI_H, CHO_H);
  886.     FuzzyRuleAntecedent* ID54_WEIGHT = new FuzzyRuleAntecedent();
  887.     ID54_WEIGHT->joinSingle(WEIGHT_VH);
  888.     FuzzyRuleAntecedent* ID54_IF_BMIandCHOandWEIGHT = new FuzzyRuleAntecedent();
  889.     ID54_IF_BMIandCHOandWEIGHT->joinWithAND(ID54_BMIandCHO, ID54_WEIGHT);
  890.  
  891.     FuzzyRuleConsequent* ID54_THEN_INSULIN = new FuzzyRuleConsequent();
  892.     ID54_THEN_INSULIN->addOutput(insulin_E);
  893.  
  894.     FuzzyRule* fuzzyRule54 = new FuzzyRule(54, ID54_IF_BMIandCHOandWEIGHT, ID54_THEN_INSULIN);
  895.     fuzzy->addFuzzyRule(fuzzyRule54);
  896. }
  897.  
  898. void loop()
  899. {
  900.     fuzzy->setInput(1, 28);
  901.     fuzzy->setInput(2, 466);
  902.     fuzzy->setInput(3, 72);
  903.  
  904.     fuzzy->fuzzify();
  905.  
  906.     Serial.print("BMI level = ");
  907.     Serial.print(BMI_L->getPertinence()); Serial.print(", ");
  908.     Serial.print(BMI_O->getPertinence()); Serial.print(", ");
  909.     Serial.println(BMI_H->getPertinence());
  910.  
  911.     Serial.print("CHO level = ");
  912.     Serial.print(CHO_L->getPertinence()); Serial.print(", ");
  913.     Serial.print(CHO_O->getPertinence()); Serial.print(", ");
  914.     Serial.println(CHO_H->getPertinence());
  915.  
  916.     Serial.print("WEIGHT level = ");
  917.     Serial.print(WEIGHT_VL->getPertinence()); Serial.print(", ");
  918.     Serial.print(WEIGHT_L->getPertinence()); Serial.print(", ");
  919.     Serial.print(WEIGHT_O1->getPertinence()); Serial.print(", ");
  920.     Serial.print(WEIGHT_O2->getPertinence()); Serial.print(", ");
  921.     Serial.print(WEIGHT_H->getPertinence()); Serial.print(", ");
  922.     Serial.println(WEIGHT_VH->getPertinence());
  923.  
  924.     // Serial.print("INSULIN level = ");
  925.     // Serial.print(insulin_A->getPertinence()); Serial.print(", ");
  926.     // Serial.print(insulin_B->getPertinence()); Serial.print(", ");
  927.     // Serial.print(insulin_C->getPertinence()); Serial.print(", ");
  928.     // Serial.print(insulin_D->getPertinence()); Serial.print(", ");
  929.     // Serial.print(insulin_E->getPertinence()); Serial.print(", ");
  930.  
  931.     float output = fuzzy->defuzzify(1);
  932.  
  933.     Serial.print("Insulin dose = ");
  934.     Serial.println(output);
  935.  
  936.     delay(100000);
  937.  
  938. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!