Lines Matching defs:data
734 data = [random.uniform(-100, 100) for _ in range(100)]
735 for x in data:
1046 # Common tests for most univariate functions that take a data argument.
1053 # Fail when the data argument (first argument) is empty.
1058 """Return int data for various tests."""
1059 data = list(range(10))
1060 while data == sorted(data):
1061 random.shuffle(data)
1062 return data
1065 # Test that the function does not modify its input data.
1066 data = self.prepare_data()
1067 assert len(data) != 1 # Necessary to avoid infinite loop.
1068 assert data != sorted(data)
1069 saved = data[:]
1070 assert data is not saved
1071 _ = self.func(data)
1072 self.assertListEqual(data, saved, "data has been modified")
1075 # Test that the order of data points doesn't change the result.
1081 data = [1, 2, 3, 3, 3, 4, 5, 6]*100
1082 expected = self.func(data)
1083 random.shuffle(data)
1084 actual = self.func(data)
1088 # Test that the type of iterable data doesn't effect the result.
1093 def generator(data):
1094 return (obj for obj in data)
1095 data = self.prepare_data()
1096 expected = self.func(data)
1098 result = self.func(kind(data))
1103 data = range(20, 50, 3)
1104 expected = self.func(list(data))
1105 self.assertEqual(self.func(data), expected)
1108 # Test that function raises when given data of the wrong type.
1126 # Check the type of data elements doesn't affect the numeric result.
1139 data = [kind(x) for x in raw]
1140 result = type(expected)(self.func(data))
1148 individual data points. E.g. the mean of a list of Fractions should itself
1152 rely on the function returning the same type as its input data.
1176 # Test that functions keeps the same type as their data points.
1177 # (Excludes mixed data types.) This only tests the type of the return
1179 data = self.prepare_data()
1181 d = [kind(x) for x in data]
1207 # Override test for empty data.
1208 for data in ([], (), iter([])):
1209 self.assertEqual(self.func(data), (int, Fraction(0), 0))
1225 data = [D("0.001"), D("5.246"), D("1.702"), D("-0.025"),
1228 self.assertEqual(self.func(data),
1235 data = [random.uniform(-100, 1000) for _ in range(1000)]
1236 self.assertApproxEqual(float(self.func(data)[1]), math.fsum(data), rel=2e-16)
1250 # Check that mixed data types fail.
1313 data = [1, 2, inf, 3, -inf, 4]
1315 self.assertTrue(math.isnan(statistics._sum(data)[1]))
1320 data = [1, 2, inf, 3, -inf, 4]
1322 self.assertRaises(decimal.InvalidOperation, statistics._sum, data)
1327 data = [1, sNAN, 2]
1328 self.assertRaises(decimal.InvalidOperation, statistics._sum, data)
1349 data = [x]*count
1350 self.assertEqual(self.func(data), x)
1363 data = [0, 1, 2, 3, 3, 3, 4, 5, 5, 6, 7, 7, 7, 7, 8, 9]
1364 random.shuffle(data)
1365 self.assertEqual(self.func(data), 4.8125)
1369 data = [17.25, 19.75, 20.0, 21.5, 21.75, 23.25, 25.125, 27.5]
1370 random.shuffle(data)
1371 self.assertEqual(self.func(data), 22.015625)
1376 data = [D("1.634"), D("2.517"), D("3.912"), D("4.072"), D("5.813")]
1377 random.shuffle(data)
1378 self.assertEqual(self.func(data), D("3.5896"))
1383 data = [F(1, 2), F(2, 3), F(3, 4), F(4, 5), F(5, 6), F(6, 7), F(7, 8)]
1384 random.shuffle(data)
1385 self.assertEqual(self.func(data), F(1479, 1960))
1393 data = raw + [inf]
1394 result = self.func(data)
1400 data = [2, 4, 6, float('inf'), 1, 3, 5, float('-inf')]
1401 result = self.func(data)
1409 data = raw + [inf]
1410 result = self.func(data)
1414 # Test adding a large constant to every data point.
1416 data = [3.4, 4.5, 4.9, 6.7, 6.8, 7.2, 8.0, 8.1, 9.4]
1417 expected = self.func(data) + c
1419 result = self.func([x+c for x in data])
1424 data = [random.uniform(-3, 5) for _ in range(1000)]
1425 expected = self.func(data)
1426 actual = self.func(data*2)
1477 for data in [
1483 with self.subTest(data=data):
1485 self.func(data)
1489 data = [2, 4, 4, 8, 16, 16]
1490 random.shuffle(data)
1491 self.assertEqual(self.func(data), 6*4/5)
1495 data = [1/8, 1/4, 1/4, 1/2, 1/2]
1496 random.shuffle(data)
1497 self.assertEqual(self.func(data), 1/4)
1509 data = [D("0.05"), D("0.10"), D("0.20"), D("0.20")]
1510 random.shuffle(data)
1511 self.assertEqual(self.func(data), D("0.10"))
1512 data = [D("1.68"), D("0.32"), D("5.94"), D("2.75")]
1513 random.shuffle(data)
1514 self.assertEqual(self.func(data), D(66528)/70723)
1519 data = [F(1, 2), F(2, 3), F(3, 4), F(4, 5), F(5, 6), F(6, 7), F(7, 8)]
1520 random.shuffle(data)
1521 self.assertEqual(self.func(data), F(7*420, 4029))
1534 # Test multiplying every data point by a constant.
1536 data = [3.4, 4.5, 4.9, 6.7, 6.8, 7.2, 8.0, 8.1, 9.4]
1537 expected = self.func(data)*c
1538 result = self.func([x*c for x in data])
1543 data = [random.uniform(1, 5) for _ in range(1000)]
1544 expected = self.func(data)
1545 actual = self.func(data*2)
1577 data = super().prepare_data()
1578 if len(data)%2 != 1:
1579 data.append(2)
1580 return data
1583 # Test median with an even number of int data points.
1584 data = [1, 2, 3, 4, 5, 6]
1585 assert len(data)%2 == 0
1586 self.assertEqual(self.func(data), 3.5)
1589 # Test median with an odd number of int data points.
1590 data = [1, 2, 3, 4, 5, 6, 9]
1591 assert len(data)%2 == 1
1592 self.assertEqual(self.func(data), 4)
1597 data = [F(1, 7), F(2, 7), F(3, 7), F(4, 7), F(5, 7)]
1598 assert len(data)%2 == 1
1599 random.shuffle(data)
1600 self.assertEqual(self.func(data), F(3, 7))
1605 data = [F(1, 7), F(2, 7), F(3, 7), F(4, 7), F(5, 7), F(6, 7)]
1606 assert len(data)%2 == 0
1607 random.shuffle(data)
1608 self.assertEqual(self.func(data), F(1, 2))
1613 data = [D('2.5'), D('3.1'), D('4.2'), D('5.7'), D('5.8')]
1614 assert len(data)%2 == 1
1615 random.shuffle(data)
1616 self.assertEqual(self.func(data), D('4.2'))
1621 data = [D('1.2'), D('2.5'), D('3.1'), D('4.2'), D('5.7'), D('5.8')]
1622 assert len(data)%2 == 0
1623 random.shuffle(data)
1624 self.assertEqual(self.func(data), D('3.65'))
1628 # Test conservation of data element type for median.
1633 data = list(range(15))
1634 assert len(data)%2 == 1
1635 while data == sorted(data):
1636 random.shuffle(data)
1637 return data
1646 data = [1, 2, 3, 4, 5, 6]
1647 assert len(data)%2 == 0
1648 self.assertEqual(self.func(data), 3)
1653 data = [F(1, 7), F(2, 7), F(3, 7), F(4, 7), F(5, 7), F(6, 7)]
1654 assert len(data)%2 == 0
1655 random.shuffle(data)
1656 self.assertEqual(self.func(data), F(3, 7))
1661 data = [D('1.1'), D('2.2'), D('3.3'), D('4.4'), D('5.5'), D('6.6')]
1662 assert len(data)%2 == 0
1663 random.shuffle(data)
1664 self.assertEqual(self.func(data), D('3.3'))
1673 data = [1, 2, 3, 4, 5, 6]
1674 assert len(data)%2 == 0
1675 self.assertEqual(self.func(data), 4)
1680 data = [F(1, 7), F(2, 7), F(3, 7), F(4, 7), F(5, 7), F(6, 7)]
1681 assert len(data)%2 == 0
1682 random.shuffle(data)
1683 self.assertEqual(self.func(data), F(4, 7))
1688 data = [D('1.1'), D('2.2'), D('3.3'), D('4.4'), D('5.5'), D('6.6')]
1689 assert len(data)%2 == 0
1690 random.shuffle(data)
1691 self.assertEqual(self.func(data), D('4.4'))
1696 # Doesn't conserve data element types, so don't use TestMedianType.
1702 data = [12, 13, 14, 14, 14, 15, 15]
1703 assert len(data)%2 == 1
1704 self.assertEqual(self.func(data), 14)
1706 data = [12, 13, 14, 14, 14, 14, 15]
1707 assert len(data)%2 == 1
1708 self.assertEqual(self.func(data), 13.875)
1710 data = [5, 10, 10, 15, 20, 20, 20, 20, 25, 25, 30]
1711 assert len(data)%2 == 1
1712 self.assertEqual(self.func(data, 5), 19.375)
1714 data = [16, 18, 18, 18, 18, 20, 20, 20, 22, 22, 22, 24, 24, 26, 28]
1715 assert len(data)%2 == 1
1716 self.assertApproxEqual(self.func(data, 2), 20.66666667, tol=1e-8)
1720 data = [5, 10, 10, 15, 20, 20, 20, 25, 25, 30]
1721 assert len(data)%2 == 0
1722 self.assertApproxEqual(self.func(data, 5), 19.16666667, tol=1e-8)
1724 data = [2, 3, 4, 4, 4, 5]
1725 assert len(data)%2 == 0
1726 self.assertApproxEqual(self.func(data), 3.83333333, tol=1e-8)
1728 data = [2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6]
1729 assert len(data)%2 == 0
1730 self.assertEqual(self.func(data), 4.5)
1732 data = [3, 4, 4, 4, 5, 5, 5, 5, 6, 6]
1733 assert len(data)%2 == 0
1734 self.assertEqual(self.func(data), 4.75)
1738 # Yet again, failure of median_grouped to conserve the data type
1742 data = [x]*count
1743 self.assertEqual(self.func(data), float(x))
1754 data = [F(5, 4), F(9, 4), F(13, 4), F(13, 4), F(17, 4)]
1755 assert len(data)%2 == 1
1756 random.shuffle(data)
1757 self.assertEqual(self.func(data), 3.0)
1762 data = [F(5, 4), F(9, 4), F(13, 4), F(13, 4), F(17, 4), F(17, 4)]
1763 assert len(data)%2 == 0
1764 random.shuffle(data)
1765 self.assertEqual(self.func(data), 3.25)
1770 data = [D('5.5'), D('6.5'), D('6.5'), D('7.5'), D('8.5')]
1771 assert len(data)%2 == 1
1772 random.shuffle(data)
1773 self.assertEqual(self.func(data), 6.75)
1778 data = [D('5.5'), D('5.5'), D('6.5'), D('6.5'), D('7.5'), D('8.5')]
1779 assert len(data)%2 == 0
1780 random.shuffle(data)
1781 self.assertEqual(self.func(data), 6.5)
1783 data = [D('5.5'), D('5.5'), D('6.5'), D('7.5'), D('7.5'), D('8.5')]
1784 assert len(data)%2 == 0
1785 random.shuffle(data)
1786 self.assertEqual(self.func(data), 7.0)
1790 data = [2.25, 2.5, 2.5, 2.75, 2.75, 3.0, 3.0, 3.25, 3.5, 3.75]
1791 self.assertEqual(self.func(data, 0.25), 2.875)
1792 data = [2.25, 2.5, 2.5, 2.75, 2.75, 2.75, 3.0, 3.0, 3.25, 3.5, 3.75]
1793 self.assertApproxEqual(self.func(data, 0.25), 2.83333333, tol=1e-8)
1794 data = [220, 220, 240, 260, 260, 260, 260, 280, 280, 300, 320, 340]
1795 self.assertEqual(self.func(data, 20), 265.0)
1798 # Test median_grouped with str, bytes data types for data and interval
1799 data = ["", "", ""]
1800 self.assertRaises(TypeError, self.func, data)
1802 data = [b"", b"", b""]
1803 self.assertRaises(TypeError, self.func, data)
1805 data = [1, 2, 3]
1807 self.assertRaises(TypeError, self.func, data, interval)
1809 data = [1, 2, 3]
1811 self.assertRaises(TypeError, self.func, data, interval)
1821 # Make sure test data has exactly one mode.
1826 data = range(20, 50, 3)
1827 self.assertEqual(self.func(data), 20)
1830 # Test mode with nominal data.
1831 data = 'abcbdb'
1832 self.assertEqual(self.func(data), 'b')
1833 data = 'fe fi fo fum fi fi'.split()
1834 self.assertEqual(self.func(data), 'fi')
1837 # Test mode with discrete numeric data.
1838 data = list(range(10))
1840 d = data + [i]
1845 # Test mode with bimodal data.
1846 data = [1, 1, 2, 2, 2, 2, 3, 4, 5, 6, 6, 6, 6, 7, 8, 9, 9]
1847 assert data.count(2) == data.count(6) == 4
1849 self.assertEqual(self.func(data), 2)
1852 # Test mode when data points are all unique.
1853 data = list(range(10))
1855 self.assertEqual(self.func(data), 0)
1858 # Test that mode raises TypeError if given None as data.
1890 for data, expected_mean, kind in [
1899 actual_mean = fmean(data)
1915 fmean() # missing data argument
1971 data = [x]*count
1972 self.assertEqual(self.func(data), 0)
1977 data = [0.123456789012345]*10000
1980 result = self.func(data)
1985 # Test that shifting the data by a constant amount does not affect
1995 data = [x + shift for x in raw]
1996 self.assertApproxEqual(self.func(data), expected)
2004 data = [x + shift for x in raw]
2005 self.assertEqual(self.func(data), expected)
2008 # Test that iter data and list data give the same result.
2015 data = [random.uniform(-3, 8) for _ in range(1000)]
2016 expected = self.func(data)
2017 self.assertEqual(self.func(iter(data)), expected)
2026 # Test the variance against an exact result for uniform data.
2027 data = list(range(10000))
2028 random.shuffle(data)
2030 self.assertEqual(self.func(data), expected)
2033 # Test population variance with int data.
2034 data = [4, 7, 13, 16]
2036 self.assertEqual(self.func(data), exact)
2039 # Test population variance with Fraction data.
2041 data = [F(1, 4), F(1, 4), F(3, 4), F(7, 4)]
2043 result = self.func(data)
2048 # Test population variance with Decimal data.
2050 data = [D("12.1"), D("12.2"), D("12.5"), D("12.9")]
2052 result = self.func(data)
2057 data = [0, 0, 1]
2059 result = self.func(data)
2075 # Test sample variance with int data.
2076 data = [4, 7, 13, 16]
2078 self.assertEqual(self.func(data), exact)
2081 # Test sample variance with Fraction data.
2083 data = [F(1, 4), F(1, 4), F(3, 4), F(7, 4)]
2085 result = self.func(data)
2090 # Test sample variance with Decimal data.
2092 data = [D(2), D(2), D(7), D(9)]
2094 result = self.func(data)
2099 data = (1.0, 2.0)
2100 self.assertEqual(self.func(data), 0.5)
2101 self.assertEqual(self.func(data, xbar=2.0), 1.0)
2104 data = [0, 0, 2]
2106 result = self.func(data)
2117 data = [random.uniform(-17, 24) for _ in range(1000)]
2118 expected = math.sqrt(statistics.pvariance(data))
2119 self.assertEqual(self.func(data), expected)
2123 data = (3, 6, 7, 10)
2124 self.assertEqual(self.func(data), 2.5)
2125 self.assertEqual(self.func(data, mu=0.5), 6.5)
2236 data = [random.uniform(-2, 9) for _ in range(1000)]
2237 expected = math.sqrt(statistics.variance(data))
2238 self.assertAlmostEqual(self.func(data), expected)
2241 data = (1.0, 2.0)
2242 self.assertEqual(self.func(data, xbar=2.0), 1.0)
2274 for data, kind in [
2282 actual_mean = geometric_mean(data)
2317 geometric_mean() # missing data argument
2355 data = [120, 200, 250, 320, 350]
2356 random.shuffle(data)
2371 self.assertEqual(expected, quantiles(data, n=n))
2372 self.assertEqual(len(quantiles(data, n=n)), n - 1)
2375 result = quantiles(map(datatype, data), n=n)
2384 sdata = sorted(data)
2387 padded_data = data + [lo, hi]
2389 quantiles(data, n=n),
2391 (n, data),
2397 act = quantiles(map(f, data), n=n)
2401 data = random.choices(range(100), k=k)
2402 q1, q2, q3 = quantiles(data)
2403 self.assertEqual(q2, statistics.median(data))
2410 data = [100, 200, 400, 800]
2411 random.shuffle(data)
2426 self.assertEqual(expected, quantiles(data, n=n, method="inclusive"))
2427 self.assertEqual(len(quantiles(data, n=n, method="inclusive")), n - 1)
2430 result = quantiles(map(datatype, data), n=n, method="inclusive")
2437 act = quantiles(map(f, data), n=n, method="inclusive")
2444 # Whenever n is smaller than the number of data points, running
2447 data = [random.randrange(10_000) for i in range(501)]
2448 actual = quantiles(data, n=32, method='inclusive')
2449 data.remove(min(data))
2450 data.remove(max(data))
2451 expected = quantiles(data, n=32)
2455 data = random.choices(range(100), k=k)
2456 q1, q2, q3 = quantiles(data, method='inclusive')
2457 self.assertEqual(q2, statistics.median(data))
2462 data = [10.0] * n
2463 self.assertEqual(quantiles(data), [10.0, 10.0, 10.0])
2464 self.assertEqual(quantiles(data, method='inclusive'),
2470 data = [random.expovariate(0.2) for i in range(total)]
2471 while len(set(data)) != total:
2472 data.append(random.expovariate(0.2))
2473 data.sort()
2479 [bisect.bisect(data, q) for q in quantiles(data, n=n)],
2486 pos = [bisect.bisect(data, q) for q in quantiles(data, n=n)]
2508 quantiles([10], n=4) # not enough data points
2510 quantiles([10, None, 30], n=4) # data is non-numeric
2636 data = [96, 107, 90, 92, 110]
2638 self.assertEqual(NormalDist.from_samples(data), NormalDist(99, 9))
2640 self.assertEqual(NormalDist.from_samples(tuple(data)), NormalDist(99, 9))
2642 self.assertEqual(NormalDist.from_samples(iter(data)), NormalDist(99, 9))
2652 nnd = NewNormalDist.from_samples(data)
2660 data = X.samples(n)
2661 self.assertEqual(len(data), n)
2662 self.assertEqual(set(map(type, data)), {float})
2663 # mean(data) expected to fall within 8 standard deviations
2664 xbar = self.module.mean(data)