piegy 1.1.6__tar.gz → 2.0.1__tar.gz

{piegy-1.1.6/src/piegy.egg-info → piegy-2.0.1}/PKG-INFO

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

{piegy-1.1.6 → piegy-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'piegy'
-version = '1.1.6'
+version = '2.0.1'
 description = 'Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory'
 readme = 'README.md'
 requires-python = '>=3.6'
@@ -42,3 +42,7 @@ package-dir = {'' = 'src'}
 [tool.setuptools.packages.find]
 where = ['src']
 
+[tool.setuptools.package-data]
+"piegy" = ["C_core/piegyc.so"]
+
+

{piegy-1.1.6 → piegy-2.0.1}/src/piegy/__version__.py

@@ -21,4 +21,6 @@ version history:
 1.1.5: update README.
 1.1.6: change name of variables in model class -- for compatability with the new C core. 1.1.6 is the last verion of v1. From v2 on, the piegy package has C core.
 
+2.0.0: update simulation core to C-based.
+2.0.1: re-upload, the C core is not included in package.
 '''

{piegy-1.1.6 → piegy-2.0.1}/src/piegy/data_tools.py

@@ -38,24 +38,19 @@ def save_data(mod, dirs = '', print_msg = True):
         
     data = []
     
-    inputs1 = []
-    inputs1.append(mod.N)
-    inputs1.append(mod.M)
-    inputs1.append(mod.maxtime)
-    inputs1.append(mod.record_itv)
-    inputs1.append(mod.sim_time)
-    inputs1.append(mod.boundary)
-    inputs1.append(mod.I.tolist())
-    inputs1.append(mod.X.tolist())
-    inputs1.append(mod.P.tolist())
-    data.append(inputs1)
-
-    inputs2 = []
-    inputs2.append(mod.print_pct)
-    inputs2.append(mod.seed)
-    inputs2.append(mod.UV_dtype)
-    inputs2.append(mod.pi_dtype)
-    data.append(inputs2)
+    inputs = []
+    inputs.append(mod.N)
+    inputs.append(mod.M)
+    inputs.append(mod.maxtime)
+    inputs.append(mod.record_itv)
+    inputs.append(mod.sim_time)
+    inputs.append(mod.boundary)
+    inputs.append(mod.I.tolist())
+    inputs.append(mod.X.tolist())
+    inputs.append(mod.P.tolist())
+    inputs.append(mod.print_pct)
+    inputs.append(mod.seed)
+    data.append(inputs)
 
     # skipped rng
     
@@ -112,14 +107,14 @@ def read_data(dirs):
     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[1][0], seed = data[1][1], UV_dtype = data[1][2], pi_dtype = data[1][3])
+                            print_pct = data[0][9], seed = data[0][10])
     except:
         raise ValueError('Invalid input parameters saved in data')
 
     # outputs
     try:
-        mod.set_data(data_empty = False, max_record = data[2][0], compress_itv = data[2][1], 
-                    U = data[2][2], V = data[2][3], Upi = data[2][4], Vpi = data[2][5])
+        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')
     

piegy-2.0.1/src/piegy/simulation.py

@@ -0,0 +1,443 @@
+'''
+Main Module of Stochastic Simulation
+-------------------------------------------
+
+Contains all the necessary tools to build a model and run models based on Gillespie Algorithm.
+
+Classes:
+- patch:        (Private) Simulates a single patch in the N x M space. Assume no spatial structure within a patch.
+                All spatial movements are based on patches.
+- model:        Stores input parameters and data generated during simulation.
+
+
+Functions:
+- find_nb_zero_flux:        (Private) Return pointers to a patch's neighbors under zero-flux (no-boundary) boundary condition.
+- find_nb_periodical:       (Private) Return pointers to a patch's neighbors under periodical (with-booundary) boundary condition.
+- find_event:               (Private) Pick a random event to happen.
+- make_signal_zero_flux:    (Private) Expand event index (return value of find_event) to a detailed signal, under zero-flux boundary condition.
+- make_signal_periodical:   (Private) Expand event index (return value of find_event) to a detailed signal, under periodical boundary condition.
+- single_init:              (Private) Initialize a single model. Meaning of 'single': see single_test and run.
+- single_test:              (Private) Run a single model.
+                            'single' means a single round of model. You can run many single rounds and then take the average --- that's done by <run> function.
+- run:                      Run multiple models and then take the average. All the model will use the same parameters.
+                            Set a seed for reproducible results.
+- demo_model:               Returns a demo model (a model object).
+
+NOTE: Only model class and run function are intended for direct usages.
+'''
+
+
+import numpy as np
+import os
+import ctypes
+from ctypes import c_size_t, c_uint32, c_int32, c_double, c_bool, c_char_p, c_char
+import numpy as np
+from numpy.ctypeslib import ndpointer
+
+
+
+
+'''
+The C core
+'''
+
+# path to the C shared libary
+C_LIB_PATH = os.path.join(os.path.dirname(__file__), 'C_core', 'piegyc.so')
+
+
+class model_c(ctypes.Structure):
+    '''
+    The C-cored model
+    '''
+
+    _fields_ = [
+        ('N', c_size_t),
+        ('M', c_size_t),
+        ('maxtime', c_double),
+        ('record_itv', c_double),
+        ('sim_time', c_size_t),
+        ('boundary', c_bool),
+
+        ('I', ctypes.POINTER(c_uint32)),
+        ('X', ctypes.POINTER(c_double)),
+        ('P', ctypes.POINTER(c_double)),
+
+        ('print_pct', c_int32),
+        ('seed', c_int32),
+
+        ('data_empty', c_bool),
+        ('max_record', c_size_t),
+        ('arr_size', c_size_t),
+        ('compress_itv', c_uint32),
+
+        ('U1d', ctypes.POINTER(c_double)),
+        ('V1d', ctypes.POINTER(c_double)),
+        ('Upi_1d', ctypes.POINTER(c_double)),
+        ('Vpi_1d', ctypes.POINTER(c_double)),
+    ]
+    def get_array(self, name):
+        """Return internal data as NumPy array, e.g. .get_array('U')"""
+        ptr = getattr(self, name)
+        return np.ctypeslib.as_array(ptr, shape=(self.arr_size,))
+
+lib = ctypes.CDLL(C_LIB_PATH, winmode = 0)
+lib.mod_init.argtypes = [
+    ctypes.POINTER(model_c), c_size_t, c_size_t,
+    c_double, c_double, c_size_t, c_bool,
+    ndpointer(dtype=np.uint32, flags="C_CONTIGUOUS"),
+    ndpointer(dtype=np.float64, flags="C_CONTIGUOUS"),
+    ndpointer(dtype=np.float64, flags="C_CONTIGUOUS"),
+    c_int32, c_int32
+]
+lib.mod_init.restype = c_bool
+
+lib.run.argtypes = [ctypes.POINTER(model_c), ctypes.POINTER(c_char), c_size_t]
+lib.run.restype = None
+
+
+
+'''
+For access by Python
+'''             
+
+class model:
+    '''
+    Store model data and input parameters.
+    Initialize a model object to run models.
+
+    Public Class Functions:
+
+        __init__:
+            Create a model object. Also initialize data storage.
+
+        __str__:
+            Print model object in a nice way.
+
+        copy:
+            Return a deep copy of self. Can choose whether to copy data as well. Default is to copy.
+
+        clear_data:
+            clear all data stored, set U, V, Upi, Vpi to zero arrays
+
+        change_maxtime:
+            Changes maxtime of self. Update data storage as well.
+
+        set_seed:
+            Set a new seed. 
+
+        compress_data:
+            compress data by only storing average values
+    '''
+
+    def __init__(self, N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct = 25, seed = None):
+
+        self.check_valid_input(N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct)
+        
+        self.N = N                      # int, N x M is spatial dimension
+        self.M = M                      # int, can't be 1. If want to make 1D space, use N = 1. And this model doesn't work for 1x1 space (causes NaN)
+        self.maxtime = maxtime          # float or int, run model for how long time
+        self.record_itv = record_itv    # float, record data every record_itv of time
+        self.sim_time = sim_time        # int, run this many of rounds (of single_test)
+        self.boundary = boundary        # bool, the N x M space have boundary or not (i.e., zero-flux (True) or periodical (False))
+        self.I = np.array(I)            # N x M x 2 np.array, initial population. Two init-popu for every patch (U and V)
+        self.X = np.array(X)            # N x M x 4 np.array, matrices. The '4' comes from 2x2 matrix flattened to 1D
+        self.P = np.array(P)            # N x M x 6 np.array, 'patch variables', i.e., mu1&2, w1&2, kappa1&2
+        self.print_pct = print_pct      # int, print how much percent is done, need to be non-zero
+        self.seed = seed                # non-negative int, seed for random number generation
+
+        self.init_storage()             # initialize storage bins. Put in a separate function because might want to change maxtime 
+                                        # and that doesn't need to initialze the whole object again
+
+
+    def init_storage(self):
+        # initialize storage bins
+        self.data_empty = True      # whether data storage bins are empty. model.run will refuse to run (raise error) if not empty.
+        self.max_record = int(self.maxtime / self.record_itv)   # int, how many data points to store sin total
+        self.compress_itv = 1       # int, intended to reduce size of data (if not 1). Updated by compress_data function
+                                    # if set to an int, say 20, mod will take average over every 20 data points and save them as new data.
+                                    # May be used over and over again to recursively reduce data size. 
+                                    # Default is 1, not to take average.
+        self.U = None               # initialized by simulation.run or data_tools.read_data
+        self.V = None
+        self.Upi = None
+        self.Vpi = None
+
+
+    def check_valid_input(self, N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct):
+        # check whether the inputs are valid
+
+        if (N < 1) or (M < 1):
+            raise ValueError('N < 1 or M < 1')
+        if (N == 1) and (M == 1):
+            raise ValueError('Model fails for 1x1 space')
+        if (M == 1):
+            raise ValueError('Please set N = 1 for 1D space.')
+        if maxtime <= 0:
+            raise ValueError('Please set a positive number for maxtime')
+        if record_itv <= 0:
+            raise ValueError('Please set a positive number for record_itv')
+        if sim_time <= 0:
+            raise ValueError('Please set a positive number for sim_time')
+        if type(boundary) != bool:
+            raise TypeError('boundary not a bool. Please use True for zero-flux (with boundary) or False for periodical (no boundary)')
+        
+        if (type(I) != list) and (type(I) != np.ndarray):
+            raise TypeError('Please set I as a list or np.ndarray')
+        if np.array(I).shape != (N, M, 2):
+            raise ValueError('Please set I as a N x M x 2 shape list or array. 2 is for init values of U, V at every patch')
+        
+        if (type(X) != list) and (type(X) != np.ndarray):
+            raise TypeError('Please set X as a list or np.ndarray')
+        if np.array(X).shape != (N, M, 4):
+            raise ValueError('Please set X as a N x M x 4 shape list or array. 4 is for the flattened 2x2 payoff matrix')
+        
+        if (type(P) != list) and (type(P) != np.ndarray):
+            raise TypeError('Please set P as a list or np.ndarray')
+        if np.array(P).shape != (N, M, 6):
+            raise ValueError('Please set P as a N x M x 6 shape list or array. 6 is for mu1, mu2, w1, w2, kappa1, kappa2')
+        
+        if print_pct <= 0:
+            raise ValueError('Please use an int > 0 for print_pct or None for not printing progress.')
+        
+
+    def check_valid_data(self, data_empty, max_record, compress_itv):
+        # check whether a set of data is valid, used when reading a saved model
+        if type(data_empty) != bool:
+            raise TypeError('data_empty not a bool')
+        
+        if type(max_record) != int:
+            raise TypeError('max_record not an int')
+        if max_record < 0:
+            raise ValueError('max_record < 0')
+        
+        if type(compress_itv) != int:
+            raise TypeError('compress_itv not an int')
+        if compress_itv < 0:
+            raise ValueError('compress_itv < 0')
+   
+
+    def __str__(self):
+        # print this mod in a nice format
+
+        self_str = ''
+        self_str += 'N = ' + str(self.N) + '\n'
+        self_str += 'M = ' + str(self.M) + '\n'
+        self_str += 'maxtime = ' + str(self.maxtime) + '\n'
+        self_str += 'record_itv = ' + str(self.record_itv) + '\n'
+        self_str += 'sim_time = ' + str(self.sim_time) + '\n'
+        self_str += 'boundary = ' + str(self.boundary) + '\n'
+        self_str += 'print_pct = ' + str(self.print_pct) + '\n'
+        self_str += 'seed = ' + str(self.seed) + '\n'
+        self_str += 'data_empty = ' + str(self.data_empty) + '\n'
+        self_str += 'compress_itv = ' + str(self.compress_itv) + '\n'
+        self_str += '\n'
+
+        # check whether I, X, P all same (compare all patches to (0, 0))
+        I_same = True
+        X_same = True
+        P_same = True
+        for i in range(self.N):
+            for j in range(self.M):
+                for k in range(2):
+                    if self.I[i][j][k] != self.I[0][0][k]:
+                        I_same = False
+                for k in range(4):
+                    if self.X[i][j][k] != self.X[0][0][k]:
+                        X_same = False
+                for k in range(6):
+                    if self.P[i][j][k] != self.P[0][0][k]:
+                        P_same = False
+        
+        if I_same:
+            self_str += 'I all same: ' + str(self.I[0][0]) + '\n'
+        else:
+            self_str += 'I:\n'
+            for i in range(self.N):
+                for j in range(self.M):
+                    self_str += str(self.I[i][j]) + ' '
+                self_str += '\n'
+            self_str += '\n'
+        
+        if X_same:
+            self_str += 'X all same: ' + str(self.X[0][0]) + '\n'
+        else:
+            self_str += 'X:\n'
+            for i in range(self.N):
+                for j in range(self.M):
+                    self_str += str(self.X[i][j]) + ' '
+                self_str += '\n'
+            self_str += '\n'
+
+        if P_same:
+            self_str += 'P all same: ' + str(self.P[0][0]) + '\n'
+        else:
+            self_str += 'P:\n'
+            for i in range(self.N):
+                for j in range(self.M):
+                    self_str += str(self.P[i][j]) + ' '
+                self_str += '\n'
+
+        return self_str
+    
+
+    def copy(self, copy_data = True):
+        # return deep copy of self
+        # copy_data decides whether to copy data as well
+        if type(copy_data) != bool:
+            raise TypeError('Please give a bool as argument: whether to copy data or not')
+
+        sim2 = model(N = self.N, M = self.M, maxtime = self.maxtime, record_itv = self.record_itv, sim_time = self.sim_time, boundary = self.boundary,
+                          I = np.copy(self.I), X = np.copy(self.X), P = np.copy(self.P), 
+                          print_pct = self.print_pct, seed = self.seed)
+
+        if copy_data:
+            # copy data as well
+            sim2.set_data(self.data_empty, self.max_record, self.compress_itv, self.U, self.V, self.Upi, self.Vpi)
+
+        return sim2
+
+
+    def calculate_ave(self):
+        # get the average value over sim_time many models
+        if self.sim_time != 1:
+            for i in range(self.N):
+                for j in range(self.M):
+                    for t in range(self.max_record):
+                        self.U[i][j][t] /= self.sim_time
+                        self.V[i][j][t] /= self.sim_time
+                        self.Upi[i][j][t] /= self.sim_time
+                        self.Vpi[i][j][t] /= self.sim_time
+
+
+    def change_maxtime(self, maxtime):
+        # change maxtime
+        if (type(maxtime) != float) and (type(maxtime) != int):
+            raise TypeError('Please pass in a float or int as the new maxtime.')
+        if maxtime <= 0:
+            raise ValueError('Please use a positive maxtime.')
+        self.maxtime = maxtime
+        self.init_storage()
+
+
+    def set_seed(self, seed):
+        # set seed
+        self.seed = seed
+
+
+    def clear_data(self):
+        # clear all data stored, set all to 0
+        self.init_storage()
+
+
+    def set_data(self, data_empty, max_record, compress_itv, U, V, Upi, Vpi):
+        # set data to the given data values
+        # copies are made
+        self.check_valid_data(data_empty, max_record, compress_itv)
+
+        self.data_empty = data_empty
+        self.max_record = max_record
+        self.compress_itv = compress_itv
+        self.U = np.copy(U)
+        self.V = np.copy(V)
+        self.Upi = np.copy(Upi)
+        self.Vpi = np.copy(Vpi)
+
+
+    def compress_data(self, compress_itv = 5):
+        # compress data by only storing average values
+        if self.data_empty:
+            raise RuntimeError('Model has empty data. Cannot compress')
+
+        if type(compress_itv) != int:
+            raise TypeError('Please use an int as compress_itv')
+        if compress_itv < 1:
+            raise ValueError('Please use record_itv >= 1')
+        if compress_itv == 1:
+            return
+        
+        self.compress_itv *= compress_itv  # may be reduced over and over again
+        self.max_record = int(self.max_record / compress_itv)  # number of data points after reducing
+
+        U_reduced = np.zeros((self.N, self.M, self.max_record), dtype = np.float64)
+        V_reduced = np.zeros((self.N, self.M, self.max_record), dtype = np.float64)
+        Upi_reduced = np.zeros((self.N, self.M, self.max_record), dtype = np.float64)
+        Vpi_reduced = np.zeros((self.N, self.M, self.max_record), dtype = np.float64)
+
+        for i in range(self.N):
+            for j in range(self.M):
+                for k in range(self.max_record):
+                    lower = k * compress_itv  # upper and lower bound of current record_itv
+                    upper = lower + compress_itv
+                    U_reduced[i][j][k] = np.mean(self.U[i, j, lower : upper])
+                    V_reduced[i][j][k] = np.mean(self.V[i, j, lower : upper])
+                    Upi_reduced[i][j][k] = np.mean(self.Upi[i, j, lower : upper])
+                    Vpi_reduced[i][j][k] = np.mean(self.Vpi[i, j, lower : upper])
+        
+        self.U = U_reduced
+        self.V = V_reduced
+        self.Upi = Upi_reduced
+        self.Vpi = Vpi_reduced
+
+
+
+def run(mod, message = ""):
+    '''
+    C-cored simulation
+    '''
+    msg_len = len(message)
+    msg_bytes = message.encode('utf-8')
+    msg_buffer = ctypes.create_string_buffer(msg_bytes, msg_len) 
+    
+    I = np.ascontiguousarray(mod.I.flatten(), dtype = np.uint32)
+    X = np.ascontiguousarray(mod.X.flatten(), dtype = np.float64)
+    P = np.ascontiguousarray(mod.P.flatten(), dtype = np.float64)
+
+    mod_c = model_c()
+    success = lib.mod_init(ctypes.byref(mod_c), 
+                           mod.N, mod.M, mod.maxtime, mod.record_itv, mod.sim_time, mod.boundary,
+                           I, X, P, mod.print_pct, mod.seed)
+    if not success:
+        raise RuntimeError("mod_init failed")
+    
+    lib.run(ctypes.byref(mod_c), msg_buffer, msg_len)
+    
+    mod.data_empty = False
+    mod.U = mod_c.get_array('U1d').reshape(mod.N, mod.M, mod.max_record)
+    mod.V = mod_c.get_array('V1d').reshape(mod.N, mod.M, mod.max_record)
+    mod.Upi = mod_c.get_array('Upi_1d').reshape(mod.N, mod.M, mod.max_record)
+    mod.Vpi = mod_c.get_array('Vpi_1d').reshape(mod.N, mod.M, mod.max_record)
+
+
+
+def demo_model():
+    '''
+    Returns a demo model.model object
+    '''
+
+    N = 10                  # Number of rows
+    M = 10                  # Number of cols
+    maxtime = 300           # how long you want the model to run
+    record_itv = 0.1        # how often to record data.
+    sim_time = 1            # repeat model to reduce randomness
+    boundary = True         # boundary condition.
+
+    # initial population for the N x M patches. 
+    I = [[[44, 22] for _ in range(M)] for _ in range(N)]
+    
+    # flattened payoff matrices, total resource is 0.4, cost of fighting is 0.1
+    X = [[[-0.1, 0.4, 0, 0.2] for _ in range(M)] for _ in range(N)]
+    
+    # patch variables
+    P = [[[0.5, 0.5, 200, 200, 0.001, 0.001] for _ in range(M)] for _ in range(N)]
+
+    print_pct = 5           # print progress
+    seed = 36               # seed for random number generation
+
+    # create a model object
+    mod = model(N, M, maxtime, record_itv, sim_time, boundary, I, X, P, 
+                            print_pct = print_pct, seed = seed)
+    
+    return mod
+
+
+

piegy-1.1.6/src/piegy/simulation.py → piegy-2.0.1/src/piegy/simulation_py.py

@@ -1,47 +1,17 @@
 '''
-Main Module of Stochastic Simulation
--------------------------------------------
-
-Contains all the necessary tools to build a model and run models based on Gillespie Algorithm.
-
-Classes:
-- patch:        (Private) Simulates a single patch in the N x M space. Assume no spatial structure within a patch.
-                All spatial movements are based on patches.
-- model:        Stores input parameters and data generated during simulation.
-
-
-Functions:
-- find_nb_zero_flux:        (Private) Return pointers to a patch's neighbors under zero-flux (no-boundary) boundary condition.
-- find_nb_periodical:       (Private) Return pointers to a patch's neighbors under periodical (with-booundary) boundary condition.
-- find_event:               (Private) Pick a random event to happen.
-- make_signal_zero_flux:    (Private) Expand event index (return value of find_event) to a detailed signal, under zero-flux boundary condition.
-- make_signal_periodical:   (Private) Expand event index (return value of find_event) to a detailed signal, under periodical boundary condition.
-- single_init:              (Private) Initialize a single model. Meaning of 'single': see single_test and run.
-- single_test:              (Private) Run a single model.
-                            'single' means a single round of model. You can run many single rounds and then take the average --- that's done by <run> function.
-- run:                      Run multiple models and then take the average. All the model will use the same parameters.
-                            Set a seed for reproducible results.
-- demo_model:               Returns a demo model (a model object).
-
-NOTE: Only model class and run function are intended for direct usages.
+Functions and class below are for Python-based simulations. Not maintained after v1.1.6 on Jun 26, 2025.
+But you can still run them by calling:
+
+>>> run_py(mod)
 '''
 
+from . import simulation
 
 import math
 import numpy as np
 from timeit import default_timer as timer
 
 
-# data type used by model.U and model.V
-UV_DTYPE = 'float64'
-
-# data type used by model.Upi and V_pi
-PI_DTYPE = 'float64'
-
-# data type for storing rates in single_test an single_init
-RATES_DTYPE = 'float64'
-
-
 class patch:
     '''
     A single patch in the N x M space.
@@ -63,7 +33,7 @@ class patch:
             Set pointers to neighbors of this patch object.
 
         update_pi:
-            Update Upi, V_pi and payoff rates (payoff rates are the first two numbers in self.pi_death_rates).
+            Update Upi, Vpi and payoff rates (payoff rates are the first two numbers in self.pi_death_rates).
         
         update_k:
             Update natural death rates (the last two numbers in self.pi_death_rates).
@@ -248,291 +218,6 @@ class patch:
                 self.V += 1
             elif self.V > 0:
                 self.V -= 1
-                
-
-
-class model:
-    '''
-    Store model data and input parameters.
-    Initialize a model object to run models.
-
-    Public Class Functions:
-
-        __init__:
-            Create a model object. Also initialize data storage.
-
-        __str__:
-            Print model object in a nice way.
-
-        copy:
-            Return a deep copy of self. Can choose whether to copy data as well. Default is to copy.
-
-        clear_data:
-            clear all data stored, set U, V, Upi, V_pi to zero arrays
-
-        change_maxtime:
-            Changes maxtime of self. Update data storage as well.
-
-        set_seed:
-            Set a new seed. 
-
-        compress_data:
-            compress data by only storing average values
-    '''
-
-    def __init__(self, N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct = 25, seed = None, UV_dtype = UV_DTYPE, pi_dtype = PI_DTYPE):
-
-        self.check_valid_input(N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct)
-        
-        self.N = N                      # int, N x M is spatial dimension
-        self.M = M                      # int, can't be 1. If want to make 1D space, use N = 1. And this model doesn't work for 1x1 space (causes NaN)
-        self.maxtime = maxtime          # float or int, run model for how long time
-        self.record_itv = record_itv        # float, record data every record_itv of time
-        self.sim_time = sim_time        # int, run this many of rounds (of single_test)
-        self.boundary = boundary        # bool, the N x M space have boundary or not (i.e., zero-flux (True) or periodical (False))
-        self.I = np.array(I)            # N x M x 2 np.array, initial population. Two init-popu for every patch (U and V)
-        self.X = np.array(X)            # N x M x 4 np.array, matrices. The '4' comes from 2x2 matrix flattened to 1D
-        self.P = np.array(P)            # N x M x 6 np.array, 'patch variables', i.e., mu1&2, w1&2, kappa1&2
-        self.print_pct = print_pct      # int, print how much percent is done, need to be non-zero
-        self.seed = seed                # non-negative int, seed for random generator
-        self.UV_dtype = UV_dtype        # what data type to store population, should be a float format. This value is passed to np.array. 
-                                        # Default is 'float64', use lower accuracy to reduce data size.
-        self.pi_dtype = pi_dtype        # what data type to store payoff, should be a float format. This value is passed to np.array. 
-                                        # Default is 'float64'
-
-        self.init_storage()                         # initialize storage bins. Put in a separate function because might want to change maxtime 
-                                                    # and that doesn't need to initialze the whole object again
-
-
-    def init_storage(self):
-        # initialize storage bins
-        self.data_empty = True                      # whether data storage bins are empty. model.run will refuse to run (raise error) if not empty.
-        self.max_record = int(self.maxtime / self.record_itv)                         # int, how many data points to store sin total
-        self.compress_itv = 1                       # int, intended to reduce size of data (if not 1). Updated by compress_data function
-                                                    # if set to an int, say 20, mod will take average over every 20 data points and save them as new data.
-                                                    # May be used over and over again to recursively reduce data size. 
-                                                    # Default is 1, not to take average.
-        self.U = np.zeros((self.N, self.M, self.max_record), dtype = self.UV_dtype)      # N x M x max_record np.array, float32, stores population of U in every patch over tiem
-        self.V = np.zeros((self.N, self.M, self.max_record), dtype = self.UV_dtype)
-        self.Upi = np.zeros((self.N, self.M, self.max_record), dtype = self.pi_dtype)   # similar to U, but for U's payoff and float 64
-        self.Vpi = np.zeros((self.N, self.M, self.max_record), dtype = self.pi_dtype)
-
-
-    def check_valid_input(self, N, M, maxtime, record_itv, sim_time, boundary, I, X, P, print_pct):
-        # check whether the inputs are valid
-        # seed, UV_dtype, pi_dtype is handled by numpy
-
-        if (N < 1) or (M < 1):
-            raise ValueError('N < 1 or M < 1')
-        if (N == 1) and (M == 1):
-            raise ValueError('Model fails for 1x1 space')
-        if (M == 1):
-            raise ValueError('Please set N = 1 for 1D space.')
-        if maxtime <= 0:
-            raise ValueError('Please set a positive number for maxtime')
-        if record_itv <= 0:
-            raise ValueError('Please set a positive number for record_itv')
-        if sim_time <= 0:
-            raise ValueError('Please set a positive number for sim_time')
-        if type(boundary) != bool:
-            raise TypeError('boundary not a bool. Please use True for zero-flux (with boundary) or False for periodical (no boundary)')
-        
-        if (type(I) != list) and (type(I) != np.ndarray):
-            raise TypeError('Please set I as a list or np.ndarray')
-        if np.array(I).shape != (N, M, 2):
-            raise ValueError('Please set I as a N x M x 2 shape list or array. 2 is for init values of U, V at every patch')
-        
-        if (type(X) != list) and (type(X) != np.ndarray):
-            raise TypeError('Please set X as a list or np.ndarray')
-        if np.array(X).shape != (N, M, 4):
-            raise ValueError('Please set X as a N x M x 4 shape list or array. 4 is for the flattened 2x2 payoff matrix')
-        
-        if (type(P) != list) and (type(P) != np.ndarray):
-            raise TypeError('Please set P as a list or np.ndarray')
-        if np.array(P).shape != (N, M, 6):
-            raise ValueError('Please set P as a N x M x 6 shape list or array. 6 is for mu1, mu2, w1, w2, kappa1, kappa2')
-        
-        if print_pct <= 0:
-            raise ValueError('Please use an int > 0 for print_pct or None for not printing progress.')
-        
-
-    def check_valid_data(self, data_empty, max_record, compress_itv):
-        # check whether a set of data is valid, used when reading a saved model
-        if type(data_empty) != bool:
-            raise TypeError('data_empty not a bool')
-        
-        if type(max_record) != int:
-            raise TypeError('max_record not an int')
-        if max_record < 0:
-            raise ValueError('max_record < 0')
-        
-        if type(compress_itv) != int:
-            raise TypeError('compress_itv not an int')
-        if compress_itv < 0:
-            raise ValueError('compress_itv < 0')
-   
-
-    def __str__(self):
-        # print this mod in a nice format
-
-        self_str = ''
-        self_str += 'N = ' + str(self.N) + '\n'
-        self_str += 'M = ' + str(self.M) + '\n'
-        self_str += 'maxtime = ' + str(self.maxtime) + '\n'
-        self_str += 'record_itv = ' + str(self.record_itv) + '\n'
-        self_str += 'sim_time = ' + str(self.sim_time) + '\n'
-        self_str += 'boundary = ' + str(self.boundary) + '\n'
-        self_str += 'print_pct = ' + str(self.print_pct) + '\n'
-        self_str += 'seed = ' + str(self.seed) + '\n'
-        self_str += 'UV_dtype = \'' + self.UV_dtype + '\'\n'
-        self_str += 'pi_dtype = \'' + self.pi_dtype + '\'\n'
-        self_str += 'compress_itv = ' + str(self.compress_itv) + '\n'
-        self_str += '\n'
-
-        # check whether I, X, P all same (compare all patches to (0, 0))
-        I_same = True
-        X_same = True
-        P_same = True
-        for i in range(self.N):
-            for j in range(self.M):
-                for k in range(2):
-                    if self.I[i][j][k] != self.I[0][0][k]:
-                        I_same = False
-                for k in range(4):
-                    if self.X[i][j][k] != self.X[0][0][k]:
-                        X_same = False
-                for k in range(6):
-                    if self.P[i][j][k] != self.P[0][0][k]:
-                        P_same = False
-        
-        if I_same:
-            self_str += 'I all same: ' + str(self.I[0][0]) + '\n'
-        else:
-            self_str += 'I:\n'
-            for i in range(self.N):
-                for j in range(self.M):
-                    self_str += str(self.I[i][j]) + ' '
-                self_str += '\n'
-            self_str += '\n'
-        
-        if X_same:
-            self_str += 'X all same: ' + str(self.X[0][0]) + '\n'
-        else:
-            self_str += 'X:\n'
-            for i in range(self.N):
-                for j in range(self.M):
-                    self_str += str(self.X[i][j]) + ' '
-                self_str += '\n'
-            self_str += '\n'
-
-        if P_same:
-            self_str += 'P all same: ' + str(self.P[0][0]) + '\n'
-        else:
-            self_str += 'P:\n'
-            for i in range(self.N):
-                for j in range(self.M):
-                    self_str += str(self.P[i][j]) + ' '
-                self_str += '\n'
-
-        return self_str
-    
-
-    def copy(self, copy_data = True):
-        # return deep copy of self
-        # copy_data decides whether to copy data as well
-        if type(copy_data) != bool:
-            raise TypeError('Please give a bool as argument: whether to copy data or not')
-
-        sim2 = model(N = self.N, M = self.M, maxtime = self.maxtime, record_itv = self.record_itv, sim_time = self.sim_time, boundary = self.boundary,
-                          I = np.copy(self.I), X = np.copy(self.X), P = np.copy(self.P), 
-                          print_pct = self.print_pct, seed = self.seed, UV_dtype = self.UV_dtype, pi_dtype = self.pi_dtype)
-
-        if copy_data:
-            # copy data as well
-            sim2.set_data(self.data_empty, self.max_record, self.compress_itv, self.U, self.V, self.Upi, self.Vpi)
-
-        return sim2
-
-
-    def calculate_ave(self):
-        # get the average value over sim_time many models
-        if self.sim_time != 1:
-            for i in range(self.N):
-                for j in range(self.M):
-                    for t in range(self.max_record):
-                        self.U[i][j][t] /= self.sim_time
-                        self.V[i][j][t] /= self.sim_time
-                        self.Upi[i][j][t] /= self.sim_time
-                        self.Vpi[i][j][t] /= self.sim_time
-
-
-    def change_maxtime(self, maxtime):
-        # change maxtime
-        if (type(maxtime) != float) and (type(maxtime) != int):
-            raise TypeError('Please pass in a float or int as the new maxtime.')
-        if maxtime <= 0:
-            raise ValueError('Please use a positive maxtime.')
-        self.maxtime = maxtime
-        self.init_storage()
-
-
-    def set_seed(self, seed):
-        # set seed
-        self.seed = seed
-
-
-    def clear_data(self):
-        # clear all data stored, set all to 0
-        self.init_storage()
-
-
-    def set_data(self, data_empty, max_record, compress_itv, U, V, Upi, V_pi):
-        # set data to the given data values
-        # copies are made
-        self.check_valid_data(data_empty, max_record, compress_itv)
-
-        self.data_empty = data_empty
-        self.max_record = max_record
-        self.compress_itv = compress_itv
-        self.U = np.copy(U)
-        self.V = np.copy(V)
-        self.Upi = np.copy(Upi)
-        self.Vpi = np.copy(V_pi)
-
-
-    def compress_data(self, compress_itv = 5):
-        # compress data by only storing average values
-        
-        if type(compress_itv) != int:
-            raise TypeError('Please use an int as compress_itv')
-        if compress_itv < 1:
-            raise ValueError('Please use record_itv >= 1')
-        if compress_itv == 1:
-            return
-        
-        self.compress_itv *= compress_itv  # may be reduced over and over again
-        self.max_record = int(self.max_record / compress_itv)  # number of data points after reducing
-
-        U_reduced = np.zeros((self.N, self.M, self.max_record), dtype = self.UV_dtype)
-        V_reduced = np.zeros((self.N, self.M, self.max_record), dtype = self.UV_dtype)
-        Upi_reduced = np.zeros((self.N, self.M, self.max_record), dtype = self.pi_dtype)
-        V_pi_reduced = np.zeros((self.N, self.M, self.max_record), dtype = self.pi_dtype)
-
-        for i in range(self.N):
-            for j in range(self.M):
-                for k in range(self.max_record):
-                    lower = k * compress_itv  # upper and lower bound of current record_itv
-                    upper = lower + compress_itv
-                    U_reduced[i][j][k] = np.mean(self.U[i, j, lower : upper])
-                    V_reduced[i][j][k] = np.mean(self.V[i, j, lower : upper])
-                    Upi_reduced[i][j][k] = np.mean(self.Upi[i, j, lower : upper])
-                    V_pi_reduced[i][j][k] = np.mean(self.Vpi[i, j, lower : upper])
-        
-        self.U = U_reduced
-        self.V = V_reduced
-        self.Upi = Upi_reduced
-        self.Vpi = V_pi_reduced
-
 
 
 
@@ -824,8 +509,8 @@ def single_init(mod, rng):
     #### Initialize Data Storage ####
 
     world = [[patch(mod.I[i][j][0], mod.I[i][j][1], mod.X[i][j], mod.P[i][j]) for j in range(mod.M)] for i in range(mod.N)]  # N x M patches
-    patch_rates = np.zeros((mod.N, mod.M), dtype = RATES_DTYPE)  # every patch's sum-of-12-srates
-    sum_rates_by_row = np.zeros((mod.N), dtype = RATES_DTYPE)  # every row's sum-of-patch, i.e., sum of 12 * M rates in every row.
+    patch_rates = np.zeros((mod.N, mod.M), dtype = np.float64)  # every patch's sum-of-12-srates
+    sum_rates_by_row = np.zeros((mod.N), dtype = np.float64)  # every row's sum-of-patch, i.e., sum of 12 * M rates in every row.
     sum_rates = 0  # sum of all N x M x 12 rates
 
     signal = None
@@ -1058,7 +743,7 @@ def single_test(mod, front_info, end_info, update_sum_frequency, rng):
 
 
 
-def run(mod, predict_runtime = False, message = ''):
+def run_py(mod, predict_runtime = False, message = ''):
     '''
     Main function. Recursively calls single_test to run many models and then takes the average.
 
@@ -1120,36 +805,4 @@ def run(mod, predict_runtime = False, message = ''):
 
 
 
-def demo_model():
-    '''
-    Returns a demo model.model object
-    '''
-
-    N = 10                  # Number of rows
-    M = 10                  # Number of cols
-    maxtime = 300           # how long you want the model to run
-    record_itv = 0.1        # how often to record data.
-    sim_time = 1            # repeat model to reduce randomness
-    boundary = True         # boundary condition.
-
-    # initial population for the N x M patches. 
-    I = [[[44, 22] for _ in range(M)] for _ in range(N)]
-    
-    # flattened payoff matrices, total resource is 0.4, cost of fighting is 0.1
-    X = [[[-0.1, 0.4, 0, 0.2] for _ in range(M)] for _ in range(N)]
-    
-    # patch variables
-    P = [[[0.5, 0.5, 200, 200, 0.001, 0.001] for _ in range(M)] for _ in range(N)]
-
-    print_pct = 5           # print progress
-    seed = 36               # seed for random number generation
-    UV_dtype = 'float32'    # data type for population
-    pi_dyna = 'float64'    # data type for payoff
-
-    # create a model object
-    mod = model(N, M, maxtime, record_itv, sim_time, boundary, I, X, P, 
-                            print_pct = print_pct, seed = seed, UV_dtype = UV_dtype, pi_dtype = pi_dyna)
-    
-    return mod
-
 

{piegy-1.1.6 → piegy-2.0.1}/src/piegy/test_var.py

@@ -88,7 +88,7 @@ def test_var1(mod, var, values, dirs, compress_itv = None, predict_runtime = Fal
                 sim2.P[i][j][PATCH_VAR_DICT[var]] = values[k]
 
         try:
-            simulation.run(sim2, predict_runtime, message = current_var_str + ', ')
+            simulation.run(sim2, message = current_var_str + ', ')
             if compress_itv != None:
                 sim2.compress_data(compress_itv)
             data_t.save_data(sim2, var_dirs[k], print_msg = False)
@@ -135,7 +135,7 @@ def test_var2(mod, var1, var2, values1, values2, dirs, compress_itv = None, pred
                     sim2.P[i][j][PATCH_VAR_DICT[var2]] = values2[k2]
 
             try:
-                simulation.run(sim2, predict_runtime, message = current_var_str + ', ')
+                simulation.run(sim2, message = current_var_str + ', ')
                 if compress_itv != None:
                     sim2.compress_data(compress_itv)
                 data_t.save_data(sim2, var_dirs[k1][k2], print_msg = False)

{piegy-1.1.6 → piegy-2.0.1/src/piegy.egg-info}/PKG-INFO

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

{piegy-1.1.6 → piegy-2.0.1}/src/piegy.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/piegy/analysis.py
 src/piegy/data_tools.py
 src/piegy/figures.py
 src/piegy/simulation.py
+src/piegy/simulation_py.py
 src/piegy/test_var.py
 src/piegy/videos.py
 src/piegy.egg-info/PKG-INFO
@@ -15,6 +16,7 @@ src/piegy.egg-info/SOURCES.txt
 src/piegy.egg-info/dependency_links.txt
 src/piegy.egg-info/requires.txt
 src/piegy.egg-info/top_level.txt
+src/piegy/C_core/piegyc.so
 src/piegy/tools/__init__.py
 src/piegy/tools/figure_tools.py
 src/piegy/tools/file_tools.py