weight_additive_two_term_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 _WEIGHT_ADDITIVE_TWO_TERM_IMPL_H_
#define _WEIGHT_ADDITIVE_TWO_TERM_IMPL_H_
 
// Include generic plasticity maths functions
#include <neuron/plasticity/stdp/maths.h>
#include <neuron/plasticity/stdp/stdp_typedefs.h>
#include <neuron/synapse_row.h>
 
#include <debug.h>
 
//---------------------------------------
// Structures
//---------------------------------------
typedef struct plasticity_weight_region_data_two_term_t {
    accum min_weight;     
    accum max_weight;     
 
    accum a2_plus;        
    accum a2_minus;       
    accum a3_plus;        
    accum a3_minus;       
} plasticity_weight_region_data_t;
 
typedef struct weight_state_t {
    accum weight;         
    uint32_t weight_shift;  
 
    const plasticity_weight_region_data_t *weight_region;
} weight_state_t;
 
#include "weight_two_term.h"
 
//---------------------------------------
// STDP weight dependence functions
//---------------------------------------
static inline weight_state_t weight_get_initial(
        weight_t weight, index_t synapse_type) {
    extern plasticity_weight_region_data_t *plasticity_weight_region_data;
    extern uint32_t *weight_shift;
 
    accum s1615_weight = kbits(weight << weight_shift[synapse_type]);
 
    return (weight_state_t) {
        .weight = s1615_weight,
        .weight_shift = weight_shift[synapse_type],
        .weight_region = &plasticity_weight_region_data[synapse_type]
    };
}
 
//---------------------------------------
static inline weight_state_t weight_two_term_apply_depression(
        weight_state_t state, int32_t a2_minus, int32_t a3_minus) {
    state.weight -= mul_accum_fixed(state.weight_region->a2_minus, a2_minus);
    state.weight -= mul_accum_fixed(state.weight_region->a3_minus, a3_minus);
    state.weight = kbits(MAX(bitsk(state.weight), bitsk(state.weight_region->min_weight)));
    return state;
}
 
//---------------------------------------
static inline weight_state_t weight_two_term_apply_potentiation(
        weight_state_t state, int32_t a2_plus, int32_t a3_plus) {
    state.weight += mul_accum_fixed(state.weight_region->a2_plus, a2_plus);
    state.weight += mul_accum_fixed(state.weight_region->a3_plus, a3_plus);
    state.weight = kbits(MIN(bitsk(state.weight), bitsk(state.weight_region->max_weight)));
    return state;
}
 
//---------------------------------------
static inline weight_t weight_get_final(weight_state_t state) {
    return (weight_t) (bitsk(state.weight) >> state.weight_shift);
}
 
static inline void weight_decay(weight_state_t *state, int32_t decay) {
    state->weight = mul_accum_fixed(state->weight, decay);
}
 
static inline accum weight_get_update(weight_state_t state) {
    return state.weight;
}
 
#endif  // _WEIGHT_ADDITIVE_TWO_TERM_IMPL_H_