<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en-us" xml:lang="en-us">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"></meta>
<meta http-equiv="X-UA-Compatible" content="IE=edge"></meta>
<meta name="copyright" content="(C) Copyright 2005"></meta>
<meta name="DC.rights.owner" content="(C) Copyright 2005"></meta>
<meta name="DC.Type" content="cppModule"></meta>
<meta name="DC.Title" content="Double Precision Mathematical Functions"></meta>
<meta name="abstract" content=""></meta>
<meta name="description" content=""></meta>
<meta name="DC.Format" content="XHTML"></meta>
<meta name="DC.Identifier" content="group__CUDA__MATH__DOUBLE"></meta>
<link rel="stylesheet" type="text/css" href="../common/formatting/commonltr.css"></link>
<link rel="stylesheet" type="text/css" href="../common/formatting/site.css"></link>
<title>CUDA Math API :: CUDA Toolkit Documentation</title>
<!--[if lt IE 9]>
<script src="../common/formatting/html5shiv-printshiv.min.js"></script>
<![endif]-->
<script type="text/javascript" charset="utf-8" src="//assets.adobedtm.com/b92787824f2e0e9b68dc2e993f9bd995339fe417/satelliteLib-7ba51e58dc61bcb0e9311aadd02a0108ab24cc6c.js"></script>
<script type="text/javascript" charset="utf-8" src="../common/formatting/jquery.min.js"></script>
<script type="text/javascript" charset="utf-8" src="../common/formatting/jquery.ba-hashchange.min.js"></script>
<script type="text/javascript" charset="utf-8" src="../common/formatting/jquery.scrollintoview.min.js"></script>
<script type="text/javascript" src="../search/htmlFileList.js"></script>
<script type="text/javascript" src="../search/htmlFileInfoList.js"></script>
<script type="text/javascript" src="../search/nwSearchFnt.min.js"></script>
<script type="text/javascript" src="../search/stemmers/en_stemmer.min.js"></script>
<script type="text/javascript" src="../search/index-1.js"></script>
<script type="text/javascript" src="../search/index-2.js"></script>
<script type="text/javascript" src="../search/index-3.js"></script>
<link rel="canonical" href="http://docs.nvidia.com/cuda/cuda-math-api/index.html"></link>
<link rel="stylesheet" type="text/css" href="../common/formatting/qwcode.highlight.css"></link>
</head>
<body>
<header id="header"><span id="company">NVIDIA</span><span id="site-title">CUDA Toolkit Documentation</span><form id="search" method="get" action="search">
<input type="text" name="search-text"></input><fieldset id="search-location">
<legend>Search In:</legend>
<label><input type="radio" name="search-type" value="site"></input>Entire Site</label>
<label><input type="radio" name="search-type" value="document"></input>Just This Document</label></fieldset>
<button type="reset">clear search</button>
<button id="submit" type="submit">search</button></form>
</header>
<div id="site-content">
<nav id="site-nav">
<div class="category closed"><a href="../index.html" title="The root of the site.">CUDA Toolkit
v10.1.168</a></div>
<div class="category"><a href="index.html" title="CUDA Math API">CUDA Math API</a></div>
<ul>
<li>
<div class="section-link"><a href="modules.html#modules">1. Modules</a></div>
<ul>
<li>
<div class="section-link"><a href="group__CUDA__MATH__INTRINSIC__HALF.html#group__CUDA__MATH__INTRINSIC__HALF">1.1. Half Precision Intrinsics</a></div>
<ul>
<li>
<div class="section-link"><a href="group__CUDA__MATH____HALF__ARITHMETIC.html#group__CUDA__MATH____HALF__ARITHMETIC">1.1.1. Half Arithmetic Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH____HALF2__ARITHMETIC.html#group__CUDA__MATH____HALF2__ARITHMETIC">1.1.2. Half2 Arithmetic Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH____HALF__COMPARISON.html#group__CUDA__MATH____HALF__COMPARISON">1.1.3. Half Comparison Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH____HALF2__COMPARISON.html#group__CUDA__MATH____HALF2__COMPARISON">1.1.4. Half2 Comparison Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH____HALF__MISC.html#group__CUDA__MATH____HALF__MISC">1.1.5. Half Precision Conversion And Data Movement</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH____HALF__FUNCTIONS.html#group__CUDA__MATH____HALF__FUNCTIONS">1.1.6. Half Math Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH____HALF2__FUNCTIONS.html#group__CUDA__MATH____HALF2__FUNCTIONS">1.1.7. Half2 Math Functions</a></div>
</li>
</ul>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH.html#group__CUDA__MATH">1.2. Mathematical Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH__SINGLE.html#group__CUDA__MATH__SINGLE">1.3. Single Precision Mathematical Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE">1.4. Double Precision Mathematical Functions</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH__INTRINSIC__SINGLE.html#group__CUDA__MATH__INTRINSIC__SINGLE">1.5. Single Precision Intrinsics</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH__INTRINSIC__DOUBLE.html#group__CUDA__MATH__INTRINSIC__DOUBLE">1.6. Double Precision Intrinsics</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH__INTRINSIC__INT.html#group__CUDA__MATH__INTRINSIC__INT">1.7. Integer Intrinsics</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH__INTRINSIC__CAST.html#group__CUDA__MATH__INTRINSIC__CAST">1.8. Type Casting Intrinsics</a></div>
</li>
<li>
<div class="section-link"><a href="group__CUDA__MATH__INTRINSIC__SIMD.html#group__CUDA__MATH__INTRINSIC__SIMD">1.9. SIMD Intrinsics</a></div>
</li>
</ul>
</li>
<li>
<div class="section-link"><a href="notices-header.html#notices-header">Notices</a></div>
<ul></ul>
</li>
</ul>
</nav>
<div id="resize-nav"></div>
<nav id="search-results">
<h2>Search Results</h2>
<ol></ol>
</nav>
<div id="contents-container">
<div id="breadcrumbs-container">
<div id="eqn-warning">This document includes math equations
(highlighted in red) which are best viewed with <a target="_blank" href="https://www.mozilla.org/firefox">Firefox</a> version 4.0
or higher, or another <a target="_blank" href="http://www.w3.org/Math/Software/mathml_software_cat_browsers.html">MathML-aware
browser</a>. There is also a <a href="../../pdf/CUDA_Math_API.pdf">PDF version of this document</a>.
</div>
<div id="breadcrumbs"><a href="group__CUDA__MATH__SINGLE.html" shape="rect">< Previous</a> | <a href="group__CUDA__MATH__INTRINSIC__SINGLE.html" shape="rect">Next ></a></div>
<div id="release-info">CUDA Math API
(<a href="../../pdf/CUDA_Math_API.pdf">PDF</a>)
-
v10.1.168
(<a href="https://developer.nvidia.com/cuda-toolkit-archive">older</a>)
-
Last updated April 24, 2019
-
<a href="mailto:CUDAIssues@nvidia.com?subject=CUDA Toolkit Documentation Feedback: CUDA Math API">Send Feedback</a></div>
</div>
<article id="contents">
<div class="topic reference apiRef apiPackage cppModule" id="group__CUDA__MATH__DOUBLE"><a name="group__CUDA__MATH__DOUBLE" shape="rect">
<!-- --></a><h2 class="topictitle2 cppModule">1.4. Double Precision Mathematical Functions</h2>
<div class="section">
<p>This section describes double precision mathematical functions. To use these functions you do not need to include any additional
header files in your program.
</p>
</div>
<h3 class="fake_sectiontitle member_header">Functions</h3>
<dl class="members">
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gfb79b8e69174e322b3d5da70cd363521" shape="rect">acos</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the arc cosine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g41d6a7aee6b7e78987c1ea9633f6467a" shape="rect">acosh</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the nonnegative arc hyperbolic cosine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g8328d1b24f630bfc9747b57a13e66e79" shape="rect">asin</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the arc sine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g10334b3ee5d54b6e6959102709af23ce" shape="rect">asinh</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the arc hyperbolic sine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g875675909708a2bd6d4e889df0e7791c" shape="rect">atan</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the arc tangent of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gdd5ea203222910d0fba30d3bcfd6fbfe" shape="rect">atan2</a> ( double <span> </span><span class="keyword keyword apiItemName">y</span>, double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the arc tangent of the ratio of first and second input arguments. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1ga8da8c2dc65bc77ced8e92475d423cb6" shape="rect">atanh</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the arc hyperbolic tangent of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g86e3a3d10161a10246658ab77fac8311" shape="rect">cbrt</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the cube root of the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1gc45db992bc2ed076e6f1edccd2d3e3d0" shape="rect">ceil</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate ceiling of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1ga06f087bfaf3245b3d78e30658eb9b2e" shape="rect">copysign</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Create value with given magnitude, copying sign of second value. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g3f1d2831497e6fa3f0072395e13a8ecf" shape="rect">cos</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the cosine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gcb71d08327c30ff681f47d5cefdf661f" shape="rect">cosh</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the hyperbolic cosine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g0b7c24b9064401951cb1e66a23b44a4b" shape="rect">cospi</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the cosine of the input argument
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g1447f688cd7e242c793ff15eb0406da2" shape="rect">cyl_bessel_i0</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the regular modified cylindrical Bessel function of order 0 for the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1ga166717a7cb710679a45eb8f94258136" shape="rect">cyl_bessel_i1</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the regular modified cylindrical Bessel function of order 1 for the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gbd196c4f3bc4260ffe99944b2400b951" shape="rect">erf</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the error function of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1ge5fb0600e76f923d822e51b6148a9d1a" shape="rect">erfc</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the complementary error function of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g16e94306d9467be526954fdef161e4da" shape="rect">erfcinv</a> ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the inverse complementary error function of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g31bd5945637fd6790091b3a0f77b9169" shape="rect">erfcx</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the scaled complementary error function of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g2f624d3d5014335f087d6e33f370088f" shape="rect">erfinv</a> ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the inverse error function of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g15c1324292b08058007e4be047228e84" shape="rect">exp</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
exponential of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g9c59e13661f0e53fd46f1cfa231f5ff2" shape="rect">exp10</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the base 10 exponential of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g033d73c657d39a2ac311c0ecb0eedd4f" shape="rect">exp2</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the base 2 exponential of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g47772b17638c6b764d5ca5a6b8df1018" shape="rect">expm1</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
exponential of the input argument, minus 1. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g4f9fbe6c98f94000badf4ecf3211c128" shape="rect">fabs</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the absolute value of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gbfbecf3022a22ba02e34a643158553e6" shape="rect">fdim</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Compute the positive difference between <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g4b7a1abc2e9e010b0e3f38bcdb2d1aa3" shape="rect">floor</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the largest integer less than or equal to <tt class="ph tt code">x</tt>. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gff2117f6f3c4ff8a2aa4ce48a0ff2070" shape="rect">fma</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span>, double <span> </span><span class="keyword keyword apiItemName">z</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Compute
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>×</mo>
<mi>y</mi>
<mo>+</mo>
<mi>z</mi>
</math>
as a single operation. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g8f5b0627e6706e432728bd16cb326754" shape="rect">fmax</a> ( double , double ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Determine the maximum numeric value of the arguments. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gc970b9542e2d3e8e5d1e3ebb6a705dde" shape="rect">fmin</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Determine the minimum numeric value of the arguments. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g5e4d96de745c62d885d0a3a6bc838b86" shape="rect">fmod</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the floating-point remainder of <tt class="ph tt code">x</tt> / <tt class="ph tt code">y</tt>. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1gf83b8e238282287d560dd12e7531e89f" shape="rect">frexp</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, int*<span> </span><span class="keyword keyword apiItemName">nptr</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Extract mantissa and exponent of a floating-point value. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
_ACRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1gc8fc174f8cc55bb32f1f6f12b4ff6c2e" shape="rect">hypot</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the square root of the sum of squares of two arguments. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
int </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g1085a209cbd5f56a4f2dbf1ba0f67be4" shape="rect">ilogb</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Compute the unbiased integer exponent of the argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g366741a6f8e9847dd7268f4a005028ff" shape="rect">isfinite</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Determine whether argument is finite. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1gfe9aea186f33fb4f951f614ff2b53701" shape="rect">isinf</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Determine whether argument is infinite. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g25649cf7c3d3c7a68423489532b8d459" shape="rect">isnan</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Determine whether argument is a NaN. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g39cb9f4d5156e720837d77f518f2298a" shape="rect">j0</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the Bessel function of the first kind of order 0 for the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g626a7fad13f7ab4e523e852e0686f6f3" shape="rect">j1</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the Bessel function of the first kind of order 1 for the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1gd4c381147beb88bc72ca3952602de721" shape="rect">jn</a> ( int <span> </span><span class="keyword keyword apiItemName">n</span>, double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the Bessel function of the first kind of order n for the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g12ac38ace0d74cc339325e745cd281d5" shape="rect">ldexp</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, int <span> </span><span class="keyword keyword apiItemName">exp</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>⋅</mo>
<msup>
<mn>2</mn>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
<mi>x</mi>
<mi>p</mi>
</mrow>
</msup>
</math>
. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g402aaedc732b2eabf59abc07d744ed35" shape="rect">lgamma</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the natural logarithm of the absolute value of the gamma function of the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
long long int </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g6d2532344fe30f7f8988e031aac8e1cd" shape="rect">llrint</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Round input to nearest integer value. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
long long int </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g6e401c3a6f291b874fc95b8480bcad02" shape="rect">llround</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Round to nearest integer value. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g28ce8e15ef5149c271eba95663becba2" shape="rect">log</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
logarithm of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g0aed82d571362c58f9486385383e7f64" shape="rect">log10</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the base 10 logarithm of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g3c680d660d75780ef53075a439211626" shape="rect">log1p</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>l</mi>
<mi>o</mi>
<msub>
<mi>g</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
</mrow>
</msub>
<mo stretchy="false">(</mo>
<mn>1</mn>
<mo>+</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gc15d49c9960470b4791eafa0607ca777" shape="rect">log2</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the base 2 logarithm of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g24e6d5c7904a61d50055d27ffe6d8fdb" shape="rect">logb</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the floating point representation of the exponent of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
long int </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g353f5748b7addbae162dd679abf829fe" shape="rect">lrint</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Round input to nearest integer value. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
long int </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g9fdb5ef303c94dc5c428dbdb534ed1fd" shape="rect">lround</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Round to nearest integer value. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1gf66b786e19d90c6c519ce7b80afa97bf" shape="rect">modf</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double*<span> </span><span class="keyword keyword apiItemName">iptr</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Break down the input argument into fractional and integral parts. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g6df5511321a5ac0dfe22389b728a8a9f" shape="rect">nan</a> ( const char*<span> </span><span class="keyword keyword apiItemName">tagp</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Returns "Not a Number" value. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g2316a104cfda8362208d52238181fbfb" shape="rect">nearbyint</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Round the input argument to the nearest integer. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gf46b3ad97567ae96f7148a10537c8f5a" shape="rect">nextafter</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Return next representable double-precision floating-point value after argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g7c5ebbdd1d0300094d9e34fbe5218a75" shape="rect">norm</a> ( int <span> </span><span class="keyword keyword apiItemName">dim</span>, const double*<span> </span><span class="keyword keyword apiItemName">t</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the square root of the sum of squares of any number of coordinates. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g0f1beab2ceb43c190bbdd53073481a87" shape="rect">norm3d</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the square root of the sum of squares of three coordinates of the argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g22d61aa6b93f5943c4d35a3545aace18" shape="rect">norm4d</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span>, double <span> </span><span class="keyword keyword apiItemName">d</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the square root of the sum of squares of four coordinates of the argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g8368e3ba7981942344d0be3b5d817e3f" shape="rect">normcdf</a> ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the standard normal cumulative distribution function. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g78e93df6c3fbade8628d33e11fc94595" shape="rect">normcdfinv</a> ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the inverse of the standard normal cumulative distribution function. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g6d36757715384dc18e0483aa1f04f6c7" shape="rect">pow</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of first argument to the power of second argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g3f5dd3f9b81f73c644d82754986ccce6" shape="rect">rcbrt</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate reciprocal cube root function. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g852e83c233f09c146c492bfd752e0dd2" shape="rect">remainder</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Compute double-precision floating-point remainder. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g4235a6814bb94b3faaf73a324210c58d" shape="rect">remquo</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span>, int*<span> </span><span class="keyword keyword apiItemName">quo</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Compute double-precision floating-point remainder and part of quotient. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gf1dfb4d01feaa01b0b1ff15cf57ebbc3" shape="rect">rhypot</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate one over the square root of the sum of squares of two arguments. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g3b8026edb2f2e441669845f0f3fa3bf7" shape="rect">rint</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Round to nearest integer value in floating-point. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g3d2150666773f15337b09aa7e1662e59" shape="rect">rnorm</a> ( int <span> </span><span class="keyword keyword apiItemName">dim</span>, const double*<span> </span><span class="keyword keyword apiItemName">t</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the reciprocal of square root of the sum of squares of any number of coordinates. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g1ac4eff7fecc1121d5dcfdebc3314e80" shape="rect">rnorm3d</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate one over the square root of the sum of squares of three coordinates of the argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g039d37d2d8d44f074e057489a439a758" shape="rect">rnorm4d</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span>, double <span> </span><span class="keyword keyword apiItemName">d</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate one over the square root of the sum of squares of four coordinates of the argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gbefba28ee84ef32c44d417cfd4f615d4" shape="rect">round</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Round to nearest integer value in floating-point. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gf799c5cd74e63236a4a08296cb12ccbc" shape="rect">rsqrt</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the reciprocal of the square root of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g7c931cea8bc2cfe694a6170379e5914f" shape="rect">scalbln</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, long int <span> </span><span class="keyword keyword apiItemName">n</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Scale floating-point input by integer power of two. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g4923bed52b438e5bfbf574bb8ce26542" shape="rect">scalbn</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, int <span> </span><span class="keyword keyword apiItemName">n</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Scale floating-point input by integer power of two. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g2bd7d6942a8b25ae518636dab9ad78a7" shape="rect">signbit</a> ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Return the sign bit of the input. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g3ebbca20a2937d1fe51329402880df85" shape="rect">sin</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the sine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
void </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gbe0e6a063a8f38850b0323933cf3320b" shape="rect">sincos</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double*<span> </span><span class="keyword keyword apiItemName">sptr</span>, double*<span> </span><span class="keyword keyword apiItemName">cptr</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the sine and cosine of the first input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
void </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gfc99d7acfc1b14dcb6f6db56147d2560" shape="rect">sincospi</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double*<span> </span><span class="keyword keyword apiItemName">sptr</span>, double*<span> </span><span class="keyword keyword apiItemName">cptr</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the sine and cosine of the first input argument
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gabc5c0e23e1550a6cc936baa9d65a61a" shape="rect">sinh</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the hyperbolic sine of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g06ae86e791c45c081184e605f984e733" shape="rect">sinpi</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the sine of the input argument
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g1c6fe34b4ac091e40eceeb0bae58459f" shape="rect">sqrt</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the square root of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1g17d00b521d79b4a4404cc593839f0b7b" shape="rect">tan</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the tangent of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gdf7b9660a2c53c91664263d39b09242d" shape="rect">tanh</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the hyperbolic tangent of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gecfb49e21fc767c952827d42268c0d48" shape="rect">tgamma</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the gamma function of the input argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
double </span><span class="member_name"><a href="#group__CUDA__MATH__DOUBLE_1gaa2c1b49a1f4aa25f8ce49236089f2a8" shape="rect">trunc</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Truncate input argument to the integral part. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g7eab7eb6999bde9057f22e36e7db95d4" shape="rect">y0</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the Bessel function of the second kind of order 0 for the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g2560f5508d3aaec918ed7e94e96a6180" shape="rect">y1</a> ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the Bessel function of the second kind of order 1 for the input argument. </span></dd>
<dt><span class="member_long_type"><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double </span><span class="member_name_long_type"><a href="#group__CUDA__MATH__DOUBLE_1g01b473912d10252607be1870b1b2660d" shape="rect">yn</a> ( int <span> </span><span class="keyword keyword apiItemName">n</span>, double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the value of the Bessel function of the second kind of order n for the input argument. </span></dd>
</dl>
<div class="description">
<h3 class="sectiontitle">Functions</h3>
<dl class="description">
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gfb79b8e69174e322b3d5da70cd363521" id="group__CUDA__MATH__DOUBLE_1gfb79b8e69174e322b3d5da70cd363521" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double acos ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the arc cosine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Result will be in radians, in the interval [0,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
</math>
] for <tt class="ph tt code">x</tt> inside [-1, +1].
<ul>
<li>acos(1) returns +0.</li>
<li>acos(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> outside [-1, +1].
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the principal value of the arc cosine of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g41d6a7aee6b7e78987c1ea9633f6467a" id="group__CUDA__MATH__DOUBLE_1g41d6a7aee6b7e78987c1ea9633f6467a" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double acosh ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the nonnegative arc hyperbolic cosine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Result will be in the interval [0,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
].
<ul>
<li>acosh(1) returns 0.</li>
<li>acosh(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> in the interval [
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
, 1).
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the nonnegative arc hyperbolic cosine of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g8328d1b24f630bfc9747b57a13e66e79" id="group__CUDA__MATH__DOUBLE_1g8328d1b24f630bfc9747b57a13e66e79" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double asin ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the arc sine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Result will be in radians, in the interval [-
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
</math>
/2, +
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
</math>
/2] for <tt class="ph tt code">x</tt> inside [-1, +1].
<ul>
<li>asin(0) returns +0.</li>
<li>asin(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> outside [-1, +1].
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the principal value of the arc sine of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g10334b3ee5d54b6e6959102709af23ce" id="group__CUDA__MATH__DOUBLE_1g10334b3ee5d54b6e6959102709af23ce" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double asinh ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the arc hyperbolic sine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>asinh(0) returns 1.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the arc hyperbolic sine of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g875675909708a2bd6d4e889df0e7791c" id="group__CUDA__MATH__DOUBLE_1g875675909708a2bd6d4e889df0e7791c" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double atan ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the arc tangent of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Result will be in radians, in the interval [-
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
</math>
/2, +
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
</math>
/2].
<ul>
<li>atan(0) returns +0.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the principal value of the arc tangent of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gdd5ea203222910d0fba30d3bcfd6fbfe" id="group__CUDA__MATH__DOUBLE_1gdd5ea203222910d0fba30d3bcfd6fbfe" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double atan2 ( double <span> </span><span class="keyword keyword apiItemName">y</span>, double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the arc tangent of the ratio of first and second input arguments. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Result will be in radians, in the interval [-
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
</math>
/, +
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
</math>
].
<ul>
<li>atan2(0, 1) returns +0.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the principal value of the arc tangent of the ratio of first and second input arguments <tt class="ph tt code">y</tt> / <tt class="ph tt code">x</tt>. The quadrant of the result is determined by the signs of inputs <tt class="ph tt code">y</tt> and <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1ga8da8c2dc65bc77ced8e92475d423cb6" id="group__CUDA__MATH__DOUBLE_1ga8da8c2dc65bc77ced8e92475d423cb6" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double atanh ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the arc hyperbolic tangent of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>atanh(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>atanh(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>1</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>atanh(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> outside interval [-1, 1].
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the arc hyperbolic tangent of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g86e3a3d10161a10246658ab77fac8311" id="group__CUDA__MATH__DOUBLE_1g86e3a3d10161a10246658ab77fac8311" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double cbrt ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the cube root of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>1</mn>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<mn>3</mn>
</mrow>
</msup>
</math>
.
<ul>
<li>cbrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>cbrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the cube root of <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>1</mn>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<mn>3</mn>
</mrow>
</msup>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gc45db992bc2ed076e6f1edccd2d3e3d0" id="group__CUDA__MATH__DOUBLE_1gc45db992bc2ed076e6f1edccd2d3e3d0" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double ceil ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate ceiling of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo fence="false" stretchy="false">⌈</mo>
<mi>x</mi>
<mo fence="false" stretchy="false">⌉</mo>
</math>
expressed as a floating-point number.
<ul>
<li>ceil(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>ceil(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Compute the smallest integer value not less than <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1ga06f087bfaf3245b3d78e30658eb9b2e" id="group__CUDA__MATH__DOUBLE_1ga06f087bfaf3245b3d78e30658eb9b2e" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double copysign ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Create value with given magnitude, copying sign of second value. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns a value with the magnitude of <tt class="ph tt code">x</tt> and the sign of <tt class="ph tt code">y</tt>.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Create a floating-point value with the magnitude <tt class="ph tt code">x</tt> and the sign of <tt class="ph tt code">y</tt>.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g3f1d2831497e6fa3f0072395e13a8ecf" id="group__CUDA__MATH__DOUBLE_1g3f1d2831497e6fa3f0072395e13a8ecf" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double cos ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the cosine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>cos(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns 1.
</li>
<li>cos(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the cosine of the input argument <tt class="ph tt code">x</tt> (measured in radians).
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gcb71d08327c30ff681f47d5cefdf661f" id="group__CUDA__MATH__DOUBLE_1gcb71d08327c30ff681f47d5cefdf661f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double cosh ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the hyperbolic cosine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>cosh(0) returns 1.</li>
<li>cosh(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the hyperbolic cosine of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g0b7c24b9064401951cb1e66a23b44a4b" id="group__CUDA__MATH__DOUBLE_1g0b7c24b9064401951cb1e66a23b44a4b" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double cospi ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the cosine of the input argument
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>cospi(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns 1.
</li>
<li>cospi(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the cosine of <tt class="ph tt code">x</tt><math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
(measured in radians), where <tt class="ph tt code">x</tt> is the input argument.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g1447f688cd7e242c793ff15eb0406da2" id="group__CUDA__MATH__DOUBLE_1g1447f688cd7e242c793ff15eb0406da2" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double cyl_bessel_i0 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the regular modified cylindrical Bessel function of order 0 for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the regular modified cylindrical Bessel function of order 0.</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the regular modified cylindrical Bessel function of order 0 for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>I</mi>
<mn>0</mn>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1ga166717a7cb710679a45eb8f94258136" id="group__CUDA__MATH__DOUBLE_1ga166717a7cb710679a45eb8f94258136" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double cyl_bessel_i1 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the regular modified cylindrical Bessel function of order 1 for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the regular modified cylindrical Bessel function of order 1.</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the regular modified cylindrical Bessel function of order 1 for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>I</mi>
<mn>1</mn>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gbd196c4f3bc4260ffe99944b2400b951" id="group__CUDA__MATH__DOUBLE_1gbd196c4f3bc4260ffe99944b2400b951" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double erf ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the error function of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>erf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>erf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>1</mn>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the error function for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mfrac>
<mn>2</mn>
<msqrt>
<mi>π</mi>
</msqrt>
</mfrac>
<msubsup>
<mo>∫</mo>
<mn>0</mn>
<mi>x</mi>
</msubsup>
<msup>
<mi>e</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>−</mo>
<msup>
<mi>t</mi>
<mn>2</mn>
</msup>
</mrow>
</msup>
<mi>d</mi>
<mi>t</mi>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1ge5fb0600e76f923d822e51b6148a9d1a" id="group__CUDA__MATH__DOUBLE_1ge5fb0600e76f923d822e51b6148a9d1a" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double erfc ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the complementary error function of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>erfc(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns 2.
</li>
<li>erfc(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the complementary error function of the input argument <tt class="ph tt code">x</tt>, 1 - erf(<tt class="ph tt code">x</tt>).
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g16e94306d9467be526954fdef161e4da" id="group__CUDA__MATH__DOUBLE_1g16e94306d9467be526954fdef161e4da" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double erfcinv ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the inverse complementary error function of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>erfcinv(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>erfcinv(2) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the inverse complementary error function of the input argument <tt class="ph tt code">y</tt>, for <tt class="ph tt code">y</tt> in the interval [0, 2]. The inverse complementary error function find the value <tt class="ph tt code">x</tt> that satisfies the equation <tt class="ph tt code">y</tt> = erfc(<tt class="ph tt code">x</tt>), for
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mn>0</mn>
<mo>≤</mo>
<mi>y</mi>
<mo>≤</mo>
<mn>2</mn>
</math>
, and
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
<mo>≤</mo>
<mi>x</mi>
<mo>≤</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g31bd5945637fd6790091b3a0f77b9169" id="group__CUDA__MATH__DOUBLE_1g31bd5945637fd6790091b3a0f77b9169" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double erfcx ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the scaled complementary error function of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>erfcx(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>-</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
</li>
<li>erfcx(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0
</li>
<li>erfcx(<tt class="ph tt code">x</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
if the correctly calculated value is outside the double floating point range.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the scaled complementary error function of the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mi>e</mi>
<mrow class="MJX-TeXAtom-ORD">
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
</mrow>
</msup>
<mo>⋅</mo>
<mrow class="MJX-TeXAtom-ORD">
<mtext>erfc</mtext>
</mrow>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g2f624d3d5014335f087d6e33f370088f" id="group__CUDA__MATH__DOUBLE_1g2f624d3d5014335f087d6e33f370088f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double erfinv ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the inverse error function of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>erfinv(1) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>erfinv(-1) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the inverse error function of the input argument <tt class="ph tt code">y</tt>, for <tt class="ph tt code">y</tt> in the interval [-1, 1]. The inverse error function finds the value <tt class="ph tt code">x</tt> that satisfies the equation <tt class="ph tt code">y</tt> = erf(<tt class="ph tt code">x</tt>), for
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mn>1</mn>
<mo>≤</mo>
<mi>y</mi>
<mo>≤</mo>
<mn>1</mn>
</math>
, and
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
<mo>≤</mo>
<mi>x</mi>
<mo>≤</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g15c1324292b08058007e4be047228e84" id="group__CUDA__MATH__DOUBLE_1g15c1324292b08058007e4be047228e84" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double exp ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
exponential of the input argument.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mi>e</mi>
<mi>x</mi>
</msup>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
exponential of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g9c59e13661f0e53fd46f1cfa231f5ff2" id="group__CUDA__MATH__DOUBLE_1g9c59e13661f0e53fd46f1cfa231f5ff2" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double exp10 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the base 10 exponential of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mn>10</mn>
<mi>x</mi>
</msup>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the base 10 exponential of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g033d73c657d39a2ac311c0ecb0eedd4f" id="group__CUDA__MATH__DOUBLE_1g033d73c657d39a2ac311c0ecb0eedd4f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double exp2 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the base 2 exponential of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mn>2</mn>
<mi>x</mi>
</msup>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the base 2 exponential of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g47772b17638c6b764d5ca5a6b8df1018" id="group__CUDA__MATH__DOUBLE_1g47772b17638c6b764d5ca5a6b8df1018" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double expm1 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
exponential of the input argument, minus 1.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mi>e</mi>
<mi>x</mi>
</msup>
<mo>−</mo>
<mn>1</mn>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
exponential of the input argument <tt class="ph tt code">x</tt>, minus 1.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g4f9fbe6c98f94000badf4ecf3211c128" id="group__CUDA__MATH__DOUBLE_1g4f9fbe6c98f94000badf4ecf3211c128" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double fabs ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the absolute value of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the absolute value of the input argument.
<ul>
<li>fabs(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>fabs(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns 0.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the absolute value of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gbfbecf3022a22ba02e34a643158553e6" id="group__CUDA__MATH__DOUBLE_1gbfbecf3022a22ba02e34a643158553e6" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double fdim ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Compute the positive difference between <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the positive difference between <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>.
<ul>
<li>fdim(<tt class="ph tt code">x</tt>, <tt class="ph tt code">y</tt>) returns <tt class="ph tt code">x</tt> - <tt class="ph tt code">y</tt> if <tt class="ph tt code">x</tt> > <tt class="ph tt code">y</tt>.
</li>
<li>fdim(<tt class="ph tt code">x</tt>, <tt class="ph tt code">y</tt>) returns +0 if <tt class="ph tt code">x</tt><math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>≤</mo>
</math><tt class="ph tt code">y</tt>.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Compute the positive difference between <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>. The positive difference is <tt class="ph tt code">x</tt> - <tt class="ph tt code">y</tt> when <tt class="ph tt code">x</tt> > <tt class="ph tt code">y</tt> and +0 otherwise.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 6. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g4b7a1abc2e9e010b0e3f38bcdb2d1aa3" id="group__CUDA__MATH__DOUBLE_1g4b7a1abc2e9e010b0e3f38bcdb2d1aa3" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double floor ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the largest integer less than or equal to <tt class="ph tt code">x</tt>.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>l</mi>
<mi>o</mi>
<msub>
<mi>g</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
</mrow>
</msub>
<mo stretchy="false">(</mo>
<mn>1</mn>
<mo>+</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
expressed as a floating-point number.
<ul>
<li>floor(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>floor(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculates the largest integer value which is less than or equal to <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gff2117f6f3c4ff8a2aa4ce48a0ff2070" id="group__CUDA__MATH__DOUBLE_1gff2117f6f3c4ff8a2aa4ce48a0ff2070" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double fma ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span>, double <span> </span><span class="keyword keyword apiItemName">z</span> ) </span></dt>
<dd class="description">
<div class="section">Compute
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>×</mo>
<mi>y</mi>
<mo>+</mo>
<mi>z</mi>
</math>
as a single operation.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the rounded value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>×</mo>
<mi>y</mi>
<mo>+</mo>
<mi>z</mi>
</math>
as a single operation.
<ul>
<li>fma(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">z</tt>) returns NaN.
</li>
<li>fma(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">z</tt>) returns NaN.
</li>
<li>fma(<tt class="ph tt code">x</tt>, <tt class="ph tt code">y</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN if
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>×</mo>
<mi>y</mi>
</math>
is an exact
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>fma(<tt class="ph tt code">x</tt>, <tt class="ph tt code">y</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN if
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>×</mo>
<mi>y</mi>
</math>
is an exact
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Compute the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>×</mo>
<mi>y</mi>
<mo>+</mo>
<mi>z</mi>
</math>
as a single ternary operation. After computing the value to infinite precision, the value is rounded once.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g8f5b0627e6706e432728bd16cb326754" id="group__CUDA__MATH__DOUBLE_1g8f5b0627e6706e432728bd16cb326754" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double fmax ( double , double ) </span></dt>
<dd class="description">
<div class="section">Determine the maximum numeric value of the arguments. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the maximum numeric values of the arguments <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>.
<ul>
<li>If both arguments are NaN, returns NaN.</li>
<li>If one argument is NaN, returns the numeric argument.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Determines the maximum numeric value of the arguments <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>. Treats NaN arguments as missing data. If one argument is a NaN and the other is legitimate numeric value, the numeric value
is chosen.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gc970b9542e2d3e8e5d1e3ebb6a705dde" id="group__CUDA__MATH__DOUBLE_1gc970b9542e2d3e8e5d1e3ebb6a705dde" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double fmin ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Determine the minimum numeric value of the arguments. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the minimum numeric values of the arguments <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>.
<ul>
<li>If both arguments are NaN, returns NaN.</li>
<li>If one argument is NaN, returns the numeric argument.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Determines the minimum numeric value of the arguments <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt>. Treats NaN arguments as missing data. If one argument is a NaN and the other is legitimate numeric value, the numeric value
is chosen.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g5e4d96de745c62d885d0a3a6bc838b86" id="group__CUDA__MATH__DOUBLE_1g5e4d96de745c62d885d0a3a6bc838b86" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double fmod ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the floating-point remainder of <tt class="ph tt code">x</tt> / <tt class="ph tt code">y</tt>.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>Returns the floating point remainder of <tt class="ph tt code">x</tt> / <tt class="ph tt code">y</tt>.
</li>
<li>fmod(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">y</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
if <tt class="ph tt code">y</tt> is not zero.
</li>
<li>fmod(<tt class="ph tt code">x</tt>, <tt class="ph tt code">y</tt>) returns NaN and raised an invalid floating point exception if <tt class="ph tt code">x</tt> is
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
or <tt class="ph tt code">y</tt> is zero.
</li>
<li>fmod(<tt class="ph tt code">x</tt>, <tt class="ph tt code">y</tt>) returns zero if <tt class="ph tt code">y</tt> is zero or the result would overflow.
</li>
<li>fmod(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns <tt class="ph tt code">x</tt> if <tt class="ph tt code">x</tt> is finite.
</li>
<li>fmod(<tt class="ph tt code">x</tt>, 0) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the floating-point remainder of <tt class="ph tt code">x</tt> / <tt class="ph tt code">y</tt>. The absolute value of the computed value is always less than <tt class="ph tt code">y's</tt> absolute value and will have the same sign as <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gf83b8e238282287d560dd12e7531e89f" id="group__CUDA__MATH__DOUBLE_1gf83b8e238282287d560dd12e7531e89f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double frexp ( double <span> </span><span class="keyword keyword apiItemName">x</span>, int*<span> </span><span class="keyword keyword apiItemName">nptr</span> ) </span></dt>
<dd class="description">
<div class="section">Extract mantissa and exponent of a floating-point value. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the fractional component <tt class="ph tt code">m</tt>.
<ul>
<li>frexp(0, <tt class="ph tt code">nptr</tt>) returns 0 for the fractional component and zero for the integer component.
</li>
<li>frexp(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">nptr</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
and stores zero in the location pointed to by <tt class="ph tt code">nptr</tt>.
</li>
<li>frexp(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">nptr</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
and stores an unspecified value in the location to which <tt class="ph tt code">nptr</tt> points.
</li>
<li>frexp(NaN, <tt class="ph tt code">y</tt>) returns a NaN and stores an unspecified value in the location to which <tt class="ph tt code">nptr</tt> points.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Decompose the floating-point value <tt class="ph tt code">x</tt> into a component <tt class="ph tt code">m</tt> for the normalized fraction element and another term <tt class="ph tt code">n</tt> for the exponent. The absolute value of <tt class="ph tt code">m</tt> will be greater than or equal to 0.5 and less than 1.0 or it will be equal to 0;
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>=</mo>
<mi>m</mi>
<mo>⋅</mo>
<msup>
<mn>2</mn>
<mi>n</mi>
</msup>
</math>
. The integer exponent <tt class="ph tt code">n</tt> will be stored in the location to which <tt class="ph tt code">nptr</tt> points.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gc8fc174f8cc55bb32f1f6f12b4ff6c2e" id="group__CUDA__MATH__DOUBLE_1gc8fc174f8cc55bb32f1f6f12b4ff6c2e" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
_ACRTIMP double hypot ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the square root of the sum of squares of two arguments. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the length of the hypotenuse
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msqrt>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>y</mi>
<mn>2</mn>
</msup>
</msqrt>
</math>
. If the correct value would overflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
. If the correct value would underflow, returns 0.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the length of the hypotenuse of a right triangle whose two sides have lengths <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt> without undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g1085a209cbd5f56a4f2dbf1ba0f67be4" id="group__CUDA__MATH__DOUBLE_1g1085a209cbd5f56a4f2dbf1ba0f67be4" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
int ilogb ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Compute the unbiased integer exponent of the argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>If successful, returns the unbiased exponent of the argument.</li>
<li>ilogb(0) returns <tt class="ph tt code">INT_MIN</tt>.
</li>
<li>ilogb(NaN) returns NaN.</li>
<li>ilogb(<tt class="ph tt code">x</tt>) returns <tt class="ph tt code">INT_MAX</tt> if <tt class="ph tt code">x</tt> is
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi mathvariant="normal">∞</mi>
</math>
or the correct value is greater than <tt class="ph tt code">INT_MAX</tt>.
</li>
<li>ilogb(<tt class="ph tt code">x</tt>) return <tt class="ph tt code">INT_MIN</tt> if the correct value is less than <tt class="ph tt code">INT_MIN</tt>.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculates the unbiased integer exponent of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g366741a6f8e9847dd7268f4a005028ff" id="group__CUDA__MATH__DOUBLE_1g366741a6f8e9847dd7268f4a005028ff" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE isfinite ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="description">
<div class="section">Determine whether argument is finite. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>With Visual Studio 2013 host compiler: __RETURN_TYPE is 'bool'. Returns true if and only if <tt class="ph tt code">a</tt> is a finite value.
</li>
<li>With other host compilers: __RETURN_TYPE is 'int'. Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is a finite value.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Determine whether the floating-point value <tt class="ph tt code">a</tt> is a finite value (zero, subnormal, or normal and not infinity or NaN).
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gfe9aea186f33fb4f951f614ff2b53701" id="group__CUDA__MATH__DOUBLE_1gfe9aea186f33fb4f951f614ff2b53701" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE isinf ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="description">
<div class="section">Determine whether argument is infinite. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>With Visual Studio 2013 host compiler: Returns true if and only if <tt class="ph tt code">a</tt> is a infinite value.
</li>
<li>With other host compilers: Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is a infinite value.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Determine whether the floating-point value <tt class="ph tt code">a</tt> is an infinite value (positive or negative).
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g25649cf7c3d3c7a68423489532b8d459" id="group__CUDA__MATH__DOUBLE_1g25649cf7c3d3c7a68423489532b8d459" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE isnan ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="description">
<div class="section">Determine whether argument is a NaN. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>With Visual Studio 2013 host compiler: __RETURN_TYPE is 'bool'. Returns true if and only if <tt class="ph tt code">a</tt> is a NaN value.
</li>
<li>With other host compilers: __RETURN_TYPE is 'int'. Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is a NaN value.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Determine whether the floating-point value <tt class="ph tt code">a</tt> is a NaN.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g39cb9f4d5156e720837d77f518f2298a" id="group__CUDA__MATH__DOUBLE_1g39cb9f4d5156e720837d77f518f2298a" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double j0 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the Bessel function of the first kind of order 0 for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the Bessel function of the first kind of order 0.
<ul>
<li>j0(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>j0(NaN) returns NaN.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the Bessel function of the first kind of order 0 for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>J</mi>
<mn>0</mn>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g626a7fad13f7ab4e523e852e0686f6f3" id="group__CUDA__MATH__DOUBLE_1g626a7fad13f7ab4e523e852e0686f6f3" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double j1 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the Bessel function of the first kind of order 1 for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the Bessel function of the first kind of order 1.
<ul>
<li>j1(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>j1(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>j1(NaN) returns NaN.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the Bessel function of the first kind of order 1 for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>J</mi>
<mn>1</mn>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gd4c381147beb88bc72ca3952602de721" id="group__CUDA__MATH__DOUBLE_1gd4c381147beb88bc72ca3952602de721" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double jn ( int <span> </span><span class="keyword keyword apiItemName">n</span>, double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the Bessel function of the first kind of order n for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the Bessel function of the first kind of order <tt class="ph tt code">n</tt>.
<ul>
<li>jn(<tt class="ph tt code">n</tt>, NaN) returns NaN.
</li>
<li>jn(<tt class="ph tt code">n</tt>, <tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">n</tt> < 0.
</li>
<li>jn(<tt class="ph tt code">n</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the Bessel function of the first kind of order <tt class="ph tt code">n</tt> for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>J</mi>
<mi>n</mi>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g12ac38ace0d74cc339325e745cd281d5" id="group__CUDA__MATH__DOUBLE_1g12ac38ace0d74cc339325e745cd281d5" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double ldexp ( double <span> </span><span class="keyword keyword apiItemName">x</span>, int <span> </span><span class="keyword keyword apiItemName">exp</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>⋅</mo>
<msup>
<mn>2</mn>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
<mi>x</mi>
<mi>p</mi>
</mrow>
</msup>
</math>
.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>ldexp(<tt class="ph tt code">x</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
if the correctly calculated value is outside the double floating point range.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>x</mi>
<mo>⋅</mo>
<msup>
<mn>2</mn>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
<mi>x</mi>
<mi>p</mi>
</mrow>
</msup>
</math>
of the input arguments <tt class="ph tt code">x</tt> and <tt class="ph tt code">exp</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g402aaedc732b2eabf59abc07d744ed35" id="group__CUDA__MATH__DOUBLE_1g402aaedc732b2eabf59abc07d744ed35" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double lgamma ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the natural logarithm of the absolute value of the gamma function of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>lgamma(1) returns +0.</li>
<li>lgamma(2) returns +0.</li>
<li>lgamma(<tt class="ph tt code">x</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
if the correctly calculated value is outside the double floating point range.
</li>
<li>lgamma(<tt class="ph tt code">x</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
if <tt class="ph tt code">x</tt><math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>≤</mo>
</math>
0 and <tt class="ph tt code">x</tt> is an integer.
</li>
<li>lgamma(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>lgamma(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the natural logarithm of the absolute value of the gamma function of the input argument <tt class="ph tt code">x</tt>, namely the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>log</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
</mrow>
</msub>
<mfenced open="|" close="|">
<mrow>
<msubsup>
<mo>∫</mo>
<mrow class="MJX-TeXAtom-ORD">
<mn>0</mn>
</mrow>
<mrow class="MJX-TeXAtom-ORD">
<mi mathvariant="normal">∞</mi>
</mrow>
</msubsup>
<msup>
<mi>e</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>−</mo>
<mi>t</mi>
</mrow>
</msup>
<msup>
<mi>t</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>x</mi>
<mo>−</mo>
<mn>1</mn>
</mrow>
</msup>
<mi>d</mi>
<mi>t</mi>
</mrow>
</mfenced>
</math>
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g6d2532344fe30f7f8988e031aac8e1cd" id="group__CUDA__MATH__DOUBLE_1g6d2532344fe30f7f8988e031aac8e1cd" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long long int llrint ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round input to nearest integer value. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns rounded integer value. </p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round <tt class="ph tt code">x</tt> to the nearest integer value, with halfway cases rounded to the nearest even integer value. If the result is outside the
range of the return type, the result is undefined.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g6e401c3a6f291b874fc95b8480bcad02" id="group__CUDA__MATH__DOUBLE_1g6e401c3a6f291b874fc95b8480bcad02" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long long int llround ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round to nearest integer value. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns rounded integer value.</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round <tt class="ph tt code">x</tt> to the nearest integer value, with halfway cases rounded away from zero. If the result is outside the range of the return
type, the result is undefined.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">This function may be slower than alternate rounding methods. See <a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g6d2532344fe30f7f8988e031aac8e1cd" title="Round input to nearest integer value." shape="rect">llrint()</a>.
</p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g28ce8e15ef5149c271eba95663becba2" id="group__CUDA__MATH__DOUBLE_1g28ce8e15ef5149c271eba95663becba2" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double log ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
logarithm of the input argument.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>log(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>log(1) returns +0.</li>
<li>log(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>log(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the base
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>e</mi>
</math>
logarithm of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g0aed82d571362c58f9486385383e7f64" id="group__CUDA__MATH__DOUBLE_1g0aed82d571362c58f9486385383e7f64" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double log10 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the base 10 logarithm of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>log10(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>log10(1) returns +0.</li>
<li>log10(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>log10(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the base 10 logarithm of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g3c680d660d75780ef53075a439211626" id="group__CUDA__MATH__DOUBLE_1g3c680d660d75780ef53075a439211626" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double log1p ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>l</mi>
<mi>o</mi>
<msub>
<mi>g</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
</mrow>
</msub>
<mo stretchy="false">(</mo>
<mn>1</mn>
<mo>+</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>log1p(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>log1p(-1) returns +0.</li>
<li>log1p(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < -1.
</li>
<li>log1p(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>l</mi>
<mi>o</mi>
<msub>
<mi>g</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
</mrow>
</msub>
<mo stretchy="false">(</mo>
<mn>1</mn>
<mo>+</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gc15d49c9960470b4791eafa0607ca777" id="group__CUDA__MATH__DOUBLE_1gc15d49c9960470b4791eafa0607ca777" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double log2 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the base 2 logarithm of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>log2(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>log2(1) returns +0.</li>
<li>log2(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>log2(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the base 2 logarithm of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g24e6d5c7904a61d50055d27ffe6d8fdb" id="group__CUDA__MATH__DOUBLE_1g24e6d5c7904a61d50055d27ffe6d8fdb" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double logb ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the floating point representation of the exponent of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>logb
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
</li>
<li>logb
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the floating point representation of the exponent of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g353f5748b7addbae162dd679abf829fe" id="group__CUDA__MATH__DOUBLE_1g353f5748b7addbae162dd679abf829fe" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long int lrint ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round input to nearest integer value. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns rounded integer value. </p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round <tt class="ph tt code">x</tt> to the nearest integer value, with halfway cases rounded to the nearest even integer value. If the result is outside the
range of the return type, the result is undefined.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g9fdb5ef303c94dc5c428dbdb534ed1fd" id="group__CUDA__MATH__DOUBLE_1g9fdb5ef303c94dc5c428dbdb534ed1fd" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long int lround ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round to nearest integer value. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns rounded integer value.</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round <tt class="ph tt code">x</tt> to the nearest integer value, with halfway cases rounded away from zero. If the result is outside the range of the return
type, the result is undefined.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">This function may be slower than alternate rounding methods. See <a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g353f5748b7addbae162dd679abf829fe" title="Round input to nearest integer value." shape="rect">lrint()</a>.
</p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gf66b786e19d90c6c519ce7b80afa97bf" id="group__CUDA__MATH__DOUBLE_1gf66b786e19d90c6c519ce7b80afa97bf" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double modf ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double*<span> </span><span class="keyword keyword apiItemName">iptr</span> ) </span></dt>
<dd class="description">
<div class="section">Break down the input argument into fractional and integral parts. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>modf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi>x</mi>
</math>
, <tt class="ph tt code">iptr</tt>) returns a result with the same sign as <tt class="ph tt code">x</tt>.
</li>
<li>modf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">iptr</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
and stores
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
in the object pointed to by <tt class="ph tt code">iptr</tt>.
</li>
<li>modf(NaN, <tt class="ph tt code">iptr</tt>) stores a NaN in the object pointed to by <tt class="ph tt code">iptr</tt> and returns a NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Break down the argument <tt class="ph tt code">x</tt> into fractional and integral parts. The integral part is stored in the argument <tt class="ph tt code">iptr</tt>. Fractional and integral parts are given the same sign as the argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g6df5511321a5ac0dfe22389b728a8a9f" id="group__CUDA__MATH__DOUBLE_1g6df5511321a5ac0dfe22389b728a8a9f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double nan ( const char*<span> </span><span class="keyword keyword apiItemName">tagp</span> ) </span></dt>
<dd class="description">
<div class="section">Returns "Not a Number" value. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>nan(<tt class="ph tt code">tagp</tt>) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Return a representation of a quiet NaN. Argument <tt class="ph tt code">tagp</tt> selects one of the possible representations.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g2316a104cfda8362208d52238181fbfb" id="group__CUDA__MATH__DOUBLE_1g2316a104cfda8362208d52238181fbfb" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double nearbyint ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round the input argument to the nearest integer. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>nearbyint(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>nearbyint(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round argument <tt class="ph tt code">x</tt> to an integer value in double precision floating-point format.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gf46b3ad97567ae96f7148a10537c8f5a" id="group__CUDA__MATH__DOUBLE_1gf46b3ad97567ae96f7148a10537c8f5a" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double nextafter ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Return next representable double-precision floating-point value after argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>nextafter(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the next representable double-precision floating-point value following <tt class="ph tt code">x</tt> in the direction of <tt class="ph tt code">y</tt>. For example, if <tt class="ph tt code">y</tt> is greater than <tt class="ph tt code">x</tt>, <a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1gf46b3ad97567ae96f7148a10537c8f5a" title="Return next representable double-precision floating-point value after argument." shape="rect">nextafter()</a> returns the smallest representable number greater than <tt class="ph tt code">x</tt></p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g7c5ebbdd1d0300094d9e34fbe5218a75" id="group__CUDA__MATH__DOUBLE_1g7c5ebbdd1d0300094d9e34fbe5218a75" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double norm ( int <span> </span><span class="keyword keyword apiItemName">dim</span>, const double*<span> </span><span class="keyword keyword apiItemName">t</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the square root of the sum of squares of any number of coordinates. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the length of the dim-D vector
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msqrt>
<msup>
<mi>p.1</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.2</mi>
<mn>2</mn>
</msup>
<mo>+ ... +</mo>
<msup>
<mi>p.dim</mi>
<mn>2</mn>
</msup>
</msqrt>
</math>
. If the correct value would overflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
. If the correct value would underflow, returns 0. If two of the input arguments is 0, returns remaining argument
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the length of a vector p, dimension of which is passed as an argument <tt class="ph tt code">without</tt> undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g0f1beab2ceb43c190bbdd53073481a87" id="group__CUDA__MATH__DOUBLE_1g0f1beab2ceb43c190bbdd53073481a87" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double norm3d ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the square root of the sum of squares of three coordinates of the argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the length of 3D vector
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msqrt>
<msup>
<mi>p.x</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.y</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.z</mi>
<mn>2</mn>
</msup>
</msqrt>
</math>
. If the correct value would overflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
. If the correct value would underflow, returns 0.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the length of three dimensional vector <tt class="ph tt code">p</tt> in euclidean space without undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g22d61aa6b93f5943c4d35a3545aace18" id="group__CUDA__MATH__DOUBLE_1g22d61aa6b93f5943c4d35a3545aace18" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double norm4d ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span>, double <span> </span><span class="keyword keyword apiItemName">d</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the square root of the sum of squares of four coordinates of the argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the length of 4D vector
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msqrt>
<msup>
<mi>p.x</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.y</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.z</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.t</mi>
<mn>2</mn>
</msup>
</msqrt>
</math>
. If the correct value would overflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
. If the correct value would underflow, returns 0.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the length of four dimensional vector <tt class="ph tt code">p</tt> in euclidean space without undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g8368e3ba7981942344d0be3b5d817e3f" id="group__CUDA__MATH__DOUBLE_1g8368e3ba7981942344d0be3b5d817e3f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double normcdf ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the standard normal cumulative distribution function. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>normcdf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns 1
</li>
<li>normcdf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the cumulative distribution function of the standard normal distribution for input argument <tt class="ph tt code">y</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi mathvariant="normal">Φ</mi>
<mo stretchy="false">(</mo>
<mi>y</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g78e93df6c3fbade8628d33e11fc94595" id="group__CUDA__MATH__DOUBLE_1g78e93df6c3fbade8628d33e11fc94595" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double normcdfinv ( double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the inverse of the standard normal cumulative distribution function. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>normcdfinv(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>normcdfinv(1) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>normcdfinv(<tt class="ph tt code">x</tt>) returns NaN if <tt class="ph tt code">x</tt> is not in the interval [0,1].
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the inverse of the standard normal cumulative distribution function for input argument <tt class="ph tt code">y</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mi mathvariant="normal">Φ</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>−</mo>
<mn>1</mn>
</mrow>
</msup>
<mo stretchy="false">(</mo>
<mi>y</mi>
<mo stretchy="false">)</mo>
</math>
. The function is defined for input values in the interval
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo stretchy="false">(</mo>
<mn>0</mn>
<mo>,</mo>
<mn>1</mn>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g6d36757715384dc18e0483aa1f04f6c7" id="group__CUDA__MATH__DOUBLE_1g6d36757715384dc18e0483aa1f04f6c7" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double pow ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of first argument to the power of second argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">y</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
for <tt class="ph tt code">y</tt> an integer less than 0.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">y</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
for <tt class="ph tt code">y</tt> an odd integer greater than 0.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">y</tt>) returns +0 for <tt class="ph tt code">y</tt> > 0 and not and odd integer.
</li>
<li>pow(-1,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns 1.
</li>
<li>pow(+1, <tt class="ph tt code">y</tt>) returns 1 for any <tt class="ph tt code">y</tt>, even a NaN.
</li>
<li>pow(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns 1 for any <tt class="ph tt code">x</tt>, even a NaN.
</li>
<li>pow(<tt class="ph tt code">x</tt>, <tt class="ph tt code">y</tt>) returns a NaN for finite <tt class="ph tt code">x</tt> < 0 and finite non-integer <tt class="ph tt code">y</tt>.
</li>
<li>pow(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
for
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo><</mo>
<mn>1</mn>
</math>
.
</li>
<li>pow(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0 for
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo>></mo>
<mn>1</mn>
</math>
.
</li>
<li>pow(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0 for
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo><</mo>
<mn>1</mn>
</math>
.
</li>
<li>pow(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
for
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo>></mo>
<mn>1</mn>
</math>
.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns -0 for <tt class="ph tt code">y</tt> an odd integer less than 0.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns +0 for <tt class="ph tt code">y</tt> < 0 and not an odd integer.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
for <tt class="ph tt code">y</tt> an odd integer greater than 0.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
for <tt class="ph tt code">y</tt> > 0 and not an odd integer.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns +0 for <tt class="ph tt code">y</tt> < 0.
</li>
<li>pow(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
for <tt class="ph tt code">y</tt> > 0.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of <tt class="ph tt code">x</tt> to the power of <tt class="ph tt code">y</tt></p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g3f5dd3f9b81f73c644d82754986ccce6" id="group__CUDA__MATH__DOUBLE_1g3f5dd3f9b81f73c644d82754986ccce6" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double rcbrt ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate reciprocal cube root function. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>rcbrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>rcbrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate reciprocal cube root function of <tt class="ph tt code">x</tt></p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g852e83c233f09c146c492bfd752e0dd2" id="group__CUDA__MATH__DOUBLE_1g852e83c233f09c146c492bfd752e0dd2" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double remainder ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Compute double-precision floating-point remainder. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>remainder(<tt class="ph tt code">x</tt>, 0) returns NaN.
</li>
<li>remainder(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>) returns NaN.
</li>
<li>remainder(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns <tt class="ph tt code">x</tt> for finite <tt class="ph tt code">x</tt>.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Compute double-precision floating-point remainder <tt class="ph tt code">r</tt> of dividing <tt class="ph tt code">x</tt> by <tt class="ph tt code">y</tt> for nonzero <tt class="ph tt code">y</tt>. Thus
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>r</mi>
<mo>=</mo>
<mi>x</mi>
<mo>−</mo>
<mi>n</mi>
<mi>y</mi>
</math>
. The value <tt class="ph tt code">n</tt> is the integer value nearest
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mfrac>
<mi>x</mi>
<mi>y</mi>
</mfrac>
</math>
. In the case when
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>n</mi>
<mo>−</mo>
<mfrac>
<mi>x</mi>
<mi>y</mi>
</mfrac>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo>=</mo>
<mfrac>
<mn>1</mn>
<mn>2</mn>
</mfrac>
</math>
, the even <tt class="ph tt code">n</tt> value is chosen.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g4235a6814bb94b3faaf73a324210c58d" id="group__CUDA__MATH__DOUBLE_1g4235a6814bb94b3faaf73a324210c58d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double remquo ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span>, int*<span> </span><span class="keyword keyword apiItemName">quo</span> ) </span></dt>
<dd class="description">
<div class="section">Compute double-precision floating-point remainder and part of quotient. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the remainder.
<ul>
<li>remquo(<tt class="ph tt code">x</tt>, 0, <tt class="ph tt code">quo</tt>) returns NaN.
</li>
<li>remquo(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">y</tt>, <tt class="ph tt code">quo</tt>) returns NaN.
</li>
<li>remquo(<tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">quo</tt>) returns <tt class="ph tt code">x</tt>.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Compute a double-precision floating-point remainder in the same way as the <a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g852e83c233f09c146c492bfd752e0dd2" title="Compute double-precision floating-point remainder." shape="rect">remainder()</a> function. Argument <tt class="ph tt code">quo</tt> returns part of quotient upon division of <tt class="ph tt code">x</tt> by <tt class="ph tt code">y</tt>. Value <tt class="ph tt code">quo</tt> has the same sign as
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mfrac>
<mi>x</mi>
<mi>y</mi>
</mfrac>
</math>
and may not be the exact quotient but agrees with the exact quotient in the low order 3 bits.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gf1dfb4d01feaa01b0b1ff15cf57ebbc3" id="group__CUDA__MATH__DOUBLE_1gf1dfb4d01feaa01b0b1ff15cf57ebbc3" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double rhypot ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate one over the square root of the sum of squares of two arguments. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns one over the length of the hypotenuse
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mfrac>
<mrow>
<mi>1</mi>
</mrow>
<mrow>
<msqrt>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>y</mi>
<mn>2</mn>
</msup>
</msqrt>
</mrow>
</mfrac>
</math>
. If the square root would overflow, returns 0. If the square root would underflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate one over the length of the hypotenuse of a right triangle whose two sides have lengths <tt class="ph tt code">x</tt> and <tt class="ph tt code">y</tt> without undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g3b8026edb2f2e441669845f0f3fa3bf7" id="group__CUDA__MATH__DOUBLE_1g3b8026edb2f2e441669845f0f3fa3bf7" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double rint ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round to nearest integer value in floating-point. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns rounded integer value. </p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round <tt class="ph tt code">x</tt> to the nearest integer value in floating-point format, with halfway cases rounded to the nearest even integer value.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g3d2150666773f15337b09aa7e1662e59" id="group__CUDA__MATH__DOUBLE_1g3d2150666773f15337b09aa7e1662e59" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double rnorm ( int <span> </span><span class="keyword keyword apiItemName">dim</span>, const double*<span> </span><span class="keyword keyword apiItemName">t</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the reciprocal of square root of the sum of squares of any number of coordinates. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns one over the length of the vector
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mfrac>
<mrow>
<mi>1</mi>
</mrow>
<mrow>
<msqrt>
<msup>
<mi>p.1</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.2</mi>
<mn>2</mn>
</msup>
<mo>+ ... +</mo>
<msup>
<mi>p.dim</mi>
<mn>2</mn>
</msup>
</msqrt>
</mrow>
</mfrac>
</math>
. If the square root would overflow, returns 0. If the square root would underflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculates one over the length of vector <tt class="ph tt code">p</tt>, dimension of which is passed as an agument, in euclidean space without undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g1ac4eff7fecc1121d5dcfdebc3314e80" id="group__CUDA__MATH__DOUBLE_1g1ac4eff7fecc1121d5dcfdebc3314e80" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double rnorm3d ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate one over the square root of the sum of squares of three coordinates of the argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns one over the length of the 3D vetor
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mfrac>
<mrow>
<mi>1</mi>
</mrow>
<mrow>
<msqrt>
<msup>
<mi>p.x</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.y</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.z</mi>
<mn>2</mn>
</msup>
</msqrt>
</mrow>
</mfrac>
</math>
. If the square root would overflow, returns 0. If the square root would underflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate one over the length of three dimensional vector <tt class="ph tt code">p</tt> in euclidean space undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g039d37d2d8d44f074e057489a439a758" id="group__CUDA__MATH__DOUBLE_1g039d37d2d8d44f074e057489a439a758" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double rnorm4d ( double <span> </span><span class="keyword keyword apiItemName">a</span>, double <span> </span><span class="keyword keyword apiItemName">b</span>, double <span> </span><span class="keyword keyword apiItemName">c</span>, double <span> </span><span class="keyword keyword apiItemName">d</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate one over the square root of the sum of squares of four coordinates of the argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns one over the length of the 3D vetor
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mfrac>
<mrow>
<mi>1</mi>
</mrow>
<mrow>
<msqrt>
<msup>
<mi>p.x</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.y</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.z</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>p.t</mi>
<mn>2</mn>
</msup>
</msqrt>
</mrow>
</mfrac>
</math>
. If the square root would overflow, returns 0. If the square root would underflow, returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate one over the length of four dimensional vector <tt class="ph tt code">p</tt> in euclidean space undue overflow or underflow.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gbefba28ee84ef32c44d417cfd4f615d4" id="group__CUDA__MATH__DOUBLE_1gbefba28ee84ef32c44d417cfd4f615d4" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double round ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round to nearest integer value in floating-point. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns rounded integer value.</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round <tt class="ph tt code">x</tt> to the nearest integer value in floating-point format, with halfway cases rounded away from zero.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">This function may be slower than alternate rounding methods. See <a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g3b8026edb2f2e441669845f0f3fa3bf7" title="Round to nearest integer value in floating-point." shape="rect">rint()</a>.
</p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gf799c5cd74e63236a4a08296cb12ccbc" id="group__CUDA__MATH__DOUBLE_1gf799c5cd74e63236a4a08296cb12ccbc" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double rsqrt ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the reciprocal of the square root of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mn>1</mn>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<msqrt>
<mi>x</mi>
</msqrt>
</math>
.
<ul>
<li>rsqrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>rsqrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>rsqrt(<tt class="ph tt code">x</tt>) returns NaN if <tt class="ph tt code">x</tt> is less than 0.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the reciprocal of the nonnegative square root of <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mn>1</mn>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<msqrt>
<mi>x</mi>
</msqrt>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g7c931cea8bc2cfe694a6170379e5914f" id="group__CUDA__MATH__DOUBLE_1g7c931cea8bc2cfe694a6170379e5914f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double scalbln ( double <span> </span><span class="keyword keyword apiItemName">x</span>, long int <span> </span><span class="keyword keyword apiItemName">n</span> ) </span></dt>
<dd class="description">
<div class="section">Scale floating-point input by integer power of two. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns <tt class="ph tt code">x</tt> *
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mn>2</mn>
<mi>n</mi>
</msup>
</math>
.
<ul>
<li>scalbln(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">n</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>scalbln(<tt class="ph tt code">x</tt>, 0) returns <tt class="ph tt code">x</tt>.
</li>
<li>scalbln(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">n</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Scale <tt class="ph tt code">x</tt> by
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mn>2</mn>
<mi>n</mi>
</msup>
</math>
by efficient manipulation of the floating-point exponent.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g4923bed52b438e5bfbf574bb8ce26542" id="group__CUDA__MATH__DOUBLE_1g4923bed52b438e5bfbf574bb8ce26542" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double scalbn ( double <span> </span><span class="keyword keyword apiItemName">x</span>, int <span> </span><span class="keyword keyword apiItemName">n</span> ) </span></dt>
<dd class="description">
<div class="section">Scale floating-point input by integer power of two. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns <tt class="ph tt code">x</tt> *
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mn>2</mn>
<mi>n</mi>
</msup>
</math>
.
<ul>
<li>scalbn(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
, <tt class="ph tt code">n</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>scalbn(<tt class="ph tt code">x</tt>, 0) returns <tt class="ph tt code">x</tt>.
</li>
<li>scalbn(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
, <tt class="ph tt code">n</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Scale <tt class="ph tt code">x</tt> by
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mn>2</mn>
<mi>n</mi>
</msup>
</math>
by efficient manipulation of the floating-point exponent.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g2bd7d6942a8b25ae518636dab9ad78a7" id="group__CUDA__MATH__DOUBLE_1g2bd7d6942a8b25ae518636dab9ad78a7" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__RETURN_TYPE signbit ( double <span> </span><span class="keyword keyword apiItemName">a</span> ) </span></dt>
<dd class="description">
<div class="section">Return the sign bit of the input. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Reports the sign bit of all values including infinities, zeros, and NaNs.
<ul>
<li>With Visual Studio 2013 host compiler: __RETURN_TYPE is 'bool'. Returns true if and only if <tt class="ph tt code">a</tt> is negative.
</li>
<li>With other host compilers: __RETURN_TYPE is 'int'. Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is negative.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Determine whether the floating-point value <tt class="ph tt code">a</tt> is negative.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g3ebbca20a2937d1fe51329402880df85" id="group__CUDA__MATH__DOUBLE_1g3ebbca20a2937d1fe51329402880df85" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double sin ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the sine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>sin(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>sin(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the sine of the input argument <tt class="ph tt code">x</tt> (measured in radians).
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gbe0e6a063a8f38850b0323933cf3320b" id="group__CUDA__MATH__DOUBLE_1gbe0e6a063a8f38850b0323933cf3320b" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
void sincos ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double*<span> </span><span class="keyword keyword apiItemName">sptr</span>, double*<span> </span><span class="keyword keyword apiItemName">cptr</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the sine and cosine of the first input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>none</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the sine and cosine of the first input argument <tt class="ph tt code">x</tt> (measured in radians). The results for sine and cosine are written into the second argument, <tt class="ph tt code">sptr</tt>, and, respectively, third argument, <tt class="ph tt code">cptr</tt>.
</p>
<p class="p"></p>
<p class="p apiDesc_subtitle"><strong class="ph b">See also:</strong></p>
<p class="p see_subsection"><a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g3ebbca20a2937d1fe51329402880df85" title="Calculate the sine of the input argument." shape="rect">sin()</a> and <a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g3f1d2831497e6fa3f0072395e13a8ecf" title="Calculate the cosine of the input argument." shape="rect">cos()</a>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gfc99d7acfc1b14dcb6f6db56147d2560" id="group__CUDA__MATH__DOUBLE_1gfc99d7acfc1b14dcb6f6db56147d2560" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
void sincospi ( double <span> </span><span class="keyword keyword apiItemName">x</span>, double*<span> </span><span class="keyword keyword apiItemName">sptr</span>, double*<span> </span><span class="keyword keyword apiItemName">cptr</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the sine and cosine of the first input argument
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>none</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the sine and cosine of the first input argument, <tt class="ph tt code">x</tt> (measured in radians),
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
. The results for sine and cosine are written into the second argument, <tt class="ph tt code">sptr</tt>, and, respectively, third argument, <tt class="ph tt code">cptr</tt>.
</p>
<p class="p"></p>
<p class="p apiDesc_subtitle"><strong class="ph b">See also:</strong></p>
<p class="p see_subsection"><a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g06ae86e791c45c081184e605f984e733" title="Calculate the sine of the input argument ." shape="rect">sinpi()</a> and <a class="xref" href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE_1g0b7c24b9064401951cb1e66a23b44a4b" title="Calculate the cosine of the input argument ." shape="rect">cospi()</a>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gabc5c0e23e1550a6cc936baa9d65a61a" id="group__CUDA__MATH__DOUBLE_1gabc5c0e23e1550a6cc936baa9d65a61a" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double sinh ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the hyperbolic sine of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>sinh(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the hyperbolic sine of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g06ae86e791c45c081184e605f984e733" id="group__CUDA__MATH__DOUBLE_1g06ae86e791c45c081184e605f984e733" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double sinpi ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the sine of the input argument
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
.
</div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>sinpi(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>sinpi(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the sine of <tt class="ph tt code">x</tt><math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>×</mo>
<mi>π</mi>
</math>
(measured in radians), where <tt class="ph tt code">x</tt> is the input argument.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g1c6fe34b4ac091e40eceeb0bae58459f" id="group__CUDA__MATH__DOUBLE_1g1c6fe34b4ac091e40eceeb0bae58459f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double sqrt ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the square root of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msqrt>
<mi>x</mi>
</msqrt>
</math>
.
<ul>
<li>sqrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>sqrt(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>sqrt(<tt class="ph tt code">x</tt>) returns NaN if <tt class="ph tt code">x</tt> is less than 0.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the nonnegative square root of <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msqrt>
<mi>x</mi>
</msqrt>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g17d00b521d79b4a4404cc593839f0b7b" id="group__CUDA__MATH__DOUBLE_1g17d00b521d79b4a4404cc593839f0b7b" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double tan ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the tangent of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>tan(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
<li>tan(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the tangent of the input argument <tt class="ph tt code">x</tt> (measured in radians).
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gdf7b9660a2c53c91664263d39b09242d" id="group__CUDA__MATH__DOUBLE_1gdf7b9660a2c53c91664263d39b09242d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double tanh ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the hyperbolic tangent of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>tanh(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the hyperbolic tangent of the input argument <tt class="ph tt code">x</tt>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gecfb49e21fc767c952827d42268c0d48" id="group__CUDA__MATH__DOUBLE_1gecfb49e21fc767c952827d42268c0d48" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double tgamma ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the gamma function of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>tgamma(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>tgamma(2) returns +1.</li>
<li>tgamma(<tt class="ph tt code">x</tt>) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
if the correctly calculated value is outside the double floating point range.
</li>
<li>tgamma(<tt class="ph tt code">x</tt>) returns NaN if <tt class="ph tt code">x</tt> < 0 and <tt class="ph tt code">x</tt> is an integer.
</li>
<li>tgamma(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN.
</li>
<li>tgamma(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the gamma function of the input argument <tt class="ph tt code">x</tt>, namely the value of
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msubsup>
<mo>∫</mo>
<mrow class="MJX-TeXAtom-ORD">
<mn>0</mn>
</mrow>
<mrow class="MJX-TeXAtom-ORD">
<mi mathvariant="normal">∞</mi>
</mrow>
</msubsup>
<msup>
<mi>e</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>−</mo>
<mi>t</mi>
</mrow>
</msup>
<msup>
<mi>t</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>x</mi>
<mo>−</mo>
<mn>1</mn>
</mrow>
</msup>
<mi>d</mi>
<mi>t</mi>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1gaa2c1b49a1f4aa25f8ce49236089f2a8" id="group__CUDA__MATH__DOUBLE_1gaa2c1b49a1f4aa25f8ce49236089f2a8" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
double trunc ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Truncate input argument to the integral part. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns truncated integer value. </p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Round <tt class="ph tt code">x</tt> to the nearest integer value that does not exceed <tt class="ph tt code">x</tt> in magnitude.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g7eab7eb6999bde9057f22e36e7db95d4" id="group__CUDA__MATH__DOUBLE_1g7eab7eb6999bde9057f22e36e7db95d4" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double y0 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the Bessel function of the second kind of order 0 for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the Bessel function of the second kind of order 0.
<ul>
<li>y0(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>y0(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>y0(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>y0(NaN) returns NaN.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the Bessel function of the second kind of order 0 for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>Y</mi>
<mn>0</mn>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g2560f5508d3aaec918ed7e94e96a6180" id="group__CUDA__MATH__DOUBLE_1g2560f5508d3aaec918ed7e94e96a6180" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double y1 ( double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the Bessel function of the second kind of order 1 for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the Bessel function of the second kind of order 1.
<ul>
<li>y1(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>y1(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>y1(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>y1(NaN) returns NaN.</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the Bessel function of the second kind of order 1 for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>Y</mi>
<mn>1</mn>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__DOUBLE_1g01b473912d10252607be1870b1b2660d" id="group__CUDA__MATH__DOUBLE_1g01b473912d10252607be1870b1b2660d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
__CUDA_MATH_CRTIMP double yn ( int <span> </span><span class="keyword keyword apiItemName">n</span>, double <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the value of the Bessel function of the second kind of order n for the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the value of the Bessel function of the second kind of order <tt class="ph tt code">n</tt>.
<ul>
<li>yn(<tt class="ph tt code">n</tt>, <tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">n</tt> < 0.
</li>
<li>yn(<tt class="ph tt code">n</tt>, 0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>yn(<tt class="ph tt code">n</tt>, <tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>yn(<tt class="ph tt code">n</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>yn(<tt class="ph tt code">n</tt>, NaN) returns NaN.
</li>
</ul>
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Calculate the value of the Bessel function of the second kind of order <tt class="ph tt code">n</tt> for the input argument <tt class="ph tt code">x</tt>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub>
<mi>Y</mi>
<mi>n</mi>
</msub>
<mo stretchy="false">(</mo>
<mi>x</mi>
<mo stretchy="false">)</mo>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix D.1, Table 7. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
</dl>
</div>
</div>
<hr id="contents-end"></hr>
</article>
</div>
</div>
<script language="JavaScript" type="text/javascript" charset="utf-8" src="../common/formatting/common.min.js"></script>
<script language="JavaScript" type="text/javascript" charset="utf-8" src="../common/scripts/google-analytics/google-analytics-write.js"></script>
<script language="JavaScript" type="text/javascript" charset="utf-8" src="../common/scripts/google-analytics/google-analytics-tracker.js"></script>
<script type="text/javascript">var switchTo5x=true;</script><script type="text/javascript" src="http://w.sharethis.com/button/buttons.js"></script><script type="text/javascript">stLight.options({publisher: "998dc202-a267-4d8e-bce9-14debadb8d92", doNotHash: false, doNotCopy: false, hashAddressBar: false});</script><script type="text/javascript">_satellite.pageBottom();</script></body>
</html>
distrib
>
Mageia
>
7
>
x86_64
>
media
>
nonfree-updates
>
by-pkgid
>
b86a85131cc739c1c53d0b55840a4328
>
files
>
1458
