home *** CD-ROM | disk | FTP | other *** search
/ AI Game Programming Wisdom / AIGameProgrammingWisdom.iso / SourceCode / 02 Useful Techniques / 08 Zarozinski / src / ffllapi / FuzzyVariableBase.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-11-29  |  32.3 KB  |  1,459 lines
  1. //
  2. // File:    FuzzyVariableBase.cpp
  3. //
  4. // Purpose:    This file contains ancestor code for the FuzzyVariable classes
  5. //
  6. // Copyright ⌐ 1999-2001 Louder Than A Bomb! Software
  7. //
  8. // This file is part of the FFLL (Free Fuzzy Logic Library) project (http://ffll.sourceforge.net)
  9. // It is released under the BSD license, see http://ffll.sourceforge.net/license.txt for the full text.
  10. // 
  11.  
  12. #include "FuzzyVariableBase.h"
  13. #include "FuzzySetBase.h"
  14. #include "FuzzyModelBase.h"
  15. #include "MemberFuncBase.h"
  16.  
  17. #include <fstream>
  18.  
  19. #ifdef _DEBUG
  20. #undef THIS_FILE
  21. static char THIS_FILE[] = __FILE__;
  22. #endif
  23.  
  24. // init static variables to a reasonable value. We add one to each array count to
  25. // account for the fact that we start counting at zero.
  26. // For example if we only had 5 elements in the array and the variable range was 0 to 5,
  27. // we'd expect each element to be 1 'x' value, but then the 'x' value at values[4] (the
  28. // fifth element) would be 4 and we EXPECT 5.The values array would look like:
  29. // 
  30. //        values[0] = 0
  31. //        values[1] = 1
  32. //        values[2] = 2
  33. //        values[3] = 3
  34. //        values[4] = 4
  35. //
  36. // if each "step" was 1. So we need to add 1 element to the array to get the results we want.
  37.  
  38.  
  39. FFLL_API ValuesArrCountType FuzzyVariableBase::x_array_count = 201;
  40. FFLL_API ValuesArrCountType FuzzyVariableBase::x_array_max_idx = FuzzyVariableBase::x_array_count - 1;
  41. FFLL_API DOMType FuzzyVariableBase::dom_array_count = 101;
  42. FFLL_API DOMType FuzzyVariableBase::dom_array_max_idx = FuzzyVariableBase::dom_array_count - 1;
  43.  
  44.  
  45. //
  46. // Function: FuzzyVariableBase()
  47. // 
  48. // Purpose:    default constructor 
  49. // 
  50. // Arguments:
  51. //
  52. //        FuzzyModelBase* _parent - model that this variable is part of
  53. // 
  54. // Returns:
  55. //
  56. //        nothing
  57. // 
  58. // Author:    Michael Zarozinski    
  59. // Date:    6/10/99
  60. // 
  61. // Modification History
  62. // Author        Date        Modification
  63. // ------        ----        ------------
  64. //
  65. //
  66.  
  67. FuzzyVariableBase::FuzzyVariableBase(FuzzyModelBase* _parent) :  FFLLBase(_parent) 
  68. {
  69.      num_of_sets = 0;
  70.     rule_index = 0;
  71.      index = -1;
  72.  
  73.     sets = NULL; 
  74.  
  75.     // set left/right shoulder
  76.     left_x = 0;
  77.     right_x = FuzzyVariableBase::x_array_max_idx;
  78.  
  79.     set_id(L""); // init identifier
  80.  
  81.     idx_multiplier = 0; // it should NEVER be 0 so by init'ing to 0 we'll know if there's a problem sooner
  82.  
  83. } // end FuzzyVariableBase::FuzzyVariableBase()
  84.  
  85. //
  86. // Function: ~FuzzyVariableBase()
  87. // 
  88. // Purpose:    default destructor 
  89. // 
  90. // Arguments:
  91. //
  92. //        none
  93. // 
  94. // Returns:
  95. //
  96. //        nothing
  97. // 
  98. // Author:    Michael Zarozinski    
  99. // Date:    6/10/99
  100. // 
  101. // Modification History
  102. // Author        Date        Modification
  103. // ------        ----        ------------
  104. //
  105. //
  106. FuzzyVariableBase::~FuzzyVariableBase()
  107. {
  108.  
  109.     delete_all_sets();
  110.  
  111. } // end FuzzyVariableBase::~FuzzyVariableBase()
  112.  
  113.  
  114.  
  115.  
  116.  
  117. //
  118. // Function:    set_ramp()
  119. // 
  120. // Purpose:        Change the ramp status of one of the variable's sets.
  121. //                A ramp is a membership function that has the 'y' axis
  122. //                as one of it's sides. For example a normal trapezoid memberhip
  123. //                function would look like this:
  124. //                                       ___
  125. //              Normal Trapezoid:       /   \
  126. //                                       ___
  127. //              Left Ramp Trapezoid:    |   \ 
  128. //                                       ___
  129. //              Right Ramp Trapezoid:   /   |  
  130. //
  131. // Arguments:
  132. //
  133. //        int left_right_ind        -    indicates if we're making a left (1) or right (0) ramp
  134. //        int hi_lo_ind            -    indicates if we're creating (1) or removing (0) ramp
  135. //        int set_idx                -    index of the set to change the ramp for
  136. //
  137. // Returns:
  138. //
  139. //        
  140. //
  141. // Author:    Michael Zarozinski
  142. // Date:    7/99
  143. // 
  144. // Modification History
  145. // Author    Date        Modification
  146. // ------    ----        ------------
  147. //
  148. //
  149.  
  150. void FuzzyVariableBase::set_ramp(int left_right_ind, int hi_lo_ind, int set_idx )
  151. {
  152.      sets[set_idx]->set_ramp(hi_lo_ind, left_right_ind);
  153.  
  154. } // end FuzzyVariableBase::set_ramp()
  155.  
  156.  
  157.  
  158.  
  159. //
  160. // Function:    is_set_id_unique
  161. // 
  162. // Purpose:        Checks if the set name passed in is unique for this variable
  163. //
  164. // Arguments:
  165. //
  166. //        const wchar_t*    set_id    - set name to check
  167. //        int                set_idx    - index for the set the id belongs to
  168. //
  169. // Returns:
  170. //
  171. //        true - id is unique
  172. //        false - id is NOT unique
  173. //
  174. // Author:    Michael Zarozinski
  175. // Date:    6/00
  176. // 
  177. // Modification History
  178. // Author    Date        Modification
  179. // ------    ----        ------------
  180. //
  181. //
  182. bool FuzzyVariableBase::is_set_id_unique(const wchar_t* set_id, int set_idx) const
  183. {
  184.      FuzzySetBase*    set;    // set we're checking
  185.  
  186.     // go through all the OTHER sets and make sure there is no match
  187.  
  188.     for (int i = 0; i < get_num_of_sets(); i++)
  189.         {
  190.         if (i == set_idx)
  191.             continue;    // skip this set
  192.  
  193.         set = get_set(i);  
  194.  
  195.         assert(set != NULL);
  196.  
  197.         // case insensitive comparison
  198.         if (wcsicmp(set->get_id(), set_id) == 0)
  199.             {
  200.             set_msg_text(ERR_SET_NON_UNIQUE_ID);  
  201.             return false;
  202.             }
  203.  
  204.         } // end loop through sets
  205.  
  206.     // if we got here the id IS unique...
  207.     return true;
  208.  
  209. } // end  is_set_id_unique()
  210.  
  211. //
  212. // Function:    set_left_x()
  213. // 
  214. // Purpose:        Set the left value for this variable. Note that the left value IS
  215. //                allowed to be greater than the right value. The only restriction is
  216. //                that they can NOT be the same.
  217. //
  218. // Arguments:
  219. //
  220. //        RealType value - value to set left_x to
  221. //
  222. // Returns:
  223. //
  224. //        0 - set value 
  225. //        -1 - problem setting value 
  226. //
  227. // Author:    Michael Zarozinski
  228. // Date:    7/99
  229. // 
  230. // Modification History
  231. // Author    Date        Modification
  232. // ------    ----        ------------
  233. //
  234. //
  235.  
  236. int FuzzyVariableBase::set_left_x(RealType value)
  237. {
  238.  
  239.     // make sure value != right_x
  240.     if (value == right_x)
  241.         {
  242.         set_msg_text(ERR_SAME_LEFT_RIGHT_VALS);
  243.         return -1;
  244.         }
  245.  
  246.     left_x = value; 
  247.  
  248.     // re-calc multiplier cuz it's affected by this
  249.     calc_idx_multiplier();
  250.  
  251.     return 0;
  252.  
  253. } // end FuzzyVariableBase::set_left_x()
  254.  
  255. //
  256. // Function:    set_right_x()
  257. // 
  258. // Purpose:        Set the right value for this variable. Note that the left value IS
  259. //                allowed to be greater than the right value. The only restriction is
  260. //                that they can NOT be the same.
  261. //
  262. // Arguments:
  263. //
  264. //        RealType value - value to set right_x to
  265. //
  266. // Returns:
  267. //
  268. //        0 - set value 
  269. //        -1 - problem setting value 
  270. //
  271. // Author:    Michael Zarozinski
  272. // Date:    7/99
  273. // 
  274. // Modification History
  275. // Author    Date        Modification
  276. // ------    ----        ------------
  277. //
  278. //
  279. int FuzzyVariableBase::set_right_x(RealType value)
  280. {
  281.     // make sure avlue != left_x
  282.     if (value == left_x)
  283.         {
  284.         set_msg_text(ERR_SAME_LEFT_RIGHT_VALS);
  285.         return -1;
  286.         }
  287.  
  288.     right_x = value; 
  289.  
  290.     // re-calc multiplier cuz it's affected by this
  291.     calc_idx_multiplier();
  292.  
  293.     return 0;
  294.  
  295. } // end FuzzyVariableBase::set_right_x()
  296.  
  297. //
  298. // Function:    calc_idx_multiplier()
  299. // 
  300. // Purpose:        Calculate the index multiplier value for this variable.
  301. //                NOTE: there is not 'set' for the multiplier - it's always calculated
  302. //
  303. // Arguments:
  304. //
  305. //        none
  306. //
  307. // Returns:
  308. //
  309. //        void
  310. //
  311. // Author:    Michael Zarozinski
  312. // Date:    8/99
  313. // 
  314. // Modification History
  315. // Author    Date        Modification
  316. // ------    ----        ------------
  317. //
  318. //
  319. // 
  320. void FuzzyVariableBase::calc_idx_multiplier()
  321. { 
  322.      idx_multiplier =(right_x - left_x) /((RealType)( FuzzyVariableBase::x_array_max_idx));
  323.     
  324. }; // end FuzzyVariableBase::calc_idx_multiplier()
  325.  
  326.  
  327.  
  328. //
  329. // Function:    delete_set()
  330. // 
  331. // Purpose:        Deletes a set from the variable and adjusts the sets[]
  332. //                array appropriately.
  333. //
  334. // Arguments:
  335. //
  336. //        int _set_idx - index of the set to delete
  337. //
  338. // Returns:
  339. //
  340. //        0 - success
  341. //        non-zero - failure
  342. //
  343. // Author:    Michael Zarozinski
  344. // Date:    8/99
  345. // 
  346. // Modification History
  347. // Author    Date        Modification
  348. // ------    ----        ------------
  349. //
  350. //
  351. int FuzzyVariableBase::delete_set(int _set_idx)
  352. {
  353.     // if we don't have any sets, just return
  354.     if (sets == NULL)
  355.         return 0; // nothing to do.
  356.  
  357.     FuzzySetBase**    tmp_sets; // temp array to hold sets
  358.     
  359.     // if we're deleting the last set, don't alloc any memory
  360.     if (num_of_sets - 1 == 0)
  361.         tmp_sets = NULL;
  362.     else
  363.         tmp_sets = new FuzzySetBase*[num_of_sets - 1];    // create temp array
  364.  
  365.     // copy the old memory to the temp mem...
  366.     int j = 0;
  367.     for (int i = 0; i < num_of_sets; i++)
  368.         {
  369.         // don't copy the set we're deleting
  370.         if (i == _set_idx)
  371.             {
  372.             // free the memory for the set we're deleting
  373.             delete sets[i] ;
  374.             sets[i] = NULL;
  375.             }
  376.         else
  377.             {
  378.             tmp_sets[j] = (FuzzySetBase*)sets[i];
  379.             tmp_sets[j]->set_index(j);
  380.             // set the index
  381.             j++;
  382.             }
  383.         
  384.         } // end loop through sets
  385.  
  386.     // decrement the set count
  387.     num_of_sets--;
  388.  
  389.     // free old memory...
  390.     delete[] sets;
  391.  
  392.     // assign the new array of sets to the sets[] member variable
  393.      sets = tmp_sets;
  394.     
  395.     return 0; 
  396.  
  397. } // end FuzzyVariableBase::delete_set()
  398.  
  399.  
  400. //
  401. // Function: delete_all_sets()
  402. // 
  403. // Purpose:    clean up the memory allocated for sets
  404. // 
  405. // Arguments:
  406. //
  407. //        none
  408. // 
  409. // Returns:
  410. //
  411. //        void
  412. // 
  413. // Author:    Michael Zarozinski    
  414. // Date:    6/10/99
  415. // 
  416. // Modification History
  417. // Author        Date        Modification
  418. // ------        ----        ------------
  419. //
  420. //
  421.  
  422. void FuzzyVariableBase::delete_all_sets()
  423. {
  424.      // if we don't have any sets, just return
  425.     if (sets == NULL)
  426.         return; // nothing to do.
  427.  
  428.     // loop through all the sets and free memory
  429.     for (int i = 0; i < num_of_sets; i++)
  430.         {
  431.         delete sets[i] ;
  432.         sets[i] = NULL;
  433.         } // end loop through sets
  434.  
  435.     num_of_sets = 0;
  436.  
  437.     // free old memory...
  438.     delete[] sets;
  439.      sets = NULL;
  440.  
  441. } // end FuzzyVariableBase::delete_all_sets()
  442.  
  443.  
  444. //
  445. // Function:    set_id()
  446. // 
  447. // Purpose:        Set the identifier for a variable or set. This version
  448. //                takes an ASCII string, converts it to wide characters and
  449. //                calls the wide character version of this function
  450. //
  451. // Arguments:
  452. //
  453. //        const char*    _id        -    identifier to set
  454. //        int            set_idx    -    index of the set to change the id for, if -1 (default), change
  455. //                                the id for the variable
  456. //
  457. // Returns:
  458. //    
  459. //        0 - success
  460. //        non-zero - non-unique id    
  461. //
  462. // Author:    Michael Zarozinski
  463. // Date:    8/99
  464. // 
  465. // Modification History
  466. // Author    Date        Modification
  467. // ------    ----        ------------
  468. //
  469. //
  470. int FuzzyVariableBase::set_id(const char* _id, int set_idx /* = -1 */)
  471. {
  472.     wchar_t* wc = new wchar_t[strlen(_id) + 1];
  473.  
  474.     // convert from char to wchar_t
  475.     swprintf(wc, L"%S", _id);
  476.  
  477.     int ret_val = set_id(wc, set_idx);  
  478.  
  479.     delete[] wc;
  480.  
  481.     return ret_val;
  482.      
  483. } // end FuzzyVariableBase::set_id()
  484.  
  485. //
  486. // Function:    set_id()
  487. // 
  488. // Purpose:        Set the identifier for a variable or set. If no set index
  489. //                is passed in set the variable's id.
  490. //                This function will only set the identifier if it's unique
  491. //
  492. // Arguments:
  493. //
  494. //        const wchar_t*    _id        -    identifier to set
  495. //        int                set_idx    -    index of the set to change the id for, if -1 (default), change
  496. //                                    the id for the variable
  497. //
  498. // Returns:
  499. //    
  500. //        0 - success
  501. //        non-zero - non-unique id    
  502. //
  503. // Author:    Michael Zarozinski
  504. // Date:    8/99
  505. // 
  506. // Modification History
  507. // Author    Date        Modification
  508. // ------    ----        ------------
  509. //
  510. //
  511. int FuzzyVariableBase::set_id(const wchar_t* _id, int set_idx /* = -1 */)
  512. {
  513.     // if a set_idx is passed in, set the name for that set
  514.     if (set_idx >= 0)
  515.         {
  516.         int ret_val = sets[set_idx]->set_id(_id);
  517.  
  518.         if (ret_val)
  519.             {
  520.             // read the error from the set and set it for 'this'
  521.             set_msg_text(sets[set_idx]->get_msg_text());
  522.              return ret_val;  
  523.             }
  524.         }
  525.  
  526.      if (_id == NULL || wcslen(_id) == 0)
  527.         {
  528.         id = L"";
  529.         return 0;
  530.         }
  531.  
  532.      FuzzyModelBase* par = get_parent();
  533.  
  534.     // make sure our id is UNIQUE within the rule block
  535.       if (par->is_var_id_unique(_id, get_index()) == false)
  536.         {
  537.         // read the error from the parent and set it for 'this'
  538.         set_msg_text(par->get_msg_text());
  539.          return -1;  
  540.         }
  541.  
  542.     // set the identifier
  543.      id = _id;
  544.  
  545.     return 0;
  546.  
  547. }; // end FuzzyVariableBase::set_id()
  548.  
  549. //
  550. // Function:    add_set()
  551. // 
  552. // Purpose:        Insert a set into this variable.  NOTE: that a COPY of the
  553. //                set passed in is inserted into the var so the caller must
  554. //                free the object if it dynamically allocated it.
  555. //
  556. // Arguments:
  557. //
  558. //        const FuzzySetBase* _new_set - set to insert a copy of
  559. //
  560. // Returns:
  561. //
  562. //        0 - success
  563. //        non-zero - failure
  564. //
  565. // Author:    Michael Zarozinski
  566. // Date:    5/00
  567. // 
  568. // Modification History
  569. // Author    Date        Modification
  570. // ------    ----        ------------
  571. //
  572. //
  573. int FuzzyVariableBase::add_set(const FuzzySetBase* _new_set)
  574. { 
  575.  
  576.     // allocate temp memory which is the current number of sets PLUS 1
  577.     FuzzySetBase**    tmp_sets = new FuzzySetBase*[num_of_sets + 1];
  578.  
  579.     // copy the old memory to the temp mem...
  580.     for (int i = 0; i < num_of_sets; i++)
  581.         {
  582.          tmp_sets[i] = (FuzzySetBase*)sets[i];
  583.         }
  584.  
  585.      tmp_sets[num_of_sets] =  new_set(); // insert empty set 
  586.  
  587.     tmp_sets[num_of_sets]->copy(*_new_set); // copy the set we passed in
  588.  
  589.     // ensure that the set id is unique... if the user changed the id we
  590.     // performed a check PRIOR to calling this, so it'll be unique, if
  591.     // we get there through cut/copy/paste or something else we 
  592.     // may need to change the name...
  593.  
  594.     std::wstring tmp_name; // temp name
  595.           
  596.     std::wstring set_name = tmp_sets[num_of_sets]->get_id();
  597.  
  598.      while (!(is_set_id_unique(set_name.data(),  get_num_of_sets())))
  599.         {
  600.         // save the name
  601.         tmp_name = set_name;
  602.  
  603.         // just keep adding "Copy of" until we get a unique id
  604.         set_name = load_string(STR_COPY_OF);
  605.         set_name += L" " + tmp_name;
  606.  
  607.         // clear the message text...
  608.         set_msg_text();
  609.  
  610.         } // end wile set is NOT unique
  611.    
  612.     tmp_sets[num_of_sets]->set_id(set_name.data());
  613.  
  614.      // set the set index...
  615.     tmp_sets[num_of_sets]->set_index(num_of_sets);
  616.  
  617.     tmp_sets[num_of_sets]->calc();
  618.  
  619.     num_of_sets++;    // increment the number of sets
  620.  
  621.     // free old memory...
  622.     delete[] sets;
  623.  
  624.     // copy new mem to old
  625.     sets = tmp_sets;
  626.   
  627.     return 0;
  628.  
  629. } // end FuzzyVariableBase::add_set()
  630.  
  631.  
  632. //
  633. // Function:    set_x_array_count()
  634. // 
  635. // Purpose:        Set the value for x_array_count. This also sets the
  636. //                x_array_max_idx value appropriately. Note: this is a static
  637. //                function so it can't call non-static member funcs which
  638. //                means the caller needs to make sure the idx_multiplier
  639. //                variables are re-calculated.
  640. //
  641. // Arguments:
  642. //
  643. //        int _count - value to set x_array_count to.
  644. //
  645. // Returns:
  646. //
  647. //        0 - success
  648. //        -1 - invalid value passed in, set x_array_count to max allowed by datatype
  649. //
  650. // Author:    Michael Zarozinski
  651. // Date:    5/01
  652. // 
  653. // Modification History
  654. // Author    Date        Modification
  655. // ------    ----        ------------
  656. //
  657. //
  658.  
  659. int FuzzyVariableBase::set_x_array_count(int _count)
  660. {
  661.     // if they're trying to set over max, set to max and return -1
  662.     if (_count > USHRT_MAX)
  663.         {
  664.         x_array_count = USHRT_MAX;
  665.         x_array_max_idx = x_array_count - 1;
  666.         return -1;
  667.         }
  668.     
  669.     x_array_count = _count;
  670.     x_array_max_idx = x_array_count - 1;
  671.  
  672.     return 0;
  673.  
  674. }; // end FuzzyVariableBase::set_x_array_count()
  675.  
  676.  
  677. //
  678. // Function:    set_dom_array_count()
  679. // 
  680. // Purpose:        Set the value for dom_array_count. This also sets the
  681. //                dom_array_max_idx value appropriately.
  682. //
  683. // Arguments:
  684. //
  685. //        int _count - value to set dom_array_count to.
  686. //
  687. // Returns:
  688. //
  689. //        0 - success
  690. //        -1 - invalid value passed in, set dom_array_count to max allowed by datatype
  691. //
  692. // Author:    Michael Zarozinski
  693. // Date:    5/01
  694. // 
  695. // Modification History
  696. // Author    Date        Modification
  697. // ------    ----        ------------
  698. //
  699. //
  700.  
  701. int FuzzyVariableBase::set_dom_array_count(int _count)
  702. {
  703.     // if they're trying to set over max, set to max and return -1
  704.     if (_count > UCHAR_MAX)
  705.         {
  706.         dom_array_count = UCHAR_MAX;
  707.         dom_array_max_idx = x_array_count - 1;
  708.         return -1;
  709.         }
  710.     
  711.     dom_array_count = _count;
  712.     dom_array_max_idx = dom_array_count - 1;
  713.  
  714.     return 0;    
  715.  
  716. }; // end FuzzyVariableBase::set_dom_array_count()
  717.  
  718.  
  719. //
  720. // Function:    save_var_to_fcl_file()
  721. // 
  722. // Purpose:        Write out the FCL (Fuzzy Control Language) for this variable. This is written
  723. //                inside a FUNCTION_BLOCK section and has the format (as defined by the
  724. //                IEC 61131-7 International Standard):
  725. //
  726. //                    VAR_INPUT Input parameter declaration
  727. //                        variable_name: data_type; (* RANGE *)
  728. //                        ....
  729. //                    END_VAR
  730. //
  731. //                NOTE: we augment the standard by writing out the variable's range in a comment
  732. //                after the semi-colon. Without this we won't know the left/right values for the
  733. //                varaible when a FCL file is read in.
  734. //
  735. // Arguments:
  736. //
  737. //        std::ofstream& file_contents - STL stream to write out to a file
  738. //
  739. /// Returns:
  740. //
  741. //        void
  742. //
  743. // Author:    Michael Zarozinski
  744. // Date:    9/01
  745. // 
  746. // Modification History
  747. // Author    Date        Modification
  748. // ------    ----        ------------
  749. //
  750. //
  751. void FuzzyVariableBase::save_var_to_fcl_file(std::ofstream& file_contents)
  752. {
  753.     // get the ascii version of the id...
  754.     char* aid = convert_to_ascii(get_id());
  755.      
  756.     // store the ORIGINAL version BEFORE we replace any spaces so we can report on it
  757.     std::string tmp = aid;
  758.  
  759.     delete[] aid;
  760.  
  761.     // now get the version with spaces replaced by underscores
  762.     aid = convert_to_ascii(get_id(), '_');
  763.  
  764.     // NOTE: the IEC 61131-7 does not specify a way to set the range of a varaible, so 
  765.     // we write them out in a range comment
  766.  
  767.     file_contents << "\t" << aid <<  "\tREAL; (* RANGE(" << get_left_x() << " .. " << get_right_x() << ") *) ";
  768.  
  769.     delete[] aid;
  770.  
  771.     FuzzyModelBase::validate_fcl_identifier(file_contents, tmp);
  772.  
  773.     file_contents << "\n";
  774.  
  775. } // end FuzzyVariableBase::save_var_to_fcl_file()
  776.  
  777.  
  778. //
  779. // Function:    save_sets_to_fcl_file()
  780. // 
  781. // Purpose:        Write out the FCL (Fuzzy Control Language) for the sets in this variable
  782. //                as defined by the IEC 61131-7 International Standard:
  783. //
  784. //                    FUZZIFY variable_name
  785. //                        TERM term_name:= membership_function;
  786. //                        ....
  787. //                    END_FUZZIFY
  788. //
  789. // Arguments:
  790. //
  791. //        std::ofstream& file_contents - STL stream to write out to a file
  792. //
  793. /// Returns:
  794. //
  795. //        void
  796. //
  797. // Author:    Michael Zarozinski
  798. // Date:    9/01
  799. // 
  800. // Modification History
  801. // Author    Date        Modification
  802. // ------    ----        ------------
  803. //
  804. //
  805. void FuzzyVariableBase::save_sets_to_fcl_file(std::ofstream& file_contents)
  806. {
  807.      FuzzySetBase*    set;    // set we're dealing with
  808.  
  809.      // get the ascii version of the id and replace any spaces
  810.     // with an underscore...
  811.     char* aid = convert_to_ascii(get_id(), '_');
  812.  
  813.     file_contents << "FUZZIFY " << aid << "\n";
  814.  
  815.     delete[] aid;
  816.  
  817.     // loop through the sets
  818.     for (int i = 0; i < num_of_sets; i++)
  819.         {
  820.         set = get_set(i);
  821.  
  822.         set->save_to_fcl_file(file_contents);
  823.  
  824.         char* aid_set = convert_to_ascii(set->get_id());
  825.  
  826.         FuzzyModelBase::validate_fcl_identifier(file_contents, aid_set);
  827.  
  828.         delete[] aid_set;
  829.  
  830.         file_contents << "\n";
  831.  
  832.         } // end loop through sets
  833.  
  834.     file_contents << "END_FUZZIFY\n\n";
  835.  
  836. } // end FuzzyVariableBase::save_sets_to_file()
  837.  
  838. //
  839. // Function:    load_sets_from_fcl_file()
  840. // 
  841. // Purpose:        Read in an FCL file and create the sets that are associated
  842. //                with this variable. 
  843. //                NOTE: This is a brain-dead parser, it can be made much more robust.
  844. //
  845. // Arguments:
  846. //
  847. //        std::ifstream& file_contents - FCL file in stream form
  848. //
  849. // Returns:
  850. //
  851. //        0 - success
  852. //        non-zero - failure
  853. //
  854. // Author:    Michael Zarozinski
  855. // Date:    9/01
  856. // 
  857. // Modification History
  858. // Author    Date        Modification
  859. // ------    ----        ------------
  860. //
  861. // 
  862. int FuzzyVariableBase::load_sets_from_fcl_file(std::ifstream& file_contents)
  863. {
  864.       file_contents.seekg(0);    // go to start of file
  865.  
  866.     // get the ascii version of this variable's id...
  867.     char* aid = convert_to_ascii(get_id());
  868.  
  869.     // search for keyword FUZZIFY followed by id of this var...
  870.     std::string stoken, var_name;
  871.     bool found = false;
  872.  
  873.     while (!found)
  874.         {
  875.  
  876.         // read until we get to the start of the variable declaration
  877.         do
  878.             {
  879.             file_contents >> stoken;
  880.  
  881.             // check for EOF
  882.             if (file_contents.eof())
  883.                 {
  884.                 set_msg_text(ERR_EOF_READING_SETS);
  885.                  return -1; 
  886.                 }
  887.  
  888.             } while (strcmp(stoken.data(), "FUZZIFY") != 0 );
  889.         
  890.         // if we got here we have a FUZZIFY block... check if it's the right var...
  891.         file_contents >> var_name;
  892.  
  893.          if (strcmp(var_name.data(), aid) == 0)
  894.              found = true;
  895.  
  896.         }; // end while !found
  897.  
  898.     delete[] aid;
  899.  
  900.     // we found "FUZZIFY <var name>", now loop until we find "END_FUZZIFY" reading
  901.     // the sets which are in the format:
  902.     // 
  903.     //            TERM term_name:= membership_function;
  904.     //
  905.     // Where membership_function ::= ( point i), ( point j), ...
  906.     // and point is either a single value (if singleton) or a list of x/y values (x, y)
  907.     // and the values MAY have a decimal point.
  908.  
  909.     // read line-by-line to get the sets...
  910.  
  911.     char line[300];
  912.      RealType x_point[7], y_point[7];    // x/y points for the set - NOTE: we assume a max of 7 points
  913.  
  914.     char* set_name;
  915.     char* token;
  916.             
  917.     // inlude ":=" in tokens so we skip the assignment operator
  918.     char seps[]   = " ,()\t\n:=";
  919.  
  920.     while(1)
  921.         {
  922.         // read in the next line
  923.         file_contents.getline(line, 300);
  924.  
  925.         // check for EOF
  926.         if (file_contents.eof())
  927.             {
  928.             set_msg_text(ERR_EOF_READING_SETS);
  929.              return -1; 
  930.             }
  931.  
  932.         token = strtok(line, seps);
  933.  
  934.         // if token is null... blank line
  935.         if (token == NULL)
  936.             continue;
  937.  
  938.         if (strcmp(token, "END_FUZZIFY") == 0)
  939.             break;    // we're done
  940.  
  941.         // validate this is the "term" keyword
  942.         if (stricmp(token, "term") != 0)
  943.             {
  944.             set_msg_text(ERR_INVALID_FILE_FORMAT); // could be a bit more "robuts" in our error reporting!
  945.             return -1;
  946.             }
  947.         
  948.         // get the set name
  949.         set_name = strtok(NULL, seps);
  950.  
  951.         token = strtok(NULL, seps);
  952.  
  953.         int num_of_points = 0;
  954.  
  955.         // handle special case of singletons.  They'll be of the form "<value>;"
  956.         // read points until we reach the semicolon
  957.  
  958.         if (token[strlen(token) - 1] == ';')
  959.             {
  960.  
  961.             // replace semi with null so we can convert
  962.             token[strlen(token) - 1] = '\0';
  963.             x_point[num_of_points] = atof(token);
  964.             // set 'y' value to max
  965.              y_point[num_of_points]  = FuzzyVariableBase::get_dom_array_max_idx();
  966.  
  967.             num_of_points = 1;
  968.             }
  969.         else
  970.             {
  971.             // not a singleton, points are of the form "(<value> , <value>)"
  972.  
  973.             while (token[0] != ';')  
  974.                 {
  975.  
  976.                 x_point[num_of_points] = atof(token);
  977.  
  978.                 token = strtok(NULL, seps);
  979.  
  980.                 if (token[0] == ';') 
  981.                     {
  982.                     if (num_of_points != 0)
  983.                         {
  984.                         // ERROR - invalid format
  985.                         set_msg_text(ERR_INVALID_FILE_FORMAT); // could be a bit more "robuts" in our error reporting!
  986.                         return -1;
  987.                         }
  988.  
  989.                     // else singleton which is OK
  990.  
  991.                      y_point[num_of_points]  = 0; 
  992.                     num_of_points++;
  993.                     continue;
  994.                     } // end if ';' found
  995.  
  996.                  y_point[num_of_points]  = atof(token);
  997.  
  998.                 num_of_points++;
  999.  
  1000.                 token = strtok(NULL, seps);
  1001.                 } // end while still reading values
  1002.  
  1003.             } // end if not singleton
  1004.  
  1005.         // set the membership func dependent on the number of datapoints....
  1006.         int type;    // type of new member func
  1007.         switch(num_of_points)
  1008.             {
  1009.              case 1:
  1010.                  type = MemberFuncBase::TYPE::SINGLETON;
  1011.                 break;
  1012.             case 3:
  1013.                 type = MemberFuncBase::TYPE::TRIANGLE;
  1014.                 break;
  1015.             case 4:
  1016.                 type = MemberFuncBase::TYPE::TRAPEZOID;
  1017.                 break;
  1018.             case 7:
  1019.                 type = MemberFuncBase::TYPE::S_CURVE;
  1020.                 break;
  1021.             default:
  1022.                 return -1; // error
  1023.  
  1024.             } // end switch on num_of_points
  1025.  
  1026.         // create the set, note we put fake values for width and stuff cuz that'll get
  1027.         // set when we set the points
  1028.  
  1029.         wchar_t* wset_name = convert_to_wide_char(set_name);
  1030.  
  1031.          FuzzySetBase* set = new_set(wset_name, 0, this, num_of_sets, 0, type);
  1032.  
  1033.         delete[] wset_name;
  1034.  
  1035.         if (set == NULL)
  1036.             return -1; // error is in msg_text
  1037.  
  1038.         // set up the nodes...
  1039.  
  1040.            // loop points. Note we skip sanity checks set_node() uses
  1041.          for (int i = 0; i < num_of_points  ; i++)
  1042.             {
  1043.             // convert values to indexes...
  1044.             int x = convert_value_to_idx(x_point[i]);
  1045.             int y = y_point[i] * FuzzyVariableBase::get_dom_array_max_idx();
  1046.  
  1047.             set->set_node(i, x, y, false); // false indicates skip sanity checks
  1048.  
  1049.             } // end loop through points
  1050.  
  1051.         // need to call ModelBase version to set up the the rule array
  1052.         (get_parent())->add_set(index, set);
  1053.         
  1054.         delete set;
  1055.  
  1056.         }; // end while(1) loop
  1057.  
  1058.     return 0;
  1059.  
  1060. } // end FuzzyVariableBase::load_sets_from_file()
  1061.  
  1062.  
  1063. //
  1064. // Function: calc()
  1065. // 
  1066. // Purpose:    This function calculates the 'y' values for all the sets
  1067. //            associated with this variable
  1068. // 
  1069. // Arguments:
  1070. //
  1071. //        int set_idx -    index of the set to calculate for. If -1 (default value)
  1072. //                        do ALL the sets
  1073. //
  1074. // Returns:
  1075. //
  1076. //        void
  1077. // 
  1078. // Author:    Michael Zarozinski    
  1079. // Date:    1/21/99
  1080. // 
  1081. // Modification History
  1082. // Author        Date        Modification
  1083. // ------        ----        ------------
  1084. //
  1085. //
  1086.  
  1087. void FuzzyVariableBase::calc(int set_idx /* = -1 */)
  1088. {
  1089.     if (set_idx >= 0)
  1090.         {
  1091.         sets[set_idx]->calc();
  1092.         }
  1093.     else
  1094.         {
  1095.          for (int i = 0; i < num_of_sets; i++)
  1096.              sets[i]->calc();
  1097.         }
  1098.  
  1099. } // end FuzzyVariableBase::calc(void)
  1100.  
  1101.  
  1102.  
  1103. //
  1104. // Function: convert_idx_to_value()
  1105. // 
  1106. // Purpose:    This function converts an index (into the values[] array) to 
  1107. //            an 'x' value between left_x and right_x for this variable
  1108. // 
  1109. // Arguments:
  1110. //
  1111. //        int idx -    index to convert to a value
  1112. //
  1113. // Returns:
  1114. //
  1115. //        RealType - x value for the index passed in
  1116. // 
  1117. // Author:    Michael Zarozinski    
  1118. // Date:    1/99
  1119. // 
  1120. // Modification History
  1121. // Author        Date        Modification
  1122. // ------        ----        ------------
  1123. // Michael Z    10/23/01    Added sanity checks
  1124. //
  1125. //
  1126.  
  1127. RealType FuzzyVariableBase::convert_idx_to_value(int idx) const
  1128. {
  1129.     assert(idx >= 0);
  1130.     assert(idx <= FuzzyVariableBase::get_x_array_count());
  1131.  
  1132.     // make sure index is within range
  1133.     if (idx < 0)
  1134.         idx = 0;
  1135.     if (idx > FuzzyVariableBase::get_x_array_max_idx())
  1136.         idx = FuzzyVariableBase::get_x_array_max_idx();
  1137.  
  1138.     return left_x + (idx * get_idx_multiplier());
  1139. };
  1140.  
  1141. //
  1142. // Function: convert_value_to_idx()
  1143. // 
  1144. // Purpose:    This function converts the 'x' value passed in to
  1145. //            an index (into the values[] array) 
  1146. // 
  1147. // Arguments:
  1148. //
  1149. //        RealType - x value to convert
  1150. //
  1151. // Returns:
  1152. //
  1153. //        ValuesArrCountType idx -    index for the value
  1154. // 
  1155. // Author:    Michael Zarozinski    
  1156. // Date:    1/99
  1157. // 
  1158. // Modification History
  1159. // Author        Date        Modification
  1160. // ------        ----        ------------
  1161. // Michael Z    10/23/01    Added sanity checks
  1162. //
  1163. //
  1164.  
  1165. ValuesArrCountType FuzzyVariableBase::convert_value_to_idx(RealType value) const
  1166. {
  1167.     // add .5 so any floating point values get rounded correctly when converting to int
  1168.     int idx = ((value -  get_left_x()) / get_idx_multiplier()) + .5;
  1169.  
  1170.     // make sure index is within range
  1171.     if (idx < 0)
  1172.         idx = 0;
  1173.     if (idx > FuzzyVariableBase::get_x_array_max_idx())
  1174.         idx = FuzzyVariableBase::get_x_array_max_idx();
  1175.  
  1176.     return idx;
  1177. };
  1178.  
  1179.  
  1180. //
  1181. // Function: init()
  1182. // 
  1183. // Purpose:    Perform common variable initialization
  1184. // 
  1185. // Arguments:
  1186. //
  1187. //        const wchar_t*    _id                    -    identifier for the variable
  1188. //        RealType        _left_x                -    left x value
  1189. //        RealType        _right_x            -    right x value
  1190. //        bool            create_unique_id    -    if true, alter the identifier (if needed) to make it unique) default = true
  1191. //
  1192. // Returns:
  1193. //
  1194. //        0 - success
  1195. //        non-zero - failure
  1196. // 
  1197. // Author:    Michael Zarozinski    
  1198. // Date:    1/99
  1199. // 
  1200. // Modification History
  1201. // Author        Date        Modification
  1202. // ------        ----        ------------
  1203. //
  1204. //
  1205.         
  1206. int FuzzyVariableBase::init(const wchar_t* _id, RealType _left_x, RealType _right_x, bool create_unique_id /* = true */)
  1207. {
  1208.     if (set_left_x(_left_x))
  1209.         return -1;
  1210.  
  1211.     if (set_right_x(_right_x))
  1212.         return -1;
  1213.  
  1214.     if (init(_id, create_unique_id)) // virtual func to set in/out var appropriately
  1215.         return -1;
  1216.  
  1217.     calc();
  1218.  
  1219.     return 0;
  1220.  
  1221. } // end FuzzyVariableBase::init()
  1222.  
  1223.  
  1224. //
  1225. // Function: init()
  1226. // 
  1227. // Purpose:    Initialize variable identifier and make it unique if applicable
  1228. // 
  1229. // Arguments:
  1230. //
  1231. //        const wchar_t*    _id                    -    identifier for the variable
  1232. //        bool            create_unique_id    -    if true, alter the identifier (if needed) to make it unique) default = true
  1233. //
  1234. // Returns:
  1235. //
  1236. //        0 - success
  1237. //        non-zero - failure
  1238. // 
  1239. // Author:    Michael Zarozinski    
  1240. // Date:    1/99
  1241. // 
  1242. // Modification History
  1243. // Author        Date        Modification
  1244. // ------        ----        ------------
  1245. //
  1246. //
  1247.         
  1248. int FuzzyVariableBase::init(const wchar_t* _id, bool create_unique_id /* = true */)
  1249. {
  1250.     int name_len;    // length of the name
  1251.  
  1252.     if (_id == NULL)
  1253.         name_len = 30;
  1254.     else
  1255.         name_len = wcslen(_id) + 5;
  1256.  
  1257.     wchar_t* tmp_name = new wchar_t[name_len]; // temp var to hold var name
  1258.  
  1259.     // if no name is passed in name it "Variable 0"
  1260.      if (_id == NULL)
  1261.         swprintf(tmp_name, L"%s 1", load_string(STR_VARIABLE));  
  1262.      else
  1263.         swprintf(tmp_name, L"%s", _id );  
  1264.      
  1265.      // set the name.  NOTE: this set_id() performs a check to ensure that the variable name is UNIQUE
  1266.     // for this model.  
  1267.  
  1268.     int ret_value; // return value
  1269.  
  1270.     if (!create_unique_id)
  1271.         {
  1272.         ret_value = set_id(tmp_name);
  1273.         }
  1274.     else
  1275.         {
  1276.         ret_value = 0;
  1277.  
  1278.          int counter = 1; // value to add to identifier to make it unique
  1279.  
  1280.         while (set_id(tmp_name))
  1281.             {
  1282.             // rename variable...
  1283.             if (_id == NULL)
  1284.                 swprintf(tmp_name, L"%s %d", load_string(STR_VARIABLE), counter  );  
  1285.              else
  1286.                 swprintf(tmp_name, L"%s %d", _id, counter );  
  1287.  
  1288.             counter++;
  1289.  
  1290.             // clear message text (should say "var not unique" right now)
  1291.             set_msg_text();
  1292.             
  1293.             } // end while !unique id
  1294.  
  1295.         }// end if rename var if not unique
  1296.  
  1297.     // free memory
  1298.     delete[] tmp_name;
  1299.  
  1300.     return ret_value;
  1301.  
  1302. } // end FuzzyVariableBase::init()
  1303.  
  1304.  
  1305. /////////////////////////////////////////////////////////////////////
  1306. ////////// Trivial Functions That Don't Require Headers /////////////
  1307. /////////////////////////////////////////////////////////////////////
  1308.         
  1309. void FuzzyVariableBase::move_node(int set_idx, int  idx, _point pt)
  1310. {
  1311.      sets[set_idx]->move_node( idx, pt);
  1312. };
  1313.  
  1314. void FuzzyVariableBase::move_node(int set_idx, int  idx, int x, int y)
  1315. {
  1316.       sets[set_idx]->move_node( idx, x, y);
  1317. };
  1318.         
  1319. FuzzySetBase* FuzzyVariableBase::get_set(int idx) const
  1320. {
  1321.     return((idx < num_of_sets)? sets[idx] : NULL);
  1322. }; 
  1323.         
  1324. int FuzzyVariableBase::get_num_of_sets(void) const 
  1325. {
  1326.     return(num_of_sets);
  1327. };
  1328.         
  1329. FFLL_INLINE short FuzzyVariableBase::get_index() const
  1330. {
  1331.     return index;
  1332. };
  1333. FFLL_INLINE void FuzzyVariableBase::set_index(int idx)
  1334. { 
  1335.     index = static_cast<short>(idx);
  1336. }; 
  1337.          
  1338. FuzzyModelBase* FuzzyVariableBase::get_parent(void) const
  1339. {
  1340.     return static_cast< FuzzyModelBase*>(FFLLBase::get_parent());
  1341. };
  1342.  
  1343.  
  1344. const wchar_t* FuzzyVariableBase::get_id(int set_idx /* = -1 */) const
  1345. {
  1346.     if (set_idx == -1)
  1347.         return((id == L"") ? NULL : id.data()); 
  1348.     else
  1349.         {
  1350.         FuzzySetBase* set = get_set(set_idx);
  1351.         return set->get_id(); 
  1352.         }
  1353.  
  1354. };  
  1355.  
  1356.  
  1357. int FuzzyVariableBase::get_rule_index(int _set_idx /* = -1 */) const
  1358. {
  1359.     if (_set_idx == -1)
  1360.         return rule_index;
  1361.  
  1362.     return sets[_set_idx]->get_rule_index();
  1363. };  
  1364.  
  1365. DOMType FuzzyVariableBase::get_dom(int set_idx, int x_position /* = -1 */) const
  1366. {
  1367.     if (sets)
  1368.         return sets[set_idx]->get_dom(x_position);  
  1369.     else
  1370.         return 0;
  1371. };
  1372.         
  1373. void FuzzyVariableBase::set_rule_index(int _rule_index, int set_idx /* = -1 */)
  1374. {
  1375.     if (set_idx == -1)
  1376.         rule_index = _rule_index;
  1377.     else
  1378.         {
  1379.         FuzzySetBase* set = get_set(set_idx);
  1380.         set->set_rule_index(_rule_index);
  1381.         } // end if set rule_index for set
  1382.  
  1383. };  
  1384.  
  1385. std::string FuzzyVariableBase::get_model_name() const
  1386. {
  1387.      return get_parent()->get_model_name();
  1388. };
  1389.  
  1390. RealType FuzzyVariableBase::get_idx_multiplier() const
  1391. {
  1392.     return idx_multiplier;
  1393. };
  1394.  
  1395. void FuzzyVariableBase::move(int set_idx, int node_idx, int new_x)
  1396. {
  1397.     // need to calc the 'x' delta...
  1398.     int x_delta = new_x - sets[set_idx]->get_node_x(node_idx);
  1399.  
  1400.     sets[set_idx]->move(x_delta);
  1401. };
  1402.  
  1403. bool FuzzyVariableBase::is_output() const 
  1404. {
  1405.     return false;
  1406. }; 
  1407.         
  1408. const char* FuzzyVariableBase::get_fcl_block_start() 
  1409. { 
  1410.     return "VAR_INPUT"; 
  1411. }         
  1412. const char* FuzzyVariableBase::get_fcl_block_end() 
  1413. { 
  1414.     return "END_VAR"; 
  1415. } 
  1416.  
  1417. RealType FuzzyVariableBase::get_left_x() const 
  1418. {    
  1419.     return left_x;
  1420. }
  1421. RealType FuzzyVariableBase::get_right_x() const 
  1422. {    
  1423.     return right_x;
  1424. } 
  1425.  
  1426. ValuesArrCountType FuzzyVariableBase::get_x_array_count() 
  1427. {    
  1428.     return x_array_count;
  1429. };
  1430. ValuesArrCountType FuzzyVariableBase::get_x_array_max_idx()
  1431. {    
  1432.     return x_array_max_idx;
  1433. };
  1434.  
  1435. DOMType FuzzyVariableBase::get_dom_array_count()
  1436. {    
  1437.     return dom_array_count;
  1438. };
  1439. DOMType FuzzyVariableBase::get_dom_array_max_idx()
  1440. {    
  1441.     return     dom_array_max_idx;
  1442. };
  1443.  
  1444.  
  1445. FuzzySetBase* FuzzyVariableBase::new_set()
  1446. {
  1447.     return new FuzzySetBase(this);
  1448. };
  1449.  
  1450. FuzzySetBase* FuzzyVariableBase::new_set(wchar_t* n, int mid_pt_x, FuzzyVariableBase* par, short index, int set_width, int type)
  1451. {
  1452.     FuzzySetBase* tmp = new_set(); // virtual function
  1453.     
  1454.     tmp->init(n, mid_pt_x, index, set_width, type);
  1455.  
  1456.     return tmp;
  1457.  
  1458. };  
  1459.