Stuff

using System;
using System.IO;

namespace AIProject {
	class BackPropagationNeuralNetwork 
	{
		private int Mode; // 0:binary 1:bipolar

		private int MaxEpoch;
		private int Epoch;
		private int NumberOfInput;
		private int NumberOfOutput;
		private double alpha;
		private double TestSetError;
		private double ErrorLimit;
		private int maxiter;
		private int NumberOfHiddenUnit;

		private int[][] training_data_input;
		private int[][] training_data_output;

		private double[] x;
		private double[] y;
		private double[] y_in;
		private double[] delta_y;
		private double[] z_in;
		private double[] delta_z_in;
		private double[] z;
		private double[] delta_z;
		private double[][] v;
		private double[][] delta_v;
		private double[][] w;
		private double[][] delta_w;

		public int getMode() {
			return Mode;
		}

		public void setMode(int newmode) {
			Mode=newmode;
		}

		public int getNumberOfOutput() {
			return NumberOfOutput;
		}

		public int getNumberOfInput() {
			return NumberOfInput;
		}

		public int getMaxEpoch() {
			return MaxEpoch;
		}

		public void setMaxEpoch(int newmaxepoch) {
			MaxEpoch=newmaxepoch;
		}

		public int getNumberOfHiddenUnit() {
			return NumberOfHiddenUnit;
		}

		public double getAlpha() {
			return alpha;
		}

		public void setAlpha(double newalpha) {
			alpha=newalpha;
		}

		public double getErrorLimit() {
			return ErrorLimit;
		}

		public void setErrorLimit(double errlimit) {
			ErrorLimit=errlimit;
		}

		public int getMaximumNumberOfIteration() {
			return maxiter;
		}

		public void setMaximumNumberOfIteration(int iter) {
			maxiter=iter;
		}

		public double getTestSetError() {
			return TestSetError;
		}

		public int SaveToFile(string FileName) {
			if (System.IO.File.Exists(FileName)) {
				System.Console.WriteLine("{0} sudah ada.", FileName);
				return 1;
			}
			System.IO.StreamWriter sr = System.IO.File.CreateText(FileName);
			sr.Close();
			return 0;
		}

		public int LoadFromFile(string FileName) {
			try {
				using (StreamReader sr = new StreamReader(FileName)) {
					String line;
					while ((line = sr.ReadLine()) != null) {
						
					}
				}
			}
			catch (Exception e) {
				Console.WriteLine("The file could not be read:");
				Console.WriteLine(e.Message);
				return 1;
			}
			return 0;
		}

		
		public void setV(int[] new_v) {
			Array.Copy(new_v,v,new_v.Length);
		}

		public void setW(int[] new_w) {
			Array.Copy(new_w,w,new_w.Length);
		}

		public void AddTrainingDataInput(int[] input) {
			//TODO: add checking to the number of input, make sure it's consistent
			if (training_data_input==null) {
				training_data_input=new int[1][];
				training_data_input[0]=input;
			} else {
				int[][] temp=new int[training_data_input.Length+1][];
				Array.Copy(training_data_input,temp,training_data_input.Length);
				Array.Copy(input,training_data_input[training_data_input.GetUpperBound(0)],input.Length);
			}
		}

		public void AddTrainingDataOutput(int[] output) {
			if (training_data_output==null) {
				training_data_output=new int[1][];
				training_data_output[0]=output;
			} else {
				int[][] temp=new int[training_data_output.Length+1][];
				Array.Copy(training_data_output,temp,training_data_output.Length);
				Array.Copy(output,training_data_output[training_data_output.GetUpperBound(0)],output.Length);
			}
		}

		public void  train() {
			int repx;
			double error;
			while ( (Epoch<MaxEpoch) && (TestSetError>ErrorLimit) ) {
				error=0;
				for (repx=0;repx<training_data_input.Length;repx++) {
					//feed forward
					int i,j,k;
					for (i=1;i<=NumberOfInput;i++) {
						x[i]=training_data_input[repx][i];
					}
					for (j=1;i<=NumberOfHiddenUnit;j++) {
						z_in[j]=v[0][j];
						for (i=1;i<=NumberOfInput;i++) {
							z_in[j]=z_in[j]+x[i] * v[i][j];
						}
						if (Mode==1) {
							z[j]=1/(1+Math.Exp(-z_in[j]));
						} else if (Mode==0) {
							z[j]=(2/(1+Math.Exp(-z_in[j])))-1;
						}
					}
					for (k=1;k<=NumberOfOutput;k++) {
						y_in[k]=w[0][k];
						for (j=1;j<=NumberOfHiddenUnit;j++) {
							y_in[k]=y_in[k]+z[j] * w[j][k];
						}
						y[k]=1/(1+Math.Exp(-y_in[k]));
					}
					//backpropagation of eror
					for (k=1;k<=NumberOfOutput;k++) {
						delta_y[k]=(training_data_output[repx][0]-y[k]) * (y[k] * (1-(y[k])));
						for (j=1;j<=NumberOfHiddenUnit;j++) {
							delta_w[k][j]=alpha * delta_y[k] * z[j];
						}
						delta_w[k][0]=alpha * delta_y[k];
					}
					for (j=1;j<=NumberOfHiddenUnit;j++) {
						for (k=1;k<=NumberOfOutput;k++) {
							delta_z_in[j]=delta_y[k] * w[k][j];
						}
						delta_z[j]=delta_z_in[j] * (z[j] * (1-z[j]));
						for (i=1;i<=NumberOfInput;i++) {
							delta_v[i][j]=alpha * delta_z[j] * x[i];
						}
						delta_v[j][0]=alpha * delta_z[j];
					}
					//weigth adj n bias
					for (k=1;k<=NumberOfOutput;k++) {
						for (j=0;j<=NumberOfHiddenUnit;j++) {
							w[k][j]=w[k][j]+delta_w[k][j];
						}
					}
					for (j=1;j<=NumberOfHiddenUnit;j++) {
						for (i=0;i<=NumberOfInput;i++) {
							v[j][i]=v[j][i]+delta_v[j][i];
						}
					}
					error=error+Math.Sqrt(training_data_output[repx][0]-y[1]);
				}
				TestSetError=error;
				Epoch++;
			}
			   
		}
				
		private void InitializeDataStructure() {
			x=new double[NumberOfInput];
			y=new double[NumberOfOutput];
			y_in=new double[NumberOfOutput];
			delta_y=new double[NumberOfOutput];
			z=new double[NumberOfHiddenUnit];
			z_in=new double[NumberOfHiddenUnit];
			delta_z=new double[NumberOfHiddenUnit];
			delta_z_in=new double[NumberOfHiddenUnit];
			v=new double[NumberOfInput][];
			delta_v=new double[NumberOfInput][];
			w=new double[NumberOfOutput][];
			delta_w=new double[NumberOfOutput][];
		}

		public BackPropagationNeuralNetwork(int mxep,double errlim,int numin,int numout,int numhid, double alp) {
			MaxEpoch=mxep;
			ErrorLimit=errlim;
			NumberOfOutput=numout;
			NumberOfInput=numin;
			NumberOfHiddenUnit=numhid;
			InitializeDataStructure();
		}
		
		public BackPropagationNeuralNetwork(string filename) {
			LoadFromFile(filename);
		}
	}

	class MainClass {
		public static void Main(string[] args){
			BackPropagationNeuralNetwork temp=new BackPropagationNeuralNetwork("experience.data");
		}
	}
}