CD Actual 14/CDACTUAL.iso/cdactual/demobin/share/program/c/ZCOMPLEX.ZIP/COMPLEX.HPP

C/C++ Source or Header | 1990-03-17 | 7.0 KB | 420 lines

//    Header:        Complex
//    Version:    2.00  28-Oct-1989
//    Language:    C++ 2.0;  Environ: Any;  Compilers: Zortech C++ 2.01
//    Purpose:    Provides the class "Complex" for C++ programs.  The
//            majority of the class is implemented inline for
//            efficiency.  Only the division, power, and i/o methods
//            are actual functions.
//    Written by:    Scott Robert Ladd, 705 West Virginia, Gunnison CO 81230
//            BBS [phone]; FidoNet 1:104/708

#ifndef COMPLEX_HPP
#define COMPLEX_HPP

#include <math.h>
#include <stream.hpp>

class Complex {
private:
    double        re;
    double        im;
    static void    ( * errorHandler) ();
protected:
public:
            Complex ( void);
            Complex ( const Complex &);
            Complex ( double &, double &);
            Complex ( double &);
    static void    setErrorHandler ( void ( * userHandler) ());
    friend double    real ( const Complex &);
    friend double    imag ( const Complex &);
    void        operator= ( const Complex &);
    void        operator= ( double &);
    Complex        operator- ();
    friend Complex     operator+ ( const Complex &, const Complex &);
    friend Complex     operator- ( const Complex &, const Complex &);
    friend Complex     operator* ( const Complex &, const Complex &);
    friend Complex     operator/ ( const Complex &, const Complex &);
    Complex     operator+= ( const Complex &);
    Complex        operator-= ( const Complex &);
    Complex        operator*= ( const Complex &);
    Complex        operator/= ( const Complex &);
    friend int    operator== ( const Complex &, const Complex &);
    friend int    operator!= ( const Complex &, const Complex &);
    friend int    operator< ( const Complex &, const Complex &);
    friend int    operator<= ( const Complex &, const Complex &);
    friend int    operator> ( const Complex &, const Complex &);
    friend int    operator>= ( const Complex &, const Complex &);
    friend double    abs ( const Complex &);
    friend double    norm ( const Complex &);
    friend double    arg ( const Complex &);
    friend Complex    polar ( double radius, double theta = 0.0);
    friend Complex    conj ( const Complex &);
    friend Complex    cos ( const Complex &);
    friend Complex    sin ( const Complex &);
    friend Complex    tan ( const Complex &);
    friend Complex    cosh ( const Complex &);
    friend Complex    sinh ( const Complex &);
    friend Complex    tanh ( const Complex &);
    friend Complex    exp ( const Complex &);
    friend Complex    log ( const Complex &);
    friend Complex    pow ( const Complex &, const Complex &);
    friend Complex    sqrt ( const Complex &);
    friend ostream &operator<< ( ostream &, const Complex &);
    friend istream &operator>> ( istream &, Complex &);
};

inline
Complex::Complex (
) {
    re = im = 0.0;
}

inline
Complex::Complex (
    const Complex &    c
) {
    re = c.re;
    im = c.im;
}

inline
Complex::Complex (
    double &    r,
    double &    i
) {
    re = r;
    im = i;
}

inline
Complex::Complex (
    double &    r
) {
    re = r;
    im = 0.0;
}

inline
void
Complex::setErrorHandler (
    void        ( * userHandler) ()
) {
    errorHandler = userHandler;
}

inline
double
real (
    const Complex &    c
) {
    return c.re;
}

inline
double
imag (
    const Complex &    c
) {
    return c.im;
}

inline
void
Complex::operator= (
    const Complex &    c
) {
    re = c.re;
    im = c.im;
}

inline
void
Complex::operator= (
    double &    r
) {
    re = r;
    im = 0.0;
}

inline
Complex
Complex::operator- (
) {
    Complex        result;
    result.re = -re;
    result.im = -im;
    return result;
}

inline
Complex
operator+ (
    const Complex &    c1,
    const Complex &    c2
) {
    Complex        result;
    result.re = c1.re + c2.re;
    result.im = c1.im + c2.im;
    return result;
}

inline
Complex
operator- (
    const Complex &    c1,
    const Complex &    c2
) {
    Complex        result;
    result.re = c1.re - c2.re;
    result.im = c1.im - c2.im;
    return result;
}

inline
Complex
operator* (
    const Complex &    c1,
    const Complex &    c2
) {
    Complex        result;
    result.re = c1.re * c2.re - c1.im * c2.im;
    result.im = c1.re * c2.im + c1.im * c2.re;
    return result;
}

inline
Complex
Complex::operator+= (
    const Complex &    c
) {
    re += c.re;
    im += c.im;
    return *this;
}

inline
Complex
Complex::operator-= (
    const Complex &    c
) {
    re -= c.re;
    im -= c.im;
    return *this;
}

inline
Complex
Complex::operator*= (
    const Complex &    c
) {
    double        oldReal;
    oldReal = re;
    re = re * c.re - im * c.im;
    im = oldReal * c.im + im * c.re;
    return *this;
}

inline
int
operator== (
    const Complex &    c1,
    const Complex & c2
) {
    return ( c1.re == c2.re) && ( c1.im == c2.im);
}

inline
int
operator!= (
    const Complex &    c1,
    const Complex & c2
) {
    return ( c1.re != c2.re) || ( c1.im != c2.im);
}

inline
int
operator< (
    const Complex &    c1,
    const Complex & c2
) {
    return abs ( c1) < abs ( c2);
}

inline
int
operator<= (
    const Complex & c1,
    const Complex & c2
) {
    return abs ( c1) <= abs ( c2);
}

inline
int
operator> (
    const Complex &    c1,
    const Complex &    c2
) {
    return abs ( c1) > abs ( c2);
}

inline
int
operator>= (
    const Complex &    c1,
    const Complex &    c2
) {
    return abs ( c1) >= abs ( c2);
}

inline
double
abs (
    const Complex &    c
) {
    double        result;
    result = sqrt ( c.re * c.re + c.im * c.im);
    return result;
}

inline
double
norm (
    const Complex &    c
) {
    double        result;
    result = c.re * c.re + c.im * c.im;
    return result;
}

inline
double
arg (
    const Complex &    c
) {
    double        result;
    result = atan2 ( c.im, c.re);
    return result;
}

inline
Complex
polar (
    double        radius,
    double        theta
) {
    Complex        result;
    result.re = radius * cos ( theta);
    result.im = radius * sin ( theta);
    return result;
}

inline
Complex
conj (
    const Complex &    c
) {
    Complex        result;
    result.re = c.re;
    result.im = -c.im;
    return result;
}

inline
Complex
cos (
    const Complex &    c
) {
    Complex        result;
    result.re = cos ( c.re) * cosh ( c.im);
    result.im = cos ( c.re) * sinh ( c.im);
    return result;
}

inline
Complex
sin (
    const Complex &    c
) {
    Complex        result;
    result.re = sin ( c.re) * cosh ( c.im);
    result.im = cos ( c.re) * sinh ( c.im);
    return result;
}

inline
Complex
tan (
    const Complex &    c
) {
    Complex        result;
    result = sin ( c) / cos ( c);
    return result;
}

inline
Complex
cosh (
    const Complex &    c
) {
    Complex        result;
    result.re = cos ( c.im) * cosh ( c.re);
    result.im = sin ( c.im) * sinh ( c.re);
    return result;
}

inline
Complex
sinh (
    const Complex &     c
) {
    Complex        result;
    result.re = cos ( c.im) * sinh ( c.re);
    result.im = sin ( c.im) * cosh ( c.re);
    return result;
}

inline
Complex
tanh (
    const Complex &    c
) {
    Complex        result;
    result = sinh ( c) / cosh ( c);
    return result;
}

inline
Complex
exp (
    const Complex &    c
) {
    Complex        result;
    double        x = exp ( c.re);
    result.re = x * cos ( c.im);
    result.im = x * sin ( c.im);
    return result;
}

inline
Complex
log (
    const Complex &    c
) {
    Complex        result;
    double        hypot = abs ( c);
    if ( hypot > 0.0) {
        result.re = log ( hypot);
        result.im = atan2 ( c.im, c.re);
    } else
        Complex::errorHandler ();
    return result;
}

#endif     // COMPLEX_HPP