synapse_types_alpha_impl.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 The University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _ALPHA_SYNAPSE_H_
#define _ALPHA_SYNAPSE_H_
 
//---------------------------------------
// Macros
//---------------------------------------
#define SYNAPSE_TYPE_BITS 1
#define SYNAPSE_TYPE_COUNT 2
 
#define NUM_EXCITATORY_RECEPTORS 1
#define NUM_INHIBITORY_RECEPTORS 1
 
#include <neuron/decay.h>
#include <debug.h>
#include "synapse_types.h"
 
//---------------------------------------
// Synapse parameters
//---------------------------------------
typedef struct alpha_params_t {
    input_t lin_init;
    input_t exp_init;
    input_t q_init;
    REAL tau;
} alpha_params_t;
 
struct synapse_types_params_t {
    alpha_params_t exc;
    alpha_params_t inh;
    REAL time_step_ms;
};
 
typedef struct alpha_state_t {
    input_t lin_buff;           
    input_t exp_buff;           
    input_t dt_divided_by_tau_sqr;
    decay_t decay;              
    input_t q_buff;             
} alpha_state_t;
 
struct synapse_types_t {
    alpha_state_t exc;         
    alpha_state_t inh;         
};
 
typedef enum {
    EXCITATORY,                 
    INHIBITORY,                 
} synapse_alpha_input_buffer_regions;
 
//---------------------------------------
// Synapse shaping inline implementation
//---------------------------------------
 
static inline void get_alpha_state(alpha_state_t *state, alpha_params_t *params,
        REAL time_step_ms, uint32_t n_steps_per_timestep) {
    REAL ts = kdivui(time_step_ms, n_steps_per_timestep);
    decay_t decay = expulr(-kdivk(ts, params->tau));
    decay_t init = kdivk(ts, (params->tau * params->tau));
    state->lin_buff = params->lin_init;
    state->exp_buff = params->exp_init;
    state->q_buff = params->q_init;
    state->dt_divided_by_tau_sqr = init;
    state->decay = decay;
}
 
static inline void synapse_types_initialise(synapse_types_t *state,
        synapse_types_params_t *params, uint32_t n_steps_per_timestep) {
    get_alpha_state(&state->exc, &params->exc, params->time_step_ms, n_steps_per_timestep);
    get_alpha_state(&state->inh, &params->inh, params->time_step_ms, n_steps_per_timestep);
}
 
static void synapse_types_save_state(synapse_types_t *state, synapse_types_params_t *params) {
    params->exc.lin_init = state->exc.lin_buff;
    params->exc.exp_init = state->exc.exp_buff;
    params->exc.q_init = state->exc.q_buff;
    params->inh.lin_init = state->inh.lin_buff;
    params->inh.exp_init = state->inh.exp_buff;
    params->inh.q_init = state->inh.q_buff;
}
 
static inline void alpha_shaping(alpha_state_t* a_params) {
    a_params->lin_buff = a_params->lin_buff + (
            a_params->q_buff * a_params->dt_divided_by_tau_sqr);
 
    // Update exponential buffer
    a_params->exp_buff = decay_s1615(a_params->exp_buff, a_params->decay);
}
 
static inline void synapse_types_shape_input(
        synapse_types_t *parameters) {
    alpha_shaping(&parameters->exc);
    alpha_shaping(&parameters->inh);
}
 
static inline void add_input_alpha(alpha_state_t *a_params, input_t input) {
    a_params->q_buff = input;
 
    a_params->exp_buff =
            decay_s1615(a_params->exp_buff, a_params->decay) + ONE;
 
    a_params->lin_buff =
            (a_params->lin_buff + (input * a_params->dt_divided_by_tau_sqr))
            * (ONE - kdivk(ONE, a_params->exp_buff));
}
 
static inline void synapse_types_add_neuron_input(
        index_t synapse_type_index, synapse_types_t *parameters,
        input_t input) {
    if (input > ZERO) {
        switch (synapse_type_index) {
        case EXCITATORY:
            add_input_alpha(&parameters->exc, input);
            break;
        case INHIBITORY:
            add_input_alpha(&parameters->inh, input);
            break;
        }
    }
}
 
static inline input_t* synapse_types_get_excitatory_input(
        input_t *excitatory_response, synapse_types_t *parameters) {
    excitatory_response[0] =
            parameters->exc.lin_buff * parameters->exc.exp_buff;
    return &excitatory_response[0];
}
 
static inline input_t* synapse_types_get_inhibitory_input(
        input_t *inhibitory_response, synapse_types_t *parameters) {
    inhibitory_response[0] =
            parameters->inh.lin_buff * parameters->inh.exp_buff;
    return &inhibitory_response[0];
}
 
static inline const char *synapse_types_get_type_char(
        index_t synapse_type_index) {
    switch (synapse_type_index) {
    case EXCITATORY:
        return "X";
    case INHIBITORY:
        return "I";
    default:
        log_debug("did not recognise synapse type %i", synapse_type_index);
        return "?";
    }
}
 
static inline void synapse_types_print_input(
        synapse_types_t *parameters) {
    io_printf(IO_BUF, "%12.6k - %12.6k",
            parameters->exc.lin_buff * parameters->exc.exp_buff,
            parameters->inh.lin_buff * parameters->inh.exp_buff);
}
 
static inline void synapse_types_print_parameters(synapse_types_t *parameters) {
    log_debug("-------------------------------------\n");
    log_debug("exc_response  = %11.4k\n",
            parameters->exc.lin_buff * parameters->exc.exp_buff);
    log_debug("inh_response  = %11.4k\n",
            parameters->inh.lin_buff * parameters->inh.exp_buff);
}
 
#endif // _ALPHA_SYNAPSE_H_