/Users/garethloy/Musimathics/Musimat1.2/include/Complex.h

Go to the documentation of this file.

/* $Revision: 1.5 $ $Date: 2006/09/08 18:56:52 $ $Author: dgl $ $Name:  $ $Id: Complex.h,v 1.5 2006/09/08 18:56:52 dgl Exp $ */
#ifndef COMPLEX_H
#define COMPLEX_H

// The Musimat Tutorial � 2006 Gareth Loy
// Derived from Chapter 9 and Appendix B of "Musimathics Vol. 1" � 2006 Gareth Loy 
// and published exclusively by The MIT Press.
// This program is released WITHOUT ANY WARRANTY; without even the implied 
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
// For information on usage and redistribution, and for a DISCLAIMER OF ALL
// WARRANTIES, see the file, "LICENSE.txt," in this distribution.
// "Musimathics" is available here:     http://mitpress.mit.edu/catalog/item/default.asp?ttype=2&tid=10916
// Gareth Loy's Musimathics website:    http://www.musimathics.com/
// The Musimat website:                 http://www.musimat.com/
// This program is released under the terms of the GNU General Public License
// available here:                      http://www.gnu.org/licenses/gpl.txt


#include <iostream>
#include <math.h>
#include "Musimat.h"


class Complex
{
        friend ostream& operator<<( ostream& os, const Complex& c ) {
                cout << "(";
                // cout.precision(2); // Use this to set precision, if desired
                cout << c.m_r << ", ";
                cout << c.m_i;
                cout << ")";
                Return os;
        }

        friend istream& operator>>( istream& is, Complex& c ) {
                char ch;
                is >> ch && (ch == '{' || ch == '(')
                        && is >> c.m_r >> ch && ch == ','
                        && is >> c.m_i >> ch && (ch == '}' || ch == '(');
                Return is;
        }

public:

        Complex() : 
          m_r(0), 
          m_i(0) {
          }

        Complex(Real i) : 
          m_r(i), 
          m_i(i) {
          }

        Complex(Real r, Real i) : 
          m_r(r), 
          m_i(i) {
          }

        Real r(Void) {
                Return m_r;
        }

        Real i(Void) {
                Return m_i;
        }

        Void r(Real r) { m_r = r; }

        Void i(Real i) { m_i = i; }

        Complex& operator=(Const Real& x) {
                m_r = x;
                m_i = 0;
                Return *this;
        }

        Bool operator==(Const Complex& x) Const {
                Return m_r == x.m_r && m_i == x.m_i;
        }

        Bool operator!=(Const Complex& x) Const {
                Return !(m_r == x.m_r && m_i == x.m_i);
        }

        Bool operator<(Const Complex& x) Const {
                Return m_r < x.m_r && m_i < x.m_i;
        }

        Bool operator<=(Const Complex& x) Const {
                Return m_r <= x.m_r && m_i <= x.m_i;
        }

        Bool operator>=(Const Complex& x) Const {
                Return m_r >= x.m_r && m_i >= x.m_i;
        }

        Bool operator>(Const Complex& x) Const {
                Return m_r > x.m_r && m_i > x.m_i;
        }

        Complex operator+(Const Complex& c){
                Return Complex(m_r + c.m_r, m_i + c.m_i);
        }

        Complex operator-(Const Complex& c){
                Return Complex(m_r - c.m_r, m_i - c.m_i);
        }

        Complex operator-(){
                Return Complex(-m_r, -m_i);
        }

        Complex operator~(){
                Return Complex(m_r, -m_i);
        }

        Complex operator*(Const Complex& c){
                Return Complex(m_r * c.m_r - m_i * c.m_i,
                                           m_r * c.m_i + m_i * c.m_r);
        }

        Complex operator*(Const Real& r){
                Complex c(r, 0.0);
                Return *this * c;
        }

        Complex operator/(Const Complex& c){
                Real modulus = c.m_r * c.m_r + c.m_i * c.m_i;
                Real r = m_i * c.m_i + m_r * c.m_r;
                Real i = m_i * c.m_r - m_r * c.m_i;
    
                Return Complex(r / modulus, i / modulus);
        }

        Complex operator/(Const Real& r){
                Complex c(r, 0.0);
                Return *this / c;
        }

        Complex& operator+=(const Complex x) {
                Return( *this = *this + x );
        }

        Complex& operator-=(const Complex x) {
                Return( *this = *this - x );
        }

        Complex& operator*=(const Complex x) {
                Return( *this = *this * x );
        }

        Complex& operator/=(const Complex x) {
                Return( *this = *this / x );
        }

        Complex& operator/=(const Real r) {
                Complex x(r, 0.0);
                Return( *this = *this / x );
        }

        Complex Abs() {
                Complex t(m_r < 0.0 ? -m_r : m_r, m_i < 0.0 ? -m_i : m_i);
                Return(t);
        }

        Complex Conjugate() {
                Complex t(m_r, -m_i);
                Return(t);
        }

        Complex Exp(Complex e) {
                Real r = e.r();
                r = exp(r);
                Real theta = e.i();
                Complex t(r * Cos(theta), r * Sin(theta));
                Return t;
        }

        Void print(String s = 0) {
                If (s)
                        cout << s;
                cout << "{ ";
                cout.precision(2);
                cout << m_r << ", ";
                cout << m_i;
                cout << " }" << endl;
        }


private:
        Real m_r;               
        Real m_i;               
};

inline Real RealPart( Complex c ) { Return c.r(); }

inline Real ImagPart( Complex c ) { Return c.i(); }

inline Void RealPart( Complex& c, Real r ) { c.r(r); }

inline Void ImagPart( Complex& c, Real r ) { c.i(r); }

inline Complex Abs( Complex c ) { Return(c.Abs()); }

inline Complex Conjugate( Complex c ) { Return(~c); }

inline Complex Exp( Complex a, Complex b ) {
        Complex x = a.Exp( b );
        Return x;
}

inline Complex Exp(Real r, Real theta) {
        Complex t(r * Cos(theta), r * Sin(theta));
        Return t;
}

#endif // COMPLEX_H