home *** CD-ROM | disk | FTP | other *** search
/ AI Game Programming Wisdom / AIGameProgrammingWisdom.iso / SourceCode / 02 Useful Techniques / 08 Zarozinski / src / ffllapi / FuzzySetBase.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-11-13  |  5.2 KB  |  156 lines
  1.  
  2. //
  3. // File:    FuzzySetBase.h
  4. //
  5. // Purpose:    This is the base class for the Fuzzy sets.  It is the ancestor of
  6. //            all set classes
  7. //
  8. // Copyright ⌐ 1999-2001 Louder Than A Bomb! Software
  9. //
  10. // This file is part of the FFLL (Free Fuzzy Logic Library) project (http://ffll.sourceforge.net)
  11. // It is released under the BSD license, see http://ffll.sourceforge.net/license.txt for the full text.
  12. //
  13.  
  14. #if !defined(AFX_FuzzySetBase_H__F5CADA04_27CC_11D3_B77E_B09059C10001__INCLUDED_)
  15. #define AFX_FuzzySetBase_H__F5CADA04_27CC_11D3_B77E_B09059C10001__INCLUDED_
  16.  
  17. class MemberFuncBase;
  18. class FuzzyVariableBase;
  19. class FuzzyModelBase;
  20.  
  21. #include "FFLLBase.h"
  22.  
  23. // 
  24. // Class:    FuzzySetBase
  25. //
  26. // This class is the base class for all sets. It's used (without desendents) in 
  27. // the output variables. It contains a pointer to a member func class that holds
  28. // the specific information for the curve that defines the set.
  29. //
  30.  
  31. class FFLL_API  FuzzySetBase : virtual  public FFLLBase  
  32. { 
  33.     ////////////////////////////////////////
  34.     ////////// Member Functions ////////////
  35.     ////////////////////////////////////////
  36.     
  37.     public:
  38.  
  39.         // constructor/destructor funcs
  40.         FuzzySetBase(); // No function body for this. Explicitly disallow auto-creation of it by the compiler
  41.          FuzzySetBase(FuzzyVariableBase* par);
  42.         virtual ~FuzzySetBase();
  43.         int init(const wchar_t* n, int mid_pt_x, short idx, int set_width, int type );
  44.          virtual int copy(const FuzzySetBase& copy_from);
  45.           virtual FuzzySetBase& operator=(const FuzzySetBase& copy_from);
  46.  
  47.         // get functions
  48.  
  49.         std::string get_model_name() const;
  50.         const wchar_t* get_id(void) const;
  51.         NodePoint get_node(int idx);
  52.         int get_node_count() const ;
  53.         int get_var_index() const;
  54.         int get_end_x(void) const;
  55.         int get_start_x(void) const;
  56.         int get_func_type() const;
  57.          int get_ramp();
  58.         int get_node_x(int node_idx) const;
  59.         int get_rule_index() const;
  60.         RealType get_idx_multiplier() const;
  61.         RealType  get_left_x() const; 
  62.         void set_index(int _idx);
  63.         DOMType get_value(int idx) const;
  64.         DOMType get_index() const;
  65.         virtual DOMType get_dom(int idx) const;
  66.  
  67.         // Set Functions
  68.  
  69.         int set_id(const wchar_t* _id, bool allow_dup = false);
  70.         void set_ramp(int hi_lo_ind, int left_right_ind);
  71.         void set_node(int idx, int x, int y, bool validate = false);
  72.         void set_member_func(void* new_func);
  73.         void set_rule_index(int idx);
  74.  
  75.         // misc funcs
  76.  
  77.         bool is_output() const ;
  78.         RealType FuzzySetBase::convert_idx_to_value(int idx) const;
  79.         virtual int new_member_func(int type, int start_x, int width);
  80.          virtual int new_member_func(int type);
  81.          void move_node(int anchor_idx, _point pt);
  82.           void move_node(int anchor_idx, int x, int y);
  83.           void move(int x_delta);
  84.          virtual void calc();
  85.          virtual void expand(int x_delta);
  86.         virtual void shrink(int x_delta);
  87.    
  88.         // save/load functions
  89.  
  90.         void save_to_fcl_file(std::ofstream& file_contents);
  91.  
  92.      protected:
  93.  
  94.         // get funcs
  95.          FuzzyModelBase* get_rule_block(); 
  96.  
  97.         // misc funcs
  98.          FuzzyVariableBase* get_parent() const;
  99.          bool is_set_id_unique() const;
  100.  
  101.  
  102.     ////////////////////////////////////////
  103.     ////////// Class Variables /////////////
  104.     ////////////////////////////////////////
  105.  
  106.     protected:
  107.          MemberFuncBase*    member_func;    // member function for this set. MemberFuncBase is an abstract
  108.                                         // class.
  109.  
  110.     private:
  111.  
  112.         std::wstring    id;            // name of the variable 
  113.         DOMType            index;        // idex for this set within it's variable
  114.         int                rule_index;    // this is the offset into memory for this set.  it's
  115.                                     // used to speed access to the rules.
  116.                                     // this value is ADDED to the index of the set in the
  117.                                     // preceeding variable.
  118.                                     // For example, if we have a 3x3x3 system (3 input variables 
  119.                                     // of 3 sets each) there would be 27 total rules.
  120.                                     // The rule_indexes would be:
  121.                                     // Variable 1:
  122.                                     //        set 1:    0
  123.                                     //        set 2:    9
  124.                                     //        set 3: 18
  125.                                     // Variable 2:
  126.                                     //        set 1: 0
  127.                                     //        set 2: 3
  128.                                     //        set 3: 6
  129.                                     // Variable 3:
  130.                                     //        set 1: 0
  131.                                     //        set 2: 1
  132.                                     //        set 3: 2
  133.                                     //
  134.                                     // so the rule index corresponding to [2][1][1] = 18 + 3 + 1 = 22
  135.                                     // NOTE: remember indexes start at 0 so index [2] = set 3!
  136.                                     //
  137.                                     // This means that everytime we calculate a rule index we have
  138.                                     // to incurr (n - 1) additions.  This isn't too bad considering 
  139.                                     // the alternative.  We made this consession to save on memory,
  140.                                     // since we're using 'unsigned short' each rule element only takes
  141.                                     // up one byte.  There are many other ways to store this information
  142.                                     // which are much more memory intensive.  The absolute fastest/most
  143.                                     // efficient way would be to access the memory via the [] operator(s)
  144.                                     // but to do that we'd need to know the number of dimensions at the 
  145.                                     // time we declare the memory (unsigned short*** array; for a 3d example)
  146.                                     // but (to my knowledge) there's no way (short of a HUGE 'case' statement)
  147.                                     // to set this at runtime.
  148.  
  149. }; // end class FuzzySetBase
  150.  
  151. #else
  152.  
  153. class FuzzySetBase; // already defined
  154.  
  155. #endif // !defined(AFX_FuzzySetBase_H__F5CADA04_27CC_11D3_B77E_B09059C10001__INCLUDED_)
  156.