timing_vogels_2011_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 VOGELS_2011_IMPL_H
#define VOGELS_2011_IMPL_H
 
//---------------------------------------
// Typedefines
//---------------------------------------
typedef int16_t post_trace_t;
typedef int16_t pre_trace_t;
 
#include <neuron/plasticity/stdp/synapse_structure/synapse_structure_weight_impl.h>
#include "timing.h"
#include <neuron/plasticity/stdp/weight_dependence/weight_one_term.h>
 
// Include debug header for log_info etc
#include <debug.h>
 
// Include generic plasticity maths functions
#include <neuron/plasticity/stdp/maths.h>
#include <neuron/plasticity/stdp/stdp_typedefs.h>
 
//---------------------------------------
// Structures
//---------------------------------------
typedef struct {
    int32_t alpha;
} plasticity_trace_region_data_t;
 
//---------------------------------------
// Externals
//---------------------------------------
extern int16_lut *tau_lookup;
 
//---------------------------------------
// Timing dependence inline functions
//---------------------------------------
 
static inline int16_t timing_decay_post(
        uint32_t time, uint32_t last_time, post_trace_t last_trace) {
    // Get time since last spike
    uint32_t delta_time = time - last_time;
 
    // Decay previous trace
    int32_t decayed_trace = STDP_FIXED_MUL_16X16(last_trace,
        maths_lut_exponential_decay(delta_time, tau_lookup));
 
    return (uint16_t) decayed_trace;
 
}
 
static inline int16_t timing_add_spike(
        uint32_t time, uint32_t last_time, int16_t last_trace) {
 
    // Decay previous trace
    int32_t decayed_trace = timing_decay_post(time, last_time, last_trace);
 
    // Add new spike to trace
    int32_t new_trace = decayed_trace + STDP_FIXED_POINT_ONE;
 
    return (int16_t)new_trace;
}
 
//---------------------------------------
// Timing dependence inline functions
//---------------------------------------
static inline post_trace_t timing_get_initial_post_trace(void) {
    return 0;
}
//---------------------------------------
static inline post_trace_t timing_add_post_spike(
        uint32_t time, uint32_t last_time, post_trace_t last_trace) {
    return timing_add_spike(time, last_time, last_trace);
}
//---------------------------------------
static inline pre_trace_t timing_add_pre_spike(
        uint32_t time, uint32_t last_time, pre_trace_t last_trace) {
    return timing_add_spike(time, last_time, last_trace);
}
//---------------------------------------
static inline update_state_t timing_apply_pre_spike(
        uint32_t time, UNUSED pre_trace_t trace, UNUSED uint32_t last_pre_time,
        UNUSED pre_trace_t last_pre_trace, uint32_t last_post_time,
        post_trace_t last_post_trace, update_state_t previous_state) {
    extern plasticity_trace_region_data_t plasticity_trace_region_data;
 
    // Get time of event relative to last post-synaptic event
    uint32_t time_since_last_post = time - last_post_time;
    int32_t exponential_decay = maths_lut_exponential_decay(
            time_since_last_post, tau_lookup);
    int32_t decayed_o1 = STDP_FIXED_MUL_16X16(last_post_trace, exponential_decay)
            - plasticity_trace_region_data.alpha;
 
    log_debug("\t\t\ttime_since_last_post_event=%u, decayed_o1=%d\n",
            time_since_last_post, decayed_o1);
 
    // Apply potentiation to state (which is a weight_state)
    return weight_one_term_apply_potentiation(previous_state, decayed_o1);
 
}
//---------------------------------------
static inline update_state_t timing_apply_post_spike(
        uint32_t time, UNUSED post_trace_t trace, uint32_t last_pre_time,
        pre_trace_t last_pre_trace, UNUSED uint32_t last_post_time,
        UNUSED post_trace_t last_post_trace, update_state_t previous_state) {
    // Get time of event relative to last pre-synaptic event
    uint32_t time_since_last_pre = time - last_pre_time;
    int32_t exponential_decay = maths_lut_exponential_decay(
            time_since_last_pre, tau_lookup);
    int32_t decayed_r1 = STDP_FIXED_MUL_16X16(last_pre_trace, exponential_decay);
 
    log_debug("\t\t\ttime_since_last_pre_event=%u, decayed_r1=%d\n",
            time_since_last_pre, decayed_r1);
 
    // Apply potentiation to state (which is a weight_state)
    return weight_one_term_apply_potentiation(previous_state, decayed_r1);
}
 
#endif  // VOGELS_2011_IMPL_H