data.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/>.
 */

#pragma once

#ifndef CYPRESS_CORE_DATA_HPP
#define CYPRESS_CORE_DATA_HPP

#include <cstdint>
#include <string>
#include <vector>

#include <cypress/core/types.hpp>
#include <cypress/util/matrix.hpp>

namespace cypress {
/*
 * Forward declarations
 */
class NeuronType;

template <typename Iterator>
struct IterableRange {
private:
    Iterator m_begin;

    Iterator m_end;

public:
    IterableRange(Iterator begin, Iterator end) : m_begin(begin), m_end(end) {}

    Iterator begin() { return m_begin; }

    Iterator end() { return m_end; }
};

template <typename Iterator>
IterableRange<Iterator> make_iterable_range(Iterator begin, Iterator end)
{
    return IterableRange<Iterator>(begin, end);
}

class PopulationData {
public:
    using ParameterType = std::vector<Real>;

    using RecordType = std::vector<uint8_t>;

    using DataType = std::vector<std::shared_ptr<Matrix<Real>>>;

private:
    size_t m_size;

    NeuronType const *m_type;

    std::string m_name;

    std::vector<ParameterType> m_parameters;

    std::vector<RecordType> m_record;

    std::vector<DataType> m_data;

public:
    PopulationData(
        size_t size = 1, NeuronType const *type = nullptr,
        const std::string &name = std::string(),
        const std::vector<ParameterType> &parameters =
            std::vector<ParameterType>(),
        const std::vector<RecordType> &record = std::vector<RecordType>(),
        const std::vector<DataType> &data = std::vector<DataType>())
        : m_size(size),
          m_type(type),
          m_name(name),
          m_parameters(parameters),
          m_record(record),
          m_data(data)
    {
    }

    size_t size() const { return m_size; }

    NeuronType const *type() const { return m_type; }

    std::string &name() { return m_name; }

    const std::string &name() const { return m_name; }

    const std::vector<ParameterType> &parameters() const
    {
        return m_parameters;
    }

    std::vector<ParameterType> &parameters() { return m_parameters; }

    const std::vector<RecordType> &record() const { return m_record; }

    std::vector<RecordType> &record() { return m_record; }

    const std::vector<DataType> &data() const { return m_data; }

    std::vector<DataType> &data() { return m_data; }

    size_t get_parameters_size(NeuronIndex nid0, NeuronIndex nid1) const;

    size_t get_record_size(NeuronIndex nid0, NeuronIndex nid1) const;

    size_t get_data_size(NeuronIndex nid0, NeuronIndex nid1) const;

    const ParameterType &read_parameters(NeuronIndex nid0,
                                         NeuronIndex nid1) const;

    const RecordType &read_record(NeuronIndex nid0, NeuronIndex nid1) const;

    const DataType &read_data(NeuronIndex nid0, NeuronIndex nid1) const;

    IterableRange<std::vector<ParameterType>::iterator> write_parameters(
        NeuronIndex nid0, NeuronIndex nid1, bool partial = true);

    IterableRange<std::vector<RecordType>::iterator> write_record(
        NeuronIndex nid0, NeuronIndex nid1, bool partial = true);

    IterableRange<std::vector<DataType>::iterator> write_data(
        NeuronIndex nid0, NeuronIndex nid1, bool partial = true);

    bool homogeneous_parameters() const { return m_parameters.size() <= 1; }

    bool homogeneous_record() const { return m_record.size() <= 1; }

    bool homogeneous_data() const { return m_data.size() <= 1; }
};

class PopulationDataView {
private:
    std::shared_ptr<PopulationData> m_data;

    NeuronIndex m_nid0;

    NeuronIndex m_nid1;

    bool m_own_parameters : 1;

    bool m_own_record : 1;

    bool m_own_data : 1;

protected:
    template <typename Seq>
    static typename Seq::value_type from_sequence(Seq list)
    {
        using Impl = typename Seq::value_type;

        // Create containers for the compund object.
        const size_t size = list.size();
        std::vector<PopulationData::ParameterType> parameters(size);
        std::vector<PopulationData::RecordType> record(size);
        std::vector<PopulationData::DataType> data(size);

        // Fill the containers
        size_t idx = 0;
        for (const Impl &i : list) {
            const PopulationData &id = i.population_data();
            if (id.parameters().size() == 1 && i.m_own_parameters) {
                parameters[idx] = id.parameters()[0];
            }
            if (id.record().size() == 1 && i.m_own_record) {
                record[idx] = id.record()[0];
            }
            if (id.data().size() == 1 && i.m_own_data) {
                data[idx] = id.data()[0];
            }
            idx++;
        }
        return Impl(std::make_shared<PopulationData>(
                        size, nullptr, std::string(), parameters, record, data),
                    0, size);
    }

    const PopulationData &population_data() const { return *m_data; }

    PopulationData &population_data() { return *m_data; }

    size_t get_parameters_size() const
    {
        return population_data().get_parameters_size(m_nid0, m_nid1);
    }

    size_t get_record_size() const
    {
        return population_data().get_record_size(m_nid0, m_nid1);
    }

    size_t get_data_size() const
    {
        return population_data().get_data_size(m_nid0, m_nid1);
    }

    const auto &read_parameters() const
    {
        return population_data().read_parameters(m_nid0, m_nid1);
    }

    const auto &read_record() const
    {
        return population_data().read_record(m_nid0, m_nid1);
    }

    const auto &read_data() const
    {
        return population_data().read_data(m_nid0, m_nid1);
    }

    auto write_parameters(bool partial = true)
    {
        return population_data().write_parameters(m_nid0, m_nid1, partial);
    }

    auto write_record(bool partial = true)
    {
        return population_data().write_record(m_nid0, m_nid1, partial);
    }

    auto write_data(bool partial = true)
    {
        return population_data().write_data(m_nid0, m_nid1, partial);
    }

public:
    PopulationDataView()
        : m_data(std::make_shared<PopulationData>(1)),
          m_nid0(0),
          m_nid1(1),
          m_own_parameters(true),
          m_own_record(true),
          m_own_data(true)
    {
    }

    PopulationDataView(const PopulationDataView &other);

    PopulationDataView(PopulationDataView &&) noexcept = default;

    PopulationDataView(std::shared_ptr<PopulationData> data, NeuronIndex nid0,
                       NeuronIndex nid1, bool own_parameters = true,
                       bool own_record = true, bool own_data = true)
        : m_data(data),
          m_nid0(nid0),
          m_nid1(nid1),
          m_own_parameters(own_parameters),
          m_own_record(own_record),
          m_own_data(own_data)
    {
    }

    PopulationDataView &operator=(const PopulationDataView &other);
};
}

#endif /* CYPRESS_CORE_DATA_HPP */