piegy 2.3.3__tar.gz → 2.3.5__tar.gz

{piegy-2.3.3/src/piegy.egg-info → piegy-2.3.5}/PKG-INFO

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

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

{piegy-2.3.3 → piegy-2.3.5}/src/piegy/C_core/runner.c

@@ -11,11 +11,11 @@
 int main() {
     size_t N = 1;
     size_t M = 100;
-    double maxtime = 600;
+    double maxtime = 300;
     double record_itv = 0.1;
     size_t sim_time = 1;
     bool boundary = true;
-    uint32_t I_single[2] = {440, 220};
+    uint32_t I_single[2] = {3, 3};
     double X_single[4] = {-1, 4, 0, 2};
     double P_single[6] = {0.5, 0.5, 100, 100, 0.001, 0.001};
     int32_t print_pct = 1;
@@ -46,8 +46,7 @@ int main() {
     mod_init(mod, N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct, seed);
 
     char message[20] = "";  // writable buffer with enough space
-    uint32_t update_sum_freq = 64;
-    uint8_t result = run(mod, message, 20, update_sum_freq);
+    uint8_t result = run(mod, message, 20);
     
     /*for (size_t i = 0; i < mod->max_record; i++) {
         fprintf(stdout, "%f ", mod->U1d[i]);

{piegy-2.3.3 → piegy-2.3.5}/src/piegy/C_core/sim_funcs.c

@@ -191,7 +191,7 @@ static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices
 
 
 
-static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char* message) {
+static uint8_t single_test(model_t* restrict mod, char* message) {
     // bring some dimensions to the front
     size_t N = mod->N;
     size_t M = mod->M;
@@ -201,9 +201,9 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
     double record_itv = mod->record_itv;
     bool boundary = mod->boundary;
 
-    double one_time = maxtime / (double)(update_sum_freq > 100 ? update_sum_freq : 100);
+    // print progress
     double one_progress = 0.0;
-    
+    double current_progress = one_progress;
     if (mod->print_pct != -1) {
         one_progress = maxtime * mod->print_pct / 100.0;
         fprintf(stdout, "\r                     ");
@@ -213,11 +213,11 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
         one_progress = 2.0 * maxtime;
     }
 
-    double one_update_sum = maxtime / (double) (update_sum_freq + 1);
-
-    double current_time = one_time;
-    double current_progress = one_progress;
-    double current_update_sum = one_update_sum;
+    // update sum of rates every 1e5 rounds
+    // many rates are updated each time, rather than re-calculated. 
+    // So need to re-calculate from scratch every some time to reduce numerical errors
+    size_t curr_update_sum_round = 0;  // current round
+    size_t update_sum_freq = UPDATE_SUM_FREQ_SM;  // the frequency really using, change based on how large values are encountered
 
     // Initialize simulation
     patch_t* world = (patch_t*) calloc(NM, sizeof(patch_t));
@@ -249,47 +249,53 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
 
     while (time < maxtime) {
 
-        // Print progress and update sums if needed
-        if (time > current_time) {
-            current_time += one_time;
-            if (time > current_progress) {
-                uint8_t curr_prog = (uint8_t)(time * 100 / maxtime);
-                if (curr_prog < 10) {
-                    fprintf(stdout, "\r%s: %d %%", message, (int)(time * 100 / maxtime));
-                } else {
-                    fprintf(stdout, "\r%s: %d%%", message, (int)(time * 100 / maxtime));
-                }
-                fflush(stdout);
-                //fflush(stdout);  // Make sure it prints immediately
-                current_progress += one_progress;
+        // Print progress
+        if (time > current_progress) {
+            uint8_t curr_prog = (uint8_t)(time * 100 / maxtime);
+            if (curr_prog < 10) {
+                fprintf(stdout, "\r%s: %d %%", message, (int)(time * 100 / maxtime));
+            } else {
+                fprintf(stdout, "\r%s: %d%%", message, (int)(time * 100 / maxtime));
             }
-            if (time > current_update_sum) {
-                current_update_sum += one_update_sum;
+            fflush(stdout);
+            //fflush(stdout);  // Make sure it prints immediately
+            current_progress += one_progress;
+        }
+        
+        // update sums
+        curr_update_sum_round++;
+        if (curr_update_sum_round > update_sum_freq) {
+            curr_update_sum_round = 0;
+            update_sum_freq = UPDATE_SUM_FREQ_LG;  // assume can make it larger
+            size_t ij = 0;
 
-                // recalculate sum
-                size_t ij = 0;
-                for (size_t i = 0; i < N; i++) {
-                    for (size_t j = 0; j < M; j++) {
-                        world[ij].sum_U_weight = 0;
-                        world[ij].sum_V_weight = 0;
-                        for (size_t k = 0; k < 4; k++) {
-                            world[ij].sum_U_weight += world[ij].U_weight[k];
-                            world[ij].sum_V_weight += world[ij].V_weight[k];
-                        }
+            for (size_t i = 0; i < N; i++) {
+                for (size_t j = 0; j < M; j++) {
+                    double sum_U_weight = 0;
+                    double sum_V_weight = 0;
+                    for (size_t k = 0; k < 4; k++) {
+                        sum_U_weight += world[ij].U_weight[k];
+                        sum_V_weight += world[ij].V_weight[k];
                     }
-                }
-                ij = 0;
-                for (size_t i = 0; i < N; i++) {
-                    sum_rates_by_row[i] = 0;
-                    for (size_t j = 0; j < M; j++) {
-                        sum_rates_by_row[i] += patch_rates[ij];
-                        ij++;
+                    world[ij].sum_U_weight = sum_U_weight;
+                    world[ij].sum_V_weight = sum_V_weight;
+                    // patch_rates are updated every time a patch is changed
+                    if (sum_U_weight > ACCURATE_BOUND) {
+                        update_sum_freq = UPDATE_SUM_FREQ_SM;  // values too large, put back the small update frequency
                     }
+                    ij++;
                 }
-                sum_rates = 0;
-                for (size_t i = 0; i < N; i++) {
-                    sum_rates += sum_rates_by_row[i];
+            }
+            ij = 0;
+            sum_rates = 0;
+            for (size_t i = 0; i < N; i++) {
+                double sum_rates_by_row_i = 0;
+                for (size_t j = 0; j < M; j++) {
+                    sum_rates_by_row_i += patch_rates[ij];
+                    ij++;
                 }
+                sum_rates_by_row[i] = sum_rates_by_row_i;
+                sum_rates += sum_rates_by_row_i;
             }
         }
 
@@ -307,7 +313,7 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
             sum_rates -= patch_rates[sij1];
 
             update_pi_k(&world[sij1], &(mod->X[sij1 * 4]), &(mod->P[sij1 * 6]));
-            init_mig(&world[sij1], &(mod->P[sij1 * 6]));
+            update_mig_just_rate(&world[sij1], &(mod->P[sij1 * 6]));
 
             patch_rates[sij1] = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
             sum_rates_by_row[si1] += patch_rates[sij1];
@@ -358,7 +364,8 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
             for (uint8_t k = 0; k < 4; k++) {
                 size_t nb_idx = nb_indices[sij1 * 4 + k];
                 if (nb_idx == NM) { continue; }
-                if (nb_need_change(nb_idx, sij1, sij2)) {
+                if (k != rela_loc) {
+                    // nb_idx isn't the second last-changed patch
                     if (update_mig_weight_rate(&world[nb_idx], &(mod->P[nb_idx * 6]), k ^ 1) == SIM_OVERFLOW) {
                         fprintf(stdout, "\nError: overflow at t = %f\n", time);
                         fflush(stdout);
@@ -371,7 +378,8 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
             for (uint8_t k = 0; k < 4; k++) {
                 size_t nb_idx = nb_indices[sij2 * 4 + k];
                 if (nb_idx == NM) { continue; }
-                if (nb_need_change(nb_idx, sij1, sij2)) {
+                if (k != (rela_loc ^ 1)) {
+                    // nb_idx isn't the first last-changed patch
                     if (update_mig_weight_rate(&world[nb_idx], &(mod->P[nb_idx * 6]), k ^ 1) == SIM_OVERFLOW) {
                         fprintf(stdout, "\nError: overflow at t = %f\n", time);
                         fflush(stdout);
@@ -475,7 +483,7 @@ static void single_test_free(patch_t** world, size_t** nb_indices, double** patc
 
 
 
-uint8_t run(model_t* mod, char* message, size_t msg_len, uint32_t update_sum_freq) {
+uint8_t run(model_t* mod, char* message, size_t msg_len) {
     if (!mod->data_empty) {
         // this won't happen if called from python, the ``simulation.run`` caller has checked it.
         fprintf(stdout, "Error: mod has non-empty data\n");
@@ -518,7 +526,7 @@ uint8_t run(model_t* mod, char* message, size_t msg_len, uint32_t update_sum_fre
             snprintf(end_info, sizeof(end_info), ", ~%.2fs left", pred_runtime);
         }*/
 
-        uint8_t result = single_test(mod, update_sum_freq, curr_msg);
+        uint8_t result = single_test(mod, curr_msg);
         
         switch (result) {
             case SUCCESS:

{piegy-2.3.3 → piegy-2.3.5}/src/piegy/C_core/sim_funcs.h

@@ -36,9 +36,14 @@
 #define SMALL_MAXTIME 2
 #define SIM_OVERFLOW 3
 
-// where 1 + exp(x) is considered overflow
+// where exp(x) is considered overflow
 // below the actual bound (709) because the large numbers will be computed with close-to-0 ones (payoff rates), so higher accuracy is needed
 #define EXP_OVERFLOW_BOUND 500
+#define ACCURATE_BOUND 10000000000LL
+
+// how frequent to update rates & sum of rates in single test (recalculate)
+#define UPDATE_SUM_FREQ_SM 100
+#define UPDATE_SUM_FREQ_LG 10000
 
 
 static uint64_t pcg_state = 0;
@@ -87,9 +92,9 @@ static void find_nb_zero_flux(size_t* restrict nb, size_t i, size_t j, size_t N,
 static void find_nb_periodical(size_t* restrict nb, size_t i, size_t j, size_t N, size_t M, size_t NM);
 static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices, 
                     double* patch_rates, double* sum_rates_by_row, double* sum_rates, signal_t* sig_p, patch_picked_t* picked_p) ;
-static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_frequency, char* message);
+static uint8_t single_test(model_t* restrict mod, char* message);
 static void single_test_free(patch_t** world, size_t** nb_indices, double** patch_rates, double** sum_rates_by_row);
-uint8_t run(model_t* mod, char* message, size_t msg_len, uint32_t update_sum_freq);
+uint8_t run(model_t* mod, char* message, size_t msg_len);
 
 
 
@@ -116,19 +121,19 @@ static inline void update_pi_k(patch_t* restrict p, const double* restrict M_sta
 
     double U = (double) p->U;
     double V = (double) p->V;
-    double sum = U + V - 1;
-    //double U_ratio = U / sum;
-    //double V_ratio = V / sum;
+    double sum = U + V;
+    double U_ratio = U / sum;
+    double V_ratio = V / sum;
 
     if (sum > 0) {
         if (U > 0) {
-            p->U_pi = (U - 1) / sum * M_start[0] + V / sum * M_start[1];
+            p->U_pi = U_ratio * M_start[0] + V_ratio * M_start[1];
         } else {
             p->U_pi = 0.0;
         }
 
         if (V > 0) {
-            p->V_pi = U / sum * M_start[2] + (V - 1) / sum * M_start[3];
+            p->V_pi = U_ratio * M_start[2] + V_ratio * M_start[3];
         } else {
             p->V_pi = 0.0;
         }
@@ -141,8 +146,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 + 1);
-    p->pi_death_rates[3] = P_start[5] * V * (sum + 1);
+    p->pi_death_rates[2] = P_start[4] * U * sum;
+    p->pi_death_rates[3] = P_start[5] * V * sum;
 
     p->sum_pi_death_rates = 0.0;
     for (size_t i = 0; i < 4; i++) {
@@ -160,7 +165,6 @@ static inline void update_mig_just_rate(patch_t* restrict p, const double* restr
 
     double mu1_U = P_start[0] * (double)p->U;
     double mu2_V = P_start[1] * (double)p->V;
-    p->sum_mig_rates = mu1_U + mu2_V;
     
     double mu1_U_divide_sum = mu1_U / p->sum_U_weight;
     double mu2_V_divide_sum = mu2_V / p->sum_V_weight;
@@ -169,6 +173,7 @@ static inline void update_mig_just_rate(patch_t* restrict p, const double* restr
         p->mig_rates[i] = mu1_U_divide_sum * p_U_weight[i];
         p->mig_rates[i + 4] = mu2_V_divide_sum * p_V_weight[i];
     }
+    p->sum_mig_rates = mu1_U + mu2_V;
 }
 
 
@@ -195,20 +200,20 @@ static inline uint8_t update_mig_weight_rate(patch_t* restrict p, const double*
 
     switch(loc) {
         case MIG_UP:
-            p_U_weight[MIG_UP] = 1 + exp(w1_Upi);
-            p_V_weight[MIG_UP] = 1 + exp(w2_Vpi);
+            p_U_weight[MIG_UP] = exp(w1_Upi);
+            p_V_weight[MIG_UP] = exp(w2_Vpi);
             break;
         case MIG_DOWN:
-            p_U_weight[MIG_DOWN] = 1 + exp(w1_Upi);
-            p_V_weight[MIG_DOWN] = 1 + exp(w2_Vpi);
+            p_U_weight[MIG_DOWN] = exp(w1_Upi);
+            p_V_weight[MIG_DOWN] = exp(w2_Vpi);
             break;
         case MIG_LEFT:
-            p_U_weight[MIG_LEFT] = 1 + exp(w1_Upi);
-            p_V_weight[MIG_LEFT] = 1 + exp(w2_Vpi);
+            p_U_weight[MIG_LEFT] = exp(w1_Upi);
+            p_V_weight[MIG_LEFT] = exp(w2_Vpi);
             break;
         default:
-            p_U_weight[MIG_RIGHT] = 1 + exp(w1_Upi);
-            p_V_weight[MIG_RIGHT] = 1 + exp(w2_Vpi);
+            p_U_weight[MIG_RIGHT] = exp(w1_Upi);
+            p_V_weight[MIG_RIGHT] = exp(w2_Vpi);
             break;
     }
     p->sum_U_weight += p_U_weight[loc];
@@ -244,7 +249,6 @@ static inline uint8_t init_mig(patch_t* restrict p, const double* restrict P_sta
 
     for (uint8_t i = 0; i < 4; i++) {
         patch_t* nbi = p->nb[i];
-
         if (nbi) {
             // not NULL
             double w1_Upi = w1 * nbi->U_pi;
@@ -255,15 +259,14 @@ static inline uint8_t init_mig(patch_t* restrict p, const double* restrict P_sta
             if (w2_Vpi > EXP_OVERFLOW_BOUND) {
                 return SIM_OVERFLOW;
             }
-            p_U_weight[i] = 1 + exp(w1_Upi);
-            p_V_weight[i] = 1 + exp(w2_Vpi);
+            p_U_weight[i] = exp(w1_Upi);
+            p_V_weight[i] = exp(w2_Vpi);
 
             p->sum_U_weight += p_U_weight[i];
             p->sum_V_weight += p_V_weight[i];
         }
     }
 
-
     double mu1_U = P_start[0] * (double)p->U;
     double mu2_V = P_start[1] * (double)p->V;
     double mu1_U_divide_sum = mu1_U / p->sum_U_weight;
@@ -582,16 +585,4 @@ static inline void make_signal_periodical(size_t N, size_t M, size_t i, size_t j
 }
 
 
-static inline bool nb_need_change(size_t nb_idx, size_t sij1, size_t sij2) {
-    // a nb doesn't need change only if two patches are updated
-
-    // or, can try this 1-line version
-    // return (nb_idx != sij1) && (nb_idx != sij2);
-    if ((nb_idx == sij1) || (nb_idx == sij2)) {
-        return false;
-    }
-    return true;  // need to change
-}
-
-
 #endif

{piegy-2.3.3 → piegy-2.3.5}/src/piegy/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '2.3.3'
+__version__ = '2.3.4'
 
 '''
 version history:
@@ -40,4 +40,6 @@ version history:
 2.3.2: allow play-with-self in payoff calculation. Changed migration function to e^(w*pi) (removed "1+" term).
         Simplified update-migration functions, improve speed by ~10%. Add -march=native flag to Makefile.
 2.3.3: fix error in calculation of migration rates.
+2.3.4: change back to the mig & payoff rules in version 2.3.2
+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.
 '''

{piegy-2.3.3 → piegy-2.3.5}/src/piegy/figures.py

@@ -530,19 +530,19 @@ def video_fig(mod, ax_list = None, num_grid = 100, U_color = 'Purples', V_color
     
 
     im = ax_list[0, 0].imshow(ave_U, cmap = U_color)
-    ax_list[0, 0].get_figure().colorbar(im, ax = ax_list[0, 0])
+    ax_list[0, 0].get_figure().colorbar(im, ax = ax_list[0, 0], extent = [0, mod.N * mod.M, 0, mod.maxtime], origin='lower', aspect = 'auto')
     ax_list[0, 0].set_title('Population U over time')
         
     im = ax_list[0, 1].imshow(ave_V, cmap = V_color)
-    ax_list[0, 1].get_figure().colorbar(im, ax = ax_list[0, 1])
+    ax_list[0, 1].get_figure().colorbar(im, ax = ax_list[0, 1], extent = [0, mod.N * mod.M, 0, mod.maxtime], origin='lower', aspect = 'auto')
     ax_list[0, 1].set_title('Population V over time')
 
     im = ax_list[1, 0].imshow(ave_Upi, cmap = U_color)
-    ax_list[1, 0].get_figure().colorbar(im, ax = ax_list[1, 0])
+    ax_list[1, 0].get_figure().colorbar(im, ax = ax_list[1, 0], extent = [0, mod.N * mod.M, 0, mod.maxtime], origin='lower', aspect = 'auto')
     ax_list[1, 0].set_title('Payoff ' + r'$p_H$' + ' over time')
 
     im = ax_list[1, 1].imshow(ave_Vpi, cmap = V_color)
-    ax_list[1, 1].get_figure().colorbar(im, ax = ax_list[1, 1])
+    ax_list[1, 1].get_figure().colorbar(im, ax = ax_list[1, 1], extent = [0, mod.N * mod.M, 0, mod.maxtime], origin='lower', aspect = 'auto')
     ax_list[1, 1].set_title('Payoff ' + r'$p_D$' + ' over time')
 
     return ax_list

{piegy-2.3.3 → piegy-2.3.5}/src/piegy/simulation.py

@@ -25,11 +25,7 @@ from numpy.ctypeslib import ndpointer
 # check whether overflow / too large values might be encountered
 # these values are considered as exponents in exp()
 EXP_OVERFLOW_BOUND = 709  # where exp(x) almost reaches overflow bound
-EXP_TOO_LARGE_BOUND = 88  # where exp(x) reaches 1e20
-
-# how frequent to update sum in simulation, i.e., accuracy
-# the defuault value is 64, increase to 4 times if encounter error 
-UPDATE_SUM_FREQ = 64
+EXP_TOO_LARGE_BOUND = 88  # where exp(x) reaches 1e34
 
 
 # read the C core into LIB
@@ -101,7 +97,7 @@ def read_lib():
     LIB.mod_free_py.argtypes = [ctypes.POINTER(model_c)]
     LIB.mod_free_py.restype = None
 
-    LIB.run.argtypes = [ctypes.POINTER(model_c), ctypes.POINTER(c_char), c_size_t, c_uint32]
+    LIB.run.argtypes = [ctypes.POINTER(model_c), ctypes.POINTER(c_char), c_size_t]
     LIB.run.restype = c_ubyte  # which is uint8
 
 
@@ -410,7 +406,7 @@ class model:
 
 
 
-def run(mod, message = "", update_sum_freq = UPDATE_SUM_FREQ):
+def run(mod, message = ""):
     '''
     C-cored simulation
     '''
@@ -437,7 +433,7 @@ def run(mod, message = "", update_sum_freq = UPDATE_SUM_FREQ):
         del mod_c
         raise RuntimeError('Model initialization failed')
     
-    result = LIB.run(ctypes.byref(mod_c), msg_buffer, msg_len, update_sum_freq)
+    result = LIB.run(ctypes.byref(mod_c), msg_buffer, msg_len)
 
     if result == SIM_SUCCESS:
         mod.set_data(False, mod.max_record, 1, mod_c.get_array('U1d').reshape(mod.N, mod.M, mod.max_record), 

{piegy-2.3.3 → piegy-2.3.5/src/piegy.egg-info}/PKG-INFO

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