ArrayCwiseUnaryOps.h (21431B)
1 2 3 typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType; 4 typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType; 5 typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType; 6 typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType; 7 typedef CwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived> RsqrtReturnType; 8 typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> SignReturnType; 9 typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> InverseReturnType; 10 typedef CwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived> BooleanNotReturnType; 11 12 typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> ExpReturnType; 13 typedef CwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived> Expm1ReturnType; 14 typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> LogReturnType; 15 typedef CwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived> Log1pReturnType; 16 typedef CwiseUnaryOp<internal::scalar_log10_op<Scalar>, const Derived> Log10ReturnType; 17 typedef CwiseUnaryOp<internal::scalar_log2_op<Scalar>, const Derived> Log2ReturnType; 18 typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> CosReturnType; 19 typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> SinReturnType; 20 typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const Derived> TanReturnType; 21 typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> AcosReturnType; 22 typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> AsinReturnType; 23 typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const Derived> AtanReturnType; 24 typedef CwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived> TanhReturnType; 25 typedef CwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const Derived> LogisticReturnType; 26 typedef CwiseUnaryOp<internal::scalar_sinh_op<Scalar>, const Derived> SinhReturnType; 27 #if EIGEN_HAS_CXX11_MATH 28 typedef CwiseUnaryOp<internal::scalar_atanh_op<Scalar>, const Derived> AtanhReturnType; 29 typedef CwiseUnaryOp<internal::scalar_asinh_op<Scalar>, const Derived> AsinhReturnType; 30 typedef CwiseUnaryOp<internal::scalar_acosh_op<Scalar>, const Derived> AcoshReturnType; 31 #endif 32 typedef CwiseUnaryOp<internal::scalar_cosh_op<Scalar>, const Derived> CoshReturnType; 33 typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> SquareReturnType; 34 typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> CubeReturnType; 35 typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived> RoundReturnType; 36 typedef CwiseUnaryOp<internal::scalar_rint_op<Scalar>, const Derived> RintReturnType; 37 typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived> FloorReturnType; 38 typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived> CeilReturnType; 39 typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType; 40 typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType; 41 typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType; 42 43 /** \returns an expression of the coefficient-wise absolute value of \c *this 44 * 45 * Example: \include Cwise_abs.cpp 46 * Output: \verbinclude Cwise_abs.out 47 * 48 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs">Math functions</a>, abs2() 49 */ 50 EIGEN_DEVICE_FUNC 51 EIGEN_STRONG_INLINE const AbsReturnType 52 abs() const 53 { 54 return AbsReturnType(derived()); 55 } 56 57 /** \returns an expression of the coefficient-wise phase angle of \c *this 58 * 59 * Example: \include Cwise_arg.cpp 60 * Output: \verbinclude Cwise_arg.out 61 * 62 * \sa abs() 63 */ 64 EIGEN_DEVICE_FUNC 65 EIGEN_STRONG_INLINE const ArgReturnType 66 arg() const 67 { 68 return ArgReturnType(derived()); 69 } 70 71 /** \returns an expression of the coefficient-wise squared absolute value of \c *this 72 * 73 * Example: \include Cwise_abs2.cpp 74 * Output: \verbinclude Cwise_abs2.out 75 * 76 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs2">Math functions</a>, abs(), square() 77 */ 78 EIGEN_DEVICE_FUNC 79 EIGEN_STRONG_INLINE const Abs2ReturnType 80 abs2() const 81 { 82 return Abs2ReturnType(derived()); 83 } 84 85 /** \returns an expression of the coefficient-wise exponential of *this. 86 * 87 * This function computes the coefficient-wise exponential. The function MatrixBase::exp() in the 88 * unsupported module MatrixFunctions computes the matrix exponential. 89 * 90 * Example: \include Cwise_exp.cpp 91 * Output: \verbinclude Cwise_exp.out 92 * 93 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_exp">Math functions</a>, pow(), log(), sin(), cos() 94 */ 95 EIGEN_DEVICE_FUNC 96 inline const ExpReturnType 97 exp() const 98 { 99 return ExpReturnType(derived()); 100 } 101 102 /** \returns an expression of the coefficient-wise exponential of *this minus 1. 103 * 104 * In exact arithmetic, \c x.expm1() is equivalent to \c x.exp() - 1, 105 * however, with finite precision, this function is much more accurate when \c x is close to zero. 106 * 107 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_expm1">Math functions</a>, exp() 108 */ 109 EIGEN_DEVICE_FUNC 110 inline const Expm1ReturnType 111 expm1() const 112 { 113 return Expm1ReturnType(derived()); 114 } 115 116 /** \returns an expression of the coefficient-wise logarithm of *this. 117 * 118 * This function computes the coefficient-wise logarithm. The function MatrixBase::log() in the 119 * unsupported module MatrixFunctions computes the matrix logarithm. 120 * 121 * Example: \include Cwise_log.cpp 122 * Output: \verbinclude Cwise_log.out 123 * 124 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log">Math functions</a>, log() 125 */ 126 EIGEN_DEVICE_FUNC 127 inline const LogReturnType 128 log() const 129 { 130 return LogReturnType(derived()); 131 } 132 133 /** \returns an expression of the coefficient-wise logarithm of 1 plus \c *this. 134 * 135 * In exact arithmetic, \c x.log() is equivalent to \c (x+1).log(), 136 * however, with finite precision, this function is much more accurate when \c x is close to zero. 137 * 138 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log1p">Math functions</a>, log() 139 */ 140 EIGEN_DEVICE_FUNC 141 inline const Log1pReturnType 142 log1p() const 143 { 144 return Log1pReturnType(derived()); 145 } 146 147 /** \returns an expression of the coefficient-wise base-10 logarithm of *this. 148 * 149 * This function computes the coefficient-wise base-10 logarithm. 150 * 151 * Example: \include Cwise_log10.cpp 152 * Output: \verbinclude Cwise_log10.out 153 * 154 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log10">Math functions</a>, log() 155 */ 156 EIGEN_DEVICE_FUNC 157 inline const Log10ReturnType 158 log10() const 159 { 160 return Log10ReturnType(derived()); 161 } 162 163 /** \returns an expression of the coefficient-wise base-2 logarithm of *this. 164 * 165 * This function computes the coefficient-wise base-2 logarithm. 166 * 167 */ 168 EIGEN_DEVICE_FUNC 169 inline const Log2ReturnType 170 log2() const 171 { 172 return Log2ReturnType(derived()); 173 } 174 175 /** \returns an expression of the coefficient-wise square root of *this. 176 * 177 * This function computes the coefficient-wise square root. The function MatrixBase::sqrt() in the 178 * unsupported module MatrixFunctions computes the matrix square root. 179 * 180 * Example: \include Cwise_sqrt.cpp 181 * Output: \verbinclude Cwise_sqrt.out 182 * 183 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sqrt">Math functions</a>, pow(), square() 184 */ 185 EIGEN_DEVICE_FUNC 186 inline const SqrtReturnType 187 sqrt() const 188 { 189 return SqrtReturnType(derived()); 190 } 191 192 /** \returns an expression of the coefficient-wise inverse square root of *this. 193 * 194 * This function computes the coefficient-wise inverse square root. 195 * 196 * Example: \include Cwise_sqrt.cpp 197 * Output: \verbinclude Cwise_sqrt.out 198 * 199 * \sa pow(), square() 200 */ 201 EIGEN_DEVICE_FUNC 202 inline const RsqrtReturnType 203 rsqrt() const 204 { 205 return RsqrtReturnType(derived()); 206 } 207 208 /** \returns an expression of the coefficient-wise signum of *this. 209 * 210 * This function computes the coefficient-wise signum. 211 * 212 * Example: \include Cwise_sign.cpp 213 * Output: \verbinclude Cwise_sign.out 214 * 215 * \sa pow(), square() 216 */ 217 EIGEN_DEVICE_FUNC 218 inline const SignReturnType 219 sign() const 220 { 221 return SignReturnType(derived()); 222 } 223 224 225 /** \returns an expression of the coefficient-wise cosine of *this. 226 * 227 * This function computes the coefficient-wise cosine. The function MatrixBase::cos() in the 228 * unsupported module MatrixFunctions computes the matrix cosine. 229 * 230 * Example: \include Cwise_cos.cpp 231 * Output: \verbinclude Cwise_cos.out 232 * 233 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cos">Math functions</a>, sin(), acos() 234 */ 235 EIGEN_DEVICE_FUNC 236 inline const CosReturnType 237 cos() const 238 { 239 return CosReturnType(derived()); 240 } 241 242 243 /** \returns an expression of the coefficient-wise sine of *this. 244 * 245 * This function computes the coefficient-wise sine. The function MatrixBase::sin() in the 246 * unsupported module MatrixFunctions computes the matrix sine. 247 * 248 * Example: \include Cwise_sin.cpp 249 * Output: \verbinclude Cwise_sin.out 250 * 251 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sin">Math functions</a>, cos(), asin() 252 */ 253 EIGEN_DEVICE_FUNC 254 inline const SinReturnType 255 sin() const 256 { 257 return SinReturnType(derived()); 258 } 259 260 /** \returns an expression of the coefficient-wise tan of *this. 261 * 262 * Example: \include Cwise_tan.cpp 263 * Output: \verbinclude Cwise_tan.out 264 * 265 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tan">Math functions</a>, cos(), sin() 266 */ 267 EIGEN_DEVICE_FUNC 268 inline const TanReturnType 269 tan() const 270 { 271 return TanReturnType(derived()); 272 } 273 274 /** \returns an expression of the coefficient-wise arc tan of *this. 275 * 276 * Example: \include Cwise_atan.cpp 277 * Output: \verbinclude Cwise_atan.out 278 * 279 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atan">Math functions</a>, tan(), asin(), acos() 280 */ 281 EIGEN_DEVICE_FUNC 282 inline const AtanReturnType 283 atan() const 284 { 285 return AtanReturnType(derived()); 286 } 287 288 /** \returns an expression of the coefficient-wise arc cosine of *this. 289 * 290 * Example: \include Cwise_acos.cpp 291 * Output: \verbinclude Cwise_acos.out 292 * 293 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acos">Math functions</a>, cos(), asin() 294 */ 295 EIGEN_DEVICE_FUNC 296 inline const AcosReturnType 297 acos() const 298 { 299 return AcosReturnType(derived()); 300 } 301 302 /** \returns an expression of the coefficient-wise arc sine of *this. 303 * 304 * Example: \include Cwise_asin.cpp 305 * Output: \verbinclude Cwise_asin.out 306 * 307 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asin">Math functions</a>, sin(), acos() 308 */ 309 EIGEN_DEVICE_FUNC 310 inline const AsinReturnType 311 asin() const 312 { 313 return AsinReturnType(derived()); 314 } 315 316 /** \returns an expression of the coefficient-wise hyperbolic tan of *this. 317 * 318 * Example: \include Cwise_tanh.cpp 319 * Output: \verbinclude Cwise_tanh.out 320 * 321 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tanh">Math functions</a>, tan(), sinh(), cosh() 322 */ 323 EIGEN_DEVICE_FUNC 324 inline const TanhReturnType 325 tanh() const 326 { 327 return TanhReturnType(derived()); 328 } 329 330 /** \returns an expression of the coefficient-wise hyperbolic sin of *this. 331 * 332 * Example: \include Cwise_sinh.cpp 333 * Output: \verbinclude Cwise_sinh.out 334 * 335 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sinh">Math functions</a>, sin(), tanh(), cosh() 336 */ 337 EIGEN_DEVICE_FUNC 338 inline const SinhReturnType 339 sinh() const 340 { 341 return SinhReturnType(derived()); 342 } 343 344 /** \returns an expression of the coefficient-wise hyperbolic cos of *this. 345 * 346 * Example: \include Cwise_cosh.cpp 347 * Output: \verbinclude Cwise_cosh.out 348 * 349 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cosh">Math functions</a>, tanh(), sinh(), cosh() 350 */ 351 EIGEN_DEVICE_FUNC 352 inline const CoshReturnType 353 cosh() const 354 { 355 return CoshReturnType(derived()); 356 } 357 358 #if EIGEN_HAS_CXX11_MATH 359 /** \returns an expression of the coefficient-wise inverse hyperbolic tan of *this. 360 * 361 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atanh">Math functions</a>, atanh(), asinh(), acosh() 362 */ 363 EIGEN_DEVICE_FUNC 364 inline const AtanhReturnType 365 atanh() const 366 { 367 return AtanhReturnType(derived()); 368 } 369 370 /** \returns an expression of the coefficient-wise inverse hyperbolic sin of *this. 371 * 372 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asinh">Math functions</a>, atanh(), asinh(), acosh() 373 */ 374 EIGEN_DEVICE_FUNC 375 inline const AsinhReturnType 376 asinh() const 377 { 378 return AsinhReturnType(derived()); 379 } 380 381 /** \returns an expression of the coefficient-wise inverse hyperbolic cos of *this. 382 * 383 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acosh">Math functions</a>, atanh(), asinh(), acosh() 384 */ 385 EIGEN_DEVICE_FUNC 386 inline const AcoshReturnType 387 acosh() const 388 { 389 return AcoshReturnType(derived()); 390 } 391 #endif 392 393 /** \returns an expression of the coefficient-wise logistic of *this. 394 */ 395 EIGEN_DEVICE_FUNC 396 inline const LogisticReturnType 397 logistic() const 398 { 399 return LogisticReturnType(derived()); 400 } 401 402 /** \returns an expression of the coefficient-wise inverse of *this. 403 * 404 * Example: \include Cwise_inverse.cpp 405 * Output: \verbinclude Cwise_inverse.out 406 * 407 * \sa operator/(), operator*() 408 */ 409 EIGEN_DEVICE_FUNC 410 inline const InverseReturnType 411 inverse() const 412 { 413 return InverseReturnType(derived()); 414 } 415 416 /** \returns an expression of the coefficient-wise square of *this. 417 * 418 * Example: \include Cwise_square.cpp 419 * Output: \verbinclude Cwise_square.out 420 * 421 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_squareE">Math functions</a>, abs2(), cube(), pow() 422 */ 423 EIGEN_DEVICE_FUNC 424 inline const SquareReturnType 425 square() const 426 { 427 return SquareReturnType(derived()); 428 } 429 430 /** \returns an expression of the coefficient-wise cube of *this. 431 * 432 * Example: \include Cwise_cube.cpp 433 * Output: \verbinclude Cwise_cube.out 434 * 435 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cube">Math functions</a>, square(), pow() 436 */ 437 EIGEN_DEVICE_FUNC 438 inline const CubeReturnType 439 cube() const 440 { 441 return CubeReturnType(derived()); 442 } 443 444 /** \returns an expression of the coefficient-wise rint of *this. 445 * 446 * Example: \include Cwise_rint.cpp 447 * Output: \verbinclude Cwise_rint.out 448 * 449 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_rint">Math functions</a>, ceil(), floor() 450 */ 451 EIGEN_DEVICE_FUNC 452 inline const RintReturnType 453 rint() const 454 { 455 return RintReturnType(derived()); 456 } 457 458 /** \returns an expression of the coefficient-wise round of *this. 459 * 460 * Example: \include Cwise_round.cpp 461 * Output: \verbinclude Cwise_round.out 462 * 463 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_round">Math functions</a>, ceil(), floor() 464 */ 465 EIGEN_DEVICE_FUNC 466 inline const RoundReturnType 467 round() const 468 { 469 return RoundReturnType(derived()); 470 } 471 472 /** \returns an expression of the coefficient-wise floor of *this. 473 * 474 * Example: \include Cwise_floor.cpp 475 * Output: \verbinclude Cwise_floor.out 476 * 477 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_floor">Math functions</a>, ceil(), round() 478 */ 479 EIGEN_DEVICE_FUNC 480 inline const FloorReturnType 481 floor() const 482 { 483 return FloorReturnType(derived()); 484 } 485 486 /** \returns an expression of the coefficient-wise ceil of *this. 487 * 488 * Example: \include Cwise_ceil.cpp 489 * Output: \verbinclude Cwise_ceil.out 490 * 491 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ceil">Math functions</a>, floor(), round() 492 */ 493 EIGEN_DEVICE_FUNC 494 inline const CeilReturnType 495 ceil() const 496 { 497 return CeilReturnType(derived()); 498 } 499 500 template<int N> struct ShiftRightXpr { 501 typedef CwiseUnaryOp<internal::scalar_shift_right_op<Scalar, N>, const Derived> Type; 502 }; 503 504 /** \returns an expression of \c *this with the \a Scalar type arithmetically 505 * shifted right by \a N bit positions. 506 * 507 * The template parameter \a N specifies the number of bit positions to shift. 508 * 509 * \sa shiftLeft() 510 */ 511 template<int N> 512 EIGEN_DEVICE_FUNC 513 typename ShiftRightXpr<N>::Type 514 shiftRight() const 515 { 516 return typename ShiftRightXpr<N>::Type(derived()); 517 } 518 519 520 template<int N> struct ShiftLeftXpr { 521 typedef CwiseUnaryOp<internal::scalar_shift_left_op<Scalar, N>, const Derived> Type; 522 }; 523 524 /** \returns an expression of \c *this with the \a Scalar type logically 525 * shifted left by \a N bit positions. 526 * 527 * The template parameter \a N specifies the number of bit positions to shift. 528 * 529 * \sa shiftRight() 530 */ 531 template<int N> 532 EIGEN_DEVICE_FUNC 533 typename ShiftLeftXpr<N>::Type 534 shiftLeft() const 535 { 536 return typename ShiftLeftXpr<N>::Type(derived()); 537 } 538 539 /** \returns an expression of the coefficient-wise isnan of *this. 540 * 541 * Example: \include Cwise_isNaN.cpp 542 * Output: \verbinclude Cwise_isNaN.out 543 * 544 * \sa isfinite(), isinf() 545 */ 546 EIGEN_DEVICE_FUNC 547 inline const IsNaNReturnType 548 isNaN() const 549 { 550 return IsNaNReturnType(derived()); 551 } 552 553 /** \returns an expression of the coefficient-wise isinf of *this. 554 * 555 * Example: \include Cwise_isInf.cpp 556 * Output: \verbinclude Cwise_isInf.out 557 * 558 * \sa isnan(), isfinite() 559 */ 560 EIGEN_DEVICE_FUNC 561 inline const IsInfReturnType 562 isInf() const 563 { 564 return IsInfReturnType(derived()); 565 } 566 567 /** \returns an expression of the coefficient-wise isfinite of *this. 568 * 569 * Example: \include Cwise_isFinite.cpp 570 * Output: \verbinclude Cwise_isFinite.out 571 * 572 * \sa isnan(), isinf() 573 */ 574 EIGEN_DEVICE_FUNC 575 inline const IsFiniteReturnType 576 isFinite() const 577 { 578 return IsFiniteReturnType(derived()); 579 } 580 581 /** \returns an expression of the coefficient-wise ! operator of *this 582 * 583 * \warning this operator is for expression of bool only. 584 * 585 * Example: \include Cwise_boolean_not.cpp 586 * Output: \verbinclude Cwise_boolean_not.out 587 * 588 * \sa operator!=() 589 */ 590 EIGEN_DEVICE_FUNC 591 inline const BooleanNotReturnType 592 operator!() const 593 { 594 EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value), 595 THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL); 596 return BooleanNotReturnType(derived()); 597 } 598 599 600 // --- SpecialFunctions module --- 601 602 typedef CwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived> LgammaReturnType; 603 typedef CwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived> DigammaReturnType; 604 typedef CwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived> ErfReturnType; 605 typedef CwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived> ErfcReturnType; 606 typedef CwiseUnaryOp<internal::scalar_ndtri_op<Scalar>, const Derived> NdtriReturnType; 607 608 /** \cpp11 \returns an expression of the coefficient-wise ln(|gamma(*this)|). 609 * 610 * \specialfunctions_module 611 * 612 * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types, 613 * or float/double in non c++11 mode, the user has to provide implementations of lgamma(T) for any scalar 614 * type T to be supported. 615 * 616 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_lgamma">Math functions</a>, digamma() 617 */ 618 EIGEN_DEVICE_FUNC 619 inline const LgammaReturnType 620 lgamma() const 621 { 622 return LgammaReturnType(derived()); 623 } 624 625 /** \returns an expression of the coefficient-wise digamma (psi, derivative of lgamma). 626 * 627 * \specialfunctions_module 628 * 629 * \note This function supports only float and double scalar types. To support other scalar types, 630 * the user has to provide implementations of digamma(T) for any scalar 631 * type T to be supported. 632 * 633 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_digamma">Math functions</a>, Eigen::digamma(), Eigen::polygamma(), lgamma() 634 */ 635 EIGEN_DEVICE_FUNC 636 inline const DigammaReturnType 637 digamma() const 638 { 639 return DigammaReturnType(derived()); 640 } 641 642 /** \cpp11 \returns an expression of the coefficient-wise Gauss error 643 * function of *this. 644 * 645 * \specialfunctions_module 646 * 647 * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types, 648 * or float/double in non c++11 mode, the user has to provide implementations of erf(T) for any scalar 649 * type T to be supported. 650 * 651 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erf">Math functions</a>, erfc() 652 */ 653 EIGEN_DEVICE_FUNC 654 inline const ErfReturnType 655 erf() const 656 { 657 return ErfReturnType(derived()); 658 } 659 660 /** \cpp11 \returns an expression of the coefficient-wise Complementary error 661 * function of *this. 662 * 663 * \specialfunctions_module 664 * 665 * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types, 666 * or float/double in non c++11 mode, the user has to provide implementations of erfc(T) for any scalar 667 * type T to be supported. 668 * 669 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erfc">Math functions</a>, erf() 670 */ 671 EIGEN_DEVICE_FUNC 672 inline const ErfcReturnType 673 erfc() const 674 { 675 return ErfcReturnType(derived()); 676 } 677 678 /** \returns an expression of the coefficient-wise inverse of the CDF of the Normal distribution function 679 * function of *this. 680 * 681 * \specialfunctions_module 682 * 683 * In other words, considering `x = ndtri(y)`, it returns the argument, x, for which the area under the 684 * Gaussian probability density function (integrated from minus infinity to x) is equal to y. 685 * 686 * \note This function supports only float and double scalar types. To support other scalar types, 687 * the user has to provide implementations of ndtri(T) for any scalar type T to be supported. 688 * 689 * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ndtri">Math functions</a> 690 */ 691 EIGEN_DEVICE_FUNC 692 inline const NdtriReturnType 693 ndtri() const 694 { 695 return NdtriReturnType(derived()); 696 }