using System;
using System.Windows.Forms;

namespace aiNnFingers
{
	public class CPN
	{
		public CPN()
		{

		}

		public RichTextBox richTextBox;

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


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

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

		//#define MIN_REAL      -HUGE_VAL
		const double MIN_REAL = double.MinValue;
		//#define MAX_REAL      +HUGE_VAL
		const double MAX_REAL = double.MaxValue;
		//#define MIN(x,y)      ((x)<(y) ? (x) : (y))
		//#define MAX(x,y)      ((x)>(y) ? (x) : (y))

		//#define LO            0
		const int LO = 0;
		//#define HI            1
		const int HI = 1;

		//#define PI            (2*asin(1))
		//#define sqr(x)        ((x)*(x))


		public struct LAYER
		{                     /* A LAYER OF A NET:                     */
			public int           Units;         /* - number of units in this layer       */
			public double[]         Output;        /* - output of ith unit                  */
			public double[][]        Weight;        /* - connection weights to ith unit      */
			public bool[]         Winner;        /* - marker for winning instar           */
		}

		public struct NET
		{                     /* A NET:                                */
			public LAYER        InputLayer;    /* - input layer                         */
			public LAYER        InstarLayer;   /* - instar layer                        */
			public LAYER        OutstarLayer;  /* - outstar layer                       */
			public int           Winners;       /* - allowed number of winning instars   */
			public double          Alpha;         /* - hidden layer learning rate          */
			public double          Beta;          /* - output layer learning rate          */
		}


		/******************************************************************************
				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      8
		const int NUM_DATA = 8;
		//#define X             11
		const int X = 11;
		//#define Y             11
		const int Y = 11;

		//#define N             (X * Y)
		const int N = X * Y;
		//#define C             NUM_DATA
		const int C = NUM_DATA;
		//#define M             2
		const int M = 2;

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

		char [][][]   Pattern_ = new char [NUM_DATA][][]
	{
		new char[Y][]
	{   "           ".ToCharArray(),
		"           ".ToCharArray(),
		"     O     ".ToCharArray(),
		"     O     ".ToCharArray(),
		"     O     ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"   OOOOO   ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray()  },
		new char[Y][]
	{
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"     O     ".ToCharArray(),
		"     O     ".ToCharArray(),
		"    O O    ".ToCharArray(),
		"    O O    ".ToCharArray(),
		"    O O    ".ToCharArray(),
		"   O   O   ".ToCharArray(),
		"   O   O   ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray()  },
		new char[Y][]
	{
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"     O     ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"   OOOOO   ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray()  },
		new char[Y][]
	{
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"     O     ".ToCharArray(),
		"     O     ".ToCharArray(),
		"     O     ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray()  },
		new char[Y][]
	{
		"           ".ToCharArray(),
		"  O        ".ToCharArray(),
		"     O     ".ToCharArray(),
		"     O     ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OO     ".ToCharArray(),
		"    OOO   O".ToCharArray(),
		"    OOOO   ".ToCharArray(),
		"   OOOOO   ".ToCharArray(),
		"           ".ToCharArray(),
		"       O   ".ToCharArray()  },
		new char[Y][]
	{
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"     O     ".ToCharArray(),
		"     O     ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"   OOOOO   ".ToCharArray(),
		"   OOOOO   ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray()  },
		new char[Y][]
	{
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"       O   ".ToCharArray(),
		"      O    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"   OOO     ".ToCharArray(),
		"  OOOOO    ".ToCharArray(),
		" OOOOO     ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray()  },
		new char[Y][]
	{
		"           ".ToCharArray(),
		"           ".ToCharArray(),
		"        O  ".ToCharArray(),
		"       O   ".ToCharArray(),
		"     OOO   ".ToCharArray(),
		"    OOO    ".ToCharArray(),
		"   OOO     ".ToCharArray(),
		" OOOOO     ".ToCharArray(),
		"OOOOO      ".ToCharArray(),
		"           ".ToCharArray(),
		"           ".ToCharArray()  } };
                                                    
		double    [][]              Input  = new double[NUM_DATA][]; //N
		double    [][]              Input_ = new double[NUM_DATA][]; //N
		double    [][]              Output = new double[NUM_DATA][]; //M

		//FILE*                 f;


		void NormalizeInput()
		{
			int  n,i;
			double Length, Length_;

			for (n=0; n<NUM_DATA; n++) 
			{
				Length  = 0;
				Length_ = 0;
				for (i=0; i<N; i++) 
				{
					Length  += (Input [n][i] * Input [n][i]);
					Length_ += (Input_[n][i] * Input_[n][i]);
				}
				Length  = Math.Sqrt(Length);
				Length_ = Math.Sqrt(Length_);
				for (i=0; i<N; i++) 
				{
					Input [n][i] /= Length;
					Input_[n][i] /= Length_;
				}
			}
		}


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

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

				for (i=0; i<Y; i++) 
				{
					for (j=0; j<X; j++) 
					{
						Input [n][i*X+j] = (Pattern [n][i][j] == 'O') ? HI : LO;
						Input_[n][i*X+j] = (Pattern_[n][i][j] == 'O') ? HI : LO;
					}
				}
			}
			NormalizeInput();
			for (n=0; n<NUM_DATA; n++) 
			{
				Output[n][0] = Math.Sin(n * 0.25 * Math.PI);
				Output[n][1] = Math.Cos(n * 0.25 * Math.PI);
			}
			//f = fopen("CPN.txt", "w");
		}


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


		void WriteOutput(ref NET Net, double[] Output)
		{
			double Angle;

			Angle = (Math.Atan2(Output[0], Output[1]) / Math.PI) * 180;
			if (Angle < 0)
				Angle = Angle + 360;

			richTextBox.AppendText(Angle.ToString("F3") + "\n");
			//fprintf(f, "%0.0f°\n", Angle);
		}


		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.InstarLayer  = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));
			Net.OutstarLayer = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));

			Net.InputLayer.Units    = N;
			Net.InputLayer.Output   = new double[N]; //(double*)  calloc(N, sizeof(double));
      
			Net.InstarLayer.Units   = C;
			Net.InstarLayer.Output  = new double[C]; //(double*)  calloc(C, sizeof(double));
			Net.InstarLayer.Weight  = new double[C][]; //(double**) calloc(C, sizeof(double*));
			Net.InstarLayer.Winner  = new bool[C]; //(bool*)  calloc(C, sizeof(bool));
      
			Net.OutstarLayer.Units  = M;
			Net.OutstarLayer.Output = new double[M]; //(double*)  calloc(M, sizeof(double));
			Net.OutstarLayer.Weight = new double[M][]; //(double**) calloc(M, sizeof(double*));
      
			for (i=0; i<C; i++) 
			{
				Net.InstarLayer.Weight[i] = new double[N]; //(double*) calloc(N, sizeof(double));
			}
			for (i=0; i<M; i++) 
			{
				Net.OutstarLayer.Weight[i] = new double[C]; //(double*) calloc(C, sizeof(double));
			}

			Net.Winners = 1;
			Net.Alpha   = 0.1;
			Net.Beta    = 0.1;
		}


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


		void GetOutput(ref NET Net, double[] Output, bool Protocoling)
		{
			int i;
   
			for (i=0; i<Net.OutstarLayer.Units; i++) 
			{
				Output[i] = Net.OutstarLayer.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 PropagateToInstars(ref NET Net)
		{
			int  w,i,j;
			double Sum, SumWinners, MaxOut;
			int  Winner = 0;

			for (i=0; i<Net.InstarLayer.Units; i++) 
			{
				Sum = 0;
				for (j=0; j<Net.InputLayer.Units; j++) 
				{
					Sum += Net.InstarLayer.Weight[i][j] * Net.InputLayer.Output[j];
				}
				Net.InstarLayer.Output[i] = Sum;
				Net.InstarLayer.Winner[i] = false;
			}
			SumWinners = 0;
			for (w=0; w<Net.Winners; w++) 
			{
				MaxOut = MIN_REAL;
				for (i=0; i<Net.InstarLayer.Units; i++) 
				{
					if (! Net.InstarLayer.Winner[i] && Net.InstarLayer.Output[i] > MaxOut)
						MaxOut = Net.InstarLayer.Output[Winner = i];
				}
				Net.InstarLayer.Winner[Winner] = true;
				SumWinners += Net.InstarLayer.Output[Winner];
			}
			for (i=0; i<Net.InstarLayer.Units; i++) 
			{
				if (Net.InstarLayer.Winner[i])
					Net.InstarLayer.Output[i] = Net.InstarLayer.Output[i] / SumWinners;
				else
					Net.InstarLayer.Output[i] = 0;
			}
		}


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

			for (i=0; i<Net.OutstarLayer.Units; i++) 
			{
				Sum = 0;
				for (j=0; j<Net.InstarLayer.Units; j++) 
				{  
					Sum += Net.OutstarLayer.Weight[i][j] * Net.InstarLayer.Output[j];
				}
				Net.OutstarLayer.Output[i] = Sum;
			}
		}


		void PropagateNet(ref NET Net)
		{
			PropagateToInstars(ref Net);
			PropagateToOutstars(ref Net);
		}


		/******************************************************************************
								T R A I N I N G   T H E   N E T
		 ******************************************************************************/


		int Winner(ref NET Net)
		{
			int i = 0;

			for (i=0; i<Net.InstarLayer.Units; i++) 
			{
				if (Net.InstarLayer.Winner[i])
					return i;
			}
			return i; //MOD
		}


		void TrainInstars(ref NET Net, int Epochs)
		{
			int n,m,i,j;
   
			for (i=0; i<Net.InstarLayer.Units; i++) 
			{
				for (j=0; j<Net.InputLayer.Units; j++) 
				{
					Net.InstarLayer.Weight[i][j] = Input[i][j];
				}
			}
			Net.Winners = 1;
			for (m=0; m<Epochs*NUM_DATA; m++) 
			{
				n = RandomEqualINT(0, NUM_DATA-1);
				SetInput(ref Net, Input[n], false);
				PropagateToInstars(ref Net);
				i = Winner(ref Net);
				for (j=0; j<Net.InputLayer.Units; j++) 
				{
					Net.InstarLayer.Weight[i][j] +=
						Net.Alpha * (Input[n][j] - Net.InstarLayer.Weight[i][j]);
				}
			}
		}


		void TrainOutstars(ref NET Net, int Epochs)
		{
			int n,m,i,j;
   
			for (i=0; i<Net.OutstarLayer.Units; i++) 
			{
				for (j=0; j<Net.InstarLayer.Units; j++) 
				{
					Net.OutstarLayer.Weight[i][j] = Output[j][i];
				}
			}
			Net.Winners = 1;
			for (m=0; m<Epochs*NUM_DATA; m++) 
			{
				n = RandomEqualINT(0, NUM_DATA-1);
				SetInput(ref Net, Input[n], false);
				PropagateToInstars(ref Net);
				j = Winner(ref Net);
				for (i=0; i<Net.OutstarLayer.Units; i++) 
				{
					Net.OutstarLayer.Weight[i][j] +=
						Net.Beta * (Output[n][i] - Net.OutstarLayer.Weight[i][j]);
				}
			}
		}


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


		void SimulateNet(ref NET Net, double[] Input)
		{
			double [] Output = new double[M];

			SetInput(ref Net, Input, true);
			PropagateNet(ref Net);
			GetOutput(ref Net, Output, true);
		}


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


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

			InitializeRandoms();
			GenerateNetwork(ref Net);
			InitializeApplication(ref Net);
			TrainInstars(ref Net, 0);         /* weights are computed for this application */
			TrainOutstars(ref Net, 0);        /* weights are computed for this application */

			Net.Winners = 2;
			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);
		}

	}
}