Wrote pow and zero divisor examples.

Author: discretegames

README.md

@@ -95,7 +95,7 @@ The names and letter-abbreviations were taken from [this image][3] ([mirror][4])
 
 ## Usage Examples
 
-This list follows [example.py](example.py) exactly and documents nearly all the things you can do with the hypercomplex numbers created by this package.
+This list follows [examples.py](examples.py) exactly and documents nearly all the things you can do with the hypercomplex numbers created by this package.
 
 Every example assumes the appropriate imports are already done, e.g. `from hypercomplex import *`.
 
@@ -137,31 +137,42 @@ Every example assumes the appropriate imports are already done, e.g. `from hyper
     print(R(2).inverse(), 1 / R(2))           # -> (0.5) (0.5)
     ```
 
-5. `conjugate` gives the conjugate of the number.
+5. Numbers can be raised to integer powers, a shortcut for repeated multiplication or division.
+
+    ```py
+    q = Q(0, 3, 4, 0)
+    print(q**5)               # -> (0 1875 2500 0)
+    print(q * q * q * q * q)  # -> (0 1875 2500 0)
+    print(q**-1)              # -> (0 -0.12 -0.16 0)
+    print(1 / q)              # -> (0 -0.12 -0.16 0)
+    print(q**0)               # -> (1 0 0 0)
+    ```
+
+6. `conjugate` gives the conjugate of the number.
 
     ```py
     print(R(9).conjugate())           # -> (9)
     print(C(9, 8).conjugate())        # -> (9 -8)
     print(Q(9, 8, 7, 6).conjugate())  # -> (9 -8 -7 -6)
     ```
 
-6. `norm` gives the absolute value as the base type (`float` by default). There is also `norm_squared`.
+7. `norm` gives the absolute value as the base type (`float` by default). There is also `norm_squared`.
 
     ```py
     print(O(3, 4).norm(), type(O(3, 4).norm()))  # -> 5.0 <class 'float'>
     print(abs(O(3, 4)))                          # -> 5.0
     print(O(3, 4).norm_squared())                # -> 25.0
     ```
 
-7. Numbers are considered equal if their coefficients all match. Non-existent coefficients are 0.
+8. Numbers are considered equal if their coefficients all match. Non-existent coefficients are 0.
 
     ```py
     print(R(999) == V(999))         # -> True
     print(C(1, 2) == Q(1, 2))       # -> True
     print(C(1, 2) == Q(1, 2, 0.1))  # -> False
     ```
 
-8. `coefficients` gives a tuple of the components of the number in their base type (`float` by default). The properties `real` and `imag` are shortcuts for the first two components. Indexing can also be used (but is inefficient).
+9. `coefficients` gives a tuple of the components of the number in their base type (`float` by default). The properties `real` and `imag` are shortcuts for the first two components. Indexing can also be used (but is inefficient).
 
     ```py
     print(R(100).coefficients())   # -> (100.0,)
@@ -171,15 +182,15 @@ Every example assumes the appropriate imports are already done, e.g. `from hyper
     print(q[0], q[1], q[2], q[3])  # -> 2.0 3.0 4.0 5.0
     ```
 
-9. `e(index)` of a number class gives the unit hypercomplex number where the index coefficient is 1 and all others are 0.
+10. `e(index)` of a number class gives the unit hypercomplex number where the index coefficient is 1 and all others are 0.
 
     ```py
     print(C.e(0))  # -> (1 0)
     print(C.e(1))  # -> (0 1)
     print(O.e(3))  # -> (0 0 0 1 0 0 0 0)
     ```
 
-10. `e_matrix` of a number class gives the multiplication table of `e(i)*e(j)`. Set `string=False` to get a 2D list instead of a string. Set `raw=True` to get the raw hypercomplex numbers.
+11. `e_matrix` of a number class gives the multiplication table of `e(i)*e(j)`. Set `string=False` to get a 2D list instead of a string. Set `raw=True` to get the raw hypercomplex numbers.
 
     ```py
     print(O.e_matrix())                        # -> e1  e2  e3  e4  e5  e6  e7
@@ -194,7 +205,7 @@ Every example assumes the appropriate imports are already done, e.g. `from hyper
     print(C.e_matrix(string=False, raw=True))  # -> [[(1 0), (0 1)], [(0 1), (-1 0)]]
     ```
 
-11. A number is considered truthy if it has has non-zero coefficients. Conversion to `int`, `float` and `complex` are only valid when the coefficients beyond the dimension of those types are all 0.
+12. A number is considered truthy if it has has non-zero coefficients. Conversion to `int`, `float` and `complex` are only valid when the coefficients beyond the dimension of those types are all 0.
 
     ```py
     print(bool(Q()))                    # -> False
@@ -205,30 +216,30 @@ Every example assumes the appropriate imports are already done, e.g. `from hyper
     # print(float(C(1, 2))) <- invalid
     ```
 
-12. Any usual format spec for the base type can be given in an f-string.
+13. Any usual format spec for the base type can be given in an f-string.
 
     ```py
     o = O(0.001, 1, -2, 3.3333, 4e5)
     print(f"{o:.2f}")                 # -> (0.00 1.00 -2.00 3.33 400000.00 0.00 0.00 0.00)
     print(f"{R(23.9):04.0f}")         # -> (0024)
     ```
 
-13. The `len` of a number is its hypercomplex dimension, i.e. the number of components or coefficients it has.
+14. The `len` of a number is its hypercomplex dimension, i.e. the number of components or coefficients it has.
 
     ```py
     print(len(R()))      # -> 1
     print(len(C(7, 7)))  # -> 2
     print(len(U()))      # -> 128
     ```
 
-14. Using `in` behaves the same as if the number were a tuple of its coefficients.
+15. Using `in` behaves the same as if the number were a tuple of its coefficients.
 
     ```py
     print(3 in Q(1, 2, 3, 4))  # -> True
     print(5 in Q(1, 2, 3, 4))  # -> False
     ```
 
-15. `copy` can be used to duplicate a number (but should generally not be needed).
+16. `copy` can be used to duplicate a number (but should generally never be needed as all operations create a new number).
 
     ```py
     x = O(9, 8, 7)
@@ -237,7 +248,7 @@ Every example assumes the appropriate imports are already done, e.g. `from hyper
     print(x is y)   # -> False
     ```
 
-16. `base` on a number class will return the base type the entire numbers are built upon.
+17. `base` on a number class will return the base type the entire numbers are built upon.
 
     ```py
     print(R.base())                      # -> <class 'float'>
@@ -246,6 +257,18 @@ Every example assumes the appropriate imports are already done, e.g. `from hyper
     print(A.base())                      # -> <class 'int'>
     ```
 
+18. Hypercomplex numbers are weird, so be careful! Here two non-zero sedenions multiply to give zero because sedenions and beyond have zero devisors.
+
+    ```py
+    s1 = S.e(5) + S.e(10)
+    s2 = S.e(6) + S.e(9)
+    print(s1)                                    # -> (0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0)
+    print(s2)                                    # -> (0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0)
+    print(s1 * s2)                               # -> (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+    print((1 / s1) * (1 / s2))                   # -> (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+    # print(1/(s1 * s2)) <- zero division error
+    ```
+
 ## About
 
 I wrote this package for the novelty of it and as a math and programming exercise. The operations it can perform on hypercomplex numbers are not particularly efficient due to the recursive nature of the Cayley-Dickson construction.

examples_to_markdown.py

@@ -52,3 +52,23 @@ def examples_to_markdown():
 
 if __name__ == "__main__":
     examples_to_markdown()
+
+# This is the only multiline example and examples_to_markdown can't handle it. Saving it here to avoid manually making it again.
+e_matrix_example = """
+
+11. `e_matrix` of a number class gives the multiplication table of `e(i)*e(j)`. Set `string=False` to get a 2D list instead of a string. Set `raw=True` to get the raw hypercomplex numbers.
+
+    ```py
+    print(O.e_matrix())                        # -> e1  e2  e3  e4  e5  e6  e7
+                                               #   -e0  e3 -e2  e5 -e4 -e7  e6
+                                               #   -e3 -e0  e1  e6  e7 -e4 -e5
+                                               #    e2 -e1 -e0  e7 -e6  e5 -e4
+                                               #   -e5 -e6 -e7 -e0  e1  e2  e3
+                                               #    e4 -e7  e6 -e1 -e0 -e3  e2
+                                               #    e7  e4 -e5 -e2  e3 -e0 -e1
+                                               #   -e6  e5  e4 -e3 -e2  e1 -e0
+                                               #
+    print(C.e_matrix(string=False, raw=True))  # -> [[(1 0), (0 1)], [(0 1), (-1 0)]]
+    ```
+
+"""

hypercomplex/examples.py

@@ -45,44 +45,53 @@
 print(R(2).inverse(), 1 / R(2))
 
 
-# %% 5. `conjugate` gives the conjugate of the number.
+# %% 5. Numbers can be raised to integer powers, a shortcut for repeated multiplication or division.
+q = Q(0, 3, 4, 0)
+print(q**5)
+print(q * q * q * q * q)
+print(q**-1)
+print(1 / q)
+print(q**0)
+
+
+# %% 6. `conjugate` gives the conjugate of the number.
 print(R(9).conjugate())
 print(C(9, 8).conjugate())
 print(Q(9, 8, 7, 6).conjugate())
 
 
-# %% 6. `norm` gives the absolute value as the base type (`float` by default). There is also `norm_squared`.
+# %% 7. `norm` gives the absolute value as the base type (`float` by default). There is also `norm_squared`.
 print(O(3, 4).norm(), type(O(3, 4).norm()))
 print(abs(O(3, 4)))
 print(O(3, 4).norm_squared())
 
 
-# %% 7. Numbers are considered equal if their coefficients all match. Non-existent coefficients are 0.
+# %% 8. Numbers are considered equal if their coefficients all match. Non-existent coefficients are 0.
 print(R(999) == V(999))
 print(C(1, 2) == Q(1, 2))
 print(C(1, 2) == Q(1, 2, 0.1))
 
 
-# %% 8. `coefficients` gives a tuple of the components of the number in their base type (`float` by default). The properties `real` and `imag` are shortcuts for the first two components. Indexing can also be used (but is inefficient).
+# %% 9. `coefficients` gives a tuple of the components of the number in their base type (`float` by default). The properties `real` and `imag` are shortcuts for the first two components. Indexing can also be used (but is inefficient).
 print(R(100).coefficients())
 q = Q(2, 3, 4, 5)
 print(q.coefficients())
 print(q.real, q.imag)
 print(q[0], q[1], q[2], q[3])
 
 
-# %% 9. `e(index)` of a number class gives the unit hypercomplex number where the index coefficient is 1 and all others are 0.
+# %% 10. `e(index)` of a number class gives the unit hypercomplex number where the index coefficient is 1 and all others are 0.
 print(C.e(0))
 print(C.e(1))
 print(O.e(3))
 
 
-# %% 10. `e_matrix` of a number class gives the multiplication table of `e(i)*e(j)`. Set `string=False` to get a 2D list instead of a string. Set `raw=True` to get the raw hypercomplex numbers.
+# %% 11. `e_matrix` of a number class gives the multiplication table of `e(i)*e(j)`. Set `string=False` to get a 2D list instead of a string. Set `raw=True` to get the raw hypercomplex numbers.
 print(O.e_matrix())
 print(C.e_matrix(string=False, raw=True))
 
 
-# %% 11. A number is considered truthy if it has has non-zero coefficients. Conversion to `int`, `float` and `complex` are only valid when the coefficients beyond the dimension of those types are all 0.
+# %% 12. A number is considered truthy if it has has non-zero coefficients. Conversion to `int`, `float` and `complex` are only valid when the coefficients beyond the dimension of those types are all 0.
 print(bool(Q()))
 print(bool(Q(0, 0, 0.01, 0)))
 
@@ -91,35 +100,45 @@
 # print(float(C(1, 2))) <- invalid
 
 
-# %% 12. Any usual format spec for the base type can be given in an f-string.
+# %% 13. Any usual format spec for the base type can be given in an f-string.
 o = O(0.001, 1, -2, 3.3333, 4e5)
 print(f"{o:.2f}")
 print(f"{R(23.9):04.0f}")
 
 
-# %% 13. The `len` of a number is its hypercomplex dimension, i.e. the number of components or coefficients it has.
+# %% 14. The `len` of a number is its hypercomplex dimension, i.e. the number of components or coefficients it has.
 print(len(R()))
 print(len(C(7, 7)))
 print(len(U()))
 
 
-# %% 14. Using `in` behaves the same as if the number were a tuple of its coefficients.
+# %% 15. Using `in` behaves the same as if the number were a tuple of its coefficients.
 print(3 in Q(1, 2, 3, 4))
 print(5 in Q(1, 2, 3, 4))
 
 
-# %% 15. `copy` can be used to duplicate a number (but should generally not be needed).
+# %% 16. `copy` can be used to duplicate a number (but should generally never be needed as all operations create a new number).
 x = O(9, 8, 7)
 y = x.copy()
 print(x == y)
 print(x is y)
 
 
-# %% 16. `base` on a number class will return the base type the entire numbers are built upon.
+# %% 17. `base` on a number class will return the base type the entire numbers are built upon.
 print(R.base())
 print(V.base())
 A = cayley_dickson_algebra(20, int)
 print(A.base())
 
 
+# %% 18. Hypercomplex numbers are weird, so be careful! Here two non-zero sedenions multiply to give zero because sedenions and beyond have zero devisors.
+s1 = S.e(5) + S.e(10)
+s2 = S.e(6) + S.e(9)
+print(s1)
+print(s2)
+print(s1 * s2)
+print((1 / s1) * (1 / s2))
+# print(1/(s1 * s2)) <- zero division error
+
+
 # %%