ReactOS  r76032
complex_trig.cpp
Go to the documentation of this file.
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 #include "stlport_prefix.h"
19 
20 
21 // Trigonometric and hyperbolic functions for complex<float>,
22 // complex<double>, and complex<long double>
23 #include <complex>
24 #include <cfloat>
25 #include <cmath>
26 
28 
29 
30 //----------------------------------------------------------------------
31 // helpers
32 #if defined (__sgi)
33  static const union { unsigned int i; float f; } float_ulimit = { 0x42b2d4fc };
34  static const float float_limit = float_ulimit.f;
35  static union {
36  struct { unsigned int h; unsigned int l; } w;
37  double d;
38  } double_ulimit = { 0x408633ce, 0x8fb9f87d };
39  static const double double_limit = double_ulimit.d;
40  static union {
41  struct { unsigned int h[2]; unsigned int l[2]; } w;
42  long double ld;
43  } ldouble_ulimit = {0x408633ce, 0x8fb9f87e, 0xbd23b659, 0x4e9bd8b1};
44 # if !defined (_STLP_NO_LONG_DOUBLE)
45  static const long double ldouble_limit = ldouble_ulimit.ld;
46 # endif
47 #else
48 # if defined (M_LN2) && defined (FLT_MAX_EXP)
49  static const float float_limit = float(M_LN2 * FLT_MAX_EXP);
50  static const double double_limit = M_LN2 * DBL_MAX_EXP;
51 # else
52  static const float float_limit = ::log(FLT_MAX);
53  static const double double_limit = ::log(DBL_MAX);
54 # endif
55 # if !defined (_STLP_NO_LONG_DOUBLE)
56 # if defined (M_LN2l)
57  static const long double ldouble_limit = M_LN2l * LDBL_MAX_EXP;
58 # else
59  static const long double ldouble_limit = ::log(LDBL_MAX);
60 # endif
61 # endif
62 #endif
63 
64 
65 //----------------------------------------------------------------------
66 // sin
67 template <class _Tp>
68 static complex<_Tp> sinT(const complex<_Tp>& z) {
69  return complex<_Tp>(::sin(z._M_re) * ::cosh(z._M_im),
70  ::cos(z._M_re) * ::sinh(z._M_im));
71 }
72 
74 { return sinT(z); }
75 
77 { return sinT(z); }
78 
79 #if !defined (_STLP_NO_LONG_DOUBLE)
81 { return sinT(z); }
82 #endif
83 
84 //----------------------------------------------------------------------
85 // cos
86 template <class _Tp>
87 static complex<_Tp> cosT(const complex<_Tp>& z) {
88  return complex<_Tp>(::cos(z._M_re) * ::cosh(z._M_im),
89  -::sin(z._M_re) * ::sinh(z._M_im));
90 }
91 
93 { return cosT(z); }
94 
96 { return cosT(z); }
97 
98 #if !defined (_STLP_NO_LONG_DOUBLE)
100 { return cosT(z); }
101 #endif
102 
103 //----------------------------------------------------------------------
104 // tan
105 template <class _Tp>
106 static complex<_Tp> tanT(const complex<_Tp>& z, const _Tp& Tp_limit) {
107  _Tp re2 = 2.f * z._M_re;
108  _Tp im2 = 2.f * z._M_im;
109 
110  if (::abs(im2) > Tp_limit)
111  return complex<_Tp>(0.f, (im2 > 0 ? 1.f : -1.f));
112  else {
113  _Tp den = ::cos(re2) + ::cosh(im2);
114  return complex<_Tp>(::sin(re2) / den, ::sinh(im2) / den);
115  }
116 }
117 
119 { return tanT(z, float_limit); }
120 
122 { return tanT(z, double_limit); }
123 
124 #if !defined (_STLP_NO_LONG_DOUBLE)
126 { return tanT(z, ldouble_limit); }
127 #endif
128 
129 //----------------------------------------------------------------------
130 // sinh
131 template <class _Tp>
133  return complex<_Tp>(::sinh(z._M_re) * ::cos(z._M_im),
134  ::cosh(z._M_re) * ::sin(z._M_im));
135 }
136 
138 { return sinhT(z); }
139 
141 { return sinhT(z); }
142 
143 #if !defined (_STLP_NO_LONG_DOUBLE)
145 { return sinhT(z); }
146 #endif
147 
148 //----------------------------------------------------------------------
149 // cosh
150 template <class _Tp>
152  return complex<_Tp>(::cosh(z._M_re) * ::cos(z._M_im),
153  ::sinh(z._M_re) * ::sin(z._M_im));
154 }
155 
157 { return coshT(z); }
158 
160 { return coshT(z); }
161 
162 #if !defined (_STLP_NO_LONG_DOUBLE)
164 { return coshT(z); }
165 #endif
166 
167 //----------------------------------------------------------------------
168 // tanh
169 template <class _Tp>
170 static complex<_Tp> tanhT(const complex<_Tp>& z, const _Tp& Tp_limit) {
171  _Tp re2 = 2.f * z._M_re;
172  _Tp im2 = 2.f * z._M_im;
173  if (::abs(re2) > Tp_limit)
174  return complex<_Tp>((re2 > 0 ? 1.f : -1.f), 0.f);
175  else {
176  _Tp den = ::cosh(re2) + ::cos(im2);
177  return complex<_Tp>(::sinh(re2) / den, ::sin(im2) / den);
178  }
179 }
180 
182 { return tanhT(z, float_limit); }
183 
185 { return tanhT(z, double_limit); }
186 
187 #if !defined (_STLP_NO_LONG_DOUBLE)
189 { return tanhT(z, ldouble_limit); }
190 #endif
191 
#define abs(i)
Definition: fconv.c:206
static complex< _Tp > cosT(const complex< _Tp > &z)
#define LDBL_MAX_EXP
Definition: gcc_float.h:86
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
#define DBL_MAX_EXP
Definition: gcc_float.h:85
_STLP_DECLSPEC complex< float > _STLP_CALL tanh(const complex< float > &z)
_STLP_DECLSPEC complex< float > _STLP_CALL sinh(const complex< float > &z)
#define FLT_MAX
Definition: gcc_float.h:107
#define FLT_MAX_EXP
Definition: compiler.h:364
static complex< _Tp > sinhT(const complex< _Tp > &z)
#define DBL_MAX
Definition: gcc_float.h:108
_STLP_DECLSPEC complex< float > _STLP_CALL cosh(const complex< float > &z)
_STLP_DECLSPEC complex< float > _STLP_CALL cos(const complex< float > &z)
value_type _M_re
Definition: _complex.h:170
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
static const long double ldouble_limit
GLenum GLclampf GLint i
Definition: glfuncs.h:14
static complex< _Tp > tanhT(const complex< _Tp > &z, const _Tp &Tp_limit)
GLdouble GLdouble z
Definition: glext.h:5874
_STLP_DECLSPEC complex< float > _STLP_CALL sin(const complex< float > &z)
r l[0]
Definition: byte_order.h:167
GLfloat f
Definition: glext.h:7540
#define d
Definition: ke_i.h:81
_STLP_DECLSPEC complex< float > _STLP_CALL tan(const complex< float > &z)
#define LDBL_MAX
Definition: gcc_float.h:109
static const double double_limit
#define _STLP_DECLSPEC
Definition: features.h:982
static complex< _Tp > sinT(const complex< _Tp > &z)
static complex< _Tp > tanT(const complex< _Tp > &z, const _Tp &Tp_limit)
static _STLP_BEGIN_NAMESPACE const float float_limit
value_type _M_im
Definition: _complex.h:171
#define f
Definition: ke_i.h:83
#define _STLP_END_NAMESPACE
Definition: features.h:503
static complex< _Tp > coshT(const complex< _Tp > &z)
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
#define _STLP_CALL
Definition: _bc.h:131
#define log(outFile, fmt,...)
Definition: util.h:15