synapse_types_exponential_impl.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 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 _SYNAPSE_TYPES_EXPONENTIAL_IMPL_H_
#define _SYNAPSE_TYPES_EXPONENTIAL_IMPL_H_
 
//---------------------------------------
// Macros
//---------------------------------------
#define SYNAPSE_TYPE_BITS 1
#define SYNAPSE_TYPE_COUNT 2
 
#define NUM_EXCITATORY_RECEPTORS 1
#define NUM_INHIBITORY_RECEPTORS 1
 
#include <debug.h>
#include "synapse_types.h"
#include "exp_synapse_utils.h"
 
//---------------------------------------
// Synapse parameters
//---------------------------------------
 
struct synapse_types_params_t {
    exp_params_t exc;
    exp_params_t inh;
    REAL time_step_ms;
};
 
struct synapse_types_t {
    exp_state_t exc;           
    exp_state_t inh;           
};
 
typedef enum {
    EXCITATORY,                 
    INHIBITORY,                 
} exponential_synapse_input_buffer_regions;
 
//---------------------------------------
// Synapse shaping inline implementation
//---------------------------------------
 
static inline void synapse_types_initialise(synapse_types_t *state,
        synapse_types_params_t *params, uint32_t n_steps_per_timestep) {
    decay_and_init(&state->exc, &params->exc, params->time_step_ms, n_steps_per_timestep);
    decay_and_init(&state->inh, &params->inh, params->time_step_ms, n_steps_per_timestep);
}
 
static inline void synapse_types_save_state(synapse_types_t *state,
        synapse_types_params_t *params) {
    params->exc.init_input = state->exc.synaptic_input_value;
    params->inh.init_input = state->inh.synaptic_input_value;
}
 
static inline void synapse_types_shape_input(
        synapse_types_t *parameters) {
    exp_shaping(&parameters->exc);
    exp_shaping(&parameters->inh);
}
 
static inline void synapse_types_add_neuron_input(
        index_t synapse_type_index, synapse_types_t *parameters,
        input_t input) {
    switch (synapse_type_index) {
    case EXCITATORY:
        add_input_exp(&parameters->exc, input);
        break;
    case INHIBITORY:
        add_input_exp(&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.synaptic_input_value;
    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.synaptic_input_value;
    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) {
    log_debug("%12.6k - %12.6k",
            parameters->exc.synaptic_input_value,
            parameters->inh.synaptic_input_value);
}
 
static inline void synapse_types_print_parameters(
        synapse_types_t *parameters) {
    log_debug("exc_decay = %R\n", parameters->exc.decay);
    log_debug("exc_init  = %R\n", parameters->exc.init);
    log_debug("inh_decay = %R\n", parameters->inh.decay);
    log_debug("inh_init  = %R\n", parameters->inh.init);
}
 
#endif  // _SYNAPSE_TYPES_EXPONENTIAL_IMPL_H_