<complex>

abs · arg · complex · conj · cos · cosh · double_complex · exp · float_complex · imag · log · log10 · norm · operator!= · operator* · operator+ · operator- · operator/ · operator<< · operator== · operator>> · polar · pow · real · sin · sinh · sqrt · tan · tanh · __STD_COMPLEX

Include the standard header <complex> to define classes double_complex and float_complex and a host of supporting functions. Unless otherwise specified, functions that can return multiple values return an imaginary part in the half-open interval (-pi, pi].

Many of the functions declared in this header have additional overloads, which behave much like the generic functions defined in the C99 header <tgmath.h>. The following functions have such additional overloads:

abs      conj     polar
acos     cos      pow
acosh    cosh     real
arg      exp      sin
asin     imag     sinh
asinh    log      sqrt
atan     log10    tan
atanh    norm     tanh

        // DECLARATIONS
#define __STD_COMPLEX

        // CLASSES
class double_complex;
class float_complex;

        // double_complex FUNCTIONS
double_complex operator+(const double_complex& left,
    const double_complex& right);
double_complex operator+(const double_complex& left,
    const double& right);
double_complex operator+(const double& left,
    const double_complex& right);
double_complex operator-(const double_complex& left,
    const double_complex& right);
double_complex operator-(const double_complex& left,
    const double& right);
double_complex operator-(const double& left,
    const double_complex& right);
double_complex operator*(const double_complex& left,
    const double_complex& right);
double_complex operator*(const double_complex& left,
    const double& right);
double_complex operator*(const double& left,
    const double_complex& right);
double_complex operator/(const double_complex& left,
    const double_complex& right);
double_complex operator/(const double_complex& left,
    const double& right);
double_complex operator/(const double& left,
    const double_complex& right);
double_complex operator+(const double_complex& left);
double_complex operator-(const double_complex& left);
bool operator==(const double_complex& left,
    const double_complex& right);
bool operator==(const double_complex& left,
    const double& right);
bool operator==(const double& left,
    const double_complex& right);
bool operator!=(const double_complex& left,
    const double_complex& right);
bool operator!=(const double_complex& left,
    const double& right);
bool operator!=(const double& left,
    const double_complex& right);
istream& operator>>(istream& istr, double_complex& right);
ostream& operator<<(ostream& ostr, const double_complex& right);
double real(const double_complex& left);
double imag(const double_complex& left);
double abs(const double_complex& left);
double arg(const double_complex& left);
double norm(const double_complex& left);
double_complex conj(const double_complex& left);
double_complex polar(const double& rho,
    const double& theta = 0);
double_complex cos(const double_complex& left);
double_complex cosh(const double_complex& left);
double_complex exp(const double_complex& left);
double_complex log(const double_complex& left);
double_complex log10(const double_complex& left);
double_complex pow(const double_complex& left, int right);
double_complex pow(const double_complex& left,
    const double& right);
double_complex pow(const double_complex& left,
    const double_complex& right);
double_complex pow(const double& left,
    const double_complex& right);
double_complex sin(const double_complex& left);
double_complex sinh(const double_complex& left);
double_complex sqrt(const double_complex& left);

        // float_complex FUNCTIONS
bool operator==(const float& left,
    const float_complex& right);
bool operator!=(const float_complex& left,
    const float_complex& right);
bool operator!=(const float_complex& left,
    const float& right);
bool operator!=(const float& left,
    const float_complex& right);
istream& operator>>(istream& istr, float_complex& right);
ostream& operator<<(ostream& ostr, const float_complex& right);
float real(const float_complex& left);
float imag(const float_complex& left);
float abs(const float_complex& left);
float arg(const float_complex& left);
float norm(const float_complex& left);
float_complex conj(const float_complex& left);
float_complex polar(const float& rho,
    const float& theta = 0);
float_complex cos(const float_complex& left);
float_complex cosh(const float_complex& left);
float_complex exp(const float_complex& left);
float_complex log(const float_complex& left);
float_complex log10(const float_complex& left);
float_complex pow(const float_complex& left, int right);
float_complex pow(const float_complex& left,
    const float& right);
float_complex pow(const float_complex& left,
    const float_complex& right);
float_complex pow(const float& left,
    const float_complex& right);
float_complex sin(const float_complex& left);
float_complex sinh(const float_complex& left);
float_complex sqrt(const float_complex& left);
        // END OF DECLARATIONS

abs

double abs(const double_complex& left);
float abs(const float_complex& left);

The function returns the magnitude of left.

arg

double arg(const double_complex& left);
float arg(const float_complex& left);

The function returns the phase angle of left.

complex

template<class Ty>
    class complex {
public:
    typedef Ty value_type;
    Ty real() const;
    Ty imag() const;
    complex(const Ty& realval = 0, const Ty& imagval = 0);
    complex(const complex& right);
    complex& operator=(const complex& right);
    complex& operator+=(const complex& right);
    complex& operator-=(const complex& right);
    complex& operator*=(const complex& right);
    complex& operator/=(const complex& right);
    complex& operator=(const Ty& right);
    complex& operator=(const Ty& right);
    complex& operator+=(const Ty& right);
    complex& operator-=(const Ty& right);
    complex& operator*=(const Ty& right);
    complex& operator/=(const Ty& right);
    };

The template class doesn't really exist. It is a convenient fiction for describing the behavior common to the two types:

• double_complex -- which behaves like complex<double>
• float_complex -- which behaves like complex<float>

The template class describes an object that stores two objects of type Ty, one that represents the real part of a complex number and one that represents the imaginary part.

complex::complex

complex(const Ty& realval = 0, const Ty& imagval = 0);
complex(const complex& right);

The first constructor initializes the stored real part to realval and the stored imaginary part to imagval. The second constructor initializes the stored real part to right.real() and the stored imaginary part to right.imag().

complex::imag

Ty imag() const;

The member function returns the stored imaginary part.

complex::operator*=

complex& operator*=(const complex& right);
complex& operator*=(const Ty& right);

The first member function replaces the stored real and imaginary parts with those corresponding to the complex product of *this and right. It then returns *this.

The second member function multiplies both the stored real part and the stored imaginary part with right. It then returns *this.

complex::operator+=

complex& operator+=(const complex& right);
complex& operator+=(const Ty& right);

The first member function replaces the stored real and imaginary parts with those corresponding to the complex sum of *this and right. It then returns *this.

The second member function adds right to the stored real part. It then returns *this.

complex::operator-=

complex& operator-=(const complex& right);
complex& operator-=(const Ty& right);

The first member function replaces the stored real and imaginary parts with those corresponding to the complex difference of *this and right. It then returns *this.

The second member function subtracts right from the stored real part. It then returns *this.

complex::operator/=

complex& operator/=(const complex& right);
complex& operator/=(const Ty& right);

The first member function replaces the stored real and imaginary parts with those corresponding to the complex quotient of *this and right. It then returns *this.

The second member function multiplies both the stored real part and the stored imaginary part with right. It then returns *this.

complex::operator=

complex& operator=(const complex& right);
complex& operator=(const Ty& right);

The first member function replaces the stored real part with right.real() and the stored imaginary part with right.imag(). It then returns *this.

The second member function replaces the stored real part with right and the stored imaginary part with zero. It then returns *this.

complex::real

Ty real() const;

The member function returns the stored real part.

complex::value_type

typedef Ty value_type;

The type is a synonym for the template parameter Ty.

conj

double_complex conj(const double_complex& left);
float_complex conj(const float_complex& left);

The function returns the conjugate of left.

cos

double_complex cos(const double_complex& left);
float_complex cos(const float_complex& left);

The function returns the cosine of left.

cosh

double_complex cosh(const double_complex& left);
float_complex cosh(const float_complex& left);

The function returns the hyperbolic cosine of left.

double_complex

class double_complex : public complex<double> {
public:
    double_complex(double realval = 0, double imagval = 0);
    double_complex(const float_complex& right);
    double_complex& operator=(const double right);
    };

The class describes an object that stores two objects of type double, one that represents the real part of a complex number and one that represents the imaginary part. The class differs from its fictitious base class complex<double> only in the constructors it defines. The first constructor initializes the stored real part to realval and the stored imaginary part to imagval. The second constructor initializes the stored real part to right.real() and the stored imaginary part to right.imag(). The assignment operator stores right in the stored real part and zero in the stored imaginary part.

exp

double_complex exp(const double_complex& left);
float_complex exp(const float_complex& left);

The function returns the exponential of left.

float_complex

class float_complex : public complex<float> {
public:
    float_complex(float realval = 0, float imagval = 0);
    explicit float_complex(const double_complex& right);
    float_complex& operator=(const float right);
    };

The class describes an object that stores two objects of type float, one that represents the real part of a complex number and one that represents the imaginary part. The class differs from its fictitious base class complex<float> only in the constructors it defines. The first constructor initializes the stored real part to realval and the stored imaginary part to imagval. The second constructor initializes the stored real part to right.real() and the stored imaginary part to right.imag(). The assignment operator stores right in the stored real part and zero in the stored imaginary part.

imag

double imag(const double_complex& left);
float imag(const float_complex& left);

The function returns the imaginary part of left.

log

double_complex log(const double_complex& left);
float_complex log(const float_complex& left);

The function returns the logarithm of left. The branch cuts are along the negative real axis.

log10

double_complex log10(const double_complex& left);
float_complex log10(const float_complex& left);

The function returns the base 10 logarithm of left. The branch cuts are along the negative real axis.

norm

double norm(const double_complex& left);
float norm(const float_complex& left);

The function returns the squared magnitude of left.

operator!=

bool operator!=(const double_complex& left,
    const double_complex& right);
bool operator!=(const double_complex& left,
    const double& right);
bool operator!=(const double& left,
    const double_complex& right);
bool operator!=(const float_complex& left,
    const float_complex& right);
bool operator!=(const float_complex& left,
    const float& right);
bool operator!=(const float& left,
    const float_complex& right);

The operators each return true only if real(left) != real(right) || imag(left) != imag(right).

operator*

double_complex operator*(const double_complex& left,
    const double_complex;& right);
double_complex operator*(const double_complex& left,
    const double& right);
double_complex operator*(const double& left,
    const double_complex& right);
float_complex operator*(const float_complex& left,
    const float_complex;& right);
float_complex operator*(const float_complex& left,
    const float& right);
float_complex operator*(const float& left,
    const float_complex& right);

The operators each convert both operands to the return type, then return the complex product of the converted left and right.

operator+

double_complex operator+(const double_complex& left,
    const double_complex;& right);
double_complex operator+(const double_complex& left,
    const double& right);
double_complex operator+(const double& left,
    const double_complex& right);
double_complex operator+(const double_complex& left);
float_complex operator+(const float_complex& left,
    const float_complex;& right);
float_complex operator+(const float_complex& left,
    const float& right);
float_complex operator+(const float& left,
    const float_complex& right);
float_complex operator+(const float_complex& left);

The binary operators each convert both operands to the return type, then return the complex sum of the converted left and right.

The unary operator returns left.

operator-

double_complex operator-(const double_complex& left,
    const double_complex;& right);
double_complex operator-(const double_complex& left,
    const double& right);
double_complex operator-(const double& left,
    const double_complex& right);
double_complex operator-(const double_complex& left);
float_complex operator-(const float_complex& left,
    const float_complex;& right);
float_complex operator-(const float_complex& left,
    const float& right);
float_complex operator-(const float& left,
    const float_complex& right);
float_complex operator-(const float_complex& left);

The binary operators each convert both operands to the return type, then return the complex difference of the converted left and right.

The unary operator returns a value whose real part is -real(left) and whose imaginary part is -imag(left).

operator/

double_complex operator/(const double_complex& left,
    const double_complex;& right);
double_complex operator/(const double_complex& left,
    const double& right);
double_complex operator/(const double& left,
    const double_complex& right);
float_complex operator/(const float_complex& left,
    const float_complex;& right);
float_complex operator/(const float_complex& left,
    const float& right);
float_complex operator/(const float& left,
    const float_complex& right);

The operators each convert both operands to the return type, then return the complex quotient of the converted left and right.

operator<<

ostream& operator<<(ostream& ostr,
    const double_complex& right);
ostream& operator<<(ostream& ostr,
    const float_complex& right);

The template function inserts the complex value right in the output stream ostr, effectively by executing:

ostringstream osstr;
osstr.flags(ostr.flags());
osstr.precision(ostr.precision());
osstr << '(' << real(right) << ','
    << imag(right) << ')';
ostr << osstr.str().c_str();

Thus, if ostr.width() is greater than zero, any padding occurs either before or after the parenthesized pair of values, which itself contains no padding. The function returns ostr.

operator==

bool operator==(const double_complex& left,
    const double_complex& right);
bool operator==(const double_complex& left,
    const double& right);
bool operator==(const double& left,
    const double_complex& right);
bool operator==(const float_complex& left,
    const float_complex& right);
bool operator==(const float_complex& left,
    const float& right);
bool operator==(const float& left,
    const float_complex& right);

The operators each return true only if real(left) == real(right) && imag(left) == imag(right).

operator>>

istream& operator>>(istream& istr,
    double_complex& right);
istream& operator>>(istream& istr,
    float_complex& right);

The template function attempts to extract a complex value from the input stream istr, effectively by executing:

istr >> ch && ch == '('
    && istr >> re >> ch && ch == ','
    && istr >> im >> ch && ch == ')'

Here, ch is an object of type char, and re and im are objects of the same type as right.real().

If the result of this expression is true, the function stores re in the real part and im in the imaginary part of right. In any event, the function returns istr.

polar

double_complex polar(const double& rho,
    const double& theta = 0);
float_complex polar(const float& rho,
    const float& theta);

The function returns the complex value whose magnitude is rho and whose phase angle is theta.

pow

double_complex pow(const double_complex& left, int right);
double_complex pow(const double_complex& left, const Ty& right);
double_complex pow(const double_complex& left,
    const double_complex& right);
double_complex pow(const Ty& left, const double_complex& right);
float_complex pow(const float_complex& left, int right);
float_complex pow(const float_complex& left, const Ty& right);
float_complex pow(const float_complex& left,
    const float_complex& right);
float_complex pow(const Ty& left, const float_complex& right);

The functions each effectively convert both operands to the return type, then return the converted left to the power right. The branch cut for left is along the negative real axis.

real

double real(const double_complex& left);
float real(const float_complex& left);

The function returns the real part of left.

sin

double_complex sin(const double_complex& left);
float_complex sin(const float_complex& left);

The function returns the sine of left.

sinh

double_complex sinh(const double_complex& left);
float_complex sinh(const float_complex& left);

The function returns the hyperbolic sine of left.

sqrt

double_complex sqrt(const double_complex& left);
float_complex sqrt(const float_complex& left);

The function returns the square root of left, with phase angle in the half-open interval (-pi/2, pi/2]. The branch cuts are along the negative real axis.

__STD_COMPLEX

#define __STD_COMPLEX

The macro is defined, with an unspecified expansion, to indicate compliance with the specifications of this header.

tan

double_complex tan(const double_complex& left);
float_complex tan(const float_complex& left);

The function returns the tangent of left.

tanh

double_complex tanh(const double_complex& left);
float_complex tanh(const float_complex& left);

The function returns the hyperbolic tangent of left.

See also the Table of Contents and the Index.

Copyright © 1992-2006 by P.J. Plauger. All rights reserved.