Add complex fraction video

Author: jamesmurphy-mc

README.md

@@ -12,6 +12,7 @@ James and his team are available for consulting, contracting, code reviews, and
 
 | N | Code | Video | 
 | -- | --- |--- |
+| 116 | [src](videos/116_complex_fraction) | [Complex (Gaussian) Rationals - Extending Python's Number hierarchy](https://youtu.be/lcm4tYGmAig) |
 | 115 | [src](videos/115_fast_pow) | [Fast pow](https://youtu.be/GrNJE6ogyQU) |
 | 114 | [src](videos/114_copy_or_no_copy) | [Python Iterators! COPY or NO COPY?](https://youtu.be/hVFKy9Gw95c) |
 | 113 | [src](videos/113_getting_rid_of_recursion) | [Getting around the recursion limit](https://youtu.be/1dUpHL5Yg8E) |

videos/116_complex_fraction/cfrac.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import operator
+import sys
+import typing
+from decimal import Decimal
+from fractions import Fraction
+from numbers import Complex, Rational
+
+_HASH_M = 2 ** (sys.hash_info.width - 1)
+
+
+def _fast_pow(x, n: int):
+    if n == 1:  # assume n >= 1
+        return x
+    half_n, remainder = divmod(n, 2)
+    result = _fast_pow(x, half_n)
+    result *= result
+    return x * result if remainder else result
+
+
+def _operator_fallbacks(monomorphic_operator, fallback_operator):
+    # See https://docs.python.org/3/library/numbers.html
+    def forward(a, b):
+        if isinstance(b, (Rational, ComplexFraction)):
+            return monomorphic_operator(a, b)
+        elif isinstance(b, (float, complex)):
+            return fallback_operator(complex(a), b)
+        else:
+            return NotImplemented
+
+    forward.__name__ = f'__{fallback_operator.__name__}__'
+    forward.__doc__ = monomorphic_operator.__doc__
+
+    def reverse(b, a):
+        if isinstance(a, (Rational, ComplexFraction)):
+            return monomorphic_operator(a, b)
+        elif isinstance(a, Complex):
+            return fallback_operator(complex(a), complex(b))
+        else:
+            return NotImplemented
+
+    reverse.__name__ = f'__r{fallback_operator.__name__}__'
+    reverse.__doc__ = monomorphic_operator.__doc__
+
+    return forward, reverse
+
+
+SupportsFrac = typing.Union[Rational, float, str, Decimal]
+
+
+class ComplexFraction(Complex):
+    """Complex numbers of the form p + qi, where p and q are rational.
+
+     Also called Gaussian rationals.
+     """
+
+    __slots__ = ("_real", "_imag")
+
+    def __new__(cls,
+                real: SupportsFrac = Fraction(0),
+                imag: SupportsFrac = Fraction(0)):
+        self = super().__new__(cls)
+        self._real = Fraction(real)
+        self._imag = Fraction(imag)
+        return self
+
+    @property
+    def real(self):
+        return self._real
+
+    @property
+    def imag(self):
+        return self._imag
+
+    @classmethod
+    def from_complex(cls, z):
+        return cls(Fraction.from_float(z.real), Fraction.from_float(z.imag))
+
+    def as_fraction_pair(self):
+        return self.real, self.imag
+
+    def __complex__(self):
+        """complex(self)"""
+        return float(self.real) + 1j * float(self.imag)
+
+    def __repr__(self):
+        """repr(self)"""
+        return f'{self.__class__.__name__}({self.real!r}, {self.imag!r})'
+
+    def __str__(self):
+        """str(self)"""
+        return f'({self.real} + {self.imag}j)'
+
+    def _add(self, other):
+        """self + other"""
+        return ComplexFraction(self.real + other.real, self.imag + other.imag)
+
+    __add__, __radd__ = _operator_fallbacks(_add, operator.add)
+
+    def _sub(self, other):
+        """self - other"""
+        return ComplexFraction(self.real - other.real, self.imag - other.imag)
+
+    __sub__, __rsub__ = _operator_fallbacks(_sub, operator.sub)
+
+    def _mul(self, other):
+        """self * other"""
+        return ComplexFraction(self.real * other.real - self.imag * other.imag,
+                               self.imag * other.real + self.real * other.imag)
+
+    __mul__, __rmul__ = _operator_fallbacks(_mul, operator.mul)
+
+    def _truediv(self, other):
+        """self / other"""
+        denominator = other.real * other.real + other.imag * other.imag
+        return ComplexFraction(
+            (self.real * other.real + self.imag * other.imag) / denominator,
+            (self.imag * other.real - self.real * other.imag) / denominator
+        )
+
+    __truediv__, __rtruediv__ = _operator_fallbacks(_truediv, operator.truediv)
+
+    def __pow__(self, exponent):
+        """self ** exponent"""
+        if not isinstance(exponent, Rational):
+            return complex(self) ** exponent
+        if exponent.denominator != 1:  # not an integer exponent
+            return complex(self) ** complex(exponent)
+        exponent = exponent.numerator
+        if exponent == 0:
+            if self == 0:
+                raise ValueError("math domain error")
+            else:
+                return ComplexFraction(1)
+        if exponent < 0:
+            return 1 / (self ** (-exponent))
+        return _fast_pow(self, exponent)
+
+    def __rpow__(self, base):
+        """base ** self"""
+        if self.imag == 0:
+            return base ** self.real
+
+        return base ** complex(self)
+
+    def __pos__(self):
+        """+self"""
+        return self
+
+    def __neg__(self):
+        """-self"""
+        return ComplexFraction(-self.real, -self.imag)
+
+    def __abs__(self):
+        """abs(self)"""
+        if self.imag == 0:
+            return abs(self.real)
+        elif self.real == 0:
+            return abs(self.imag)
+        return self.norm_squared() ** .5
+
+    def norm_squared(self):
+        """Square of Euclidean norm"""
+        return self.real * self.real + self.imag * self.imag
+
+    def conjugate(self):
+        """p + qi -> p - qi"""
+        return ComplexFraction(self.real, -self.imag)
+
+    def __hash__(self):
+        """hash(self)"""
+        # See https://docs.python.org/3/library/stdtypes.html
+        hash_value = hash(self.real) + sys.hash_info.imag * hash(self.imag)
+        hash_value = (hash_value & (_HASH_M - 1)) - (hash_value & _HASH_M)
+        if hash_value == -1:
+            hash_value = -2
+        return hash_value
+
+    def __eq__(self, other):
+        """self == other"""
+        if not isinstance(other, Complex):
+            return NotImplemented
+
+        return self.real == other.real and self.imag == other.imag
+
+    def __bool__(self):
+        """bool(self)"""
+        return self.real != 0 or self.imag != 0
+
+    def __reduce__(self):
+        return self.__class__, (self._real, self._imag)
+
+    def __copy__(self):
+        if type(self) == ComplexFraction:
+            return self  # immutable
+        return self.__class__(self._real, self._imag)
+
+    def __deepcopy__(self, memo):
+        if type(self) == ComplexFraction:
+            return self  # immutable components
+        return self.__class__(self._real, self._imag)

videos/116_complex_fraction/test_cfrac.py

@@ -0,0 +1,89 @@
+import math
+
+import pytest
+
+from cfrac import ComplexFraction
+from fractions import Fraction
+
+
+def test_construction():
+    assert ComplexFraction() == ComplexFraction(0)
+    assert ComplexFraction() == 0
+    assert ComplexFraction() == 0.0
+    assert ComplexFraction(1, 1) == 1 + 1j
+    assert ComplexFraction.from_complex(1 + 1j) == ComplexFraction(1, 1)
+
+
+def test_conversions():
+    assert complex(ComplexFraction(0)) == 0
+    assert abs(complex(ComplexFraction(1, 2)) - (1 + 2j)) < 1e-6
+    assert ComplexFraction(1, 2).as_fraction_pair() == (1, 2)
+
+
+def test_arithmetic():
+    assert ComplexFraction(1) + ComplexFraction(2) == ComplexFraction(3)
+    assert ComplexFraction(1, 2) + ComplexFraction(3, 4) == ComplexFraction(4, 6)
+    assert ComplexFraction(1, 2) - ComplexFraction(3, 4) == ComplexFraction(-2, -2)
+    assert ComplexFraction(1, 2) * ComplexFraction(3, 4) == ComplexFraction(-5, 10)
+    assert ComplexFraction(1, 2) / ComplexFraction(3, 4) == ComplexFraction(Fraction(11, 25), Fraction(2, 25))
+    assert +ComplexFraction(1, 2) == ComplexFraction(1, 2)
+    assert -ComplexFraction(1, 2) == ComplexFraction(-1, -2)
+    assert ComplexFraction(1, 2).conjugate() == ComplexFraction(1, -2)
+    assert ComplexFraction(1, 2).norm_squared() == 5
+    assert math.isclose(abs(ComplexFraction(1, 2)), math.sqrt(5))
+    z = ComplexFraction(1)
+    z += 1j
+    assert z == ComplexFraction(1, 1)
+
+
+def test_operator_fallbacks():
+    assert ComplexFraction(1) + 1 == 2
+    assert type(ComplexFraction(1) + 1) == ComplexFraction
+
+    assert 1 + ComplexFraction(1) == 2
+    assert type(1 + ComplexFraction(1)) == ComplexFraction
+
+    assert abs(ComplexFraction(1) + 1.5 - 2.5) < 1e-6
+    assert type(ComplexFraction(1) + 1.5) == complex
+
+
+def test_pow():
+    assert ComplexFraction(1, 2) ** 0 == 1
+    assert ComplexFraction(1, 2) ** 5 == ComplexFraction(41, -38)
+    assert ComplexFraction(1, 2) ** -5 == ComplexFraction(Fraction(41, 3125), Fraction(38, 3125))
+    assert ComplexFraction(0, 1) ** 1000 == 1
+
+    with pytest.raises(ValueError):
+        ComplexFraction(0) ** 0
+
+
+def test_hash():
+    assert hash(ComplexFraction(0)) == hash(0)
+    assert hash(ComplexFraction(42)) == hash(42)
+    assert hash(ComplexFraction(Fraction(1, 2))) == hash(Fraction(1, 2))
+    assert hash(ComplexFraction(0, 1)) == hash(1j)
+
+    d = {ComplexFraction(0, 1): "a", ComplexFraction(1, 0): "b", ComplexFraction(1, 1): "c"}
+    assert d[1j] == "a"
+    assert d[1] == "b"
+    assert d[1 + 1j] == "c"
+
+
+def test_bool():
+    assert not bool(ComplexFraction(0))
+    assert bool(ComplexFraction(1))
+    assert bool(ComplexFraction(0, 1))
+
+
+def test_comparisons_raise():
+    with pytest.raises(TypeError):
+        ComplexFraction() < ComplexFraction()
+
+    with pytest.raises(TypeError):
+        ComplexFraction() <= ComplexFraction()
+
+    with pytest.raises(TypeError):
+        ComplexFraction() > ComplexFraction()
+
+    with pytest.raises(TypeError):
+        ComplexFraction() >= ComplexFraction()