leaky.h

Go to the documentation of this file.

/***********************************************************************
    Copyright (C) 2005,2006 Frédéric HENRY <neryel@reveries.info>

    This file is part of ASpiReNN.

    ASpiReNN is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published 
    by the Free Software Foundation; either version 2 of the License,
    or (at your option) any later version.

    ASpiReNN is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License 
    along with ASpiReNN; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307  USA.

***********************************************************************/

#ifndef _LEAKY_H_
#define _LEAKY_H_

#include "neuron.h"

typedef struct {
  aspi_neuron_t parent;
  /* Voltage that will happen in xxx steps */
  double * futur_voltages_exci;
  double * futur_voltages_inhib;
  /* Max delay the neuron can bufferize */
  int max_delay;
  /* Current index for voltages buffer */
  int vindex;
  /* Dates of last spikes */
  int * last_spike;
  /* Record of last v_trace */
  double * v_traces;
  /* Size of buffer last_spikes */
  int memory;
  /* Number of "current" index */
  int index;
  /* Frequence trace of the neuron */
  double freq;
  /* Threshold */
  double threshold;
  /* Standard deviation of incoming weights (used for I.P.) */
  double std_dev_ip_init;
  double std_dev_ip_current;
  /* Pointer to a network */
  aspi_object_t * network;
  double v_mem[100]; //temp
} aspi_leaky_t;


typedef struct {
  aspi_neuron_class_t parent;
} aspi_leaky_class_t;


aspi_class_t * aspi_leaky (void);

/* Instance methods */
aspi_object_t * aspi_leaky_init (aspi_object_t * self);
aspi_object_t * aspi_leaky_init_full (aspi_object_t * self, int memory, int delay);
void aspi_leaky_dtor (aspi_object_t * self);
aspi_object_t * aspi_leaky_dup (aspi_object_t * self);

void aspi_leaky_set_memory (aspi_object_t * self, int memory);
void aspi_leaky_set_max_delay (aspi_object_t * self, int delay);
void aspi_leaky_add_in_n_steps (aspi_object_t * self, double voltages, int steps);
void aspi_leaky_update_voltage (aspi_object_t * self);
void aspi_leaky_set_threshold (aspi_object_t * self, double threshold);
double aspi_leaky_get_threshold (aspi_object_t * self);
double aspi_leaky_get_threshold_ip (aspi_object_t * self);
int aspi_leaky_get_last_spike (aspi_object_t * self);
int aspi_leaky_get_last_spike_before (aspi_object_t * self, int before);
double aspi_leaky_get_v_trace (aspi_object_t * self);
double aspi_leaky_get_v_trace_at (aspi_object_t * self, int time);

void aspi_leaky_set_last_spike (aspi_object_t * self, int time);
void aspi_leaky_fire (aspi_object_t * self);
int aspi_leaky_has_fired (aspi_object_t * self);
int aspi_leaky_has_fired_at (aspi_object_t * self, int time);
double aspi_leaky_get_voltage (aspi_object_t * self);
double aspi_leaky_get_freq (aspi_object_t * self);


/* Class methods */
void aspi_leaky_class_set_rest_voltage (double rest);
void aspi_leaky_class_set_noise (double noise);
void aspi_leaky_class_set_leak (double leak);
void aspi_leaky_class_set_refractory (int refractory);
int aspi_leaky_class_get_refractory (void);
void aspi_leaky_class_set_threshold (double threshold);
void aspi_leaky_class_set_threshold_leak (double leak);
void aspi_leaky_class_set_dynamic_threshold (int dynamic_threshold);
double aspi_leaky_class_get_threshold (void);
void aspi_leaky_class_set_stp (int set_stp);
void aspi_leaky_class_set_ip (int set_ip);
void aspi_leaky_class_set_ip_factor (double ip_factor);
void aspi_neuron_class_set_reversal_potential (int set_reversal_potential);
void aspi_neuron_class_set_reversal_potentials (double rev_pot_exci, double rev_pot_inhib);




#define ASPI_LEAKY(x) (aspi_object_check (x, aspi_leaky ()), ((aspi_leaky_t *) x))
#define ASPI_LEAKY_CLASS(x) (aspi_class_check (x, aspi_leaky ()), ((aspi_leaky_class_t * ) x))

#endif /* _LEAKY_H_ */

---