piegy 2.3.6__tar.gz → 2.3.8__tar.gz

{piegy-2.3.6 → piegy-2.3.8}/MANIFEST.in

@@ -4,3 +4,4 @@ include LICENSE.txt
 include src/piegy/C_core/*.c
 include src/piegy/C_core/*.h
 include src/piegy/C_core/Makefile
+exclude src/piegy/C_core/runner.c

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

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

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

piegy-2.3.8/src/piegy/C_core/patch.c

@@ -0,0 +1,53 @@
+/**
+ * This .c includes the patch struct and "member functions" 
+ * that correponds to patch class in piegy.model module
+*/
+
+#include "patch.h"
+
+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;
+    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;
+        p->V_weight[i] = 0;
+        p->pi_death_rates[i] = 0;
+    }
+    for (size_t i = 0; i < 8; i++) {
+        p->mig_rates[i] = 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, 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++) {
+        if (nb_start[k] != NM) {
+            // neighbor is valid
+            world[ij].nb[k] = &world[nb_start[k]];
+            num_nb += 1;
+        } else {
+            world[ij].nb[k] = NULL;
+        }
+    }
+    world[ij].P[0] *= (0.25 * num_nb);
+    world[ij].P[1] *= (0.25 * num_nb);
+}

{piegy-2.3.6 → piegy-2.3.8}/src/piegy/C_core/patch.h

@@ -10,18 +10,21 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
-
+#include <string.h>
 
 
 typedef struct patch_t {
-    size_t i;
-    size_t j;
+    size_t row;
+    size_t col;
 
-    uint32_t U;
+    uint32_t U;  // store as double directly to avoid runtime conversion (to double)
     uint32_t V;
     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 i, size_t j);
-void set_nb(patch_t* world, 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.6 → piegy-2.3.8}/src/piegy/C_core/sim_funcs.c

@@ -76,68 +76,60 @@ static double single_init(const model_t* restrict mod, patch_t* restrict world,
     size_t M = mod->M;
     size_t NM = N * M;
     size_t max_record = mod->max_record;
-    size_t ij = 0;  // used to track index i * M + j in double for loops
+    size_t ij_out = 0;  // used to track index i * M + j in double for loops, "out" means not the "looper" in for loop
 
     // init world
     for (size_t i = 0; i < N; i++) {
         for (size_t j = 0; j < M; j++) {
-            patch_init(&world[ij], mod->I[ij * 2], mod->I[ij * 2 + 1], i, j);
-            ij++;
+            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++;
         }
     }
 
     // init nb_indices
-    ij = 0;
+    ij_out = 0;
     if (mod->boundary) {
         for (size_t i = 0; i < N; i++) {
             for (size_t j = 0; j < M; j++) {
-                find_nb_zero_flux(&nb_indices[ij * 4], i, j, N, M, NM);
-                ij++;
+                find_nb_zero_flux(&nb_indices[ij_out * 4], i, j, N, M, NM);
+                ij_out++;
             }
         }
     } else {
         for (size_t i = 0; i < N; i++) {
             for (size_t j = 0; j < M; j++) {
-                find_nb_periodical(&nb_indices[ij * 4], i, j, N, M, NM);
-                ij++;
+                find_nb_periodical(&nb_indices[ij_out * 4], i, j, N, M, NM);
+                ij_out++;
             }
         }
     }
 
 
     // set nb pointers for patches
-    ij = 0;
-    for (size_t i = 0; i < N; i++) {
-        for (size_t j = 0; j < M; j++) {
-            set_nb(world, &nb_indices[ij * 4], ij, NM);
-            ij++;
-        }
+    for (size_t ij = 0; ij < NM; ij++) {
+        set_nb(world, &nb_indices[ij * 4], ij, NM);
     }
 
     //////// Begin Running ////////
 
     // init payoff & natural death rates
-    ij = 0;
-    for (size_t i = 0; i < N; i++) {
-        for (size_t j = 0; j < M; j++) {
-            update_pi_k(&world[ij], &(mod->X[ij * 4]), &(mod->P[ij * 6]));
-            ij++;
-        }
+    for (size_t ij = 0; ij < N; ij++) {
+        update_pi_k(&world[ij]);
     }
 
     // init migration rates & store patch rates
-    ij = 0;
+    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], &(mod->P[ij * 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;
             }
-            double ij_rates = world[ij].sum_pi_death_rates + world[ij].sum_mig_rates;
-            patch_rates[ij] = ij_rates;
+            double ij_rates = world[ij_out].sum_pi_death_rates + world[ij_out].sum_mig_rates;
+            patch_rates[ij_out] = ij_rates;
             sum_rates_by_row[i] += ij_rates;
             *sum_rates_p = *sum_rates_p + ij_rates;  // can't do *sum_rates_p += ij_rates
-            ij++;
+            ij_out++;
         }
     }
 
@@ -172,22 +164,20 @@ 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);
-        ij = 0;
-        for (size_t i = 0; i < N; i++) {
-            for (size_t j = 0; j < M; j++) {
-                for (size_t k = 0; k < recod_idx; k++) {
-                    mod->U1d[ij * max_record + k] += world[ij].U;
-                    mod->V1d[ij * max_record + k] += world[ij].V;
-                    mod->Upi_1d[ij * max_record + k] += world[ij].U_pi;
-                    mod->Vpi_1d[ij * max_record + k] += world[ij].V_pi;
-                }
-                ij++;
+
+        for (size_t ij = 0; ij < NM; ij++) {
+            size_t ij_max_record = ij * max_record;
+            for (size_t k = 0; k < recod_idx; k++) {
+                mod->U1d[ij_max_record + k] += world[ij].U;
+                mod->V1d[ij_max_record + k] += world[ij].V;
+                mod->Upi_1d[ij_max_record + k] += world[ij].U_pi;
+                mod->Vpi_1d[ij_max_record + k] += world[ij].V_pi;
             }
-        } 
+        }
     }
 
     return time;
@@ -204,29 +194,20 @@ 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;
-
-    // print progress
-    double one_progress = 0.0;
-    double current_progress = one_progress;
-    if (mod->print_pct != -1) {
-        one_progress = maxtime * mod->print_pct / 100.0;
-        fprintf(stdout, "\r                     ");
-        fprintf(stdout, "\r%s: 0 %%", message);
-        fflush(stdout);
-    } else {
-        one_progress = 2.0 * maxtime;
-    }
+    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. 
     // So need to re-calculate from scratch every some rounds to reduce numerical errors
     size_t curr_update_sum_round = 0;  // current round
-    size_t update_sum_rounds = UPDATE_SUM_ROUNDS_SM;  // recalculate sum every this many rounds
+    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;
@@ -234,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,32 +243,36 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
             fflush(stdout);
             single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
             return ACCURACY_ERROR;
-        }
-    size_t record_index = time / mod->record_itv;
+    }
+    size_t record_index = (size_t) (time / mod->record_itv);
     double record_time = time - record_index * record_itv;
 
+    ////////  while loop  ////////
 
     while (time < maxtime) {
 
-        // Print progress
-        if (time > current_progress) {
-            uint8_t curr_prog = (uint8_t)(time * 100 / maxtime);
-            if (curr_prog < 10) {
-                fprintf(stdout, "\r%s: %d %%", message, (int)(time * 100 / maxtime));
-            } else {
-                fprintf(stdout, "\r%s: %d%%", message, (int)(time * 100 / maxtime));
-            }
-            fflush(stdout);
-            //fflush(stdout);  // Make sure it prints immediately
-            current_progress += one_progress;
-        }
-        
-        // update sums
+        // update sums and print progress
         curr_update_sum_round++;
-        if (curr_update_sum_round > update_sum_rounds) {
+        if (curr_update_sum_round > update_sum_freq) {
             curr_update_sum_round = 0;
 
-            update_sum_rounds = UPDATE_SUM_ROUNDS_LG;  // assume can make it larger
+            // Print progress
+            if (time > current_progress) {
+                uint8_t curr_prog = (uint8_t)(time * 100 / maxtime);
+                if (curr_prog < 10) {
+                    fprintf(stdout, "\r%s: %d %%", message, (int)(time * 100 / maxtime));
+                } else {
+                    fprintf(stdout, "\r%s: %d%%", message, (int)(time * 100 / maxtime));
+                }
+                fflush(stdout);
+                //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;
+            }
+
+            // update sum
+            update_sum_freq = UPDATE_SUM_ROUNDS_LG;  // assume can make it larger
             for (size_t ij = 0; ij < NM; ij++) {
                 double sum_U_weight = 0;
                 double sum_V_weight = 0;
@@ -285,19 +281,19 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                     sum_V_weight += world[ij].V_weight[k];
                 }
                 if (sum_U_weight > ACCURATE_BOUND || sum_V_weight > ACCURATE_BOUND) {
-                    update_sum_rounds = UPDATE_SUM_ROUNDS_SM;  // values too large, put back the small update frequency
+                    update_sum_freq = UPDATE_SUM_ROUNDS_SM;  // values too large, put back the small update frequency
                 }
                 world[ij].sum_U_weight = sum_U_weight;
                 world[ij].sum_V_weight = sum_V_weight;
                 // patch_rates are updated every time a patch is changed
             }
-            size_t ij = 0;
+            size_t ij_out = 0;
             sum_rates = 0;
             for (size_t i = 0; i < N; i++) {
                 double sum_rates_by_row_i = 0;
                 for (size_t j = 0; j < M; j++) {
-                    sum_rates_by_row_i += patch_rates[ij];
-                    ij++;
+                    sum_rates_by_row_i += patch_rates[ij_out];
+                    ij_out++;
                 }
                 sum_rates_by_row[i] = sum_rates_by_row_i;
                 sum_rates += sum_rates_by_row_i;
@@ -318,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], &(mod->X[sij1 * 4]), &(mod->P[sij1 * 6]));
-            update_mig_just_rate(&world[sij1], &(mod->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];
@@ -331,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], &(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]));
+            update_pi_k(&world[sij1]);  // update both patches' payoffs first
+            update_pi_k(&world[sij2]);
 
-            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) {
+            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);
@@ -357,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], &(mod->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);
@@ -372,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], &(mod->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);
@@ -386,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], &(mod->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);
@@ -396,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);
@@ -416,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);
@@ -437,11 +432,12 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 size_t upper = record_index + multi_records;
 
                 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++) {
-                        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;
+                        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,11 +446,12 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         } else {
             // if already exceeds maxtime
             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++) {
-                    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;
+                    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;
                 }
             }
         }
@@ -514,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
@@ -550,10 +553,12 @@ uint8_t run(model_t* restrict mod, char* message, size_t msg_len) {
 
     calculate_ave(mod);
 
-    double stop = clock();
-
-    fprintf(stdout, "\r%sruntime: %.3fs             \n", message, (double)(stop - start) / CLOCKS_PER_SEC);
-    fflush(stdout);
+    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);
+    }
     return SUCCESS;
 }