using System;
using System.Windows.Forms;

namespace aiNnFingers
{
	public class HOPFIELD
	{
		public HOPFIELD()
		{

		}

		public RichTextBox richTextBox;

		//#include <stdlib.h>
		//#include <stdio.h>


		//typedef int           BOOL;
		//typedef char          CHAR;
		//typedef int           INT;

		//#define FALSE         0
		//#define TRUE          1
		//#define NOT           !
		//#define AND           &&
		//#define OR            ||

		//#define LO            -1
		const int LO = -1;
		//#define HI            +1
		const int HI = +1;

		//#define BINARY(x)     ((x)==LO ? false : true)
		public bool BINARY(int x)
		{
			if(x == LO)
				return false;
			else
				return true;
		}

		//#define BIPOLAR(x)    ((x)==false ? LO : HI)
		public int BIPOLAR(bool x)
		{
			if(x == false)
				return LO;
			else
				return HI;
		}

		public struct NET
		{                     /* A NET:                                */
			public int           Units;         /* - number of units in this net         */
			public int[]          Output;        /* - output of ith unit                  */
			public int[]          Threshold;     /* - threshold of ith unit               */
			public int[][]         Weight;        /* - connection weights to ith unit      */
		} 


		/******************************************************************************
				R A N D O M S   D R A W N   F R O M   D I S T R I B U T I O N S
		 ******************************************************************************/

		Random r;
		const int RAND_MAX = Int32.MaxValue;
		void InitializeRandoms()
		{
			//srand(4711);
			r = new Random(4711);
		}


		int RandomEqualINT(int Low, int High)
		{
			//return rand() % (High-Low+1) + Low;
			int retVal = r.Next() % (High-Low+1) + Low;
			return retVal;
		} 


		/******************************************************************************
					   A P P L I C A T I O N - S P E C I F I C   C O D E
		 ******************************************************************************/


		//#define NUM_DATA      5
		const int NUM_DATA = 5;
		//#define X             10
		const int X = 10;
		//#define Y             10
		const int Y = 10;

		//#define N             (X * Y)
		const int N = X * Y;

		char  [][][] Pattern = new char[NUM_DATA][][] //NUM_DATA Y X
	{
		new char [Y][]
	{   "O O O O O ".ToCharArray(),
		" O O O O O".ToCharArray(),
		"O O O O O ".ToCharArray(),
		" O O O O O".ToCharArray(),
		"O O O O O ".ToCharArray(),
		" O O O O O".ToCharArray(),
		"O O O O O ".ToCharArray(),
		" O O O O O".ToCharArray(),
		"O O O O O ".ToCharArray(),
		" O O O O O".ToCharArray()  },
		new char [Y][]
	{
		"OO  OO  OO".ToCharArray(),
		"OO  OO  OO".ToCharArray(),
		"  OO  OO  ".ToCharArray(),
		"  OO  OO  ".ToCharArray(),
		"OO  OO  OO".ToCharArray(),
		"OO  OO  OO".ToCharArray(),
		"  OO  OO  ".ToCharArray(),
		"  OO  OO  ".ToCharArray(),
		"OO  OO  OO".ToCharArray(),
		"OO  OO  OO".ToCharArray()  },
		new char [Y][]
	{
		"OOOOO     ".ToCharArray(),
		"OOOOO     ".ToCharArray(),
		"OOOOO     ".ToCharArray(),
		"OOOOO     ".ToCharArray(),
		"OOOOO     ".ToCharArray(),
		"     OOOOO".ToCharArray(),
		"     OOOOO".ToCharArray(),
		"     OOOOO".ToCharArray(),
		"     OOOOO".ToCharArray(),
		"     OOOOO".ToCharArray()  },
		new char [Y][]
	{
		"O  O  O  O".ToCharArray(),
		" O  O  O  ".ToCharArray(),
		"  O  O  O ".ToCharArray(),
		"O  O  O  O".ToCharArray(),
		" O  O  O  ".ToCharArray(),
		"  O  O  O ".ToCharArray(),
		"O  O  O  O".ToCharArray(),
		" O  O  O  ".ToCharArray(),
		"  O  O  O ".ToCharArray(),
		"O  O  O  O".ToCharArray()  },
		new char [Y][]
	{
		"OOOOOOOOOO".ToCharArray(),
		"O        O".ToCharArray(),
		"O OOOOOO O".ToCharArray(),
		"O O    O O".ToCharArray(),
		"O O OO O O".ToCharArray(),
		"O O OO O O".ToCharArray(),
		"O O    O O".ToCharArray(),
		"O OOOOOO O".ToCharArray(),
		"O        O".ToCharArray(),
		"OOOOOOOOOO".ToCharArray()  } };

		char [][][] Pattern_ = new char[NUM_DATA][][] //NUM_DATA Y X
	{
		new char [Y][]
	{   "          ".ToCharArray(),
		"          ".ToCharArray(),
		"          ".ToCharArray(),
		"          ".ToCharArray(),
		"          ".ToCharArray(),
		" O O O O O".ToCharArray(),
		"O O O O O ".ToCharArray(),
		" O O O O O".ToCharArray(),
		"O O O O O ".ToCharArray(),
		" O O O O O".ToCharArray()  },
		new char [Y][]
	{
		"OOO O    O".ToCharArray(),
		" O  OOO OO".ToCharArray(),
		"  O O OO O".ToCharArray(),
		" OOO   O  ".ToCharArray(),
		"OO  O  OOO".ToCharArray(),
		" O OOO   O".ToCharArray(),
		"O OO  O  O".ToCharArray(),
		"   O OOO  ".ToCharArray(),
		"OO OOO  O ".ToCharArray(),
		" O  O  OOO".ToCharArray()  },
		new char [Y][]
	{
		"OOOOO     ".ToCharArray(),
		"O   O OOO ".ToCharArray(),
		"O   O OOO ".ToCharArray(),
		"O   O OOO ".ToCharArray(),
		"OOOOO     ".ToCharArray(),
		"     OOOOO".ToCharArray(),
		" OOO O   O".ToCharArray(),
		" OOO O   O".ToCharArray(),
		" OOO O   O".ToCharArray(),
		"     OOOOO".ToCharArray()  },
		new char [Y][]
	{
		"O  OOOO  O".ToCharArray(),
		"OO  OOOO  ".ToCharArray(),
		"OOO  OOOO ".ToCharArray(),
		"OOOO  OOOO".ToCharArray(),
		" OOOO  OOO".ToCharArray(),
		"  OOOO  OO".ToCharArray(),
		"O  OOOO  O".ToCharArray(),
		"OO  OOOO  ".ToCharArray(),
		"OOO  OOOO ".ToCharArray(),
		"OOOO  OOOO".ToCharArray()  },
		new char [Y][]
	{
		"OOOOOOOOOO".ToCharArray(),
		"O        O".ToCharArray(),
		"O        O".ToCharArray(),
		"O        O".ToCharArray(),
		"O   OO   O".ToCharArray(),
		"O   OO   O".ToCharArray(),
		"O        O".ToCharArray(),
		"O        O".ToCharArray(),
		"O        O".ToCharArray(),
		"OOOOOOOOOO".ToCharArray()  } };

		int [][]                   Input = new int [NUM_DATA][]; //N
		int [][]                   Input_ = new int [NUM_DATA][]; //N

		//FILE*                 f;

		void InitializeApplication(ref NET Net)
		{
			int n,i,j;

			for (n=0; n<NUM_DATA; n++) 
			{
				Input[n] = new int[N];
				Input_[n] = new int[N];

				for (i=0; i<Y; i++) 
				{
					for (j=0; j<X; j++) 
					{
						Input [n][i*X+j] = BIPOLAR(Pattern [n][i][j] == 'O');
						Input_[n][i*X+j] = BIPOLAR(Pattern_[n][i][j] == 'O');
					}
				}
			}
			//f = fopen("HOPFIELD.txt", "w");
		}


		void WriteNet(ref NET Net)
		{
			int i,j;
   
			for (i=0; i<Y; i++) 
			{
				for (j=0; j<X; j++) 
				{
					//fprintf(f, "%c", BINARY(Net.Output[i*X+j]) ? 'O' : ' ');
					bool binOut = BINARY(Net.Output[i*X+j]);
					char c = 'O';
					if(binOut == false)
						c = ' ';
					richTextBox.AppendText(c.ToString());
				}
				//fprintf(f, "\n");
				richTextBox.AppendText("\n");
			}
			//fprintf(f, "\n");
			richTextBox.AppendText("\n");
		}


		void FinalizeApplication(ref NET Net)
		{
			//fclose(f);
		}


		/******************************************************************************
								  I N I T I A L I Z A T I O N
		 ******************************************************************************/


		void GenerateNetwork(ref NET Net)
		{
			int i;

			Net.Units     = N;
			Net.Output    = new int[N]; //(int*)  calloc(N, sizeof(int));
			Net.Threshold = new int[N]; //(int*)  calloc(N, sizeof(int));
			Net.Weight    = new int[N][]; //(int**) calloc(N, sizeof(int*));

			for (i=0; i<N; i++) 
			{
				Net.Threshold[i] = 0;
				Net.Weight[i]    = new int[N]; //(int*) calloc(N, sizeof(int));
			}
		}


		void CalculateWeights(ref NET Net)
		{
			int i,j,n;
			int Weight;

			for (i=0; i<Net.Units; i++) 
			{
				for (j=0; j<Net.Units; j++) 
				{
					Weight = 0;
					if (i!=j) 
					{
						for (n=0; n<NUM_DATA; n++) 
						{
							Weight += Input[n][i] * Input[n][j];
						}
					}
					Net.Weight[i][j] = Weight;
				}
			}
		}


		void SetInput(ref NET Net, int[] Input)
		{
			int i;
   
			for (i=0; i<Net.Units; i++) 
			{
				Net.Output[i] = Input[i];
			}
			WriteNet(ref Net);
		}


		void GetOutput(ref NET Net, int[] Output)
		{
			int i;
   
			for (i=0; i<Net.Units; i++) 
			{
				Output[i] = Net.Output[i];
			}
			WriteNet(ref Net);
		}


		/******************************************************************************
							 P R O P A G A T I N G   S I G N A L S
		 ******************************************************************************/


		bool PropagateUnit(ref NET Net, int i)
		{
			int  j;
			int  Sum, Out = 0;
			bool Changed;

			Changed = false;
			Sum = 0;
			for (j=0; j<Net.Units; j++) 
			{
				Sum += Net.Weight[i][j] * Net.Output[j];
			}
			if (Sum != Net.Threshold[i]) 
			{
				if (Sum < Net.Threshold[i]) Out = LO;
				if (Sum > Net.Threshold[i]) Out = HI;
				if (Out != Net.Output[i]) 
				{
					Changed = true;
					Net.Output[i] = Out;
				}
			}
			return Changed;
		}


		void PropagateNet(ref NET Net)
		{
			int Iteration, IterationOfLastChange;

			Iteration = 0;
			IterationOfLastChange = 0;
			do 
			{
				Iteration++;
				if (PropagateUnit(ref Net, RandomEqualINT(0, Net.Units-1)))
					IterationOfLastChange = Iteration;
			} while (Iteration-IterationOfLastChange < 10*Net.Units);
		}


		/******************************************************************************
							  S I M U L A T I N G   T H E   N E T
		 ******************************************************************************/


		void SimulateNet(ref NET Net, int[] Input)
		{
			int [] Output = new int[N];
   
			SetInput(ref Net, Input);
			PropagateNet(ref Net);
			GetOutput(ref Net, Output);
		}


		/******************************************************************************
											M A I N
		 ******************************************************************************/


		public void main()
		{
			NET Net = new NET();
			int n;

			InitializeRandoms();
			GenerateNetwork(ref Net);
			InitializeApplication(ref Net);
			CalculateWeights(ref Net);
   
			for (n=0; n<NUM_DATA; n++) 
			{
				SimulateNet(ref Net, Input[n]);
			}
			for (n=0; n<NUM_DATA; n++) 
			{
				SimulateNet(ref Net, Input_[n]);
			}
   
			FinalizeApplication(ref Net);
		}

	}
}