Fuzzy Logic Vs Adaline Neural Network

using System;
using System.Collections;

namespace Fuzzy_Logic_Library
{
	/// <summary>
	/// Fuzzy pattern class basically a storage class for holding data
	/// completely ripped off from the pattern class in the neural network library
	/// </summary>
	public class FuzzyPattern
	{
		private ArrayList arrayInSet;
		private ArrayList arrayOutSet;
		private static int nPatternID = 0;
		private int nCurrentID;


		public FuzzyPattern()
		{
			//
			// TODO: Add constructor logic here
			//
			arrayInSet = new ArrayList();
			arrayOutSet = new ArrayList();
			nPatternID++;
			nCurrentID = nPatternID;

		}


		/// <summary>
		/// get the in set array
		/// </summary>
		public ArrayList InSet
		{
			get
			{
				return arrayInSet;
			}
		}

		/// <summary>
		/// get the out set array
		/// </summary>
		public ArrayList OutSet
		{
			get
			{
				return arrayOutSet;
			}
		}

		/// <summary>
		/// get the pattern id
		/// </summary>
		public int PatternID
		{
			get
			{
				return nCurrentID;
			}
		}


		/// <summary>
		/// constructor taking the array sizes
		/// </summary>
		/// <param name="nInSize"></param>
		/// <param name="nOutSize"></param>
		public FuzzyPattern( int nInSize, int nOutSize )
		{
			arrayInSet = new ArrayList( nInSize );
			for( int i=0; i<nInSize; i++ )
				arrayInSet.Add( 0.0 );
			arrayOutSet = new ArrayList( nOutSize );
			for( int i=0; i<nOutSize; i++ )
				arrayOutSet.Add( 0.0 );
			nPatternID++;
			nCurrentID = nPatternID;

		}

		/// <summary>
		/// constructor taking array lists
		/// </summary>
		/// <param name="arrayInSet"></param>
		/// <param name="arrayOutSet"></param>
		public FuzzyPattern( ArrayList arrayInSet, ArrayList arrayOutSet )
		{
			arrayInSet = arrayInSet;
			arrayOutSet = arrayOutSet;
			nPatternID++;
			nCurrentID = nPatternID;
		}


		public FuzzyPattern( double inputOne, double inputTwo, double output )
		{

			arrayInSet = new ArrayList();
			arrayInSet.Add( inputOne );
			arrayInSet.Add( inputTwo );
			arrayOutSet = new ArrayList();
			arrayOutSet.Add( output );

			nPatternID++;
			nCurrentID = nPatternID;

		}



		/// <summary>
		/// set the input value
		/// </summary>
		/// <param name="nIndex"></param>
		/// <param name="dValue"></param>
		public void SetInValue( int nIndex, double dValue )
		{
			if( nIndex < arrayInSet.Count )
				arrayInSet[ nIndex ] = dValue;
			else
				arrayInSet.Add( dValue );
		}

		/// <summary>
		/// set the output value
		/// </summary>
		/// <param name="nIndex"></param>
		/// <param name="dValue"></param>
		public void SetOutValue( int nIndex, double dValue )
		{

			if( nIndex < arrayOutSet.Count )
				arrayOutSet[ nIndex ] = dValue;
			else
				arrayOutSet.Add( dValue );
		}

		/// <summary>
		/// get the input value at the given index
		/// </summary>
		/// <param name="nIndex"></param>
		/// <returns></returns>
		public double InputValue( int nIndex )
		{
			if( nIndex < arrayInSet.Count )
				return ( double )arrayInSet[ nIndex ];
			else
				return 0.0;
		}


		/// <summary>
		/// get the output value at the given index
		/// </summary>
		/// <param name="nIndex"></param>
		/// <returns></returns>
		public double OutputValue( int nIndex )
		{
			if( nIndex < arrayOutSet.Count )
				return ( double )arrayOutSet[ nIndex ];
			else
			{
				return 0.0;
			}
		}

		public int InputSize()
		{
			return arrayInSet.Count;
		}

		public int OutputSize()
		{
			return arrayOutSet.Count;
		}

	}

	public class FuzzyIntegerPattern : FuzzyPattern
	{
		public FuzzyIntegerPattern() : base()
		{
		}

		public FuzzyIntegerPattern( int nInSize, int nOutSize ) : base( nInSize, nOutSize )
		{
		}

		/// <summary>
		/// constructor taking array lists
		/// </summary>
		/// <param name="arrayInSet"></param>
		/// <param name="arrayOutSet"></param>
		public FuzzyIntegerPattern( ArrayList arrayInSet, ArrayList arrayOutSet ) : base( arrayInSet, arrayOutSet )
		{
		}


		public FuzzyIntegerPattern( FuzzyInteger inputOne, FuzzyInteger inputTwo, double output ) : base()
		{
			this.InSet.Add( inputOne );
			this.InSet.Add( inputTwo );
			this.OutSet.Add( output );
		}

		public FuzzyIntegerPattern( FuzzyInteger inputOne, FuzzyInteger inputTwo ) : base()
		{
			this.InSet.Add( inputOne );
			this.InSet.Add( inputTwo );
		}

		new public FuzzyInteger InputValue( int nIndex )
		{

			if( nIndex < this.InSet.Count )
				return ( FuzzyInteger )this.InSet[ nIndex ];
			else
			{
				return new FuzzyInteger();
			}
		}

		public void SetInValue( int nIndex, FuzzyInteger nValue )
		{		
			if( nIndex < this.InSet.Count )
				this.InSet[ nIndex ] = nValue;
			else
				this.InSet.Add( nValue );
		}
			
	}

	public class FuzzyDoublePattern : FuzzyPattern
	{
		public FuzzyDoublePattern() : base()
		{
		}

		public FuzzyDoublePattern( int nInSize, int nOutSize ) : base( nInSize, nOutSize )
		{
		}

		/// <summary>
		/// constructor taking array lists
		/// </summary>
		/// <param name="arrayInSet"></param>
		/// <param name="arrayOutSet"></param>
		public FuzzyDoublePattern( ArrayList arrayInSet, ArrayList arrayOutSet ) : base( arrayInSet, arrayOutSet )
		{
		}


		public FuzzyDoublePattern( FuzzyInteger inputOne, FuzzyInteger inputTwo, double output ) : base()
		{
			this.InSet.Add( inputOne );
			this.InSet.Add( inputTwo );
			this.OutSet.Add( output );
		}

		public FuzzyDoublePattern( FuzzyInteger inputOne, FuzzyInteger inputTwo ) : base()
		{
			this.InSet.Add( inputOne );
			this.InSet.Add( inputTwo );
		}

		new public FuzzyDouble InputValue( int nIndex )
		{

			if( nIndex < this.InSet.Count )
				return ( FuzzyDouble )this.InSet[ nIndex ];
			else
			{
				return new FuzzyDouble();
			}
		}

		public void SetInValue( int nIndex, FuzzyDouble nValue )
		{		
			if( nIndex < this.InSet.Count )
				this.InSet[ nIndex ] = nValue;
			else
				this.InSet.Add( nValue );
		}
			
	}
}