def test_evidence_1vs1(self):
ta = [ttt.Player(ttt.Gaussian(25., 1e-7), 25.0 / 6, 25.0 / 300)]
tb = [ttt.Player(ttt.Gaussian(25., 1e-7), 25.0 / 6, 25.0 / 300)]
g = ttt.Game([ta, tb], [0, 0], 0.25)
self.assertAlmostEqual(g.evidence, 0.25, 3)
g = ttt.Game([ta, tb], [1, 0], 0.25)
self.assertAlmostEqual(g.evidence, 0.375, 3)
def test_evidence_1vs1(self):
ta = [ttt.Rating(ttt.Gaussian(25., 1e-7))]
tb = [ttt.Rating(ttt.Gaussian(25., 1e-7))]
g = ttt.Game([ta, tb], [0, 0], 0.25)
self.assertAlmostEqual(g.evidence, 0.25, 3)
g = ttt.Game([ta, tb], [0, 1], 0.25)
self.assertAlmostEqual(g.evidence, 0.375, 3)
def test_one_batch_history(self):
composition = [[['aj'], ['bj']], [['bj'], ['cj']], [['cj'], ['aj']]]
results = [[1, 0], [1, 0], [1, 0]]
times = [1, 1, 1]
priors = dict()
for k in ["aj", "bj", "cj"]:
priors[k] = ttt.Player(ttt.Gaussian(25., 25.0 / 3), 25.0 / 6,
0.15 * 25.0 / 3)
h1 = ttt.History(composition, results, times, priors)
self.assertAlmostEqual(h1.batches[0].posterior("aj").mu, 22.904, 3)
self.assertAlmostEqual(h1.batches[0].posterior("aj").sigma, 6.010, 3)
self.assertAlmostEqual(h1.batches[0].posterior("cj").mu, 25.110, 3)
self.assertAlmostEqual(h1.batches[0].posterior("cj").sigma, 5.866, 3)
step, i = h1.convergence()
self.assertAlmostEqual(h1.batches[0].posterior("aj").mu, 25.000, 3)
self.assertAlmostEqual(h1.batches[0].posterior("aj").sigma, 5.419, 3)
self.assertAlmostEqual(h1.batches[0].posterior("cj").mu, 25.000, 3)
self.assertAlmostEqual(h1.batches[0].posterior("cj").sigma, 5.419, 3)
priors = dict()
for k in ["aj", "bj", "cj"]:
priors[k] = ttt.Player(ttt.Gaussian(25., 25.0 / 3), 25.0 / 6,
25.0 / 300)
h2 = ttt.History(composition, results, [1, 2, 3], priors)
self.assertAlmostEqual(h2.batches[2].posterior("aj").mu, 22.904, 3)
self.assertAlmostEqual(h2.batches[2].posterior("aj").sigma, 6.011, 3)
self.assertAlmostEqual(h2.batches[2].posterior("cj").mu, 25.111, 3)
self.assertAlmostEqual(h2.batches[2].posterior("cj").sigma, 5.867, 3)
step2, i2 = h2.convergence()
self.assertAlmostEqual(h2.batches[2].posterior("aj").mu, 24.999, 3)
self.assertAlmostEqual(h2.batches[2].posterior("aj").sigma, 5.420, 3)
self.assertAlmostEqual(h2.batches[2].posterior("cj").mu, 25.001, 3)
self.assertAlmostEqual(h2.batches[2].posterior("cj").sigma, 5.420, 3)
def test_gaussian_init(self):
N01 = ttt.Gaussian(mu=0, sigma=1)
self.assertAlmostEqual(N01.mu, 0)
self.assertAlmostEqual(N01.sigma, 1.0)
Ninf = ttt.Gaussian(0, math.inf)
self.assertAlmostEqual(Ninf.mu, 0)
self.assertAlmostEqual(Ninf.sigma, math.inf)
N00 = ttt.Gaussian(mu=0, sigma=0)
self.assertAlmostEqual(N00.mu, 0)
self.assertAlmostEqual(N00.sigma, 0)
def test_1vs1vs1(self):
[a], [b], [c] = ttt.Game(
[[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)]],
[1, 2, 0]).posteriors()
self.assertAlmostEqual(a.mu, 25.000000, 5)
self.assertAlmostEqual(a.sigma, 6.238469796, 5)
self.assertAlmostEqual(b.mu, 31.3113582213, 5)
self.assertAlmostEqual(b.sigma, 6.69881865, 5)
self.assertAlmostEqual(c.mu, 18.6886417787, 5)
[a], [b], [c] = ttt.Game(
[[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6,
25.0 / 300)]]).posteriors()
self.assertAlmostEqual(b.mu, 25.000000, 5)
self.assertAlmostEqual(b.sigma, 6.238469796, 5)
self.assertAlmostEqual(a.mu, 31.3113582213, 5)
self.assertAlmostEqual(a.sigma, 6.69881865, 5)
self.assertAlmostEqual(c.mu, 18.6886417787, 5)
[a], [b], [c] = ttt.Game(
[[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)]],
[1, 2, 0], 0.5).posteriors()
self.assertAlmostEqual(a.mu, 25.000, 3)
self.assertAlmostEqual(a.sigma, 6.093, 3)
self.assertAlmostEqual(b.mu, 33.379, 3)
self.assertAlmostEqual(b.sigma, 6.484, 3)
self.assertAlmostEqual(c.mu, 16.621, 3)
def test_NvsN_Draw(self):
ta = [
ttt.Rating(ttt.Gaussian(15., 1.)),
ttt.Rating(ttt.Gaussian(15., 1.))
]
tb = [ttt.Rating(ttt.Gaussian(30., 2.))]
[a, b], [c] = ttt.Game([ta, tb], [0, 0], 0.25).posteriors
self.assertAlmostEqual(a.mu, 15.000, 2)
self.assertAlmostEqual(a.sigma, 0.9916, 3)
self.assertAlmostEqual(b.mu, 15.000, 2)
self.assertAlmostEqual(b.sigma, 0.9916, 3)
self.assertAlmostEqual(c.mu, 30.000, 2)
self.assertAlmostEqual(c.sigma, 1.9320, 2)
def gaussian(self):
N, M = ttt.Gaussian(25.0, 25.0 / 3), ttt.Gaussian(0.0, 1.0)
mu, sigma = M / N
self.assertAlmostEqual(mu, -0.365, places=3)
self.assertAlmostEqual(sigma, 1.007, places=3)
mu, sigma = N * M
self.assertAlmostEqual(mu, 0.355, places=3)
self.assertAlmostEqual(sigma, 0.993, places=3)
mu, sigma = N + M
self.assertAlmostEqual(mu, 25.000, places=3)
self.assertAlmostEqual(sigma, 8.393, places=3)
mu, sigma = N - ttt.Gaussian(1.0, 1.0)
self.assertAlmostEqual(mu, 24.000, places=3)
self.assertAlmostEqual(sigma, 8.393, places=3)
def test_trunc(self):
mu, sigma = ttt.Gaussian(0, 1).trunc(0., False)
self.assertAlmostEqual((mu, sigma),
(0.7978845368663289, 0.6028103066716792))
mu, sigma = ttt.Gaussian(0.,
math.sqrt(2) * (25 / 6)).trunc(
1.8776005988, True)
self.assertAlmostEqual(mu, 0.0)
self.assertAlmostEqual(sigma, 1.07670, places=4)
mu, sigma = ttt.Gaussian(12.,
math.sqrt(2) * (25 / 6)).trunc(
1.8776005988, True)
self.assertAlmostEqual(mu, 0.3900999, places=5)
self.assertAlmostEqual(sigma, 1.034401, places=5)
def test_1vs1_draw(self):
[a], [b] = ttt.Game([[ttt.Rating()], [ttt.Rating()]], [0, 0],
0.25).posteriors
self.assertAlmostEqual(a.mu, 25.000, 2)
self.assertAlmostEqual(a.sigma, 6.469, 2)
self.assertAlmostEqual(b.mu, 25.000, 2)
self.assertAlmostEqual(b.sigma, 6.469, 2)
ta = [ttt.Rating(ttt.Gaussian(25., 3.))]
tb = [ttt.Rating(ttt.Gaussian(29., 2.))]
[a], [b] = ttt.Game([ta, tb], [0, 0], 0.25).posteriors
self.assertAlmostEqual(a.mu, 25.736, 2)
self.assertAlmostEqual(a.sigma, 2.710, 2)
self.assertAlmostEqual(b.mu, 28.672, 2)
self.assertAlmostEqual(b.sigma, 1.916, 2)
def test_forget(self):
gamma = 0.15 * 25.0 / 3
N = ttt.Gaussian(25., 1e-7)
_, sigma = N.forget(gamma, 5)
self.assertAlmostEqual(sigma, math.sqrt(5 * gamma**2))
_, sigma = N.forget(gamma, 1)
self.assertAlmostEqual(sigma, math.sqrt(1 * gamma**2))
def test_1vs1_draw(self):
[a], [b] = ttt.Game(
[[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)]],
[0, 0], 0.25).posteriors()
self.assertAlmostEqual(a.mu, 25.000, 2)
self.assertAlmostEqual(a.sigma, 6.469, 2)
self.assertAlmostEqual(b.mu, 25.000, 2)
self.assertAlmostEqual(b.sigma, 6.469, 2)
ta = [ttt.Player(ttt.Gaussian(25., 3.), 25.0 / 6, 25.0 / 300)]
tb = [ttt.Player(ttt.Gaussian(29., 2.), 25.0 / 6, 25.0 / 300)]
[a], [b] = ttt.Game([ta, tb], [0, 0], 0.25).posteriors()
self.assertAlmostEqual(a.mu, 25.736, 4)
self.assertAlmostEqual(a.sigma, 2.709956, 4)
self.assertAlmostEqual(b.mu, 28.67289, 4)
self.assertAlmostEqual(b.sigma, 1.916471, 4)
def test_NvsN_Draw(self):
ta = [
ttt.Player(ttt.Gaussian(15., 1.), 25.0 / 6, 25.0 / 300),
ttt.Player(ttt.Gaussian(15., 1.), 25.0 / 6, 25.0 / 300)
]
tb = [ttt.Player(ttt.Gaussian(30., 2.), 25.0 / 6, 25.0 / 300)]
[a, b], [c] = ttt.Game([ta, tb], [0, 0], 0.25).posteriors()
self.assertAlmostEqual(a.mu, 15.000, 3)
self.assertAlmostEqual(a.sigma, 0.9916, 3)
self.assertAlmostEqual(b.mu, 15.000, 3)
self.assertAlmostEqual(b.sigma, 0.9916, 3)
self.assertAlmostEqual(c.mu, 30.000, 3)
self.assertAlmostEqual(c.sigma, 1.9320, 3)
[a, b], [c] = ttt.Game([ta, tb], [1, 0], 0.0).posteriors()
self.assertAlmostEqual(a.mu, 15.105, 3)
self.assertAlmostEqual(a.sigma, 0.995, 3)
ta = [
ttt.Player(ttt.Gaussian(15., 1.), 25.0 / 6, 25.0 / 300),
ttt.Player(ttt.Gaussian(15., 1.), 25.0 / 6, 25.0 / 300)
]
tb = [
ttt.Player(ttt.Gaussian(15., 1.), 25.0 / 6, 25.0 / 300),
ttt.Player(ttt.Gaussian(15., 1.), 25.0 / 6, 25.0 / 300)
]
[a, b], [c, d] = ttt.Game([ta, tb], [1, 0], 0.0).posteriors()
self.assertAlmostEqual(a.mu, 15.093, 3)
self.assertAlmostEqual(a.sigma, 0.996, 3)
self.assertAlmostEqual(c.mu, 14.907, 3)
self.assertAlmostEqual(c.sigma, 0.996, 3)
def test_1vs1vs1_draw(self):
[a], [b], [c] = ttt.Game(
[[ttt.Rating()], [ttt.Rating()], [ttt.Rating()]], [0, 0, 0],
0.25).posteriors
self.assertAlmostEqual(a.mu, 25.000, 2)
self.assertAlmostEqual(a.sigma, 5.746947, 4)
self.assertAlmostEqual(b.mu, 25.000, 2)
self.assertAlmostEqual(b.sigma, 5.714755, 4)
ta = [ttt.Rating(ttt.Gaussian(25., 3.))]
tb = [ttt.Rating(ttt.Gaussian(25., 3.))]
tc = [ttt.Rating(ttt.Gaussian(29., 2.))]
[a], [b], [c] = ttt.Game([ta, tb, tc], [0, 0, 0], 0.25).posteriors
self.assertAlmostEqual(a.mu, 25.473, 2)
self.assertAlmostEqual(a.sigma, 2.645, 2)
self.assertAlmostEqual(b.mu, 25.505, 2)
self.assertAlmostEqual(b.sigma, 2.631, 2)
self.assertAlmostEqual(c.mu, 28.565, 2)
self.assertAlmostEqual(c.sigma, 1.888, 2)
def test_1vs1vs1_margin_0(self):
ta = [ttt.Rating(ttt.Gaussian(25., 1e-7))]
tb = [ttt.Rating(ttt.Gaussian(25., 1e-7))]
tc = [ttt.Rating(ttt.Gaussian(25., 1e-7))]
g_abc = ttt.Game([ta, tb, tc], [1, 2, 3], 0.)
g_acb = ttt.Game([ta, tb, tc], [1, 3, 2], 0.)
g_bac = ttt.Game([ta, tb, tc], [2, 1, 3], 0.)
g_bca = ttt.Game([ta, tb, tc], [3, 1, 2], 0.)
g_cab = ttt.Game([ta, tb, tc], [2, 3, 1], 0.)
g_cba = ttt.Game([ta, tb, tc], [3, 2, 1], 0.)
proba = 0
proba += g_abc.evidence
proba += g_acb.evidence
proba += g_bac.evidence
proba += g_bca.evidence
proba += g_cab.evidence
proba += g_cba.evidence
print("Corregir la evidencia multiequipos para que sume 1")
self.assertAlmostEqual(proba, 1.49999991)
def test_NvsNvsN_mixt(self):
ta = [
ttt.Player(ttt.Gaussian(12., 3.), 25.0 / 6, 25.0 / 300),
ttt.Player(ttt.Gaussian(18., 3.), 25.0 / 6, 25.0 / 300)
]
tb = [ttt.Player(ttt.Gaussian(30., 3.), 25.0 / 6, 25.0 / 300)]
tc = [
ttt.Player(ttt.Gaussian(14., 3.), 25.0 / 6, 25.0 / 300),
ttt.Player(ttt.Gaussian(16., 3.), 25.0 / 6, 25.0 / 300)
]
[a, b], [c], [d, e] = ttt.Game([ta, tb, tc], [1, 0, 0],
0.25).posteriors()
self.assertAlmostEqual(a.mu, 13.051, 3)
self.assertAlmostEqual(a.sigma, 2.864, 3)
self.assertAlmostEqual(b.mu, 19.051, 3)
self.assertAlmostEqual(b.sigma, 2.864, 3)
self.assertAlmostEqual(c.mu, 29.292, 3)
self.assertAlmostEqual(c.sigma, 2.764, 3)
self.assertAlmostEqual(d.mu, 13.658, 3)
self.assertAlmostEqual(d.sigma, 2.813, 3)
self.assertAlmostEqual(e.mu, 15.658, 3)
self.assertAlmostEqual(e.sigma, 2.813, 3)
def test_learning_curve(self):
composition = [[["aj"], ["bj"]], [["bj"], ["cj"]], [["cj"], ["aj"]]]
results = [[1, 0], [1, 0], [1, 0]]
priors = dict()
for k in ["aj", "bj", "cj"]:
priors[k] = ttt.Player(ttt.Gaussian(25., 25.0 / 3), 25.0 / 6,
25.0 / 300)
h = ttt.History(composition, results, [5, 6, 7], priors)
h.convergence()
lc = h.learning_curves()
self.assertEqual(lc["aj"][0][0], 5)
self.assertEqual(lc["aj"][-1][0], 7)
self.assertAlmostEqual(lc["aj"][-1][1].mu, 24.999, 3)
self.assertAlmostEqual(lc["aj"][-1][1].sigma, 5.420, 3)
self.assertAlmostEqual(lc["cj"][-1][1].mu, 25.001, 3)
self.assertAlmostEqual(lc["cj"][-1][1].sigma, 5.420, 3)
def test_1vs1(self):
ta = [ttt.Rating()]
tb = [ttt.Rating()]
g = ttt.Game([ta, tb], [1, 0])
[a], [b] = g.posteriors
self.assertAlmostEqual(a.mu, 20.79477925612302, 4)
self.assertAlmostEqual(b.mu, 29.20522074387697, 4)
self.assertAlmostEqual(a.sigma, 7.194481422570443, places=4)
g = ttt.Game([[ttt.Rating(ttt.Gaussian(29, 1))], [ttt.Rating()]],
[1, 0], 0.0)
[a], [b] = g.posteriors
self.assertAlmostEqual(a.mu, 28.896, places=2)
self.assertAlmostEqual(a.sigma, 0.996, places=2)
self.assertAlmostEqual(b.mu, 32.189, places=2)
self.assertAlmostEqual(b.sigma, 6.062, places=2)
def test_one_event_each(self):
agents = dict()
for k in ["a", "b", "c", "d", "e", "f"]:
agents[k] = ttt.Agent(
ttt.Player(ttt.Gaussian(25., 25.0 / 3), 25.0 / 6, 25.0 / 300),
ttt.Ninf, -ttt.inf)
b = ttt.Batch(composition=[[["a"], ["b"]], [["c"], ["d"]],
[["e"], ["f"]]],
results=[[1, 0], [0, 1], [1, 0]],
time=0,
agents=agents)
post = b.posteriors()
self.assertAlmostEqual(post["a"].mu, 29.205, 3)
self.assertAlmostEqual(post["a"].sigma, 7.194, 3)
self.assertAlmostEqual(post["b"].mu, 20.795, 3)
self.assertAlmostEqual(post["b"].sigma, 7.194, 3)
self.assertAlmostEqual(post["c"].mu, 20.795, 3)
self.assertAlmostEqual(post["c"].sigma, 7.194, 3)
self.assertEqual(b.convergence(), 1)
def test_trueSkill_Through_Time(self):
composition = [[["a"], ["b"]], [["a"], ["c"]], [["b"], ["c"]]]
results = [[1, 0], [0, 1], [1, 0]]
priors = dict()
for k in ["a", "b", "c"]:
priors[k] = ttt.Player(ttt.Gaussian(25., 25.0 / 3), 25.0 / 6,
25.0 / 300)
h = ttt.History(composition, results, [], priors)
step, i = h.convergence()
self.assertEqual(h.batches[2].skills["b"].elapsed, 1)
self.assertEqual(h.batches[2].skills["c"].elapsed, 1)
self.assertAlmostEqual(h.batches[0].posterior("a").mu, 25.0002673, 5)
self.assertAlmostEqual(h.batches[0].posterior("a").sigma, 5.41938162,
5)
self.assertAlmostEqual(h.batches[0].posterior("b").mu, 24.999465, 5)
self.assertAlmostEqual(h.batches[0].posterior("b").sigma, 5.419425831,
5)
self.assertAlmostEqual(h.batches[2].posterior("b").mu, 25.00053219, 5)
self.assertAlmostEqual(h.batches[2].posterior("b").sigma, 5.419696790,
5)
def test_sigma_beta_0(self):
composition = [[["a", "a_b", "b"], ["c", "c_d", "d"]],
[["e", "e_f", "f"], ["b", "b_c", "c"]],
[["a", "a_d", "d"], ["e", "e_f", "f"]]]
results = [[1, 0], [0, 1], [1, 0]]
priors = dict()
for k in ["a_b", "c_d", "e_f", "b_c", "a_d", "e_f"]:
priors[k] = ttt.Player(ttt.Gaussian(mu=0.0, sigma=1e-7),
beta=0.0,
gamma=0.2)
h = ttt.History(composition=composition,
results=results,
priors=priors,
mu=0.0,
sigma=6.0,
beta=1.0,
gamma=0.0)
step, i = h.convergence()
self.assertAlmostEqual(h.batches[0].posterior("a_b").mu, 0.0, 4)
self.assertAlmostEqual(h.batches[0].posterior("a_b").sigma, 0.0, 4)
self.assertAlmostEqual(h.batches[2].posterior("e_f").mu, -0.002, 4)
self.assertAlmostEqual(h.batches[2].posterior("e_f").sigma, 0.2, 4)
def test_history_init(self):
composition = [[["aa"], ["b"]], [["aa"], ["c"]], [["b"], ["c"]]]
results = [[1, 0], [0, 1], [1, 0]]
priors = dict()
for k in ["aa", "b", "c"]:
priors[k] = ttt.Player(ttt.Gaussian(25., 25.0 / 3), 25.0 / 6,
0.15 * 25.0 / 3)
h = ttt.History(composition, results, [1, 2, 3], priors)
p0 = h.batches[0].posteriors()
self.assertAlmostEqual(p0["aa"].mu, 29.205, 3)
self.assertAlmostEqual(p0["aa"].sigma, 7.19448, 3)
observed = h.batches[1].skills["aa"].forward.sigma
gamma = 0.15 * 25.0 / 3
expected = math.sqrt((gamma * 1)**2 +
h.batches[0].posterior("aa").sigma**2)
self.assertAlmostEqual(observed, expected)
observed = h.batches[1].posterior("aa")
[expected], [c] = ttt.Game(h.batches[1].within_priors(0),
[0, 1]).posteriors()
self.assertAlmostEqual(observed.mu, expected.mu, 3)
self.assertAlmostEqual(observed.sigma, expected.sigma, 3)
def test_batch_same_strength(self):
agents = dict()
for k in ["a", "b", "c", "d", "e", "f"]:
agents[k] = ttt.Agent(
ttt.Player(ttt.Gaussian(25., 25.0 / 3), 25.0 / 6, 25.0 / 300),
ttt.Ninf, -ttt.inf)
b = ttt.Batch([[["a"], ["b"]], [["a"], ["c"]], [["b"], ["c"]]],
[[1, 0], [0, 1], [1, 0]], 2, agents)
post = b.posteriors()
self.assertAlmostEqual(post["a"].mu, 24.96097, 3)
self.assertAlmostEqual(post["a"].sigma, 6.299, 3)
self.assertAlmostEqual(post["b"].mu, 27.09559, 3)
self.assertAlmostEqual(post["b"].sigma, 6.01033, 3)
self.assertAlmostEqual(post["c"].mu, 24.88968, 3)
self.assertAlmostEqual(post["c"].sigma, 5.86631, 3)
self.assertEqual(b.convergence() > 0, True)
post = b.posteriors()
self.assertAlmostEqual(post["a"].mu, 25.000, 3)
self.assertAlmostEqual(post["a"].sigma, 5.419, 3)
self.assertAlmostEqual(post["b"].mu, 25.000, 3)
self.assertAlmostEqual(post["b"].sigma, 5.419, 3)
self.assertAlmostEqual(post["c"].mu, 25.000, 3)
self.assertAlmostEqual(post["c"].sigma, 5.419, 3)
def test_1vs1vs1_draw(self):
[a], [b], [c] = ttt.Game(
[[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)]],
[0, 0, 0], 0.25).posteriors()
self.assertAlmostEqual(a.mu, 25.000, 3)
self.assertAlmostEqual(a.sigma, 5.729, 3)
self.assertAlmostEqual(b.mu, 25.000, 3)
self.assertAlmostEqual(b.sigma, 5.707, 3)
ta = [ttt.Player(ttt.Gaussian(25., 3.), 25.0 / 6, 25.0 / 300)]
tb = [ttt.Player(ttt.Gaussian(25., 3.), 25.0 / 6, 25.0 / 300)]
tc = [ttt.Player(ttt.Gaussian(29., 2.), 25.0 / 6, 25.0 / 300)]
[a], [b], [c] = ttt.Game([ta, tb, tc], [0, 0, 0], 0.25).posteriors()
self.assertAlmostEqual(a.mu, 25.489, 3)
self.assertAlmostEqual(a.sigma, 2.638, 3)
self.assertAlmostEqual(b.mu, 25.511, 3)
self.assertAlmostEqual(b.sigma, 2.629, 3)
self.assertAlmostEqual(c.mu, 28.556, 3)
self.assertAlmostEqual(c.sigma, 1.886, 3)
def test_1vs1(self):
ta = [ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)]
tb = [ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6, 25.0 / 300)]
g = ttt.Game([ta, tb], [0, 1], 0.0)
[a], [b] = g.posteriors()
self.assertAlmostEqual(a.mu, 20.79477925612302, 4)
self.assertAlmostEqual(b.mu, 29.20522074387697, 4)
self.assertAlmostEqual(a.sigma, 7.194481422570443, places=4)
g = ttt.Game([[ttt.Player(ttt.Gaussian(29., 1.), 25.0 / 6)],
[ttt.Player(ttt.Gaussian(25.0, 25.0 / 3), 25.0 / 6)]],
[0, 1])
[a], [b] = g.posteriors()
self.assertAlmostEqual(a.mu, 28.89648, places=4)
self.assertAlmostEqual(a.sigma, 0.9966043, places=4)
self.assertAlmostEqual(b.mu, 32.18921, places=4)
self.assertAlmostEqual(b.sigma, 6.062064, places=4)
ta = [ttt.Player(ttt.Gaussian(1.139, 0.531), 1.0, 0.2125)]
tb = [ttt.Player(ttt.Gaussian(15.568, 0.51), 1.0, 0.2125)]
g = ttt.Game([ta, tb], [0, 1], 0.0)
self.assertAlmostEqual(g.likelihoods[0][0].sigma, ttt.inf)
self.assertAlmostEqual(g.likelihoods[1][0].sigma, ttt.inf)
self.assertAlmostEqual(g.likelihoods[0][0].mu, 0.0)
import numpy as np
import matplotlib.pyplot as plt
import src as ttt
import os
name = os.path.basename(__file__).split(".py")[0]
N = ttt.Gaussian(mu=25,sigma=25/3)
mu= 25
sigma = 25/3
LENG = 1000
proporcion = 5/7
x = np.linspace(mu-3*sigma,mu+3*sigma,LENG)
y = np.linspace(mu-3*sigma,mu+3*sigma,LENG)
z = np.linspace(mu-3*sigma,mu+3*sigma,LENG)
print(N.trunc(30,True))
def gaus(x,mu,sigma):
y = 1/(sigma*(np.sqrt(2*np.pi)))*np.exp(-0.5*((x-mu)/sigma)**2)
return y
print(x[int(5/7*LENG)])
index = int(proporcion*LENG)
muTrunc, sigmaTrunc = ttt.Gaussian(mu,sigma).trunc(x[index],True)
for i in range(len(x)):
y[i] = gaus(x[i], muTrunc, sigmaTrunc)
if i <= int(3/5*LENG):
def test_pdf(self):
self.assertAlmostEqual(ttt.N01.pdf(0.3), 0.38138781)
N23 = ttt.Gaussian(2., 3.)
self.assertAlmostEqual(N23.pdf(0.3), 0.11325579)
def test_cdf(self):
self.assertAlmostEqual(ttt.N01.cdf(0.3), 0.617911409)
N23 = ttt.Gaussian(2., 3.)
self.assertAlmostEqual(N23.cdf(0.3), 0.28547031)
def test_ppf(self):
self.assertAlmostEqual(ttt.N01.ppf(0.3), -0.52440044)
N23 = ttt.Gaussian(2., 3.)
self.assertAlmostEqual(N23.ppf(0.3), 0.42679866)
def test_pdf(self):
self.assertAlmostEqual(ttt.pdf(0.3, ttt.N01.mu, ttt.N01.sigma),
0.38138781)
N23 = ttt.Gaussian(2., 3.)
self.assertAlmostEqual(ttt.pdf(0.3, N23.mu, N23.sigma), 0.11325579)
def test_dict_diff(self):
self.assertEqual((0.1, 0.05), ttt.max_tuple((0., 0.), (0.1, 0.05)))
self.assertEqual((0.1, 0.05), ttt.max_tuple((0., 0.05), (0.1, 0.0)))
d1 = dict([(0, ttt.Gaussian(2.1, 3.05))])
d2 = dict([(0, ttt.Gaussian(2.0, 3.0))])
ttt.dict_diff(d1, d2)
