Made Complex.hpp up to date in python example

Author: Sebastien Ponce

code/python/Complex.hpp

@@ -1,69 +1,110 @@
+#include <ostream>
+#include <cmath>
+
 template <typename T=float>
 class Complex_t {
 public:
-    Complex_t(T r, T i);
-    Complex_t(T r);
-    Complex_t();
-
-    T real() const {return m_r;};
-    T imaginary() const {return m_i;};
-
-    Complex_t operator+(const Complex_t& other) const;
-    Complex_t operator-(const Complex_t& other) const;
-    Complex_t operator*(const Complex_t& other) const;
-    Complex_t operator*(const T factor) const;
-    Complex_t operator/(const T dividend) const;
-    Complex_t& operator+=(const Complex_t& other);
-    bool operator<(const Complex_t& a) const;
+    Complex_t() = default;
+    Complex_t(T r, T i) : m_r(r), m_i(i) {}
+
+    T real() const { return m_r; }
+    T imaginary() const { return m_i; }
+
+    T norm_sqr() const {
+        return m_r * m_r + m_i * m_i;
+    }
+
+    T norm() const {
+        return std::sqrt(norm_sqr());
+    }
+
+    Complex_t& operator+=(const Complex_t& other) {
+        m_r += other.m_r;
+        m_i += other.m_i;
+        return *this;
+    }
+
+    Complex_t& operator-=(const Complex_t& other) {
+        m_r -= other.m_r;
+        m_i -= other.m_i;
+        return *this;
+    }
+
+    Complex_t& operator*=(const Complex_t& other) {
+        const auto r = m_r * other.m_r - m_i * other.m_i;
+        const auto i = m_r * other.m_i + m_i * other.m_r;
+        m_r = r;
+        m_i = i;
+        return *this;
+    }
+
+    Complex_t& operator*=(T factor) {
+        m_r *= factor;
+        m_i *= factor;
+        return *this;
+    }
+
+    Complex_t& operator/=(const Complex_t& other) {
+        const T ns = other.norm_sqr();
+        const auto r = (m_r * other.m_r + m_i * other.m_i) / ns;
+        const auto i = (m_i * other.m_r - m_r * other.m_i) / ns;
+        m_r = r;
+        m_i = i;
+        return *this;
+    }
+
+    Complex_t& operator/=(T divisor) {
+        m_r /= divisor;
+        m_i /= divisor;
+        return *this;
+    }
+
+    friend Complex_t operator+(Complex_t a, const Complex_t& b) {
+        return a += b;
+    }
+
+    friend Complex_t operator-(Complex_t a, const Complex_t& b) {
+        return a -= b;
+    }
+
+    friend Complex_t operator*(Complex_t a, const Complex_t& b) {
+        return a *= b;
+    }
+
+    friend Complex_t operator*(Complex_t c, T factor) {
+        return c *= factor;
+    }
+
+    friend Complex_t operator*(T factor, Complex_t c) {
+        return c *= factor;
+    }
+
+    friend Complex_t operator/(Complex_t a, Complex_t b) {
+        return a /= b;
+    }
+
+    friend Complex_t operator/(Complex_t c, T divisor) {
+        return c /= divisor;
+    }
+
+    friend Complex_t operator/(T dividend, const Complex_t& c) {
+        return Complex_t(dividend, 0) / c;
+    }
+
+    friend bool operator==(const Complex_t& a, const Complex_t& b) {
+        return a.m_r == b.m_r && a.m_i == b.m_i;
+    }
+
+    friend bool operator<(const Complex_t& a, const Complex_t& b) {
+        return a.norm_sqr() < b.norm_sqr();
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const Complex_t<T>& c) {
+        return os << "(" << c.real() << ", " << c.imaginary() << ")";
+    }
+
 private:
-    T m_r, m_i;
+    T m_r{}, m_i{};
 };
 
-typedef Complex_t<> Complex;
-
-template <typename T>
-Complex_t<T>::Complex_t() {}
-
-template <typename T>
-Complex_t<T>::Complex_t(T r) : m_r(r), m_i(0) {}
-
-template <typename T>
-Complex_t<T>::Complex_t(T r, T i) : m_r(r), m_i(i) {}
-
-template <typename T>
-Complex_t<T> Complex_t<T>::operator+(const Complex_t<T>& other) const {
-    return Complex_t(m_r + other.m_r, m_i + other.m_i);
-}
-
-template <typename T>
-Complex_t<T> Complex_t<T>::operator-(const Complex_t<T>& other) const {
-    return Complex_t(m_r - other.m_r, m_i - other.m_i);
-}
-
-template <typename T>
-Complex_t<T> Complex_t<T>::operator*(const Complex_t<T>& other) const {
-    return Complex_t(m_r*other.m_r - m_i*other.m_i,
-                     m_r*other.m_i + m_i*other.m_r);
-}
-
-template <typename T>
-Complex_t<T> Complex_t<T>::operator*(const T factor) const {
-    return Complex_t(m_r*factor, m_i*factor);
-}
-
-template <typename T>
-Complex_t<T> Complex_t<T>::operator/(const T dividend) const {
-    return Complex_t(m_r/dividend, m_i/dividend);
-}
-
-template <typename T>
-Complex_t<T>& Complex_t<T>::operator+=(const Complex_t<T>& other) {
-    m_r += other.m_r;
-    m_i += other.m_i;
-    return *this;
-}
-
-template <typename T>
-bool Complex_t<T>::operator<(const Complex_t<T>& other) const {
-    return (m_r*m_r+m_i*m_i) < (other.m_r*other.m_r+other.m_i*other.m_i);
-}
+using Complex = Complex_t<>;

code/python/mandel.cpp

@@ -1,10 +1,10 @@
 #include "mandel.hpp"
 
 int mandel(const Complex &a) {
-  Complex z = 0;
+  Complex z{0, 0};
   for (int n = 1; n < 100; n++) {
     z = z*z + a;
-    if (Complex(2) < z) {
+    if (Complex{2, 0} < z) {
       return n;
     }
   }