using System;
using System.IO;
using System.Windows.Forms;

namespace aiNnFingers
{
	public class ADALINE
	{
		public ADALINE()
		{

		}

		public RichTextBox richTextBox;
		public RichTextBox richTextBox2;

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

		//typedef int           BOOL; //bool
		//typedef char          CHAR; //char
		//typedef int           INT; //int
		//typedef double        REAL; //double

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

		//#define MIN(x,y)      ((x)<(y) ? (x) : (y)) //Math.Min
		//#define MAX(x,y)      ((x)>(y) ? (x) : (y)) //Math.Max

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

		//#define sqr(x)        ((x)*(x)) //replace with X * X


		//redefine structs and make public
		public struct LAYER
		{                     /* A LAYER OF A NET:                     */
				public int           Units;         /* - number of units in this layer       */
				public double[]         Activation;    /* - activation of ith unit              */
				public int[]          Output;        /* - output of ith unit                  */
				public double[]         Error;         /* - error term of ith unit              */
				public double[][]        Weight;        /* - connection weights to ith unit      */
		}

		public struct NET
		{                     /* A NET:                                */
				public LAYER        InputLayer;    /* - input layer                         */
				public LAYER        OutputLayer;   /* - output layer                        */
				public double          Eta;           /* - learning rate                       */
				public double          Error;         /* - total net error                     */
				public double          Epsilon;       /* - net error to terminate training     */
		}

		/******************************************************************************
				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;
		}      


		double RandomEqualREAL(double Low, double High)
		{
			double retVal = ((double) r.Next() / (double) RAND_MAX) * (High-Low) + Low; //takes about 1000 times;
			//double retVal = 0; //takes about 269 times
			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      10
		const int NUM_DATA = 10;
		//#define X             5
		const int X = 5;
		//#define Y             7
		const int Y = 7;

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

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

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

		//int [,]                   Output = new int[NUM_DATA, M]
		int [][]                   Output = new int[NUM_DATA][]
		                      
										{
											new int[M] {HI, LO, LO, LO, LO, LO, LO, LO, LO, LO},
											new int[M] {LO, HI, LO, LO, LO, LO, LO, LO, LO, LO},
											new int[M] {LO, LO, HI, LO, LO, LO, LO, LO, LO, LO},
											new int[M] {LO, LO, LO, HI, LO, LO, LO, LO, LO, LO},
											new int[M] {LO, LO, LO, LO, HI, LO, LO, LO, LO, LO},
											new int[M] {LO, LO, LO, LO, LO, HI, LO, LO, LO, LO},
											new int[M] {LO, LO, LO, LO, LO, LO, HI, LO, LO, LO},
											new int[M] {LO, LO, LO, LO, LO, LO, LO, HI, LO, LO},
											new int[M] {LO, LO, LO, LO, LO, LO, LO, LO, HI, LO},
											new int[M] {LO, LO, LO, LO, LO, LO, LO, LO, LO, HI}  };

		//FILE*                 f;
		//FileInfo                 f;
		//FileStream fs;

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

			Net.Eta     = 0.001;
			Net.Epsilon = 0.0001;

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

				for (i=0; i<Y; i++) 
				{
					for (j=0; j<X; j++) 
					{
						Input[n][i*X+j] = (Pattern[n][i][j] == 'O') ? HI : LO;
					}
				}
			}
			//f = fopen("ADALINE.txt", "w");
		}


		void WriteInput(ref NET Net, int[] Input)
		{
			int i;
			   
			for (i=0; i<N; i++) 
			{
				if (i%X == 0) 
				{
					//fprintf(f, "\n");
					richTextBox.AppendText("\n");
				}
				//fprintf(f, "%c", (Input[i] == HI) ? 'O' : ' ');
				char outChar = Input[i] == HI ? 'O' : ' ';
				richTextBox.AppendText(outChar.ToString());
			}
			//fprintf(f, " -> ");
			richTextBox.AppendText(" -> ");
		}


		void WriteOutput(ref NET Net, int[] Output)
		{
			int i;
			int Count, Index=0;
			   
			Count = 0;
			for (i=0; i<M; i++) 
			{
				if (Output[i] == HI) 
				{
					Count++;
					Index = i;
				}
			}
			if (Count == 1)
			{
				//fprintf(f, "%i\n", Index);
				richTextBox.AppendText(Index.ToString() + "\n");
			}
			else
			{
				//fprintf(f, "%s\n", "invalid");
				richTextBox.AppendText("invalid\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.InputLayer  = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));
			Net.OutputLayer = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));

			Net.InputLayer.Units       = N;
			Net.InputLayer.Output      = new int[N+1]; //(int*)   calloc(N+1, sizeof(int));
			Net.InputLayer.Output[0]   = BIAS;

			Net.OutputLayer.Units      = M;
			Net.OutputLayer.Activation = new double[M+1]; //(double*)  calloc(M+1, sizeof(double));
			Net.OutputLayer.Output     = new int[M+1]; //(int*)   calloc(M+1, sizeof(int));
			Net.OutputLayer.Error      = new double[M+1]; //(double*)  calloc(M+1, sizeof(double));
			Net.OutputLayer.Weight     = new double[M+1][]; //(double**) calloc(M+1, sizeof(double*));
			      
			for (i=1; i<=M; i++) 
			{
				Net.OutputLayer.Weight[i] = new double[N+1]; //(double*) calloc(N+1, sizeof(double));
			}

			Net.Eta     = 0.1;
			Net.Epsilon = 0.01;
		}


		void RandomWeights(ref NET Net)
		{
			int i,j;
			   
			for (i=1; i<=Net.OutputLayer.Units; i++) 
			{
				for (j=0; j<=Net.InputLayer.Units; j++) 
				{
					Net.OutputLayer.Weight[i][j] = RandomEqualREAL(-0.5, 0.5);
				}
			}
		}


		void SetInput(ref NET Net, int[] Input, bool Protocoling)
		{
			int i;
			   
			for (i=1; i<=Net.InputLayer.Units; i++) 
			{
				Net.InputLayer.Output[i] = Input[i-1];
			}
			if (Protocoling) 
			{
				WriteInput(ref Net, Input);
			}
		}


		void GetOutput(ref NET Net, int[] Output, bool Protocoling)
		{
			int i;
			   
			for (i=1; i<=Net.OutputLayer.Units; i++) 
			{
				Output[i-1] = Net.OutputLayer.Output[i];
			}
			if (Protocoling) 
			{
				WriteOutput(ref Net, Output);
			}
		}


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


		void PropagateNet(ref NET Net)
		{
			int  i,j;
			double Sum;

			for (i=1; i<=Net.OutputLayer.Units; i++) 
			{
				Sum = 0;
				for (j=0; j<=Net.InputLayer.Units; j++) 
				{
					Sum += Net.OutputLayer.Weight[i][j] * Net.InputLayer.Output[j];
				}
				Net.OutputLayer.Activation[i] = Sum;
				if (Sum >= 0)
					Net.OutputLayer.Output[i] = HI;
				else
					Net.OutputLayer.Output[i] = LO;
			}
		}


		/******************************************************************************
							A D J U S T I N G   W E I G H T S
		******************************************************************************/


		void ComputeOutputError(ref NET Net, int[] Target)
		{
			int  i;
			double Err;
			   
			Net.Error = 0;
			for (i=1; i<=Net.OutputLayer.Units; i++) 
			{
				Err = Target[i-1] - Net.OutputLayer.Activation[i];
				Net.OutputLayer.Error[i] = Err;
				Net.Error += 0.5 * (Err * Err);
			}
		}


		void AdjustWeights(ref NET Net)
		{
			int  i,j;
			int  Out;
			double Err;
			   
			for (i=1; i<=Net.OutputLayer.Units; i++) 
			{
				for (j=0; j<=Net.InputLayer.Units; j++) 
				{
					Out = Net.InputLayer.Output[j];
					Err = Net.OutputLayer.Error[i];
					Net.OutputLayer.Weight[i][j] += Net.Eta * Err * Out;
				}
			}
		}


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


		void SimulateNet(ref NET Net, int[] Input, int[] Target, bool Training, bool Protocoling)
		{
			//int Output[M];
			int [] Output = new int[M];
			   
			SetInput(ref Net, Input, Protocoling);
			PropagateNet(ref Net);
			GetOutput(ref Net, Output, Protocoling);
			   
			ComputeOutputError(ref Net, Target);
			if (Training)
				AdjustWeights(ref Net);
		}


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


		public void main()
		{
			NET  Net = new NET();
			double Error;
			bool Stop;
			int  n,m;

			InitializeRandoms();
			GenerateNetwork(ref Net);
			RandomWeights(ref Net);
			InitializeApplication(ref Net);
			   
			int iters = 0;
			do 
			{
				Error = 0;
				Stop = true;
				for (n=0; n<NUM_DATA; n++) 
				{
					SimulateNet(ref Net, Input[n], Output[n], false, false);
					Error = Math.Max(Error, Net.Error);
					Stop = Stop && (Net.Error < Net.Epsilon);
				}
				Error = Math.Max(Error, Net.Epsilon);
				double outErr = (Net.Epsilon / Error) * 100;
				//printf("Training %0.0f%% completed ...\n", (Net.Epsilon / Error) * 100);
				iters = iters + 1;
				richTextBox.AppendText(iters.ToString() + " Training " + outErr.ToString("F") + " completed ...\n");
				if (!Stop) 
				{
					for (m=0; m<10*NUM_DATA; m++) 
					{
						n = RandomEqualINT(0, NUM_DATA-1);      
						SimulateNet(ref Net, Input[n], Output[n], true, false);
					}
				}
			} while (!Stop);
			   
			for (n=0; n<NUM_DATA; n++) 
			{
				SimulateNet(ref Net, Input[n], Output[n], false, true);
			}
			   
			FinalizeApplication(ref Net);
		}
	}
}