piegy 2.3.4__tar.gz → 2.3.6__tar.gz

{piegy-2.3.4/src/piegy.egg-info → piegy-2.3.6}/PKG-INFO

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

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

{piegy-2.3.4 → piegy-2.3.6}/src/piegy/C_core/Makefile

@@ -4,7 +4,6 @@ CC = gcc
 #### Common Flags ####
 
 ## Flags for Max Speed ##
-# standard
 CFLAGS_COMMON = -O3 -march=native -flto -std=c99 -DNDEBUG -ffp-contract=fast -funroll-loops -fomit-frame-pointer -MMD -MP
 LDFLAGS_COMMON = -flto
 

{piegy-2.3.4 → piegy-2.3.6}/src/piegy/C_core/runner.c

@@ -11,13 +11,13 @@
 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};
+    double P_single[6] = {0.5, 0.5, 80, 80, 0.001, 0.001};
     int32_t print_pct = 1;
     int32_t seed = 36;  // -1 for None
 
@@ -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.4 → piegy-2.3.6}/src/piegy/C_core/sim_funcs.c

@@ -68,8 +68,9 @@ static void find_nb_periodical(size_t* restrict nb, size_t i, size_t j, size_t N
 
 
 // single_init function: initializes world, runs 1 event, returns updated variables
-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_p, signal_t* sig_p, patch_picked_t* picked_p) {
+static double single_init(const model_t* restrict mod, patch_t* restrict world, size_t* restrict nb_indices, 
+                    double* restrict patch_rates, double* restrict sum_rates_by_row, double* restrict sum_rates_p, 
+                    signal_t* restrict sig_p, patch_picked_t* restrict picked_p) {
 
     size_t N = mod->N;
     size_t M = mod->M;
@@ -145,6 +146,9 @@ static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices
     find_patch(picked_p, expected_sum, patch_rates, sum_rates_by_row, *sum_rates_p, N, M);
     size_t picked_idx = picked_p->i * M + picked_p->j;
     size_t e0 = find_event(&world[picked_idx], expected_sum - picked_p->current_sum);
+    if (picked_idx >= NM || e0 >= 12) {
+        return -1 * ACCURACY_ERROR;
+    }
 
     // make signal
     if (mod->boundary) {
@@ -191,7 +195,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 +205,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 +217,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 rounds to reduce numerical errors
+    size_t curr_update_sum_round = 0;  // current round
+    size_t update_sum_rounds = UPDATE_SUM_ROUNDS_SM;  // recalculate sum every this many rounds
 
     // Initialize simulation
     patch_t* world = (patch_t*) calloc(NM, sizeof(patch_t));
@@ -242,54 +246,61 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
         fflush(stdout);
         single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
         return SIM_OVERFLOW;
-    }
+    } else if (time == -1 * ACCURACY_ERROR) {
+            fprintf(stdout, "\nError: accuracy too low at t = 0, simulation stopped\n");
+            fflush(stdout);
+            single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
+            return ACCURACY_ERROR;
+        }
     size_t record_index = time / mod->record_itv;
     double record_time = time - record_index * record_itv;
 
 
     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;
-
-                // 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];
-                        }
-                    }
+            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_rounds) {
+            curr_update_sum_round = 0;
+
+            update_sum_rounds = UPDATE_SUM_ROUNDS_LG;  // assume can make it larger
+            for (size_t ij = 0; ij < NM; ij++) {
+                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++;
-                    }
+                if (sum_U_weight > ACCURATE_BOUND || sum_V_weight > ACCURATE_BOUND) {
+                    update_sum_rounds = UPDATE_SUM_ROUNDS_SM;  // values too large, put back the small update frequency
                 }
-                sum_rates = 0;
-                for (size_t i = 0; i < N; i++) {
-                    sum_rates += sum_rates_by_row[i];
+                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
+            }
+            size_t 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;
             }
         }
 
@@ -301,13 +312,14 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
         size_t sij1 = signal.ij1;
         size_t sij2 = signal.ij2;
         uint8_t rela_loc = signal.rela_loc;
+
         if (rela_loc == NO_MIG) {
             // if only one
             sum_rates_by_row[si1] -= patch_rates[sij1];
             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 +370,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 +384,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);
@@ -388,6 +402,12 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
         find_patch(&picked, expected_sum, patch_rates, sum_rates_by_row, sum_rates, N, M);
         size_t picked_idx = picked.i * M + picked.j;
         uint8_t e0 = find_event(&world[picked_idx], expected_sum - picked.current_sum);
+        if (picked_idx >= NM || e0 >= 12) {
+            fprintf(stdout, "\nError: accuracy too low at t = %f, simulation stopped\n", time);
+            fflush(stdout);
+            single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
+            return ACCURACY_ERROR;
+        }
 
         // make signal
         if (boundary) {
@@ -416,16 +436,12 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
                 record_time -= multi_records * record_itv;
                 size_t upper = record_index + multi_records;
 
-                size_t ij = 0;
-                for (size_t i = 0; i < N; i++) {
-                    for (size_t j = 0; j < M; j++) {
-                        for (size_t k = record_index; k < upper; k++) {
-                            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;
-                        }
-                        ij++;
+                for (size_t ij = 0; ij < NM; ij++) {
+                    for (size_t k = record_index; k < upper; k++) {
+                        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;
@@ -433,16 +449,12 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
 
         } else {
             // if already exceeds maxtime
-            size_t ij = 0;
-            for (size_t i = 0; i < N; i++) {
-                for (size_t j = 0; j < M; j++) {
-                    for (size_t k = record_index; k < max_record; k++) {
-                        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;
-                    }
-                    ij++;
+            for (size_t ij = 0; ij < NM; ij++) {
+                for (size_t k = record_index; k < max_record; k++) {
+                    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;
                 }
             }
         }
@@ -475,7 +487,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* restrict 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 +530,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:
@@ -530,6 +542,9 @@ uint8_t run(model_t* mod, char* message, size_t msg_len, uint32_t update_sum_fre
             case SIM_OVERFLOW:
                 // error message is handled by single_test
                 return SIM_OVERFLOW;
+            case ACCURACY_ERROR:
+                // error message is handled by single_test
+                return ACCURACY_ERROR;
         }
     }
 

{piegy-2.3.4 → piegy-2.3.6}/src/piegy/C_core/sim_funcs.h

@@ -35,10 +35,16 @@
 #define DATA_NOT_EMPTY 1
 #define SMALL_MAXTIME 2
 #define SIM_OVERFLOW 3
+#define ACCURACY_ERROR 4
 
 // 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
+// below the actual bound (709) to preserve accuracy
 #define EXP_OVERFLOW_BOUND 500
+#define ACCURATE_BOUND 10000000000LL
+
+// how frequent to update rates & sum of rates in single test (recalculate)
+#define UPDATE_SUM_ROUNDS_SM 100
+#define UPDATE_SUM_ROUNDS_LG 10000
 
 
 static uint64_t pcg_state = 0;
@@ -85,11 +91,12 @@ typedef struct signal_t {
 */
 static void find_nb_zero_flux(size_t* restrict nb, size_t i, size_t j, size_t N, size_t M, size_t NM);
 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 double single_init(const model_t* restrict mod, patch_t* restrict world, size_t* restrict nb_indices, 
+                    double* restrict patch_rates, double* restrict sum_rates_by_row, double* restrict sum_rates_p, 
+                    signal_t* restrict sig_p, patch_picked_t* restrict picked_p);
+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* restrict mod, char* message, size_t msg_len);
 
 
 
@@ -153,7 +160,6 @@ 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) {
-    // BUGGY - not using
     // 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;
@@ -161,7 +167,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;
@@ -170,6 +175,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;
 }
 
 
@@ -245,7 +251,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;
@@ -264,7 +269,6 @@ 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_divide_sum = mu1_U / p->sum_U_weight;
@@ -583,16 +587,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.4 → piegy-2.3.6}/src/piegy/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '2.3.4'
+__version__ = '2.3.6'
 
 '''
 version history:
@@ -41,4 +41,6 @@ version history:
         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.
+2.3.6: index error due to reduced accuracy is now explicitly handled.
 '''

{piegy-2.3.4 → piegy-2.3.6}/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.4 → piegy-2.3.6}/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 = 30  # where exp(x) reaches ~10e13 and accuracy goes below 10^-3 (10^-3 isn't accurate any more)
 
 
 # read the C core into LIB
@@ -40,6 +36,7 @@ SIM_SUCCESS = 0
 SIM_DATA_EMPTY = 1
 SIM_SMALL_MAXTIME = 2
 SIM_OVERFLOW = 3
+ACCURACY_ERROR = 4
 
 
 '''
@@ -101,7 +98,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 +407,7 @@ class model:
 
 
 
-def run(mod, message = "", update_sum_freq = UPDATE_SUM_FREQ):
+def run(mod, message = ""):
     '''
     C-cored simulation
     '''
@@ -437,7 +434,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), 
@@ -453,7 +450,11 @@ def run(mod, message = "", update_sum_freq = UPDATE_SUM_FREQ):
     elif result == SIM_OVERFLOW:
         LIB.mod_free_py(ctypes.byref(mod_c))
         del mod_c
-        raise OverflowError('Overflow in simulation')
+        raise OverflowError('Overflow in simulation. Possibly due to too large w1, w2, or payoff matrix values.')
+    elif result == ACCURACY_ERROR:
+        LIB.mod_free_py(ctypes.byref(mod_c))
+        del mod_c
+        raise RuntimeError('Accuracy dropped catastrophically during simulation. Possibly due to too large w1, w2, or payoff matrix values.')
     else:
         LIB.mod_free_py(ctypes.byref(mod_c))
         del mod_c
@@ -528,9 +529,9 @@ def check_overflow_func(mod):
             w1_pi = pi_expected[i][j] * mod.P[i][j][2]  # w1 * U_pi
             w2_pi = pi_expected[i][j] * mod.P[i][j][3]  # w2 * V_pi
             if ((w1_pi > EXP_OVERFLOW_BOUND) or (w2_pi > EXP_OVERFLOW_BOUND)):
-                print("Warning: might cause overflow. \n\t w1, w2, or payoff matrix values too large")
+                print("Warning: might cause overflow in simulation. \n\t w1, w2, or payoff matrix values too large")
                 return
             if ((w1_pi > EXP_TOO_LARGE_BOUND) or (w2_pi > EXP_TOO_LARGE_BOUND)):
-                print("Warning: might encounter large values > 3e38 in simulation. \n\t w1, w2, or payoff matrix values too large")
+                print("Warning: might have low accuracy in simulation. \n\t w1, w2, or payoff matrix values too large")
                 return
 

{piegy-2.3.4 → piegy-2.3.6}/src/piegy/test_var.py

@@ -92,8 +92,8 @@ def test_var1(mod, var, values, dirs, compress_itv = None):
             if compress_itv != None:
                 sim2.compress_data(compress_itv)
             data_t.save_data(sim2, var_dirs[k], print_msg = False)
-        except OverflowError:
-            print(current_var_str + ' raised OverflowError, skipped')
+        except (OverflowError, RuntimeError):
+            print(current_var_str + ' raised error, skipped')
             continue
 
     return var_dirs
@@ -139,8 +139,8 @@ def test_var2(mod, var1, var2, values1, values2, dirs, compress_itv = None):
                 if compress_itv != None:
                     sim2.compress_data(compress_itv)
                 data_t.save_data(sim2, var_dirs[k1][k2], print_msg = False)
-            except OverflowError:
-                print(current_var_str + ' raised OverflowError, skipped')
+            except (OverflowError, RuntimeError):
+                print(current_var_str + ' raised error, skipped')
                 continue
 
     return var_dirs

{piegy-2.3.4 → piegy-2.3.6/src/piegy.egg-info}/PKG-INFO

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