fuzzynumber.cs

包括Pheromones Algorythm、Memory Algorythm和Hill Climbing Algorythm I

using System;

namespace Fuzzy_Logic_Library
{
	/// <summary>
	/// Fuzzy number class deals with fuzzy numbers
	/// </summary>
	public class FuzzyNumber : FuzzyBasic
	{

		public FuzzyNumber() : base()
		{
			//
			// TODO: Add constructor logic here
			//
		}

		public FuzzyNumber( double number ) : base()
		{
			Number = number;
		}

		public FuzzyNumber( FuzzyNumber fuzzy ) : base()
		{
			this.ID = fuzzy.ID;
			this.Maximum = fuzzy.Maximum;
			this.Membership = fuzzy.Membership;
			this.Minimum = fuzzy.Minimum;
			this.Name = fuzzy.Name;
			this.Number = fuzzy.Number;
		}

		public FuzzyNumber( double rangeLow, double rangeHigh ) : base()
		{
			Minimum = rangeLow;
			Maximum = rangeHigh;
			Number = rangeLow + ( ( rangeHigh - rangeLow ) /2 );
			Membership = 1.0;
		}

		public FuzzyNumber( double number, double rangeLow, double rangeHigh ) : base()
		{
			Minimum = rangeLow;
			Maximum = rangeHigh;
			Number = number;
			Membership = 0.0;
			SetMembership();
		}

		public FuzzyNumber( string name, double number )
		{
			Minimum = number - 10;
			Maximum = number + 10;
			Number = number;
			SetMembership();
			Name = name;
		}

		public FuzzyNumber( string name, double number, double rangeLow, double rangeHigh ) : base()
		{
			Minimum = rangeLow;
			Maximum = rangeHigh;
			Number = number;
			SetMembership();
			Name = name;
		}

		public FuzzyNumber( string name, double rangeLow, double rangeHigh ) : base()
		{
			Minimum = rangeLow;
			Maximum = rangeHigh;
			Number = rangeLow + ( ( rangeHigh - rangeLow ) / 2 );
			Membership = 1.0;
			Name = name;
		}

		public FuzzyNumber( string name, double number, double rangeLow, double rangeHigh, bool bUseMaxAsComplete ) : base()
		{
			Minimum = rangeLow;
			if( bUseMaxAsComplete == true )
				Maximum = rangeHigh + rangeHigh;
			else
				Maximum = rangeHigh;

			Number = number;
			Membership = 0.0;
			Name = name;
			SetMembership();
		}


		public override string ToString()
		{
			return base.ToString() + ", Number = " + Number.ToString() + ", Minimum = " + Minimum.ToString() + ", Maximum = " + Maximum.ToString() + ", Membership = " + Membership.ToString();
		}


		/// <summary>
		/// Overloaded operators Note no attempt is made to check for minimum and maximum
		/// values this is up to the code using the class 
		/// </summary>

		public static FuzzyNumber operator +( FuzzyNumber num, double number )
		{
			FuzzyNumber fuzzTemp = new FuzzyNumber( num.Number + number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator +( FuzzyNumber num, FuzzyNumber number )
		{
			FuzzyNumber fuzzTemp = new FuzzyNumber( num.Number + number.Number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator -( FuzzyNumber num, double number )
		{
			FuzzyNumber fuzzTemp = new FuzzyNumber( num.Number - number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator -( FuzzyNumber num, FuzzyNumber number )
		{
			FuzzyNumber fuzzTemp = new FuzzyNumber( num.Number - number.Number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator *( FuzzyNumber num, double number )
		{
			FuzzyNumber fuzzTemp;
			if( num.Number == 0.0 || number == 0.0 )
			{
				fuzzTemp = new FuzzyNumber( num.Number, num.Minimum, num.Maximum );
				fuzzTemp.SetMembership();
				return fuzzTemp;
			}

			fuzzTemp = new FuzzyNumber( num.Number * number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator *( FuzzyNumber num, FuzzyNumber number )
		{
			FuzzyNumber fuzzTemp;
			if( num.Number == 0.0 || number.Number == 0.0 )
			{
				fuzzTemp = new FuzzyNumber( num.Number, num.Minimum, num.Maximum );
				fuzzTemp.SetMembership();
				return fuzzTemp;
			}

			fuzzTemp = new FuzzyNumber( num.Number * number.Number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator /( FuzzyNumber num, double number )
		{
			FuzzyNumber fuzzTemp;
			if( num.Number == 0.0 || number == 0.0 )
			{
				fuzzTemp = new FuzzyNumber( num.Number, num.Minimum, num.Maximum );
				fuzzTemp.SetMembership();
				return fuzzTemp;
			}

			fuzzTemp = new FuzzyNumber( num.Number / number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator /( FuzzyNumber num, FuzzyNumber number )
		{
			FuzzyNumber fuzzTemp;
			if( num.Number == 0.0 || number.Number == 0.0 )
			{
				fuzzTemp = new FuzzyNumber( num.Number, num.Minimum, num.Maximum );
				fuzzTemp.SetMembership();
				return fuzzTemp;
			}

			fuzzTemp = new FuzzyNumber( num.Number / number.Number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator %( FuzzyNumber num, double number )
		{
			FuzzyNumber fuzzTemp;
			if( num.Number == 0.0 || number == 0.0 )
			{
				fuzzTemp = new FuzzyNumber( num.Number, num.Minimum, num.Maximum );
				fuzzTemp.SetMembership();
				return fuzzTemp;
			}

			fuzzTemp = new FuzzyNumber( num.Number % number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}

		public static FuzzyNumber operator %( FuzzyNumber num, FuzzyNumber number )
		{
			FuzzyNumber fuzzTemp;
			if( num.Number == 0.0 || number.Number == 0.0 )
			{
				fuzzTemp = new FuzzyNumber( num.Number, num.Minimum, num.Maximum );
				fuzzTemp.SetMembership();
				return fuzzTemp;
			}

			fuzzTemp = new FuzzyNumber( num.Number % number.Number, num.Minimum, num.Maximum );
			fuzzTemp.SetMembership();
			return fuzzTemp;
		}
	}

	/// <summary>
	/// The fuzzy set class for holding and manipulating fuzzy numbers
	/// </summary>
	public class FuzzyNumberSet : FuzzySet
	{
		private double setValue;

		public double FuzzySetValue
		{
			get
			{
				return setValue;
			}
			set
			{
				setValue = value;
				UpdateSetValue();
			}
		}
		
		/// <summary>
		/// basic constructor
		/// </summary>
		public FuzzyNumberSet() : base()
		{
		}

		/// <summary>
		///  conbstructor that creates a number of empty fuzzy numbers
		/// </summary>
		/// <param name="nNumberCount"></param>
		public FuzzyNumberSet( int nNumberCount ) : base()
		{

			for( int i=0; i<nNumberCount; i++ )
			{
				FuzzyNumber temp = new FuzzyNumber();
				FuzzyArray.Add( temp );
			}
		}

		/// <summary>
		/// constructor that takes the first fuzzy number
		/// </summary>
		/// <param name="fuzzyNum"></param>
		public FuzzyNumberSet( FuzzyNumber fuzzyNum ) : base()
		{
			FuzzyArray.Add( fuzzyNum );
		}

		/// <summary>
		/// constructor that takes the values for the first fuzzy number
		/// </summary>
		/// <param name="number"></param>
		/// <param name="minimum"></param>
		/// <param name="maximum"></param>
		public FuzzyNumberSet( double number, double minimum, double maximum ) : base()
		{
			FuzzyNumber temp = new FuzzyNumber( number, minimum, maximum );
			FuzzyArray.Add( temp );
		}

		

		/// <summary>
		///  get the name of the current value of the set
		/// </summary>
		/// <returns></returns>
		public override string GetTerm()
		{
			for( int i=0; i<this.Count; i++ )
			{
				FuzzyNumber temp = ( FuzzyNumber )FuzzyArray[ i ];
				if( temp.Number == this.FuzzySetValue )
				{
					return temp.Name;
				}
			}

			return null;
		}




		/// <summary>
		///  Is the current value within the specified term ( name of the fuzzy number )
		///  
		/// </summary>
		/// <param name="strTerm">name of the fuzzy number that the value is supposed to be within</param>
		/// <returns>true or false</returns>
		public override bool IsTerm( string strTerm )
		{
			for( int i=0; i<this.Count; i++ )
			{
				if( ( ( FuzzyBasic )FuzzyArray[ i ] ).Name == strTerm )
				{
					FuzzyBasic temp = ( FuzzyBasic )FuzzyArray[ i ];
					if( temp.Maximum >= this.setValue && temp.Minimum <= this.setValue )
					{
						return true;
					} 
					else
						return false;
				}
			}

			return false;
		}

		/// <summary>
		/// gets the default membership value for the term ie when membership == 1
		/// therefore gets the middle value
		/// </summary>
		/// <param name="strTerm"></param>
		/// <returns></returns>
		public override double ValueFromTerm( string strTerm )
		{
			for( int i=0; i<this.Count; i++ )
			{
				FuzzyNumber temp = ( FuzzyNumber )FuzzyArray[ i ];
				if( temp.Name == strTerm )
				{
					return ( temp.Maximum - ( ( temp.Maximum - temp.Minimum ) / 2 ) );
				}
			}

			return 0.0;
		}



		/// <summary>
		///  Set the value for the Set to the Name of a passed in fuzzy number
		/// </summary>
		/// <param name="strTerm"></param>
		public override void SetToTerm( string strTerm )
		{
			this.FuzzySetValue = ValueFromTerm( strTerm );
		}


		/// <summary>
		/// update the individual fuzzy numbers when the set value changes
		/// </summary>
		private void UpdateSetValue()
		{
			for( int i=0; i<this.Count; i++ )
			{
				if( this.FuzzySetValue <= ( ( FuzzyNumber )FuzzyArray[ i ] ).Maximum  
					&& this.FuzzySetValue >= ( ( FuzzyNumber )FuzzyArray[ i ] ).Minimum )
				{
					( ( FuzzyNumber )FuzzyArray[ i ] ).Number = this.FuzzySetValue;
				}
				else
					( ( FuzzyNumber )FuzzyArray[ i ] ).Number = 0.0;