Listing 1 The header <complex>

#define __STD_COMPLEX
       // TEMPLATE CLASS complex
template<class T>
    class complex {
public:
    complex(T re = 0, T im = 0);
    template<class U>
       complex(const complex<U>& x);
    T real() const;
    T imag() const;
    template<class U>
       complex<T>& operator=(const complex<U>& rhs);
    template<class U>
       complex<T>& operator+=(const complex<U>& rhs);
    template<class U>
       complex<T>& operator-=(const complex<U>& rhs);
    template<class U>
       complex<T>& operator*=(const complex<U>& rhs);
    template<class U>
       complex<T>& operator/=(const complex<U>& rhs);
    };
       // CLASS complex<float>
class complex<float> {
public:
    complex(float re = 0, float im = 0);
    explicit complex(const complex<double>& rhs);
    explicit complex(const complex<long double>& rhs);
    template<class U>
       complex<float>& operator=(const complex<U>& rhs);
    template<class U>
       complex<float>& operator+=(const complex<U>& rhs);
    template<class U>
       complex<float>& operator-=(const complex<U>& rhs);
    template<class U>
       complex<float>& operator*=(const complex<U>& rhs);
    template<class U>
       complex<float>& operator/=(const complex<U>& rhs);
    };
       // CLASS complex<double>
class complex<double> {
public:
    complex(double re = 0, double im = 0);
    complex(const complex<float>& rhs);
    explicit complex(const complex<long double>& rhs);
    template<class U>
       complex<double>& operator=(const complex<U>& rhs);
    template<class U>
       complex<double>& operator+=(const complex<U>& rhs);
    template<class U>
       complex<double>& operator-=(const complex<U>& rhs);
    template<class U>
       complex<double>& operator*=(const complex<U>& rhs);
    template<class U>
       complex<double>& operator/=(const complex<U>& rhs);
    };
       // CLASS complex<long double>
class complex<long double> {
public:
    complex(long double re = 0, long double im = 0);
    complex(const complex<float>& rhs);
    complex(const complex<double>& rhs);
    template<class U>
       complex<long double>& operator=(
            const complex<U>& rhs);
    template<class U>
       complex<long double>& operator+=(
            const complex<U>& rhs);
    template<class U>
       complex<long double>& operator-=(
            const complex<U>& rhs);
    template<class U>
       complex<long double>& operator*=(
            const complex<U>& rhs);
    template<class U>
       complex<long double>& operator/=(
            const complex<U>& rhs);
    };
       // TEMPLATE FUNCTIONS FOR complex
template<class T>
    complex<T> operator+(const complex<T>& lhs,
       const complex<T>& rhs);
template<class T>
    complex<T> operator+(const complex<T>& lhs, T rhs);
template<class T>
    complex<T> operator+(T lhs, const complex<T>& rhs);
template<class T>
    complex<T> operator-(const complex<T>& lhs,
       const complex<T>& rhs);
template<class T>
    complex<T> operator-(const complex<T>& lhs, T rhs);
template<class T>
    complex<T> operator-(T lhs, const complex<T>& rhs);
template<class T>
    complex<T> operator*(const complex<T>& lhs,
       const complex<T>& rhs);
template<class T>
    complex<T> operator*(const complex<T>& lhs, T rhs);
template<class T>
    complex<T> operator*(T lhs, const complex<T>& rhs);
template<class T>
    complex<T> operator/(const complex<T>& lhs,
       const complex<T>& rhs);
template<class T>
    complex<T> operator/(const complex<T>& lhs. T rhs);
template<class T>
    complex<T> operator/(T lhs, const complex<T>& rhs);
template<class T>
    complex<T> operator+(const complex<T>& lhs);
template<class T>
    complex<T> operator-(const complex<T>& lhs);
template<class T>
    bool operator==(const complex<T>& lhs,
       const complex<T>& rhs);
template<class T>
    bool operator==(const complex<T>& lhs, T rhs);
template<class T>
    bool operator==(T lhs, const complex<T>& rhs);
template<class T>
    bool operator!=(const complex<T>& lhs,
       const complex<T>& rhs);
template<class T>
    bool operator!=(const complex<T>& lhs. T rhs);
template<class T>
    bool operator!=(T lhs, const complex<T>& rhs);
template<class T>
    istream& operator>>(istream& is, complex<T>& x);
template<class T>
    ostream& operator<<(ostream& os, const complex<T>& x);
template<class T>
    T real(const complex<T>& x);
template<class T>
    T imag(const complex<T>& x);
template<class T>
    T abs(const complex<T>& x);
template<class T>
    T arg(const complex<T>& x);
template<class T>
    T norm(const complex<T>& x);
template<class T>
    complex<T> conjg(const complex<T>& x);
template<class T>
    complex<T> polar(T rho, T theta);
template<class T>
    complex<T> cos(const complex<T>& x);
template<class T>
    complex<T> cosh(const complex<T>& x);
template<class T>
    complex<T> exp(const complex<T>& x);
template<class T>
    complex<T> log(const complex<T>& x);
template<class T>
    complex<T> log10(const complex<T>& x);
template<class T>
    complex<T> pow(const complex<T>& x, int y);
template<class T>
    complex<T> pow(const complex<T>& x, T y);
template<class T>
    complex<T> pow(const complex<T>& x,
       const complex<T>& y);
template<class T>
    complex<T> pow(T x, const complex<T>& y);
template<class T>
    complex<T> sin(const complex<T>& x);
template<class T>
    complex<T> sinh(const complex<T>& x);
template<class T>
    complex<T> sqrt(const complex<T>& x);