def test_distributions_normal_json_serialization(): d = NormalDistribution(5, 2) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "NormalDistribution") assert_array_equal(e.parameters, [5, 2]) assert_array_equal(e.summaries, [0, 0, 0])
def test_uniform_kernel():
d = UniformKernelDensity([1, 3, 5, 6, 2, 2, 3, 2, 2])
assert_equal(round(d.log_probability(2.2), 4), -0.4055)
assert_equal(round(d.log_probability(6.2), 4), -2.1972)
assert_equal(d.log_probability(10), float('-inf'))
d = UniformKernelDensity([1, 100, 200])
assert_not_equal(round(d.log_probability(2.2), 4), -0.4055)
assert_not_equal(round(d.log_probability(6.2), 4), -2.1972)
d.summarize([1, 3, 5, 6, 2])
d.summarize([2, 3, 2, 2])
d.from_summaries()
assert_equal(round(d.log_probability(2.2), 4), -0.4055)
assert_equal(round(d.log_probability(6.2), 4), -2.1972)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "UniformKernelDensity")
assert_equal(round(e.log_probability(2.2), 4), -0.4055)
assert_equal(round(e.log_probability(6.2), 4), -2.1972)
f = pickle.loads(pickle.dumps(e))
assert_equal(e.name, "UniformKernelDensity")
assert_equal(round(f.log_probability(2.2), 4), -0.4055)
assert_equal(round(f.log_probability(6.2), 4), -2.1972)
def test_gamma():
d = GammaDistribution(5, 2)
assert_equal(round(d.log_probability(4), 4), -2.1671)
d.fit([2.3, 4.3, 2.7, 2.3, 3.1, 3.2, 3.4, 3.1, 2.9, 2.8])
assert_equal(round(d.parameters[0], 4), 31.8806)
assert_equal(round(d.parameters[1], 4), 10.5916)
d = GammaDistribution(2, 7)
assert_not_equal(round(d.log_probability(4), 4), -2.1671)
d.summarize([2.3, 4.3, 2.7])
d.summarize([2.3, 3.1, 3.2])
d.summarize([3.4, 3.1, 2.9, 2.8])
d.from_summaries()
assert_equal(round(d.parameters[0], 4), 31.8806)
assert_equal(round(d.parameters[1], 4), 10.5916)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "GammaDistribution")
assert_equal(round(e.parameters[0], 4), 31.8806)
assert_equal(round(e.parameters[1], 4), 10.5916)
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "GammaDistribution")
assert_equal(round(f.parameters[0], 4), 31.8806)
assert_equal(round(f.parameters[1], 4), 10.5916)
def test_lognormal():
d = LogNormalDistribution(5, 2)
assert_equal(round(d.log_probability(5), 4), -4.6585)
d.fit([5.1, 5.03, 4.98, 5.05, 4.91, 5.2, 5.1, 5., 4.8, 5.21])
assert_equal(round(d.parameters[0], 4), 1.6167)
assert_equal(round(d.parameters[1], 4), 0.0237)
d.summarize([5.1, 5.03, 4.98, 5.05])
d.summarize([4.91, 5.2, 5.1])
d.summarize([5., 4.8, 5.21])
d.from_summaries()
assert_equal(round(d.parameters[0], 4), 1.6167)
assert_equal(round(d.parameters[1], 4), 0.0237)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "LogNormalDistribution")
assert_equal(round(e.parameters[0], 4), 1.6167)
assert_equal(round(e.parameters[1], 4), 0.0237)
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "LogNormalDistribution")
assert_equal(round(f.parameters[0], 4), 1.6167)
assert_equal(round(f.parameters[1], 4), 0.0237)
def test_lognormal(): d = LogNormalDistribution(5, 2) assert_equal(round(d.log_probability(5), 4), -4.6585) d.fit([5.1, 5.03, 4.98, 5.05, 4.91, 5.2, 5.1, 5., 4.8, 5.21]) assert_equal(round(d.parameters[0], 4), 1.6167) assert_equal(round(d.parameters[1], 4), 0.0237) d.summarize([5.1, 5.03, 4.98, 5.05]) d.summarize([4.91, 5.2, 5.1]) d.summarize([5., 4.8, 5.21]) d.from_summaries() assert_equal(round(d.parameters[0], 4), 1.6167) assert_equal(round(d.parameters[1], 4), 0.0237) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "LogNormalDistribution") assert_equal(round(e.parameters[0], 4), 1.6167) assert_equal(round(e.parameters[1], 4), 0.0237) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "LogNormalDistribution") assert_equal(round(f.parameters[0], 4), 1.6167) assert_equal(round(f.parameters[1], 4), 0.0237)
def test_gamma(): d = GammaDistribution(5, 2) assert_equal(round(d.log_probability(4), 4), -2.1671) d.fit([2.3, 4.3, 2.7, 2.3, 3.1, 3.2, 3.4, 3.1, 2.9, 2.8]) assert_equal(round(d.parameters[0], 4), 31.8806) assert_equal(round(d.parameters[1], 4), 10.5916) d = GammaDistribution(2, 7) assert_not_equal(round(d.log_probability(4), 4), -2.1671) d.summarize([2.3, 4.3, 2.7]) d.summarize([2.3, 3.1, 3.2]) d.summarize([3.4, 3.1, 2.9, 2.8]) d.from_summaries() assert_equal(round(d.parameters[0], 4), 31.8806) assert_equal(round(d.parameters[1], 4), 10.5916) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "GammaDistribution") assert_equal(round(e.parameters[0], 4), 31.8806) assert_equal(round(e.parameters[1], 4), 10.5916) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "GammaDistribution") assert_equal(round(f.parameters[0], 4), 31.8806) assert_equal(round(f.parameters[1], 4), 10.5916)
def test_uniform_kernel():
d = UniformKernelDensity([1, 3, 5, 6, 2, 2, 3, 2, 2])
assert_equal(round(d.log_probability(2.2), 4), -0.4055)
assert_equal(round(d.log_probability(6.2), 4), -2.1972)
assert_equal(d.log_probability(10), float('-inf'))
d = UniformKernelDensity([1, 100, 200])
assert_not_equal(round(d.log_probability(2.2), 4), -0.4055)
assert_not_equal(round(d.log_probability(6.2), 4), -2.1972)
d.summarize([1, 3, 5, 6, 2])
d.summarize([2, 3, 2, 2])
d.from_summaries()
assert_equal(round(d.log_probability(2.2), 4), -0.4055)
assert_equal(round(d.log_probability(6.2), 4), -2.1972)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "UniformKernelDensity")
assert_equal(round(e.log_probability(2.2), 4), -0.4055)
assert_equal(round(e.log_probability(6.2), 4), -2.1972)
f = pickle.loads(pickle.dumps(e))
assert_equal(e.name, "UniformKernelDensity")
assert_equal(round(f.log_probability(2.2), 4), -0.4055)
assert_equal(round(f.log_probability(6.2), 4), -2.1972)
def test_distributions_normal_json_serialization(): d = NormalDistribution(5, 2) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "NormalDistribution") assert_array_equal(e.parameters, [5, 2]) assert_array_equal(e.summaries, [0, 0, 0])
def test_distributions_uniform_json_serialization(): d = UniformDistribution(0, 10) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "UniformDistribution") assert_array_equal(e.parameters, [0, 10]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_json_serialization(): d = UniformDistribution(0, 10) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "UniformDistribution") assert_array_equal(e.parameters, [0, 10]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_discrete():
d = DiscreteDistribution({'A': 0.25, 'C': 0.25, 'G': 0.25, 'T': 0.25})
assert_equal(d.log_probability('C'), -1.3862943611198906)
assert_equal(d.log_probability('A'), d.log_probability('C'))
assert_equal(d.log_probability('G'), d.log_probability('T'))
assert_equal(d.log_probability('a'), float('-inf'))
seq = "ACGTACGTTGCATGCACGCGCTCTCGCGC"
d.fit(list(seq))
assert_equal(d.log_probability('C'), -0.9694005571881036)
assert_equal(d.log_probability('A'), -1.9810014688665833)
assert_equal(d.log_probability('T'), -1.575536360758419)
seq = "ACGTGTG"
d.fit(list(seq), weights=[0., 1., 2., 3., 4., 5., 6.])
assert_equal(d.log_probability('A'), float('-inf'))
assert_equal(d.log_probability('C'), -3.044522437723423)
assert_equal(d.log_probability('G'), -0.5596157879354228)
d.summarize(list("ACG"), weights=[0., 1., 2.])
d.summarize(list("TGT"), weights=[3., 4., 5.])
d.summarize(list("G"), weights=[6.])
d.from_summaries()
assert_equal(d.log_probability('A'), float('-inf'))
assert_equal(round(d.log_probability('C'), 4), -3.0445)
assert_equal(round(d.log_probability('G'), 4), -0.5596)
d = DiscreteDistribution({'A': 0.0, 'B': 1.0})
d.summarize(list("ABABABAB"))
d.summarize(list("ABAB"))
d.summarize(list("BABABABABABABABABA"))
d.from_summaries(inertia=0.75)
assert_equal(d.parameters[0], {'A': 0.125, 'B': 0.875})
d = DiscreteDistribution({'A': 0.0, 'B': 1.0})
d.summarize(list("ABABABAB"))
d.summarize(list("ABAB"))
d.summarize(list("BABABABABABABABABA"))
d.from_summaries(inertia=0.5)
assert_equal(d.parameters[0], {'A': 0.25, 'B': 0.75})
d.freeze()
d.fit(list('ABAABBAAAAAAAAAAAAAAAAAA'))
assert_equal(d.parameters[0], {'A': 0.25, 'B': 0.75})
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "DiscreteDistribution")
assert_equal(e.parameters[0], {'A': 0.25, 'B': 0.75})
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "DiscreteDistribution")
assert_equal(f.parameters[0], {'A': 0.25, 'B': 0.75})
def test_discrete():
d = DiscreteDistribution({'A': 0.25, 'C': 0.25, 'G': 0.25, 'T': 0.25})
assert_equal(d.log_probability('C'), -1.3862943611198906)
assert_equal(d.log_probability('A'), d.log_probability('C'))
assert_equal(d.log_probability('G'), d.log_probability('T'))
assert_equal(d.log_probability('a'), float('-inf'))
seq = "ACGTACGTTGCATGCACGCGCTCTCGCGC"
d.fit(list(seq))
assert_equal(d.log_probability('C'), -0.9694005571881036)
assert_equal(d.log_probability('A'), -1.9810014688665833)
assert_equal(d.log_probability('T'), -1.575536360758419)
seq = "ACGTGTG"
d.fit(list(seq), weights=[0., 1., 2., 3., 4., 5., 6.])
assert_equal(d.log_probability('A'), float('-inf'))
assert_equal(d.log_probability('C'), -3.044522437723423)
assert_equal(d.log_probability('G'), -0.5596157879354228)
d.summarize(list("ACG"), weights=[0., 1., 2.])
d.summarize(list("TGT"), weights=[3., 4., 5.])
d.summarize(list("G"), weights=[6.])
d.from_summaries()
assert_equal(d.log_probability('A'), float('-inf'))
assert_equal(round(d.log_probability('C'), 4), -3.0445)
assert_equal(round(d.log_probability('G'), 4), -0.5596)
d = DiscreteDistribution({'A': 0.0, 'B': 1.0})
d.summarize(list("ABABABAB"))
d.summarize(list("ABAB"))
d.summarize(list("BABABABABABABABABA"))
d.from_summaries(inertia=0.75)
assert_equal(d.parameters[0], {'A': 0.125, 'B': 0.875})
d = DiscreteDistribution({'A': 0.0, 'B': 1.0})
d.summarize(list("ABABABAB"))
d.summarize(list("ABAB"))
d.summarize(list("BABABABABABABABABA"))
d.from_summaries(inertia=0.5)
assert_equal(d.parameters[0], {'A': 0.25, 'B': 0.75})
d.freeze()
d.fit(list('ABAABBAAAAAAAAAAAAAAAAAA'))
assert_equal(d.parameters[0], {'A': 0.25, 'B': 0.75})
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "DiscreteDistribution")
assert_equal(e.parameters[0], {'A': 0.25, 'B': 0.75})
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "DiscreteDistribution")
assert_equal(f.parameters[0], {'A': 0.25, 'B': 0.75})
def test_bernoulli():
d = BernoulliDistribution(0.6)
assert_equal(d.probability(0), 0.4)
assert_equal(d.probability(1), 0.6)
assert_equal(d.parameters[0], 1 - d.probability(0))
assert_equal(d.parameters[0], d.probability(1))
d.fit([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
assert_not_equal(d.probability(1), 1.0)
assert_equal(d.probability(0), 1.0)
a = [0.0, 0.0, 0.0]
b = [1.0, 1.0, 1.0]
c = [1.0, 1.0, 1.0]
d.summarize(a)
d.from_summaries()
assert_equal(d.probability(0), 1)
assert_equal(d.probability(1), 0)
d.summarize(a)
d.summarize(b)
d.from_summaries()
assert_equal(d.probability(0), 0.5)
assert_equal(d.probability(1), 0.5)
assert_equal(d.parameters[0], d.probability(0))
assert_equal(d.parameters[0], d.probability(1))
d.summarize(a)
d.summarize(b)
d.summarize(c)
d.from_summaries()
assert_equal(round(d.probability(0), 4), 0.3333)
assert_equal(round(d.probability(1), 4), 0.6667)
assert_equal(d.parameters[0], d.probability(1))
d = BernoulliDistribution.from_samples([0.0, 0.0, 0.0, 0.0, 0.0, 1.0])
assert_equal(round(d.probability(0), 4), 0.8333)
assert_equal(round(d.probability(1), 4), 0.1667)
assert_almost_equal(d.parameters[0], d.probability(1))
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "BernoulliDistribution")
assert_equal(round(e.parameters[0], 4), 0.1667)
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "BernoulliDistribution")
assert_equal(round(f.parameters[0], 4), 0.1667)
def test_bernoulli(): d = BernoulliDistribution(0.6) assert_equal(d.probability(0), 0.4) assert_equal(d.probability(1), 0.6) assert_equal(d.parameters[0], 1-d.probability(0)) assert_equal(d.parameters[0], d.probability(1)) d.fit([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) assert_not_equal(d.probability(1), 1.0) assert_equal(d.probability(0), 1.0) a = [0.0, 0.0, 0.0] b = [1.0, 1.0, 1.0] c = [1.0, 1.0, 1.0] d.summarize(a) d.from_summaries() assert_equal(d.probability(0), 1) assert_equal(d.probability(1), 0) d.summarize(a) d.summarize(b) d.from_summaries() assert_equal(d.probability(0), 0.5) assert_equal(d.probability(1), 0.5) assert_equal(d.parameters[0], d.probability(0)) assert_equal(d.parameters[0], d.probability(1)) d.summarize(a) d.summarize(b) d.summarize(c) d.from_summaries() assert_equal(round(d.probability(0), 4), 0.3333) assert_equal(round(d.probability(1), 4), 0.6667) assert_equal(d.parameters[0], d.probability(1)) d = BernoulliDistribution.from_samples([0.0, 0.0, 0.0, 0.0, 0.0, 1.0]) assert_equal(round(d.probability(0), 4), 0.8333) assert_equal(round(d.probability(1), 4), 0.1667) assert_almost_equal(d.parameters[0], d.probability(1)) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "BernoulliDistribution") assert_equal(round(e.parameters[0], 4), 0.1667) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "BernoulliDistribution") assert_equal(round(f.parameters[0], 4), 0.1667)
def test_triangular_kernel():
d = TriangleKernelDensity([1, 6, 3, 4, 5, 2])
assert_equal(round(d.log_probability(6.5), 4), -2.4849)
d = TriangleKernelDensity([1, 8, 100])
assert_not_equal(round(d.log_probability(6.5), 4), -2.4849)
d.summarize([1, 6])
d.summarize([3, 4, 5])
d.summarize([2])
d.from_summaries()
assert_equal(round(d.log_probability(6.5), 4), -2.4849)
d.freeze()
d.fit([1, 4, 6, 7, 3, 5, 7, 8, 3, 3, 4])
assert_equal(round(d.log_probability(6.5), 4), -2.4849)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "TriangleKernelDensity")
assert_equal(round(e.log_probability(6.5), 4), -2.4849)
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "TriangleKernelDensity")
assert_equal(round(f.log_probability(6.5), 4), -2.4849)
def test_gaussian_kernel():
d = GaussianKernelDensity([0, 4, 3, 5, 7, 4, 2])
assert_equal(round(d.log_probability(3.3), 4), -1.7042)
d.fit([1, 6, 8, 3, 2, 4, 7, 2])
assert_equal(round(d.log_probability(1.2), 4), -2.0237)
d.fit([1, 0, 108], weights=[2., 3., 278.])
assert_equal(round(d.log_probability(110), 4), -2.9368)
assert_equal(round(d.log_probability(0), 4), -5.1262)
d.summarize([1, 6, 8, 3])
d.summarize([2, 4, 7])
d.summarize([2])
d.from_summaries()
assert_equal(round(d.log_probability(1.2), 4), -2.0237)
d.summarize([1, 0, 108], weights=[2., 3., 278.])
d.from_summaries()
assert_equal(round(d.log_probability(110), 4), -2.9368)
assert_equal(round(d.log_probability(0), 4), -5.1262)
d.freeze()
d.fit([1, 3, 5, 4, 6, 7, 3, 4, 2])
assert_equal(round(d.log_probability(110), 4), -2.9368)
assert_equal(round(d.log_probability(0), 4), -5.1262)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "GaussianKernelDensity")
assert_equal(round(e.log_probability(110), 4), -2.9368)
assert_equal(round(e.log_probability(0), 4), -5.1262)
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "GaussianKernelDensity")
assert_equal(round(f.log_probability(110), 4), -2.9368)
assert_equal(round(f.log_probability(0), 4), -5.1262)
def test_exponential():
d = ExponentialDistribution(3)
assert_equal(round(d.log_probability(8), 4), -22.9014)
d.fit([2.7, 2.9, 3.8, 1.9, 2.7, 1.6, 1.3, 1.0, 1.9])
assert_equal(round(d.parameters[0], 4), 0.4545)
d = ExponentialDistribution(4)
assert_not_equal(round(d.log_probability(8), 4), -22.9014)
d.summarize([2.7, 2.9, 3.8])
d.summarize([1.9, 2.7, 1.6])
d.summarize([1.3, 1.0, 1.9])
d.from_summaries()
assert_equal(round(d.parameters[0], 4), 0.4545)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "ExponentialDistribution")
assert_equal(round(e.parameters[0], 4), 0.4545)
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "ExponentialDistribution")
assert_equal(round(f.parameters[0], 4), 0.4545)
def test_exponential(): d = ExponentialDistribution(3) assert_equal(round(d.log_probability(8), 4), -22.9014) d.fit([2.7, 2.9, 3.8, 1.9, 2.7, 1.6, 1.3, 1.0, 1.9]) assert_equal(round(d.parameters[0], 4), 0.4545) d = ExponentialDistribution(4) assert_not_equal(round(d.log_probability(8), 4), -22.9014) d.summarize([2.7, 2.9, 3.8]) d.summarize([1.9, 2.7, 1.6]) d.summarize([1.3, 1.0, 1.9]) d.from_summaries() assert_equal(round(d.parameters[0], 4), 0.4545) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "ExponentialDistribution") assert_equal(round(e.parameters[0], 4), 0.4545) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "ExponentialDistribution") assert_equal(round(f.parameters[0], 4), 0.4545)
def test_gaussian_kernel(): d = GaussianKernelDensity([0, 4, 3, 5, 7, 4, 2]) assert_equal(round(d.log_probability(3.3), 4), -1.7042) d.fit([1, 6, 8, 3, 2, 4, 7, 2]) assert_equal(round(d.log_probability(1.2), 4), -2.0237) d.fit([1, 0, 108], weights=[2., 3., 278.]) assert_equal(round(d.log_probability(110), 4), -2.9368) assert_equal(round(d.log_probability(0), 4), -5.1262) d.summarize([1, 6, 8, 3]) d.summarize([2, 4, 7]) d.summarize([2]) d.from_summaries() assert_equal(round(d.log_probability(1.2), 4), -2.0237) d.summarize([1, 0, 108], weights=[2., 3., 278.]) d.from_summaries() assert_equal(round(d.log_probability(110), 4), -2.9368) assert_equal(round(d.log_probability(0), 4), -5.1262) d.freeze() d.fit([1, 3, 5, 4, 6, 7, 3, 4, 2]) assert_equal(round(d.log_probability(110), 4), -2.9368) assert_equal(round(d.log_probability(0), 4), -5.1262) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "GaussianKernelDensity") assert_equal(round(e.log_probability(110), 4), -2.9368) assert_equal(round(e.log_probability(0), 4), -5.1262) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "GaussianKernelDensity") assert_equal(round(f.log_probability(110), 4), -2.9368) assert_equal(round(f.log_probability(0), 4), -5.1262)
def test_triangular_kernel(): d = TriangleKernelDensity([1, 6, 3, 4, 5, 2]) assert_equal(round(d.log_probability(6.5), 4), -2.4849) d = TriangleKernelDensity([1, 8, 100]) assert_not_equal(round(d.log_probability(6.5), 4), -2.4849) d.summarize([1, 6]) d.summarize([3, 4, 5]) d.summarize([2]) d.from_summaries() assert_equal(round(d.log_probability(6.5), 4), -2.4849) d.freeze() d.fit([1, 4, 6, 7, 3, 5, 7, 8, 3, 3, 4]) assert_equal(round(d.log_probability(6.5), 4), -2.4849) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "TriangleKernelDensity") assert_equal(round(e.log_probability(6.5), 4), -2.4849) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "TriangleKernelDensity") assert_equal(round(f.log_probability(6.5), 4), -2.4849)
def test_independent():
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
ExponentialDistribution(2)])
assert_equal(round(d.log_probability((4, 1)), 4), -3.0439)
assert_equal(round(d.log_probability((100, 0.001)), 4), -1129.0459)
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
ExponentialDistribution(2)],
weights=[18., 1.])
assert_equal(round(d.log_probability((4, 1)), 4), -32.5744)
assert_equal(round(d.log_probability((100, 0.001)), 4), -20334.5764)
d.fit([(5, 1), (5.2, 1.7), (4.7, 1.9), (4.9, 2.4), (4.5, 1.2)])
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.86)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 0.2417)
assert_equal(round(d.parameters[0][1].parameters[0], 4), 0.6098)
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
UniformDistribution(0, 10)])
d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0),
(2, 20)],
inertia=0.5)
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0),
(2, 20)],
inertia=0.75)
assert_not_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_not_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_not_equal(d.parameters[0][1].parameters[0], -2.5)
assert_not_equal(d.parameters[0][1].parameters[1], 15)
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
UniformDistribution(0, 10)])
d.summarize([(0, 0), (5, 0), (3, 0)])
d.summarize([(5, -5), (7, 0)])
d.summarize([(3, 0), (4, 0), (5, 0), (2, 20)])
d.from_summaries(inertia=0.5)
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
d.freeze()
d.fit([(1, 7), (7, 2), (2, 4), (2, 4), (1, 4)])
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "IndependentComponentsDistribution")
assert_equal(round(e.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(e.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(e.parameters[0][1].parameters[0], -2.5)
assert_equal(e.parameters[0][1].parameters[1], 15)
f = pickle.loads(pickle.dumps(e))
assert_equal(e.name, "IndependentComponentsDistribution")
assert_equal(round(f.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(f.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(f.parameters[0][1].parameters[0], -2.5)
assert_equal(f.parameters[0][1].parameters[1], 15)
X = numpy.array([[0.5, 0.2, 0.7], [0.3, 0.1, 0.9], [0.4, 0.3, 0.8],
[0.3, 0.3, 0.9], [0.3, 0.2, 0.6], [0.5, 0.2, 0.8]])
d = IndependentComponentsDistribution.from_samples(
X, distributions=NormalDistribution)
assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4)
assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4)
assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4)
assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4)
assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4)
assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4)
d = IndependentComponentsDistribution.from_samples(
X, distributions=ExponentialDistribution)
assert_almost_equal(d.parameters[0][0].parameters[0], 2.6087, 4)
assert_almost_equal(d.parameters[0][1].parameters[0], 4.6154, 4)
assert_almost_equal(d.parameters[0][2].parameters[0], 1.2766, 4)
d = IndependentComponentsDistribution.from_samples(X,
distributions=[
NormalDistribution,
NormalDistribution,
NormalDistribution
])
assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4)
assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4)
assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4)
assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4)
assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4)
assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4)
d = IndependentComponentsDistribution.from_samples(
X,
distributions=[
NormalDistribution, LogNormalDistribution, ExponentialDistribution
])
assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4)
assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4)
assert_almost_equal(d.parameters[0][1].parameters[0], -1.5898, 4)
assert_almost_equal(d.parameters[0][1].parameters[1], 0.36673, 4)
assert_almost_equal(d.parameters[0][2].parameters[0], 1.27660, 4)
def test_normal():
d = NormalDistribution(5, 2)
e = NormalDistribution(5., 2.)
assert_true(isinstance(d.log_probability(5), float))
assert_true(isinstance(d.log_probability([5]), float))
assert_true(isinstance(d.log_probability([5, 6]), numpy.ndarray))
assert_almost_equal(d.log_probability(5), -1.61208571, 8)
assert_equal(d.log_probability(5), e.log_probability(5))
assert_equal(d.log_probability(5), d.log_probability(5.))
assert_almost_equal(d.log_probability(0), -4.737085713764219)
assert_equal(d.log_probability(0), e.log_probability(0.))
d.fit([5, 4, 5, 4, 6, 5, 6, 5, 4, 6, 5, 4])
assert_almost_equal(d.parameters[0], 4.9167, 4)
assert_almost_equal(d.parameters[1], 0.7592, 4)
assert_not_equal(d.log_probability(4), e.log_probability(4))
assert_almost_equal(d.log_probability(4), -1.3723678499651766)
assert_almost_equal(d.log_probability(18), -149.13140399454429)
assert_almost_equal(d.log_probability(1e8), -8674697942168743.0, -4)
d = NormalDistribution(5, 1e-10)
assert_almost_equal(d.log_probability(1e100), -4.9999999999999994e+219)
d.fit([0, 2, 3, 2, 100], weights=[0, 5, 2, 3, 200])
assert_equal(round(d.parameters[0], 4), 95.3429)
assert_equal(round(d.parameters[1], 4), 20.8276)
assert_equal(round(d.log_probability(50), 8), -6.32501194)
d = NormalDistribution(5, 2)
d.fit([0, 5, 3, 5, 7, 3, 4, 5, 2], inertia=0.5)
assert_equal(round(d.parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[1], 4), 1.9655)
d.summarize([0, 2], weights=[0, 5])
d.summarize([3, 2], weights=[2, 3])
d.summarize([100], weights=[200])
d.from_summaries()
assert_equal(round(d.parameters[0], 4), 95.3429)
assert_equal(round(d.parameters[1], 4), 20.8276)
d.freeze()
d.fit([0, 1, 1, 2, 3, 2, 1, 2, 2])
assert_equal(round(d.parameters[0], 4), 95.3429)
assert_equal(round(d.parameters[1], 4), 20.8276)
d.thaw()
d.fit([5, 4, 5, 4, 6, 5, 6, 5, 4, 6, 5, 4])
assert_equal(round(d.parameters[0], 4), 4.9167)
assert_equal(round(d.parameters[1], 4), 0.7592)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "NormalDistribution")
assert_equal(round(e.parameters[0], 4), 4.9167)
assert_equal(round(e.parameters[1], 4), 0.7592)
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "NormalDistribution")
assert_equal(round(f.parameters[0], 4), 4.9167)
assert_equal(round(f.parameters[1], 4), 0.7592)
def test_uniform():
d = UniformDistribution(0, 10)
assert_almost_equal(d.log_probability(2.34), -2.3025850929940455, 8)
assert_equal(d.log_probability(2), d.log_probability(8))
assert_equal(d.log_probability(10), d.log_probability(3.4))
assert_equal(d.log_probability(1.7), d.log_probability(9.7))
assert_equal(d.log_probability(10.0001), float("-inf"))
assert_equal(d.log_probability(-0.0001), float("-inf"))
for i in range(10):
data = numpy.random.randn(100) * 100
d.fit(data)
assert_equal(d.parameters[0], data.min())
assert_equal(d.parameters[1], data.max())
minimum, maximum = data.min(), data.max()
for i in range(100):
sample = d.sample()
assert_less_equal(minimum, sample)
assert_less_equal(sample, maximum)
d = UniformDistribution(0, 10)
d.fit([-5, 20], inertia=0.5)
assert_equal(d.parameters[0], -2.5)
assert_equal(d.parameters[1], 15)
d.fit([-100, 100], inertia=1.0)
assert_equal(d.parameters[0], -2.5)
assert_equal(d.parameters[1], 15)
d.summarize([0, 50, 2, 24, 28])
d.summarize([-20, 7, 8, 4])
d.from_summaries(inertia=0.75)
assert_equal(d.parameters[0], -6.875)
assert_equal(d.parameters[1], 23.75)
d.summarize([0, 100])
d.summarize([100, 200])
d.from_summaries()
assert_equal(d.parameters[0], 0)
assert_equal(d.parameters[1], 200)
d.freeze()
d.fit([0, 1, 6, 7, 8, 3, 4, 5, 2])
assert_equal(d.parameters, [0, 200])
d.thaw()
d.fit([0, 1, 6, 7, 8, 3, 4, 5, 2])
assert_equal(d.parameters, [0, 8])
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "UniformDistribution")
assert_equal(e.parameters, [0, 8])
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "UniformDistribution")
assert_equal(f.parameters, [0, 8])
def test_uniform():
d = UniformDistribution(0, 10)
assert_almost_equal(d.log_probability(2.34), -2.3025850929940455, 8)
assert_equal(d.log_probability(2), d.log_probability(8))
assert_equal(d.log_probability(10), d.log_probability(3.4))
assert_equal(d.log_probability(1.7), d.log_probability(9.7))
assert_equal(d.log_probability(10.0001), float("-inf"))
assert_equal(d.log_probability(-0.0001), float("-inf"))
for i in range(10):
data = numpy.random.randn(100) * 100
d.fit(data)
assert_equal(d.parameters[0], data.min())
assert_equal(d.parameters[1], data.max())
minimum, maximum = data.min(), data.max()
for i in range(100):
sample = d.sample()
assert_less_equal(minimum, sample)
assert_less_equal(sample, maximum)
d = UniformDistribution(0, 10)
d.fit([-5, 20], inertia=0.5)
assert_equal(d.parameters[0], -2.5)
assert_equal(d.parameters[1], 15)
d.fit([-100, 100], inertia=1.0)
assert_equal(d.parameters[0], -2.5)
assert_equal(d.parameters[1], 15)
d.summarize([0, 50, 2, 24, 28])
d.summarize([-20, 7, 8, 4])
d.from_summaries(inertia=0.75)
assert_equal(d.parameters[0], -6.875)
assert_equal(d.parameters[1], 23.75)
d.summarize([0, 100])
d.summarize([100, 200])
d.from_summaries()
assert_equal(d.parameters[0], 0)
assert_equal(d.parameters[1], 200)
d.freeze()
d.fit([0, 1, 6, 7, 8, 3, 4, 5, 2])
assert_equal(d.parameters, [0, 200])
d.thaw()
d.fit([0, 1, 6, 7, 8, 3, 4, 5, 2])
assert_equal(d.parameters, [0, 8])
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "UniformDistribution")
assert_equal(e.parameters, [0, 8])
f = pickle.loads(pickle.dumps(e))
assert_equal(f.name, "UniformDistribution")
assert_equal(f.parameters, [0, 8])
def test_independent():
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
ExponentialDistribution(2)])
assert_equal(round(d.log_probability((4, 1)), 4), -3.0439)
assert_equal(round(d.log_probability((100, 0.001)), 4), -1129.0459)
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
ExponentialDistribution(2)],
weights=[18., 1.])
assert_equal(round(d.log_probability((4, 1)), 4), -0.1536)
assert_equal(round(d.log_probability((100, 0.001)), 4), -1126.1556)
d.fit([(5, 1), (5.2, 1.7), (4.7, 1.9), (4.9, 2.4), (4.5, 1.2)])
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.86)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 0.2417)
assert_equal(round(d.parameters[0][1].parameters[0], 4), 0.6098)
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
UniformDistribution(0, 10)])
d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0),
(2, 20)],
inertia=0.5)
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0),
(2, 20)],
inertia=0.75)
assert_not_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_not_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_not_equal(d.parameters[0][1].parameters[0], -2.5)
assert_not_equal(d.parameters[0][1].parameters[1], 15)
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2),
UniformDistribution(0, 10)])
d.summarize([(0, 0), (5, 0), (3, 0)])
d.summarize([(5, -5), (7, 0)])
d.summarize([(3, 0), (4, 0), (5, 0), (2, 20)])
d.from_summaries(inertia=0.5)
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
d.freeze()
d.fit([(1, 7), (7, 2), (2, 4), (2, 4), (1, 4)])
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "IndependentComponentsDistribution")
assert_equal(round(e.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(e.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(e.parameters[0][1].parameters[0], -2.5)
assert_equal(e.parameters[0][1].parameters[1], 15)
f = pickle.loads(pickle.dumps(e))
assert_equal(e.name, "IndependentComponentsDistribution")
assert_equal(round(f.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(f.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(f.parameters[0][1].parameters[0], -2.5)
assert_equal(f.parameters[0][1].parameters[1], 15)
def test_independent():
d = IndependentComponentsDistribution(
[NormalDistribution(5, 2), ExponentialDistribution(2)])
assert_equal(round(d.log_probability((4, 1)), 4), -3.0439)
assert_equal(round(d.log_probability((100, 0.001)), 4), -1129.0459)
d = IndependentComponentsDistribution([NormalDistribution(5, 2),
ExponentialDistribution(2)],
weights=[18., 1.])
assert_equal(round(d.log_probability((4, 1)), 4), -0.1536)
assert_equal(round(d.log_probability((100, 0.001)), 4), -1126.1556)
d.fit([(5, 1), (5.2, 1.7), (4.7, 1.9), (4.9, 2.4), (4.5, 1.2)])
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.86)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 0.2417)
assert_equal(round(d.parameters[0][1].parameters[0], 4), 0.6098)
d = IndependentComponentsDistribution([NormalDistribution(5, 2),
UniformDistribution(0, 10)])
d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0),
(3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.5)
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0),
(3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.75)
assert_not_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_not_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_not_equal(d.parameters[0][1].parameters[0], -2.5)
assert_not_equal(d.parameters[0][1].parameters[1], 15)
d = IndependentComponentsDistribution([NormalDistribution(5, 2),
UniformDistribution(0, 10)])
d.summarize([(0, 0), (5, 0), (3, 0)])
d.summarize([(5, -5), (7, 0)])
d.summarize([(3, 0), (4, 0), (5, 0), (2, 20)])
d.from_summaries(inertia=0.5)
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
d.freeze()
d.fit([(1, 7), (7, 2), (2, 4), (2, 4), (1, 4)])
assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(d.parameters[0][1].parameters[0], -2.5)
assert_equal(d.parameters[0][1].parameters[1], 15)
e = Distribution.from_json(d.to_json())
assert_equal(e.name, "IndependentComponentsDistribution")
assert_equal(round(e.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(e.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(e.parameters[0][1].parameters[0], -2.5)
assert_equal(e.parameters[0][1].parameters[1], 15)
f = pickle.loads(pickle.dumps(e))
assert_equal(e.name, "IndependentComponentsDistribution")
assert_equal(round(f.parameters[0][0].parameters[0], 4), 4.3889)
assert_equal(round(f.parameters[0][0].parameters[1], 4), 1.9655)
assert_equal(f.parameters[0][1].parameters[0], -2.5)
assert_equal(f.parameters[0][1].parameters[1], 15)
def test_normal(): d = NormalDistribution(5, 2) e = NormalDistribution(5., 2.) assert_true(isinstance(d.log_probability(5), float)) assert_true(isinstance(d.log_probability([5]), float)) assert_true(isinstance(d.log_probability([5, 6]), numpy.ndarray)) assert_almost_equal(d.log_probability(5), -1.61208571, 8) assert_equal(d.log_probability(5), e.log_probability(5)) assert_equal(d.log_probability(5), d.log_probability(5.)) assert_almost_equal(d.log_probability(0), -4.737085713764219) assert_equal(d.log_probability(0), e.log_probability(0.)) d.fit([5, 4, 5, 4, 6, 5, 6, 5, 4, 6, 5, 4]) assert_almost_equal(d.parameters[0], 4.9167, 4) assert_almost_equal(d.parameters[1], 0.7592, 4) assert_not_equal(d.log_probability(4), e.log_probability(4)) assert_almost_equal(d.log_probability(4), -1.3723678499651766) assert_almost_equal(d.log_probability(18), -149.13140399454429) assert_almost_equal(d.log_probability(1e8), -8674697942168743.0, -4) d = NormalDistribution(5, 1e-10) assert_almost_equal(d.log_probability(1e100), -4.9999999999999994e+219) d.fit([0, 2, 3, 2, 100], weights=[0, 5, 2, 3, 200]) assert_equal(round(d.parameters[0], 4), 95.3429) assert_equal(round(d.parameters[1], 4), 20.8276) assert_equal(round(d.log_probability(50), 8), -6.32501194) d = NormalDistribution(5, 2) d.fit([0, 5, 3, 5, 7, 3, 4, 5, 2], inertia=0.5) assert_equal(round(d.parameters[0], 4), 4.3889) assert_equal(round(d.parameters[1], 4), 1.9655) d.summarize([0, 2], weights=[0, 5]) d.summarize([3, 2], weights=[2, 3]) d.summarize([100], weights=[200]) d.from_summaries() assert_equal(round(d.parameters[0], 4), 95.3429) assert_equal(round(d.parameters[1], 4), 20.8276) d.freeze() d.fit([0, 1, 1, 2, 3, 2, 1, 2, 2]) assert_equal(round(d.parameters[0], 4), 95.3429) assert_equal(round(d.parameters[1], 4), 20.8276) d.thaw() d.fit([5, 4, 5, 4, 6, 5, 6, 5, 4, 6, 5, 4]) assert_equal(round(d.parameters[0], 4), 4.9167) assert_equal(round(d.parameters[1], 4), 0.7592) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "NormalDistribution") assert_equal(round(e.parameters[0], 4), 4.9167) assert_equal(round(e.parameters[1], 4), 0.7592) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "NormalDistribution") assert_equal(round(f.parameters[0], 4), 4.9167) assert_equal(round(f.parameters[1], 4), 0.7592)
def test_independent(): d = IndependentComponentsDistribution( [NormalDistribution(5, 2), ExponentialDistribution(2)]) assert_equal(round(d.log_probability((4, 1)), 4), -3.0439) assert_equal(round(d.log_probability((100, 0.001)), 4), -1129.0459) d = IndependentComponentsDistribution([NormalDistribution(5, 2), ExponentialDistribution(2)], weights=[18., 1.]) assert_equal(round(d.log_probability((4, 1)), 4), -32.5744) assert_equal(round(d.log_probability((100, 0.001)), 4), -20334.5764) d.fit([(5, 1), (5.2, 1.7), (4.7, 1.9), (4.9, 2.4), (4.5, 1.2)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.86) assert_equal(round(d.parameters[0][0].parameters[1], 4), 0.2417) assert_equal(round(d.parameters[0][1].parameters[0], 4), 0.6098) d = IndependentComponentsDistribution([NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.75) assert_not_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_not_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_not_equal(d.parameters[0][1].parameters[0], -2.5) assert_not_equal(d.parameters[0][1].parameters[1], 15) d = IndependentComponentsDistribution([NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.summarize([(0, 0), (5, 0), (3, 0)]) d.summarize([(5, -5), (7, 0)]) d.summarize([(3, 0), (4, 0), (5, 0), (2, 20)]) d.from_summaries(inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.freeze() d.fit([(1, 7), (7, 2), (2, 4), (2, 4), (1, 4)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(e.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(e.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(e.parameters[0][1].parameters[0], -2.5) assert_equal(e.parameters[0][1].parameters[1], 15) f = pickle.loads(pickle.dumps(e)) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(f.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(f.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(f.parameters[0][1].parameters[0], -2.5) assert_equal(f.parameters[0][1].parameters[1], 15) X = numpy.array([[0.5, 0.2, 0.7], [0.3, 0.1, 0.9], [0.4, 0.3, 0.8], [0.3, 0.3, 0.9], [0.3, 0.2, 0.6], [0.5, 0.2, 0.8]]) d = IndependentComponentsDistribution.from_samples(X, distributions=NormalDistribution) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4) assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4) d = IndependentComponentsDistribution.from_samples(X, distributions=ExponentialDistribution) assert_almost_equal(d.parameters[0][0].parameters[0], 2.6087, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 4.6154, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 1.2766, 4) d = IndependentComponentsDistribution.from_samples(X, distributions=[NormalDistribution, NormalDistribution, NormalDistribution]) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4) assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4) d = IndependentComponentsDistribution.from_samples(X, distributions=[NormalDistribution, LogNormalDistribution, ExponentialDistribution]) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], -1.5898, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.36673, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 1.27660, 4)
