tfuzzycontroller.cpp

人工智能中模糊逻辑算法 FuzzyLib 2.0 is a comprehensive C++ Fuzzy Logic library for constructing fuzzy logic sy

////////////////////////////////////////////////////////////////////////////////
#include "TFuzzyController.h"
////////////////////////////////////////////////////////////////////////////////

#include "RulesEditorFrm.h"


TFuzzyController::TFuzzyController()
{
  for (int i=0; i<MAX_PREMISES_PER_PREDICATE; i++)
  {
   	input_variables[i] = NULL;
  }
  for (int i=0; i<MAX_RULES_PER_CONTROLLER; i++)
  {
   	rules[i] = NULL;
  }
}


TFuzzyController::~TFuzzyController()
{
  clear_input_variables();
  clear_rules();
}




void TFuzzyController::clear_input_variables()
{
  for (int i=0; i<MAX_PREMISES_PER_PREDICATE; i++)
  {
  	if (input_variables[i] != NULL) delete input_variables[i];
   	input_variables[i] = NULL;
  }
}


void TFuzzyController::add_input_variable(TVariable* variable)
{
  for (int i=0; i<MAX_PREMISES_PER_PREDICATE; i++)
  {
  	if (input_variables[i] == NULL)
    {
		input_variables[i] = variable;
  	    break;
    }
  }
}


void TFuzzyController::remove_input_variable(TVariable* variable)
{
  for (int i=0; i<MAX_PREMISES_PER_PREDICATE; i++)
  {
  	if (*(input_variables[i]) == *variable)
    {
		delete input_variables[i];
		// shift up
		for (int j=i; j<MAX_PREMISES_PER_PREDICATE-1; j++)
    	{
			input_variables[j] = input_variables[j+1];
	    }
		// invalidate last
        input_variables[MAX_PREMISES_PER_PREDICATE-1] = NULL;
        break;
    }
  }
}


void TFuzzyController::edit_input_variables()
{
//
}






void TFuzzyController::clear_rules()
{
  for (int i=0; i<MAX_RULES_PER_CONTROLLER; i++)
  {
  	if (rules[i] != NULL) delete rules[i];
   	rules[i] = NULL;
  }
}


void TFuzzyController::add_rule(TFuzzyRule* rule)
{
  for (int i=0; i<MAX_RULES_PER_CONTROLLER; i++)
  {
  	if (rules[i] == NULL)
    {
		rules[i] = rule;
  	    break;
    }
  }
}

void TFuzzyController::remove_rule(TFuzzyRule* rule)
{
  for (int i=0; i<MAX_RULES_PER_CONTROLLER; i++)
  {
  	if (*(rules[i]) == *rule)
    {
		delete rules[i];
		// shift up
		for (int j=i; j<MAX_RULES_PER_CONTROLLER-1; j++)
    	{
			rules[j] = rules[j+1];
	    }
		// invalidate last
        rules[MAX_RULES_PER_CONTROLLER-1] = NULL;
        break;
    }
  }
}


void TFuzzyController::edit_rules()
{
    RulesEditorForm->FuzzyController = this;
    RulesEditorForm->Show();    // loads this->rules for editing
}





TFuzzySet* TFuzzyController::GenerateOutputSet(
			   				int aggregation_method,		// ZADEH, MEAN, ... PRODUCT, BONDEDSUM
    	            	    int correlation_method,		// TRUNCATE, SCALE
	    	       			int alphaCut_type,	   		// STRONG, WEAK
            	        	int composition_method 		// ZADEH, MEAN, ... PRODUCT, BONDEDSUM
						  )
{
	TFuzzySet* rules_results[MAX_RULES_PER_CONTROLLER];
	for (int i=0; i<MAX_RULES_PER_CONTROLLER; i++)
	{
		rules_results[i] = NULL;
	}

    // for each rule, correlate inputs to output, apply weight, apply alphaCut
	for (int i=0; i<MAX_RULES_PER_CONTROLLER; i++)
	{
		if (rules[i] != NULL)
		{
			rules_results[i] = rules[i]->Evaluate(aggregation_method, correlation_method, alphaCut_type);
		}
		else
		{
			break;
		}
	}



	// rules_results composition ---> output_set
    TFuzzySet* output_set = NULL;

	if (rules_results[0] != NULL)
	{
		output_set = new TFuzzySet(*rules_results[0]);

		for (int i=1; i<MAX_RULES_PER_CONTROLLER; i++)
		{
			if ((rules[i] != NULL) && (rules_results[i] != NULL))
			{
				*output_set = output_set->or(*(rules_results[i]), composition_method);
			}
			else
			{
				break;
			}
		}
	}

	return output_set;
}




double TFuzzyController::GenerateOutput(
			   				int aggregation_method,		// ZADEH, MEAN, ... PRODUCT, BONDEDSUM
    	            	    int correlation_method,		// TRUNCATE, SCALE
	    	       			int alphaCut_type,	   		// STRONG, WEAK
            	        	int composition_method,		// ZADEH, MEAN, ... PRODUCT, BONDEDSUM
	                        int defuzzification_method	// CENTROID, MAXIMUM_HIGHT, ...
						  )
{
	double output = INVALID_DOMAIN;

    TFuzzySet* output_set = GenerateOutputSet(aggregation_method, correlation_method, alphaCut_type, composition_method);
    if (output_set != NULL)
    {
	    output = output_set->defuzzify(defuzzification_method);
    }
    delete output_set;

	return output;
}





bool  TFuzzyController::operator ==	(TFuzzyController& controller2)	// comparison
{
	for (int i=0; i<MAX_PREMISES_PER_PREDICATE-1; i++)
   	{
    	if (!(input_variables[i] == controller2.input_variables[i])) return false;
    }
	for (int i=0; i<MAX_RULES_PER_CONTROLLER; i++)
	{
    	if (!(rules[i] == controller2.rules[i])) return false;
    }
   	return true;
}
////////////////////////////////////////////////////////////////////////////////