def test_binary_matrices(p, accessibility_matrix, adjacency_matrix,
communication_matrix):
mc = _MarkovChain(p)
actual = mc.accessibility_matrix
expected = _np.asarray(accessibility_matrix)
assert _np.array_equal(actual, expected)
for i in range(mc.size):
for j in range(mc.size):
actual = mc.is_accessible(j, i)
expected = mc.accessibility_matrix[i, j] != 0
assert actual == expected
actual = mc.are_communicating(i, j)
expected = mc.accessibility_matrix[
i, j] != 0 and mc.accessibility_matrix[j, i] != 0
assert actual == expected
actual = mc.adjacency_matrix
expected = _np.asarray(adjacency_matrix)
assert _np.array_equal(actual, expected)
actual = mc.communication_matrix
expected = _np.asarray(communication_matrix)
assert _np.array_equal(actual, expected)
def test_attributes(p, is_absorbing, is_canonical, is_doubly_stochastic,
is_ergodic, is_reversible, is_symmetric):
mc = _MarkovChain(p)
actual = mc.is_absorbing
expected = is_absorbing
assert actual == expected
actual = mc.is_canonical
expected = is_canonical
assert actual == expected
actual = mc.is_doubly_stochastic
expected = is_doubly_stochastic
assert actual == expected
actual = mc.is_ergodic
expected = is_ergodic
assert actual == expected
actual = mc.is_reversible
expected = is_reversible
assert actual == expected
actual = mc.is_symmetric
expected = is_symmetric
assert actual == expected
def test_stationary_distributions(p, stationary_distributions):
mc = _MarkovChain(p)
stationary_distributions = [
_np.array(stationary_distribution)
for stationary_distribution in stationary_distributions
]
actual = len(mc.pi)
expected = len(stationary_distributions)
assert actual == expected
actual = len(mc.pi)
expected = len(mc.recurrent_classes)
assert actual == expected
ss_matrix = _np.vstack(mc.pi)
actual = _npl.matrix_rank(ss_matrix)
expected = min(ss_matrix.shape)
assert actual == expected
for index, stationary_distribution in enumerate(stationary_distributions):
assert _np.isclose(_np.sum(mc.pi[index]), 1.0)
actual = mc.pi[index]
expected = stationary_distribution
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_states_cyclic(p):
mc = _MarkovChain(p)
if len(mc.cyclic_states) > 0:
for state in mc.cyclic_states:
assert mc.is_cyclic_state(state) is True
def test_entropy(p, entropy_rate, entropy_rate_normalized,
topological_entropy):
mc = _MarkovChain(p)
actual = mc.entropy_rate
expected = entropy_rate
if actual is not None and expected is not None:
assert _np.isclose(actual, expected)
else:
assert actual == expected
actual = mc.entropy_rate_normalized
expected = entropy_rate_normalized
if actual is not None and expected is not None:
assert _np.isclose(actual, expected)
else:
assert actual == expected
actual = mc.topological_entropy
expected = topological_entropy
assert _np.isclose(actual, expected)
def test_states_space(p, recurrent_classes, transient_classes):
mc = _MarkovChain(p)
actual = mc.recurrent_states
expected = sorted([
state for recurrent_class in recurrent_classes
for state in recurrent_class
])
assert actual == expected
actual = mc.transient_states
expected = sorted([
state for transient_class in transient_classes
for state in transient_class
])
assert actual == expected
actual = sorted(mc.recurrent_states + mc.transient_states)
expected = mc.states
assert actual == expected
if len(mc.recurrent_states) > 0:
for state in mc.recurrent_states:
assert mc.is_recurrent_state(state) is True
if len(mc.transient_states) > 0:
for state in mc.transient_states:
assert mc.is_transient_state(state) is True
def test_walk(p, seed, steps, initial_state, final_state, output_indices,
value):
mc = _MarkovChain(p)
actual_walk = mc.walk(steps, initial_state, final_state, output_indices,
seed)
expected_walk = value
actual = actual_walk
expected = expected_walk
assert actual == expected
if initial_state is not None:
actual = actual[0]
expected = initial_state
assert actual == expected
if final_state is None:
actual = len(actual_walk)
expected = len(expected_walk)
assert actual == expected
def test_aliased_methods(p, params):
lcl = locals()
lcl['mc'] = _MarkovChain(p)
for member_name, member in _MarkovChain.__dict__.items():
if isinstance(member,
property) or not hasattr(member, '_aliases') or hasattr(
member,
'_random_output') or member.__name__ != member_name:
continue
if member_name not in params:
raise KeyError(f'Undefined parameters for method "{member_name}".')
actual = eval('mc.' + member_name +
'()') if params[member_name] is None else eval(
'mc.' + member_name + '(*params[member_name])')
for member_alias in member._aliases:
expected = eval('mc.' + member_alias +
'()') if params[member_name] is None else eval(
'mc.' + member_alias +
'(*params[member_name])')
assert _compare_values(actual, expected)
def test_hitting_times(p, targets, value):
mc = _MarkovChain(p)
actual = mc.hitting_times(targets)
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_walk_probability(p, walk, value):
mc = _MarkovChain(p)
actual = mc.walk_probability(walk)
expected = value
assert _np.isclose(actual, expected)
def test_mean_number_visits(p, mean_number_visits):
mc = _MarkovChain(p)
actual = mc.mean_number_visits()
expected = _np.asarray(mean_number_visits)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_predict(p, steps, initial_state, output_indices, value):
mc = _MarkovChain(p)
actual = mc.predict(steps, initial_state, output_indices)
expected = value
assert actual == expected
def test_expected_transitions(p, steps, initial_distribution, value):
mc = _MarkovChain(p)
actual = mc.expected_transitions(steps, initial_distribution)
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_lumping_partitions(p, lumping_partitions):
mc = _MarkovChain(p)
actual = mc.lumping_partitions
expected = lumping_partitions
assert actual == expected
def test_expected_rewards(p, steps, rewards, value):
mc = _MarkovChain(p)
actual = mc.expected_rewards(steps, rewards)
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_next_state(p, seed, initial_state, output_index, value):
mc = _MarkovChain(p)
actual = mc.next_state(initial_state, output_index, seed)
expected = value
assert actual == expected
def test_mixing_time(p, initial_distribution, jump, cutoff_type, value):
mc = _MarkovChain(p)
actual = mc.mixing_time(initial_distribution, jump, cutoff_type)
expected = value
assert actual == expected
def test_lazy(p, inertial_weights, value):
mc = _MarkovChain(p)
mc_lazy = mc.to_lazy_chain(inertial_weights)
actual = mc_lazy.p
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_bounded(p, boundary_condition, value):
mc = _MarkovChain(p)
mc_bounded = mc.to_bounded_chain(boundary_condition)
actual = mc_bounded.p
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_sensitivity(p, state, value):
mc = _MarkovChain(p)
actual = mc.sensitivity(state)
expected = value
if actual is not None and expected is not None:
expected = _np.asarray(expected)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
else:
assert actual == expected
def test_time_correlations(p, walk1, walk2, time_points, value):
mc = _MarkovChain(p)
actual = _np.asarray(mc.time_correlations(walk1, walk2, time_points))
expected = value
if actual is not None and expected is not None:
expected = _np.asarray(expected)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
else:
assert actual == expected
def test_absorption_probabilities(p, absorption_probabilities):
mc = _MarkovChain(p)
actual = mc.absorption_probabilities()
expected = absorption_probabilities
if actual is not None and expected is not None:
expected = _np.asarray(expected)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
else:
assert actual == expected
def test_mean_first_passage_times_between(p, origins, targets, value):
mc = _MarkovChain(p)
actual = mc.mean_first_passage_times_between(origins, targets)
expected = value
if actual is not None and expected is not None:
expected = _np.asarray(expected)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
else:
assert actual == expected
def test_matrix(p, determinant, rank):
mc = _MarkovChain(p)
actual = mc.determinant
expected = determinant
assert _np.isclose(actual, expected)
actual = mc.rank
expected = rank
assert actual == expected
def test_first_passage_probabilities(p, steps, initial_state,
first_passage_states, value):
mc = _MarkovChain(p)
actual = mc.first_passage_probabilities(steps, initial_state,
first_passage_states)
expected = _np.asarray(value)
if first_passage_states is not None:
assert actual.size == steps
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_canonical(p, canonical_form):
mc = _MarkovChain(p)
mc_canonical = mc.to_canonical_form()
actual = mc_canonical.p
if mc.is_canonical:
expected = mc.p
else:
expected = _np.asarray(canonical_form)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_closest_reversible(p, distribution, weighted, value):
mc = _MarkovChain(p)
cr = mc.closest_reversible(distribution, weighted)
if mc.is_reversible:
actual = cr.p
expected = mc.p
else:
actual = cr.p
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_lump(p, partitions, value):
if value is None:
_pt.skip('Markov _chain is not lumpable for the specified partitions.')
else:
mc = _MarkovChain(p)
mc_lump = mc.lump(partitions)
actual = mc_lump.p
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_hitting_probabilities(p, targets, value):
mc = _MarkovChain(p)
actual = mc.hitting_probabilities(targets)
expected = _np.asarray(value)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
if mc.is_irreducible:
expected = _np.ones(mc.size, dtype=float)
_npt.assert_allclose(actual, expected, rtol=1e-5, atol=1e-8)
def test_periodicity(p, period):
mc = _MarkovChain(p)
actual = mc.period
expected = period
assert actual == expected
actual = mc.is_aperiodic
expected = period == 1
assert actual == expected
