piegy 2.0.5__tar.gz → 2.1.8__tar.gz

piegy-2.1.8/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include LICENSE.txt
+
+include src/piegy/C_core/*.c
+include src/piegy/C_core/*.h
+include src/piegy/C_core/Makefile

{piegy-2.0.5/src/piegy.egg-info → piegy-2.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piegy
-Version: 2.0.5
+Version: 2.1.8
 Summary: Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory
 Author-email: Chenning Xu <cxu7@caltech.edu>
 License: BSD 3-Clause License
@@ -44,7 +44,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy
@@ -100,7 +100,7 @@ simulation.run(mod)
 fig1, ax1 = plt.subplots()
 figures.UV_dyna(mod, ax1)
 fig2, ax2 = plt.subplots(1, 2, figsize = (12.8, 4.8))
-U_hmap, V_hmap = figures.UV_heatmap(mod, ax2[0], ax2[1])
+figures.UV_heatmap(mod, ax2[0], ax2[1])
 ```
 
 The figures reveal population dynamics and steady state population distribution.

{piegy-2.0.5 → piegy-2.1.8}/README.md

@@ -45,7 +45,7 @@ simulation.run(mod)
 fig1, ax1 = plt.subplots()
 figures.UV_dyna(mod, ax1)
 fig2, ax2 = plt.subplots(1, 2, figsize = (12.8, 4.8))
-U_hmap, V_hmap = figures.UV_heatmap(mod, ax2[0], ax2[1])
+figures.UV_heatmap(mod, ax2[0], ax2[1])
 ```
 
 The figures reveal population dynamics and steady state population distribution.

{piegy-2.0.5 → piegy-2.1.8}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'piegy'
-version = '2.0.5'
+version = '2.1.8'
 description = 'Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory'
 readme = 'README.md'
-requires-python = '>=3.6'
+requires-python = '>=3.7'
 license = {file = "LICENSE.txt"}
 authors = [
     {name = 'Chenning Xu', email = 'cxu7@caltech.edu'}
@@ -42,7 +42,4 @@ package-dir = {'' = 'src'}
 [tool.setuptools.packages.find]
 where = ['src']
 
-[tool.setuptools.package-data]
-"piegy" = ["C_core/piegyc.so"]
-
 

piegy-2.1.8/setup.py

@@ -0,0 +1,85 @@
+import subprocess
+import sys
+import os
+import re
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+from setuptools.command.build_py import build_py
+import platform
+import datetime
+import textwrap
+
+
+class BuildSharedLib(build_ext):
+    def run(self):
+        # Build your shared lib first
+        subprocess.check_call(['make', '-C', 'src/piegy/C_core', 'clean', 'so'])
+        # Then continue with normal build_ext run
+        super().run()
+
+    def build_extension(self, ext):
+        if sys.platform == 'win32':
+            lib_name = 'piegyc.dll'
+        else:
+            lib_name = 'piegyc.so'
+        so_path = os.path.abspath(f'src/piegy/C_core/{lib_name}')
+        target_path = self.get_ext_fullpath(ext.name)
+
+        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+        self.copy_file(so_path, target_path)
+
+
+
+class AddCompileInfo(build_py):
+
+    def get_version(self):
+        version_file = os.path.join('src', 'piegy', '__version__.py')
+        with open(version_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        # Regex to extract __version__ = '...'
+        version_match = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', content, re.MULTILINE)
+        if version_match:
+            return version_match.group(1)
+        raise RuntimeError("Unable to find version string.")
+
+    def generate_build_info(self):
+        version = self.get_version()
+        build_from = os.environ.get("BUILD_TYPE", "local machine")
+        build_info_content = f'''
+        """
+        Contains build info, whether it's local built, or a pre-compiled wheel.
+        Auto-generated at compile time.
+        """
+
+        build_info = {{
+            "version": "{version}",
+            "built from": "{build_from}",
+            "build date": "{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}",
+            "python version": "{platform.python_version()}",
+            "platform": "{sys.platform}"
+        }}
+        '''
+        return textwrap.dedent(build_info_content[1:])
+    
+    
+    def run(self):
+        # Write build_info.py directly before building python files
+        build_info_path = os.path.abspath(os.path.join('src/piegy/build_info.py'))
+        with open(build_info_path, 'w') as f:
+            f.write(self.generate_build_info())
+        super().run()
+
+
+# Declare the extension module (empty sources)
+ext_modules = [
+    Extension('piegy.C_core.piegyc', sources=[])
+]
+
+setup(
+    ext_modules=ext_modules,
+    cmdclass={'build_ext': BuildSharedLib, 
+              'build_py': AddCompileInfo,},
+    package_data={"piegy": ["C_core/piegyc.so", "build_info.py"]},
+    include_package_data=True,
+)
+

piegy-2.1.8/src/piegy/C_core/Makefile

@@ -0,0 +1,97 @@
+# Compiler and flags
+CC = gcc
+
+#### Common Flags ####
+
+## Flags for Max Speed ##
+# standard
+CFLAGS_COMMON = -O3 -flto -std=c99 -DNDEBUG -ffp-contract=fast -MMD -MP
+LDFLAGS_COMMON = -flto
+
+## Flags for Debugging ##
+# slower, debuggable with lldb, with Address Sanitizer. Don't use in python
+#CFLAGS = -g -std=c99 -Wall -Wextra -MMD -MP -fsanitize=address,undefined -fno-omit-frame-pointer
+#LDFLAGS = -fsanitize=address,undefined
+# slower, regular build, allow lldb
+#CFLAGS = -g -std=c99 -Wall -Wextra -MMD -MP
+#LDFLAGS = 
+
+
+#### OS specific ####
+OS := $(shell uname)
+
+ifeq ($(OS),Darwin)
+    # macOS flags
+    CFLAGS = $(CFLAGS_COMMON) -fPIC -mmacosx-version-min=11.0 -arch arm64
+    LDFLAGS = $(LDFLAGS_COMMON)
+else ifeq ($(OS),Linux)
+    # Linux flags
+    CFLAGS = $(CFLAGS_COMMON) -fPIC 
+    LDFLAGS = $(LDFLAGS_COMMON)
+else ifeq '$(findstring ;,$(PATH))' ';'
+    # windows flags
+    CFLAGS = $(CFLAGS_COMMON) -D_WIN32_WINNT=0x0A00 -DWINVER=0x0A00
+    LDFLAGS = $(LDFLAGS_COMMON)
+else
+    # Default fallback
+    CFLAGS = $(CFLAGS_COMMON) -fPIC
+    LDFLAGS = $(LDFLAGS_COMMON)
+endif
+
+
+
+#### Targets and Commands ####
+
+# Source and object files
+SRC = sim_funcs.c model.c patch.c 
+RUNNER_SRC = runner.c
+OBJ = $(SRC:.c=.o)
+RUNNER_OBJ = $(RUNNER_SRC:.c=.o)
+RUNNER_DEPS = $(RUNNER_OBJ:.o=.d)
+DEPS = $(OBJ:.o=.d) $(RUNNER_DEPS)
+
+# Executable name
+TEST = runner
+ifeq '$(findstring ;,$(PATH))' ';'
+    # windows
+    SHARED_LIB = piegyc.dll
+else
+    SHARED_LIB = piegyc.so
+endif
+
+
+# Default target
+all: $(SHARED_LIB) $(TEST)
+
+# test file
+test: $(TEST)
+
+# shared library
+so: $(SHARED_LIB)
+
+# Link the final binary
+$(TEST): $(OBJ) $(RUNNER_OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^
+
+# Shared library target
+$(SHARED_LIB): $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -shared -o $@ $^
+
+# Compile source files to object files
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+# Clean build files
+clean:
+	rm -f $(OBJ) $(RUNNER_OBJ) $(TEST) $(SHARED_LIB) $(DEPS)
+
+# Rebuild target: clean then all
+re: clean all
+
+# Include auto-generated dependency files
+-include $(DEPS)
+
+.PHONY: all clean re test so
+
+
+

piegy-2.1.8/src/piegy/C_core/model.c

@@ -0,0 +1,108 @@
+/**
+ * This .c includes the model struct and "member functions" 
+ * that correponds to patch class in piegy.model module
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "model.h"
+
+
+bool mod_init(model_t* mod, size_t N, size_t M,
+                double maxtime, double record_itv, size_t sim_time, bool boundary,
+                const uint32_t* I, const double* X, const double* P,
+                int32_t print_pct, int32_t seed) {
+
+    mod->N = N;
+    mod->M = M;
+    mod->maxtime = maxtime;
+    mod->record_itv = record_itv;
+    mod->sim_time = sim_time;
+    mod->boundary = boundary;
+    mod->print_pct = print_pct;
+    mod->seed = seed;
+
+    size_t NM = N * M;
+
+    // I, X, P
+    mod->I = (uint32_t*) malloc(sizeof(uint32_t) * NM * 2);
+    mod->X = (double*) malloc(sizeof(double) * NM * 4);
+    mod->P = (double*) malloc(sizeof(double) * NM * 6);
+
+    if (!mod->I || !mod->X || !mod->P) return false;
+
+    memcpy(mod->I, I, sizeof(uint32_t) * NM * 2);
+    memcpy(mod->X, X, sizeof(double) * NM * 4);
+    memcpy(mod->P, P, sizeof(double) * NM * 6);
+
+    // Data
+    mod->data_empty = true;
+    mod->max_record = (size_t)(mod->maxtime / mod->record_itv);
+    mod->arr_size = NM * mod->max_record;
+    mod->compress_itv = 1;
+
+    mod->U1d     = (double*) calloc(mod->arr_size, sizeof(double));
+    mod->V1d     = (double*) calloc(mod->arr_size, sizeof(double));
+    mod->Upi_1d  = (double*) calloc(mod->arr_size, sizeof(double));
+    mod->Vpi_1d  = (double*) calloc(mod->arr_size, sizeof(double));
+
+    if (!mod->U1d || !mod->V1d || !mod->Upi_1d || !mod->Vpi_1d) {
+        fprintf(stdout, "Error: allocating memory in mod_init.\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+
+    return true;
+}
+
+
+
+void mod_free(model_t* mod) {
+    if (!mod) return;
+
+    free(mod->I);
+    free(mod->X);
+    free(mod->P);
+    free(mod->U1d);
+    free(mod->V1d);
+    free(mod->Upi_1d);
+    free(mod->Vpi_1d);
+    mod->I = NULL;
+    mod->X = mod->P = mod->U1d = mod->V1d = mod->Upi_1d = mod->Vpi_1d = NULL;
+
+    free(mod);
+}
+
+
+void mod_free_py(model_t* mod) {
+    // free function for python
+
+    if (!mod) return;
+    if (mod->I) { free(mod->I); }
+    if (mod->X) { free(mod->X); }
+    if (mod->P) { free(mod->P); }
+    if (mod->U1d) { free(mod->U1d); }
+    if (mod->V1d) { free(mod->V1d); }
+    if (mod->Upi_1d) { free(mod->Upi_1d); }
+    if (mod->Vpi_1d) { free(mod->Vpi_1d); }
+    // if (mod) { free(mod); }
+
+    mod->I = NULL;
+    mod->X = mod->P = mod->U1d = mod->V1d = mod->Upi_1d = mod->Vpi_1d = NULL;
+}
+
+
+void calculate_ave(model_t* mod) {
+    if (mod->sim_time == 1) return;
+
+    for (size_t i = 0; i < mod->arr_size; i++) {
+        mod->U1d[i]    /= mod->sim_time;
+        mod->V1d[i]    /= mod->sim_time;
+        mod->Upi_1d[i] /= mod->sim_time;
+        mod->Vpi_1d[i] /= mod->sim_time;
+    }
+}
+

piegy-2.1.8/src/piegy/C_core/model.h

@@ -0,0 +1,54 @@
+/**
+ * This .h includes the model struct and "member functions" 
+ * that correpond to patch class in piegy.model module
+*/
+#ifndef MODEL_H
+#define MODEL_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+
+typedef struct model_t {
+    size_t N;
+    size_t M;
+    double maxtime;
+    double record_itv;
+    size_t sim_time;
+
+    bool boundary;
+
+    // 3D arrays flattened to 1D for C
+    // Sizes: N * M * 2, N * M * 4, N * M * 6
+    uint32_t* I;
+    double* X;
+    double* P;
+
+    int32_t print_pct; 
+    int32_t seed;  // -1 for none
+
+    // vars for data storage
+    bool data_empty;
+    size_t max_record;
+    size_t arr_size;  // size of U, V, U_pi, V_pi, equals N * M * max_record
+    uint32_t compress_itv;
+    double* U1d;
+    double* V1d;
+    double* Upi_1d;
+    double* Vpi_1d;
+} model_t;
+
+
+bool mod_init(model_t* mod, size_t N, size_t M,
+                double maxtime, double record_itv, size_t sim_time, bool boundary,
+                const uint32_t* I, const double* X, const double* P,
+                int32_t print_pct, int32_t seed);
+void mod_free(model_t* mod);
+void mod_free_py(model_t* mod);
+void calculate_ave(model_t* mod);
+
+
+
+#endif // MODEL_H
+

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

@@ -0,0 +1,43 @@
+/**
+ * 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 i, size_t j) {
+    if (p == NULL) return;
+    p->i = i;
+    p->j = j;
+
+    p->U = U;
+    p->V = V;
+    p->U_pi = 0.0;
+    p->V_pi = 0.0;
+
+    for (size_t i = 0; i < 4; i++) {
+        p->U_weight[i] = 0.0;
+        p->V_weight[i] = 0.0;
+        p->pi_death_rates[i] = 0.0;
+    }
+    for (size_t i = 0; i < 8; i++) {
+        p->mig_rates[i] = 0.0;
+    }
+    p->sum_U_weight = 0.0;
+    p->sum_V_weight = 0.0;
+    p->sum_pi_death_rates = 0.0;
+    p->sum_mig_rates = 0.0;
+}
+
+
+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
+    for (size_t k = 0; k < 4; k++) {
+        if (nb_start[k] != NM) {
+            // neighbor is valid
+            world[ij].nb[k] = &world[nb_start[k]];
+        } else {
+            world[ij].nb[k] = NULL;
+        }
+    }
+}

piegy-2.1.8/src/piegy/C_core/patch.h

@@ -0,0 +1,43 @@
+/**
+ * This .h includes the patch struct and "member functions" 
+ * that correponds to patch class in piegy.model module
+*/
+
+#ifndef PATCH_H
+#define PATCH_H
+
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+
+// patch_t has size 33 * sizeof(size_t)
+#define SIZEOF_PATCH_T (uint32_t) (sizeof(patch_t) / sizeof(size_t))
+
+typedef struct patch_t {
+    size_t i;
+    size_t j;
+
+    uint32_t U;
+    uint32_t V;
+    double U_pi;
+    double V_pi;
+
+    struct patch_t* nb[4];
+    double U_weight[4];  // stores migration weight of each of the 4 neighbors
+    double V_weight[4];
+    double sum_U_weight; // sum of U_weight
+    double sum_V_weight;
+    double pi_death_rates[4];
+    double mig_rates[8];
+    double sum_pi_death_rates;
+    double sum_mig_rates;
+} 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);
+
+#endif // PATCH_H
+

piegy-2.1.8/src/piegy/C_core/piegyc.h

@@ -0,0 +1,49 @@
+// piegyc.h
+// piegy simulation module written in c
+#ifndef PIEGYC_H
+#define PIEGYC_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+
+typedef struct model_t {
+    size_t N;
+    size_t M;
+    double maxtime;
+    double record_itv;
+    size_t sim_time;
+
+    bool boundary;
+
+    // 3D arrays flattened to 1D for C
+    // Sizes: N * M * 2, N * M * 4, N * M * 6
+    uint32_t* I;
+    double* X;
+    double* P;
+
+    int32_t print_pct; 
+    int32_t seed;  // -1 for none
+
+    // vars for data storage
+    bool data_empty;
+    size_t max_record;
+    size_t arr_size;  // size of U, V, U_pi, V_pi, equals N * M * max_record
+    uint32_t compress_itv;
+    double* U1d;
+    double* V;
+    double* U_pi;
+    double* V_pi;
+} model_t;
+
+bool mod_init(model_t* mod, size_t N, size_t M,
+                double maxtime, double record_itv, size_t sim_time, bool boundary,
+                const uint32_t* I, const double* X, const double* P,
+                int32_t print_pct, int32_t seed);
+void mod_free_py(model_t* mod);
+
+void run(model_t* mod, char* message, size_t msg_len);
+
+
+
+#endif  // PIEGYC_H

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

@@ -0,0 +1,61 @@
+#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 = 1000;
+    double record_itv = 0.1;
+    size_t sim_time = 3;
+    bool boundary = true;
+    uint32_t I_single[2] = {200, 100};
+    double X_single[4] = {-1, 4, 0, 2};
+    double P_single[6] = {0.5, 0.5, 1, 1, 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
+    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;
+}
+