piegy 2.3.7__tar.gz → 2.3.8__tar.gz

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

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

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

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

@@ -5,32 +5,38 @@
 
 #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 < 6; i++) {
+        p->P[i] = P_start[i];
+    }
 
     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 +48,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.8}/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.7 → piegy-2.3.8}/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;
             }
@@ -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,9 @@ 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
+    // 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 +215,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 +247,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) {
@@ -268,7 +265,9 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                     fprintf(stdout, "\r%s: %d%%", message, (int)(time * 100 / maxtime));
                 }
                 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 +314,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 +327,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 +353,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 +368,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 +382,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 +392,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);
@@ -413,7 +411,7 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
             make_signal_periodical(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 +434,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 +448,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;
                 }
             }
         }
@@ -513,27 +511,33 @@ uint8_t run(model_t* restrict mod, char* message, size_t msg_len) {
 
     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 +553,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.8}/src/piegy/C_core/sim_funcs.h

@@ -122,10 +122,8 @@ static inline double random01() {
  * 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;
@@ -134,13 +132,13 @@ static inline void update_pi_k(patch_t* restrict p, const double* restrict M_sta
 
     if (sum > 0) {
         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 +151,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 +162,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 +182,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, 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 +194,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 +224,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 +240,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 +249,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 +272,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;
 
@@ -367,6 +365,7 @@ static inline void find_patch(patch_picked_t* restrict picked, double expected_s
     double current_sum = 0;
     size_t row = 0;
     size_t col = 0;
+    size_t row_M = 0;
 
     // Find row
     if (N != 1) {
@@ -388,10 +387,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;
@@ -496,9 +494,6 @@ 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;
     }
 }
 
@@ -582,9 +577,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.8}/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.8}/src/piegy/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '2.3.7'
+__version__ = '2.3.8'
 
 '''
 version history:
@@ -44,4 +44,5 @@ 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.
 '''

{piegy-2.3.7 → piegy-2.3.8}/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.
 '''
 
 
@@ -14,7 +14,7 @@ import gzip
 import os
 
 
-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
 
@@ -70,7 +70,7 @@ def save_data(mod, dirs = '', print_msg = True):
 
 
 
-def read_data(dirs):
+def load(dirs):
     '''
     Reads and returns a model object.
 

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

@@ -176,7 +176,7 @@ class model:
                                     # 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.U = None               # initialized by simulation.run or data_tools.load
         self.V = None
         self.Upi = None
         self.Vpi = None
@@ -426,10 +426,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.8}/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.8/src/piegy.egg-info}/PKG-INFO

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