A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://clang.llvm.org/doxygen/complex__cmath_8h_source.html below:

clang: lib/Headers/openmp_wrappers/complex_cmath.h Source File

15#error "This file is for OpenMP compilation only." 19#error "This file is for C++ compilation only." 22#ifndef _LIBCPP_COMPLEX 23#define _LIBCPP_COMPLEX 28#define __DEVICE__ static constexpr __attribute__((nothrow)) 45typename

enable_if<is_integral<_Tp>::value || is_same<_Tp, double>::value,

48 return atan2

(0., __re);

52typename

enable_if<is_same<_Tp, float>::value,

float

>::type

arg

(_Tp __re) {

59 if

(std::isinf(

__c

.real()))

61 if

(std::isinf(

__c

.imag()))

63 return __c

.real() *

__c

.real() +

__c

.imag() *

__c

.imag();

67#ifdef _GLIBCXX20_CONSTEXPR 68#define CXX20_CONSTEXPR_DEVICE __DEVICE__ 70#define CXX20_CONSTEXPR_DEVICE 74 return

std::complex<_Tp>(

__c

.real(), -

__c

.imag());

79template

<

class

_Tp> std::complex<_Tp>

proj

(

const

std::complex<_Tp> &

__c

) {

80

std::complex<_Tp> __r =

__c

;

81 if

(std::isinf(

__c

.real()) || std::isinf(

__c

.imag()))

89

complex<_Tp>

polar

(

const

_Tp &__rho,

const

_Tp &__theta = _Tp()) {

90 if

(std::isnan(__rho) ||

signbit

(__rho))

91 return

std::complex<_Tp>(_Tp(

NAN

), _Tp(

NAN

));

92 if

(std::isnan(__theta)) {

93 if

(std::isinf(__rho))

94 return

std::complex<_Tp>(__rho, __theta);

95 return

std::complex<_Tp>(__theta, __theta);

97 if

(std::isinf(__theta)) {

98 if

(std::isinf(__rho))

99 return

std::complex<_Tp>(__rho, _Tp(

NAN

));

100 return

std::complex<_Tp>(_Tp(

NAN

), _Tp(

NAN

));

102

_Tp __x = __rho *

cos

(__theta);

105

_Tp

__y

= __rho *

sin

(__theta);

106 if

(std::isnan(

__y

))

108 return

std::complex<_Tp>(__x,

__y

);

113template

<

class

_Tp> std::complex<_Tp>

log

(

const

std::complex<_Tp> &__x) {

114 return

std::complex<_Tp>(

log

(

abs

(__x)),

arg

(__x));

119template

<

class

_Tp> std::complex<_Tp>

log10

(

const

std::complex<_Tp> &__x) {

120 return log

(__x) /

log

(_Tp(10));

127 if

(std::isinf(__x.imag()))

128 return

std::complex<_Tp>(_Tp(

INFINITY

), __x.imag());

129 if

(std::isinf(__x.real())) {

130 if

(__x.real() > _Tp(0))

131 return

std::complex<_Tp>(__x.real(), std::isnan(__x.imag())

134 return

std::complex<_Tp>(std::isnan(__x.imag()) ? __x.imag() : _Tp(0),

144

_Tp __i = __x.imag();

145 if

(std::isinf(__x.real())) {

146 if

(__x.real() < _Tp(0)) {

147 if

(!std::isfinite(__i))

149

}

else if

(__i == 0 || !std::isfinite(__i)) {

152 return

std::complex<_Tp>(__x.real(), __i);

154

}

else if

(std::isnan(__x.real()) && __x.imag() == 0)

156

_Tp __e =

exp

(__x.real());

157 return

std::complex<_Tp>(__e *

cos

(__i), __e *

sin

(__i));

163

std::complex<_Tp>

pow

(

const

std::complex<_Tp> &__x,

164 const

std::complex<_Tp> &

__y

) {

170template

<

class

_Tp> std::complex<_Tp>

__sqr

(

const

std::complex<_Tp> &__x) {

171 return

std::complex<_Tp>((__x.real() - __x.imag()) *

172

(__x.real() + __x.imag()),

173

_Tp(2) * __x.real() * __x.imag());

180 const

_Tp __pi(

atan2

(+0., -0.));

181 if

(std::isinf(__x.real())) {

182 if

(std::isnan(__x.imag()))

184 if

(std::isinf(__x.imag()))

185 return

std::complex<_Tp>(__x.real(),

186 copysign

(__pi * _Tp(0.25), __x.imag()));

187 return

std::complex<_Tp>(__x.real(),

copysign

(_Tp(0), __x.imag()));

189 if

(std::isnan(__x.real())) {

190 if

(std::isinf(__x.imag()))

191 return

std::complex<_Tp>(__x.imag(), __x.real());

194 return

std::complex<_Tp>(__x.real(), __x.real());

196 if

(std::isinf(__x.imag()))

197 return

std::complex<_Tp>(

copysign

(__x.imag(), __x.real()),

198 copysign

(__pi / _Tp(2), __x.imag()));

199

std::complex<_Tp> __z =

log

(__x +

sqrt

(

__sqr

(__x) + _Tp(1)));

200 return

std::complex<_Tp>(

copysign

(__z.real(), __x.real()),

208 const

_Tp __pi(

atan2

(+0., -0.));

209 if

(std::isinf(__x.real())) {

210 if

(std::isnan(__x.imag()))

211 return

std::complex<_Tp>(

abs

(__x.real()), __x.imag());

212 if

(std::isinf(__x.imag())) {

214 return

std::complex<_Tp>(__x.real(),

215 copysign

(__pi * _Tp(0.25), __x.imag()));

217 return

std::complex<_Tp>(-__x.real(),

218 copysign

(__pi * _Tp(0.75), __x.imag()));

221 return

std::complex<_Tp>(-__x.real(),

copysign

(__pi, __x.imag()));

222 return

std::complex<_Tp>(__x.real(),

copysign

(_Tp(0), __x.imag()));

224 if

(std::isnan(__x.real())) {

225 if

(std::isinf(__x.imag()))

226 return

std::complex<_Tp>(

abs

(__x.imag()), __x.real());

227 return

std::complex<_Tp>(__x.real(), __x.real());

229 if

(std::isinf(__x.imag()))

230 return

std::complex<_Tp>(

abs

(__x.imag()),

231 copysign

(__pi / _Tp(2), __x.imag()));

232

std::complex<_Tp> __z =

log

(__x +

sqrt

(

__sqr

(__x) - _Tp(1)));

233 return

std::complex<_Tp>(

copysign

(__z.real(), _Tp(0)),

241 const

_Tp __pi(

atan2

(+0., -0.));

242 if

(std::isinf(__x.imag())) {

243 return

std::complex<_Tp>(

copysign

(_Tp(0), __x.real()),

244 copysign

(__pi / _Tp(2), __x.imag()));

246 if

(std::isnan(__x.imag())) {

247 if

(std::isinf(__x.real()) || __x.real() == 0)

248 return

std::complex<_Tp>(

copysign

(_Tp(0), __x.real()), __x.imag());

249 return

std::complex<_Tp>(__x.imag(), __x.imag());

251 if

(std::isnan(__x.real())) {

252 return

std::complex<_Tp>(__x.real(), __x.real());

254 if

(std::isinf(__x.real())) {

255 return

std::complex<_Tp>(

copysign

(_Tp(0), __x.real()),

256 copysign

(__pi / _Tp(2), __x.imag()));

258 if

(

abs

(__x.real()) == _Tp(1) && __x.imag() == _Tp(0)) {

262

std::complex<_Tp> __z =

log

((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);

263 return

std::complex<_Tp>(

copysign

(__z.real(), __x.real()),

271 if

(std::isinf(__x.real()) && !std::isfinite(__x.imag()))

272 return

std::complex<_Tp>(__x.real(), _Tp(

NAN

));

273 if

(__x.real() == 0 && !std::isfinite(__x.imag()))

274 return

std::complex<_Tp>(__x.real(), _Tp(

NAN

));

275 if

(__x.imag() == 0 && !std::isfinite(__x.real()))

277 return

std::complex<_Tp>(

sinh

(__x.real()) *

cos

(__x.imag()),

278 cosh

(__x.real()) *

sin

(__x.imag()));

285 if

(std::isinf(__x.real()) && !std::isfinite(__x.imag()))

286 return

std::complex<_Tp>(

abs

(__x.real()), _Tp(

NAN

));

287 if

(__x.real() == 0 && !std::isfinite(__x.imag()))

288 return

std::complex<_Tp>(_Tp(

NAN

), __x.real());

289 if

(__x.real() == 0 && __x.imag() == 0)

290 return

std::complex<_Tp>(_Tp(1), __x.imag());

291 if

(__x.imag() == 0 && !std::isfinite(__x.real()))

292 return

std::complex<_Tp>(

abs

(__x.real()), __x.imag());

293 return

std::complex<_Tp>(

cosh

(__x.real()) *

cos

(__x.imag()),

294 sinh

(__x.real()) *

sin

(__x.imag()));

301 if

(std::isinf(__x.real())) {

302 if

(!std::isfinite(__x.imag()))

303 return

std::complex<_Tp>(_Tp(1), _Tp(0));

304 return

std::complex<_Tp>(_Tp(1),

307 if

(std::isnan(__x.real()) && __x.imag() == 0)

309

_Tp __2r(_Tp(2) * __x.real());

310

_Tp __2i(_Tp(2) * __x.imag());

311

_Tp __d(

cosh

(__2r) +

cos

(__2i));

312

_Tp __2rsh(

sinh

(__2r));

313 if

(std::isinf(__2rsh) && std::isinf(__d))

314 return

std::complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),

315

__2i > _Tp(0) ? _Tp(0) : _Tp(-0.));

316 return

std::complex<_Tp>(__2rsh / __d,

sin

(__2i) / __d);

323

std::complex<_Tp> __z =

asinh

(complex<_Tp>(-__x.imag(), __x.real()));

324 return

std::complex<_Tp>(__z.imag(), -__z.real());

331 const

_Tp __pi(

atan2

(+0., -0.));

332 if

(std::isinf(__x.real())) {

333 if

(std::isnan(__x.imag()))

334 return

std::complex<_Tp>(__x.imag(), __x.real());

335 if

(std::isinf(__x.imag())) {

336 if

(__x.real() < _Tp(0))

337 return

std::complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());

338 return

std::complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());

340 if

(__x.real() < _Tp(0))

341 return

std::complex<_Tp>(__pi,

342 signbit

(__x.imag()) ? -__x.real() : __x.real());

343 return

std::complex<_Tp>(_Tp(0),

344 signbit

(__x.imag()) ? __x.real() : -__x.real());

346 if

(std::isnan(__x.real())) {

347 if

(std::isinf(__x.imag()))

348 return

std::complex<_Tp>(__x.real(), -__x.imag());

349 return

std::complex<_Tp>(__x.real(), __x.real());

351 if

(std::isinf(__x.imag()))

352 return

std::complex<_Tp>(__pi / _Tp(2), -__x.imag());

353 if

(__x.real() == 0 && (__x.imag() == 0 ||

isnan

(__x.imag())))

354 return

std::complex<_Tp>(__pi / _Tp(2), -__x.imag());

355

std::complex<_Tp> __z =

log

(__x +

sqrt

(

__sqr

(__x) - _Tp(1)));

357 return

std::complex<_Tp>(

abs

(__z.imag()),

abs

(__z.real()));

358 return

std::complex<_Tp>(

abs

(__z.imag()), -

abs

(__z.real()));

365

std::complex<_Tp> __z =

atanh

(complex<_Tp>(-__x.imag(), __x.real()));

366 return

std::complex<_Tp>(__z.imag(), -__z.real());

373

std::complex<_Tp> __z =

sinh

(complex<_Tp>(-__x.imag(), __x.real()));

374 return

std::complex<_Tp>(__z.imag(), -__z.real());

379template

<

class

_Tp> std::complex<_Tp>

cos

(

const

std::complex<_Tp> &__x) {

380 return cosh

(complex<_Tp>(-__x.imag(), __x.real()));

387

std::complex<_Tp> __z =

tanh

(complex<_Tp>(-__x.imag(), __x.real()));

388 return

std::complex<_Tp>(__z.imag(), -__z.real());

__DEVICE__ bool isnan(float __x)

Test for a NaN.

__DEVICE__ bool signbit(float __x)

Test for sign bit.

__DEVICE__ float atan2f(float __a, float __b)

static __inline__ vector float vector float vector float __c

static __inline__ uint32_t uint32_t __y

#define CXX20_CONSTEXPR_DEVICE

__DEVICE__ _Tp norm(const std::complex< _Tp > &__c)

__DEVICE__ _Tp abs(const std::complex< _Tp > &__c)

std::complex< _Tp > __sqr(const std::complex< _Tp > &__x)

complex< _Tp > polar(const _Tp &__rho, const _Tp &__theta=_Tp())

__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)

std::complex< _Tp > proj(const std::complex< _Tp > &__c)

#define copysign(__x, __y)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4