piegy 2.3.5__tar.gz → 2.3.7__tar.gz

{piegy-2.3.5 → piegy-2.3.7}/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.5/src/piegy.egg-info → piegy-2.3.7}/PKG-INFO

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

{piegy-2.3.5 → piegy-2.3.7}/pyproject.toml

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

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/C_core/Makefile

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

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

@@ -5,10 +5,10 @@
 
 #include "patch.h"
 
-void patch_init(patch_t* p, uint32_t U, uint32_t V, size_t i, size_t j) {
+void patch_init(patch_t* p, uint32_t U, uint32_t V, size_t row, size_t col) {
     if (p == NULL) return;
-    p->i = i;
-    p->j = j;
+    p->row = row;
+    p->col = col;
 
     p->U = U;
     p->V = V;
@@ -30,14 +30,18 @@ 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 set_nb(patch_t* world, double* P_start, 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;
         }
     }
+    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);
 }

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/C_core/patch.h

@@ -14,10 +14,10 @@
 
 
 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;
@@ -34,8 +34,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);
+void set_nb(patch_t* world, double* P_start, size_t* nb_start, size_t ij, size_t NM) ;
 
 #endif // PATCH_H
 

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/C_core/sim_funcs.c

@@ -68,75 +68,68 @@ static void find_nb_periodical(size_t* restrict nb, size_t i, size_t j, size_t N
 
 
 // single_init function: initializes world, runs 1 event, returns updated variables
-static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices, 
-                    double* patch_rates, double* sum_rates_by_row, double* sum_rates_p, signal_t* sig_p, patch_picked_t* picked_p) {
+static double single_init(const model_t* restrict mod, patch_t* restrict world, size_t* restrict nb_indices, 
+                    double* restrict patch_rates, double* restrict sum_rates_by_row, double* restrict sum_rates_p, 
+                    signal_t* restrict sig_p, patch_picked_t* restrict picked_p) {
 
     size_t N = mod->N;
     size_t M = mod->M;
     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);
+            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, &(mod->P[ij * 6]), &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], &(mod->X[ij * 4]), &(mod->P[ij * 6]));
     }
 
     // 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], &(mod->P[ij_out * 6]));  // 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++;
         }
     }
 
@@ -145,6 +138,9 @@ static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices
     find_patch(picked_p, expected_sum, patch_rates, sum_rates_by_row, *sum_rates_p, N, M);
     size_t picked_idx = picked_p->i * M + picked_p->j;
     size_t e0 = find_event(&world[picked_idx], expected_sum - picked_p->current_sum);
+    if (picked_idx >= NM || e0 >= 12) {
+        return -1 * ACCURACY_ERROR;
+    }
 
     // make signal
     if (mod->boundary) {
@@ -172,18 +168,16 @@ static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices
     // 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;
@@ -200,10 +194,15 @@ 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;
-    double current_progress = one_progress;
     if (mod->print_pct != -1) {
         one_progress = maxtime * mod->print_pct / 100.0;
         fprintf(stdout, "\r                     ");
@@ -212,12 +211,13 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
     } else {
         one_progress = 2.0 * maxtime;
     }
+    double current_progress = one_progress;
 
     // update sum of rates every 1e5 rounds
     // many rates are updated each time, rather than re-calculated. 
-    // So need to re-calculate from scratch every some time to reduce numerical errors
+    // So need to re-calculate from scratch every some rounds to reduce numerical errors
     size_t curr_update_sum_round = 0;  // current round
-    size_t update_sum_freq = UPDATE_SUM_FREQ_SM;  // the frequency really using, change based on how large values are encountered
+    size_t update_sum_freq = UPDATE_SUM_ROUNDS_SM;  // recalculate sum every this many rounds
 
     // Initialize simulation
     patch_t* world = (patch_t*) calloc(NM, sizeof(patch_t));
@@ -242,57 +242,59 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         fflush(stdout);
         single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
         return SIM_OVERFLOW;
+    } else if (time == -1 * ACCURACY_ERROR) {
+            fprintf(stdout, "\nError: accuracy too low at t = 0, simulation stopped\n");
+            fflush(stdout);
+            single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
+            return ACCURACY_ERROR;
     }
-    size_t record_index = time / mod->record_itv;
+    size_t record_index = (size_t) (time / mod->record_itv);
     double record_time = time - record_index * record_itv;
 
 
     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_freq) {
             curr_update_sum_round = 0;
-            update_sum_freq = UPDATE_SUM_FREQ_LG;  // assume can make it larger
-            size_t ij = 0;
 
-            for (size_t i = 0; i < N; i++) {
-                for (size_t j = 0; j < M; j++) {
-                    double sum_U_weight = 0;
-                    double sum_V_weight = 0;
-                    for (size_t k = 0; k < 4; k++) {
-                        sum_U_weight += world[ij].U_weight[k];
-                        sum_V_weight += world[ij].V_weight[k];
-                    }
-                    world[ij].sum_U_weight = sum_U_weight;
-                    world[ij].sum_V_weight = sum_V_weight;
-                    // patch_rates are updated every time a patch is changed
-                    if (sum_U_weight > ACCURATE_BOUND) {
-                        update_sum_freq = UPDATE_SUM_FREQ_SM;  // values too large, put back the small update frequency
-                    }
-                    ij++;
+            // 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 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;
+                for (size_t k = 0; k < 4; k++) {
+                    sum_U_weight += world[ij].U_weight[k];
+                    sum_V_weight += world[ij].V_weight[k];
                 }
+                if (sum_U_weight > ACCURATE_BOUND || sum_V_weight > ACCURATE_BOUND) {
+                    update_sum_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
             }
-            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;
@@ -307,13 +309,14 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         size_t sij1 = signal.ij1;
         size_t sij2 = signal.ij2;
         uint8_t rela_loc = signal.rela_loc;
+
         if (rela_loc == NO_MIG) {
             // if only one
             sum_rates_by_row[si1] -= patch_rates[sij1];
             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], &(X[sij1 * 4]), &(P[sij1 * 6]));
+            update_mig_just_rate(&world[sij1], &(P[sij1 * 6]));
 
             patch_rates[sij1] = world[sij1].sum_pi_death_rates + world[sij1].sum_mig_rates;
             sum_rates_by_row[si1] += patch_rates[sij1];
@@ -325,11 +328,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], &(X[sij1 * 4]), &(P[sij1 * 6]));  // update both patches' payoffs first
+            update_pi_k(&world[sij2], &(X[sij2 * 4]), &(P[sij2 * 6]));
 
-            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], &(P[sij1 * 6]), rela_loc) == SIM_OVERFLOW || 
+                update_mig_weight_rate(&world[sij2], &(P[sij2 * 6]), rela_loc ^ 1) == SIM_OVERFLOW) {
 
                 fprintf(stdout, "\nError: overflow at t = %f\n", time);
                 fflush(stdout);
@@ -351,7 +354,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], &(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);
@@ -366,7 +369,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], &(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);
@@ -380,7 +383,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], &(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);
@@ -396,6 +399,12 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
         find_patch(&picked, expected_sum, patch_rates, sum_rates_by_row, sum_rates, N, M);
         size_t picked_idx = picked.i * M + picked.j;
         uint8_t e0 = find_event(&world[picked_idx], expected_sum - picked.current_sum);
+        if (picked_idx >= NM || e0 >= 12) {
+            fprintf(stdout, "\nError: accuracy too low at t = %f, simulation stopped\n", time);
+            fflush(stdout);
+            single_test_free(&world, &nb_indices, &patch_rates,  &sum_rates_by_row);
+            return ACCURACY_ERROR;
+        }
 
         // make signal
         if (boundary) {
@@ -424,16 +433,13 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
                 record_time -= multi_records * record_itv;
                 size_t upper = record_index + multi_records;
 
-                size_t ij = 0;
-                for (size_t i = 0; i < N; i++) {
-                    for (size_t j = 0; j < M; j++) {
-                        for (size_t k = record_index; k < upper; k++) {
-                            mod->U1d[ij * max_record + k] += world[ij].U;
-                            mod->V1d[ij * max_record + k] += world[ij].V;
-                            mod->Upi_1d[ij * max_record + k] += world[ij].U_pi;
-                            mod->Vpi_1d[ij * max_record + k] += world[ij].V_pi;
-                        }
-                        ij++;
+                for (size_t ij = 0; ij < NM; ij++) {
+                    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;
                     }
                 }
                 record_index += multi_records;
@@ -441,16 +447,13 @@ static uint8_t single_test(model_t* restrict mod, char* message) {
 
         } else {
             // if already exceeds maxtime
-            size_t ij = 0;
-            for (size_t i = 0; i < N; i++) {
-                for (size_t j = 0; j < M; j++) {
-                    for (size_t k = record_index; k < max_record; k++) {
-                        mod->U1d[ij * max_record + k] += world[ij].U;
-                        mod->V1d[ij * max_record + k] += world[ij].V;
-                        mod->Upi_1d[ij * max_record + k] += world[ij].U_pi;
-                        mod->Vpi_1d[ij * max_record + k] += world[ij].V_pi;
-                    }
-                    ij++;
+            for (size_t ij = 0; ij < NM; ij++) {
+                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;
                 }
             }
         }
@@ -483,7 +486,7 @@ static void single_test_free(patch_t** world, size_t** nb_indices, double** patc
 
 
 
-uint8_t run(model_t* mod, char* message, size_t msg_len) {
+uint8_t run(model_t* restrict mod, char* message, size_t msg_len) {
     if (!mod->data_empty) {
         // this won't happen if called from python, the ``simulation.run`` caller has checked it.
         fprintf(stdout, "Error: mod has non-empty data\n");
@@ -538,6 +541,9 @@ uint8_t run(model_t* mod, char* message, size_t msg_len) {
             case SIM_OVERFLOW:
                 // error message is handled by single_test
                 return SIM_OVERFLOW;
+            case ACCURACY_ERROR:
+                // error message is handled by single_test
+                return ACCURACY_ERROR;
         }
     }
 
@@ -545,8 +551,10 @@ uint8_t run(model_t* mod, char* message, size_t msg_len) {
 
     double stop = clock();
 
-    fprintf(stdout, "\r%sruntime: %.3fs             \n", message, (double)(stop - start) / CLOCKS_PER_SEC);
-    fflush(stdout);
+    if (mod->print_pct != -1) {
+        fprintf(stdout, "\r%sruntime: %.3fs             \n", message, (double)(stop - start) / CLOCKS_PER_SEC);
+        fflush(stdout);
+    }
     return SUCCESS;
 }
 

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/C_core/sim_funcs.h

@@ -18,8 +18,8 @@
 
 
 
-// upper bound for RNG is 2^24 + 1
-#define RAND_UPPER_PLUS_2 (double) (0x3fffffffu + 2)
+// upper bound for RNG is 2^30 + 1
+#define RAND_UPPER_PLUS_2 (double) ((1LL << 30) + 1)
 
 // directions of migration
 // so that 3 - mig_dir = reflection of it. Used to track neighbors
@@ -35,19 +35,25 @@
 #define DATA_NOT_EMPTY 1
 #define SMALL_MAXTIME 2
 #define SIM_OVERFLOW 3
+#define ACCURACY_ERROR 4
+
+
+/**
+ * Handling Numerical Errors:
+ * half of the rates / values related to rates are calculated on a cumulative basis. i.e., updated over time instead of re-calculating from scratch
+ * numerival errors might explode in this case, so need to re-calculate every sometime
+*/
 
 // where exp(x) is considered overflow
-// below the actual bound (709) because the large numbers will be computed with close-to-0 ones (payoff rates), so higher accuracy is needed
+// below the actual bound (709) to preserve accuracy
 #define EXP_OVERFLOW_BOUND 500
-#define ACCURATE_BOUND 10000000000LL
-
-// how frequent to update rates & sum of rates in single test (recalculate)
-#define UPDATE_SUM_FREQ_SM 100
-#define UPDATE_SUM_FREQ_LG 10000
 
+// Compare current rates with this bound
+#define ACCURATE_BOUND 1LL << 33  // about 8.6 * 10^9
 
-static uint64_t pcg_state = 0;
-static uint64_t pcg_inc = 0;
+// how frequent to update rates & sum of rates in single test (recalculate)
+#define UPDATE_SUM_ROUNDS_SM 100  // small, more frequent if some rate is larger than ACCURATE_BOUND
+#define UPDATE_SUM_ROUNDS_LG 10000
 
  
 
@@ -90,11 +96,12 @@ typedef struct signal_t {
 */
 static void find_nb_zero_flux(size_t* restrict nb, size_t i, size_t j, size_t N, size_t M, size_t NM);
 static void find_nb_periodical(size_t* restrict nb, size_t i, size_t j, size_t N, size_t M, size_t NM);
-static double single_init(const model_t* mod, patch_t* world, size_t* nb_indices, 
-                    double* patch_rates, double* sum_rates_by_row, double* sum_rates, signal_t* sig_p, patch_picked_t* picked_p) ;
+static double single_init(const model_t* restrict mod, patch_t* restrict world, size_t* restrict nb_indices, 
+                    double* restrict patch_rates, double* restrict sum_rates_by_row, double* restrict sum_rates_p, 
+                    signal_t* restrict sig_p, patch_picked_t* restrict picked_p);
 static uint8_t single_test(model_t* restrict mod, char* message);
 static void single_test_free(patch_t** world, size_t** nb_indices, double** patch_rates, double** sum_rates_by_row);
-uint8_t run(model_t* mod, char* message, size_t msg_len);
+uint8_t run(model_t* restrict mod, char* message, size_t msg_len);
 
 
 
@@ -107,7 +114,7 @@ static inline double random01() {
     uint32_t r1 = rand() & 0x7fff;  // RAND_MAX is different across machines, ensure 15 bits
     uint32_t r2 = rand() & 0x7fff;
 
-    double r_combined = (r1  << 15) + r2;  // discard the lower 3 bits, which are unstable
+    double r_combined = (r1  << 15) + r2;
     return (r_combined + 1) / RAND_UPPER_PLUS_2;
 }
 
@@ -119,8 +126,8 @@ static inline void update_pi_k(patch_t* restrict p, const double* restrict M_sta
     // M_start: start index of patch (i, j)'s matrix
     // P_start: start index of p's patch variables, i.e., ij * 6
 
-    double U = (double) p->U;
-    double V = (double) p->V;
+    uint32_t U = p->U;
+    uint32_t V = p->V;
     double sum = U + V;
     double U_ratio = U / sum;
     double V_ratio = V / sum;
@@ -163,8 +170,8 @@ static inline void update_mig_just_rate(patch_t* restrict p, const double* restr
     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;
+    double mu1_U = P_start[0] * p->U;
+    double mu2_V = P_start[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;
@@ -347,9 +354,6 @@ static inline void change_popu(patch_t* restrict p, uint8_t s) {
                 p->V -= 1;
             }
             return;
-        //default:
-        //    fprintf(stderr, "Bug: invalid event number in change_popu: %hhu\n", s);
-        //    return;
     }
 }
 

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

@@ -1,4 +1,4 @@
-__version__ = '2.3.4'
+__version__ = '2.3.7'
 
 '''
 version history:
@@ -42,4 +42,6 @@ version history:
 2.3.3: fix error in calculation of migration rates.
 2.3.4: change back to the mig & payoff rules in version 2.3.2
 2.3.5: improved accuracy for simulation, now can better handle large mig rates. Numerical errors are now being checked and reduced automatically based on how large the values are.
+2.3.6: index error due to reduced accuracy is now explicitly handled.
+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.
 '''

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/data_tools.py

@@ -29,12 +29,8 @@ def save_data(mod, dirs = '', print_msg = True):
     except AttributeError:
         raise ValueError('mod is not a model object')
 
-    if dirs != '':
-        # add slash '/'
-        if dirs[:-1] != '/':
-            dirs += '/'
-        if not os.path.exists(dirs):
-            os.makedirs(dirs)
+    if not os.path.exists(dirs):
+        os.makedirs(dirs)
         
     data = []
     
@@ -64,14 +60,11 @@ def save_data(mod, dirs = '', print_msg = True):
     outputs.append(mod.Vpi.tolist())
     # H&Vpi_total are not saved, will be calculated when reading the data
     data.append(outputs)
-    
-    data_json = json.dumps(data)
-    data_bytes = data_json.encode('utf-8')
-    data_dirs = dirs + 'data.json.gz'
-    
-    with gzip.open(data_dirs, 'w') as f:
-        f.write(data_bytes)
-    
+
+    data_dirs = os.path.join(dirs, 'data.json.gz')
+    with gzip.open(data_dirs, 'wb') as f:
+        f.write(json.dumps(data).encode('utf-8'))
+
     if print_msg:
         print('data saved: ' + data_dirs)
 
@@ -89,35 +82,30 @@ def read_data(dirs):
     - mod: a piegy.model.model object read from the data.
     '''
     
-    if dirs != '':
-        # add slash '/'
-        if dirs[:-1] != '/':
-            dirs += '/'
-        if not os.path.exists(dirs):
-            raise FileNotFoundError('dirs not found: ' + dirs)
-            
-    if not os.path.isfile(dirs + 'data.json.gz'):
+    if not os.path.exists(dirs):
+        raise FileNotFoundError('dirs not found: ' + dirs)
+    
+    data_dirs = os.path.join(dirs, 'data.json.gz')
+    if not os.path.isfile(data_dirs):
         raise FileNotFoundError('data not found in ' + dirs)
     
-    with gzip.open(dirs + 'data.json.gz', 'r') as f:
-        data_bytes = f.read()
-    data_json = data_bytes.decode('utf-8')
-    data = json.loads(data_json)
-
-    # inputs
-    try:
-        mod = simulation.model(N = data[0][0], M = data[0][1], maxtime = data[0][2], record_itv = data[0][3],
-                            sim_time = data[0][4], boundary = data[0][5], I = data[0][6], X = data[0][7], P = data[0][8], 
-                            print_pct = data[0][9], seed = data[0][10], check_overflow = data[0][11])
-    except:
-        raise ValueError('Invalid input parameters saved in data')
-
-    # outputs
-    try:
-        mod.set_data(data_empty = False, max_record = data[1][0], compress_itv = data[1][1], 
-                    U = data[1][2], V = data[1][3], Upi = data[1][4], Vpi = data[1][5])
-    except:
-        raise ValueError('Invalid model results saved in data')
+    with gzip.open(data_dirs, 'rb') as f:
+        data = json.loads(f.read().decode('utf-8'))
+
+        # inputs
+        try:
+            mod = simulation.model(N = data[0][0], M = data[0][1], maxtime = data[0][2], record_itv = data[0][3],
+                                sim_time = data[0][4], boundary = data[0][5], I = data[0][6], X = data[0][7], P = data[0][8], 
+                                print_pct = data[0][9], seed = data[0][10], check_overflow = data[0][11])
+        except:
+            raise ValueError('Invalid input parameters saved in data')
+
+        # outputs
+        try:
+            mod.set_data(data_empty = False, max_record = data[1][0], compress_itv = data[1][1], 
+                        U = data[1][2], V = data[1][3], Upi = data[1][4], Vpi = data[1][5])
+        except:
+            raise ValueError('Invalid model results saved in data')
     
     return mod
 

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/figures.py

@@ -332,15 +332,15 @@ def pi_bar(mod, ax_U = None, ax_V = None, U_color = 'violet', V_color = 'yellowg
     end_index = int(mod.max_record * end)
     
     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)
+    Vpi_ave = figure_t.ave_interval_1D(mod.Vpi, start_index, end_index)
     
     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_D$', start, end)
-    V_text = figure_t.gen_text(np.mean(V_pi_ave), np.std(V_pi_ave))
+    V_text = figure_t.gen_text(np.mean(Vpi_ave), np.std(Vpi_ave))
     
     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)
+    ax_V = figure_t.bar(Vpi_ave, ax_V, V_color, 'Patches', 'Payoff ' + r'$p_D$', V_title, V_text)
 
     return ax_U, ax_V
 

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

@@ -25,7 +25,7 @@ from numpy.ctypeslib import ndpointer
 # check whether overflow / too large values might be encountered
 # these values are considered as exponents in exp()
 EXP_OVERFLOW_BOUND = 709  # where exp(x) almost reaches overflow bound
-EXP_TOO_LARGE_BOUND = 88  # where exp(x) reaches 1e34
+EXP_TOO_LARGE_BOUND = 30  # where exp(x) reaches ~10e13 and accuracy goes below 10^-3 (10^-3 isn't accurate any more)
 
 
 # read the C core into LIB
@@ -36,6 +36,7 @@ SIM_SUCCESS = 0
 SIM_DATA_EMPTY = 1
 SIM_SMALL_MAXTIME = 2
 SIM_OVERFLOW = 3
+ACCURACY_ERROR = 4
 
 
 '''
@@ -449,7 +450,11 @@ def run(mod, message = ""):
     elif result == SIM_OVERFLOW:
         LIB.mod_free_py(ctypes.byref(mod_c))
         del mod_c
-        raise OverflowError('Overflow in simulation')
+        raise OverflowError('Overflow in simulation. Possibly due to too large w1, w2, or payoff.')
+    elif result == ACCURACY_ERROR:
+        LIB.mod_free_py(ctypes.byref(mod_c))
+        del mod_c
+        raise RuntimeError('Accuracy dropped catastrophically during simulation. Possibly due to too large w1, w2, or payoff.')
     else:
         LIB.mod_free_py(ctypes.byref(mod_c))
         del mod_c
@@ -524,9 +529,9 @@ def check_overflow_func(mod):
             w1_pi = pi_expected[i][j] * mod.P[i][j][2]  # w1 * U_pi
             w2_pi = pi_expected[i][j] * mod.P[i][j][3]  # w2 * V_pi
             if ((w1_pi > EXP_OVERFLOW_BOUND) or (w2_pi > EXP_OVERFLOW_BOUND)):
-                print("Warning: might cause overflow. \n\t w1, w2, or payoff matrix values too large")
+                print("Warning: might cause overflow in simulation. w1, w2, or payoff matrix values too large")
                 return
             if ((w1_pi > EXP_TOO_LARGE_BOUND) or (w2_pi > EXP_TOO_LARGE_BOUND)):
-                print("Warning: might encounter large values > 3e38 in simulation. \n\t w1, w2, or payoff matrix values too large")
+                print("Warning: might have low accuracy in simulation. w1, w2, or payoff matrix values too large")
                 return
 

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/test_var.py

@@ -92,8 +92,9 @@ def test_var1(mod, var, values, dirs, compress_itv = None):
             if compress_itv != None:
                 sim2.compress_data(compress_itv)
             data_t.save_data(sim2, var_dirs[k], print_msg = False)
-        except OverflowError:
-            print(current_var_str + ' raised OverflowError, skipped')
+            del sim2
+        except (OverflowError, RuntimeError):
+            print(current_var_str + ' raised error, skipped')
             continue
 
     return var_dirs
@@ -139,8 +140,9 @@ def test_var2(mod, var1, var2, values1, values2, dirs, compress_itv = None):
                 if compress_itv != None:
                     sim2.compress_data(compress_itv)
                 data_t.save_data(sim2, var_dirs[k1][k2], print_msg = False)
-            except OverflowError:
-                print(current_var_str + ' raised OverflowError, skipped')
+                del sim2
+            except (OverflowError, RuntimeError):
+                print(current_var_str + ' raised error, skipped')
                 continue
 
     return var_dirs
@@ -185,6 +187,7 @@ def var_UV1(var, values, var_dirs, ax_U = None, ax_V = None, start = 0.95, end =
 
         U_ave.append(sum(figure_t.ave_interval_1D(simk.U, start_index, end_index)) / NM)
         V_ave.append(sum(figure_t.ave_interval_1D(simk.V, start_index, end_index)) / NM)
+        del simk
         
     #### plot ####
     if ax_U == None:
@@ -253,6 +256,7 @@ def var_UV2(var1, var2, values1, values2, var_dirs, ax_U = None, ax_V = None, va
 
             U_ave[k1].append(sum(figure_t.ave_interval_1D(simk.U, start_index, end_index)) / NM)
             V_ave[k1].append(sum(figure_t.ave_interval_1D(simk.V, start_index, end_index)) / NM)
+            del simk
 
     U_ave = np.array(U_ave)
     V_ave = np.array(V_ave)
@@ -340,7 +344,6 @@ def var_pi1(var, values, var_dirs, ax_U = None, ax_V = None, start = 0.95, end =
 
         U_ave.append(np.sum(figure_t.ave_interval(simk.Upi, start_index, end_index)) / NM)
         V_ave.append(np.sum(figure_t.ave_interval(simk.Vpi, start_index, end_index)) / NM)
-
         del simk
             
     #### plot ####
@@ -406,8 +409,7 @@ def var_pi2(var1, var2, values1, values2, var_dirs, ax_U = None, ax_V = None, va
 
             U_ave[k1].append(np.sum(figure_t.ave_interval(simk.Upi, start_index, end_index)) / NM)
             V_ave[k1].append(np.sum(figure_t.ave_interval(simk.Vpi, start_index, end_index)) / NM)
-
-            del simk    # manually delete this large object
+            del simk
 
     U_ave = np.array(U_ave)
     V_ave = np.array(V_ave)
@@ -507,14 +509,16 @@ def var_convergence1(var_dirs, interval = 20, start = 0.8, fluc = 0.07):
 
     diverge_list = []
 
-    for dirs in var_dirs:
+    for k in range(len(var_dirs)):
+        dirs = var_dirs[k]
         try:
-            mod = data_t.read_data(dirs)
+            simk = data_t.read_data(dirs)
         except FileNotFoundError:
             print(dirs + ' data not found, skipped')
             continue
-        if not analysis.check_convergence(mod, interval, start, fluc):
+        if not analysis.check_convergence(simk, interval, start, fluc):
             diverge_list.append(dirs)
+        del simk
 
     return diverge_list
 
@@ -574,14 +578,16 @@ def var_convergence2(var_dirs, interval = 20, start = 0.8, fluc = 0.07):
     diverge_list = []
 
     for sublist in var_dirs:
-        for dirs in sublist:
+        for k in range(len(sublist)):
+            dirs = sublist[k]
             try:
-                mod = data_t.read_data(dirs)
+                simk = data_t.read_data(dirs)
             except FileNotFoundError:
                 print(dirs + ' data not found, skipped')
                 continue
-            if not analysis.check_convergence(mod, interval, start, fluc):
+            if not analysis.check_convergence(simk, interval, start, fluc):
                 diverge_list.append(dirs)
+            del simk
 
     return diverge_list
 

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/tools/figure_tools.py

@@ -187,7 +187,7 @@ def ave_interval_1D(data, start_index, end_index):
     M = len(data[0])
 
     if start_index == end_index:
-        start_index = end_index - 1
+        end_index = start_index + 1  # exactly one record
         
     data_ave = np.zeros(N * M)
     

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/tools/find_C.py

@@ -9,9 +9,8 @@ def find_C():
     C_core_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'C_core')
     C_list = os.listdir(C_core_path)
     for file in C_list:
-        if file[-3:] == '.so':
-            return C_core_path + '/' + file
-        if file[-4:] == '.pyd':
-            return C_core_path + '/' + file
+        if (file[-3:] == '.so') or (file[-4:] == '.pyd') or (file[-4:] == '.dll') or (file[-4:] == '.lib'):
+            if 'piegyc' in file:
+                return C_core_path + '/' + file
 
     raise FileNotFoundError('C computation core not found. You can either compile manully or use the Python core instead. Please see docs.')

{piegy-2.3.5 → piegy-2.3.7}/src/piegy/videos.py

@@ -27,7 +27,6 @@ import matplotlib.style as mplstyle
 import numpy as np
 import os
 from cv2 import imread, VideoWriter, VideoWriter_fourcc
-from moviepy import ImageSequenceClip
 
 
 # a list of supported figures
@@ -144,7 +143,7 @@ def frame_lim(mod, func, frames):
     U_ylim = get_max_lim(U_ylist)
     V_xlim = get_max_lim(V_xlist)
     V_ylim = get_max_lim(V_ylist)
-    
+
     return U_xlim, U_ylim, V_xlim, V_ylim
 
 
@@ -200,14 +199,15 @@ def make_mp4(video_dir, frame_dir, fps):
         if (file[-4:] == '.png') and ('frame' in file):
             frame_path.append(os.path.join(frame_dir, file))
 
+    # setup cv2 video writer
     first_frame = imread(frame_path[0])
     height, width, _ = first_frame.shape
     fourcc = VideoWriter_fourcc(*'mp4v')
     video_writer = VideoWriter(video_dir, fourcc, fps, (width, height))
 
     for file in frame_path:
-            frame = imread(file)
-            video_writer.write(frame)
+        frame = imread(file)
+        video_writer.write(frame)
     video_writer.release()
 
 
@@ -236,9 +236,9 @@ def make_video(mod, func_name = 'UV_hmap', frames = 100, dpi = 200, fps = 30, U_
     # convert color if invalid colors are given
     U_color, V_color = convert_color(func_name, U_color, V_color)
 
-    # set fast style for faster speed
-    original_rc = mpl.rcParams.copy()
-    mplstyle.use('fast')
+    # set Agg backend for faster speed
+    original_backend = mpl.get_backend()
+    mpl.use("Agg")
     
     # print progress
     one_progress = frames / 100
@@ -267,7 +267,7 @@ def make_video(mod, func_name = 'UV_hmap', frames = 100, dpi = 200, fps = 30, U_
 
     #### for loop ####
     
-    for i in range(frames - 1):
+    for i in range(frames):
         if i > current_progress:
             print('making frames', round(i / frames * 100), '%', end = '\r')
             current_progress += one_progress
@@ -277,9 +277,9 @@ def make_video(mod, func_name = 'UV_hmap', frames = 100, dpi = 200, fps = 30, U_
             fig_U, ax_U = plt.subplots(figsize = figsize)
             fig_V, ax_V = plt.subplots(figsize = figsize)
         else:
-            fig_U, ax_U = plt.subplots(figsize = figsize)#, constrained_layout = True)
-            fig_V, ax_V = plt.subplots(figsize = figsize)#, constrained_layout = True)
-
+            fig_U, ax_U = plt.subplots(figsize = figsize)
+            fig_V, ax_V = plt.subplots(figsize = figsize)
+            
         if 'hmap' in func_name:
             func(mod, ax_U = ax_U, ax_V = ax_V, U_color = U_color, V_color = V_color, start = i / frames, end = (i + 1) / frames, vrange_U = U_clim, vrange_V = V_clim)
         else:
@@ -304,6 +304,9 @@ def make_video(mod, func_name = 'UV_hmap', frames = 100, dpi = 200, fps = 30, U_
         plt.close(fig_V)
         
     #### for loop ends ####
+
+    # reset to original backend
+    mpl.use(original_backend)
     
     # frames done
     print('making mp4...      ', end = '\r')

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

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

{piegy-2.3.5 → piegy-2.3.7}/src/piegy.egg-info/SOURCES.txt

@@ -23,7 +23,6 @@ src/piegy/C_core/model.c
 src/piegy/C_core/model.h
 src/piegy/C_core/patch.c
 src/piegy/C_core/patch.h
-src/piegy/C_core/runner.c
 src/piegy/C_core/sim_funcs.c
 src/piegy/C_core/sim_funcs.h
 src/piegy/tools/__init__.py

piegy-2.3.5/src/piegy/C_core/runner.c

@@ -1,61 +0,0 @@
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "model.h"
-#include "patch.h"
-#include "sim_funcs.h"
-
-
-int main() {
-    size_t N = 1;
-    size_t M = 100;
-    double maxtime = 300;
-    double record_itv = 0.1;
-    size_t sim_time = 1;
-    bool boundary = true;
-    uint32_t I_single[2] = {3, 3};
-    double X_single[4] = {-1, 4, 0, 2};
-    double P_single[6] = {0.5, 0.5, 100, 100, 0.001, 0.001};
-    int32_t print_pct = 1;
-    int32_t seed = 36;  // -1 for None
-
-    uint32_t I[N * M * 2];
-    double X[N * M * 4];
-    double P[N * M * 6];
-
-    //printf("sizeof(patch_t) = %zu bytes\n", sizeof(patch_t));
-    size_t ij = 0;
-    for (size_t i = 0; i < N; i++) {
-        for (size_t j = 0; j < M; j++) {
-            I[ij * 2] = I_single[0];
-            I[ij * 2 + 1] = I_single[1];
-
-            for (size_t k = 0; k < 4; k++) {
-                X[ij * 4 + k] = X_single[k];
-            }
-            for (size_t k = 0; k < 6; k++) {
-                P[ij * 6 + k] = P_single[k];
-            }
-            ++ij;
-        }
-    }
-
-    model_t* mod = malloc(sizeof(model_t));
-    mod_init(mod, N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct, seed);
-
-    char message[20] = "";  // writable buffer with enough space
-    uint8_t result = run(mod, message, 20);
-    
-    /*for (size_t i = 0; i < mod->max_record; i++) {
-        fprintf(stdout, "%f ", mod->U1d[i]);
-    }
-    fprintf(stdout, "\n");
-    for (size_t i = 0; i < mod->max_record; i++) {
-        fprintf(stdout, "%f ", mod->Upi_1d[i]);
-    }*/
-    mod_free(mod);
-    mod = NULL;
-}
-