using System;
using System.Windows.Forms;

namespace aiNnFingers
{
	public class BOLTZMAN
	{
		public BOLTZMAN()
		{

		}

		public RichTextBox richTextBox;

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

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

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

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

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


		public struct NET
		{                     /* A NET:                                */
			public int           Units;         /* - number of units in this net         */
			public bool[]         Output;        /* - output of ith unit                  */
			public int[]          On;            /* - counting on states in equilibrium   */
			public int[]          Off;           /* - counting off states in equilibrium  */
			public double[]         Threshold;     /* - threshold of ith unit               */
			public double[][]        Weight;        /* - connection weights to ith unit      */
			public double          Temperature;   /* - actual temperature                  */
		} 


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


		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; //268 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_CITIES    10
		const int NUM_CITIES = 10;
		//#define N             (NUM_CITIES * NUM_CITIES)
		const int N = NUM_CITIES * NUM_CITIES;

		double                  Gamma;
		double [][]                 Distance = new double[NUM_CITIES][]; //NUM_CITIES

		//FILE*                 f;

		void InitializeApplication(ref NET Net)
		{
			int  n1,n2;
			double x1,x2,y1,y2;
			double Alpha1, Alpha2;

			Gamma = 7;
			for (n1=0; n1<NUM_CITIES; n1++) 
			{
				Distance[n1] = new double[NUM_CITIES];

				for (n2=0; n2<NUM_CITIES; n2++) 
				{
					Alpha1 = ((double) n1 / NUM_CITIES) * 2 * Math.PI;
					Alpha2 = ((double) n2 / NUM_CITIES) * 2 * Math.PI;
					x1 = Math.Cos(Alpha1);
					y1 = Math.Sin(Alpha1);
					x2 = Math.Cos(Alpha2);
					y2 = Math.Sin(Alpha2);
					//Distance[n1][n2] = sqrt(sqr(x1-x2) + sqr(y1-y2));
					double xSub = x1-x2;
					double ySub = y1-y2;
					double xSqr = xSub * xSub;
					double ySqr = ySub * ySub;
					Distance[n1][n2] = Math.Sqrt(xSqr + ySqr);
				}
			}
			//f = fopen("BOLTZMAN.txt", "w");
			richTextBox.AppendText("Temperature    Valid    Length    Tour\n\n");
			//fprintf(f, "Temperature    Valid    Length    Tour\n\n");
		}


		void CalculateWeights(ref NET Net)
		{
			int  n1,n2,n3,n4;
			int  i,j;
			int  Pred_n3, Succ_n3;
			double Weight;

			for (n1=0; n1<NUM_CITIES; n1++) 
			{
				for (n2=0; n2<NUM_CITIES; n2++) 
				{
					i = n1*NUM_CITIES+n2;
					for (n3=0; n3<NUM_CITIES; n3++) 
					{
						for (n4=0; n4<NUM_CITIES; n4++) 
						{
							j = n3*NUM_CITIES+n4;
							Weight = 0;
							if (i!=j) 
							{
								Pred_n3 = (n3==0 ? NUM_CITIES-1 : n3-1);
								Succ_n3 = (n3==NUM_CITIES-1 ? 0 : n3+1);
								if ((n1==n3) || (n2==n4))
									Weight = -Gamma;
								else if ((n1 == Pred_n3) || (n1 == Succ_n3))
									Weight = -Distance[n2][n4];
							}
							Net.Weight[i][j] = Weight;
						}
					}
					Net.Threshold[i] = -Gamma/2;
				}
			}
		}


		bool ValidTour(ref NET Net)
		{
			int n1,n2;
			int Cities, Stops;

			for (n1=0; n1<NUM_CITIES; n1++) 
			{
				Cities = 0;
				Stops  = 0;
				for (n2=0; n2<NUM_CITIES; n2++) 
				{
					if (Net.Output[n1*NUM_CITIES+n2]) 
					{
						if (++Cities > 1) 
							return false;
					}
					if (Net.Output[n2*NUM_CITIES+n1]) 
					{
						if (++Stops > 1) 
							return false;
					}
				}
				if ((Cities != 1) || (Stops != 1))
					return false;
			}
			return true;
		}


		double LengthOfTour(ref NET Net)
		{
			int  n1,n2,n3;
			double Length;

			Length = 0;
			for (n1=0; n1<NUM_CITIES; n1++) 
			{
				for (n2=0; n2<NUM_CITIES; n2++) 
				{
					if (Net.Output[((n1) % NUM_CITIES)*NUM_CITIES+n2])
						break;
				}
				for (n3=0; n3<NUM_CITIES; n3++) 
				{
					if (Net.Output[((n1+1) % NUM_CITIES)*NUM_CITIES+n3])
						break;
				}
				Length += Distance[n2][n3];
			}
			return Length;
		}


		int iter = 0;
		void WriteTour(ref NET Net)
		{
			int  n1,n2;
			bool First;

			iter = iter + 1;
			Application.DoEvents();
			if (ValidTour(ref Net))
			{
				double out1 = Net.Temperature;
				double out2 = LengthOfTour(ref Net);
				richTextBox.AppendText(iter.ToString() + "  " + out1.ToString("F5") + "\tyes\t" + out2.ToString("F3"));
				//fprintf(f, "%11.6f      yes    %6.3f    ", Net.Temperature, LengthOfTour(Net));
			}
			else
			{
				double out1 = Net.Temperature;
				richTextBox.AppendText(iter.ToString() + "  " + out1.ToString("F5") + "\tno\t");
				//fprintf(f, "%11.6f       no              ", Net.Temperature);
			}

			for (n1=0; n1<NUM_CITIES; n1++) 
			{
				First = true;
				richTextBox.AppendText("[");
				//fprintf(f, "[");
				for (n2=0; n2<NUM_CITIES; n2++) 
				{
					if (Net.Output[n1*NUM_CITIES+n2]) 
					{
						if (First) 
						{
							First = false;
							richTextBox.AppendText(n2.ToString());
							//fprintf(f, "%d", n2);
						}
						else 
						{
							richTextBox.AppendText(", " + n2.ToString());
							//fprintf(f, ", %d", n2);
						}
					}
				}
				richTextBox.AppendText("]");
				//fprintf(f, "]");
				if (n1 != NUM_CITIES-1) 
				{
					richTextBox.AppendText(" . ");
					//fprintf(f, " . ");
				}
			}
			richTextBox.AppendText("\n");
			//fprintf(f, "\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 bool[N]; //(bool*)  calloc(N, sizeof(bool));
			Net.On        = new int[N]; //(int*)   calloc(N, sizeof(int));
			Net.Off       = new int[N]; //(int*)   calloc(N, sizeof(int));
			Net.Threshold = new double[N]; //(double*)  calloc(N, sizeof(double));
			Net.Weight    = new double[N][]; //(double**) calloc(N, sizeof(double*));

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


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


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

		

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

			Sum = 0;
			for (j=0; j<Net.Units; j++) 
			{
				Sum += Net.Weight[i][j] * (double) BINARY(Net.Output[j]);
			}
			Sum -= Net.Threshold[i];
			Probability = 1 / (1 + Math.Exp(-Sum / Net.Temperature));
			if (RandomEqualREAL(0, 1) <= Probability)
				Net.Output[i] = true;
			else
				Net.Output[i] = false;
		}


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


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

			for (i=0; i<Net.Units; i++) 
			{
				Net.On[i]  = 0;
				Net.Off[i] = 0;
			}

			for (n=0; n<1000*Net.Units; n++) 
			{
				PropagateUnit(ref Net, i = RandomEqualINT(0, Net.Units-1));
			}
			for (n=0; n<100*Net.Units; n++) 
			{
				PropagateUnit(ref Net, i = RandomEqualINT(0, Net.Units-1));
				if (Net.Output[i])
					Net.On[i]++;
				else
					Net.Off[i]++;
			}

			for (i=0; i<Net.Units; i++) 
			{
				Net.Output[i] = Net.On[i] > Net.Off[i];
			}
		}


		void Anneal(ref NET Net)
		{
			Net.Temperature = 100;
			do 
			{
				BringToThermalEquilibrium(ref Net);
				WriteTour(ref Net);
				Net.Temperature *= 0.99;
			} while (!ValidTour(ref Net));
		}


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


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

			InitializeRandoms();
			GenerateNetwork(ref Net);
			InitializeApplication(ref Net);
			CalculateWeights(ref Net);
			SetRandom(ref Net);
			Anneal(ref Net);
			FinalizeApplication(ref Net);
		}
	}
}