utilities.hpp

Go to the documentation of this file.

/*
 *  SNABSuite -- Spiking Neural Architecture Benchmark Suite
 *  Copyright (C) 2016  Christoph Jenzen
 *
 *  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 SNABSUITE_UTIL_UTILITIES_HPP
#define SNABSUITE_UTIL_UTILITIES_HPP

#include <cypress/cypress.hpp>

#include <algorithm>  // Minimal and Maximal element
#include <cmath>
#include <fstream>
#include <iostream>
#include <numeric>  // std::accumulate
#include <string>
#include <vector>

namespace SNAB {

using cypress::Json;

class Utilities {
public:
    static std::vector<std::string> &split(const std::string &s, char delim,
                                           std::vector<std::string> &elems);
    static std::vector<std::string> split(const std::string &s, char delim);

    static void progress_callback(double p);

    template <typename T>
    static void calculate_statistics(const std::vector<T> &data, T &min, T &max,
                                     double &avg, double &std_dev)
    {
        if (data.size() > 1) {
            // Calculate statistics
            max = *std::max_element(data.begin(), data.end());
            min = *std::min_element(data.begin(), data.end());
            avg = double(std::accumulate(data.begin(), data.end(), 0.0)) /
                  double(data.size());
            std_dev = 0.0;
            std::for_each(data.begin(), data.end(), [&](const T val) {
                std_dev += (val - avg) * (val - avg);
            });
            std_dev = std::sqrt(double(std_dev) / double(data.size() - 1));
        }
        else if (data.size() == 1) {
            min = data[0];
            max = data[0];
            avg = data[0];
            std_dev = 0;
        }
        else {
            min = 0;
            max = 0;
            avg = 0;
            std_dev = 0;
        }
    }

    template <typename T>
    static void write_vector_to_csv(T &data, std::string file_name)
    {
        std::ofstream file;
        file.open(file_name, std::ofstream::out);
        if (file.good()) {
            for (auto i : data) {
                file << i << std::endl;
            }
            // file << std::endl;
        }
        else {
            std::cerr << "Could not open file " << file_name
                      << "for writing csv!" << std::endl;
        }
    }

    template <typename T>
    static void write_vector2_to_csv(T &data, std::string file_name,
                                     std::string first_line = "")
    {
        std::ofstream file;
        file.open(file_name, std::ofstream::out);
        if (file.good()) {
            if (first_line != "") {
                file << first_line << std::endl;
            }
            for (auto i : data) {
                for (auto j : i) {
                    file << j << ", ";
                }
                file << std::endl;
            }
        }
        else {
            std::cerr << "Could not open file " << file_name
                      << "for writing csv!" << std::endl;
        }
    }

    static Json merge_json(const Json &a, const Json &b);

    static Json manipulate_backend_string(std::string &backend, Json &json);

    static void plot_spikes(std::string filename, std::string simulator);

    static void plot_histogram(std::string filename, std::string simulator,
                               bool normalized, int n_bins, std::string title);

    static void plot_voltages_spikes(std::string filename,
                                     std::string simulator, size_t mem_col = 1,
                                     size_t t_col = 0,
                                     std::string spikes_file = "",
                                     size_t spikes_col = 0);

    static void plot_1d_curve(std::string filename, std::string simulator,
                              size_t x_col, size_t y_col, int std_dev_vol = -1);
};
}  // namespace SNAB

#endif /* SNABSUITE_UTIL_UTILITIES_HPP */