piegy 2.3.1__tar.gz → 2.3.3__tar.gz

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

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

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

{piegy-2.3.1 → piegy-2.3.3}/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.3.1 → piegy-2.3.3}/src/piegy/C_core/runner.c

@@ -11,14 +11,14 @@
 int main() {
     size_t N = 1;
     size_t M = 100;
-    double maxtime = 200;
+    double maxtime = 600;
     double record_itv = 0.1;
-    size_t sim_time = 200;
+    size_t sim_time = 1;
     bool boundary = true;
-    uint32_t I_single[2] = {200, 100};
+    uint32_t I_single[2] = {440, 220};
     double X_single[4] = {-1, 4, 0, 2};
-    double P_single[6] = {0.5, 0.5, 50, 294, 0.001, 0.001};
-    int32_t print_pct = 25;
+    double P_single[6] = {0.5, 0.5, 100, 100, 0.001, 0.001};
+    int32_t print_pct = 1;
     int32_t seed = 36;  // -1 for None
 
     uint32_t I[N * M * 2];

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

@@ -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;
             }
@@ -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);
     }
 
@@ -300,71 +300,58 @@ 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;
+            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]));
-            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;
-            }
+            init_mig(&world[sij1], &(mod->P[sij1 * 6]));
 
-            picked_rate = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
-            patch_rates[sij1] = picked_rate;
-            sum_rates_by_row[si1] += picked_rate;
-            sum_rates += picked_rate;
+            patch_rates[sij1] = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
+            sum_rates_by_row[si1] += patch_rates[sij1];
+            sum_rates += patch_rates[sij1];
         } else {
             // two
-            double picked_rate1 = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
-            double picked_rate2 = world[sij2].sum_pi_death_rates + world[sij2].sum_mig_rates;
-            sum_rates_by_row[si1] -= picked_rate1;
-            sum_rates_by_row[si2] -= picked_rate2;
-            sum_rates -= picked_rate1;
-            sum_rates -= picked_rate2;
+            sum_rates_by_row[si1] -= patch_rates[sij1];
+            sum_rates_by_row[si2] -= patch_rates[sij2];
+            sum_rates -= patch_rates[sij1];
+            sum_rates -= patch_rates[sij2];
 
             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);
                 return SIM_OVERFLOW;
             }
 
-            picked_rate1 = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
-            picked_rate2 = world[sij2].sum_pi_death_rates + world[sij2].sum_mig_rates;
-
-            patch_rates[sij1] = picked_rate1;
-            patch_rates[sij2] = picked_rate2;
-            sum_rates_by_row[si1] += picked_rate1;
-            sum_rates_by_row[si2] += picked_rate2;
-            sum_rates += picked_rate1;
-            sum_rates += picked_rate2;
+            patch_rates[sij1] = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
+            patch_rates[sij2] = world[sij2].sum_pi_death_rates + world[sij2].sum_mig_rates;
+            sum_rates_by_row[si1] += patch_rates[sij1];
+            sum_rates_by_row[si2] += patch_rates[sij2];
+            sum_rates += patch_rates[sij1];
+            sum_rates += patch_rates[sij2];
         }
 
         // 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 +359,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 +372,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);
@@ -415,7 +400,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);
         }
 

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

@@ -28,14 +28,15 @@
 #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
+// where 1 + exp(x) is considered overflow
 // below the actual bound (709) because the large numbers will be computed with close-to-0 ones (payoff rates), so higher accuracy is needed
 #define EXP_OVERFLOW_BOUND 500
 
@@ -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;
@@ -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 - 1;
+    //double U_ratio = U / sum;
+    //double V_ratio = V / sum;
 
-    if (sum_minus_1 > 0) {
-        if (U != 0) {
-            p->U_pi = ((U - 1) / sum_minus_1) * M_start[0] +
-                      (V / sum_minus_1) * M_start[1];
+    if (sum > 0) {
+        if (U > 0) {
+            p->U_pi = (U - 1) / 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];
+        if (V > 0) {
+            p->V_pi = U / sum * M_start[2] + (V - 1) / 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 + 1);
+    p->pi_death_rates[3] = P_start[5] * V * (sum + 1);
 
     p->sum_pi_death_rates = 0.0;
     for (size_t i = 0; i < 4; i++) {
@@ -148,19 +151,38 @@ 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 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] * (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;
+
+    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];
+    }
+}
+
+
+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 are two patch changed, to update mig rates of in each other's direction
+
     double* p_U_weight = p->U_weight;
     double* p_V_weight = p->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];
+    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,44 +193,45 @@ 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] = 1 + exp(w1_Upi);
+            p_V_weight[MIG_UP] = 1 + 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] = 1 + exp(w1_Upi);
+            p_V_weight[MIG_DOWN] = 1 + 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] = 1 + exp(w1_Upi);
+            p_V_weight[MIG_LEFT] = 1 + 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] = 1 + exp(w1_Upi);
+            p_V_weight[MIG_RIGHT] = 1 + 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;
 
     double* p_U_weight = p->U_weight;
     double* p_V_weight = p->V_weight;
@@ -232,14 +255,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] = 1 + exp(w1_Upi);
+            p_V_weight[i] = 1 + 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 +273,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;
@@ -297,7 +322,7 @@ static inline void change_popu(patch_t* restrict p, uint8_t s) {
             return;
         case 2:
             // Natural birth/death for U due to payoff
-            if (p->U_pi > 0.0) {
+            if (p->U_pi > 0) {
                 p->U += 1;
             } else if (p->U > 0) {
                 p->U -= 1;
@@ -313,7 +338,7 @@ static inline void change_popu(patch_t* restrict p, uint8_t s) {
             return;
         default:
             // Natural birth/death for V due to payoff
-            if (p->V_pi > 0.0) {
+            if (p->V_pi > 0) {
                 p->V += 1;
             } else if (p->V > 0) {
                 p->V -= 1;
@@ -337,23 +362,25 @@ static inline void find_patch(patch_picked_t* restrict picked, double expected_s
     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 +419,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 +505,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.3.1 → piegy-2.3.3}/src/piegy/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '2.3.1'
+__version__ = '2.3.3'
 
 '''
 version history:
@@ -37,4 +37,7 @@ version history:
 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.
+2.3.3: fix error in calculation of migration rates.
 '''

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

@@ -491,19 +491,19 @@ def UV_pi(mod, ax_U = None, ax_V = None, U_color = 'violet', V_color = 'yellowgr
 
 
 
-def video_fig(mod, ax_list = None, num_itv = 100, U_color = 'Purples', V_color = 'Greens'):
+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_itv: how many time intervals to plot
+    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_itv > mod.max_record:
-        raise ValueError('num_itv too large, larger than mod.max_record')
-    idx_step = int(mod.max_record / num_itv)
+    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 = []
@@ -525,7 +525,7 @@ def video_fig(mod, ax_list = None, num_itv = 100, U_color = 'Purples', V_color =
             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 - 1])
+            ax_list[i, j].set_xlim([0, mod.M])
             ax_list[i, j].set_ylim([0, mod.maxtime])
     
 

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

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