/***************************************************
  Starter code for CS182 Part2
  Assignment 4: Backpropagation
  Unit.java
  **************************************************/

import java.util.*;


/**
 * Unit is the basic unit of a neural network.
 */
public class Unit {

  // Unit attributes
  // ** to be filled in **

  // The following Unit attributes are suggested starting points
  // for the assignment. You may wish to modify them as necessary
  // for your particular implementation.
				
  Vector in;			// input Units for this Unit
  
  Vector out;			// output Units for this Unit

  double[] inWeights;		// current (input) weights for this Unit

  double activation;		// this unit's activation level

  double error;			// this unit's error

  double delta;			// this unit's delta

  double weightChange[];	// weight changes for each weight

  int index;			// index number for this Unit

  Net net;			// network this unit belongs to



  /**
   * Constructor for Unit class.
   * Takes an index number and Net to which Unit belongs. 
   * 
   */
  public Unit () {
  	in = new Vector();
  	out = new Vector();
  }

  public void addIncomingUnit(Unit inUnit) {
  	this.in.add(inUnit);
  }
  public void setOutgoingUnit(Unit outUnit) {
  	this.out.add(outUnit);
  }
  
  // Below are some suggested methods that you may wish to complete
  // and use in your implementation.


  /**
   * initalize()
   * Randomize all incoming weights between the network's
   * minimum and maximum weights, including bias weights.
   */
  public void initialize() {
  	this.inWeights = new double[in.size()];
  	for(int i=0; i<in.size(); i++) {
  		inWeights[i] = getRandom(Net.MIN_WEIGHT, Net.MAX_WEIGHT);
  	}
  	weightChange = new double[in.size()];
  }

  /**
   * computeActivation()
   * Compute output activation of this unit.
   * Apply sigmoid function to weighted sum of inputs.
   */
  public double computeActivation() {
  	this.activation = 0;
  	for(int i = 0; i<in.size(); i++) {
  		activation += ( ((Unit)in.elementAt(i)).activation * inWeights[i]);
  	}
  	activation = 1.0 / (1.0 + Math.exp(- activation) ); 
  	return activation;
  }

  /** 
   * computeError(targets)
   * 
   * Computes error for the output node.
   * 
   * @param target is the current true output
   */
  public void computeError(int target) {
    error = (target - activation);
    delta = error *  activation * (1 - activation); // hidden nodes have a different delta than output nodes
  }

  /** 
   * computeWeightChange()
   * 
   * Calculate the current weight change, including a momentum factor.
   */
  public void computeWeightChange() {
  	for(int i=0; i<in.size(); i++) {
  		weightChange[i] = (Net.momentum * weightChange[i]);  // momentum term
  		weightChange[i] += Net.learningRate * delta *((Unit)in.elementAt(i)).activation;
  	}
   }
  
  /** 
   * Update changes to weights for this pattern.
   */
  public void updateWeights() {
  	for(int i=0; i<in.size(); i++) {
  		inWeights[i] += weightChange[i];
  	}
  }

  // additional methods 
  // ** to be filled in **

  /** 
    Return a random number between min and max.
   */
  Random randy = new Random();
  public double getRandom(double min, double max) {
  	return (randy.nextDouble() * (max - min)) + min;
  }

}