def __init__(self, id, parameters):
self.id = id
self.rng = RVGs.RNG(seed=id)
self.params = parameters
self.gillespie = Markov.Gillespie(
transition_rate_matrix=parameters.rateMatrix)
self.stateMonitor = PatientStateMonitor(parameters=parameters)
def __init__(self, id, parameters):
""" initiates a patient
:param id: ID of the patient
:param parameters: an instance of the parameters class
"""
self.id = id
self.rng = RVGs.RNG(seed=id)
self.params = parameters
self.stateMonitor = PatientStateMonitor(parameters=parameters)
def __init__(self, id, trans_rate_matrix):
""" initiates a patient
:param id: ID of the patient
:param trans_rate_matrix: transition rate matrix
"""
self.id = id
self.rng = RVGs.RNG(seed=id) # random number generator for this patient
# gillespie algorithm
self.gillespie = Markov.Gillespie(transition_rate_matrix=trans_rate_matrix)
self.stateMonitor = PatientStateMonitor() # patient state monitor
def __populate_parameter_sets(self, diagnostic):
# create a parameter set generator
param_generator = ParameterGenerator(diagnostic=diagnostic)
# create as many sets of parameters as the number of cohorts
for i in range(len(self.ids)):
# create a new random number generator for each parameter set
rng = RVGs.RNG(seed=i)
# get and store a new set of parameter
self.param_sets.append(param_generator.get_new_parameters(rng=rng))
def __init__(self, id, parameters):
""" initiates a patient
:param id: ID of the patient
:param parameters: an instance of the parameters class
"""
self.id = id
self.rng = RVGs.RNG(
seed=id) # random number generator for this patient
self.params = parameters
# gillespie algorithm
self.gillespie = Markov.Gillespie(
transition_rate_matrix=parameters.rateMatrix)
self.stateMonitor = PatientStateMonitor(
parameters=parameters) # patient state monitor
def get_obj_value(self, x, seed_index=0):
""" returns one realization from x^2+noise """
# create a random number generator
rng = RVGs.RNG(seed=seed_index)
accum_penalty = 0 # accumulated penalty
# test the feasibility
if x[1] < 1:
accum_penalty += self._penalty * pow(x[1] - 1, 2)
x[1] = 1
return (x[0] + 1) * (x[0] + 1) + x[1] * x[1] + self._err.sample(
rng) + accum_penalty
from tests.ProbDistributions import RVGtests as Tests
import SimPy.RandomVariantGenerators as rndSupport
# use numpy random number generator
rng = rndSupport.RNG(1)
print('')
# tests
Tests.test_rng(rng)
Tests.test_bernoulli(rng, p=.2)
Tests.test_beta(rng, a=2, b=5, loc=1,scale=2)
Tests.test_exponential(rng, scale=10, loc=1)
Tests.test_beta_binomial(rng, n=100, a=2, b=3, loc=1, scale=2)
Tests.test_binomial(rng, n=1000, p=.2, loc=1)
Tests.test_dirichlet(rng, a=[1, 2, 3])
Tests.test_empirical(rng, prob=[0.2, 0.2, 0.6])
Tests.test_gamma(rng, a=2, scale=4, loc=1)
Tests.test_gamma_poisson(rng, a=2, gamma_scale=4, loc=1, scale=1)
Tests.test_geometric(rng, p=.2, loc=1)
Tests.test_johnsonsb(rng, a=10, b=3, loc=10, scale=100)
Tests.test_johnsonsu(rng, a=10, b=3, loc=1, scale=2)
Tests.test_lognormal(rng, s=0.2, loc=2, scale=1.1)
Tests.test_multinomial(rng, n=1000, pvals=.2)
Tests.test_negative_binomial(rng, n=10, p=.2, loc=1)
Tests.test_normal(rng, loc=5, scale=1.2)
Tests.test_poisson(rng, mu=2)
Tests.test_triangular(rng, c=0.2, loc=6, scale=7)
Tests.test_uniform(rng, loc=2, scale=7)
Tests.test_uniform_discrete(rng, l=0, r=5)
def __init__(self, seed):
self.rng = RVGs.RNG(seed=seed)
self.beta = RVGs.Beta(a=1, b=2)
self.sum = 0
self.seed = seed
def __init__(self, id, parameters):
self.id = id
self.rng = RVGs.RNG(seed=id)
self.params = parameters
self.stateMonitor = PatientStateMonitor(parameters=parameters)
def get_obj_value(self, x, seed_index=0):
""" returns one realization from x^2+noise """
# create a random number generator
rng = RVGs.RNG(seed=seed_index)
return (x[0] + 1) * (x[0] + 1) + x[1] * x[1] + self._err.sample(rng)
