piegy 2.3.5__tar.gz → 2.3.6__tar.gz

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

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

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

{piegy-2.3.5 → 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.5 → piegy-2.3.6}/src/piegy/C_core/runner.c

@@ -17,7 +17,7 @@ int main() {
     bool boundary = true;
     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
 

{piegy-2.3.5 → 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) {
@@ -215,9 +219,9 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
 
     // 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
+    // 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_freq = UPDATE_SUM_FREQ_SM;  // the frequency really using, change based on how large values are encountered
+    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,7 +246,12 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         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;
 
@@ -264,29 +273,25 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         
         // update sums
         curr_update_sum_round++;
-        if (curr_update_sum_round > update_sum_freq) {
+        if (curr_update_sum_round > update_sum_rounds) {
             curr_update_sum_round = 0;
-            update_sum_freq = UPDATE_SUM_FREQ_LG;  // assume can make it larger
-            size_t ij = 0;
 
-            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];
-                    }
-                    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++;
+            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];
+                }
+                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
                 }
+                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
             }
-            ij = 0;
+            size_t ij = 0;
             sum_rates = 0;
             for (size_t i = 0; i < N; i++) {
                 double sum_rates_by_row_i = 0;
@@ -307,6 +312,7 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         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];
@@ -396,6 +402,12 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         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) {
@@ -424,16 +436,12 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 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;
@@ -441,16 +449,12 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
 
         } 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;
                 }
             }
         }
@@ -483,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) {
+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");
@@ -538,6 +542,9 @@ uint8_t run(model_t* mod, char* message, size_t msg_len) {
             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.5 → piegy-2.3.6}/src/piegy/C_core/sim_funcs.h

@@ -35,15 +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_FREQ_SM 100
-#define UPDATE_SUM_FREQ_LG 10000
+#define UPDATE_SUM_ROUNDS_SM 100
+#define UPDATE_SUM_ROUNDS_LG 10000
 
 
 static uint64_t pcg_state = 0;
@@ -90,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 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);
+uint8_t run(model_t* restrict mod, char* message, size_t msg_len);
 
 
 

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

@@ -1,4 +1,4 @@
-__version__ = '2.3.4'
+__version__ = '2.3.6'
 
 '''
 version history:
@@ -42,4 +42,5 @@ version history:
 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.5 → piegy-2.3.6}/src/piegy/simulation.py

@@ -25,7 +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 1e34
+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
@@ -36,6 +36,7 @@ SIM_SUCCESS = 0
 SIM_DATA_EMPTY = 1
 SIM_SMALL_MAXTIME = 2
 SIM_OVERFLOW = 3
+ACCURACY_ERROR = 4
 
 
 '''
@@ -449,7 +450,11 @@ def run(mod, message = ""):
     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
@@ -524,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.5 → 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.5 → piegy-2.3.6/src/piegy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piegy
-Version: 2.3.5
+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