piegy 2.3.7__tar.gz → 2.3.9__tar.gz

{piegy-2.3.7/src/piegy.egg-info → piegy-2.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piegy
-Version: 2.3.7
+Version: 2.3.9
 Summary: Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory
 Author-email: Chenning Xu <cxu7@caltech.edu>
 License: BSD 3-Clause License

{piegy-2.3.7 → piegy-2.3.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'piegy'
-version = '2.3.7'
+version = '2.3.9'
 description = 'Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory'
 readme = 'README.md'
 requires-python = '>=3.7'

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/C_core/model.c

@@ -79,17 +79,16 @@ void mod_free(model_t* mod) {
 
 void mod_free_py(model_t* mod) {
     // free function for python
-
+    // the same as mod_free except for not having free(mod)
     if (!mod) return;
-    if (mod->I) { free(mod->I); }
-    if (mod->X) { free(mod->X); }
-    if (mod->P) { free(mod->P); }
-    if (mod->U1d) { free(mod->U1d); }
-    if (mod->V1d) { free(mod->V1d); }
-    if (mod->Upi_1d) { free(mod->Upi_1d); }
-    if (mod->Vpi_1d) { free(mod->Vpi_1d); }
-    // if (mod) { free(mod); }
 
+    free(mod->I);
+    free(mod->X);
+    free(mod->P);
+    free(mod->U1d);
+    free(mod->V1d);
+    free(mod->Upi_1d);
+    free(mod->Vpi_1d);
     mod->I = NULL;
     mod->X = mod->P = mod->U1d = mod->V1d = mod->Upi_1d = mod->Vpi_1d = NULL;
 }

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/C_core/patch.c

@@ -5,32 +5,35 @@
 
 #include "patch.h"
 
-void patch_init(patch_t* p, uint32_t U, uint32_t V, size_t row, size_t col) {
+void patch_init(patch_t* p, uint32_t U, uint32_t V, size_t row, size_t col, double* X_start, double* P_start) {
     if (p == NULL) return;
     p->row = row;
     p->col = col;
 
     p->U = U;
     p->V = V;
-    p->U_pi = 0.0;
-    p->V_pi = 0.0;
+    p->U_pi = 0;
+    p->V_pi = 0;
+
+    memcpy(p->X, X_start, 4 * sizeof(double));
+    memcpy(p->P, P_start, 6 * sizeof(double));
 
     for (size_t i = 0; i < 4; i++) {
-        p->U_weight[i] = 0.0;
-        p->V_weight[i] = 0.0;
-        p->pi_death_rates[i] = 0.0;
+        p->U_weight[i] = 0;
+        p->V_weight[i] = 0;
+        p->pi_death_rates[i] = 0;
     }
     for (size_t i = 0; i < 8; i++) {
-        p->mig_rates[i] = 0.0;
+        p->mig_rates[i] = 0;
     }
-    p->sum_U_weight = 0.0;
-    p->sum_V_weight = 0.0;
-    p->sum_pi_death_rates = 0.0;
-    p->sum_mig_rates = 0.0;
+    p->sum_U_weight = 0;
+    p->sum_V_weight = 0;
+    p->sum_pi_death_rates = 0;
+    p->sum_mig_rates = 0;
 }
 
 
-void set_nb(patch_t* world, double* P_start, size_t* nb_start, size_t ij, size_t NM) {
+void set_nb(patch_t* world, size_t* nb_start, size_t ij, size_t NM) {
     // nb_start is the where patch ij's neighbor indices start
     size_t num_nb = 0;
     for (size_t k = 0; k < 4; k++) {
@@ -42,6 +45,6 @@ void set_nb(patch_t* world, double* P_start, size_t* nb_start, size_t ij, size_t
             world[ij].nb[k] = NULL;
         }
     }
-    P_start[0] *= (0.25 * num_nb);  // scale total migration rates by how many neighbors the patch has
-    P_start[1] *= (0.25 * num_nb);
+    world[ij].P[0] *= (0.25 * num_nb);
+    world[ij].P[1] *= (0.25 * num_nb);
 }

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/C_core/patch.h

@@ -10,7 +10,7 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
-
+#include <string.h>
 
 
 typedef struct patch_t {
@@ -22,6 +22,9 @@ typedef struct patch_t {
     double U_pi;
     double V_pi;
 
+    double X[4];  // a copy of matrix and patch variables (mu, w, kappa)
+    double P[6];
+
     struct patch_t* nb[4];
     double U_weight[4];  // stores migration weight of each of the 4 neighbors
     double V_weight[4];
@@ -34,8 +37,8 @@ typedef struct patch_t {
 } patch_t;
 
 // in .c
-void patch_init(patch_t* p, uint32_t U, uint32_t V, size_t row, size_t col);
-void set_nb(patch_t* world, double* P_start, size_t* nb_start, size_t ij, size_t NM) ;
+void patch_init(patch_t* p, uint32_t U, uint32_t V, size_t row, size_t col, double* X_start, double* P_start);
+void set_nb(patch_t* world, size_t* nb_start, size_t ij, size_t NM) ;
 
 #endif // PATCH_H
 

piegy-2.3.9/src/piegy/C_core/random.h

@@ -0,0 +1,77 @@
+/**
+ * The Random Number Generation module
+ * Returns a random double in (0, 1) with 2^-53 resolution, 0 and 1 not included
+ * 
+ * First initialize xoshiro256+ states with Splitmix64
+ * Then use xoshiro256+ for random number generation
+ * 
+ * Referrence:
+ * xoshiro256++ code: https://prng.di.unimi.it
+ * Splitmix64 code: https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64
+ * 
+*/
+
+#include <stdint.h>
+
+
+// resolution of random01 is 2^-53
+// which is (about) the IEEE 754 double precision
+#define MAX_53BIT (uint64_t) ((1ULL << 53) - 1)
+#define RAND_DENOM 1.0 / ((double) (1ULL << 53))
+// xor_state
+static uint64_t xor_state[4];
+static uint64_t splitmix64_state;
+
+
+
+static inline uint64_t Splitmix64_rand() {
+    // used to seed PCG initial states
+    splitmix64_state += 0x9e3779b97f4a7c15ULL;
+    uint64_t z = splitmix64_state;
+    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;
+    z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;
+    return z ^ (z >> 31);
+}
+
+
+static inline uint64_t rot23(const uint64_t x) {
+    // 23 and 64 - 23
+    // Not used here, part of xoshiro256++
+	return (x << 23) | (x >> 41);
+}
+
+
+static inline uint64_t rot45(const uint64_t x) {
+    // 45 and 64 - 45
+	return (x << 45) | (x >> 19);
+}
+
+
+static inline double random01() {
+    // return a random number in (0, 1) with 2^-53 resolution. 0 and 1 not included.
+
+	const uint64_t result = xor_state[0] + xor_state[3];
+    const uint64_t t = xor_state[1] << 17;
+
+	xor_state[2] ^= xor_state[0];
+	xor_state[3] ^= xor_state[1];
+	xor_state[1] ^= xor_state[2];
+	xor_state[0] ^= xor_state[3];
+
+    xor_state[2] ^= t;
+	xor_state[3] = rot45(xor_state[3]);
+
+	return ((double) (result & MAX_53BIT) + 0.5) * RAND_DENOM;
+}
+
+
+static inline void rand_init(const uint64_t seed) {
+    // initialize PCG random
+    splitmix64_state = seed;
+    for (int i = 0; i < 4; i++) {
+        xor_state[i] = Splitmix64_rand();
+    }
+    (void) random01();
+}
+
+

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/C_core/sim_funcs.c

@@ -81,7 +81,7 @@ static double single_init(const model_t* restrict mod, patch_t* restrict world,
     // init world
     for (size_t i = 0; i < N; i++) {
         for (size_t j = 0; j < M; j++) {
-            patch_init(&world[ij_out], mod->I[ij_out * 2], mod->I[ij_out * 2 + 1], i, j);
+            patch_init(&world[ij_out], mod->I[ij_out * 2], mod->I[ij_out * 2 + 1], i, j, &(mod->X[ij_out * 4]), &(mod->P[ij_out * 6]));
             ij_out++;
         }
     }
@@ -107,21 +107,21 @@ static double single_init(const model_t* restrict mod, patch_t* restrict world,
 
     // set nb pointers for patches
     for (size_t ij = 0; ij < NM; ij++) {
-        set_nb(world, &(mod->P[ij * 6]), &nb_indices[ij * 4], ij, NM);
+        set_nb(world, &nb_indices[ij * 4], ij, NM);
     }
 
     //////// Begin Running ////////
 
     // init payoff & natural death rates
     for (size_t ij = 0; ij < N; ij++) {
-        update_pi_k(&world[ij], &(mod->X[ij * 4]), &(mod->P[ij * 6]));
+        update_pi_k(&world[ij]);
     }
 
     // init migration rates & store patch rates
     ij_out = 0;
     for (size_t i = 0; i < N; i++) {
         for (size_t j = 0; j < M; j++) {
-            uint8_t mig_result = init_mig(&world[ij_out], &(mod->P[ij_out * 6]));  // init mig rates for all 4 directions
+            uint8_t mig_result = init_mig(&world[ij_out]);  // init mig rates for all 4 directions
             if (mig_result == SIM_OVERFLOW) {
                 return -1 * SIM_OVERFLOW;
             }
@@ -144,7 +144,7 @@ static double single_init(const model_t* restrict mod, patch_t* restrict world,
 
     // make signal
     if (mod->boundary) {
-        make_signal_zero_flux(picked_p->i, picked_p->j, e0, sig_p); 
+        make_signal_zero_flux(N, M, picked_p->i, picked_p->j, e0, sig_p); 
     } else {
         make_signal_periodical(N, M, picked_p->i, picked_p->j, e0, sig_p);
     }
@@ -164,7 +164,7 @@ static double single_init(const model_t* restrict mod, patch_t* restrict world,
         // maxtime too small
         return -1 * SMALL_MAXTIME;
     }
-
+    
     // store data
     if (time > mod->record_itv) {
         size_t recod_idx = (size_t) (time / mod->record_itv);
@@ -194,24 +194,10 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
     size_t max_record = mod->max_record;
     double record_itv = mod->record_itv;
     bool boundary = mod->boundary;
-    double* X = mod->X;
-    double* P = mod->P;
-    double* U1d = mod->U1d;
-    double* V1d = mod->V1d;
-    double* Upi_1d = mod->Upi_1d;
-    double* Vpi_1d = mod->Vpi_1d;
-
-    // print progress
-    double one_progress = 0.0;
-    if (mod->print_pct != -1) {
-        one_progress = maxtime * mod->print_pct / 100.0;
-        fprintf(stdout, "\r                     ");
-        fprintf(stdout, "\r%s: 0 %%", message);
-        fflush(stdout);
-    } else {
-        one_progress = 2.0 * maxtime;
-    }
-    double current_progress = one_progress;
+    double* mod_U1d = mod->U1d;
+    double* mod_V1d = mod->V1d;
+    double* mod_Upi_1d = mod->Upi_1d;
+    double* mod_Vpi_1d = mod->Vpi_1d;
 
     // update sum of rates every 1e5 rounds
     // many rates are updated each time, rather than re-calculated. 
@@ -219,10 +205,17 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
     size_t curr_update_sum_round = 0;  // current round
     size_t update_sum_freq = UPDATE_SUM_ROUNDS_SM;  // recalculate sum every this many rounds
 
-    // Initialize simulation
+    // set make_signal function based on boundary conditions
+    void (*make_signal)(size_t, size_t, size_t, size_t, uint8_t, signal_t*);
+    if (mod->boundary) {
+        make_signal = &make_signal_zero_flux;
+    } else {
+        make_signal = &make_signal_periodical;
+    }
+
+    // core containers
     patch_t* world = (patch_t*) calloc(NM, sizeof(patch_t));
     size_t* nb_indices = (size_t*) calloc(NM * 4, sizeof(size_t));
-
     double* patch_rates = (double*) calloc(NM, sizeof(double));
     double* sum_rates_by_row = (double*) calloc(N, sizeof(double));
     double sum_rates = 0;
@@ -230,6 +223,17 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
     signal_t signal;
     patch_picked_t picked;
 
+    // print progress
+    double one_progress = one_progress = 2.0 * maxtime;
+    if (mod->print_pct != -1) {
+        one_progress = maxtime * mod->print_pct / 100.0;
+        fprintf(stdout, "\r                     ");
+        fprintf(stdout, "\r%s: 0 %%", message);
+        fflush(stdout);
+    }
+    double current_progress = one_progress;
+
+    // Call single_init. Initialize rates and run for 1 event
     double time = single_init(mod, world, nb_indices, patch_rates, sum_rates_by_row, &sum_rates, &signal, &picked);
     if (time == -1 * SMALL_MAXTIME) {
         // time too small
@@ -251,9 +255,10 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
     size_t record_index = (size_t) (time / mod->record_itv);
     double record_time = time - record_index * record_itv;
 
+    ////////  while loop  ////////
 
     while (time < maxtime) {
-        
+
         // update sums and print progress
         curr_update_sum_round++;
         if (curr_update_sum_round > update_sum_freq) {
@@ -264,11 +269,14 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 uint8_t curr_prog = (uint8_t)(time * 100 / maxtime);
                 if (curr_prog < 10) {
                     fprintf(stdout, "\r%s: %d %%", message, (int)(time * 100 / maxtime));
+                    fflush(stdout);
                 } else {
                     fprintf(stdout, "\r%s: %d%%", message, (int)(time * 100 / maxtime));
+                    fflush(stdout);
                 }
-                fflush(stdout);
-                //fflush(stdout);  // Make sure it prints immediately
+                //fprintf(stdout, "\n99: %d, %d, %f, %f\n100: %d, %d, %f, %f\n", 
+                //world[98].U, world[98].V, world[98].mig_rates[3], world[98].mig_rates[7], world[99].U, world[99].V, world[99].mig_rates[2], world[99].mig_rates[6]);
+                //fflush(stdout);
                 current_progress += one_progress;
             }
 
@@ -315,8 +323,8 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
             sum_rates_by_row[si1] -= patch_rates[sij1];
             sum_rates -= patch_rates[sij1];
 
-            update_pi_k(&world[sij1], &(X[sij1 * 4]), &(P[sij1 * 6]));
-            update_mig_just_rate(&world[sij1], &(P[sij1 * 6]));
+            update_pi_k(&world[sij1]);
+            update_mig_just_rate(&world[sij1]);
 
             patch_rates[sij1] = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
             sum_rates_by_row[si1] += patch_rates[sij1];
@@ -328,11 +336,11 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
             sum_rates -= patch_rates[sij1];
             sum_rates -= patch_rates[sij2];
 
-            update_pi_k(&world[sij1], &(X[sij1 * 4]), &(P[sij1 * 6]));  // update both patches' payoffs first
-            update_pi_k(&world[sij2], &(X[sij2 * 4]), &(P[sij2 * 6]));
+            update_pi_k(&world[sij1]);  // update both patches' payoffs first
+            update_pi_k(&world[sij2]);
 
-            if (update_mig_weight_rate(&world[sij1], &(P[sij1 * 6]), rela_loc) == SIM_OVERFLOW || 
-                update_mig_weight_rate(&world[sij2], &(P[sij2 * 6]), rela_loc ^ 1) == SIM_OVERFLOW) {
+            if (update_mig_weight_rate(&world[sij1], rela_loc) == SIM_OVERFLOW || 
+                update_mig_weight_rate(&world[sij2], rela_loc ^ 1) == SIM_OVERFLOW) {
 
                 fprintf(stdout, "\nError: overflow at t = %f\n", time);
                 fflush(stdout);
@@ -354,7 +362,7 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 size_t nb_idx = nb_indices[sij1 * 4 + k];
                 if (nb_idx == NM) { continue; }  // invalid neighbor
                 // all neighbors, as long as exists, need to change
-                if (update_mig_weight_rate(&world[nb_idx], &(P[nb_idx * 6]), k ^ 1) == SIM_OVERFLOW) {
+                if (update_mig_weight_rate(&world[nb_idx], k ^ 1) == SIM_OVERFLOW) {
                     fprintf(stdout, "\nError: overflow at t = %f\n", time);
                     fflush(stdout);
                     single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
@@ -369,7 +377,7 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 if (nb_idx == NM) { continue; }
                 if (k != rela_loc) {
                     // nb_idx isn't the second last-changed patch
-                    if (update_mig_weight_rate(&world[nb_idx], &(P[nb_idx * 6]), k ^ 1) == SIM_OVERFLOW) {
+                    if (update_mig_weight_rate(&world[nb_idx], k ^ 1) == SIM_OVERFLOW) {
                         fprintf(stdout, "\nError: overflow at t = %f\n", time);
                         fflush(stdout);
                         single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
@@ -383,7 +391,7 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 if (nb_idx == NM) { continue; }
                 if (k != (rela_loc ^ 1)) {
                     // nb_idx isn't the first last-changed patch
-                    if (update_mig_weight_rate(&world[nb_idx], &(P[nb_idx * 6]), k ^ 1) == SIM_OVERFLOW) {
+                    if (update_mig_weight_rate(&world[nb_idx], k ^ 1) == SIM_OVERFLOW) {
                         fprintf(stdout, "\nError: overflow at t = %f\n", time);
                         fflush(stdout);
                         single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
@@ -393,7 +401,6 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
             }
         }
 
-
         // pick a random event
         double expected_sum = random01() * sum_rates;
         find_patch(&picked, expected_sum, patch_rates, sum_rates_by_row, sum_rates, N, M);
@@ -407,13 +414,9 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         }
 
         // make signal
-        if (boundary) {
-            make_signal_zero_flux(picked.i, picked.j, e0, &signal);
-        } else {
-            make_signal_periodical(N, M, picked.i, picked.j, e0, &signal);
-        }
+        (*make_signal)(N, M, picked.i, picked.j, e0, &signal);
         signal.ij1 = signal.i1 * M + signal.j1;
-        signal.ij2 = signal.i2 * M + signal.j2; 
+        signal.ij2 = signal.i2 * M + signal.j2;
 
         // let the event happenn
         change_popu(&world[signal.ij1], signal.e1);
@@ -436,10 +439,10 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 for (size_t ij = 0; ij < NM; ij++) {
                     size_t ij_max_record = ij * max_record;
                     for (size_t k = record_index; k < upper; k++) {
-                        U1d[ij_max_record + k] += world[ij].U;
-                        V1d[ij_max_record + k] += world[ij].V;
-                        Upi_1d[ij_max_record + k] += world[ij].U_pi;
-                        Vpi_1d[ij_max_record + k] += world[ij].V_pi;
+                        mod_U1d[ij_max_record + k] += world[ij].U;
+                        mod_V1d[ij_max_record + k] += world[ij].V;
+                        mod_Upi_1d[ij_max_record + k] += world[ij].U_pi;
+                        mod_Vpi_1d[ij_max_record + k] += world[ij].V_pi;
                     }
                 }
                 record_index += multi_records;
@@ -450,10 +453,10 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
             for (size_t ij = 0; ij < NM; ij++) {
                 size_t ij_max_record = ij * max_record;
                 for (size_t k = record_index; k < max_record; k++) {
-                    U1d[ij_max_record + k] += world[ij].U;
-                    V1d[ij_max_record + k] += world[ij].V;
-                    Upi_1d[ij_max_record + k] += world[ij].U_pi;
-                    Vpi_1d[ij_max_record + k] += world[ij].V_pi;
+                    mod_U1d[ij_max_record + k] += world[ij].U;
+                    mod_V1d[ij_max_record + k] += world[ij].V;
+                    mod_Upi_1d[ij_max_record + k] += world[ij].U_pi;
+                    mod_Vpi_1d[ij_max_record + k] += world[ij].V_pi;
                 }
             }
         }
@@ -500,40 +503,40 @@ uint8_t run(model_t* restrict mod, char* message, size_t msg_len) {
 
     // initialize random
     if (mod->seed != -1) {
-        srand((uint32_t) mod->seed);
-    } else {
-        srand(time(NULL));
-    }
-
-    if (mod->seed == -1){
-        srand(time(NULL));
+        rand_init((uint64_t) mod->seed);
     } else {
-        srand(mod->seed);
+        rand_init((uint64_t) time(NULL));
     }
 
     if (mod->print_pct == 0) {
         mod->print_pct = 5;  // default print_pct
+    } 
+    size_t print_round = 0;  // print every some round if print_pct == x * 100, set to 0 for not printing
+    if (mod->print_pct >= 100) {
+        print_round = mod->print_pct / 100;  // print progress every some round
+        mod->print_pct = -1;  // not printing progress in single_test
     }
 
-    size_t i = 0;
+    size_t round = 0;
 
-    while (i < mod->sim_time) {
+    while (round < mod->sim_time) {
         char curr_msg[100 + msg_len];  // message for current round
         strcpy(curr_msg, message);
         strcat(curr_msg, "round ");
-        snprintf(curr_msg + strlen(curr_msg), sizeof(curr_msg) - strlen(curr_msg), "%zu", i);
+        snprintf(curr_msg + strlen(curr_msg), sizeof(curr_msg) - strlen(curr_msg), "%zu", round);
 
-        /*if (predict_runtime && i > 0) {
-            double time_elapsed = timer() - start;
-            double pred_runtime = time_elapsed / i * (mod->sim_time - i);
-            snprintf(end_info, sizeof(end_info), ", ~%.2fs left", pred_runtime);
-        }*/
+        if ((print_round != 0) && (round % print_round == 0)) {
+            // only printing the round number
+            // add "!= 0" because round 0 could trigger printing
+            fprintf(stdout, "\r%s", curr_msg);
+            fflush(stdout);
+        }
 
         uint8_t result = single_test(mod, curr_msg);
         
         switch (result) {
             case SUCCESS:
-                i++;
+                round++;
                 break;
             case SMALL_MAXTIME:
                 // error message is handled by single_test
@@ -549,9 +552,9 @@ uint8_t run(model_t* restrict mod, char* message, size_t msg_len) {
 
     calculate_ave(mod);
 
-    double stop = clock();
-
-    if (mod->print_pct != -1) {
+    if ((mod->print_pct != -1) || (print_round != 0)) {
+        // print runtime if the original mod->print_pct != -1
+        double stop = clock();
         fprintf(stdout, "\r%sruntime: %.3fs             \n", message, (double)(stop - start) / CLOCKS_PER_SEC);
         fflush(stdout);
     }

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/C_core/sim_funcs.h

@@ -15,11 +15,11 @@
 
 #include "patch.h"
 #include "model.h"
+#include "random.h"
+
 
 
 
-// upper bound for RNG is 2^30 + 1
-#define RAND_UPPER_PLUS_2 (double) ((1LL << 30) + 1)
 
 // directions of migration
 // so that 3 - mig_dir = reflection of it. Used to track neighbors
@@ -55,8 +55,6 @@
 #define UPDATE_SUM_ROUNDS_SM 100  // small, more frequent if some rate is larger than ACCURATE_BOUND
 #define UPDATE_SUM_ROUNDS_LG 10000
 
- 
-
 
 /**
  * index of patch in find_patch
@@ -105,42 +103,27 @@ uint8_t run(model_t* restrict mod, char* message, size_t msg_len);
 
 
 
-/**
- * Inline Functions
-*/
-
-static inline double random01() {
-    // generate a 24 bit random int, then convert to a (0, 1) ranged double
-    uint32_t r1 = rand() & 0x7fff;  // RAND_MAX is different across machines, ensure 15 bits
-    uint32_t r2 = rand() & 0x7fff;
-
-    double r_combined = (r1  << 15) + r2;
-    return (r_combined + 1) / RAND_UPPER_PLUS_2;
-}
-
 /**
  * patch functions
 */
 
-static inline void update_pi_k(patch_t* restrict p, const double* restrict M_start, const double* restrict P_start) {
-    // M_start: start index of patch (i, j)'s matrix
-    // P_start: start index of p's patch variables, i.e., ij * 6
-
+static inline void update_pi_k(patch_t* restrict p) {
+    // update payoff and carrying capacity rates 
     uint32_t U = p->U;
     uint32_t V = p->V;
     double sum = U + V;
-    double U_ratio = U / sum;
-    double V_ratio = V / sum;
 
     if (sum > 0) {
+        double U_ratio = U / sum;
+        double V_ratio = V / sum;
         if (U > 0) {
-            p->U_pi = U_ratio * M_start[0] + V_ratio * M_start[1];
+            p->U_pi = U_ratio * p->X[0] + V_ratio * p->X[1];
         } else {
             p->U_pi = 0.0;
         }
 
         if (V > 0) {
-            p->V_pi = U_ratio * M_start[2] + V_ratio * M_start[3];
+            p->V_pi = U_ratio * p->X[2] + V_ratio * p->X[3];
         } else {
             p->V_pi = 0.0;
         }
@@ -153,8 +136,8 @@ static inline void update_pi_k(patch_t* restrict p, const double* restrict M_sta
     p->pi_death_rates[0] = fabs(U * p->U_pi);
     p->pi_death_rates[1] = fabs(V * p->V_pi);
 
-    p->pi_death_rates[2] = P_start[4] * U * sum;
-    p->pi_death_rates[3] = P_start[5] * V * sum;
+    p->pi_death_rates[2] = p->P[4] * U * sum;
+    p->pi_death_rates[3] = p->P[5] * V * sum;
 
     p->sum_pi_death_rates = 0.0;
     for (size_t i = 0; i < 4; i++) {
@@ -164,14 +147,14 @@ static inline void update_pi_k(patch_t* restrict p, const double* restrict M_sta
 
 
 
-static inline void update_mig_just_rate(patch_t* restrict p, const double* restrict P_start) {
+static inline void update_mig_just_rate(patch_t* restrict p) {
     // update migration weight for patch p, in location loc. Only rate is updated
     // used by last-changed patch, when there is only one last-changed patch
     double* p_U_weight = p->U_weight;
     double* p_V_weight = p->V_weight;
 
-    double mu1_U = P_start[0] * p->U;
-    double mu2_V = P_start[1] * p->V;
+    double mu1_U = p->P[0] * p->U;
+    double mu2_V = p->P[1] * p->V;
     
     double mu1_U_divide_sum = mu1_U / p->sum_U_weight;
     double mu2_V_divide_sum = mu2_V / p->sum_V_weight;
@@ -184,7 +167,7 @@ static inline void update_mig_just_rate(patch_t* restrict p, const double* restr
 }
 
 
-static inline uint8_t update_mig_weight_rate(patch_t* restrict p, const double* P_start, uint8_t loc) {
+static inline uint8_t update_mig_weight_rate(patch_t* restrict p, const uint8_t loc) {
     // update migration weight as well as rates, in one direction
     // used by neighbors of last-changed patches
     // also used by last-changed patches themselve, when there are two patch changed, to update mig rates of in each other's direction
@@ -196,8 +179,8 @@ static inline uint8_t update_mig_weight_rate(patch_t* restrict p, const double*
     p->sum_U_weight -= p_U_weight[loc];
     p->sum_V_weight -= p_V_weight[loc];
 
-    double w1_Upi = P_start[2] * nbi->U_pi;
-    double w2_Vpi = P_start[3] * nbi->V_pi;
+    double w1_Upi = p->P[2] * nbi->U_pi;
+    double w2_Vpi = p->P[3] * nbi->V_pi;
     if (w1_Upi > EXP_OVERFLOW_BOUND) {
         return SIM_OVERFLOW;
     }
@@ -226,8 +209,8 @@ static inline uint8_t update_mig_weight_rate(patch_t* restrict p, const double*
     p->sum_U_weight += p_U_weight[loc];
     p->sum_V_weight += p_V_weight[loc];
 
-    double mu1_U = P_start[0] * (double)p->U;
-    double mu2_V = P_start[1] * (double)p->V;
+    double mu1_U = p->P[0] * p->U;
+    double mu2_V = p->P[1] * p->V;
     double mu1_U_divide_sum = mu1_U / p->sum_U_weight;
     double mu2_V_divide_sum = mu2_V / p->sum_V_weight;
 
@@ -242,7 +225,7 @@ static inline uint8_t update_mig_weight_rate(patch_t* restrict p, const double*
 
 
 
-static inline uint8_t init_mig(patch_t* restrict p, const double* restrict P_start) {
+static inline uint8_t init_mig(patch_t* restrict p) {
     // update migration rate for all directions
 
     double* p_U_weight = p->U_weight;
@@ -251,8 +234,8 @@ static inline uint8_t init_mig(patch_t* restrict p, const double* restrict P_sta
     p->sum_U_weight = 0.0;
     p->sum_V_weight = 0.0;
 
-    double w1 = P_start[2];
-    double w2 = P_start[3];
+    double w1 = p->P[2];
+    double w2 = p->P[3];
 
     for (uint8_t i = 0; i < 4; i++) {
         patch_t* nbi = p->nb[i];
@@ -274,8 +257,8 @@ static inline uint8_t init_mig(patch_t* restrict p, const double* restrict P_sta
         }
     }
 
-    double mu1_U = P_start[0] * (double)p->U;
-    double mu2_V = P_start[1] * (double)p->V;
+    double mu1_U = p->P[0] * p->U;
+    double mu2_V = p->P[1] * p->V;
     double mu1_U_divide_sum = mu1_U / p->sum_U_weight;
     double mu2_V_divide_sum = mu2_V / p->sum_V_weight;
 
@@ -290,7 +273,7 @@ static inline uint8_t init_mig(patch_t* restrict p, const double* restrict P_sta
 
 
 
-static inline uint8_t find_event(const patch_t* restrict p, double expected_sum) {
+static inline uint8_t find_event(const patch_t* restrict p, const double expected_sum) {
     size_t event = 0;
     double current_sum;
 
@@ -320,7 +303,7 @@ static inline uint8_t find_event(const patch_t* restrict p, double expected_sum)
 }
 
 
-static inline void change_popu(patch_t* restrict p, uint8_t s) {
+static inline void change_popu(patch_t* restrict p, const uint8_t s) {
     switch (s) {
         case 0:
             // Migration IN for U
@@ -362,11 +345,12 @@ static inline void change_popu(patch_t* restrict p, uint8_t s) {
  * Main Simulation Functions
 */
 
-static inline void find_patch(patch_picked_t* restrict picked, double expected_sum, 
-                                const double* restrict patch_rates, const double* restrict sum_rates_by_row, double sum_rates, size_t N, size_t M) {
+static inline void find_patch(patch_picked_t* restrict picked, const double expected_sum, 
+                                const double* restrict patch_rates, const double* restrict sum_rates_by_row, const double sum_rates, const size_t N, const size_t M) {
     double current_sum = 0;
     size_t row = 0;
     size_t col = 0;
+    size_t row_M = 0;
 
     // Find row
     if (N != 1) {
@@ -388,10 +372,9 @@ static inline void find_patch(patch_picked_t* restrict picked, double expected_s
             }
             row++;
         }
+        row_M = row * M;
     }
 
-    size_t row_M = row * M;
-
     // Find col in that row
     if ((expected_sum - current_sum) < sum_rates_by_row[row] * 0.5) {
         col = 0;
@@ -418,7 +401,10 @@ static inline void find_patch(patch_picked_t* restrict picked, double expected_s
 
 
 
-static inline void make_signal_zero_flux(size_t i, size_t j, uint8_t e, signal_t* restrict signal) {
+static inline void make_signal_zero_flux(const size_t N, const size_t M, const size_t i, const size_t j, const uint8_t e, signal_t* restrict signal) {
+    // pass in N & M as well to match the param set of make_signal_periodical
+    (void) N;
+    (void) M;
     // this is always the case for the first one
     signal->i1 = i;
     signal->j1 = j;
@@ -496,15 +482,12 @@ static inline void make_signal_zero_flux(size_t i, size_t j, uint8_t e, signal_t
             signal->e2 = 3;
             signal->rela_loc = MIG_RIGHT;
             return;
-        //default:
-        //    fprintf(stderr, "Bug: invalid case in make_signal_zf, i, j, e: %zu, %zu, %hhu\n", i, j, e);
-        //    return;
     }
 }
 
 
 
-static inline void make_signal_periodical(size_t N, size_t M, size_t i, size_t j, uint8_t e, signal_t* restrict signal) {
+static inline void make_signal_periodical(const size_t N, const size_t M, const size_t i, const size_t j, const uint8_t e, signal_t* restrict signal) {
     // this is always the case for the first one
     signal->i1 = i;
     signal->j1 = j;
@@ -582,9 +565,6 @@ static inline void make_signal_periodical(size_t N, size_t M, size_t i, size_t j
             signal->e2 = 3;
             signal->rela_loc = MIG_RIGHT;
             return;
-        //default:
-        //    fprintf(stderr, "Bug: invalid case in make_signal_pr, i, j, e: %zu, %zu, %hhu\n", i, j, e);
-        //    return;
     }
 }
 

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/__init__.py

@@ -23,7 +23,7 @@ from .build_info import build_info
 
 from .simulation import model, run, demo_model, UV_expected_val, check_overflow_func
 from .videos import make_video, SUPPORTED_FIGURES
-from .data_tools import save_data, read_data
+from .data_tools import save, load
 
 from .analysis import rounds_expected, scale_maxtime, check_convergence, combine_sim
 
@@ -38,7 +38,7 @@ simulation_memebers = ['model', 'run', 'demo_model']
 
 videos_members = ['make_video', 'SUPPORTED_FIGURES']
 
-data_members = ['save_data', 'read_data']
+data_members = ['save', 'load']
 
 analysis_members = ['expected_rounds', 'scale_maxtime', 'check_convergence', 'combine_mod']
 

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '2.3.7'
+__version__ = '2.3.9'
 
 '''
 version history:
@@ -44,4 +44,6 @@ version history:
 2.3.5: improved accuracy for simulation, now can better handle large mig rates. Numerical errors are now being checked and reduced automatically based on how large the values are.
 2.3.6: index error due to reduced accuracy is now explicitly handled.
 2.3.7: update migration rules on the boundary. mu values are scaled based on how many neighbors a patch has. Minor debugging in several modules.
+2.3.8: bug fix for 2.3.7 update.
+2.3.9: now use xoshiro256+ as RNG.
 '''

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/data_tools.py

@@ -2,8 +2,8 @@
 Stores and reads a model object.
 
 Functions:
-- save_data:    save a model object.
-- read_data:    read a model object.
+- save:    save a model object.
+- load:    load a model object.
 '''
 
 
@@ -12,9 +12,10 @@ from . import simulation
 import json
 import gzip
 import os
+import numpy as np
 
 
-def save_data(mod, dirs = '', print_msg = True):
+def save(mod, dirs = '', print_msg = True):
     '''
     Saves a model object. Data will be stored at dirs/data.json.gz
 
@@ -46,7 +47,6 @@ def save_data(mod, dirs = '', print_msg = True):
     inputs.append(mod.P.tolist())
     inputs.append(mod.print_pct)
     inputs.append(mod.seed)
-    inputs.append(mod.check_overflow)
     data.append(inputs)
 
     # skipped rng
@@ -54,11 +54,17 @@ def save_data(mod, dirs = '', print_msg = True):
     outputs = []
     outputs.append(mod.max_record)
     outputs.append(mod.compress_itv)
-    outputs.append(mod.U.tolist())
-    outputs.append(mod.V.tolist())
-    outputs.append(mod.Upi.tolist())
-    outputs.append(mod.Vpi.tolist())
-    # H&Vpi_total are not saved, will be calculated when reading the data
+    if not mod.data_empty:
+        outputs.append(mod.U.tolist())
+        outputs.append(mod.V.tolist())
+        outputs.append(mod.Upi.tolist())
+        outputs.append(mod.Vpi.tolist())
+    else:
+        outputs.append(None)
+        outputs.append(None)
+        outputs.append(None)
+        outputs.append(None)
+
     data.append(outputs)
 
     data_dirs = os.path.join(dirs, 'data.json.gz')
@@ -70,7 +76,7 @@ def save_data(mod, dirs = '', print_msg = True):
 
 
 
-def read_data(dirs):
+def load(dirs):
     '''
     Reads and returns a model object.
 
@@ -96,16 +102,19 @@ def read_data(dirs):
         try:
             mod = simulation.model(N = data[0][0], M = data[0][1], maxtime = data[0][2], record_itv = data[0][3],
                                 sim_time = data[0][4], boundary = data[0][5], I = data[0][6], X = data[0][7], P = data[0][8], 
-                                print_pct = data[0][9], seed = data[0][10], check_overflow = data[0][11])
+                                print_pct = data[0][9], seed = data[0][10], check_overflow = False)
         except:
-            raise ValueError('Invalid input parameters saved in data')
+            raise ValueError('Invalid input parameters stored in data')
 
         # outputs
         try:
             mod.set_data(data_empty = False, max_record = data[1][0], compress_itv = data[1][1], 
                         U = data[1][2], V = data[1][3], Upi = data[1][4], Vpi = data[1][5])
+            if (mod.U is None) or (isinstance(mod.U, np.ndarray) and mod.U.shape == () and mod.U.item() is None):
+                # if data is None
+                mod.data_empty = True
         except:
-            raise ValueError('Invalid model results saved in data')
+            raise ValueError('Invalid simulation results stored in data')
     
     return mod
 

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/simulation.py

@@ -164,22 +164,11 @@ class model:
         if check_overflow:
             check_overflow_func(self)
 
-        self.init_storage()             # initialize storage bins. Put in a separate function because might want to change maxtime 
-                                        # and that doesn't need to initialze the whole object again
+        # initialize storage bins.
+        self.set_data(data_empty = True, max_record = int(maxtime / record_itv), compress_itv = 1, 
+                      U = None, V = None, Upi = None, Vpi = None)
 
 
-    def init_storage(self):
-        # initialize storage bins
-        self.data_empty = True      # whether data storage bins are empty. model.run will refuse to run (raise error) if not empty.
-        self.max_record = int(self.maxtime / self.record_itv)   # int, how many data points to store sin total
-        self.compress_itv = 1       # int, intended to reduce size of data (if not 1). Updated by compress_data function
-                                    # if set to an int, say 20, mod will take average over every 20 data points and save them as new data.
-                                    # May be used over and over again to recursively reduce data size. 
-                                    # Default is 1, not to take average.
-        self.U = None               # initialized by simulation.run or data_tools.read_data
-        self.V = None
-        self.Upi = None
-        self.Vpi = None
 
 
     def check_valid_input(self, N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct, seed, check_overflow):
@@ -319,6 +308,8 @@ class model:
 
         if copy_data:
             # copy data as well
+            if self.data_empty:
+                print("Warning: model has empty data")
             sim2.set_data(self.data_empty, self.max_record, self.compress_itv, self.U, self.V, self.Upi, self.Vpi)
 
         return sim2
@@ -426,10 +417,10 @@ def run(mod, message = ""):
     P = np.ascontiguousarray(mod.P.flatten(), dtype = np.float64)
 
     mod_c = model_c()
-    success = LIB.mod_init(ctypes.byref(mod_c), 
+    init_sucess = LIB.mod_init(ctypes.byref(mod_c), 
                            mod.N, mod.M, mod.maxtime, mod.record_itv, mod.sim_time, mod.boundary,
                            I, X, P, mod.print_pct, mod.seed)
-    if not success:
+    if not init_sucess:
         LIB.mod_free_py(ctypes.byref(mod_c))
         del mod_c
         raise RuntimeError('Model initialization failed')

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/simulation_py.py

@@ -93,7 +93,13 @@ class patch:
     def set_nb_pointers(self, nb):
         # nb is a list of pointers (point to patches)
         # nb is passed from the model class
+        nb_count = 0
+        for nb_i in nb:
+            if nb_i != None:
+                nb_count += 1
         self.nb = nb
+        self.mu1 *= (0.25 * nb_count)
+        self.mu2 *= (0.25 * nb_count)
     
     
     def update_pi_k(self):
@@ -101,19 +107,21 @@ class patch:
 
         U = self.U  # bring the values to front
         V = self.V
-        sum_minus_1 = U + V - 1  # this value is used several times
+        sum_UV = U + V  # this value is used several times
         
-        if sum_minus_1 > 0:
+        if sum_UV > 0:
             # interaction happens only if there is more than 1 individual
+            U_ratio = U / sum_UV
+            V_ratio = V / sum_UV
             
             if U != 0:
                 # no payoff if U == 0
-                self.Upi = (U - 1) / sum_minus_1 * self.matrix[0] + V / sum_minus_1 * self.matrix[1]
+                self.Upi = U_ratio * self.matrix[0] + V_ratio * self.matrix[1]
             else:
                 self.Upi = 0
                 
             if V != 0:
-                self.Vpi = U / sum_minus_1 * self.matrix[2] + (V - 1) / sum_minus_1 * self.matrix[3]
+                self.Vpi = U_ratio * self.matrix[2] + V_ratio * self.matrix[3]
             else:
                 self.Vpi = 0
                 
@@ -127,8 +135,8 @@ class patch:
         self.pi_death_rates[1] = abs(V * self.Vpi)
 
         # update natural death rates
-        self.pi_death_rates[2] = self.kappa1 * U * (sum_minus_1 + 1)
-        self.pi_death_rates[3] = self.kappa2 * V * (sum_minus_1 + 1)
+        self.pi_death_rates[2] = self.kappa1 * U * sum_UV
+        self.pi_death_rates[3] = self.kappa2 * V * sum_UV
 
         # update sum of rates
         self.sum_pi_death_rates = sum(self.pi_death_rates)
@@ -143,8 +151,8 @@ class patch:
 
         for i in range(4):
             if self.nb[i] != None:
-                U_weight[i] = 1 + pow(math.e, self.w1 * self.nb[i].Upi)
-                V_weight[i] = 1 + pow(math.e, self.w2 * self.nb[i].Vpi)
+                U_weight[i] = pow(math.e, self.w1 * self.nb[i].Upi)
+                V_weight[i] = pow(math.e, self.w2 * self.nb[i].Vpi)
 
         mu1_U = self.mu1 * self.U
         mu2_V = self.mu2 * self.V
@@ -746,7 +754,7 @@ def single_test(mod, front_info, end_info, update_sum_frequency, rng):
 
 
 
-def run_py(mod, predict_runtime = False, message = ''):
+def run(mod, predict_runtime = False, message = ''):
     '''
     Main function. Recursively calls single_test to run many models and then takes the average.
 

{piegy-2.3.7 → piegy-2.3.9}/src/piegy/test_var.py

@@ -91,7 +91,7 @@ def test_var1(mod, var, values, dirs, compress_itv = None):
             simulation.run(sim2, message = current_var_str + ', ')
             if compress_itv != None:
                 sim2.compress_data(compress_itv)
-            data_t.save_data(sim2, var_dirs[k], print_msg = False)
+            data_t.save(sim2, var_dirs[k], print_msg = False)
             del sim2
         except (OverflowError, RuntimeError):
             print(current_var_str + ' raised error, skipped')
@@ -139,7 +139,7 @@ def test_var2(mod, var1, var2, values1, values2, dirs, compress_itv = None):
                 simulation.run(sim2, message = current_var_str + ', ')
                 if compress_itv != None:
                     sim2.compress_data(compress_itv)
-                data_t.save_data(sim2, var_dirs[k1][k2], print_msg = False)
+                data_t.save(sim2, var_dirs[k1][k2], print_msg = False)
                 del sim2
             except (OverflowError, RuntimeError):
                 print(current_var_str + ' raised error, skipped')
@@ -175,7 +175,7 @@ def var_UV1(var, values, var_dirs, ax_U = None, ax_V = None, start = 0.95, end =
 
     for k in range(len(var_dirs)):
         try:
-            simk = data_t.read_data(var_dirs[k])
+            simk = data_t.load(var_dirs[k])
         except FileNotFoundError:
             print(var + '=' + str(values[k]) + ' not found, skipped')
             U_ave.append(None)
@@ -244,7 +244,7 @@ def var_UV2(var1, var2, values1, values2, var_dirs, ax_U = None, ax_V = None, va
     for k1 in range(len(var_dirs)):
         for k2 in range(len(var_dirs[k1])):
             try:
-                simk = data_t.read_data(var_dirs[k1][k2])
+                simk = data_t.load(var_dirs[k1][k2])
             except FileNotFoundError:
                 print(var1 + '=' + str(values1[k1]) + ', ' + var2 + '=' + str(values2[k2]) + ' not found, skipped')
                 U_ave[k1].append(None)
@@ -332,7 +332,7 @@ def var_pi1(var, values, var_dirs, ax_U = None, ax_V = None, start = 0.95, end =
     
     for k in range(len(var_dirs)):
         try:
-            simk = data_t.read_data(var_dirs[k])
+            simk = data_t.load(var_dirs[k])
         except FileNotFoundError:
             print(var + '=' + str(values[k]) + ' not found, skipped')
             U_ave.append(None)
@@ -397,7 +397,7 @@ def var_pi2(var1, var2, values1, values2, var_dirs, ax_U = None, ax_V = None, va
     for k1 in range(len(var_dirs)):
         for k2 in range(len(var_dirs[k1])):
             try:
-                simk = data_t.read_data(var_dirs[k1][k2])
+                simk = data_t.load(var_dirs[k1][k2])
             except FileNotFoundError:
                 print(var1 + '=' + str(values1[k1]) + ', ' + var2 + '=' + str(values2[k2]) + ' not found, skipped')
                 U_ave[k1].append(None)
@@ -512,7 +512,7 @@ def var_convergence1(var_dirs, interval = 20, start = 0.8, fluc = 0.07):
     for k in range(len(var_dirs)):
         dirs = var_dirs[k]
         try:
-            simk = data_t.read_data(dirs)
+            simk = data_t.load(dirs)
         except FileNotFoundError:
             print(dirs + ' data not found, skipped')
             continue
@@ -581,7 +581,7 @@ def var_convergence2(var_dirs, interval = 20, start = 0.8, fluc = 0.07):
         for k in range(len(sublist)):
             dirs = sublist[k]
             try:
-                simk = data_t.read_data(dirs)
+                simk = data_t.load(dirs)
             except FileNotFoundError:
                 print(dirs + ' data not found, skipped')
                 continue

{piegy-2.3.7 → piegy-2.3.9/src/piegy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piegy
-Version: 2.3.7
+Version: 2.3.9
 Summary: Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory
 Author-email: Chenning Xu <cxu7@caltech.edu>
 License: BSD 3-Clause License

{piegy-2.3.7 → piegy-2.3.9}/src/piegy.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ src/piegy/C_core/model.c
 src/piegy/C_core/model.h
 src/piegy/C_core/patch.c
 src/piegy/C_core/patch.h
+src/piegy/C_core/random.h
 src/piegy/C_core/sim_funcs.c
 src/piegy/C_core/sim_funcs.h
 src/piegy/tools/__init__.py