import java.util.*;
   import java.io.*;
   import java.lang.Math;
 
    class neural_net_blah_2
   {
       public static void main(String args[])
      {
		//mod 3?
		//numbers 1-8..maybe. test 5.
         net nn = new net(3,2,3);

         for(int k=0;k<10;k++) {
			int testnum=(int)(Math.random()*8);
			while(testnum==6)
			{
			testnum=(int)(Math.random()*8);
			}
			double in_test[]=new double[3];
			in_test[0]=(int)(testnum/8);
			testnum-=in_test[0];
			
			in_test[1]=(int)(testnum/4);
			testnum-=in_test[1];
			
			in_test[2]=testnum;
			
			System.out.println(testnum+" " + in_test[0]+":"+in_test[1]+":"+in_test[2]);
			
         }
      	
			double in_test[]={1.0,1.0,0.0};
         nn.test(ex_in);
      //   nn.display();
      }
   }

    class neuron
   {
      public static int NEXT_ID=1;
      public int ID;
      public double weights[];
      public neuron[] neighbors; //things that fire to it
      public int num_neighbors=0;
      public int max_neighbors;
      public double sum=0;
      public double output=0;
      public double delta=0;
      public double dws=0;

       public neuron(int m)
      {
         ID=NEXT_ID++;
         max_neighbors=m;
         weights=new double[max_neighbors];
         neighbors=new neuron[max_neighbors];	 
      }
      
       public void clear()
      {
         sum=0;
         output=0;
         delta=0;
         dws=0;
      }
      
       public void setWeights(double[] w)
      {
         weights=w;
      }
       
       public void randomize_weights()
      {
         for(int i=0;i<num_neighbors;i++)
         {
            weights[i]=Math.random()*2-1; //assuming bipolar
         }
      }
   		
       public void fireTo(neuron target)
      {
         target.firedBy(this);
      }
   	
       public void firedBy(neuron before)
      {
         if(num_neighbors==max_neighbors-1)
         {
            System.out.println("Too many neighbors..");
            return; 
         }
         neighbors[num_neighbors]=before;
         num_neighbors++;
      }

       public double sumUp()
      {
         double ct=0;
         for(int i=0;i<num_neighbors;i++)
         {
            ct+=weights[i]*neighbors[i].output;
         }
         sum=ct;
         return ct;
      }
   	
       public double eval()
      {
         output=sigmoid(sum);
         return output;
      }
      
       public double sigmoid(double x)
      {
         return 1/(1+Math.exp(-x));
      }
   	
      //g'(in) for sigmoid is g'=g(1-g)
       public double deriv_sigmoid(double x)
      {
         return sigmoid(x)*(1-sigmoid(x));
      }

   	//train
   	
       private double outError(double O, double D)
      {
         return (D-O)*O*(1-O);
      
      }
      
       void display()
      {
         System.out.println("Neuron ID: " + ID + " sum: " + rounded(sum) + " eval: " + rounded(output) +  " delta: " + rounded(delta));
         System.out.println("Things that fire to this neuron: ");
         for(int i=0;i<num_neighbors;i++)
         {
            System.out.println("\t "+neighbors[i].ID+" weight: "+ rounded(weights[i]) );
         }
         System.out.println();
      }
   	
       double rounded(double n)
      {
         return (double)((int)(n*100))/100;
      }
   
   }

    class net
   {
      public layer input;
      public layer output;
      public layer hidden;
      public layer bias;
   	
       public net(int a, int b, int c)
      {
         input = new layer(a);
         hidden = new layer(b);
         output = new layer(c);
         bias=new layer(a+b+c+10);
         bias.setValues(-1);
         connectAll();
         randomize_weights();
      }
       public void randomize_weights()
      {
         output.randomize_weights();
         hidden.randomize_weights();
      }
       public void connectAll()
      {
         hidden.firedByLayer(input);
         output.firedByLayer(hidden);
         hidden.connectBias(bias);
         output.connectBias(bias);  
      	
      	
      }
       public void display()
      {
         System.out.println("=================Displaying Neural Net=================");
         System.out.println("------Displaying input layer-------");
         input.display();
         System.out.println("------Displaying hidden layer------");
         hidden.display();
         System.out.println("------Displaying output layer------");
         output.display();
         System.out.println("-----------------------------------");
         System.out.println();
      }
      
       public  void initInput(double[] n)
      {
         for(int i=0;i<input.num_neurons;i++)
         {
            input.neurons[i].sum=n[i];
            input.neurons[i].output=n[i];
         }
      }
      
       //for each e in examples do
      	//for each node j in input layer, a_j <- example_input[j]
      	//for layer = 2 (not input) to L do
      		//in_i <- sum W_j,i*a_j
      		//a_i <- g(in_i)
      	//for each node i in output layer
      		//delta_i <- g'(in_i) x (example_output[j]-a_i)
      	//for l=L-1 to 1 do
      		//for each node j in layer l do	
      			//delta_j <- g'(in_j)*sum(W_j,i*delta(i))
      			//for each node i in layer l+1 do
      				//W_j,i <- W_j,i + alpha x a_j x delta_i
      //until some stopping criterion is satisfied
   	
       public void test(double[] example_input)
      {
         input.clear();
         hidden.clear();
         output.clear();

         initInput(example_input);
         hidden.sumUp();	
         hidden.eval();
      	
         output.sumUp();
         output.eval();
         output.display();
      }
   	     
      //for each e in examples do .. err, call this method multiple times
       public void backProp(double[] example_input, double[] example_output)
      {
      //see page 746 in AI book
      
         input.clear();
         hidden.clear();
         output.clear();
      
      	//for each node j in input layer, a_j <- example_input[j]
         initInput(example_input);
      	//for layer = 2 (not input) to L do
      		//in_i <- sum W_j,i*a_j
      		//a_i <- g(in_i)
         hidden.sumUp();	
         hidden.eval();
      	
         output.sumUp();
         output.eval();

      //g'(in) for sigmoid is g'=g(1-g)

      	//for each node i in output layer
      		//delta_i <- g'(in_i) x (example_output[j]-a_i)
         output.getDelta_output(example_output);
         //display();
      	//for l=L-1 to 1 do [supposed to be a loop but i dont have my layers organized like this]
      	
      		//for each node j in hidden layer do
      			//delta_j <- g'(in_j)*sum(W_j,i*delta(i))
         output.setDeltaWeightSums(); //sets delta weight sums for hidden so that it can calculate delta
         hidden.getDelta();
         	
      			//for each node i in layer l+1 do
      				//W_j,i <- W_j,i + alpha x a_j x delta_i
         output.adjustWeights(); //adjusts weights between hidden and output			
      
      		//for each node j in input layer do	
      			//delta_j <- g'(in_j)*sum(W_j,i*delta(i))
         hidden.setDeltaWeightSums();
         input.getDelta();	
      			//for each node i in layer l+1 do
      				//W_j,i <- W_j,i + alpha x a_j x delta_i
         hidden.adjustWeights();			
      }
   }

    class layer
   {
      public int num_neurons;
      public neuron neurons[];
      //not sure how to represent learning rate..
   
       public layer(int size)
      {
         num_neurons=size;
         neurons=new neuron[size];
         for(int i=0;i<num_neurons;i++)
         {
            neurons[i]=new neuron(20); //umm, maybe not 20
         }
      }
       public void randomize_weights()
      {
         for (int i=0;i<num_neurons;i++)
         {
            neurons[i].randomize_weights();
         }
      }
       public void firedByLayer(layer L)
      {
         for(int i=0;i<num_neurons;i++)
         {
            for(int j=0;j<L.num_neurons;j++)
            {
               neurons[i].firedBy(L.neurons[j]);
            }
         }
      
      }
     
       void sumUp() //sum; this layer fires to L.
      {
         for(int i=0;i<num_neurons;i++)
         {
            neurons[i].sumUp();
         }
      }
      
       void eval() //sigmoid function or whatnot
      {
         for(int i=0;i<num_neurons;i++)
         {
            neurons[i].eval();
         }
      }
      
       void getDelta_output(double[] expected)
      {
      	//for each node i in output layer
      		//delta_i <- g'(in_i) x (example_output[j]-a_i)
         for(int i=0;i<num_neurons;i++)
         {
            neurons[i].delta=neurons[i].deriv_sigmoid(neurons[i].sum)*(expected[i]-neurons[i].output);
         }
      }
      
       void setDeltaWeightSums() //for the layer that inputs to it
      {
         for(int i=0;i<num_neurons;i++)
         {
            for(int j=0;j<neurons[i].num_neighbors;j++)
            {
               neuron neighbor=neurons[i].neighbors[j]; //neighbor fires to neurons[i]
               neighbor.dws+=neurons[i].weights[j]*neurons[i].delta;
            }
         }
      }
   	
       void getDelta() //for not-output layer
      {
      //delta_j <- g'(in_j)*sum(W_j,i*delta(i))
         for(int i=0;i<num_neurons;i++)
         {//wow. where / what to do with deriv methods?
            neurons[i].delta=neurons[i].deriv_sigmoid(neurons[i].sum)*(neurons[i].dws);
         }//delta weight sum depends on layer a neuron fires to, not from
      }
      
   	
       void adjustWeights() 
      {
         double alpha = 0.25; //learning rate
         for(int i=0;i<num_neurons;i++)
         {
            for(int j=0;j<neurons[i].num_neighbors;j++)
            {
               neuron neighbor=neurons[i].neighbors[j];
               neurons[i].weights[j]+=alpha*neighbor.output*neurons[i].delta;
            }
         }
      }

       void clear()
      {
         for(int i=0;i<num_neurons;i++)
         {
            neurons[i].clear();
         }
      }
   	
       void connectBias(layer bias)
      {
         for(int i=0;i<num_neurons;i++)
         {
            neurons[i].firedBy(bias.neurons[neurons[i].ID]);
         }
      }

   //later separate out evaluating and summing
       void display()
      {
         System.out.println("===========================");
         for(int i=0;i<num_neurons;i++)
         {
            neurons[i].display();//System.out.print(neurons[i].rounded(neurons[i].output) + " ");
         }
         System.out.println();
      }
   
       void setValues(double n)
      {
         for(int i=0;i<num_neurons;i++)
         {
         neurons[i].sum=-1;
         neurons[i].output=-1;
         }
      
      }
   
   }