complex

symbian上STL模板库的实现

// The template and inlines for the -*- C++ -*- complex number classes.

// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

//
// ISO C++ 14882: 26.2  Complex Numbers
// Note: this is not a conforming implementation.
// Initially implemented by Ulrich Drepper <[e-mail]>
// Improved by Gabriel Dos Reis <[e-mail]>
//

/** @file complex
 *  This is a Standard C++ Library header.  You should @c #include this header
 *  in your programs, rather than any of the "st[dl]_*.h" implementation files.
 */

#ifndef _GLIBCXX_COMPLEX
#define _GLIBCXX_COMPLEX 1

//#pragma GCC system_header

#include <bits/c++config.h>
#include <bits/cpp_type_traits.h>
#include <cmath>
#include <sstream>

namespace std
{
    // Forward declarations
    template<typename _Tp> class complex;
    template<> class complex<float>;
    template<> class complex<double>;
    template<> class complex<long double>;

    ///  Return magnitude of @a z.
    template<typename _Tp> _Tp abs(const complex<_Tp>&);
    ///  Return phase angle of @a z.
    template<typename _Tp> _Tp arg(const complex<_Tp>&);
    ///  Return @a z magnitude squared.
    template<typename _Tp> _Tp norm(const complex<_Tp>&);

    ///  Return complex conjugate of @a z.
    template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
    ///  Return complex with magnitude @a rho and angle @a theta.
    template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);

    // Transcendentals:
    /// Return complex cosine of @a z.
    template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
    /// Return complex hyperbolic cosine of @a z.
    template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
    /// Return complex base e exponential of @a z.
    template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
    /// Return complex natural logarithm of @a z.
    template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
    /// Return complex base 10 logarithm of @a z.
    template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
    /// Return complex cosine of @a z.
    template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
    /// Return @a x to the @a y'th power.
    template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
    /// Return @a x to the @a y'th power.
    template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, 
            const complex<_Tp>&);
    /// Return @a x to the @a y'th power.
    template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
    /// Return complex sine of @a z.
    template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
    /// Return complex hyperbolic sine of @a z.
    template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
    /// Return complex square root of @a z.
    template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
    /// Return complex tangent of @a z.
    template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
    /// Return complex hyperbolic tangent of @a z.
    template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
    //@}


    // 26.2.2  Primary template class complex
    /**
     *  Template to represent complex numbers.
     *
     *  Specializations for float, double, and long double are part of the
     *  library.  Results with any other type are not guaranteed.
     *
     *  @param  Tp  Type of real and imaginary values.
     */
    template<typename _Tp>
    class complex
{
    public:
        /// Value typedef.
        typedef _Tp value_type;

        ///  Default constructor.  First parameter is x, second parameter is y.
        ///  Unspecified parameters default to 0.
        complex(const _Tp& = _Tp(), const _Tp & = _Tp());

        // Lets the compiler synthesize the copy constructor   
        // complex (const complex<_Tp>&);
        ///  Copy constructor.
        template<typename _Up>
            complex(const complex<_Up>&);

        ///  Return real part of complex number.
        _Tp& real(); 
        ///  Return real part of complex number.
        const _Tp& real() const;
        ///  Return imaginary part of complex number.
        _Tp& imag();
        ///  Return imaginary part of complex number.
        const _Tp& imag() const;

        /// Assign this complex number to scalar @a t.
        complex<_Tp>& operator=(const _Tp&);
        /// Add @a t to this complex number.
        complex<_Tp>& operator+=(const _Tp&);
        /// Subtract @a t from this complex number.
        complex<_Tp>& operator-=(const _Tp&);
        /// Multiply this complex number by @a t.
        complex<_Tp>& operator*=(const _Tp&);
        /// Divide this complex number by @a t.
        complex<_Tp>& operator/=(const _Tp&);

        // Lets the compiler synthesize the
        // copy and assignment operator
        // complex<_Tp>& operator= (const complex<_Tp>&);
        /// Assign this complex number to complex @a z.
        template<typename _Up>
            complex<_Tp>& operator=(const complex<_Up>&);
        /// Add @a z to this complex number.
        template<typename _Up>
            complex<_Tp>& operator+=(const complex<_Up>&);
        /// Subtract @a z from this complex number.
        template<typename _Up>
            complex<_Tp>& operator-=(const complex<_Up>&);
        /// Multiply this complex number by @a z.
        template<typename _Up>
            complex<_Tp>& operator*=(const complex<_Up>&);
        /// Divide this complex number by @a z.
        template<typename _Up>
            complex<_Tp>& operator/=(const complex<_Up>&);

    private:
        _Tp _M_real;
        _Tp _M_imag;
};

template<typename _Tp>
inline _Tp&
complex<_Tp>::real() { return _M_real; }

template<typename _Tp>
inline const _Tp&
complex<_Tp>::real() const { return _M_real; }

template<typename _Tp>
inline _Tp&
complex<_Tp>::imag() { return _M_imag; }

template<typename _Tp>
inline const _Tp&
complex<_Tp>::imag() const { return _M_imag; }

template<typename _Tp>
    inline 
complex<_Tp>::complex(const _Tp& __r, const _Tp& __i)
    : _M_real(__r), _M_imag(__i) { }

    template<typename _Tp>
    template<typename _Up>
    inline 
complex<_Tp>::complex(const complex<_Up>& __z)
    : _M_real(__z.real()), _M_imag(__z.imag()) { }

    template<typename _Tp>
    complex<_Tp>&
complex<_Tp>::operator=(const _Tp& __t)
{
    _M_real = __t;
    _M_imag = _Tp();
    return *this;
} 

// 26.2.5/1
template<typename _Tp>
    inline complex<_Tp>&
complex<_Tp>::operator+=(const _Tp& __t)
{
    _M_real += __t;
    return *this;
}

// 26.2.5/3
template<typename _Tp>
    inline complex<_Tp>&
complex<_Tp>::operator-=(const _Tp& __t)
{
    _M_real -= __t;
    return *this;
}

// 26.2.5/5
template<typename _Tp>
    complex<_Tp>&
complex<_Tp>::operator*=(const _Tp& __t)
{
    _M_real *= __t;
    _M_imag *= __t;
    return *this;
}

// 26.2.5/7
template<typename _Tp>
    complex<_Tp>&
complex<_Tp>::operator/=(const _Tp& __t)
{
    _M_real /= __t;
    _M_imag /= __t;
    return *this;
}

template<typename _Tp>
template<typename _Up>
    complex<_Tp>&
complex<_Tp>::operator=(const complex<_Up>& __z)
{
    _M_real = __z.real();
    _M_imag = __z.imag();
    return *this;
}

// 26.2.5/9
template<typename _Tp>
template<typename _Up>
    complex<_Tp>&
complex<_Tp>::operator+=(const complex<_Up>& __z)
{
    _M_real += __z.real();
    _M_imag += __z.imag();
    return *this;
}

// 26.2.5/11
template<typename _Tp>
template<typename _Up>
    complex<_Tp>&
complex<_Tp>::operator-=(const complex<_Up>& __z)
{
    _M_real -= __z.real();
    _M_imag -= __z.imag();
    return *this;
}

// 26.2.5/13
// XXX: This is a grammar school implementation.
template<typename _Tp>
template<typename _Up>
    complex<_Tp>&
complex<_Tp>::operator*=(const complex<_Up>& __z)
{
    const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
    _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
    _M_real = __r;
    return *this;
}

// 26.2.5/15
// XXX: This is a grammar school implementation.
template<typename _Tp>
template<typename _Up>
    complex<_Tp>&
complex<_Tp>::operator/=(const complex<_Up>& __z)
{
    const _Tp __r =  _M_real * __z.real() + _M_imag * __z.imag();
    const _Tp __n = std::norm(__z);
    _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
    _M_real = __r / __n;
    return *this;
}

// Operators:
//@{
///  Return new complex value @a x plus @a y.
template<typename _Tp>
    inline complex<_Tp>
operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
    complex<_Tp> __r = __x;
    __r += __y;
    return __r;
}

template<typename _Tp>
    inline complex<_Tp>
operator+(const complex<_Tp>& __x, const _Tp& __y)
{
    complex<_Tp> __r = __x;
    __r.real() += __y;
    return __r;
}

template<typename _Tp>
    inline complex<_Tp>
operator+(const _Tp& __x, const complex<_Tp>& __y)
{
    complex<_Tp> __r = __y;
    __r.real() += __x;
    return __r;
}
//@}

//@{
///  Return new complex value @a x minus @a y.
template<typename _Tp>
    inline complex<_Tp>
operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
    complex<_Tp> __r = __x;
    __r -= __y;
    return __r;
}

template<typename _Tp>
    inline complex<_Tp>
operator-(const complex<_Tp>& __x, const _Tp& __y)
{
    complex<_Tp> __r = __x;
    __r.real() -= __y;
    return __r;
}

template<typename _Tp>
    inline complex<_Tp>
operator-(const _Tp& __x, const complex<_Tp>& __y)
{
    complex<_Tp> __r(__x, -__y.imag());
    __r.real() -= __y.real();
    return __r;
}
//@}

//@{
///  Return new complex value @a x times @a y.
template<typename _Tp>
    inline complex<_Tp>
operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
    complex<_Tp> __r = __x;
    __r *= __y;
    return __r;
}

template<typename _Tp>
    inline complex<_Tp>
operator*(const complex<_Tp>& __x, const _Tp& __y)
{
    complex<_Tp> __r = __x;
    __r *= __y;
    return __r;
}

template<typename _Tp>
    inline complex<_Tp>
operator*(const _Tp& __x, const complex<_Tp>& __y)
{
    complex<_Tp> __r = __y;
    __r *= __x;
    return __r;
}
//@}

//@{
///  Return new complex value @a x divided by @a y.
template<typename _Tp>
    inline complex<_Tp>
operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
    complex<_Tp> __r = __x;
    __r /= __y;
    return __r;
}

template<typename _Tp>