piegy 2.1.0__cp311-cp311-macosx_11_0_arm64.whl

piegy/C_core/Makefile

@@ -0,0 +1,100 @@
+# Compiler and flags
+CC = gcc
+
+#### Common Flags ####
+
+## Flags for Max Speed ##
+# standard
+CFLAGS_COMMON = -O3 -flto -std=c99 -DNDEBUG -ffp-contract=fast
+LDFLAGS_COMMON = -flto
+
+## Flags for Debugging ##
+# slower, debuggable with lldb, with Address Sanitizer. Don't use in python
+#CFLAGS = -g -std=c99 -Wall -Wextra -fsanitize=address,undefined -fno-omit-frame-pointer
+#LDFLAGS = -fsanitize=address,undefined
+# slower, regular build, allow lldb
+#CFLAGS = -g -std=c99 -Wall -Wextra
+#LDFLAGS = 
+
+# Enable auto header dependency tracking
+DEPFLAGS = -MMD -MP
+CFLAGS += $(DEPFLAGS)
+
+
+#### OS specific ####
+UNAME_S := $(shell uname -s)
+
+ifeq ($(UNAME_S),Darwin)
+    # macOS-specific flags
+    CFLAGS = $(CFLAGS_COMMON) -fPIC -mmacosx-version-min=11.0 -arch arm64 $(DEPFLAGS)
+    LDFLAGS = $(LDFLAGS_COMMON)
+else ifeq ($(UNAME_S),Linux)
+    # Linux-specific flags
+    CFLAGS = $(CFLAGS_COMMON) -fPIC $(DEPFLAGS)
+    LDFLAGS = $(LDFLAGS_COMMON)
+else ifeq ($(UNAME_S),Windows_NT)
+    # Windows-specific flags
+    CFLAGS = $(CFLAGS_COMMON) -D_WIN32_WINNT=0x0A00 -DWINVER=0x0A00 $(DEPFLAGS)
+    LDFLAGS = $(LDFLAGS_COMMON)
+else
+    # Default fallback
+    CFLAGS = $(CFLAGS_COMMON) -fPIC $(DEPFLAGS)
+    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 ($(OS),Windows_NT)
+    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) $(LDFLAGS) -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/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/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/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/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/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/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;
+}
+