apcplx.h

任意精度计算的实现

    apfloat re, im;                             // Won't be private
};


// Inline apcomplex functions

inline apcomplex::apcomplex ()
{
}

inline apcomplex apcomplex::operator+ () const
{
    return *this;
}

inline apcomplex apcomplex::operator- () const
{
    return apcomplex (-re, -im);
}


// Definitions of compound-assignment operator member functions

inline apcomplex &apcomplex::operator+= (const apcomplex &z)
{
    re = re + z.re;
    im = im + z.im;

    return *this;
}

inline apcomplex &apcomplex::operator+= (const apfloat &d)
{
    re = re + d;

    return *this;
}

inline apcomplex &apcomplex::operator-= (const apcomplex &z)
{
    re = re - z.re;
    im = im - z.im;

    return *this;
}

inline apcomplex &apcomplex::operator-= (const apfloat &d)
{
    re = re - d;

    return *this;
}

inline apcomplex &apcomplex::operator*= (const apcomplex &z)
{
    *this = *this * z;

    return *this;
}

inline apcomplex &apcomplex::operator*= (const apfloat &d)
{
    re = re * d;
    im = im * d;

    return *this;
}

inline apcomplex &apcomplex::operator/= (const apfloat &d)
{
    *this = *this / d;

    return *this;
}


// Overloaded mathematical functions

apcomplex pow (apcomplex base, unsigned long exp);
apcomplex pow (apcomplex base, unsigned exp);
apcomplex pow (apcomplex base, long exp);
apcomplex pow (apcomplex base, int exp);
apcomplex sqrt (apcomplex z);
apcomplex cbrt (apcomplex z);
apcomplex invroot (apcomplex u, unsigned n);
apfloat abs (apcomplex z);
apcomplex agm (apcomplex a, apcomplex b);
apcomplex exp (apcomplex z);
apcomplex rawlog (apcomplex z);
apcomplex log (apcomplex z);
apcomplex pow (apcomplex z, apfloat w);
apcomplex pow (apfloat z, apcomplex w);
apcomplex pow (apcomplex z, apcomplex w);
apcomplex acos (apcomplex z);
apcomplex acosh (apcomplex z);
apcomplex asin (apcomplex z);
apcomplex asinh (apcomplex z);
apcomplex atan (apcomplex z);
apcomplex atanh (apcomplex z);
apcomplex cos (apcomplex z);
apcomplex cosh (apcomplex z);
apcomplex sin (apcomplex z);
apcomplex sinh (apcomplex z);
apcomplex tan (apcomplex z);
apcomplex tanh (apcomplex z);

// Real trigonometric functions that use complex stuff
apfloat acos (apfloat x);
apfloat asin (apfloat x);
apfloat atan (apfloat x);
apfloat atan2 (apfloat x, apfloat y);
apfloat cos (apfloat x);
apfloat sin (apfloat x);
apfloat tan (apfloat x);


// Definitions of non-member apcomplex functions

inline apcomplex polar (apfloat mag, apfloat angle)
{
    return mag * exp (apcomplex (0, angle));
}

inline apfloat real (const apcomplex &z)
{
    return z.re;
}

inline apfloat imag (const apcomplex &z)
{
    return z.im;
}

inline apcomplex conj (const apcomplex &z)
{
    return apcomplex (z.re, -z.im);
}

inline apfloat norm (const apcomplex &z)
{
    return z.re * z.re + z.im * z.im;
}

inline apfloat arg (const apcomplex &z)
{
    return atan2 (z.re, z.im);
}


// Definitions of non-member binary operator functions

inline apcomplex operator+ (const apcomplex &z1, const apcomplex &z2)
{
    return apcomplex (z1.re + z2.re, z1.im + z2.im);
}

inline apcomplex operator+ (const apfloat &d1, const apcomplex &z2)
{
    return apcomplex (d1 + z2.re, z2.im);
}

inline apcomplex operator+ (const apcomplex &z1, const apfloat &d2)
{
    return apcomplex (z1.re + d2, z1.im);
}

inline apcomplex operator- (const apcomplex &z1, const apcomplex &z2)
{
    return apcomplex (z1.re - z2.re, z1.im - z2.im);
}

inline apcomplex operator- (const apfloat &d1, const apcomplex &z2)
{
    return apcomplex (d1 - z2.re, -z2.im);
}

inline apcomplex operator- (const apcomplex &z1, const apfloat &d2)
{
    return apcomplex (z1.re - d2, z1.im);
}

inline apcomplex operator* (const apfloat &d1, const apcomplex &z2)
{
    return apcomplex (d1 * z2.re, d1 * z2.im);
}

inline apcomplex operator* (const apcomplex &z1, const apfloat &d2)
{
    return apcomplex (z1.re * d2, z1.im * d2);
}

inline bool operator== (const apcomplex &z1, const apcomplex &z2)
{
    return (z1.re == z2.re && z1.im == z2.im);
}

inline bool operator== (const apfloat &d1, const apcomplex &z2)
{
    return (d1 == z2.re && !z2.im.sign ());
}

inline bool operator== (const apcomplex &z1, const apfloat &d2)
{
    return (z1.re == d2 && !z1.im.sign ());
}

inline bool operator!= (const apcomplex &z1, const apcomplex &z2)
{
    return (z1.re != z2.re || z1.im != z2.im);
}

inline bool operator!= (const apfloat &d1, const apcomplex &z2)
{
    return (d1 != z2.re || z2.im.sign ());
}

inline bool operator!= (const apcomplex &z1, const apfloat &d2)
{
    return (z1.re != d2 || z1.im.sign ());
}


#endif  // __APCPLX_H