| // -*- C++ -*- |
| /*************************************************************************** |
| * |
| * <complex> - definitions of the template complex and specializations |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 2000-2007 Rogue Wave Software, Inc. |
| * |
| **************************************************************************/ |
| |
| #ifndef _RWSTD_COMPLEX_INCLUDED |
| #define _RWSTD_COMPLEX_INCLUDED |
| |
| #include <sstream> |
| #include <iosfwd> |
| #include <utility> |
| |
| #include <rw/_defs.h> |
| #include _RWSTD_CMATH |
| |
| |
| #ifdef _RWSTD_MSVC |
| # pragma warning (push) |
| // disable conversion from 'double' to 'float', possible loss of data |
| // until a conforming <cmath> header with float and long double overloads |
| // for the C functions is provided |
| # pragma warning (disable: 4244) |
| #endif // _RWSTD_MSVC |
| |
| |
| _RWSTD_NAMESPACE (std) { |
| |
| // 26.2.2 |
| template <class _TypeT> |
| class complex; |
| |
| // 26.2.3 |
| _RWSTD_SPECIALIZED_CLASS |
| class complex<float>; |
| |
| // 26.2.3 |
| _RWSTD_SPECIALIZED_CLASS |
| class complex<double>; |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| // 26.2.3 |
| _RWSTD_SPECIALIZED_CLASS |
| class complex<long double>; |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| |
| // 26.2.6 complex non-member operations (used from within member functions) |
| |
| // 26.2.6, p7 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator* (const complex<_TypeT> &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return complex<_TypeT>(_TypeT ( __lhs.real () * __rhs.real () |
| - __lhs.imag () * __rhs.imag ()), |
| _TypeT ( __lhs.imag () * __rhs.real () |
| + __lhs.real () * __rhs.imag ())); |
| } |
| |
| |
| // 26.2.6, p8 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator/ (const complex<_TypeT> &__lhs, const complex<_TypeT> &__rhs) |
| { |
| _TypeT __den = __rhs.real() * __rhs.real() + __rhs.imag() * __rhs.imag(); |
| |
| return complex<_TypeT>(_TypeT ( __lhs.real () * __rhs.real () |
| + __lhs.imag () * __rhs.imag ()) / __den, |
| _TypeT ( __lhs.imag () * __rhs.real () |
| - __lhs.real () * __rhs.imag ()) / __den); |
| } |
| |
| |
| // 26.2.3 - complex specializations |
| |
| _RWSTD_SPECIALIZED_CLASS |
| class complex<float> |
| { |
| public: |
| typedef float value_type; |
| |
| // implicit conversion |
| complex (value_type __re = value_type (), value_type __im = value_type ()) |
| : _C_re (__re), _C_im (__im) { } |
| |
| // defined after the definition of the incomplete complex<double> |
| explicit complex (const complex<double>&); |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| // defined after the definition of the incomplete complex<long double> |
| explicit complex (const complex<long double>&); |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| value_type imag () const { |
| return _C_im; |
| } |
| |
| value_type real () const { |
| return _C_re; |
| } |
| |
| #if defined (_COMPILER_VERSION) && _COMPILER_VERSION <= 730 |
| |
| // working around a MIPSpro 7.3.1 bug (SGI serial #0800690BCFC2) |
| complex<value_type>& operator= (const complex<value_type>& __rhs) { |
| return (_C_re = __rhs._C_re), (_C_im = __rhs._C_im), *this; |
| } |
| |
| #endif // _COMPILER_VERSION <= 730 |
| |
| template <class _TypeT> |
| complex& operator= (const complex<_TypeT>& __rhs) { |
| return (_C_re = __rhs.real ()), (_C_im = __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator+= (const complex<_TypeX> &__rhs) { |
| return (_C_re += __rhs.real ()), (_C_im += __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator-= (const complex<_TypeX> &__rhs) { |
| return (_C_re -= __rhs.real ()), (_C_im -= __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator*= (const complex<_TypeX> &__rhs) { |
| return *this = *this * complex<value_type>(__rhs); |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator/= (const complex<_TypeX> &__rhs) { |
| return *this = *this / complex<value_type>(__rhs); |
| } |
| |
| complex<value_type>& operator= (value_type __rhs) { |
| return (_C_re = __rhs), (_C_im = value_type ()), *this; |
| } |
| |
| complex<value_type>& operator+= (value_type __rhs) { |
| return _C_re += __rhs, *this; |
| } |
| |
| complex<value_type>& operator-= (value_type __rhs) { |
| return _C_re -= __rhs, *this; |
| } |
| |
| complex<value_type>& operator*= (value_type __rhs) { |
| return (_C_re *= __rhs), (_C_im *= __rhs), *this; |
| } |
| |
| complex<value_type>& operator/= (value_type __rhs) { |
| return (_C_re /= __rhs), (_C_im /= __rhs), *this; |
| } |
| |
| private: |
| value_type _C_re, _C_im; |
| }; |
| |
| |
| _RWSTD_SPECIALIZED_CLASS |
| class complex<double> |
| { |
| public: |
| typedef double value_type; |
| |
| // implicit conversion |
| complex (value_type __re = value_type (), value_type __im = value_type ()) |
| : _C_re (__re), _C_im (__im) { } |
| |
| // implicit conversion |
| complex (const complex<float> &__rhs) |
| : _C_re (__rhs.real ()), _C_im (__rhs.imag ()) { } |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| // defined after the definition of the incomplete complex<long double> |
| explicit complex (const complex<long double>&); |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| value_type imag () const { |
| return _C_im; |
| } |
| |
| value_type real () const { |
| return _C_re; |
| } |
| |
| #if defined (_COMPILER_VERSION) && _COMPILER_VERSION <= 730 |
| |
| // working around a MIPSpro 7.3.1 bug (SGI serial #0800690BCFC2) |
| complex<value_type>& operator= (const complex<value_type>& __rhs) { |
| return (_C_re = __rhs._C_re), (_C_im = __rhs._C_im), *this; |
| } |
| |
| #endif // _COMPILER_VERSION <= 730 |
| |
| template <class _TypeT> |
| complex& operator= (const complex<_TypeT>& __rhs) { |
| return (_C_re = __rhs.real ()), (_C_im = __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator+= (const complex<_TypeX> &__rhs) { |
| return (_C_re += __rhs.real ()), (_C_im += __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator-= (const complex<_TypeX> &__rhs) { |
| return (_C_re -= __rhs.real ()), (_C_im -= __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator*= (const complex<_TypeX> &__rhs) { |
| return *this = *this * complex<value_type>(__rhs); |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator/= (const complex<_TypeX> &__rhs) { |
| return *this = *this / complex<value_type>(__rhs); |
| } |
| |
| complex<value_type>& operator= (value_type __rhs) { |
| return (_C_re = __rhs), (_C_im = value_type ()), *this; |
| } |
| |
| complex<value_type>& operator+= (value_type __rhs) { |
| return _C_re += __rhs, *this; |
| } |
| |
| complex<value_type>& operator-= (value_type __rhs) { |
| return _C_re -= __rhs, *this; |
| } |
| |
| complex<value_type>& operator*= (value_type __rhs) { |
| return (_C_re *= __rhs), (_C_im *= __rhs), *this; |
| } |
| |
| complex<value_type>& operator/= (value_type __rhs) { |
| return (_C_re /= __rhs), (_C_im /= __rhs), *this; |
| } |
| |
| private: |
| value_type _C_re, _C_im; |
| }; |
| |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| _RWSTD_SPECIALIZED_CLASS |
| class complex<long double> |
| { |
| public: |
| typedef long double value_type; |
| |
| // implicit conversion |
| complex (value_type __re = value_type (), value_type __im = value_type ()) |
| : _C_re (__re), _C_im (__im) { } |
| |
| // implicit conversion |
| complex (const complex<float> &__rhs) |
| : _C_re (__rhs.real ()), _C_im (__rhs.imag ()) { } |
| |
| // implicit conversion |
| complex (const complex<double> &__rhs) |
| : _C_re (__rhs.real ()), _C_im (__rhs.imag ()) { } |
| |
| value_type imag () const { |
| return _C_im; |
| } |
| |
| value_type real () const { |
| return _C_re; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator+= (const complex<_TypeX> &__rhs) { |
| return (_C_re += __rhs.real ()), (_C_im += __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator-= (const complex<_TypeX> &__rhs) { |
| return (_C_re -= __rhs.real ()), (_C_im -= __rhs.imag ()), *this; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator*= (const complex<_TypeX> &__rhs) { |
| return *this = *this * complex<value_type>(__rhs); |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator/= (const complex<_TypeX> &__rhs) { |
| return *this = *this / complex<value_type>(__rhs); |
| } |
| |
| #if defined (_COMPILER_VERSION) && _COMPILER_VERSION <= 730 |
| |
| // working around a MIPSpro 7.3.1 bug (SGI serial #0800690BCFC2) |
| complex<value_type>& operator= (const complex<value_type>& __rhs) { |
| return (_C_re = __rhs._C_re), (_C_im = __rhs._C_im), *this; |
| } |
| |
| #endif // _COMPILER_VERSION <= 730 |
| |
| template <class _TypeT> |
| complex& operator= (const complex<_TypeT>& __rhs) { |
| return (_C_re = __rhs.real ()), (_C_im = __rhs.imag ()), *this; |
| } |
| |
| complex& operator+= (value_type __rhs) { |
| return _C_re += __rhs, *this; |
| } |
| |
| complex& operator-= (value_type __rhs) { |
| return _C_re -= __rhs, *this; |
| } |
| |
| complex& operator*= (value_type __rhs) { |
| return (_C_re *= __rhs), (_C_im *= __rhs), *this; |
| } |
| |
| complex& operator/= (value_type __rhs) { |
| return (_C_re /= __rhs), (_C_im /= __rhs), *this; |
| } |
| |
| private: |
| value_type _C_re, _C_im; |
| }; |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| |
| inline complex<float>::complex (const complex<double> &__rhs) |
| : _C_re (_RWSTD_STATIC_CAST (value_type, __rhs.real ())), |
| _C_im (_RWSTD_STATIC_CAST (value_type, __rhs.imag ())) |
| { } |
| |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| inline complex<float>::complex (const complex<long double> &__rhs) |
| : _C_re (_RWSTD_STATIC_CAST (value_type, __rhs.real ())), |
| _C_im (_RWSTD_STATIC_CAST (value_type, __rhs.imag ())) |
| { } |
| |
| inline complex<double>::complex (const complex<long double> &__rhs) |
| : _C_re (_RWSTD_STATIC_CAST (value_type, __rhs.real ())), |
| _C_im (_RWSTD_STATIC_CAST (value_type, __rhs.imag ())) |
| { } |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| |
| |
| // 26.2.2 |
| template <class _TypeT> |
| class complex |
| { |
| public: |
| typedef _TypeT value_type; |
| |
| complex (const value_type &__re = value_type (), |
| const value_type &__im = value_type ()) |
| : _C_re (__re), _C_im (__im) { } |
| |
| value_type imag () const { |
| return _C_im; |
| } |
| |
| value_type real () const { |
| return _C_re; |
| } |
| |
| template <class _TypeU> |
| complex (const complex<_TypeU>& __rhs) |
| : _C_re (_RWSTD_STATIC_CAST (value_type, __rhs.real ())), |
| _C_im (_RWSTD_STATIC_CAST (value_type, __rhs.imag ())) { } |
| |
| template <class _TypeU> |
| complex& operator= (const complex<_TypeU>& __rhs) { |
| // not recursive: calls the compiler-generated operator=() |
| return *this = complex (__rhs); |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator+= (const complex<_TypeX> &__rhs) { |
| return *this = *this + __rhs; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator-= (const complex<_TypeX> &__rhs) { |
| return *this = *this - __rhs; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator*= (const complex<_TypeX> &__rhs) { |
| return *this = *this * __rhs; |
| } |
| |
| template <class _TypeX> |
| complex<value_type>& operator/= (const complex<_TypeX> &__rhs) { |
| return *this = *this / __rhs; |
| } |
| |
| complex& operator= (value_type __rhs) { |
| return (_C_re = __rhs), (_C_im = value_type ()), *this; |
| } |
| |
| complex& operator+= (value_type __rhs) { |
| return _C_re += __rhs, *this; |
| } |
| |
| complex& operator-= (value_type __rhs) { |
| return _C_re -= __rhs, *this; |
| } |
| |
| complex& operator*= (value_type __rhs) { |
| return (_C_re *= __rhs), (_C_im *= __rhs), *this; |
| } |
| |
| complex& operator/= (value_type __rhs) { |
| return (_C_re /= __rhs), (_C_im /= __rhs), *this; |
| } |
| |
| private: |
| value_type _C_re, _C_im; |
| }; |
| |
| |
| // 26.2.6 complex non-member operations |
| |
| // 26.2.6, p1 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator+ (const complex<_TypeT> &__rhs) |
| { |
| return __rhs; |
| } |
| |
| |
| // 26.2.6, p3 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator+ (const complex<_TypeT> &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return complex<_TypeT>(_TypeT (__lhs.real () + __rhs.real ()), |
| _TypeT (__lhs.imag () + __rhs.imag ())); |
| } |
| |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator+ (const complex<_TypeT> &__lhs, const _TypeT &__rhs) |
| { |
| return complex<_TypeT>(__lhs.real () + __rhs, __lhs.imag ()); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator+ (const _TypeT &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return __rhs + __lhs; |
| } |
| |
| |
| // 26.2.6, p4 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator- (const complex<_TypeT> &__rhs) |
| { |
| return complex<_TypeT>(-__rhs.real (), -__rhs.imag ()); |
| } |
| |
| |
| // 26.2.6, p6 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator- (const complex<_TypeT> &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return complex<_TypeT>(_TypeT (__lhs.real () - __rhs.real ()), |
| _TypeT (__lhs.imag () - __rhs.imag ())); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator- (const complex<_TypeT> &__lhs, const _TypeT &__rhs) |
| { |
| return complex<_TypeT>(__lhs.real () - __rhs, __lhs.imag ()); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator- (const _TypeT &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return complex<_TypeT>(__lhs - __rhs.real (), - __rhs.imag ()); |
| } |
| |
| |
| // 26.2.6, p7 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator* (const complex<_TypeT> &__lhs, const _TypeT &__rhs) |
| { |
| return complex<_TypeT>(__lhs.real () * __rhs, __lhs.imag () * __rhs); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator* (const _TypeT &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return __rhs * __lhs; |
| } |
| |
| |
| // 26.2.6, p8 |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator/ (const complex<_TypeT> &__lhs, const _TypeT &__rhs) |
| { |
| return complex<_TypeT>(__lhs.real () / __rhs, |
| __lhs.imag () / __rhs); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> |
| operator/ (const _TypeT &__lhs, const complex<_TypeT> &__rhs) |
| { |
| _TypeT __den = __rhs.real() * __rhs.real() + __rhs.imag() * __rhs.imag(); |
| |
| return complex<_TypeT>(_TypeT (__lhs * __rhs.real ()) / __den, |
| -_TypeT (__lhs * __rhs.imag ()) / __den); |
| } |
| |
| |
| // 26.2.6, p9 |
| template <class _TypeT> |
| inline bool |
| operator== (const complex<_TypeT> &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return __lhs.real () == __rhs.real () && __lhs.imag () == __rhs.imag (); |
| } |
| |
| |
| template <class _TypeT> |
| inline bool operator== (const complex<_TypeT> &__lhs, const _TypeT &__rhs) |
| { |
| return __lhs.real () == __rhs && __lhs.imag () == _TypeT (); |
| } |
| |
| |
| template <class _TypeT> |
| inline bool operator== (const _TypeT &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return __rhs == __lhs; |
| } |
| |
| |
| // 26.2.6, p11 |
| template <class _TypeT> |
| inline bool |
| operator!= (const complex<_TypeT> &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return !(__lhs == __rhs); |
| } |
| |
| |
| template <class _TypeT> |
| inline bool operator!= (const complex<_TypeT> &__lhs, const _TypeT &__rhs) |
| { |
| return !(__lhs == __rhs); |
| } |
| |
| |
| template <class _TypeT> |
| inline bool operator!= (const _TypeT &__lhs, const complex<_TypeT> &__rhs) |
| { |
| return !(__lhs == __rhs); |
| } |
| |
| |
| // 26.2.7 - complex value operations |
| |
| // 26.2.7, p1 |
| template<class _TypeT> |
| inline _TypeT real (const complex<_TypeT> &__a) |
| { |
| return __a.real (); |
| } |
| |
| |
| // 26.2.7, p2 |
| template<class _TypeT> |
| inline _TypeT imag (const complex<_TypeT> &__a) |
| { |
| return __a.imag (); |
| } |
| |
| |
| // 26.2.7, p3 |
| template <class _TypeT> |
| inline _TypeT abs (const complex<_TypeT> &__a) |
| { |
| return _RWSTD_C::sqrt (norm (__a)); |
| } |
| |
| |
| // 26.2.7, p4 |
| template <class _TypeT> |
| inline _TypeT arg (const complex<_TypeT>& __a) |
| { |
| // guarantee that arg (complex<T>()) == 0 |
| return __a == complex<_TypeT>() ? _TypeT () |
| : _RWSTD_C::atan2 (__a.imag (), __a.real ()); |
| } |
| |
| |
| // 26.2.7, p5 |
| template <class _TypeT> |
| inline _TypeT norm (const complex<_TypeT> &__a) |
| { |
| return __a.real () * __a.real () + __a.imag () * __a.imag (); |
| } |
| |
| |
| // 26.2.7, p6 |
| template <class _TypeT> |
| inline complex<_TypeT> conj (const complex<_TypeT> &__a) |
| { |
| return complex<_TypeT>(__a.real (), -__a.imag ()); |
| } |
| |
| |
| // 26.2.7, p7, lwg issue 79 |
| template <class _TypeT> |
| inline complex<_TypeT> polar (const _TypeT &__rho, |
| const _TypeT &__theta = _TypeT ()) |
| { |
| return complex<_TypeT>(__rho * _RWSTD_C::cos (__theta), |
| __rho * _RWSTD_C::sin (__theta)); |
| } |
| |
| |
| // 26.2.8 - complex transcendentals |
| |
| |
| // complex cosine of complex number `a' |
| // cos (a) = cos u * cosh v - i * sin u * sinh v |
| template <class _TypeT> |
| inline complex<_TypeT> cos (const complex<_TypeT>& __a) |
| { |
| return complex<_TypeT>( _RWSTD_C::cos (__a.real ()) |
| * _RWSTD_C::cosh (__a.imag ()), |
| -_RWSTD_C::sin (__a.real ()) |
| * _RWSTD_C::sinh (__a.imag ())); |
| } |
| |
| |
| // complex hyperbolic cosine of complex number `a' |
| // cosh (a) = cosh u * cosv + i * sinh u * sin v |
| template <class _TypeT> |
| inline complex<_TypeT> cosh (const complex<_TypeT>& __a) |
| { |
| return complex<_TypeT>( _RWSTD_C::cosh (__a.real ()) |
| * _RWSTD_C::cos (__a.imag ()), |
| _RWSTD_C::sinh (__a.real ()) |
| * _RWSTD_C::sin (__a.imag ())); |
| } |
| |
| |
| // complex exponential of complex number `a' |
| // exp (a) = exp(u) * (cos v + i * sin v) |
| template <class _TypeT> |
| inline complex<_TypeT> exp (const complex<_TypeT>& __a) |
| { |
| _TypeT __e = _RWSTD_C::exp (__a.real ()); |
| return complex<_TypeT>(__e * _RWSTD_C::cos (__a.imag ()), |
| __e * _RWSTD_C::sin (__a.imag ())); |
| } |
| |
| |
| |
| // complex<T> natural log of complex<T> number `a' |
| // log (a) = log(r) + i * theta |
| template <class _TypeT> |
| inline complex<_TypeT> log (const complex<_TypeT>& __a) |
| { |
| return complex<_TypeT>(_RWSTD_C::log (abs (__a)), arg (__a)); |
| } |
| |
| |
| template <class _TypeT> |
| complex<_TypeT> log10 (const complex<_TypeT>&); |
| |
| // |
| // For all the power functions: |
| // |
| // 0**0 == 1 |
| // 0**x == 0 for x != 0 |
| // |
| |
| |
| // complex number `a' raised to an integer power `n' |
| // a**n = r**n * (cos(n theta) + i sin (n theta)) |
| _EXPORT |
| template <class _TypeT> |
| complex<_TypeT> |
| pow (const complex<_TypeT>&, int); |
| |
| |
| // complex number `a' raised to a real power `s' |
| // a**s = exp(s * log(a)) |
| _EXPORT |
| template <class _TypeT> |
| complex<_TypeT> |
| pow (const complex<_TypeT>&, const _TypeT&); |
| |
| |
| // real number `s' raised to a complex power `a' |
| // s**a = exp(a * log (s)) |
| _EXPORT |
| template <class _TypeT> |
| complex<_TypeT> |
| pow (const _TypeT&, const complex<_TypeT>&); |
| |
| |
| // complex<T> number `a1' raised to `a' complex<T> power `a2' |
| // a1**a2 = rho * (cos(phi) + i sin(phi)) |
| // rho = r1 ** u2 * exp (-v2 * theta1) |
| // phi = v2 * log(r1) + u2 * theta1 |
| _EXPORT |
| template <class _TypeT> |
| complex<_TypeT> |
| pow (const complex<_TypeT>&, const complex<_TypeT>&); |
| |
| |
| // complex<T> sine of complex<T> number `a' |
| // sin (a) = sin u * cosh v + i * cos u * sinh v |
| template <class _TypeT> |
| inline complex<_TypeT> sin (const complex<_TypeT>& __a) |
| { |
| return complex<_TypeT>( _RWSTD_C::sin (__a.real ()) |
| * _RWSTD_C::cosh (__a.imag ()), |
| _RWSTD_C::cos (__a.real ()) |
| * _RWSTD_C::sinh (__a.imag ())); |
| } |
| |
| |
| // complex<T> hyperbolic sine of complex<T> number `a' |
| // sinh (a) = sinh u cos v + i cosh u sin v |
| template <class _TypeT> |
| inline complex<_TypeT> sinh (const complex<_TypeT>& __a) |
| { |
| return complex<_TypeT>( _RWSTD_C::sinh (__a.real ()) |
| * _RWSTD_C::cos (__a.imag ()), |
| _RWSTD_C::cosh (__a.real ()) |
| * _RWSTD_C::sin (__a.imag ())); |
| } |
| |
| |
| // complex<T> square root of complex<T> number `a' |
| // sqrt(a) = sqrt(r) * ( cos (theta/2) + i sin (theta/2)) |
| template <class _TypeT> |
| inline complex<_TypeT> sqrt (const complex<_TypeT>& __a) |
| { |
| _TypeT __r = _RWSTD_C::sqrt(abs(__a)); |
| _TypeT __th = arg (__a) / _TypeT (2.0); |
| return complex<_TypeT>(__r * _RWSTD_C::cos (__th), |
| __r * _RWSTD_C::sin (__th)); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> tan (const complex<_TypeT>& __a) |
| { |
| return complex<_TypeT>(sin (__a) / cos (__a)); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> tanh (const complex<_TypeT>& __a) |
| { |
| return complex<_TypeT>(sinh (__a) / cosh (__a)); |
| } |
| |
| |
| template <class _TypeT> |
| inline complex<_TypeT> log10 (const complex<_TypeT>& __a) |
| { |
| const _TypeT __log10e = _TypeT (0.4342944819032518276511289189166051L); |
| return __log10e * log (__a); |
| } |
| |
| |
| // 26.2.6, p12: MT-safe extractor (not atomic) |
| _EXPORT |
| template <class _TypeT, class _CharT, class _Traits> |
| basic_istream<_CharT, _Traits >& |
| operator>> (basic_istream<_CharT, _Traits>&, complex<_TypeT>&); |
| |
| |
| // 26.2.6, p15: MT-safe atomic inserter |
| _EXPORT |
| template <class _TypeT, class _CharT, class _Traits> |
| basic_ostream<_CharT, _Traits>& |
| operator<< (basic_ostream<_CharT, _Traits>&, const complex<_TypeT>&); |
| |
| } // namespace std |
| |
| |
| #ifdef _RWSTD_MSVC |
| # pragma warning (pop) |
| #endif // _RWSTD_MSVC |
| |
| |
| #if _RWSTD_DEFINE_TEMPLATE (_COMPLEX) |
| # include <complex.cc> |
| #endif // _RWSTD_DEFINE_TEMPLATE (_BASIC_OSTREAM) |
| |
| |
| #endif // _RWSTD_COMPLEX_INCLUDED |
