home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / stlpt453.zip / STLport-4.5.3 / src / complex_exp.cpp < prev    next >
C/C++ Source or Header  |  2001-02-07  |  7KB  |  236 lines
  1. /*
  2.  * Copyright (c) 1999
  3.  * Silicon Graphics Computer Systems, Inc.
  4.  *
  5.  * Copyright (c) 1999 
  6.  * Boris Fomitchev
  7.  *
  8.  * This material is provided "as is", with absolutely no warranty expressed
  9.  * or implied. Any use is at your own risk.
  10.  *
  11.  * Permission to use or copy this software for any purpose is hereby granted 
  12.  * without fee, provided the above notices are retained on all copies.
  13.  * Permission to modify the code and to distribute modified code is granted,
  14.  * provided the above notices are retained, and a notice that the code was
  15.  * modified is included with the above copyright notice.
  16.  *
  17.  */ 
  18.  
  19. # include "stlport_prefix.h"
  20. // exp, log, pow for complex<float>, complex<double>, and complex<long double>
  21.  
  22. #include <numeric>
  23. #include "complex_impl.h"
  24.  
  25. _STLP_BEGIN_NAMESPACE
  26.  
  27. //----------------------------------------------------------------------
  28. // exp
  29.  
  30. _STLP_DECLSPEC complex<float>  _STLP_CALL
  31. exp(const complex<float>& z)
  32. {
  33.   float expx = _STLP_EXPF(z._M_re);
  34.   return complex<float>(expx * _STLP_COSF(z._M_im),
  35.                         expx * _STLP_SINF(z._M_im));
  36. }
  37.  
  38. _STLP_DECLSPEC complex<double> _STLP_CALL exp(const complex<double>& z)
  39. {
  40.   double expx = _STLP_EXP(z._M_re);
  41.   return complex<double>(expx * _STLP_COS(z._M_im),
  42.                          expx * _STLP_SIN(z._M_im));
  43. }
  44.  
  45. _STLP_DECLSPEC complex<long double> _STLP_CALL exp(const complex<long double>& z)
  46. {
  47.   long double expx = _STLP_EXPL(z._M_re);
  48.   return complex<long double>(expx * _STLP_COSL(z._M_im),
  49.                               expx * _STLP_SINL(z._M_im));
  50. }
  51.  
  52. //----------------------------------------------------------------------
  53. // log10
  54.  
  55. _STLP_DECLSPEC complex<float> _STLP_CALL log10(const complex<float>& z)
  56. {
  57.   complex<float> r;
  58.   static float ln10_inv = 1.f / _STLP_LOGF(10.f);
  59.  
  60.   r._M_im = _STLP_ATAN2F(z._M_im, z._M_re) * ln10_inv;
  61.   r._M_re = _STLP_LOG10F(_STLP_HYPOTF(z._M_re, z._M_im));
  62.   return r;
  63. }
  64.  
  65. _STLP_DECLSPEC complex<double> _STLP_CALL log10(const complex<double>& z)
  66. {
  67.   complex<double> r;
  68.   static double ln10_inv = 1. / _STLP_LOG(10.);
  69.  
  70.   r._M_im = _STLP_ATAN2(z._M_im, z._M_re) * ln10_inv;
  71.   r._M_re = _STLP_LOG10(_STLP_HYPOT(z._M_re, z._M_im));
  72.   return r;
  73. }
  74.  
  75. _STLP_DECLSPEC complex<long double> _STLP_CALL log10(const complex<long double>& z)
  76. {
  77.   complex<long double> result;
  78.   static long double ln10_inv = 1.l / _STLP_LOGL(10.l);
  79.  
  80.   result._M_im = _STLP_ATAN2L(z._M_im, z._M_re) * ln10_inv;
  81.   result._M_re = _STLP_LOG10L(_STLP_HYPOTL(z._M_re, z._M_im));
  82.   return result;
  83. }
  84.  
  85.  
  86. //----------------------------------------------------------------------
  87. // log
  88.  
  89. _STLP_DECLSPEC complex<float> _STLP_CALL log(const complex<float>& z)
  90. {
  91.   complex<float> r;
  92.  
  93.   r._M_im = _STLP_ATAN2F(z._M_im, z._M_re);
  94.   r._M_re = _STLP_LOGF(_STLP_HYPOTF(z._M_re, z._M_im));
  95.   return r;
  96. }
  97.  
  98. _STLP_DECLSPEC complex<double> _STLP_CALL log(const complex<double>& z)
  99. {
  100.   complex<double> r;
  101.  
  102.   r._M_im = _STLP_ATAN2(z._M_im, z._M_re);
  103.   r._M_re = _STLP_LOG(_STLP_HYPOT(z._M_re, z._M_im));
  104.   return r;
  105. }
  106.  
  107. _STLP_DECLSPEC complex<long double> _STLP_CALL log(const complex<long double>& z)
  108. {
  109.   complex<long double> result;
  110.  
  111.   result._M_im = _STLP_ATAN2L(z._M_im, z._M_re);
  112.   result._M_re = _STLP_LOGL(_STLP_HYPOTL(z._M_re, z._M_im));
  113.   return result;
  114. }
  115.  
  116.  
  117. //----------------------------------------------------------------------
  118. // pow
  119.  
  120. _STLP_DECLSPEC complex<float> _STLP_CALL pow(const float& a, const complex<float>& b) {
  121.   float logr = _STLP_LOGF(a);
  122.   float x = _STLP_EXPF(logr*b._M_re);
  123.   float y = logr*b._M_im;
  124.  
  125.   return complex<float>(x * _STLP_COSF(y), x * _STLP_SINF(y));
  126. }
  127.  
  128. _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>& z_in, int n) {
  129.   complex<float> z = z_in;
  130.   z = __power(z, (n < 0 ? -n : n), multiplies< complex<float> >());
  131.   if (n < 0)
  132.     return 1.f / z;
  133.   else
  134.     return z;
  135. }
  136.  
  137. _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>& a, const float& b) {
  138.   float logr = _STLP_LOGF(_STLP_HYPOTF(a._M_re,a._M_im));
  139.   float logi = _STLP_ATAN2F(a._M_im, a._M_re);
  140.   float x = _STLP_EXPF(logr * b);
  141.   float y = logi * b;
  142.  
  143.   return complex<float>(x * _STLP_COSF(y), x * _STLP_SINF(y));
  144. }  
  145.  
  146. _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>& a, const complex<float>& b) {
  147.   float logr = _STLP_LOGF(_STLP_HYPOTF(a._M_re,a._M_im));
  148.   float logi = _STLP_ATAN2F(a._M_im, a._M_re);
  149.   float x = _STLP_EXPF(logr*b._M_re - logi*b._M_im);
  150.   float y = logr*b._M_im + logi*b._M_re;
  151.  
  152.   return complex<float>(x * _STLP_COSF(y), x * _STLP_SINF(y));
  153. }
  154.  
  155.  
  156. _STLP_DECLSPEC complex<double> _STLP_CALL pow(const double& a, const complex<double>& b) {
  157.   double logr = _STLP_LOG(a);
  158.   double x = _STLP_EXP(logr*b._M_re);
  159.   double y = logr*b._M_im;
  160.  
  161.   return complex<double>(x * _STLP_COS(y), x * _STLP_SIN(y));
  162. }
  163.  
  164. _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>& z_in, int n) {
  165.   complex<double> z = z_in;
  166.   z = __power(z, (n < 0 ? -n : n), multiplies< complex<double> >());
  167.   if (n < 0)
  168. #if !defined(__SC__)            //*TY 04/15/2000 - 
  169.     return 1. / z;
  170. #else                            //*TY 04/15/2000 - added workaround for SCpp compiler
  171.     return double(1.0) / z;        //*TY 04/15/2000 - it incorrectly assign long double attribute to floating point literals
  172. #endif                            //*TY 04/15/2000 - 
  173.   else
  174.     return z;
  175. }
  176.  
  177. _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>& a, const double& b) {
  178.   double logr = _STLP_LOG(_STLP_HYPOT(a._M_re,a._M_im));
  179.   double logi = _STLP_ATAN2(a._M_im, a._M_re);
  180.   double x = _STLP_EXP(logr * b);
  181.   double y = logi * b;
  182.  
  183.   return complex<double>(x * _STLP_COS(y), x * _STLP_SIN(y));
  184. }  
  185.  
  186. _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>& a, const complex<double>& b) {
  187.   double logr = _STLP_LOG(_STLP_HYPOT(a._M_re,a._M_im));
  188.   double logi = _STLP_ATAN2(a._M_im, a._M_re);
  189.   double x = _STLP_EXP(logr*b._M_re - logi*b._M_im);
  190.   double y = logr*b._M_im + logi*b._M_re;
  191.  
  192.   return complex<double>(x * _STLP_COS(y), x * _STLP_SIN(y));
  193. }
  194.  
  195.  
  196. _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const long double& a,
  197.                                                    const complex<long double>& b) {
  198.   long double logr = _STLP_LOGL(a);
  199.   long double x = _STLP_EXPL(logr*b._M_re);
  200.   long double y = logr*b._M_im;
  201.  
  202.   return complex<long double>(x * _STLP_COSL(y), x * _STLP_SINL(y));
  203. }
  204.  
  205. _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>& z_in, int n) {
  206.   complex<long double> z = z_in;
  207.   z = __power(z, (n < 0 ? -n : n), multiplies< complex<long double> >());
  208.   if (n < 0)
  209.     return 1.l / z;
  210.   else
  211.     return z;
  212. }
  213.  
  214. _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>& a,
  215.                          const long double& b) {
  216.   long double logr = _STLP_LOGL(_STLP_HYPOTL(a._M_re,a._M_im));
  217.   long double logi = _STLP_ATAN2L(a._M_im, a._M_re);
  218.   long double x = _STLP_EXPL(logr * b);
  219.   long double y = logi * b;
  220.  
  221.   return complex<long double>(x * _STLP_COSL(y), x * _STLP_SINL(y));
  222. }  
  223.  
  224. _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>& a,
  225.                          const complex<long double>& b) {
  226.   long double logr = _STLP_LOGL(_STLP_HYPOTL(a._M_re,a._M_im));
  227.   long double logi = _STLP_ATAN2L(a._M_im, a._M_re);
  228.   long double x = _STLP_EXPL(logr*b._M_re - logi*b._M_im);
  229.   long double y = logr*b._M_im + logi*b._M_re;
  230.  
  231.   return complex<long double>(x * _STLP_COSL(y), x * _STLP_SINL(y));
  232. }
  233.  
  234. _STLP_END_NAMESPACE
  235.  
  236.