thetaNeuron.h

// Summary: Theta neuron class definition
// Author: Sam McKennoch
// Date: 2007-2009

#ifndef THETANEURON_HEADER
#define THETANEURON_HEADER

//standard libraries
#include "stdafx.h"
#include <fstream>
#include <string>
#include <iostream>
#include <cmath>
#include <ctime>

using namespace std;

//Constant Defaults
#define IO -0.001
#define ALPHA 1
#define OFFSET 0.0001
#define TIMESTEP 0.001
#define EPS 1e-10
#define PI 3.14159265
#define MAX_NUM_OUTPUT_SPIKES 5


class thetaNeuron  {

//----------------------------------------------------------------------------------------------------------------
//public methods
//----------------------------------------------------------------------------------------------------------------
public:

        enum Method
        {
                Numerical, 
                EventDriven 
        };

        thetaNeuron(int new_num_inputs = 3.0, double weight_ini = 1e6, double new_io = IO){
                srand((unsigned)time(0));
                weights=new double[new_num_inputs];
                for(int k=0;k<new_num_inputs;k++){
                        if (weight_ini>100)
                                weights[k] = (2.0*rand()/(RAND_MAX + 1.0))-1.0;
                        else
                                weights[k] = weight_ini;
                } 
                num_inputs=new_num_inputs;
                io = new_io;
                if (io>=0) io=IO;
                beta=sqrt(fabs(ALPHA*io));
                positive_fixed_point=acos((1+ALPHA*io)/(1-ALPHA*io));
                phase=positive_fixed_point+OFFSET;
                verbose=1;                                       
                method=Numerical;
        }

        ~thetaNeuron(){ 
                delete [] weights; 
                weights = NULL;
        }


        //Get and Set Methods

        double getPhase(void) {return phase;}

        Method getMethod(void) {return method;}

        void setMethod(Method new_method) {method=new_method;}

        void setVerbose(bool new_verbose) {verbose=new_verbose;}

        double getWeight(int index) {
                if (index<num_inputs) {
                        return weights[index];
                }
                else return -1;
        }

        void setWeight(double new_weight, int index) {
                if (index<num_inputs) {
                        weights[index]=new_weight;
                }
        }

        double getIo(void) {return io;}

        void setIo(double new_io) {
                if (new_io<0) {
                        io=new_io;
                        beta=sqrt(fabs(ALPHA*io));
                        positive_fixed_point=acos((1+ALPHA*io)/(1-ALPHA*io));
                        phase=positive_fixed_point+OFFSET;
                }
        }       

        void displayThetaNeuron(void);

        int runThetaNeuron(double ti[], double ts[], int max_num_ts);

//----------------------------------------------------------------------------------------------------------------
//private members
//----------------------------------------------------------------------------------------------------------------
private:      
        double io; 
        double beta; 
        double positive_fixed_point; 
        double phase; 
        double *weights; 
        int num_inputs; 
        bool verbose; 
        Method method; 
        //Simple Implementation of atanh
        //Assumes -1 < x < 1
        static double atanh(double x)
        {
                return ( 0.5 * log( ( 1.0 + x ) / ( 1.0 - x ) ) );
        }

        //Function perform descending order bubble sort on array
        //The indices sorted indices are returned as well.
        //For example, if array={1.5 0.5 7}, then array will shuffled
        //into {0.5 1.5 7} and indices will be {1 0 2}
        void sortArray(double array[], int indices[], int size)
        {
                bool swap;
                double temp;
                int temp2;
                int n;
                for (n = 0; n < size; n++)
                {
                        indices[n]=n;
                }
                do
                {
                        swap = false;
                        for (n = 0; n < (size - 1); n++)
                        {
                                if (array[n] > array[n + 1])
                                {
                                        temp = array[n];
                                        array[n] = array[n + 1];
                                        array[n + 1] = temp;
                                        temp2 = indices[n];
                                        indices[n] = indices[n + 1];
                                        indices[n + 1] = temp2;            
                                        swap = true;
                                }
                        } 
                } while (swap);
        }

        //Template Function to Display Array Members on One Line in the Console
        //size is the size of array
        template <class ItemType>
        void showArray(ItemType array[], int size)
        {
                for (int j = 0; j < size; j++) {
                        cout << array[j] << " ";
                }
                cout << endl;
        }       
};

#endif

---