IO.hpp

Go to the documentation of this file.

#ifndef IO_HPP
#define IO_HPP

#include "config.hpp"

namespace NTB
{

    template <typename T>
    inline std::vector<T> load_vector(std::string filename)
    {
        std::vector<T> numbers;
        std::ifstream inputFile(filename);
        if (inputFile.good())
        {
            T current_number = 0;
            while (inputFile >> current_number)
                numbers.push_back(current_number);

            inputFile.close();
        }

        else 
        {
            std::cout << "Error reading " << filename << "\n";
            exit(EXIT_FAILURE);
        }

        return numbers;
    }
    //-------------------------------------------------------------------------
    inline bool file_exists(const std::string &filename)
    {
        struct stat buf;
        if (stat(filename.c_str(), &buf) != -1)
        {
            return true;
        }
        return false;
    }

    //-------------------------------------------------------------------------
    template <typename T>
    inline std::vector<std::vector<T>> load_matrix(
        const std::string filename,
        const int row,
        const int col)
    {
        std::ifstream ifile(filename);

        /*to check if input file exists*/
        if (file_exists(filename))
        {
            std::vector<std::vector<T>> Cij(row, std::vector<T>(col));

            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < col; j++)
                {
                    ifile >> Cij[i][j];
                }
            }
            ifile.close();
            return Cij;
        }
        else
        {
            std::cerr << "\n file : " << filename << " not found \n";
            exit(2);
        }
    }

    //-------------------------------------------------------------------------
    template <typename T>
    std::vector<std::vector<T>> adjmat_to_adjlist(
        const std::vector<std::vector<T>> &A,
        const double threshold = 1e-8,
        std::string in_degree = "row")
    {
        int row = A.size();
        int col = A[0].size();
        std::vector<std::vector<int>> adjlist;

        if (in_degree == "row")
        {
            adjlist.resize(row);

            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < col; j++)
                {
                    if (std::abs(A[i][j]) > 1.e-8)
                        adjlist[i].push_back(j);
                }
            }
        }
        else
        {
            adjlist.resize(col);

            for (int i = 0; i < col; i++)
            {
                for (int j = 0; j < row; j++)
                {
                    if (std::abs(A[i][j]) > 1.e-8)
                        adjlist[i].push_back(j);
                }
            }
        }

        return adjlist;
    }

    //-------------------------------------------------------------------------
    template <typename T>
    void write_matrix_to_file(const std::vector<std::vector<T>> &A,
                              const std::string filename)
    {
        int row = A.size();
        int col = A[0].size();

        std::ofstream ofile;
        ofile.open(filename);
        if (ofile.is_open())
        {
            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < col; j++)
                {
                    ofile << A[i][j] << " ";
                }
                ofile << "\n";
            }
            ofile.close();
        }
        else
            std::cout << "Error opening file to write data. \n";
    }

    //-------------------------------------------------------------------------
    template <typename T>
    void write_vector_to_file(const std::vector<T> &v,
                              const std::string filename)
    {
        size_t n = v.size();
        std::ofstream ofile;
        ofile.open(filename);
        if (ofile.is_open())
        {
            for (size_t i = 0; i < n; ++i)
                ofile << v[i] << "\n";
            ofile.close();
        }
        else
        {
            std::cout << "Error opening file to write data. \n";
            exit(EXIT_FAILURE);
        }
    }
    //-------------------------------------------------------------------------

    void spikes_to_file(const std::string filename,
                        const std::vector<std::vector<double>> &spikes)
    {

        FILE *spkfile;
        spkfile = fopen(filename.c_str(), "w");

        if (file_exists(filename))
        {
            for (size_t i = 0; i < spikes.size(); i++)
            {
                for (size_t j = 0; j < spikes[i].size(); j++)
                {
                    fprintf(spkfile, "%18.6f", spikes[i][j]);
                }
                fprintf(spkfile, "\n");
            }

            fclose(spkfile);
        }
        else
        {
            printf("Could not open file properly in spike_to_file!\n");
            exit(EXIT_FAILURE);
        }
    }

} // namespace NTB

#endif // !IO_HPP