tfuzzyset.cpp

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

                    					+
										4 * ((truths[x] > set2.truths[x]) ? truths[x] : set2.truths[x])
		                            ) / 6.0), 2);
			}
		    result->minTruth  = pow(((
                    			2 * ((minTruth < set2.minTruth) ? minTruth : set2.minTruth)
                    			+
								4 * ((minTruth > set2.minTruth) ? minTruth : set2.minTruth)
                                ) / 6.0), 2);
		    result->maxTruth  = pow(((
                    			2 * ((maxTruth < set2.maxTruth) ? maxTruth : set2.maxTruth)
                    			+
								4 * ((maxTruth > set2.maxTruth) ? maxTruth : set2.maxTruth)
                                ) / 6.0), 2);
        }
        break;
		case MEANROOT:		//					((2*min(s1,s2)+4*max(s1,s2))/6)^.5
        {
			for (int x=0; x<DOMAIN_POINTS; x++)
			{
		   		result->truths[x] = pow(((
                    					2 * ((truths[x] < set2.truths[x]) ? truths[x] : set2.truths[x])
                    					+
										4 * ((truths[x] > set2.truths[x]) ? truths[x] : set2.truths[x])
                                    ) / 6.0), 0.5);
			}
		    result->minTruth  = pow(((
                    			2 * ((minTruth < set2.minTruth) ? minTruth : set2.minTruth)
                    			+
								4 * ((minTruth > set2.minTruth) ? minTruth : set2.minTruth)
                                ) / 6.0), 0.5);
		    result->maxTruth  = pow(((
                    			2 * ((maxTruth < set2.maxTruth) ? maxTruth : set2.maxTruth)
                    			+
								4 * ((maxTruth > set2.maxTruth) ? maxTruth : set2.maxTruth)
                                ) / 6.0), 0.5);
        }
        break;
		case PRODUCT:		//					(s1+s2)-(s1*s2)
        {
			for (int x=0; x<DOMAIN_POINTS; x++)
			{
		   		result->truths[x] = (truths[x] + set2.truths[x]) - (truths[x] * set2.truths[x]);
			}
		    result->minTruth  = (minTruth + set2.minTruth) - (minTruth * set2.minTruth);
		    result->maxTruth  = (maxTruth + set2.maxTruth) - (maxTruth * set2.maxTruth);
        }
        break;
		case BOUNDEDSUM:	//					min(1,(s1+s2))
        {
			for (int x=0; x<DOMAIN_POINTS; x++)
			{
		   		result->truths[x] = (1.0 < (truths[x] + set2.truths[x])) ? 1.0 : (truths[x] + set2.truths[x]);
			}
		    result->minTruth  = (1.0 < (minTruth + set2.minTruth)) ? 1.0 : (minTruth + set2.minTruth);
		    result->maxTruth  = (1.0 < (maxTruth + set2.maxTruth)) ? 1.0 : (maxTruth + set2.maxTruth);
        }
        break;
    }
	return *result;
}





TFuzzySet&	TFuzzySet::not(int type)
{
	TFuzzySet* result = new TFuzzySet(*this);
	switch(type)
   	{
		case ZADEH:			//					1-s1
		case MEAN:			//      	    	1-s1
		case MEANSQUARE:	//         			1-s1
		case MEANROOT:		//					1-s1
		case PRODUCT:		//					1-s1
		case BOUNDEDSUM:	//                  1-s1
        {
			for (int x=0; x<DOMAIN_POINTS; x++)
			{
   				result->truths[x] = 1.0 - truths[x];
			}
		    result->minTruth  = 1.0 - maxTruth;
		    result->maxTruth  = 1.0 - minTruth;
		         if (direction == UP)   result->direction = DOWN;
		    else if (direction == DOWN) result->direction = UP;
        }
        break;
    }
	return *result;
}


////////////////////////////////////////////////////////////////////////////////









////////////////////////////////////////////////////////////////////////////////
// operators
////////////////////////////////////////////////////////////////////////////////

bool       TFuzzySet::operator == 		(TFuzzySet& set2)   		 	  		// comparison
{
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		if (this->truths[x] != set2.truths[x]) return false;
	}
	return true;
}

bool       TFuzzySet::operator != 		(TFuzzySet& set2)   		 	  		// comparison
{
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		if (this->truths[x] != set2.truths[x]) return true;
	}
	return false;
}

bool	   TFuzzySet::operator <  		(TFuzzySet& set2)   		   			// comparison
{
    double integral1 = 0.0;
    double integral2 = 0.0;
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		integral1 += this->truths[x];
   		integral2 += set2.truths[x];
	}
	return (integral1 < integral2);
}

bool	   TFuzzySet::operator >  		(TFuzzySet& set2)   		   			// comparison
{
    double integral1 = 0.0;
    double integral2 = 0.0;
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		integral1 += this->truths[x];
   		integral2 += set2.truths[x];
	}
	return (integral1 > integral2);
}

bool	   TFuzzySet::operator <=  		(TFuzzySet& set2)   		   			// comparison
{
	return !(*this > set2);
}

bool	   TFuzzySet::operator >=  		(TFuzzySet& set2)   		   			// comparison
{
	return !(*this < set2);
}

TFuzzySet& TFuzzySet::operator =  		(TFuzzySet& set2)      					// assignment
{
	set_variable(set2.get_variable());
    if (set2.get_name() != NULL)
   	{
   		name	= new char[strlen(set2.get_name())+1];
        strcpy(name, set2.get_name());
   	}
	set_shape(set2.get_shape());
	set_direction(set2.get_direction());
	set_min (set2.get_min());
	set_mid1(set2.get_mid1());
	set_mid (set2.get_mid());
	set_mid2(set2.get_mid2());
	set_max (set2.get_max());
	set_minTruth(set2.get_minTruth());
	set_maxTruth(set2.get_maxTruth());
	for(int i=0; i<MAX_HEDGES; i++)    	hedges[i] = set2.hedges[i];
	for(int i=0; i<DOMAIN_POINTS; i++) 	truths[i] = set2.truths[i];
	set_alphaCut(set2.get_alphaCut());
	return *this;
}



TFuzzySet& 		 	  operator +  		(TFuzzySet& set1, TFuzzySet& set2)		// WARNING: maxTruth can be > 1.0
{
	TFuzzySet* result = new TFuzzySet(set1);
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		result->truths[x] = set1.truths[x] + set2.truths[x];
	}
    result->minTruth  = set1.minTruth + set2.minTruth;
    result->maxTruth  = set1.maxTruth + set2.maxTruth;
	return *result;
}

TFuzzySet& 		 	  operator +  		(TFuzzySet& set1, double shift)			// shift-up
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->shift_up(shift);
	return *result;
}

TFuzzySet& 		 	  operator +  		(double shift, TFuzzySet& set1)			// shift-up
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->shift_up(shift);
	return *result;
}


TFuzzySet& 		 	  operator -  		(TFuzzySet& set1, TFuzzySet& set2)		// WARNING: maxTruth can be > 1.0
{
	TFuzzySet* result = new TFuzzySet(set1);
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		result->truths[x] = set1.truths[x] - set2.truths[x];
	}
    result->minTruth  = set1.minTruth - set2.minTruth;
    result->maxTruth  = set1.maxTruth - set2.maxTruth;
	return *result;
}

TFuzzySet& 		 	  operator -  		(TFuzzySet& set1, double shift)			// shift-down
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->shift_down(shift);
	return *result;
}

TFuzzySet& 		 	  operator -  		(double shift, TFuzzySet& set1)			// shift-down
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->shift_down(shift);
	return *result;
}


TFuzzySet& 		 	  operator *  		(TFuzzySet& set1, TFuzzySet& set2)		// WARNING: maxTruth can be > 1.0
{
	TFuzzySet* result = new TFuzzySet(set1);
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		result->truths[x] = set1.truths[x] * set2.truths[x];
	}
    result->minTruth  = set1.minTruth * set2.minTruth;
    result->maxTruth  = set1.maxTruth * set2.maxTruth;
	return *result;
}

TFuzzySet& 			  operator *  		(TFuzzySet& set1, double factor)		// scale up
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->scale_up(factor);
	return *result;
}

TFuzzySet& 			  operator *  		(double factor, TFuzzySet& set1)		// scale up
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->scale_up(factor);
	return *result;
}


TFuzzySet& 		 	  operator /  		(TFuzzySet& set1, TFuzzySet& set2)		//
{
	TFuzzySet* result = new TFuzzySet(set1);
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		result->truths[x] = set1.truths[x] / set2.truths[x];
	}
    result->minTruth  = set1.minTruth / set2.minTruth;
    result->maxTruth  = set1.maxTruth / set2.maxTruth;
	return *result;
}

TFuzzySet& 			  operator /  		(TFuzzySet& set1, double percent)		// scale down
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->scale_down(percent);
	return *result;
}

TFuzzySet& 			  operator /  		(double percent, TFuzzySet& set1)		// scale down
{
	TFuzzySet* result = new TFuzzySet(set1);
    result->scale_down(percent);
	return *result;
}


TFuzzySet& 		 	  operator ^  		(TFuzzySet& set1, double power)			// hedge (dilute or intensify)
{
	TFuzzySet* result = new TFuzzySet(set1);
	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		result->truths[x] = pow(set1.truths[x], power);
	}
    result->minTruth  = pow(set1.minTruth, power);
    result->maxTruth  = pow(set1.maxTruth, power);
	return *result;
}


TFuzzySet& 		 	  operator && 		(TFuzzySet& set1, TFuzzySet& set2)  	// and
{
	return set1.and(set2);
}

TFuzzySet& 		 	  operator || 		(TFuzzySet& set1, TFuzzySet& set2)		// or
{
	return set1.or(set2);
}

TFuzzySet& 		 	  operator !  		(TFuzzySet& set1)						// not
{
	return set1.not();
}


double	   TFuzzySet::operator [] 		(double x)								// truth(double x)
{
	return truths[(int)x];
}


		   TFuzzySet::operator double 	()  									// defuzzify(CENTROID)
{
	return defuzzify();
}


ostream&   			  operator <<		(ostream& s, TFuzzySet& set1)			// save
{
	s << set1.variable->name  << " ";
	s << set1.variable->unit  << " ";
	s << set1.variable->begin << " ";
	s << set1.variable->end   << " ";
	s << set1.name      << " ";
    s << set1.shape     << " ";
	s << set1.direction << " ";
    s << set1.min       << " ";
	s << set1.mid1      << " ";
    s << set1.mid       << " ";
	s << set1.mid2      << " ";
    s << set1.max       << " ";
	s << set1.minTruth  << " ";
    s << set1.maxTruth  << " ";
	s << set1.alphaCut  << " ";
   	s << endl;

	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		s << set1.truths[x] << " ";
	}
    s << endl;

	for (int x=0; x<MAX_HEDGES; x++)
	{
   		s << set1.hedges[x] << " ";
	}
    s << endl;

	return s;
}



istream&   			  operator >>		(istream& s, TFuzzySet& set1)			// load
{
    char variable_name[256];	s >> variable_name; set1.variable->set_name(variable_name);
    char variable_unit[256];	s >> variable_unit; set1.variable->set_unit(variable_unit);
    s >> set1.variable->begin;
    s >> set1.variable->end;
    char name[256];				s >> name; 			set1.set_name(name);
	s >> set1.shape;
	s >> set1.direction;
    s >> set1.min;
	s >> set1.mid1;
    s >> set1.mid;
	s >> set1.mid2;
    s >> set1.max;
	s >> set1.minTruth;
	s >> set1.maxTruth;
    s >> set1.alphaCut;

	for (int x=0; x<DOMAIN_POINTS; x++)
	{
   		s >> set1.truths[x];
	}

	for (int x=0; x<MAX_HEDGES; x++)
	{
   		s >> set1.hedges[x];
	}

	return s;
}

////////////////////////////////////////////////////////////////////////////////












////////////////////////////////////////////////////////////////////////////////
// graphics
////////////////////////////////////////////////////////////////////////////////

void TFuzzySet::Draw(TCanvas* canvas)
{
	int XScale = 2;
	int YScale = 100;
	for (int x=0; x<DOMAIN_POINTS-1; x++)
   	{
		canvas->MoveTo(x*XScale, ((int)((1.0 - truths[x])*YScale)));
		canvas->LineTo((x+1)*XScale, ((int)((1.0 - truths[x+1])*YScale)));
    }
   	canvas->Refresh();
}

////////////////////////////////////////////////////////////////////////////////