vbi 0.1.3__cp310-cp310-manylinux2014_x86_64.whl

vbi/models/cpp/_src/utility.hpp

@@ -0,0 +1,307 @@
+#ifndef UTILITY_HPP
+#define UTILITY_HPP
+
+#include <vector>
+#include <string>
+#include <random>
+#include <assert.h>
+#include <iostream>
+#include <algorithm>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+// #include <Eigen/Dense>
+
+using std::string;
+using std::vector;
+
+typedef std::vector<double> dim1;
+typedef std::vector<unsigned> dim1I;
+typedef std::vector<std::vector<double>> dim2;
+typedef std::vector<std::vector<unsigned>> dim2I;
+
+bool fileExists(const std::string &filename)
+{
+    struct stat buf;
+    if (stat(filename.c_str(), &buf) != -1)
+    {
+        return true;
+    }
+    return false;
+}
+
+bool folderExists(const std::string &path)
+{
+    struct stat st;
+    if (stat(path.c_str(), &st) == 0)
+    {
+        if (st.st_mode & S_IFDIR != 0)
+            return true;
+        else
+            return false;
+    }
+    else
+        return false;
+}
+
+std::vector<std::vector<unsigned>> adjmat_to_adjlist(const dim2 &A)
+{
+    size_t n = A.size();
+
+    std::vector<std::vector<unsigned>> adjlist;
+    adjlist.resize(n);
+
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 0; j < n; ++j)
+        {
+            if (std::abs(A[i][j]) > 1e-8)
+                adjlist[i].push_back(j);
+        }
+    }
+
+    return adjlist;
+}
+
+// std::vector<std::vector<size_t>> adjmat_to_adjlist(const dim2 &A)
+// {
+//     size_t n = A.size();
+
+//     std::vector<std::vector<size_t>> adjlist;
+//     adjlist.resize(n);
+
+//     for (int i = 0; i < n; ++i)
+//     {
+//         for (int j = 0; j < n; ++j)
+//         {
+//             if (std::abs(A[j][i]) > 1e-8)
+//                 adjlist[i].push_back(j);
+//         }
+//     }
+
+//     return adjlist;
+// }
+
+dim1 moving_average(const dim1 &vec, const size_t window)
+{
+    size_t size = vec.size();
+    size_t ind = 0;
+    size_t buffer_size = int(size / window);
+    dim1 vec_out(buffer_size);
+
+    for (size_t itr = 0; itr < (size - window); ++itr)
+    {
+        double sum = 0.0;
+        for (int j = itr; j < itr + window; ++j)
+            sum += vec[j];
+        vec_out[ind] = sum / double(window);
+        ind++;
+    }
+
+    return vec_out;
+}
+
+// adding vectors
+void add(const vector<double> &a, const vector<double> &b, vector<double> &c)
+{
+    // c need to be allocated memory.
+    transform(a.begin(), a.end(), b.begin(), c.begin(),
+              [](double a, double b)
+              { return a + b; });
+}
+
+void add(const vector<float> &a, const vector<double> &b, vector<float> &c)
+{
+    assert(a.size() == b.size());
+    assert(b.size() == c.size());
+
+    for (size_t i = 0; i < a.size(); ++i)
+        c[i] = a[i] + b[i];
+}
+
+double average(std::vector<double> const &numbers)
+{
+    if (numbers.empty())
+    {
+        return 0;
+    }
+    double sum = 0;
+    size_t arrayLength = numbers.size();
+    for (size_t i = 0; i < arrayLength; i++)
+        sum += numbers[i];
+    return sum / arrayLength;
+
+    // return std::reduce(v.begin(), v.end()) / count;
+}
+
+dim1 average(dim2 &V)
+{
+    // size_t num_nodes = (axis == "COL") ? V.size() : V[0].size();
+    size_t n = V[0].size();
+    size_t nt = V.size();
+    dim1 out(n);
+
+    for (size_t i = 0; i < n; ++i)
+    {
+        for (size_t j = 0; j < nt; ++j)
+            out[i] += V[j][i];
+    }
+    return out;
+}
+
+long get_mem_usage()
+{
+    // measure memory usage
+
+    struct rusage myusage;
+
+    getrusage(RUSAGE_SELF, &myusage);
+    return myusage.ru_maxrss;
+}
+
+void display_timing(double wtime, double cptime)
+{
+    int wh;      //, ch;
+    int wmin;    //, cpmin;
+    double wsec; //, csec;
+    wh = (int)wtime / 3600;
+    // ch = (int)cptime / 3600;
+    wmin = ((int)wtime % 3600) / 60;
+    // cpmin = ((int)cptime % 3600) / 60;
+    wsec = wtime - (3600. * wh + 60. * wmin);
+    // csec = cptime - (3600. * ch + 60. * cpmin);
+    printf("Wall Time : %d hours and %d minutes and %.4f seconds.\n", wh, wmin, wsec);
+    // printf ("CPU  Time : %d hours and %d minutes and %.4f seconds.\n",ch,cpmin,csec);
+}
+
+template <typename T>
+inline std::vector<std::vector<T>> load_matrix(
+    const std::string filename,
+    const size_t row,
+    const size_t col)
+{
+    /*!
+    * Read matrix into vector of vector
+    *
+    * \param filename [string] name of text file to read
+    * \param row [int] number of rows
+    * \param col [int] number of columns
+
+    * \return vector of vector of specified type
+    *
+    * **example**
+    * std::vector<std::vector<int>> A = Neuro::read_matrix<int>(
+    * "data/matrix_integer.txt", 4, 3);
+    */
+
+    std::ifstream ifile(filename);
+
+    /*to check if input file exists*/
+    if (fileExists(filename))
+    {
+        std::vector<std::vector<T>> Cij(row, std::vector<T>(col));
+
+        for (size_t i = 0; i < row; i++)
+        {
+            for (size_t j = 0; j < col; j++)
+            {
+                ifile >> Cij[i][j];
+            }
+        }
+        ifile.close();
+        return Cij;
+    }
+    else
+    {
+        std::cerr << "\n file : " << filename << " not found \n";
+        exit(2);
+    }
+}
+
+double get_wall_time()
+{
+    /*!
+    measure real passed time
+    \return wall time in second
+    */
+
+    struct timeval time;
+    if (gettimeofday(&time, NULL))
+    {
+        //  Handle error
+        return 0;
+    }
+    return (double)time.tv_sec + (double)time.tv_usec * .000001;
+}
+
+std::mt19937 &rng(const bool fix_seed)
+{
+    if (fix_seed)
+    {
+        static std::mt19937 instance{2};
+        return instance;
+    }
+    else
+    {
+        static std::mt19937 instance{std::random_device{}()};
+        return instance;
+    }
+}
+
+void fill_vector(dim1 &v, const vector<int> indices, const double value)
+{
+    for (size_t i = 0; i < indices.size(); ++i)
+        v[indices[i]] = value;
+}
+
+int find_nan(const dim1 &vec)
+{
+    int ind = vec.size() - 1;
+    if (std::isnan(vec[ind]))
+    {
+        std::cout << "nan found!" << std::endl;
+        return -1;
+    }
+    return 0;
+}
+
+dim1 matvec(const dim2 &mat, const dim1 &x, const int offset = 0)
+{
+    int N = mat.size();
+    dim1 y(N);
+
+    // # pragma omp simd
+    for (int i = 0; i < N; ++i)
+    {
+        y[i] = 0.0;
+        for (int j = 0; j < N; ++j)
+            y[i] += mat[i][j] * x[j + offset];
+    }
+    return y;
+}
+
+dim1 matvec_s(const dim2 &mat, const dim2I &a, const dim1 &x, const int offset = 0)
+{
+    int n = mat.size();
+    dim1 y(n);
+
+    # pragma omp simd
+    for (int i=0; i<n; ++i)
+    {
+        for(int j:a[i])
+        {
+            y[i] += mat[i][j] * x[j + offset];
+        }
+    }
+    return y;
+}
+
+// dim1 matmul_e(const Eigen::MatrixXd &A, const Eigen::VectorXd &x)
+// {
+//     Eigen::VectorXd y = A * x;
+//     dim1 y_vec(y.data(), y.data() + y.size());
+//     return y_vec;
+// }
+
+#endif

vbi/models/cpp/_src/vep.hpp

@@ -0,0 +1,171 @@
+#ifndef bvep_HPP
+#define bvep_HPP
+
+#include <cmath>
+#include <fenv.h>
+#include <vector>
+#include <random>
+#include <string>
+#include <assert.h>
+#include <iostream>
+#include <fstream>
+#include "utility.hpp"
+
+using std::string;
+using std::vector;
+
+typedef std::vector<double> dim1;
+typedef std::vector<dim1> dim2;
+
+class VEP
+{
+private:
+    int nn;
+    dim1 x;
+    dim1 eta;
+    double G;
+    dim1 iext;
+    double dt;
+    dim1 times;
+    double tcut;
+    double tend;
+    dim2 states;
+    int fix_seed;
+    dim2 weights;
+    string method;
+    double inv_tau;
+    unsigned num_steps;
+    double noise_sigma;
+    dim1 initial_state;
+    vector<vector<unsigned>> adjlist;
+
+public:
+    VEP(
+        double G,
+        dim1 iext,
+        dim1 eta,
+        double dt,
+        double tcut,
+        double tend,
+        double tau,
+        double noise_sigma,
+        dim1 initial_state,
+        dim2 weights,
+        int fix_seed,
+        string method)
+    {
+        this->G = G;
+        this->dt = dt;
+        this->nn = weights.size();
+        this->iext = iext;
+        this->eta = eta;
+        this->tcut = tcut;
+        this->tend = tend;
+        this->method = method;
+        this->fix_seed = fix_seed;
+        this->weights = weights;
+        this->inv_tau = 1.0 / tau;
+        this->noise_sigma = noise_sigma;
+        this->initial_state = initial_state;
+        adjlist = adjmat_to_adjlist(weights);
+
+        unsigned idx_cut = (int)(tcut / dt);
+        num_steps = (int)(tend / dt);
+        unsigned bufsize = num_steps - idx_cut;
+
+        states.resize(bufsize);
+        for (int i = 0; i < bufsize; i++)
+        {
+            states[i].resize(nn);
+        }
+        times.resize(bufsize);
+    };
+
+    void rhs(const vector<double> &x, vector<double> &dxdt, const double t)
+    {
+        for (int i = 0; i < nn; i++)
+        {
+            double gx = 0.0;
+            for (size_t j = 0; j < adjlist[i].size(); ++j)
+            {
+                int k = adjlist[i][j];
+                gx += weights[i][k] * (x[k] - x[i]);
+            }
+            dxdt[i] = 1.0 - x[i] * x[i] * x[i] - 2.0 * x[i] * x[i] - x[i + nn] + iext[i];
+            dxdt[i + nn] = inv_tau * (4.0 * (x[i] - eta[i]) - x[i + nn] - G * gx);
+        }
+    }
+
+    void euler_step(vector<double> &x, const double t)
+    {
+        std::normal_distribution<> normal(0, 1);
+        vector<double> dxdt(nn * 2);
+
+        rhs(x, dxdt, t);
+        for (int i = 0; i < nn * 2; i++)
+        {
+            x[i] += dt * dxdt[i] + sqrt(dt) * noise_sigma * normal(rng(fix_seed));
+        }
+    }
+
+    void heun_step(vector<double> &x, const double t)
+    {
+        std::normal_distribution<> normal(0, 1);
+        vector<double> dxdt(nn * 2);
+        vector<double> xtemp(nn * 2);
+
+        rhs(x, dxdt, t);
+        for (int i = 0; i < nn * 2; i++)
+        {
+            xtemp[i] = x[i] + dt * dxdt[i] + sqrt(dt) * noise_sigma * normal(rng(fix_seed));
+        }
+
+        vector<double> dxdt_temp(nn * 2);
+        rhs(xtemp, dxdt_temp, t + dt);
+        for (int i = 0; i < nn * 2; i++)
+        {
+            x[i] += 0.5 * dt * (dxdt[i] + dxdt_temp[i]) + sqrt(dt) * noise_sigma * normal(rng(fix_seed));
+        }
+    }
+
+    void integrate()
+    {
+        dim1 x = initial_state;
+        int idxtcut = (int)(tcut / dt);
+        double t = 0.0;
+        int counter = 0;
+
+        for (int it = 0; it < num_steps; it++)
+        {
+            if (it >= idxtcut)
+            {
+                for (int i = 0; i < nn; i++)
+                {
+                    states[counter][i] = x[i];
+                }
+                times[counter] = t;
+                counter++;
+            }
+
+            t += dt;
+            if (method == "euler")
+                euler_step(x, t);
+            else if (method == "heun")
+                heun_step(x, t);
+            else
+                throw std::invalid_argument("Invalid method");
+        }
+    }
+
+    dim2 get_states()
+    {
+        return states;
+    }
+
+    dim1 get_times()
+    {
+        return times;
+    }
+};
+
+#endif

vbi/models/cpp/_src/vep.i

@@ -0,0 +1,16 @@
+%module vep
+
+%{
+#include "vep.hpp"
+%}
+
+%include stl.i
+%include "std_string.i"
+/* instantiate the required template specializations */
+namespace std {
+    %template(IntVector)     vector<int>;
+    %template(DoubleVector)  vector<double>;
+    %template(DoubleVector2) vector<vector<double> >;
+}
+
+%include "vep.hpp"