using System;
using System.Windows.Forms;

namespace aiNnFingers
{
	public class ART1
	{
		public ART1()
		{

		}

		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;

		public double BINARY(bool x)
		{
			if(x == false)
				return 0;
			else
				return 1;
		}


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

		public struct NET
		{                     /* A NET:                                */
			public LAYER        F1;            /* - F1 layer                            */
			public LAYER        F2;            /* - F2 layer                            */
			public int           Winner;        /* - last winner in F2 layer             */
			public double          A1;            /* - A parameter for F1 layer            */
			public double          B1;            /* - B parameter for F1 layer            */
			public double          C1;            /* - C parameter for F1 layer            */
			public double          D1;            /* - D parameter for F1 layer            */
			public double          L;             /* - L parameter for net                 */
			public double          Rho;           /* - vigilance parameter                 */
		}


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


		//#define N             5
		const int N = 5;
		//#define M             10
		const int M = 10;

		//#define NO_WINNER     M
		const int NO_WINNER = M;

		//#define NUM_DATA      30
		const int NUM_DATA = 30;

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

		bool  [][]                Input = new bool[NUM_DATA][]; //N
		bool  [][]                Output = new bool[NUM_DATA][]; //M

		//FILE*                 f;


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

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

				for (i=0; i<N; i++) 
				{
					Input[n][i] = (Pattern[n][i] == 'O');
				}
			}
			Net.A1  = 1;
			Net.B1  = 1.5;
			Net.C1  = 5;
			Net.D1  = 0.9;
			Net.L   = 3;
			Net.Rho = 0.9;
			for (i=0; i<Net.F1.Units; i++) 
			{
				for (j=0; j<Net.F2.Units; j++) 
				{
					Net.F1.Weight[i][j] = (Net.B1 - 1) / Net.D1 + 0.2;
					Net.F2.Weight[j][i] = Net.L / (Net.L - 1 + N) - 0.1;
				}
			}
			//f = fopen("ART1.txt", "w");
		}


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


		void WriteOutput(ref NET Net, bool[] Output)
		{
			if (Net.Winner != NO_WINNER)
			{
				richTextBox.AppendText("Class " + Net.Winner.ToString() + "\n");
				//fprintf(f, "Class %i\n", Net.Winner);
			}
			else
			{
				richTextBox.AppendText("new Input and all Classes exhausted\n");
				//fprintf(f, "new Input and all Classes exhausted\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.F1 = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));
			Net.F2 = new LAYER(); //(LAYER*) malloc(sizeof(LAYER));
      
			Net.F1.Units     = N;
			Net.F1.Output    = new bool[N]; //(bool*)  calloc(N, sizeof(bool));
			Net.F1.Weight    = new double[N][]; //(double**) calloc(N, sizeof(double*));

			Net.F2.Units     = M;
			Net.F2.Output    = new bool[M]; //(bool*)  calloc(M, sizeof(bool));
			Net.F2.Weight    = new double[M][]; //(double**) calloc(M, sizeof(double*));
			Net.F2.Inhibited = new bool[M]; //(bool*)  calloc(M, sizeof(bool));

			for (i=0; i<N; i++) 
			{
				Net.F1.Weight[i] = new double[M]; //(double*) calloc(M, sizeof(double));
			}
			for (i=0; i<M; i++) 
			{
				Net.F2.Weight[i] = new double[N]; //(double*) calloc(N, sizeof(double));
			}
		}


		void SetInput(ref NET Net, bool[] Input)
		{
			int  i;
			double Activation;
   
			for (i=0; i<Net.F1.Units; i++) 
			{
				Activation = BINARY(Input[i]) / (1 + Net.A1 * (BINARY(Input[i]) + Net.B1) + Net.C1);
				Net.F1.Output[i] = (Activation > 0);
			}
		}


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


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


		void PropagateToF2(ref NET Net)
		{
			int  i,j;
			double Sum, MaxOut;
   
			MaxOut = MIN_REAL;
			Net.Winner = NO_WINNER;
			for (i=0; i<Net.F2.Units; i++) 
			{
				if (!Net.F2.Inhibited[i]) 
				{
					Sum = 0;
					for (j=0; j<Net.F1.Units; j++) 
					{
						Sum += Net.F2.Weight[i][j] * BINARY(Net.F1.Output[j]);
					}
					if (Sum > MaxOut) 
					{
						MaxOut = Sum;
						Net.Winner = i;
					}
				}
				Net.F2.Output[i] = false;
			}
			if (Net.Winner != NO_WINNER)
				Net.F2.Output[Net.Winner] = true;
		}


		void PropagateToF1(ref NET Net, bool[] Input)
		{
			int  i;
			double Sum, Activation;
   
			for (i=0; i<Net.F1.Units; i++) 
			{
				Sum = Net.F1.Weight[i][Net.Winner] * BINARY(Net.F2.Output[Net.Winner]);
				Activation = (BINARY(Input[i]) + Net.D1 * Sum - Net.B1) /
					(1 + Net.A1 * (BINARY(Input[i]) + Net.D1 * Sum) + Net.C1);
				Net.F1.Output[i] = (Activation > 0);
			}
		}


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


		double Magnitude(ref NET Net, bool[] Input)
		{
			int  i;
			double Magnitude;

			Magnitude = 0;
			for (i=0; i<Net.F1.Units; i++) 
			{
				Magnitude += BINARY(Input[i]);
			}
			return Magnitude;
		}


		void AdjustWeights(ref NET Net)
		{
			int  i;
			double MagnitudeInput_;

			for (i=0; i<Net.F1.Units; i++) 
			{
				if (Net.F1.Output[i]) 
				{
					MagnitudeInput_ = Magnitude(ref Net, Net.F1.Output);
					Net.F1.Weight[i][Net.Winner] = 1;
					Net.F2.Weight[Net.Winner][i] = Net.L / (Net.L - 1 + MagnitudeInput_);
				}
				else 
				{
					Net.F1.Weight[i][Net.Winner] = 0;
					Net.F2.Weight[Net.Winner][i] = 0;
				}
			}
		}


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


		void SimulateNet(ref NET Net, bool[] Input, bool[] Output)
		{
			int  i;
			bool Resonance, Exhausted;
			double MagnitudeInput, MagnitudeInput_;

			WriteInput(ref Net, Input);      
			for (i=0; i<Net.F2.Units; i++) 
			{
				Net.F2.Inhibited[i] = false;
			}
			Resonance = false;
			Exhausted = false;
			do 
			{
				SetInput(ref Net, Input);
				PropagateToF2(ref Net);
				GetOutput(ref Net, Output);
				if (Net.Winner != NO_WINNER) 
				{
					PropagateToF1(ref Net, Input);
					MagnitudeInput = Magnitude(ref Net, Input);
					MagnitudeInput_ = Magnitude(ref Net, Net.F1.Output);
					if ((MagnitudeInput_ / MagnitudeInput) < Net.Rho)
						Net.F2.Inhibited[Net.Winner] = true;
					else
						Resonance = true;
				}
				else Exhausted = true;
			} while (!(Resonance || Exhausted));
			if (Resonance)
				AdjustWeights(ref Net);
			WriteOutput(ref Net, Output);      
		}


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


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

			GenerateNetwork(ref Net);
			InitializeApplication(ref Net);

			for (n=0; n<NUM_DATA; n++) 
			{
				SimulateNet(ref Net, Input[n], Output[n]);
			}

			FinalizeApplication(ref Net);
		}
	}
}