def test_1(self):
""" Testing ten admissible realizations of state space for the first
three periods.
"""
# Generate constraint periods
constraints = dict()
constraints['periods'] = np.random.randint(3, 5)
# Generate random initialization file
generate_init(constraints)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj = simulate(respy_obj)
# Distribute class attributes
states_number_period = respy_obj.get_attr('states_number_period')
states_all = respy_obj.get_attr('states_all')
# The next hard-coded results assume that at least two more
# years of education are admissible.
edu_max = respy_obj.get_attr('edu_max')
edu_start = respy_obj.get_attr('edu_start')
if edu_max - edu_start < 2:
return
# The number of admissible states in the first three periods
for j, number_period in enumerate([1, 4, 13]):
assert (states_number_period[j] == number_period)
# The actual realizations of admissible states in period one
assert ((states_all[0, 0, :] == [0, 0, 0, 1]).all())
# The actual realizations of admissible states in period two
states = [[0, 0, 0, 0], [0, 0, 1, 1], [0, 1, 0, 0]]
states += [[1, 0, 0, 0]]
for j, state in enumerate(states):
assert ((states_all[1, j, :] == state).all())
# The actual realizations of admissible states in period three
states = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 0, 1, 1]]
states += [[0, 0, 2, 1], [0, 1, 0, 0], [0, 1, 1, 0]]
states += [[0, 1, 1, 1], [0, 2, 0, 0], [1, 0, 0, 0]]
states += [[1, 0, 1, 0], [1, 0, 1, 1], [1, 1, 0, 0]]
states += [[2, 0, 0, 0]]
for j, state in enumerate(states):
assert ((states_all[2, j, :] == state).all())
def test_4(self):
""" Test the solution of deterministic model with ambiguity and
interpolation. This test has the same result as in the absence of
random variation in payoffs, it does not matter whether the
environment is ambiguous or not.
"""
# Solve specified economy
for version in ['FORTRAN', 'PYTHON']:
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fifth.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 88750)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, -1.0)
def test_2(self):
""" If there is no random variation in rewards then the number of draws to simulate the
expected future value should have no effect.
"""
params_spec, options_spec = generate_random_model(deterministic=True)
# Initialize auxiliary objects
base = None
for _ in range(2):
num_draws_emax = np.random.randint(1, 100)
respy_obj = RespyCls(params_spec, options_spec)
respy_obj.unlock()
respy_obj.set_attr("num_draws_emax", num_draws_emax)
respy_obj.lock()
respy_obj = simulate_observed(respy_obj)
periods_emax = respy_obj.get_attr("periods_emax")
if base is None:
base = periods_emax.copy()
diff = np.max(
abs(
np.ma.masked_invalid(base) -
np.ma.masked_invalid(periods_emax)))
np.testing.assert_almost_equal(diff, 0.0)
def test_3(self):
""" Test the solution of deterministic model with ambiguity and
interpolation. This test has the same result as in the absence of
random variation in payoffs, it does not matter whether the
environment is ambiguous or not.
"""
# Solve specified economy
for version in ['FORTRAN', 'PYTHON']:
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fifth.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 88750)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, -1.0)
def test_2(self):
""" This test ensures that the record files are identical.
"""
# Generate random initialization file. The number of periods is higher than
# usual as only FORTRAN implementations are used to solve the random request.
# This ensures that also some cases of interpolation are explored.
constr = {
"program": {
"version": "fortran"
},
"num_periods": np.random.randint(3, 10),
"estimation": {
"maxfun": 0
},
}
params_spec, options_spec = generate_random_model(point_constr=constr)
base_sol_log, base_est_info_log = None, None
base_est_log = None
for is_parallel in [False, True]:
options_spec["program"]["threads"] = 1
options_spec["program"]["procs"] = 1
if is_parallel:
if IS_PARALLELISM_OMP:
options_spec["program"]["threads"] = np.random.randint(
2, 5)
if IS_PARALLELISM_MPI:
options_spec["program"]["procs"] = np.random.randint(2, 5)
respy_obj = RespyCls(params_spec, options_spec)
file_sim = respy_obj.get_attr("file_sim")
simulate_observed(respy_obj)
respy_obj.fit()
# Check for identical records
fname = file_sim + ".respy.sol"
if base_sol_log is None:
base_sol_log = open(fname, "r").read()
assert open(fname, "r").read() == base_sol_log
if base_est_info_log is None:
base_est_info_log = open("est.respy.info", "r").read()
assert open("est.respy.info", "r").read() == base_est_info_log
if base_est_log is None:
base_est_log = open("est.respy.log", "r").readlines()
compare_est_log(base_est_log)
def test_3(self):
""" Test the solution of model with ambiguity.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_third.respy.ini')
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 86121.335057)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 1.9162587639887239)
def test_4(self):
""" Test the solution of model with ambiguity.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fourth.respy.ini')
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 75.719528)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 2.802285449312437)
def test_1(self):
""" Test solution of simple model against hard-coded results.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_first.respy.ini')
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 103320.40501)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 1.9775860444869962)
def test_2(self):
""" If there is no random variation in payoffs then the number of
draws to simulate the expected future value should have no effect.
"""
# Generate constraints
constr = dict()
constr['is_deterministic'] = True
# Generate random initialization file
generate_init(constr)
# Initialize auxiliary objects
base = None
for _ in range(2):
# Draw a random number of draws for
# expected future value calculations.
num_draws_emax = np.random.randint(1, 100)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('num_draws_emax', num_draws_emax)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Distribute class attributes
periods_emax = respy_obj.get_attr('periods_emax')
if base is None:
base = periods_emax.copy()
# Statistic
diff = np.max(
abs(
np.ma.masked_invalid(base) -
np.ma.masked_invalid(periods_emax)))
# Checks
assert (np.isfinite(diff))
assert (diff < 10e-10)
def test_10(self):
""" Function that calculates the number of observations by individual.
"""
for _ in range(2):
params_spec, options_spec = generate_random_model()
respy_obj = RespyCls(params_spec, options_spec)
respy_obj = simulate_observed(respy_obj)
num_agents_est = respy_obj.get_attr("num_agents_est")
data_array = process_dataset(respy_obj).to_numpy()
py = np.bincount(data_array[:, 0].astype(int))
f90 = fort_debug.wrapper_get_num_obs_agent(data_array,
num_agents_est)
assert_almost_equal(py, f90)
def test_2(self):
""" If there is no random variation in payoffs then the number of
draws to simulate the expected future value should have no effect.
"""
# Generate constraints
constr = dict()
constr['is_deterministic'] = True
# Generate random initialization file
generate_init(constr)
# Initialize auxiliary objects
base = None
for _ in range(2):
# Draw a random number of draws for
# expected future value calculations.
num_draws_emax = np.random.randint(1, 100)
# Perform toolbox actions
respy_obj = RespyCls('test.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('num_draws_emax', num_draws_emax)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Distribute class attributes
periods_emax = respy_obj.get_attr('periods_emax')
if base is None:
base = periods_emax.copy()
# Statistic
diff = np.max(abs(np.ma.masked_invalid(base) - np.ma.masked_invalid(
periods_emax)))
# Checks
assert (np.isfinite(diff))
assert (diff < 10e-10)
def change_status(identifiers, init_file, is_fixed):
""" Change the status of the a list of parameters.
"""
# Baseline
init_dict = read(init_file)
respy_obj = RespyCls(init_file)
model_paras = respy_obj.get_attr('model_paras')
coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky = \
dist_model_paras(model_paras, True)
for identifier in identifiers:
if identifier in list(range(0, 6)):
j = identifier
init_dict['OCCUPATION A']['coeffs'][j] = coeffs_a[j]
init_dict['OCCUPATION A']['fixed'][j] = is_fixed
elif identifier in list(range(6, 12)):
j = identifier - 6
init_dict['OCCUPATION B']['coeffs'][j] = coeffs_b[j]
init_dict['OCCUPATION B']['fixed'][j] = is_fixed
elif identifier in list(range(12, 15)):
j = identifier - 12
init_dict['EDUCATION']['coeffs'][j] = coeffs_edu[j]
init_dict['EDUCATION']['fixed'][j] = is_fixed
elif identifier in list(range(15, 16)):
j = identifier - 15
init_dict['HOME']['coeffs'][j] = coeffs_home[j]
init_dict['HOME']['fixed'][j] = is_fixed
elif identifier in list(range(16, 26)):
j = identifier - 16
shocks_coeffs = cholesky_to_coeffs(shocks_cholesky)
init_dict['SHOCKS']['coeffs'] = shocks_coeffs
init_dict['SHOCKS']['fixed'][j] = is_fixed
else:
raise NotImplementedError
# Print dictionary to file
print_init_dict(init_dict, init_file)
def test_5(self):
""" Test the solution of deterministic model without ambiguity,
but with interpolation. As a deterministic model is requested,
all versions should yield the same result without any additional effort.
"""
# Solve specified economy
for version in ['FORTRAN', 'PYTHON']:
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fifth.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 88750)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, -1.0)
def test_4(self):
""" Test the solution of deterministic model without ambiguity,
but with interpolation. As a deterministic model is requested,
all versions should yield the same result without any additional effort.
"""
# Solve specified economy
for version in ['FORTRAN', 'PYTHON']:
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_fifth.respy.ini')
respy_obj.unlock()
respy_obj.set_attr('version', version)
respy_obj.lock()
respy_obj = simulate(respy_obj)
# Assess expected future value
val = respy_obj.get_attr('periods_emax')[0, :1]
np.testing.assert_allclose(val, 88750)
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, -1.0)
def test_2(self):
""" Compare the solution of simple model against hard-coded results.
"""
# Solve specified economy
respy_obj = RespyCls(TEST_RESOURCES_DIR + '/test_second.respy.ini')
respy_obj = simulate(respy_obj)
# Distribute class attributes
systematic = respy_obj.get_attr('periods_payoffs_systematic')
emax = respy_obj.get_attr('periods_emax')
# PERIOD 3: Check the systematic payoffs against hand calculations.
vals = [[2.7456010000000000, 07.5383250000000000, -3999.60, 1.140]]
vals += [[3.0343583944356758, 09.2073308658822519, -3999.60, 1.140]]
vals += [[3.0343583944356758, 09.2073308658822519, 0000.90, 1.140]]
vals += [[3.3534846500000000, 11.2458593100000000, 0000.40, 1.140]]
vals += [[3.5966397255692826, 12.0612761204447200, -3999.60, 1.140]]
vals += [[3.9749016274947495, 14.7316759204425760, -3999.60, 1.140]]
vals += [[3.9749016274947495, 14.7316759204425760, 0000.90, 1.140]]
vals += [[6.2338866585247175, 31.1869581683094590, -3999.60, 1.140]]
vals += [[3.4556134647626764, 11.5883467192233920, -3999.60, 1.140]]
vals += [[3.8190435053663370, 14.1540386453758080, -3999.60, 1.140]]
vals += [[3.8190435053663370, 14.1540386453758080, 0000.90, 1.140]]
vals += [[4.5267307943142532, 18.5412874597468690, -3999.60, 1.140]]
vals += [[5.5289614776240041, 27.6603505585167470, -3999.60, 1.140]]
for i, val in enumerate(vals):
(np.testing.assert_allclose(systematic[2, i, :], val))
# PERIOD 3: Check expected future values. As there are no
# random draws, this corresponds to the maximum
# value in the last period.
vals = [7.53832493366, 9.20733086588, 9.20733086588, 11.2458593149]
vals += [12.06127612040, 14.7316759204, 14.7316759204, 31.1869581683]
vals += [11.58834671922, 14.1540386453, 14.1540386453, 18.5412874597]
vals += [27.660350558516747]
for i, val in enumerate(vals):
(np.testing.assert_allclose(emax[2, i], [val]))
# PERIOD 2: Check the systematic payoffs against hand calculations.
vals = [[2.7456010150169163, 07.5383249336619222, -3999.60, 1.140]]
vals += [[3.0343583944356758, 09.2073308658822519, 0000.90, 1.140]]
vals += [[3.5966397255692826, 12.0612761204447200, -3999.60, 1.140]]
vals += [[3.4556134647626764, 11.5883467192233920, -3999.60, 1.140]]
for i, val in enumerate(vals):
(np.testing.assert_allclose(systematic[1, i, :], val))
# PERIOD 2: Check expected future values.
vals = [18.9965372481, 23.2024229903, 41.6888863803, 29.7329464954]
for i, val in enumerate(vals):
(np.testing.assert_allclose(emax[1, i], [val]))
# PERIOD 1: Check the systematic payoffs against hand calculations.
vals = [[2.7456010150169163, 7.5383249336619222, 0.90, 1.140]]
for i, val in enumerate(vals):
(np.testing.assert_allclose(systematic[0, i, :], val))
# PERIOD 1 Check expected future values.
vals = [47.142766995]
for i, val in enumerate(vals):
(np.testing.assert_allclose(emax[0, 0], [val]))
# Assess evaluation
_, val = estimate(respy_obj)
np.testing.assert_allclose(val, 0.00)
