using System;
using System.Windows.Forms;

namespace aiNnFingers
{
	public class BAM
	{
		public BAM()
		{

		}

		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;
		//}
		public int BINARY(int x)
		{
			if(x == LO)
				return 0;
			else
				return 1;
		}

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

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

		public struct NET
		{                     /* A NET:                                */
			public LAYER        X;             /* - X layer                             */
			public LAYER        Y;             /* - Y layer                             */
		}


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


		bool RandomEqualBOOL()
		{
			//return rand() % 2;
			int retVal = r.Next() % 2;
			if(retVal == 0)
				return false;
			else
				return true;
			//return Boolean.Parse(retVal.ToString());
		}      


		/******************************************************************************
					   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      3
		const int NUM_DATA = 3;
		//#define IN_CHARS      5
		const int IN_CHARS = 5;
		//#define OUT_CHARS     7
		const int OUT_CHARS = 7;

		//#define BITS_PER_CHAR 6
		const int BITS_PER_CHAR = 6;
		//#define FIRST_CHAR    ' '
		const char FIRST_CHAR = ' ';

		//#define N             (IN_CHARS  * BITS_PER_CHAR)
		const int N = IN_CHARS * BITS_PER_CHAR;
		//#define M             (OUT_CHARS * BITS_PER_CHAR)
		const int M = OUT_CHARS * BITS_PER_CHAR;

		char [][]                 Names = new char[NUM_DATA][] //IN_CHARS 
	{
		"TINA ".ToCharArray(),
		"ANTJE".ToCharArray(), 
		"LISA ".ToCharArray()  };
                                     
		char  [][]                Names_ = new char[NUM_DATA][] //IN_CHARS
	{
		"TINE ".ToCharArray(),
		"ANNJE".ToCharArray(), 
		"RITA ".ToCharArray()  };

		char [][]                 Phones = new char[NUM_DATA][] //OUT_CHARS
	{
		"6843726".ToCharArray(),
		"8034673".ToCharArray(),
		"7260915".ToCharArray()  };

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

		//FILE*                 f;


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

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

				for (i=0; i<IN_CHARS; i++) 
				{
					a  = Names [n][i] - FIRST_CHAR;
					a_ = Names_[n][i] - FIRST_CHAR;
					for (j=0; j<BITS_PER_CHAR; j++) 
					{
						Input [n][i*BITS_PER_CHAR+j] = BIPOLAR(a % 2);
						Input_[n][i*BITS_PER_CHAR+j] = BIPOLAR(a_ % 2);
						a  /= 2;
						a_ /= 2;
					}
				}
				for (i=0; i<OUT_CHARS; i++) 
				{
					a = Phones[n][i] - FIRST_CHAR;
					for (j=0; j<BITS_PER_CHAR; j++) 
					{
						Output[n][i*BITS_PER_CHAR+j] = BIPOLAR(a % 2);
						a /= 2;
					}
				}
			}
			//f = fopen("BAM.txt", "w");
		}


		//void WriteLayer(LAYER* Layer)
		void WriteLayer(ref LAYER Layer)
		{
			int i,j,a,p;
   
			for (i=0; i<(Layer.Units / BITS_PER_CHAR); i++) 
			{
				a = 0;
				p = 1;
				for (j=0; j<BITS_PER_CHAR; j++) 
				{
					a += BINARY(Layer.Output[i*BITS_PER_CHAR+j]) * p;
					p *= 2;  
				}
				char outChar = (char) (a + FIRST_CHAR);
				richTextBox.AppendText(outChar.ToString());
				//fprintf(f, "%c", a + FIRST_CHAR);
			}
		}


		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.X = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));
			Net.Y = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));
      
			Net.X.Units  = N;
			Net.X.Output = new int[N]; //(int*)  calloc(N, sizeof(int));
			Net.X.Weight = new int[N][]; //(int**) calloc(N, sizeof(int*));

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

			for (i=0; i<N; i++) 
			{
				Net.X.Weight[i] = new int[M]; //(int*) calloc(M, sizeof(int));
			}
			for (i=0; i<M; i++) 
			{
				Net.Y.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.X.Units; i++) 
			{
				for (j=0; j<Net.Y.Units; j++) 
				{
					Weight = 0;
					for (n=0; n<NUM_DATA; n++) 
					{
						Weight += Input[n][i] * Output[n][j];
					}
					Net.X.Weight[i][j] = Weight;
					Net.Y.Weight[j][i] = Weight;
				}
			}
		}


		//void SetInput(LAYER* Layer, int[] Input)
		void SetInput(ref LAYER Layer, int[] Input)
		{
			int i;
   
			for (i=0; i<Layer.Units; i++) 
			{
				Layer.Output[i] = Input[i];
			}
			WriteLayer(ref Layer);
		}


		//void SetRandom(LAYER* Layer)
		void SetRandom(ref LAYER Layer)
		{
			int i;
   
			for (i=0; i<Layer.Units; i++) 
			{
				Layer.Output[i] = BIPOLAR(RandomEqualBOOL());
			}
			WriteLayer(ref Layer);
		}


		//void GetOutput(LAYER* Layer, int* Output)
		void GetOutput(ref LAYER Layer, int[] Output)
		{
			int i;
   
			for (i=0; i<Layer.Units; i++) 
			{
				Output[i] = Layer.Output[i];
			}
			WriteLayer(ref Layer);
		}


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


		//bool PropagateLayer(LAYER* From, LAYER* To)
		bool PropagateLayer(ref LAYER From, ref LAYER To)
		{
			int  i,j;
			int  Sum, Out = 0;
			bool Stable;

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


		//void PropagateNet(LAYER* From, LAYER* To)
		void PropagateNet(ref LAYER From, ref LAYER To)
		{
			bool Stable1, Stable2;

			do 
			{
				Stable1 = PropagateLayer(ref From, ref To);
				Stable2 = PropagateLayer(ref To, ref From);
			} while (!(Stable1 && Stable2));
		}


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


		//void SimulateNet(LAYER* From, LAYER* To, int* Pattern, int* Input, int* Output)
		void SimulateNet(ref LAYER From, ref LAYER To, int[] Pattern, int[] Input, int[] Output)
		{
			SetInput(ref From, Pattern); 
			richTextBox.AppendText(" . ");
			//fprintf(f, " . ");
			SetRandom(ref To);           
			richTextBox.AppendText("  |  ");
			//fprintf(f, "  |  ");
			PropagateNet(ref From, ref To);
			GetOutput(ref From, Input);  
			richTextBox.AppendText(" . ");
			//fprintf(f, " . ");
			GetOutput(ref To, Output);   
			richTextBox.AppendText("\n\n");
			//fprintf(f, "\n\n");
		}


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


		public void main()
		{
			NET Net = new NET();
			int n;
			int [] I = new int[N];
			int [] O = new int[M];

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