timing_nearest_pair_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 _TIMING_NEAREST_PAIR_IMPL_H_
#define _TIMING_NEAREST_PAIR_IMPL_H_
 
//---------------------------------------
// Structures
//---------------------------------------
typedef struct post_trace_t {
} post_trace_t;
 
typedef struct pre_trace_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>
 
//---------------------------------------
// Timing dependence inline functions
//---------------------------------------
static inline post_trace_t timing_get_initial_post_trace(void) {
    return (post_trace_t) {};
}
 
//---------------------------------------
static inline post_trace_t timing_add_post_spike(
        uint32_t time, uint32_t last_time, UNUSED post_trace_t last_trace) {
    log_debug("\tdelta_time=%u\n", time - last_time);
 
    // Return new pre- synaptic event with decayed trace values with energy
    // for new spike added
    return (post_trace_t) {};
}
 
static inline post_trace_t timing_decay_post(
        UNUSED uint32_t time, UNUSED uint32_t last_time,
        UNUSED post_trace_t last_trace) {
    return (post_trace_t) {};
}
 
//---------------------------------------
static inline pre_trace_t timing_add_pre_spike(
        uint32_t time, uint32_t last_time, UNUSED pre_trace_t last_trace) {
    log_debug("\tdelta_time=%u\n", time - last_time);
 
    return (pre_trace_t ) {};
}
 
//---------------------------------------
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,
        UNUSED post_trace_t last_post_trace, update_state_t previous_state) {
    extern int16_lut *tau_minus_lookup;
 
    // Get time of event relative to last post-synaptic event
    uint32_t time_since_last_post = time - last_post_time;
    int32_t decayed_o1 = maths_lut_exponential_decay(
        time_since_last_post, tau_minus_lookup);
 
    log_debug("\t\t\ttime_since_last_post=%u, decayed_o1=%d\n",
            time_since_last_post, decayed_o1);
 
    // Apply depression to state (which is a weight_state)
    return weight_one_term_apply_depression(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,
        UNUSED pre_trace_t last_pre_trace, uint32_t last_post_time,
        UNUSED post_trace_t last_post_trace, update_state_t previous_state) {
    extern int16_lut *tau_plus_lookup;
 
    // Get time of event relative to last pre-synaptic event
    uint32_t time_since_last_pre = time - last_pre_time;
    uint32_t time_since_last_post = time - last_post_time;
 
    if (time_since_last_pre > 0) {
        int32_t decayed_r1 = maths_lut_exponential_decay(
            time_since_last_pre, tau_plus_lookup);
 
        log_debug("\t\t\ttime_since_last_pre=%u, decayed_r1=%d\n",
                time_since_last_pre, decayed_r1);
 
        if (time_since_last_post < time_since_last_pre) {
            log_debug("\t\t\tSetting trace to zero as not first pre-post pairing");
            decayed_r1 = 0;
        }
 
        // Apply potentiation to state (which is a weight_state)
        return weight_one_term_apply_potentiation(previous_state, decayed_r1);
    } else {
        return previous_state;
    }
}
 
#endif  // _TIMING_NEAREST_PAIR_IMPL_H_