piegy 2.2.3__tar.gz → 2.3.2__tar.gz

{piegy-2.2.3/src/piegy.egg-info → piegy-2.3.2}/PKG-INFO

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

{piegy-2.2.3 → piegy-2.3.2}/pyproject.toml

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

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/C_core/Makefile

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

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/C_core/patch.h

@@ -23,14 +23,14 @@ typedef struct patch_t {
     double V_pi;
 
     struct patch_t* nb[4];
-    long double U_weight[4];  // stores migration weight of each of the 4 neighbors
-    long double V_weight[4];
-    long double sum_U_weight; // sum of U_weight
-    long double sum_V_weight;
+    double U_weight[4];  // stores migration weight of each of the 4 neighbors
+    double V_weight[4];
+    double sum_U_weight; // sum of U_weight
+    double sum_V_weight;
     double pi_death_rates[4];
-    long double mig_rates[8];
+    double mig_rates[8];
     double sum_pi_death_rates;
-    long double sum_mig_rates;
+    double sum_mig_rates;
 } patch_t;
 
 // in .c

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/C_core/runner.c

@@ -11,9 +11,9 @@
 int main() {
     size_t N = 1;
     size_t M = 100;
-    double maxtime = 200;
+    double maxtime = 100;
     double record_itv = 0.1;
-    size_t sim_time = 200;
+    size_t sim_time = 10;
     bool boundary = true;
     uint32_t I_single[2] = {200, 100};
     double X_single[4] = {-1, 4, 0, 2};

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/C_core/sim_funcs.c

@@ -69,7 +69,7 @@ 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, 
-                    long double* patch_rates, long double* sum_rates_by_row, long double* sum_rates_p, signal_t* sig_p, patch_picked_t* picked_p) {
+                    double* patch_rates, double* sum_rates_by_row, double* sum_rates_p, signal_t* sig_p, patch_picked_t* picked_p) {
 
     size_t N = mod->N;
     size_t M = mod->M;
@@ -128,7 +128,7 @@ static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices
     ij = 0;
     for (size_t i = 0; i < N; i++) {
         for (size_t j = 0; j < M; j++) {
-            uint8_t mig_result = update_mig_all(&world[ij], &(mod->P[ij * 6]));  // init mig rates for all 4 directions
+            uint8_t mig_result = init_mig(&world[ij], &(mod->P[ij * 6]));  // init mig rates for all 4 directions
             if (mig_result == SIM_OVERFLOW) {
                 return -1 * SIM_OVERFLOW;
             }
@@ -141,7 +141,7 @@ static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices
     }
 
     // pick the first random event
-    long double expected_sum = random01() * *sum_rates_p;
+    double expected_sum = random01() * *sum_rates_p;
     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);
@@ -157,7 +157,7 @@ static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices
 
     // update patch based on signal
     change_popu(&world[sig_p->ij1], sig_p->e1);
-    if (!sig_p->only_first) {
+    if (sig_p->rela_loc != NO_MIG) {
         change_popu(&world[sig_p->ij2], sig_p->e2);
     }
 
@@ -223,9 +223,9 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
     patch_t* world = (patch_t*) calloc(NM, sizeof(patch_t));
     size_t* nb_indices = (size_t*) calloc(NM * 4, sizeof(size_t));
 
-    long double* patch_rates = (long double*) calloc(NM, sizeof(long double));
-    long double* sum_rates_by_row = (long double*) calloc(N, sizeof(long double));
-    long double sum_rates = 0;
+    double* patch_rates = (double*) calloc(NM, sizeof(double));
+    double* sum_rates_by_row = (double*) calloc(N, sizeof(double));
+    double sum_rates = 0;
 
     signal_t signal;
     patch_picked_t picked;
@@ -300,21 +300,15 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
         size_t si2 = signal.i2;
         size_t sij1 = signal.ij1;
         size_t sij2 = signal.ij2;
-        bool only_first = signal.only_first;
-        if (only_first) {
+        uint8_t rela_loc = signal.rela_loc;
+        if (rela_loc == NO_MIG) {
             // if only one
             double picked_rate = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
             sum_rates_by_row[si1] -= picked_rate;
             sum_rates -= picked_rate;
 
             update_pi_k(&world[sij1], &(mod->X[sij1 * 4]), &(mod->P[sij1 * 6]));
-            uint8_t mig_result = update_mig_all(&world[sij1], &(mod->P[sij1 * 6]));
-            if (mig_result == 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);
-                return SIM_OVERFLOW;
-            }
+            update_mig_just_rate(&world[sij1], &(mod->P[sij1 * 6]));
 
             picked_rate = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
             patch_rates[sij1] = picked_rate;
@@ -331,9 +325,10 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
 
             update_pi_k(&world[sij1], &(mod->X[sij1 * 4]), &(mod->P[sij1 * 6]));  // update both patches' payoffs first
             update_pi_k(&world[sij2], &(mod->X[sij2 * 4]), &(mod->P[sij2 * 6]));
-            uint8_t mig_result1 = update_mig_all(&world[sij1], &(mod->P[sij1 * 6]));   // and then mig rates
-            uint8_t mig_result2 = update_mig_all(&world[sij2], &(mod->P[sij2 * 6]));
-            if (mig_result1 == SIM_OVERFLOW || mig_result2 == SIM_OVERFLOW) {
+
+            if (update_mig_weight_rate(&world[sij1], &(mod->P[sij1 * 6]), rela_loc) == SIM_OVERFLOW || 
+                update_mig_weight_rate(&world[sij2], &(mod->P[sij2 * 6]), rela_loc ^ 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);
@@ -352,19 +347,18 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
         }
 
         // update neighbors of last-changed patches
-        if (only_first) {
+        if (rela_loc == NO_MIG) {
             for (uint8_t k = 0; k < 4; k++) {
                 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
-                uint8_t mig_result = update_mig_one(&world[nb_idx], &(mod->P[nb_idx * 6]), k ^ 1);
-                if (mig_result == SIM_OVERFLOW) {
+                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);
                     single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
                     return SIM_OVERFLOW;
                 }
-                // sum_mig_rate is not changed
+                // patch_rates, and sums of rates is not changed
             }
         } else {
             // the first patch
@@ -372,8 +366,7 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
                 size_t nb_idx = nb_indices[sij1 * 4 + k];
                 if (nb_idx == NM) { continue; }
                 if (nb_need_change(nb_idx, sij1, sij2)) {
-                    uint8_t mig_result = update_mig_one(&world[nb_idx], &(mod->P[nb_idx * 6]), k ^ 1);
-                    if (mig_result == SIM_OVERFLOW) {
+                    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);
                         single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
@@ -386,8 +379,7 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
                 size_t nb_idx = nb_indices[sij2 * 4 + k];
                 if (nb_idx == NM) { continue; }
                 if (nb_need_change(nb_idx, sij1, sij2)) {
-                    uint8_t mig_result = update_mig_one(&world[nb_idx], &(mod->P[nb_idx * 6]), k ^ 1);
-                    if (mig_result == SIM_OVERFLOW) {
+                    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);
                         single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
@@ -399,7 +391,7 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
 
 
         // pick a random event
-        long double expected_sum = random01() * sum_rates;
+        double expected_sum = random01() * sum_rates;
         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);
@@ -415,7 +407,7 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
 
         // let the event happenn
         change_popu(&world[signal.ij1], signal.e1);
-        if (!signal.only_first) {
+        if (signal.rela_loc != NO_MIG) {
             change_popu(&world[signal.ij2], signal.e2);
         }
 
@@ -477,7 +469,7 @@ static uint8_t single_test(model_t* restrict mod, uint32_t update_sum_freq, char
 
 
 
-static void single_test_free(patch_t** world, size_t** nb_indices, long double** patch_rates, long double** sum_rates_by_row) {
+static void single_test_free(patch_t** world, size_t** nb_indices, double** patch_rates, double** sum_rates_by_row) {
     free(*world);
     free(*nb_indices);
     free(*patch_rates);

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/C_core/sim_funcs.h

@@ -28,16 +28,17 @@
 #define MIG_DOWN 1
 #define MIG_LEFT 2
 #define MIG_RIGHT 3
+#define NO_MIG 4
 
 // results of single_test
 #define SUCCESS 0
 #define DATA_NOT_EMPTY 1
-#define SMALL_MAXTIME 2  // must > 1 for signal control in single test
-#define SIM_OVERFLOW 3  // must > 1 for signal control in single test
+#define SMALL_MAXTIME 2
+#define SIM_OVERFLOW 3
 
 // 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 600
+#define EXP_OVERFLOW_BOUND 500
 
 
 static uint64_t pcg_state = 0;
@@ -59,8 +60,10 @@ typedef struct patch_picked_t {
  * index & event number in make_signal_*
 */
 typedef struct signal_t {
-    // does the signal only have the first patch?
-    bool only_first;
+    // relative location of the second patch to the first
+    // set to NO_MIG if the event only affects one patch
+    // otherwise set to MIG_* constants as defined above
+    uint8_t rela_loc;
 
     // the first patch
     size_t i1;
@@ -83,9 +86,9 @@ 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, 
-                    long double* patch_rates, long double* sum_rates_by_row, long double* sum_rates, signal_t* sig_p, patch_picked_t* picked_p) ;
+                    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 void single_test_free(patch_t** world, size_t** nb_indices, long double** patch_rates, long double** sum_rates_by_row);
+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);
 
 
@@ -94,12 +97,12 @@ uint8_t run(model_t* mod, char* message, size_t msg_len, uint32_t update_sum_fre
  * Inline Functions
 */
 
-static inline long double random01() {
+static inline double random01() {
     // generate a 24 bit random int, then convert to a (0, 1) ranged double
     uint32_t r1 = rand() & 0x7fff;  // RAND_MAX is different across machines, ensure 15 bits
     uint32_t r2 = rand() & 0x7fff;
 
-    long double r_combined = (r1 << 15) + r2;  // discard the lower 3 bits, which are unstable
+    double r_combined = (r1  << 15) + r2;  // discard the lower 3 bits, which are unstable
     return (r_combined + 1) / RAND_UPPER_PLUS_2;
 }
 
@@ -113,19 +116,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_minus_1 = U + V - 1.0;
+    double sum = U + V;
 
-    if (sum_minus_1 > 0) {
+    if (sum > 0) {
         if (U != 0) {
-            p->U_pi = ((U - 1) / sum_minus_1) * M_start[0] +
-                      (V / sum_minus_1) * M_start[1];
+            p->U_pi = (U / sum) * M_start[0] +
+                      (V / sum) * M_start[1];
         } else {
             p->U_pi = 0.0;
         }
 
         if (V != 0) {
-            p->V_pi = (U / sum_minus_1) * M_start[2] +
-                      ((V - 1) / sum_minus_1) * M_start[3];
+            p->V_pi = (U / sum) * M_start[2] +
+                      (V / sum) * M_start[3];
         } else {
             p->V_pi = 0.0;
         }
@@ -138,8 +141,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_minus_1 + 1.0);
-    p->pi_death_rates[3] = P_start[5] * V * (sum_minus_1 + 1.0);
+    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++) {
@@ -148,19 +151,37 @@ static inline void update_pi_k(patch_t* restrict p, const double* restrict M_sta
 }
 
 
-static inline uint8_t update_mig_one(patch_t* restrict p, const double* restrict P_start, uint8_t nb_loc) {
-    // update mig rate for one direction
-    // P_start: start index of p's patch variables, i.e., ij * 6
-    // nb_loc: location of neighbor, up, down, left, right
+
+static inline void update_mig_just_rate(patch_t* restrict p, const double* restrict P_start) {
+    // update migration weight for patch p, in location loc. Only rate is updated
+    // used by neighbors of last-changed patches, to update migration weights
+    double* p_U_weight = p->U_weight;
+    double* p_V_weight = p->V_weight;
 
     double mu1_U = P_start[0] * (double)p->U;
     double mu2_V = P_start[1] * (double)p->V;
-    long double* p_U_weight = p->U_weight;
-    long double* p_V_weight = p->V_weight;
+    double mu1_U_divide_sum = mu1_U / p->sum_U_weight;
+    double mu2_V_divide_sum = mu2_V / p->sum_V_weight;
 
-    patch_t* nbi = p->nb[nb_loc];
-    p->sum_U_weight -= p_U_weight[nb_loc];
-    p->sum_V_weight -= p_V_weight[nb_loc];
+    for (uint8_t i = 0; i < 4; i++) {
+        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;
+}
+
+
+static inline uint8_t update_mig_weight_rate(patch_t* restrict p, const double* P_start, 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 is only one patch changed, to update mig rates without having to update weights
+
+    double* p_U_weight = p->U_weight;
+    double* p_V_weight = p->V_weight;
+
+    patch_t* nbi = p->nb[loc];
+    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;
@@ -171,47 +192,48 @@ static inline uint8_t update_mig_one(patch_t* restrict p, const double* restrict
         return SIM_OVERFLOW;
     }
 
-    switch(nb_loc) {
+    switch(loc) {
         case MIG_UP:
-            p_U_weight[MIG_UP] = 1.0 + exp(w1_Upi);
-            p_V_weight[MIG_UP] = 1.0 + 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.0 + exp(w1_Upi);
-            p_V_weight[MIG_DOWN] = 1.0 + 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.0 + exp(w1_Upi);
-            p_V_weight[MIG_LEFT] = 1.0 + 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.0 + exp(w1_Upi);
-            p_V_weight[MIG_RIGHT] = 1.0 + 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[nb_loc];
-    p->sum_V_weight += p_V_weight[nb_loc];
+    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_divide_sum = mu1_U / p->sum_U_weight;
     double mu2_V_divide_sum = mu2_V / p->sum_V_weight;
 
-    for (size_t i = 0; i < 4; i++) {
+    for (uint8_t i = 0; i < 4; i++) {
         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;
 
     return SUCCESS;
 }
 
 
 
-static inline uint8_t update_mig_all(patch_t* restrict p, const double* restrict P_start) {
+static inline uint8_t init_mig(patch_t* restrict p, const double* restrict P_start) {
     // update migration rate for all directions
-    double mu1_U = P_start[0] * (double)p->U;
-    double mu2_V = P_start[1] * (double)p->V;
 
-    long double* p_U_weight = p->U_weight;
-    long double* p_V_weight = p->V_weight;
+    double* p_U_weight = p->U_weight;
+    double* p_V_weight = p->V_weight;
 
     p->sum_U_weight = 0.0;
     p->sum_V_weight = 0.0;
@@ -232,14 +254,17 @@ static inline uint8_t update_mig_all(patch_t* restrict p, const double* restrict
             if (w2_Vpi > EXP_OVERFLOW_BOUND) {
                 return SIM_OVERFLOW;
             }
-            p_U_weight[i] = 1.0 + exp(w1_Upi);
-            p_V_weight[i] = 1.0 + 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;
     double mu2_V_divide_sum = mu2_V / p->sum_V_weight;
 
@@ -247,7 +272,6 @@ static inline uint8_t update_mig_all(patch_t* restrict p, const double* restrict
         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;
 
     return SUCCESS;
@@ -255,7 +279,7 @@ static inline uint8_t update_mig_all(patch_t* restrict p, const double* restrict
 
 
 
-static inline uint8_t find_event(const patch_t* restrict p, long double expected_sum) {
+static inline uint8_t find_event(const patch_t* restrict p, double expected_sum) {
     size_t event = 0;
     double current_sum;
 
@@ -330,30 +354,32 @@ static inline void change_popu(patch_t* restrict p, uint8_t s) {
  * Main Simulation Functions
 */
 
-static inline void find_patch(patch_picked_t* restrict picked, long double expected_sum, 
-                                const long double* restrict patch_rates, const long double* restrict sum_rates_by_row, long double sum_rates, size_t N, size_t M) {
+static inline void find_patch(patch_picked_t* restrict picked, double expected_sum, 
+                                const double* restrict patch_rates, const double* restrict sum_rates_by_row, double sum_rates, size_t N, size_t M) {
     double current_sum = 0;
     size_t row = 0;
     size_t col = 0;
 
     // Find row
-    if (expected_sum < sum_rates * 0.5) {
-        current_sum = 0.0;
-        row = 0;
-        while (current_sum < expected_sum) {
-            current_sum += sum_rates_by_row[row];
-            row++;
-        }
-        row--;
-        current_sum -= sum_rates_by_row[row];
-    } else {
-        current_sum = sum_rates;
-        row = N - 1;
-        while (current_sum > expected_sum) {
-            current_sum -= sum_rates_by_row[row];
+    if (N != 1) {
+        if (expected_sum < sum_rates * 0.5) {
+            current_sum = 0.0;
+            row = 0;
+            while (current_sum < expected_sum) {
+                current_sum += sum_rates_by_row[row];
+                row++;
+            }
             row--;
+            current_sum -= sum_rates_by_row[row];
+        } else {
+            current_sum = sum_rates;
+            row = N - 1;
+            while (current_sum > expected_sum) {
+                current_sum -= sum_rates_by_row[row];
+                row--;
+            }
+            row++;
         }
-        row++;
     }
 
     size_t row_M = row * M;
@@ -392,75 +418,75 @@ static inline void make_signal_zero_flux(size_t i, size_t j, uint8_t e, signal_t
     switch (e) {
         case 0:
             signal->e1 = 2;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 1:
             signal->e1 = 5;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 2:
             signal->e1 = 1;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 3:
             signal->e1 = 4;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 4:
             signal->e1 = 1;
             signal->i2 = i - 1;
             signal->j2 = j;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_UP;
             return;
         case 5:
             signal->e1 = 1;
             signal->i2 = i + 1;
             signal->j2 = j;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_DOWN;
             return;
         case 6:
             signal->e1 = 1;
             signal->i2 = i;
             signal->j2 = j - 1;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_LEFT;
             return;
         case 7:
             signal->e1 = 1;
             signal->i2 = i;
             signal->j2 = j + 1;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_RIGHT;
             return;
         case 8:
             signal->e1 = 4;
             signal->i2 = i - 1;
             signal->j2 = j;
             signal->e2 = 3;
-            signal->only_first = false;
+            signal->rela_loc = MIG_UP;
             return;
         case 9:
             signal->e1 = 4;
             signal->i2 = i + 1;
             signal->j2 = j;
             signal->e2 = 3;
-            signal->only_first = false;
+            signal->rela_loc = MIG_DOWN;
             return;
         case 10:
             signal->e1 = 4;
             signal->i2 = i;
             signal->j2 = j - 1;
             signal->e2 = 3;
-            signal->only_first = false;
+            signal->rela_loc = MIG_LEFT;
             return;
         default:
             signal->e1 = 4;
             signal->i2 = i;
             signal->j2 = j + 1;
             signal->e2 = 3;
-            signal->only_first = false;
+            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);
@@ -478,75 +504,75 @@ static inline void make_signal_periodical(size_t N, size_t M, size_t i, size_t j
     switch (e) {
         case 0:
             signal->e1 = 2;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 1:
             signal->e1 = 5;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 2:
             signal->e1 = 1;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 3:
             signal->e1 = 4;
-            signal->only_first = true;
+            signal->rela_loc = NO_MIG;
             return;
         case 4:
             signal->e1 = 1;
             signal->i2 = i != 0 ? i - 1 : N - 1;
             signal->j2 = j;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_UP;
             return;
         case 5:
             signal->e1 = 1;
             signal->i2 = i != N - 1 ? i + 1 : 0;
             signal->j2 = j;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_DOWN;
             return;
         case 6:
             signal->e1 = 1;
             signal->i2 = i;
             signal->j2 = j != 0 ? j - 1 : M - 1;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_LEFT;
             return;
         case 7:
             signal->e1 = 1;
             signal->i2 = i;
             signal->j2 = j != M - 1 ? j + 1 : 0;
             signal->e2 = 0;
-            signal->only_first = false;
+            signal->rela_loc = MIG_RIGHT;
             return;
         case 8:
             signal->e1 = 4;
             signal->i2 = i != 0 ? i - 1 : N - 1;
             signal->j2 = j;
             signal->e2 = 3;
-            signal->only_first = false;
+            signal->rela_loc = MIG_UP;
             return;
         case 9:
             signal->e1 = 4;
             signal->i2 = i != N - 1 ? i + 1 : 0;
             signal->j2 = j;
             signal->e2 = 3;
-            signal->only_first = false;
+            signal->rela_loc = MIG_DOWN;
             return;
         case 10:
             signal->e1 = 4;
             signal->i2 = i;
             signal->j2 = j != 0 ? j - 1 : M - 1;
             signal->e2 = 3;
-            signal->only_first = false;
+            signal->rela_loc = MIG_LEFT;
             return;
         default:
             signal->e1 = 4;
             signal->i2 = i;
             signal->j2 = j != M - 1 ? j + 1 : 0;
             signal->e2 = 3;
-            signal->only_first = false;
+            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);

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/__init__.py

@@ -28,7 +28,7 @@ from .data_tools import save_data, read_data
 from .analysis import rounds_expected, scale_maxtime, check_convergence, combine_sim
 
 from .figures import (UV_hmap, UV_bar, UV_dyna, UV_hist, UV_std, UV_expected, 
-                      pi_hmap, pi_bar, pi_dyna, pi_hist, pi_std, UV_pi)
+                      pi_hmap, pi_bar, pi_dyna, pi_hist, pi_std, UV_pi, video_fig)
 
 from .test_var import (test_var1, var_UV1, var_pi1, var_convergence1, get_dirs1, 
                        test_var2, var_UV2, var_pi2, var_convergence2, get_dirs2)
@@ -43,7 +43,7 @@ data_members = ['save_data', 'read_data']
 analysis_members = ['expected_rounds', 'scale_maxtime', 'check_convergence', 'combine_mod']
 
 figures_members = ['UV_hmap', 'UV_bar', 'UV_dyna', 'UV_hist', 'UV_std', 'UV_expected_val', 'UV_expected', 
-                   'pi_hmap', 'pi_bar', 'pi_dyna', 'pi_hist', 'pi_std', 'UV_pi']
+                   'pi_hmap', 'pi_bar', 'pi_dyna', 'pi_hist', 'pi_std', 'UV_pi', 'video_fig']
 
 test_var_members = ['test_var1', 'var_UV1', 'var_pi1', 'var_convergence1', 'get_dirs1', 
                     'test_var2', 'var_UV2', 'var_pi2', 'var_convergence2', 'get_dirs2']

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '2.2.3'
+__version__ = '2.3.2'
 
 '''
 version history:
@@ -35,4 +35,8 @@ version history:
 2.2.1: change heatmap plotting tool from Seaborn to Matplotlib. Change video maker to cv2 (opencv-python).
 2.2.2: impose stricter overflow error check. Used update_mig_one function (already written before, didn't use). This gives 30% speed improvement.
 2.2.3: raised rate calculation to higher accuracy (long double), and switched to 30-bit random number generator.
+2.3.1: roll back accuracy update. Decrease toleratable bound for exponent of exp() to 500. 
+        Add video_fig function to figures module, which plots change of patch popu/payoff overtime in a 2D figure. Add auto-sorting for values passed to test_var plot functions.
+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.
 '''

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/figures.py

@@ -306,9 +306,9 @@ def pi_hmap(mod, ax_U = None, ax_V = None, U_color = 'BuPu', V_color = 'YlGn', s
     Upi_ave = figure_t.ave_interval(mod.Upi, start_index, end_index)
     V_pi_ave = figure_t.ave_interval(mod.Vpi, start_index, end_index)
     
-    U_title = figure_t.gen_title('Payoff ' + r'$p_U$', start, end)
+    U_title = figure_t.gen_title('Payoff ' + r'$p_H$', start, end)
     U_text = figure_t.gen_text(np.mean(Upi_ave), np.std(Upi_ave))
-    V_title = figure_t.gen_title('Payoff ' + r'$p_V$', start, end)
+    V_title = figure_t.gen_title('Payoff ' + r'$p_D$', start, end)
     V_text = figure_t.gen_text(np.mean(V_pi_ave), np.std(V_pi_ave))
     
     figure_t.hmap(Upi_ave, ax_U, U_color, U_title, U_text, vmin = vrange_U[0], vmax = vrange_U[1])
@@ -334,13 +334,13 @@ def pi_bar(mod, ax_U = None, ax_V = None, U_color = 'violet', V_color = 'yellowg
     Upi_ave = figure_t.ave_interval_1D(mod.Upi, start_index, end_index)
     V_pi_ave = figure_t.ave_interval_1D(mod.Vpi, start_index, end_index)
     
-    U_title = figure_t.gen_title(r'$p_U$', start, end)
+    U_title = figure_t.gen_title(r'$p_H$', start, end)
     U_text = figure_t.gen_text(np.mean(Upi_ave), np.std(Upi_ave))
-    V_title = figure_t.gen_title(r'$p_V$', start, end)
+    V_title = figure_t.gen_title(r'$p_D$', start, end)
     V_text = figure_t.gen_text(np.mean(V_pi_ave), np.std(V_pi_ave))
     
-    ax_U = figure_t.bar(Upi_ave, ax_U, U_color, 'Patches', 'Payoff ' + r'$p_U$', U_title, U_text)
-    ax_V = figure_t.bar(V_pi_ave, ax_V, V_color, 'Patches', 'Payoff ' + r'$p_V$', V_title, V_text)
+    ax_U = figure_t.bar(Upi_ave, ax_U, U_color, 'Patches', 'Payoff ' + r'$p_H$', U_title, U_text)
+    ax_V = figure_t.bar(V_pi_ave, ax_V, V_color, 'Patches', 'Payoff ' + r'$p_D$', V_title, V_text)
 
     return ax_U, ax_V
 
@@ -376,12 +376,12 @@ def pi_dyna(mod, ax = None, interval = 20, grid = True):
     if ax == None:
         _, ax = plt.subplots()
     ax.grid(grid)
-    ax.plot(xaxis, U_curve, CURVE_TYPE, label = r'$p_U$')
-    ax.plot(xaxis, V_curve, CURVE_TYPE, label = r'$p_V$')
+    ax.plot(xaxis, U_curve, CURVE_TYPE, label = r'$p_H$')
+    ax.plot(xaxis, V_curve, CURVE_TYPE, label = r'$p_D$')
     ax.plot(xaxis, total_curve, CURVE_TYPE, label = 'total')
     ax.set_xlabel('Time')
     ax.set_ylabel('Payoff')
-    ax.set_title('Payoff ' + r'$p_U$' + ' & ' + r'$p_V$' + ' over time')
+    ax.set_title('Payoff ' + r'$p_H$' + ' & ' + r'$p_D$' + ' over time')
     ax.legend()
 
     return ax
@@ -408,17 +408,17 @@ def pi_hist(mod, ax_U = None, ax_V = None, U_color = 'violet', V_color = 'yellow
     
     if ax_U == None:
         _, ax_U = plt.subplots()
-    ax_U.set_xlabel('Payoff ' + r'$p_U$')
+    ax_U.set_xlabel('Payoff ' + r'$p_H$')
     ax_U.set_ylabel('Density')
     ax_U.hist(Upi_ave, color = U_color, density = True)
-    ax_U.set_title(figure_t.gen_title('Payoff ' + r'$p_U$' + ' Hist', start, end))
+    ax_U.set_title(figure_t.gen_title('Payoff ' + r'$p_H$' + ' Hist', start, end))
     
     if ax_V == None:
         _, ax_V = plt.subplots()
-    ax_V.set_xlabel('Payoff ' + r'$p_V$')
+    ax_V.set_xlabel('Payoff ' + r'$p_D$')
     ax_V.set_ylabel('Density')
     ax_V.hist(V_pi_ave, color = V_color, density = True)
-    ax_V.set_title(figure_t.gen_title('Payoff ' + r'$p_V$' + ' Hist', start, end))
+    ax_V.set_title(figure_t.gen_title('Payoff ' + r'$p_D$' + ' Hist', start, end))
 
     return ax_U, ax_V
 
@@ -453,8 +453,8 @@ def pi_std(mod, ax = None, interval = 20, grid = True):
     if ax == None:
         _, ax = plt.subplots()
     ax.grid(grid)
-    ax.plot(xaxis, Upi_std, CURVE_TYPE, label = r'$p_U$' + ' std')
-    ax.plot(xaxis, V_pi_std, CURVE_TYPE, label = r'$p_V$' + ' std')
+    ax.plot(xaxis, Upi_std, CURVE_TYPE, label = r'$p_H$' + ' std')
+    ax.plot(xaxis, V_pi_std, CURVE_TYPE, label = r'$p_D$' + ' std')
     ax.legend()
     ax.set_xlabel('Time')
     ax.set_ylabel('Std Dev')
@@ -484,9 +484,66 @@ def UV_pi(mod, ax_U = None, ax_V = None, U_color = 'violet', V_color = 'yellowgr
     V_pi_ave = figure_t.ave_interval(mod.Vpi, start_index, end_index)
     
     
-    ax_U = figure_t.scatter(U_ave, Upi_ave, ax_U, U_color, alpha, xlabel = 'U', ylabel = 'Payoff ' + r'$p_U$', title = 'U - ' + r'$p_U$')
-    ax_V = figure_t.scatter(V_ave, V_pi_ave, ax_V, V_color, alpha, xlabel = 'V', ylabel = 'Payoff ' + r'$p_V$', title = 'V - ' + r'$p_V$')
+    ax_U = figure_t.scatter(U_ave, Upi_ave, ax_U, U_color, alpha, xlabel = 'U', ylabel = 'Payoff ' + r'$p_H$', title = 'U - ' + r'$p_H$')
+    ax_V = figure_t.scatter(V_ave, V_pi_ave, ax_V, V_color, alpha, xlabel = 'V', ylabel = 'Payoff ' + r'$p_D$', title = 'V - ' + r'$p_D$')
     
     return ax_U, ax_V
 
 
+
+def video_fig(mod, ax_list = None, num_grid = 100, U_color = 'Purples', V_color = 'Greens'):
+    '''
+    Plot distribution dynamics over time, of U, V population and payoff.
+
+    mod: simulation.model object
+    ax_list: a 2*2 list of ax, or None (a new 2*2 ax_list will be created)
+    num_grid: how many grid for the time axis
+    U_color & V_color: matplotlib color map, color for U, V population and payoff.
+    '''
+
+    if num_grid > mod.max_record:
+        raise ValueError('num_grid too large, larger than mod.max_record')
+    idx_step = int(mod.max_record / num_grid)
+    ave_U = []
+    ave_V = []
+    ave_Upi = []
+    ave_Vpi = []
+
+    for lower_idx in range(0, mod.max_record, idx_step):
+        ave_U.append(figure_t.ave_interval_1D(mod.U, lower_idx, lower_idx + idx_step))
+        ave_V.append(figure_t.ave_interval_1D(mod.V, lower_idx, lower_idx + idx_step))
+        ave_Upi.append(figure_t.ave_interval_1D(mod.Upi, lower_idx, lower_idx + idx_step))
+        ave_Vpi.append(figure_t.ave_interval_1D(mod.Vpi, lower_idx, lower_idx + idx_step))
+
+    if ax_list == None:
+
+        _, ax_list = plt.subplots(2, 2, figsize = (9.6, 12.8), dpi = 300)
+
+    for i in range(2):
+        for j in range(2):
+            ax_list[i, j].spines['top'].set_visible(False)
+            ax_list[i, j].spines['right'].set_visible(False)
+            ax_list[i, j].set_xlabel('Patches')
+            ax_list[i, j].set_ylabel('Time')
+            ax_list[i, j].set_xlim([0, mod.M])
+            ax_list[i, j].set_ylim([0, mod.maxtime])
+    
+
+    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].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].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].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].set_title('Payoff ' + r'$p_D$' + ' over time')
+
+    return ax_list
+

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/test_var.py

@@ -169,6 +169,7 @@ def var_UV1(var, values, var_dirs, ax_U = None, ax_V = None, start = 0.95, end =
     # average value of U, V over the interval. One entry for one value of var
     U_ave = []
     V_ave = []
+    values = sorted(values)
 
     for k in range(len(var_dirs)):
         try:
@@ -234,6 +235,8 @@ def var_UV2(var1, var2, values1, values2, var_dirs, ax_U = None, ax_V = None, va
     # average value of U, V over the interval. One entry for one values of var1, var2
     U_ave = [[] for k1 in range(len(var_dirs))]
     V_ave = [[] for k1 in range(len(var_dirs))]
+    values1 = sorted(values1)
+    values2 = sorted(values2)
 
     for k1 in range(len(var_dirs)):
         for k2 in range(len(var_dirs[k1])):
@@ -321,6 +324,7 @@ def var_pi1(var, values, var_dirs, ax_U = None, ax_V = None, start = 0.95, end =
     # take average value of payoff over an interval of time
     U_ave = []
     V_ave = []
+    values = sorted(values)
     
     for k in range(len(var_dirs)):
         try:
@@ -347,12 +351,12 @@ def var_pi1(var, values, var_dirs, ax_U = None, ax_V = None, start = 0.95, end =
     var_disp = PATCH_VAR_DISP[var]
     
     ax_U.set_xlabel(var_disp)
-    ax_U.set_ylabel('Payoff ' + r'$p_U$')
+    ax_U.set_ylabel('Payoff ' + r'$p_H$')
     ax_U.plot(values, U_ave, DOTTED_CURVE_TYPE, color = U_color)
     ax_U.set_title(figure_t.gen_title(var_disp + r'$\,-\,p_U$', start, end))
     
     ax_V.set_xlabel(var_disp)
-    ax_V.set_ylabel('Payoff ' + r'$p_V$')
+    ax_V.set_ylabel('Payoff ' + r'$p_D$')
     ax_V.plot(values, V_ave, DOTTED_CURVE_TYPE, color = V_color)
     ax_V.set_title(figure_t.gen_title(var_disp  + r'$\,-\,p_V$', start, end))
 
@@ -384,6 +388,8 @@ def var_pi2(var1, var2, values1, values2, var_dirs, ax_U = None, ax_V = None, va
     # take average value of payoff over an interval of time
     U_ave = [[] for k1 in range(len(var_dirs))]
     V_ave = [[] for k1 in range(len(var_dirs))]
+    values1 = sorted(values1)
+    values2 = sorted(values2)
 
     for k1 in range(len(var_dirs)):
         for k2 in range(len(var_dirs[k1])):

{piegy-2.2.3 → piegy-2.3.2}/src/piegy/tools/figure_tools.py

@@ -172,7 +172,7 @@ def ave_interval(data, start_index, end_index):
 def ave_interval_1D(data, start_index, end_index):
     '''
     Calculate average value of data over an interval. Return a 1D np.array.
-    Assume data is 3D and has shape (1 x M x K) or (N x 1 x K). Then implicitly 'compress' that 1 and takes average on the 3rd axis.
+    Assume data is 3D and has shape (N x M x K). Then implicitly 'compress' that N x M to 1D (NM) and takes average on the 3rd axis K.
 
     Input:
         data:       3D np.array or list. One of its dimensions must have size 1. Will take average on the 3rd axis.

{piegy-2.2.3 → piegy-2.3.2/src/piegy.egg-info}/PKG-INFO

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