def test_compare_recursive(self): n = 20 seq_a = [ordinal([(1, 1)])] seq_b = [ordinal([(1, 1), (0, 1)])] while len(seq_a) < n: seq_a.append(ordinal([(seq_a[-1], 2), (2, 1)])) seq_b.append(ordinal([(seq_b[-1], 1)])) for i in range(n): a = seq_a[i] b = seq_b[i] self.assertTrue(a < b) self.assertTrue(a <= b) self.assertTrue(a != b) self.assertFalse(a > b) self.assertFalse(a >= b) self.assertFalse(a == b) for i in range(1, n): b = seq_a[i] for j in range(i): a = seq_a[j] self.assertTrue(a < b) self.assertTrue(a <= b) self.assertTrue(a != b) self.assertFalse(a > b) self.assertFalse(a >= b) self.assertFalse(a == b) b = seq_b[i] for j in range(i): a = seq_b[j] self.assertTrue(a < b) self.assertTrue(a <= b) self.assertTrue(a != b) self.assertFalse(a > b) self.assertFalse(a >= b) self.assertFalse(a == b)
def test_constants(self): """ Small test case to ensure all the provided constants, such as omega, are actually the ordinals they're supposed to be. """ from ordinal import ordinal, omega, epsilon_0, zeta_0 self.assertEqual(omega, ordinal('omega')) self.assertEqual(epsilon_0, ordinal('epsilon_0')) self.assertEqual(zeta_0, ordinal('zeta_0')) self.assertTrue(1 < omega) self.assertTrue(omega < epsilon_0) self.assertTrue(epsilon_0 < zeta_0)
def seasons(i): """Seasons as strings for searching""" i = int(i) if i == 0: return 'Specials' else: return ordinal(i)
def test_add_large(self): small = 2**8191 - 1 big = ordinal([(2, 1), (1, 2)]) huge = ordinal([(big, 3)]) operands = [ ordinal([(small, 7), (0, 2)]), ordinal([(big, 2), (0, 5)]), ordinal([(huge, 1), (small, 8), (0, 3)]), ordinal([(huge, 4), (big, 3), (0, 6)]) ] results = [[(small, 14), (0, 2)], [(big, 2), (0, 5)], [(huge, 1), (small, 8), (0, 3)], [(huge, 4), (big, 3), (0, 6)], [(big, 2), (small, 7), (0, 2)], [(big, 4), (0, 5)], [(huge, 1), (small, 8), (0, 3)], [(huge, 4), (big, 3), (0, 6)], [(huge, 1), (small, 15), (0, 2)], [(huge, 1), (big, 2), (0, 5)], [(huge, 2), (small, 8), (0, 3)], [(huge, 5), (big, 3), (0, 6)], [(huge, 4), (big, 3), (small, 7), (0, 2)], [(huge, 4), (big, 5), (0, 5)], [(huge, 5), (small, 8), (0, 3)], [(huge, 8), (big, 3), (0, 6)]] for (a, b), r in zip(itertools.product(*[operands] * 2), results): self.assertEqual(r, ordinal(a + b).cnf)
def mainMenu(scaleLetter, num, reps): if len(sys.argv) < 3: scaleLetter = input( "Please enter a scale. eg: g# or ab or a: ").title() num = float(input("Please enter flash interval: ")) reps = int( input("Please enter number of reps or press enter to continue: ")) degrees = int(input("Please enter number of keys to use: ")) reps = 99 if reps == 0 else reps for lvl in range(degrees, 8): if lvl == 5: reps = 49 # selected scale to practice scale = scales[scaleLetter] if os.name == "posix": os.system("clear") else: os.system("cls") print(f"Flashing keys in the {scaleLetter} scale") print(f" Interval: {num}s") print(f" Reps: {reps}") print(f" Degree: {lvl}") print(" Notes: " + ", ".join(scale[0:8])) print("===================") print() print() print(' Position: Key') for r in range(1, lvl + 1): print(' {} tone of {}: {}'.format(ordinal(r), scaleLetter, scale[r - 1])) input("Press enter to continue... ") print() print() for i in range(reps): r = randint(1, lvl) print(' {} tone of {}: '.format(ordinal(r), scaleLetter), end=' ', flush=True) sleep(num) print(scale[r - 1]) sleep(1) mainMenu(scaleLetter, num, reps)
def seasons(i): """Seasons as strings for searching""" try: i = int(i) except: i = 0 if i == 0: return 'Specials' else: return ordinal(i)
def test_multiply_basic(self): operands = [ ordinal([]), # 0 ordinal([(0, 1)]), # 1 ordinal([(0, 4)]), # 4 ordinal([(1, 1)]), # omega ordinal([(2, 9)]), # omega**2 * 9 ] results = [[], [], [], [], [], [], [(0, 1)], [(0, 4)], [(1, 1)], [(2, 9)], [], [(0, 4)], [(0, 16)], [(1, 1)], [(2, 9)], [], [(1, 1)], [(1, 4)], [(2, 1)], [(3, 9)], [], [(2, 9)], [(2, 36)], [(3, 1)], [(4, 9)]] for (a, b), r in zip(itertools.product(*[operands] * 2), results): self.assertEqual(r, ordinal(a * b).cnf)
def test_add_basic(self): operands = [ ordinal([]), # 0 ordinal([(0, 1)]), # 1 ordinal([(0, 4)]), # 4 ordinal([(1, 1)]), # omega ordinal([(2, 9)]), # omega**2 * 9 ] results = [[], [(0, 1)], [(0, 4)], [(1, 1)], [(2, 9)], [(0, 1)], [(0, 2)], [(0, 5)], [(1, 1)], [(2, 9)], [(0, 4)], [(0, 5)], [(0, 8)], [(1, 1)], [(2, 9)], [(1, 1)], [(1, 1), (0, 1)], [(1, 1), (0, 4)], [(1, 2)], [(2, 9)], [(2, 9)], [(2, 9), (0, 1)], [(2, 9), (0, 4)], [(2, 9), (1, 1)], [(2, 18)]] for (a, b), r in zip(itertools.product(*[operands] * 2), results): self.assertEqual(r, ordinal(a + b).cnf)
def test_string(self): self.assertEqual("Enter a number!", ordinal.ordinal('b'))
def test_third(self): self.assertEqual("3rd", ordinal.ordinal(3))
def test_st(self): self.assertEqual('21st',ordinal.ordinal(21))
def test_eleventh(self): self.assertEqual("11th", ordinal.ordinal(11))
def test_instance_warn(self): warnings.simplefilter('error') with self.assertRaises(UserWarning): ordinal(-1) with self.assertRaises(UserWarning): ordinal([], unchecked=True) with self.assertRaises(UserWarning): ordinal([(1 / 2, 1)], unchecked=True) with self.assertRaises(UserWarning): ordinal([(-1, 1)], unchecked=True) with self.assertRaises(UserWarning): ordinal([(1, 1 / 2)], unchecked=True) with self.assertRaises(UserWarning): ordinal([(1, -1)], unchecked=True) warnings.resetwarnings()
def test_decimal(self): self.assertEqual("1st", ordinal.ordinal(1.0))
def test_string_input(self): self.assertEqual("1st", ordinal.ordinal("1")) self.assertEqual("Improper input", ordinal.ordinal("abc"))
def test_one_thousand_two(self): self.assertEqual("1002nd", ordinal.ordinal(1002))
def test_negative_one(self): self.assertEqual("-1st", ordinal.ordinal(-1))
def test_twelfth(self): self.assertEqual("12th", ordinal.ordinal(12))
def test_fourth(self): self.assertEqual("4th", ordinal.ordinal(4))
def test_zero(self): self.assertEqual("0th", ordinal.ordinal(0))
def test_integers(self): """ Sanity tests involving ordinals that are mathematically integers and the builtin int objects. Since integers are very straightforward and cheap to test with, we do a lot of the low level sanity checks here. """ from ordinal import ordinal, ordinal_type for i in range(100): self.assertTrue(isinstance(i, ordinal_type)) self.assertTrue(isinstance(ordinal(i), ordinal_type)) self.assertEqual(i == i, ordinal(i) == i) self.assertEqual(i == i, ordinal(i) == ordinal(i)) self.assertEqual(i != i, ordinal(i) != i) self.assertEqual(i != i, ordinal(i) != ordinal(i)) self.assertEqual(i > i, ordinal(i) > i) self.assertEqual(i > i, ordinal(i) > ordinal(i)) self.assertEqual(i >= i, ordinal(i) >= i) self.assertEqual(i >= i, ordinal(i) >= ordinal(i)) self.assertEqual(i < i, ordinal(i) < i) self.assertEqual(i < i, ordinal(i) < ordinal(i)) self.assertEqual(i <= i, ordinal(i) <= i) self.assertEqual(i <= i, ordinal(i) <= ordinal(i)) for j in range(1, 100): for i in range(j): self.assertEqual(i == j, ordinal(i) == j) self.assertEqual(i == j, ordinal(i) == ordinal(j)) self.assertEqual(i != j, ordinal(i) != j) self.assertEqual(i != j, ordinal(i) != ordinal(j)) self.assertEqual(i > j, ordinal(i) > j) self.assertEqual(i > j, ordinal(i) > ordinal(j)) self.assertEqual(i >= j, ordinal(i) >= j) self.assertEqual(i >= j, ordinal(i) >= ordinal(j)) self.assertEqual(i < j, ordinal(i) < j) self.assertEqual(i < j, ordinal(i) < ordinal(j)) self.assertEqual(i <= j, ordinal(i) <= j) self.assertEqual(i <= j, ordinal(i) <= ordinal(j)) self.assertEqual(j == i, ordinal(j) == i) self.assertEqual(j == i, ordinal(j) == ordinal(i)) self.assertEqual(j != i, ordinal(j) != i) self.assertEqual(j != i, ordinal(j) != ordinal(i)) self.assertEqual(j > i, ordinal(j) > i) self.assertEqual(j > i, ordinal(j) > ordinal(i)) self.assertEqual(j >= i, ordinal(j) >= i) self.assertEqual(j >= i, ordinal(j) >= ordinal(i)) self.assertEqual(j < i, ordinal(j) < i) self.assertEqual(j < i, ordinal(j) < ordinal(i)) self.assertEqual(j <= i, ordinal(j) <= i) self.assertEqual(j <= i, ordinal(j) <= ordinal(i)) with self.assertRaises(ValueError): ordinal(-1) with self.assertRaises(TypeError): ordinal(0.5)
def test_first(self): self.assertEqual("1st", ordinal.ordinal(1))
def test_st(self): self.assertEqual('21st', ordinal.ordinal(21))
def test_multiply_mid(self): operands = [ ordinal([(6, 8), (5, 7), (3, 6), (0, 5)]), ordinal([(ordinal([(1, 1), (0, 2)]), 3), (0, 4)]), ordinal([(ordinal([(1, 1), (0, 4)]), 3), (0, 2)]) ] results = [[(12, 8), (11, 7), (9, 6), (6, 40)], [(ordinal([(1, 1), (0, 2)]), 3), (6, 32)], [(ordinal([(1, 1), (0, 4)]), 3), (6, 16)], [(ordinal([(1, 1), (0, 8)]), 8), (ordinal([(1, 1), (0, 7)]), 7), (ordinal([(1, 1), (0, 5)]), 6), (ordinal([(1, 1), (0, 2)]), 15)], [(ordinal([(1, 2), (0, 2)]), 3), (ordinal([(1, 1), (0, 2)]), 12)], [(ordinal([(1, 2), (0, 4)]), 3), (ordinal([(1, 1), (0, 2)]), 6)], [(ordinal([(1, 1), (0, 10)]), 8), (ordinal([(1, 1), (0, 9)]), 7), (ordinal([(1, 1), (0, 7)]), 6), (ordinal([(1, 1), (0, 4)]), 15)], [(ordinal([(1, 2), (0, 2)]), 3), (ordinal([(1, 1), (0, 4)]), 12)], [(ordinal([(1, 2), (0, 4)]), 3), (ordinal([(1, 1), (0, 4)]), 6)]] for (a, b), r in zip(itertools.product(*[operands] * 2), results): self.assertEqual(r, ordinal(a * b).cnf)
def test_forth(self): self.assertEqual("4th", ordinal.ordinal(4))
def test_instance_eq(self): self.assertEqual(ordinal(0), 0) self.assertEqual(ordinal(1), 1) self.assertEqual(ordinal(3), ordinal(3)) self.assertEqual(ordinal('omega'), omega) self.assertEqual(ordinal(omega), omega)
def test_first(self): self.assertEqual("1st", ordinal.ordinal(1)) # first ordinal is document from importing
def test_nd(self): self.assertEqual('2nd',ordinal.ordinal(2))
def test_second(self): self.assertEqual("2nd", ordinal.ordinal(2))
def test_third(self): self.assertEqual(ordinal.ordinal(3), "3rd")
def test_eleven(self): self.assertNotEqual(ordinal.ordinal(111), "111st")
def test_instance_cnf(self): self.assertEqual(ordinal(0).cnf, []) self.assertEqual(ordinal(1).cnf, [(0, 1)]) self.assertEqual(ordinal(7).cnf, [(0, 7)]) self.assertEqual(ordinal('omega').cnf, [(1, 1)]) self.assertEqual(ordinal([(4, 3), (2, 1)]).cnf, [(4, 3), (2, 1)])
def test_other(self): self.assertEqual(ordinal.ordinal(34), "34th")
def test_compare(self): self.assertTrue(ordinal(omega) == omega) self.assertTrue(ordinal(omega) >= omega) self.assertTrue(ordinal(omega) <= omega) self.assertFalse(ordinal(omega) != omega) self.assertFalse(ordinal(omega) > omega) self.assertFalse(ordinal(omega) < omega) self.assertTrue(ordinal(0) == 0) self.assertTrue(ordinal(0) < 1) self.assertFalse(ordinal(1) < 0) self.assertFalse(ordinal(omega) < 0) self.assertTrue(ordinal(omega) > 1) ord_ref = ordinal([(3, 2), (1, 4), (0, 1)]) for cnf in [[(1, 4), (0, 1)], [(1, 9)], [(3, 1), (1, 8)], [(3, 1), (2, 6), (1, 7), (0, 8)], [(3, 2), (1, 3), (0, 7)], [(3, 2), (1, 4)]]: ord_cmp = ordinal(cnf) self.assertTrue(ord_ref > ord_cmp) self.assertTrue(ord_ref >= ord_cmp) self.assertTrue(ord_ref != ord_cmp) self.assertFalse(ord_ref < ord_cmp) self.assertFalse(ord_ref <= ord_cmp) self.assertFalse(ord_ref == ord_cmp) for cnf in [[(3, 2), (1, 4), (0, 1)]]: ord_cmp = ordinal(cnf) self.assertTrue(ord_ref == ord_cmp) self.assertTrue(ord_ref >= ord_cmp) self.assertTrue(ord_ref <= ord_cmp) self.assertFalse(ord_ref < ord_cmp) self.assertFalse(ord_ref > ord_cmp) self.assertFalse(ord_ref != ord_cmp) for cnf in [[(3, 2), (1, 4), (0, 2)], [(3, 2), (1, 5)], [(3, 2), (2, 1)], [(3, 3), (0, 1)], [(4, 1)]]: ord_cmp = ordinal(cnf) self.assertTrue(ord_ref < ord_cmp) self.assertTrue(ord_ref <= ord_cmp) self.assertTrue(ord_ref != ord_cmp) self.assertFalse(ord_ref > ord_cmp) self.assertFalse(ord_ref >= ord_cmp) self.assertFalse(ord_ref == ord_cmp)
def ordinal(self, number): return ordinal.ordinal(number)
def test_second(self): self.assertEqual("11th", ordinal.ordinal(11))
def test_first(self): self.assertEqual(ordinal.ordinal(self.value), "1st")
def test_eleven(self): self.assertEqual('11th',ordinal.ordinal(11))
def test_second(self): self.assertEqual("3rd", ordinal.ordinal(3))
def test_second(self): self.assertEqual(ordinal.ordinal(2), "2nd")
def test_string_input(self): self.assertEqual("Input is not a number.", ordinal.ordinal("1"))
def test_nd(self): self.assertEqual('2nd', ordinal.ordinal(2))
def test_first(self): self.assertEqual("1st", ordinal.ordinal(1)) # first ordinal: module, second ordinal: method
def test_eleven(self): self.assertEqual('11th', ordinal.ordinal(11))