def test_arrays() -> None:
x = np.array([1,4,9,16])
if no.mpi.rank() == 0:
comm.send(x, dest=1)
if no.mpi.rank() == 1:
y = comm.recv(source=0)
assert np.array_equal(x,y)
df = pd.read_csv("./test/df2.csv")
if no.mpi.rank() == 0:
comm.send(df, dest=1)
if no.mpi.rank() == 1:
dfrec = comm.recv(source=0)
assert dfrec.equals(df)
i = "rank %d" % no.mpi.rank()
root = 0
i = comm.bcast(i, root=root)
# all procs should now have root process value
assert i == "rank 0"
# a0 will be different for each proc
a0 = np.random.rand(2,2)
a1 = comm.bcast(a0, root)
# a1 will equal a0 on rank 0 only
if no.mpi.rank() == 0:
assert np.array_equal(a0, a1)
else:
assert not np.array_equal(a0, a1)
# base model for MC engine
model = no.Model(no.NoTimeline(), no.MonteCarlo.deterministic_identical_stream)
# # check identical streams (independent=False)
u = model.mc.ustream(1000)
v = comm.bcast(u, root=root)
# u == v on all processes
assert np.array_equal(u, v)
# base model for MC engine
model = no.Model(no.NoTimeline(), no.MonteCarlo.deterministic_independent_stream)
# # check identical streams (independent=False)
u = model.mc.ustream(1000)
v = comm.bcast(u, root=root)
# u != v on all non-root processes
if no.mpi.rank() != root:
assert not np.array_equal(u, v)
else:
assert np.array_equal(u, v)
def test() -> None:
df = pd.read_csv("./test/df.csv")
# base model for MC engine
model = no.Model(no.NoTimeline(),
no.MonteCarlo.deterministic_identical_stream)
cats = np.array(range(4))
# identity matrix means no transitions
trans = np.identity(len(cats))
no.df.transition(model, cats, trans, df, "DC2101EW_C_ETHPUK11")
assert len(df["DC2101EW_C_ETHPUK11"].unique()
) == 1 and df["DC2101EW_C_ETHPUK11"].unique()[0] == 2
# NOTE transition matrix interpreted as being COLUMN MAJOR due to pandas DataFrame storing data in column-major order
# force 2->3
trans[2, 2] = 0.0
trans[2, 3] = 1.0
no.df.transition(model, cats, trans, df, "DC2101EW_C_ETHPUK11")
no.log(df["DC2101EW_C_ETHPUK11"].unique())
assert len(df["DC2101EW_C_ETHPUK11"].unique()
) == 1 and df["DC2101EW_C_ETHPUK11"].unique()[0] == 3
# ~half of 3->0
trans[3, 0] = 0.5
trans[3, 3] = 0.5
no.df.transition(model, cats, trans, df, "DC2101EW_C_ETHPUK11")
assert np.array_equal(np.sort(df["DC2101EW_C_ETHPUK11"].unique()),
np.array([0, 3]))
def test_errors() -> None:
df = pd.read_csv("./test/df.csv")
# base model for MC engine
model = no.Model(no.NoTimeline(),
no.MonteCarlo.deterministic_identical_stream)
cats = np.array(range(4))
# identity matrix means no transitions
trans = np.identity(len(cats))
# invalid transition matrices
assert_throws(ValueError, no.df.transition, model, cats, np.ones((1, 2)),
df, "DC2101EW_C_ETHPUK11")
assert_throws(ValueError, no.df.transition, model, cats, np.ones((1, 1)),
df, "DC2101EW_C_ETHPUK11")
assert_throws(ValueError, no.df.transition, model, cats, trans + 0.1, df,
"DC2101EW_C_ETHPUK11")
# category data MUST be 64bit integer. This will almost certainly be the default on linux/OSX (LP64) but maybe not on windows (LLP64)
df["DC2101EW_C_ETHPUK11"] = df["DC2101EW_C_ETHPUK11"].astype(np.int32)
assert_throws(TypeError, no.df.transition, model, cats, trans, df,
"DC2101EW_C_ETHPUK11")
def test_base() -> None:
base = no.Model(no.NoTimeline(),
no.MonteCarlo.deterministic_identical_stream)
assert_throws(
RuntimeError, no.run, base
) # RuntimeError: Tried to call pure virtual function "Model::step"
def __init__(self, mortality_hazard: float, n: int) -> None:
# initialise base model with a nondeterministic seed results will vary (slightly)
super().__init__(neworder.NoTimeline(),
neworder.MonteCarlo.nondeterministic_stream)
# initialise population
self.population = [Person(mortality_hazard) for _ in range(n)]
neworder.log("created %d individuals" % n)
def test_null_timeline() -> None:
t0 = no.NoTimeline()
assert t0.nsteps() == 1
assert t0.dt() == 0.0
assert not t0.at_end()
assert t0.index() == 0
assert no.time.isnever(t0.time())
assert no.time.isnever(t0.end())
m = _TestModel2(0, 1, 1)
no.run(m)
assert m.timeline.at_end()
assert m.timeline.index() == 1
assert m.timeline.time() == 1.0
def __init__(self, mortality_hazard_file: str, n: int, dt: float) -> None:
# Direct sampling doesnt require a timeline
super().__init__(neworder.NoTimeline(),
neworder.MonteCarlo.deterministic_identical_stream)
# initialise cohort
self.mortality_hazard = pd.read_csv(mortality_hazard_file)
# store the largest age we have a rate for
self.max_rate_age = max(self.mortality_hazard.DC1117EW_C_AGE) - 1
# neworder.log(self.mortality_hazard.head())
self.population = pd.DataFrame(
index=neworder.df.unique_index(n),
data={"age_at_death": neworder.time.far_future()})
# the time interval of the mortality data values
self.dt = dt
def __init__(self, n: int, p: float) -> None:
"""
We create a null timeline, corresponding to a single instantaneous
transition, and initialise the base class with this plus a
randomly-seeded Monte-Carlo engine
NB it is *essential* to initialise the base class.
Failure to do so will result in UNDEFINED BEHAVIOUR
"""
super().__init__(neworder.NoTimeline(),
neworder.MonteCarlo.nondeterministic_stream)
# create a silent population of size n
self.population = pd.DataFrame(index=neworder.df.unique_index(n),
data={"talkative": False})
self.population.index.name = "id"
# set the transition probability
self.p_talk = p
def __init__(self, n: int):
super().__init__(neworder.NoTimeline(),
neworder.MonteCarlo.deterministic_identical_stream)
# initialise population - time of death only
self.population = pd.DataFrame(index=neworder.df.unique_index(n),
data={
"TimeOfDeath":
self.mc.first_arrival(
data.mortality_rate,
data.mortality_delta_t, n, 0.0),
"TimeOfPregnancy":
neworder.time.never(),
"Parity":
Parity.CHILDLESS,
"Unions":
0,
})
def test_consistency() -> None:
# need to wrap timeline in a model to do the stepping, which isnt directly accessible from python
class ConsistencyTest(no.Model):
def __init__(self, timeline: no.Timeline) -> None:
super().__init__(timeline,
no.MonteCarlo.deterministic_identical_stream)
def step(self) -> None:
pass
m = ConsistencyTest(no.NoTimeline())
assert m.timeline.nsteps() == 1
no.run(m)
assert m.timeline.index() == 1
m = ConsistencyTest(no.LinearTimeline(2020, 2021, 12))
assert m.timeline.nsteps() == 12
no.run(m)
assert m.timeline.index() == 12
assert m.timeline.time() == 2021
m = ConsistencyTest(no.NumericTimeline([2020 + i / 12 for i in range(13)]))
assert m.timeline.nsteps() == 12
no.run(m)
assert m.timeline.index() == 12
assert m.timeline.time() == 2021
s = date(2019, 10, 31)
e = date(2020, 10, 31)
m = ConsistencyTest(no.CalendarTimeline(s, e, 1, "m"))
assert m.timeline.time().date() == s
assert m.timeline.nsteps() == 12
no.run(m)
assert m.timeline.time().date() == e
assert m.timeline.index() == 12
# t = np.ones((3,3)) / 3
# no.df.transition(m, c, t, df, "n")
# no.log(df.n.value_counts())
# for i in c:
# no.log(df.n.value_counts()[i] > n/3 - sqrt(n) and df.n.value_counts()[i] < n/3 + sqrt(n))
# t = np.array([
# [1.0, 1.0, 1.0],
# [0.0, 0.0, 0.0],
# [0.0, 0.0, 0.0],
# ])
# no.df.transition(m, c, t, df, "n")
# no.log(df.n.value_counts())
if __name__ == "__main__":
m = no.Model(no.NoTimeline(), no.MonteCarlo.deterministic_identical_stream)
rows, tc, colcpp = cpp_impl(m, get_data())
no.log("C++ %d: %f" % (rows, tc))
m.mc.reset()
rows, tp, colpy = python_impl(m, get_data())
no.log("py %d: %f" % (rows, tp))
#no.log(colcpp-colpy)
assert np.array_equal(colcpp, colpy)
no.log("speedup factor = %f" % (tp / tc))
# f(m)
def __init__(self) -> None:
super().__init__(no.NoTimeline(),
no.MonteCarlo.deterministic_identical_stream)
def test_basic() -> None:
# test unique index generation
idx = no.df.unique_index(100)
assert np.array_equal(
idx, np.arange(no.mpi.rank(), 100 * no.mpi.size(), step=no.mpi.size()))
idx = no.df.unique_index(100)
assert np.array_equal(
idx,
np.arange(100 * no.mpi.size() + no.mpi.rank(),
200 * no.mpi.size(),
step=no.mpi.size()))
N = 100000
# base model for MC engine
model = no.Model(no.NoTimeline(),
no.MonteCarlo.deterministic_identical_stream)
c = [1, 2, 3]
df = pd.DataFrame({"category": [1] * N})
# no transitions, check no changes
t = np.identity(3)
no.df.transition(model, c, t, df, "category")
assert df.category.value_counts()[1] == N
# all 1 -> 2
t[0, 0] = 0.0
t[0, 1] = 1.0
no.df.transition(model, c, t, df, "category")
assert 1 not in df.category.value_counts()
assert df.category.value_counts()[2] == N
# 2 -> 1 or 3
t = np.array([
[1.0, 0.0, 0.0],
[0.5, 0.0, 0.5],
[0.0, 0.0, 1.0],
])
no.df.transition(model, c, t, df, "category")
assert 2 not in df.category.value_counts()
for i in [1, 3]:
assert df.category.value_counts()[i] > N / 2 - sqrt(
N) and df.category.value_counts()[i] < N / 2 + sqrt(N)
# spread evenly
t = np.ones((3, 3)) / 3
no.df.transition(model, c, t, df, "category")
for i in c:
assert df.category.value_counts()[i] > N / 3 - sqrt(
N) and df.category.value_counts()[i] < N / 3 + sqrt(N)
# all -> 1
t = np.array([
[1.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
])
no.df.transition(model, c, t, df, "category")
assert df.category.value_counts()[1] == N
