piegy 2.3.8__tar.gz → 2.3.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piegy
-Version: 2.3.8
+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.8 → piegy-2.3.9}/pyproject.toml

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

{piegy-2.3.8 → 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.8 → piegy-2.3.9}/src/piegy/C_core/patch.c

@@ -17,9 +17,6 @@ void patch_init(patch_t* p, uint32_t U, uint32_t V, size_t row, size_t col, doub
 
     memcpy(p->X, X_start, 4 * sizeof(double));
     memcpy(p->P, P_start, 6 * sizeof(double));
-    for (size_t i = 0; i < 6; i++) {
-        p->P[i] = P_start[i];
-    }
 
     for (size_t i = 0; i < 4; i++) {
         p->U_weight[i] = 0;

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.8 → piegy-2.3.9}/src/piegy/C_core/sim_funcs.c

@@ -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);
     }
@@ -205,6 +205,14 @@ 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
 
+    // 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));
@@ -261,10 +269,11 @@ 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);
                 //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);
@@ -405,11 +414,7 @@ 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;
 
@@ -498,15 +503,9 @@ 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) {

{piegy-2.3.8 → 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,19 +103,6 @@ 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
 */
@@ -127,10 +112,10 @@ static inline void update_pi_k(patch_t* restrict p) {
     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 * p->X[0] + V_ratio * p->X[1];
         } else {
@@ -182,7 +167,7 @@ static inline void update_mig_just_rate(patch_t* restrict p) {
 }
 
 
-static inline uint8_t update_mig_weight_rate(patch_t* restrict p, 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
@@ -288,7 +273,7 @@ static inline uint8_t init_mig(patch_t* restrict p) {
 
 
 
-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;
 
@@ -318,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
@@ -360,8 +345,8 @@ 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;
@@ -416,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;
@@ -499,7 +487,7 @@ static inline void make_signal_zero_flux(size_t i, size_t j, uint8_t e, signal_t
 
 
 
-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;

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

@@ -1,4 +1,4 @@
-__version__ = '2.3.8'
+__version__ = '2.3.9'
 
 '''
 version history:
@@ -45,4 +45,5 @@ version history:
 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.8 → piegy-2.3.9}/src/piegy/data_tools.py

@@ -12,6 +12,7 @@ from . import simulation
 import json
 import gzip
 import os
+import numpy as np
 
 
 def save(mod, dirs = '', print_msg = True):
@@ -46,7 +47,6 @@ def save(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(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')
@@ -96,16 +102,19 @@ def load(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.8 → 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.load
-        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

{piegy-2.3.8 → 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.8 → piegy-2.3.9/src/piegy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piegy
-Version: 2.3.8
+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.8 → 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