///////////////////////////////////////////////////////////////
//                                                           //
//  bneuron.cpp - model basic neuron                         //
//                                                           //
//  version:      1.3                                        //
//  Language:     Visual C++, ver 5.0                        //
//  Platform:     Micron Dual Pentium Pro 200                //
//                Windows NT 4.0, service pack 3             //
//  Application:  ELE591/791 Example                         //
//  Author:       Jim Fawcett                                //
//                CST 2-187, (315) 443-3948                  //
//                fawcett@neptune.syr.edu                    //
//                                                           //
///////////////////////////////////////////////////////////////

#include <iostream>
#include <iomanip>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include "bneuron.h"

using namespace std;

//----< static factory function >------------------------------

neuron* neuron::makeNeuron(const neuron &n) {

  return n.clone();
}

//----< cloning neurons >--------------------------------------

neuron* neuron::clone() const {

  neuron *temp;
  try {
    temp = new neuron(*this);       // copy of self
  } catch(...) {
    throw "memory allocation failure\n";
    return 0;
  }
  return temp;
}

//----< sizing constructor >-----------------------------------

neuron::neuron(int inputs) : wts(inputs), ins(inputs) {

  int i;
  for(i=0; i<inputs; i++) {
    ins[i] = 1.0;
    wts[i] = 0.1;
  }
}

//

//----< resize neuron arrays >---------------------------------

void neuron::size(int n) {

  if(n<=0) {
    cout << "  invalid size parameter " << n << endl;
    return;
  }
  ins.size(n);    // vector resize
  wts.size(n);    //   "      "
}

//----< copy constructor >-------------------------------------

neuron::neuron(const neuron &n) : wts(n.wts), ins(n.ins) { }

//----< assignment operator >----------------------------------

neuron& neuron::operator=(const neuron &n) {

  if(this == &n) return *this;
  wts = n.wts;
  ins = n.ins;
  return *this;
}

//----< check input index >------------------------------------

int neuron::chkIndex(int i) {

  if(i<0 || ins.size()<=i) {
    cout << "  domain error in neuron::chkIndex(" << i << ")\n";
    exit(1);
  }
  return i;
}

//----< access value of ith weight >---------------------------

double& neuron::weight(int i) { return wts[chkIndex(i)]; }

//----< access value of ith input >----------------------------

double& neuron::input(int i) { return ins[chkIndex(i)]; }

//----< access input vector >----------------------------------

vec<double>& neuron::inputs() { return ins; }

//

//----< access weights >---------------------------------------

vec<double>& neuron::weights() { return wts; }

//----< initialize weights with random values >----------------

void neuron::randWts(double min, double max, bool newSeed) {

  static int count = 654321;
  static bool beenHere = false;

  double scaleFactor = (max-min)/RAND_MAX;
  if(newSeed || !beenHere) {
    count += 123456;
    srand((unsigned)time(NULL) + count);
    beenHere = true;
  }
  int i;
  for(i=0; i<wts.size(); i++)
    wts[i] = rand()*scaleFactor + min;
}

//----< input to neuron function >-----------------------------

double neuron::sum() {

  double _sum = wts[0];  // bias
  int i;
  for(i=1; i<ins.size(); i++)
    _sum += wts[i]*ins[i];
  return _sum;
}

//

//----< output nonlinearity >----------------------------------

double neuron::outFunc(double sum) {

  if(sum > 0) return  1;
  if(sum < 0) return -1;
  return 0;
}

//----< output nonlinearity slope >----------------------------

double neuron::slope(double sum) { return 0; }

//----< fetch neuron output >----------------------------------

double neuron::output() { return outFunc(sum()); }

//----< derivative of output >---------------------------------

double neuron::outDeriv() { return slope(sum()); }

//----< display neuron elements >------------------------------

void neuron::display(ostream &out, char *msg) {

  if(msg) out << msg << '\n';
  out << "  neuron size = " << ins.size() << '\n';
  out << "  weights:\n"; wts.display(out);
  out << "  inputs:\n";  ins.display(out);
  out << "  sum = " << sum() << '\n';
}

//

//----< sigmoid neuron output function >-----------------------

double sneuron::outFunc(double sum) { return (1.0/(1.0+exp(-sum))); }

//----< slope of sigmoid function >----------------------------

double sneuron::slope(double sum) { 
  
  return (outFunc(sum)*(1.0-outFunc(sum))); 
}

//----< cloning sigmoid neurons >------------------------------

neuron* sneuron::clone() const {

  neuron* temp;
  try {
    temp = new sneuron(*this);      // copy of self
  } catch(...) {
    throw "memory allocation failure\n";
    return 0;
  }
  return temp;
}


//----< linear neuron output function >------------------------

double lneuron::outFunc(double sum) { return sum; }

//----< slope of linear function >-----------------------------

double lneuron::slope(double sum) { return 1.0; }

//----< cloning linear neurons >-------------------------------

neuron* lneuron::clone() const {

  neuron* temp;
  try {
    temp = new lneuron(*this);      // copy of self
  } catch(...) {
    throw "memory allocation failure\n";
    return 0;
  }
  return temp;
}


//

//----< test stub >--------------------------------------------

#ifdef TEST_BNEURON

void main() {

  cout << "  Simulation of a Basic Neuron  \n"
       << " ============================== \n\n";

  const int numInputs = 2;
  double min=-1, max=3, inc=3;

  neuron Einstein1(numInputs);
  int i;
  for(i=0; i<numInputs; i++) {
    Einstein1.weight(i) = 0.2 + 0.2*i;
  }

  double val;
  // Einstein1.input(0) is a bias
  for(val = min; val < max; val += inc) {
    Einstein1.input(1) = val;
    Einstein1.display(cout,"switching neuron:");
    cout << "  output = " << setw(2) << Einstein1.output() << '\n';
  }
  cout << endl;

  cout << "\n  Test void, copy construction and assignment:"
       << "\n ==============================================\n\n";

  neuron anotherEinstein1 = Einstein1;
  Einstein1.display(cout,"Einstein1 neuron:");
  anotherEinstein1.display(cout,"a copy of Einstein1 neuron:");

  neuron lastEinstein1;
  lastEinstein1 = anotherEinstein1;
  anotherEinstein1.display(cout,"result of assigning Einstein1:");


  cout << "\f  Simulation of a Sigmoid Neuron  \n"
       << " ================================ \n\n";

  sneuron Einstein2(numInputs);
  for(i=0; i<numInputs; i++) {
    Einstein2.weight(i) = 0.2 + 0.2*i;
  }

  // Einstein2.input(0) is a bias;
  for(val = min; val < max; val += inc) {
    Einstein2.input(1) = val;
    Einstein2.display(cout,"sigmoid neuron:");
    cout << "  output = " << setw(2) << Einstein2.output() << '\n';
  }
  cout << endl;

//

  cout << "\n  Test void, copy construction and assignment:"
       << "\n ==============================================\n\n";

  neuron anotherEinstein2 = Einstein2;
  Einstein2.display(cout,"Einstein2 neuron:");
  anotherEinstein2.display(cout,"a copy of Einstein2 neuron:");

  neuron lastEinstein2;
  lastEinstein2 = anotherEinstein2;
  anotherEinstein2.display(cout,"result of assigning Einstein2:");


  cout << "\f  Simulation of a linear Neuron  \n"
       << " ================================= \n\n";

  lneuron Einstein3(numInputs);
  for(i=0; i<numInputs; i++) {
    Einstein3.weight(i) = 0.2 + 0.2*i;
  }

  // Einstein3.input(0) is a bias
  for(val = min; val < max; val += inc) {
    Einstein3.input(1) = val;
    Einstein3.display(cout,"linear neuron:");
    cout << "  output = " << setw(2) << Einstein3.output() << '\n';
  }
  cout << endl;

  cout << "\n  Test void, copy construction and assignment:"
       << "\n ==============================================\n\n";

  neuron anotherEinstein3 = Einstein3;
  Einstein3.display(cout,"Einstein3 neuron:");
  anotherEinstein3.display(cout,"a copy of Einstein3 neuron:");

  neuron lastEinstein3;
  lastEinstein3 = anotherEinstein3;
  anotherEinstein3.display(cout,"result of assigning Einstein3:");

  cout << "\n  Test initializing with random weights:"
       << "\n ========================================\n\n";

  lneuron testRand(4);
  testRand.randWts(-0.2,0.2,true);
  testRand.display(cout,"weights seeded from clock");
  testRand.randWts(-0.2,0.2,false);
  testRand.display(cout,"fixed seed weights");
  testRand.randWts(-0.2,0.2,false);
  testRand.display(cout,"fixed seed weights again");
}

#endif