maths.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014 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 MATHS_H
#define MATHS_H
 
// Standard includes
#include <common/neuron-typedefs.h>
#include <debug.h>
#include <spin1_api.h>
 
//---------------------------------------
// Macros
//---------------------------------------
#define MIN(X, Y)   ((X) < (Y) ? (X) : (Y))
#define MAX(X, Y)   ((X) > (Y) ? (X) : (Y))
 
typedef struct int16_lut {
    uint16_t size;    
    uint16_t shift;   
    int16_t values[]; 
} int16_lut;
 
//---------------------------------------
// Plasticity maths function inline implementation
//---------------------------------------
static inline int16_lut *maths_copy_int16_lut(address_t *address) {
    int16_lut *sdram_lut = (int16_lut *) *address;
    uint32_t size = sizeof(int16_lut) + (sdram_lut->size * sizeof(int16_t));
    int16_lut *lut = spin1_malloc(size);
    if (lut == NULL) {
        log_error("Not enough space to allocate LUT.  Try reducing the timestep,"
            " the number of neurons per core, or the tau value; size = %u", size);
        rt_error(RTE_SWERR);
    }
    spin1_memcpy(lut, sdram_lut, size);
 
    // Pad to number of words (+ 1 for size / shift header)
    const uint32_t num_words = (lut->size / 2) + (((lut->size & 1) != 0) ? 1 : 0);
    *address += num_words + 1;
 
    return lut;
}
 
static inline int32_t maths_lut_exponential_decay(
        uint32_t time, const int16_lut *lut) {
    // Calculate lut index
    uint32_t lut_index = time >> lut->shift;
 
    // Return value from LUT
    return (lut_index < lut->size) ? lut->values[lut_index] : 0;
}
 
static inline int32_t maths_clamp_pot(int32_t x, uint32_t shift) {
    uint32_t y = x >> shift;
    if (y) {
        x = ~y >> (32 - shift);
    }
 
    return x;
}
 
//---------------------------------------
static inline int32_t maths_mul_16x16(int16_t x, int16_t y) {
    return x * y;
}
 
//---------------------------------------
static inline int32_t maths_fixed_mul16(
        int32_t a, int32_t b, const int32_t fixed_point_position) {
    // Multiply lower 16-bits of a and b together
    return __smulbb(a, b) >> fixed_point_position;
}
 
//---------------------------------------
static inline int32_t maths_fixed_mul32(
        int32_t a, int32_t b, const int32_t fixed_point_position) {
    int32_t mul = a * b;
 
    // Shift down and return
    return (mul >> fixed_point_position);
}
 
#endif // MATHS_H