delta_sigma.hpp

Go to the documentation of this file.

/*
 *  Cypress -- C++ Spiking Neural Network Simulation Framework
 *  Copyright (C) 2016  Andreas Stöckel
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CYPRESS_NEF_DELTA_SIGMA
#define CYPRESS_NEF_DELTA_SIGMA

#include <cmath>
#include <cstddef>
#include <vector>

#include <cypress/core/types.hpp>

namespace cypress {
namespace nef {

class DeltaSigma {
public:
    static constexpr Real DEFAULT_RESPONSE_TIME = 50e-3;
    static constexpr Real DEFAULT_STEP = 1e-4;
    static constexpr Real DEFAULT_EPS = 1e-6;
    static constexpr Real DEFAULT_MIN_SPIKE_INTERVAL = 1e-3;

    struct GaussWindow {
        static Real value(Real x) { return std::exp(-x * x); }

        static Real limit(Real eps = 1e-6f)
        {
            return std::sqrt(-std::log(eps));
        }
    };

    struct ExponentialWindow {
        static Real value(Real x)
        {
            return x < 0.0f ? 0.0f : std::exp(-x);
        }

        static Real limit(Real eps = 1e-6f) { return -std::log(eps); }
    };

    class DiscreteWindow {
    private:
        Real m_alpha;
        Real m_sigma;
        Real m_step;
        Real m_integral;
        Real m_integral_to_zero;
        std::vector<Real> m_values;

        DiscreteWindow(Real alpha, Real sigma, Real step, Real integral,
                       Real integral_to_zero, std::vector<Real> &&values)
            : m_alpha(alpha),
              m_sigma(sigma),
              m_step(step),
              m_integral(integral),
              m_integral_to_zero(integral_to_zero),
              m_values(values)
        {
        }

        template <typename Window>
        static std::pair<Real, Real> calculate_alpha_and_response_time(
            Real spike_interval, Real sigma, Real step, Real eps,
            Real p = 0.05f);

        template <typename Window>
        static std::pair<Real, Real> choose_params(
            Real min_spike_interval = DEFAULT_MIN_SPIKE_INTERVAL,
            Real response_time = DEFAULT_RESPONSE_TIME,
            Real step = DEFAULT_STEP, Real eps = DEFAULT_EPS);

    public:
        template <typename Window>
        static DiscreteWindow create_manual(Real alpha, Real sigma,
                                            Real step = DEFAULT_STEP,
                                            Real eps = DEFAULT_EPS);

        template <typename Window>
        static DiscreteWindow create(
            Real min_spike_interval = DEFAULT_MIN_SPIKE_INTERVAL,
            Real response_time = DEFAULT_RESPONSE_TIME,
            Real step = DEFAULT_STEP, Real eps = DEFAULT_EPS);

        Real alpha() const { return m_alpha; }

        Real sigma() const { return m_sigma; }

        Real step() const { return m_step; }

        Real integral() const { return m_integral; }

        Real integral_to_zero() const { return m_integral_to_zero; }

        Real limit(Real eps = DEFAULT_EPS) const
        {
            return std::sqrt(-std::log(eps));
        }

        size_t size() const { return m_values.size(); }

        Real operator[](size_t i) const { return m_values[i]; }

        auto begin() const { return m_values.begin(); }

        auto end() const { return m_values.end(); }
    };

    static std::vector<Real> encode(
        const std::vector<Real> &values, const DiscreteWindow &window, Real t0,
        Real min_val = -1.0, Real max_val = 1.0,
        Real min_spike_interval = DEFAULT_MIN_SPIKE_INTERVAL);

    template <typename Fun>
    static std::vector<Real> encode(
        const Fun &f, const DiscreteWindow &window, Real t0, Real t1,
        Real min_val = -1.0, Real max_val = 1.0,
        Real min_spike_interval = DEFAULT_MIN_SPIKE_INTERVAL)
    {
        const size_t n_samples = std::ceil(t1 - t0) / window.step();
        std::vector<Real> values(n_samples);
        for (size_t i = 0; i < n_samples; i++) {
            values[i] = f(t0 + i * window.step());
        }
        return encode(values, window, t0, min_val, max_val, min_spike_interval);
    }

    static std::vector<Real> decode(const std::vector<Real> &spikes,
                                    const DiscreteWindow &window, Real t0,
                                    Real t1, Real min_val = -1.0,
                                    Real max_val = 1.0);
};
}
}

#endif /* CYPRESS_NEF_DELTA_SIGMA */