<!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="Single 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__SINGLE"></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="../common/formatting/jquery.min.js"></script>
<script type="text/javascript" charset="utf-8" src="../common/formatting/jquery.ba-hashchange.min.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>
<article id="contents">
<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="eqn-warning-buf"></div>
<div id="breadcrumbs"><a href="group__CUDA__MATH.html" shape="rect">< Previous</a> | <a href="group__CUDA__MATH__DOUBLE.html" shape="rect">Next ></a></div>
<div id="release-info">CUDA Math API
(<a href="../../pdf/CUDA_Math_API.pdf">PDF</a>)
-
CUDA Toolkit v5.5
(<a href="https://developer.nvidia.com/cuda-toolkit-archive">older</a>)
-
Last updated
July 19, 2013
-
<a href="mailto:cudatools@nvidia.com?subject=CUDA Tools Documentation Feedback: cuda-math-api">Send Feedback</a></div>
<div class="topic reference apiRef apiPackage cppModule" id="group__CUDA__MATH__SINGLE"><a name="group__CUDA__MATH__SINGLE" shape="rect">
<!-- --></a><h2 class="topictitle2 cppModule">1.2. Single Precision Mathematical Functions</h2>
<div class="section">
<p>This section describes single precision mathematical functions. </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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g63d1c22538561dc228fc230d10d85dca" shape="rect">acosf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gb0f45cada398311319b50a00ff7e826e" shape="rect">acoshf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g82b2bb388724796ae8a30069abb3b386" shape="rect">asinf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g74d4dabb94aa5c77ce31fd0ea987c083" shape="rect">asinhf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gd89b766e91b1c84f2e8e81beb750707d" shape="rect">atan2f</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g82629bb4eec2d8c9c95b9c69188beff9" shape="rect">atanf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g1b176d9d72adbf998b1960f830ad9dcc" shape="rect">atanhf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g96d2384128af36ea9cb9b20d366900c7" shape="rect">cbrtf</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g43a6f3aa4ccdb026b038a3fe9a80f65d" shape="rect">ceilf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gf624240731f96c35e2bbf9aaa9217ad6" shape="rect">copysignf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g20858ddd8f75a2c8332bdecd536057bf" shape="rect">cosf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g34a53cc088d117bc7045caa111279799" shape="rect">coshf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g6fc515121cf408a92ef611a3c6fdc5cc" shape="rect">cospif</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g31faaaeab2a785191c3e0e66e030ceca" shape="rect">erfcf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g2bae6c7d986e0ab7e5cf685ac8b7236c" shape="rect">erfcinvf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gec797649c94f21aecb8dc033a7b97353" shape="rect">erfcxf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g3b8115ff34a107f4608152fd943dbf81" shape="rect">erff</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g0f3b173d8ba48cd495cc9c37e1f5ed4d" shape="rect">erfinvf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g60f1de4fe78a907d915a52be29a799e7" shape="rect">exp10f</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g3e2984de99de67ca680c9bb4f4427f81" shape="rect">exp2f</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1ge2d7656fe00f9e750c6f3bde8cc0dca6" shape="rect">expf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g832817212e7b0debe05d23ea37bdd748" shape="rect">expm1f</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gb00f8593e1bfb1985526020fbec4e0fc" shape="rect">fabsf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Calculate the absolute value of its argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g13959e5ca19c910e0d6f8e6ca5492149" shape="rect">fdimf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g26852224a1347ee9b5edee12c869d206" shape="rect">fdividef</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Divide two floating point values. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gdbff62f4c1647b9694f35d053eff5288" shape="rect">floorf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g5910ee832dab4f5d37118e0a6811c195" shape="rect">fmaf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span>, float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g6e7516db46be25c33fb26e203287f2a3" shape="rect">fmaxf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gbf48322ad520d7b12542edf990dde8c0" shape="rect">fminf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g9255f64a2585463fea365c8273d23904" shape="rect">fmodf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g56e8cba742e2f80647903dac9c93eb37" shape="rect">frexpf</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g2880a4ebf5500aeb74fb01340ea91215" shape="rect">hypotf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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__SINGLE_1g4e9bcb254b97eb63abf3092233464131" shape="rect">ilogbf</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
int </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gb8b25d1859c58659aa30c4c0ac246e42" shape="rect">isfinite</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
int </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g8cfb9bd373d33c3a5bca35363e730c05" shape="rect">isinf</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
int </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g7754b0a95fed7553a58bd63d29946647" shape="rect">isnan</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gba3e4bad4109f5e8509dc1925fade7ce" shape="rect">j0f</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g462954bfc6ada6132f28bd7fce41334e" shape="rect">j1f</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gdcd52a43c4f2d8d9148a022d6d6851dd" shape="rect">jnf</a> ( int <span> </span><span class="keyword keyword apiItemName">n</span>, float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g7d82accff3d8e3307d61e028c19c30cd" shape="rect">ldexpf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gf7ffab2d685130195ba255e954e21130" shape="rect">lgammaf</a> ( float <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__SINGLE_1g7d4af230b5deee73fbfa9801f44f0616" shape="rect">llrintf</a> ( float <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__SINGLE_1gf2a7fe8fb57e5b39886d776f75fdf5d6" shape="rect">llroundf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gb49e218cf742a0eb08e5516dd5160585" shape="rect">log10f</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g9d53128ab5f7d6ebc4798f243481a6d7" shape="rect">log1pf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gfc9ae1bd4ebb4cd9533a50f1bf486f08" shape="rect">log2f</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g9a86f57d529d7000b04cb30e859a21b7" shape="rect">logbf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gcdaf041c4071f63cba0e51658b89ffa4" shape="rect">logf</a> ( float <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 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__SINGLE_1g639a876a55da8142dcd917ce6c12c27d" shape="rect">lrintf</a> ( float <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__SINGLE_1g4d10236b2afbafda2fd85825811b84e3" shape="rect">lroundf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g7c49d2e467f6ca3cfc0362d84bb474ab" shape="rect">modff</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float*<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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g372c640f910303dc4a7f17ce684322c5" shape="rect">nanf</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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g53c10d923def0d85af5a2b65b1a021f0" shape="rect">nearbyintf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g997fc003282f27b1c02c8a44fb4189f0" shape="rect">nextafterf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Return next representable single-precision floating-point value afer argument. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g102ea4753919ee208c9b294e1c053cf1" shape="rect">normcdff</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g1c0a28ad7f7555ab16e0a1e409690174" shape="rect">normcdfinvf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gb519b517c0036b3604d602f716a919dd" shape="rect">powf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g937164a0d40347821ad16b5cb5069c92" shape="rect">rcbrtf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g36179ffa51305653b55c1e76f44154ff" shape="rect">remainderf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="shortdesc"><span></span><span class="desc">Compute single-precision floating-point remainder. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1ga0d8ebba46ca705859d1c7462b53118d" shape="rect">remquof</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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 single-precision floating-point remainder and part of quotient. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g7791cd93108ffc6d24524f2e8635ccfd" shape="rect">rintf</a> ( float <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 in floating-point. </span></dd>
<dt><span class="member_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1ga1c1521079e51b4f54771b16a7f8aeea" shape="rect">roundf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g5a9bc318028131cfd13d10abfae1ae13" shape="rect">rsqrtf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gc94fa1e3aea5f190b7ceb47917e722be" shape="rect">scalblnf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1ge5d0f588dbdbce27abe79ac3280a429f" shape="rect">scalbnf</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
int </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g41ad29746811ca87119628ad4a811356" shape="rect">signbit</a> ( float <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>
void </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g9456ff9df91a3874180d89a94b36fd46" shape="rect">sincosf</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float*<span> </span><span class="keyword keyword apiItemName">sptr</span>, float*<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__SINGLE_1gab8978300988c385e0aa4b6cba44225e" shape="rect">sincospif</a> ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float*<span> </span><span class="keyword keyword apiItemName">sptr</span>, float*<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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g4677d53159664972c54bb697b9c1bace" shape="rect">sinf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g72c262cde9f805d08492c316fc0158d9" shape="rect">sinhf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g85a985e497f4199be19462387e062ae2" shape="rect">sinpif</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gcb80df3c252b3feb3cc88f992b955a14" shape="rect">sqrtf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g561a1e0eab1092d294d331caf9bb93c5" shape="rect">tanf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g7d925743801795775ca98ae83d4ba6e6" shape="rect">tanhf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g0e556a6b5d691277e3234f4548d9ae23" shape="rect">tgammaf</a> ( float <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>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g86499f47865e04e1ca845927f41b3322" shape="rect">truncf</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g87d0270856e29b6a34038c017513f811" shape="rect">y0f</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1gbba94fdcb53f6a12f8bf5191697e8359" shape="rect">y1f</a> ( float <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_type"><span class="keyword keyword apiItemName">__device__</span>
float </span><span class="member_name"><a href="#group__CUDA__MATH__SINGLE_1g383612b6d78a55003343521bca193ecd" shape="rect">ynf</a> ( int <span> </span><span class="keyword keyword apiItemName">n</span>, float <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__SINGLE_1g63d1c22538561dc228fc230d10d85dca" id="group__CUDA__MATH__SINGLE_1g63d1c22538561dc228fc230d10d85dca" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float acosf ( float <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>acosf(1) returns +0.</li>
<li>acosf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gb0f45cada398311319b50a00ff7e826e" id="group__CUDA__MATH__SINGLE_1gb0f45cada398311319b50a00ff7e826e" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float acoshf ( float <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>acoshf(1) returns 0.</li>
<li>acoshf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g82b2bb388724796ae8a30069abb3b386" id="group__CUDA__MATH__SINGLE_1g82b2bb388724796ae8a30069abb3b386" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float asinf ( float <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>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<mn>2</mn>
</math>
, +
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<mn>2</mn>
</math>
] for <tt class="ph tt code">x</tt> inside [-1, +1].
<ul>
<li>asinf(0) returns +0.</li>
<li>asinf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g74d4dabb94aa5c77ce31fd0ea987c083" id="group__CUDA__MATH__SINGLE_1g74d4dabb94aa5c77ce31fd0ea987c083" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float asinhf ( float <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>asinhf(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gd89b766e91b1c84f2e8e81beb750707d" id="group__CUDA__MATH__SINGLE_1gd89b766e91b1c84f2e8e81beb750707d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float atan2f ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</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>atan2f(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">x</tt> / <tt class="ph tt code">y</tt>. The quadrant of the result is determined by the signs of inputs <tt class="ph tt code">x</tt> and <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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g82629bb4eec2d8c9c95b9c69188beff9" id="group__CUDA__MATH__SINGLE_1g82629bb4eec2d8c9c95b9c69188beff9" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float atanf ( float <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>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<mn>2</mn>
</math>
, +
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mi>π</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>/</mo>
</mrow>
<mn>2</mn>
</math>
].
<ul>
<li>atanf(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g1b176d9d72adbf998b1960f830ad9dcc" id="group__CUDA__MATH__SINGLE_1g1b176d9d72adbf998b1960f830ad9dcc" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float atanhf ( float <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>atanhf(
<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>atanhf(
<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>atanhf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g96d2384128af36ea9cb9b20d366900c7" id="group__CUDA__MATH__SINGLE_1g96d2384128af36ea9cb9b20d366900c7" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float cbrtf ( float <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>cbrtf(
<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>cbrtf(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g43a6f3aa4ccdb026b038a3fe9a80f65d" id="group__CUDA__MATH__SINGLE_1g43a6f3aa4ccdb026b038a3fe9a80f65d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float ceilf ( float <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>ceilf(
<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>ceilf(
<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__SINGLE_1gf624240731f96c35e2bbf9aaa9217ad6" id="group__CUDA__MATH__SINGLE_1gf624240731f96c35e2bbf9aaa9217ad6" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float copysignf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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__SINGLE_1g20858ddd8f75a2c8332bdecd536057bf" id="group__CUDA__MATH__SINGLE_1g20858ddd8f75a2c8332bdecd536057bf" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float cosf ( float <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>cosf(0) returns 1.</li>
<li>cosf(
<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><ul class="ul">
<li class="li">
<p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix C, Table C-1. </p>
</li>
<li class="li">
<p class="p">This function is affected by the <tt class="ph tt code">--use_fast_math</tt> compiler flag. See the CUDA C Programming Guide, Appendix C, Table C-3 for a complete list of functions affected.
</p>
</li>
</ul>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g34a53cc088d117bc7045caa111279799" id="group__CUDA__MATH__SINGLE_1g34a53cc088d117bc7045caa111279799" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float coshf ( float <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>coshf(0) returns 1.</li>
<li>coshf(
<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 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g6fc515121cf408a92ef611a3c6fdc5cc" id="group__CUDA__MATH__SINGLE_1g6fc515121cf408a92ef611a3c6fdc5cc" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float cospif ( float <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>cospif(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mn>0</mn>
</math>
) returns 1.
</li>
<li>cospif(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g31faaaeab2a785191c3e0e66e030ceca" id="group__CUDA__MATH__SINGLE_1g31faaaeab2a785191c3e0e66e030ceca" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float erfcf ( float <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>erfcf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns 2.
</li>
<li>erfcf(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g2bae6c7d986e0ab7e5cf685ac8b7236c" id="group__CUDA__MATH__SINGLE_1g2bae6c7d986e0ab7e5cf685ac8b7236c" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float erfcinvf ( float <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>erfcinvf(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>erfcinvf(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gec797649c94f21aecb8dc033a7b97353" id="group__CUDA__MATH__SINGLE_1gec797649c94f21aecb8dc033a7b97353" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float erfcxf ( float <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>erfcxf(
<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>erfcxf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0
</li>
<li>erfcxf(<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 single 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g3b8115ff34a107f4608152fd943dbf81" id="group__CUDA__MATH__SINGLE_1g3b8115ff34a107f4608152fd943dbf81" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float erff ( float <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>erff(
<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>erff(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g0f3b173d8ba48cd495cc9c37e1f5ed4d" id="group__CUDA__MATH__SINGLE_1g0f3b173d8ba48cd495cc9c37e1f5ed4d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float erfinvf ( float <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>erfinvf(1) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>erfinvf(-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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g60f1de4fe78a907d915a52be29a799e7" id="group__CUDA__MATH__SINGLE_1g60f1de4fe78a907d915a52be29a799e7" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float exp10f ( float <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><ul class="ul">
<li class="li">
<p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix C, Table C-1. </p>
</li>
<li class="li">
<p class="p">This function is affected by the <tt class="ph tt code">--use_fast_math</tt> compiler flag. See the CUDA C Programming Guide, Appendix C, Table C-3 for a complete list of functions affected.
</p>
</li>
</ul>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g3e2984de99de67ca680c9bb4f4427f81" id="group__CUDA__MATH__SINGLE_1g3e2984de99de67ca680c9bb4f4427f81" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float exp2f ( float <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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1ge2d7656fe00f9e750c6f3bde8cc0dca6" id="group__CUDA__MATH__SINGLE_1ge2d7656fe00f9e750c6f3bde8cc0dca6" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float expf ( float <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>,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msup>
<mi>e</mi>
<mi>x</mi>
</msup>
</math>
.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><ul class="ul">
<li class="li">
<p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix C, Table C-1. </p>
</li>
<li class="li">
<p class="p">This function is affected by the <tt class="ph tt code">--use_fast_math</tt> compiler flag. See the CUDA C Programming Guide, Appendix C, Table C-3 for a complete list of functions affected.
</p>
</li>
</ul>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g832817212e7b0debe05d23ea37bdd748" id="group__CUDA__MATH__SINGLE_1g832817212e7b0debe05d23ea37bdd748" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float expm1f ( float <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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gb00f8593e1bfb1985526020fbec4e0fc" id="group__CUDA__MATH__SINGLE_1gb00f8593e1bfb1985526020fbec4e0fc" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float fabsf ( float <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the absolute value of its argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns the absolute value of its 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g13959e5ca19c910e0d6f8e6ca5492149" id="group__CUDA__MATH__SINGLE_1g13959e5ca19c910e0d6f8e6ca5492149" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float fdimf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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>fdimf(<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>fdimf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g26852224a1347ee9b5edee12c869d206" id="group__CUDA__MATH__SINGLE_1g26852224a1347ee9b5edee12c869d206" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float fdividef ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Divide two floating point values. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">Returns <tt class="ph tt code">x</tt> / <tt class="ph tt code">y</tt>.
</p>
</div>
<div class="section">
<h6 class="description_header">Description</h6>
<p>Compute <tt class="ph tt code">x</tt> divided by <tt class="ph tt code">y</tt>. If <tt class="ph tt code">--use_fast_math</tt> is specified, use <a class="xref" href="group__CUDA__MATH__INTRINSIC__SINGLE.html#group__CUDA__MATH__INTRINSIC__SINGLE_1gc996beec34f94f6376d0674a6860e107" title="Calculate the fast approximate division of the input arguments." shape="rect">__fdividef()</a> for higher performance, otherwise use normal division.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><ul class="ul">
<li class="li">
<p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix C, Table C-1. </p>
</li>
<li class="li">
<p class="p">This function is affected by the <tt class="ph tt code">--use_fast_math</tt> compiler flag. See the CUDA C Programming Guide, Appendix C, Table C-3 for a complete list of functions affected.
</p>
</li>
</ul>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gdbff62f4c1647b9694f35d053eff5288" id="group__CUDA__MATH__SINGLE_1gdbff62f4c1647b9694f35d053eff5288" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float floorf ( float <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>floorf(
<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>floorf(
<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 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g5910ee832dab4f5d37118e0a6811c195" id="group__CUDA__MATH__SINGLE_1g5910ee832dab4f5d37118e0a6811c195" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float fmaf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span>, float <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>fmaf(
<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>fmaf(
<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>fmaf(<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>fmaf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g6e7516db46be25c33fb26e203287f2a3" id="group__CUDA__MATH__SINGLE_1g6e7516db46be25c33fb26e203287f2a3" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float fmaxf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gbf48322ad520d7b12542edf990dde8c0" id="group__CUDA__MATH__SINGLE_1gbf48322ad520d7b12542edf990dde8c0" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float fminf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g9255f64a2585463fea365c8273d23904" id="group__CUDA__MATH__SINGLE_1g9255f64a2585463fea365c8273d23904" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float fmodf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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>fmodf(
<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>fmodf(<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>fmodf(<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>fmodf(<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>fmodf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g56e8cba742e2f80647903dac9c93eb37" id="group__CUDA__MATH__SINGLE_1g56e8cba742e2f80647903dac9c93eb37" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float frexpf ( float <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>Decomposes 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g2880a4ebf5500aeb74fb01340ea91215" id="group__CUDA__MATH__SINGLE_1g2880a4ebf5500aeb74fb01340ea91215" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float hypotf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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>Calculates 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g4e9bcb254b97eb63abf3092233464131" id="group__CUDA__MATH__SINGLE_1g4e9bcb254b97eb63abf3092233464131" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
int ilogbf ( float <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>ilogbf(0) returns <tt class="ph tt code">INT_MIN</tt>.
</li>
<li>ilogbf(NaN) returns NaN.</li>
<li>ilogbf(<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>ilogbf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gb8b25d1859c58659aa30c4c0ac246e42" id="group__CUDA__MATH__SINGLE_1gb8b25d1859c58659aa30c4c0ac246e42" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
int isfinite ( float <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">Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is a finite value.
</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__SINGLE_1g8cfb9bd373d33c3a5bca35363e730c05" id="group__CUDA__MATH__SINGLE_1g8cfb9bd373d33c3a5bca35363e730c05" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
int isinf ( float <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">Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is a infinite value.
</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__SINGLE_1g7754b0a95fed7553a58bd63d29946647" id="group__CUDA__MATH__SINGLE_1g7754b0a95fed7553a58bd63d29946647" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
int isnan ( float <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">Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is a NaN value.
</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__SINGLE_1gba3e4bad4109f5e8509dc1925fade7ce" id="group__CUDA__MATH__SINGLE_1gba3e4bad4109f5e8509dc1925fade7ce" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float j0f ( float <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>j0f(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>j0f(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g462954bfc6ada6132f28bd7fce41334e" id="group__CUDA__MATH__SINGLE_1g462954bfc6ada6132f28bd7fce41334e" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float j1f ( float <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>j1f(
<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>j1f(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>j1f(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gdcd52a43c4f2d8d9148a022d6d6851dd" id="group__CUDA__MATH__SINGLE_1gdcd52a43c4f2d8d9148a022d6d6851dd" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float jnf ( int <span> </span><span class="keyword keyword apiItemName">n</span>, float <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>jnf(<tt class="ph tt code">n</tt>, NaN) returns NaN.
</li>
<li>jnf(<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>jnf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g7d82accff3d8e3307d61e028c19c30cd" id="group__CUDA__MATH__SINGLE_1g7d82accff3d8e3307d61e028c19c30cd" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float ldexpf ( float <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>ldexpf(<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 single 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gf7ffab2d685130195ba255e954e21130" id="group__CUDA__MATH__SINGLE_1gf7ffab2d685130195ba255e954e21130" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float lgammaf ( float <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>lgammaf(1) returns +0.</li>
<li>lgammaf(2) returns +0.</li>
<li>lgammaf(<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 single floating point range.
</li>
<li>lgammaf(<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.
</li>
<li>lgammaf(
<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>lgammaf(
<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">
<mi>l</mi>
<mi>o</mi>
<msub>
<mi>g</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>e</mi>
</mrow>
</msub>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mtext> </mtext>
<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 class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
</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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g7d4af230b5deee73fbfa9801f44f0616" id="group__CUDA__MATH__SINGLE_1g7d4af230b5deee73fbfa9801f44f0616" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long long int llrintf ( float <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 towards zero. 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__SINGLE_1gf2a7fe8fb57e5b39886d776f75fdf5d6" id="group__CUDA__MATH__SINGLE_1gf2a7fe8fb57e5b39886d776f75fdf5d6" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long long int llroundf ( float <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__SINGLE.html#group__CUDA__MATH__SINGLE_1g7d4af230b5deee73fbfa9801f44f0616" title="Round input to nearest integer value." shape="rect">llrintf()</a>.
</p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gb49e218cf742a0eb08e5516dd5160585" id="group__CUDA__MATH__SINGLE_1gb49e218cf742a0eb08e5516dd5160585" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float log10f ( float <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>log10f(
<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>log10f(1) returns +0.</li>
<li>log10f(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>log10f(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g9d53128ab5f7d6ebc4798f243481a6d7" id="group__CUDA__MATH__SINGLE_1g9d53128ab5f7d6ebc4798f243481a6d7" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float log1pf ( float <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>log1pf(
<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>log1pf(-1) returns +0.</li>
<li>log1pf(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < -1.
</li>
<li>log1pf(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gfc9ae1bd4ebb4cd9533a50f1bf486f08" id="group__CUDA__MATH__SINGLE_1gfc9ae1bd4ebb4cd9533a50f1bf486f08" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float log2f ( float <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>log2f(
<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>log2f(1) returns +0.</li>
<li>log2f(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>log2f(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g9a86f57d529d7000b04cb30e859a21b7" id="group__CUDA__MATH__SINGLE_1g9a86f57d529d7000b04cb30e859a21b7" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float logbf ( float <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>logbf
<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>logbf
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gcdaf041c4071f63cba0e51658b89ffa4" id="group__CUDA__MATH__SINGLE_1gcdaf041c4071f63cba0e51658b89ffa4" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float logf ( float <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Calculate the natural logarithm of the input argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>logf(
<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>logf(1) returns +0.</li>
<li>logf(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>logf(
<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 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g639a876a55da8142dcd917ce6c12c27d" id="group__CUDA__MATH__SINGLE_1g639a876a55da8142dcd917ce6c12c27d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long int lrintf ( float <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 towards zero. 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__SINGLE_1g4d10236b2afbafda2fd85825811b84e3" id="group__CUDA__MATH__SINGLE_1g4d10236b2afbafda2fd85825811b84e3" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
long int lroundf ( float <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__SINGLE.html#group__CUDA__MATH__SINGLE_1g639a876a55da8142dcd917ce6c12c27d" title="Round input to nearest integer value." shape="rect">lrintf()</a>.
</p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g7c49d2e467f6ca3cfc0362d84bb474ab" id="group__CUDA__MATH__SINGLE_1g7c49d2e467f6ca3cfc0362d84bb474ab" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float modff ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float*<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>modff(
<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>modff(
<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>modff(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g372c640f910303dc4a7f17ce684322c5" id="group__CUDA__MATH__SINGLE_1g372c640f910303dc4a7f17ce684322c5" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float nanf ( 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>nanf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g53c10d923def0d85af5a2b65b1a021f0" id="group__CUDA__MATH__SINGLE_1g53c10d923def0d85af5a2b65b1a021f0" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float nearbyintf ( float <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>nearbyintf(
<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>nearbyintf(
<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 single 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g997fc003282f27b1c02c8a44fb4189f0" id="group__CUDA__MATH__SINGLE_1g997fc003282f27b1c02c8a44fb4189f0" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float nextafterf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Return next representable single-precision floating-point value afer argument. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>nextafterf(
<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 single-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__SINGLE.html#group__CUDA__MATH__SINGLE_1g997fc003282f27b1c02c8a44fb4189f0" title="Return next representable single-precision floating-point value afer argument." shape="rect">nextafterf()</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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g102ea4753919ee208c9b294e1c053cf1" id="group__CUDA__MATH__SINGLE_1g102ea4753919ee208c9b294e1c053cf1" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float normcdff ( float <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>normcdff(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns 1
</li>
<li>normcdff(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g1c0a28ad7f7555ab16e0a1e409690174" id="group__CUDA__MATH__SINGLE_1g1c0a28ad7f7555ab16e0a1e409690174" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float normcdfinvf ( float <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>normcdfinvf(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>normcdfinvf(1) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>normcdfinvf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gb519b517c0036b3604d602f716a919dd" id="group__CUDA__MATH__SINGLE_1gb519b517c0036b3604d602f716a919dd" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float powf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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>powf(
<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>powf(
<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>powf(
<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>powf(-1,
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>±</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns 1.
</li>
<li>powf(+1, <tt class="ph tt code">y</tt>) returns 1 for any <tt class="ph tt code">y</tt>, even a NaN.
</li>
<li>powf(<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>powf(<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>powf(<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>powf(<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>powf(<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>powf(<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>powf(
<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>powf(
<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>powf(
<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>powf(
<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>powf(
<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>powf(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g937164a0d40347821ad16b5cb5069c92" id="group__CUDA__MATH__SINGLE_1g937164a0d40347821ad16b5cb5069c92" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float rcbrtf ( float <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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g36179ffa51305653b55c1e76f44154ff" id="group__CUDA__MATH__SINGLE_1g36179ffa51305653b55c1e76f44154ff" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float remainderf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <span> </span><span class="keyword keyword apiItemName">y</span> ) </span></dt>
<dd class="description">
<div class="section">Compute single-precision floating-point remainder. </div>
<div class="section">
<h6 class="return_header">Returns</h6>
<p class="return">
<ul>
<li>remainderf(<tt class="ph tt code">x</tt>, 0) returns NaN.
</li>
<li>remainderf(
<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>remainderf(<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 single-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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1ga0d8ebba46ca705859d1c7462b53118d" id="group__CUDA__MATH__SINGLE_1ga0d8ebba46ca705859d1c7462b53118d" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float remquof ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float <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 single-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>remquof(<tt class="ph tt code">x</tt>, 0, <tt class="ph tt code">quo</tt>) returns NaN.
</li>
<li>remquof(
<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>remquof(<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__SINGLE.html#group__CUDA__MATH__SINGLE_1g36179ffa51305653b55c1e76f44154ff" title="Compute single-precision floating-point remainder." shape="rect">remainderf()</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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g7791cd93108ffc6d24524f2e8635ccfd" id="group__CUDA__MATH__SINGLE_1g7791cd93108ffc6d24524f2e8635ccfd" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float rintf ( float <span> </span><span class="keyword keyword apiItemName">x</span> ) </span></dt>
<dd class="description">
<div class="section">Round input 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 towards zero.
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1ga1c1521079e51b4f54771b16a7f8aeea" id="group__CUDA__MATH__SINGLE_1ga1c1521079e51b4f54771b16a7f8aeea" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float roundf ( float <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__SINGLE.html#group__CUDA__MATH__SINGLE_1g7791cd93108ffc6d24524f2e8635ccfd" title="Round input to nearest integer value in floating-point." shape="rect">rintf()</a>.
</p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g5a9bc318028131cfd13d10abfae1ae13" id="group__CUDA__MATH__SINGLE_1g5a9bc318028131cfd13d10abfae1ae13" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float rsqrtf ( float <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>rsqrtf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>rsqrtf(
<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>rsqrtf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gc94fa1e3aea5f190b7ceb47917e722be" id="group__CUDA__MATH__SINGLE_1gc94fa1e3aea5f190b7ceb47917e722be" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float scalblnf ( float <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>scalblnf(
<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>scalblnf(<tt class="ph tt code">x</tt>, 0) returns <tt class="ph tt code">x</tt>.
</li>
<li>scalblnf(
<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__SINGLE_1ge5d0f588dbdbce27abe79ac3280a429f" id="group__CUDA__MATH__SINGLE_1ge5d0f588dbdbce27abe79ac3280a429f" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float scalbnf ( float <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>scalbnf(
<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>scalbnf(<tt class="ph tt code">x</tt>, 0) returns <tt class="ph tt code">x</tt>.
</li>
<li>scalbnf(
<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__SINGLE_1g41ad29746811ca87119628ad4a811356" id="group__CUDA__MATH__SINGLE_1g41ad29746811ca87119628ad4a811356" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
int signbit ( float <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">Returns a nonzero value if and only if <tt class="ph tt code">a</tt> is negative. Reports the sign bit of all values including infinities, zeros, and NaNs.
</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__SINGLE_1g9456ff9df91a3874180d89a94b36fd46" id="group__CUDA__MATH__SINGLE_1g9456ff9df91a3874180d89a94b36fd46" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
void sincosf ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float*<span> </span><span class="keyword keyword apiItemName">sptr</span>, float*<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__SINGLE.html#group__CUDA__MATH__SINGLE_1g4677d53159664972c54bb697b9c1bace" title="Calculate the sine of the input argument." shape="rect">sinf()</a> and <a class="xref" href="group__CUDA__MATH__SINGLE.html#group__CUDA__MATH__SINGLE_1g20858ddd8f75a2c8332bdecd536057bf" title="Calculate the cosine of the input argument." shape="rect">cosf()</a>.
</p>
<p class="p"></p>
<p class="p">
<div class="note note"><span class="notetitle">Note:</span><ul class="ul">
<li class="li">
<p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix C, Table C-1. </p>
</li>
<li class="li">
<p class="p">This function is affected by the <tt class="ph tt code">--use_fast_math</tt> compiler flag. See the CUDA C Programming Guide, Appendix C, Table C-3 for a complete list of functions affected.
</p>
</li>
</ul>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gab8978300988c385e0aa4b6cba44225e" id="group__CUDA__MATH__SINGLE_1gab8978300988c385e0aa4b6cba44225e" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
void sincospif ( float <span> </span><span class="keyword keyword apiItemName">x</span>, float*<span> </span><span class="keyword keyword apiItemName">sptr</span>, float*<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__SINGLE.html#group__CUDA__MATH__SINGLE_1g85a985e497f4199be19462387e062ae2" title="Calculate the sine of the input argument ." shape="rect">sinpif()</a> and <a class="xref" href="group__CUDA__MATH__SINGLE.html#group__CUDA__MATH__SINGLE_1g6fc515121cf408a92ef611a3c6fdc5cc" title="Calculate the cosine of the input argument ." shape="rect">cospif()</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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g4677d53159664972c54bb697b9c1bace" id="group__CUDA__MATH__SINGLE_1g4677d53159664972c54bb697b9c1bace" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float sinf ( float <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>sinf(
<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>sinf(
<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><ul class="ul">
<li class="li">
<p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix C, Table C-1. </p>
</li>
<li class="li">
<p class="p">This function is affected by the <tt class="ph tt code">--use_fast_math</tt> compiler flag. See the CUDA C Programming Guide, Appendix C, Table C-3 for a complete list of functions affected.
</p>
</li>
</ul>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g72c262cde9f805d08492c316fc0158d9" id="group__CUDA__MATH__SINGLE_1g72c262cde9f805d08492c316fc0158d9" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float sinhf ( float <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>sinhf(
<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>sinhf(
<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 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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g85a985e497f4199be19462387e062ae2" id="group__CUDA__MATH__SINGLE_1g85a985e497f4199be19462387e062ae2" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float sinpif ( float <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>sinpif(
<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>sinpif(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gcb80df3c252b3feb3cc88f992b955a14" id="group__CUDA__MATH__SINGLE_1gcb80df3c252b3feb3cc88f992b955a14" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float sqrtf ( float <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>sqrtf(
<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>sqrtf(
<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>sqrtf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g561a1e0eab1092d294d331caf9bb93c5" id="group__CUDA__MATH__SINGLE_1g561a1e0eab1092d294d331caf9bb93c5" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float tanf ( float <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>tanf(
<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>tanf(
<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><ul class="ul">
<li class="li">
<p class="p">For accuracy information for this function see the CUDA C Programming Guide, Appendix C, Table C-1. </p>
</li>
<li class="li">
<p class="p">This function is affected by the <tt class="ph tt code">--use_fast_math</tt> compiler flag. See the CUDA C Programming Guide, Appendix C, Table C-3 for a complete list of functions affected.
</p>
</li>
</ul>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g7d925743801795775ca98ae83d4ba6e6" id="group__CUDA__MATH__SINGLE_1g7d925743801795775ca98ae83d4ba6e6" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float tanhf ( float <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>tanhf(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g0e556a6b5d691277e3234f4548d9ae23" id="group__CUDA__MATH__SINGLE_1g0e556a6b5d691277e3234f4548d9ae23" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float tgammaf ( float <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>tgammaf(
<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>tgammaf(2) returns +0.</li>
<li>tgammaf(<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 single floating point range.
</li>
<li>tgammaf(<tt class="ph tt code">x</tt>) returns NaN if <tt class="ph tt code">x</tt> < 0.
</li>
<li>tgammaf(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns NaN.
</li>
<li>tgammaf(
<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g86499f47865e04e1ca845927f41b3322" id="group__CUDA__MATH__SINGLE_1g86499f47865e04e1ca845927f41b3322" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float truncf ( float <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__SINGLE_1g87d0270856e29b6a34038c017513f811" id="group__CUDA__MATH__SINGLE_1g87d0270856e29b6a34038c017513f811" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float y0f ( float <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>y0f(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>y0f(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>y0f(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>y0f(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1gbba94fdcb53f6a12f8bf5191697e8359" id="group__CUDA__MATH__SINGLE_1gbba94fdcb53f6a12f8bf5191697e8359" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float y1f ( float <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>y1f(0) returns
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>−</mo>
<mi mathvariant="normal">∞</mi>
</math>
.
</li>
<li>y1f(<tt class="ph tt code">x</tt>) returns NaN for <tt class="ph tt code">x</tt> < 0.
</li>
<li>y1f(
<math xmlns="http://www.w3.org/1998/Math/MathML">
<mo>+</mo>
<mi mathvariant="normal">∞</mi>
</math>
) returns +0.
</li>
<li>y1f(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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
<dt class="description"><a name="group__CUDA__MATH__SINGLE_1g383612b6d78a55003343521bca193ecd" id="group__CUDA__MATH__SINGLE_1g383612b6d78a55003343521bca193ecd" shape="rect">
<!-- --></a><span><span class="keyword keyword apiItemName">__device__</span>
float ynf ( int <span> </span><span class="keyword keyword apiItemName">n</span>, float <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>ynf(<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>ynf(<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>ynf(<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>ynf(<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>ynf(<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 C, Table C-1. </p>
</div>
</p>
<p class="p"></p>
</div>
</dd>
</dl>
</div>
</div>
<hr id="contents-end"></hr>
<div id="breadcrumbs"><a href="group__CUDA__MATH.html" shape="rect">< Previous</a> | <a href="group__CUDA__MATH__DOUBLE.html" shape="rect">Next ></a></div>
<div id="release-info">CUDA Math API
(<a href="../../pdf/CUDA_Math_API.pdf">PDF</a>)
-
CUDA Toolkit v5.5
(<a href="https://developer.nvidia.com/cuda-toolkit-archive">older</a>)
-
Last updated
July 19, 2013
-
<a href="mailto:cudatools@nvidia.com?subject=CUDA Tools Documentation Feedback: cuda-math-api">Send Feedback</a></div>
</article>
<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>
<nav id="site-nav">
<div class="category closed"><span class="twiddle">▷</span><a href="../index.html" title="The root of the site.">CUDA Toolkit</a></div>
<ul class="closed">
<li><a href="../cuda-toolkit-release-notes/index.html" title="The Release Notes for the CUDA Toolkit from v4.0 to today.">Release Notes</a></li>
<li><a href="../eula/index.html" title="The End User License Agreements for the NVIDIA CUDA Toolkit, the NVIDIA CUDA Samples, the NVIDIA Display Driver, and NVIDIA NSight (Visual Studio Edition).">EULA</a></li>
<li><a href="../cuda-getting-started-guide-for-linux/index.html" title="This guide discusses how to install and check for correct operation of the CUDA Development Tools on GNU/Linux systems.">Getting Started Linux</a></li>
<li><a href="../cuda-getting-started-guide-for-mac-os-x/index.html" title="This guide discusses how to install and check for correct operation of the CUDA Development Tools on Mac OS X systems.">Getting Started Mac OS X</a></li>
<li><a href="../cuda-getting-started-guide-for-microsoft-windows/index.html" title="This guide discusses how to install and check for correct operation of the CUDA Development Tools on Microsoft Windows systems.">Getting Started Windows</a></li>
<li><a href="../cuda-c-programming-guide/index.html" title="This guide provides a detailed discussion of the CUDA programming model and programming interface. It then describes the hardware implementation, and provides guidance on how to achieve maximum performance. The Appendixes include a list of all CUDA-enabled devices, detailed description of all extensions to the C language, listings of supported mathematical functions, C++ features supported in host and device code, details on texture fetching, technical specifications of various devices, and concludes by introducing the low-level driver API.">Programming Guide</a></li>
<li><a href="../cuda-c-best-practices-guide/index.html" title="This guide presents established parallelization and optimization techniques and explains coding metaphors and idioms that can greatly simplify programming for CUDA-capable GPU architectures. The intent is to provide guidelines for obtaining the best performance from NVIDIA GPUs using the CUDA Toolkit.">Best Practices Guide</a></li>
<li><a href="../kepler-compatibility-guide/index.html" title="This application note is intended to help developers ensure that their NVIDIA CUDA applications will run effectively on GPUs based on the NVIDIA Kepler Architecture. This document provides guidance to ensure that your software applications are compatible with Kepler.">Kepler Compatibility Guide</a></li>
<li><a href="../kepler-tuning-guide/index.html" title="Kepler is NVIDIA's next-generation architecture for CUDA compute applications. Applications that follow the best practices for the Fermi architecture should typically see speedups on the Kepler architecture without any code changes. This guide summarizes the ways that an application can be fine-tuned to gain additional speedups by leveraging Kepler architectural features.">Kepler Tuning Guide</a></li>
<li><a href="../parallel-thread-execution/index.html" title="This guide provides detailed instructions on the use of PTX, a low-level parallel thread execution virtual machine and instruction set architecture (ISA). PTX exposes the GPU as a data-parallel computing device.">PTX ISA</a></li>
<li><a href="../optimus-developer-guide/index.html" title="This document explains how CUDA APIs can be used to query for GPU capabilities in NVIDIA Optimus systems.">Developer Guide for Optimus</a></li>
<li><a href="../video-decoder/index.html" title="This document provides the video decoder API specification and the format conversion and display using DirectX or OpenGL following decode.">Video Decoder</a></li>
<li><a href="../video-encoder/index.html" title="This document provides the CUDA video encoder specifications, including the C-library API functions and encoder query parameters.">Video Encoder</a></li>
<li><a href="../inline-ptx-assembly/index.html" title="This document shows how to inline PTX (parallel thread execution) assembly language statements into CUDA code. It describes available assembler statement parameters and constraints, and the document also provides a list of some pitfalls that you may encounter.">Inline PTX Assembly</a></li>
<li><a href="../cuda-runtime-api/index.html" title="The CUDA runtime API.">CUDA Runtime API</a></li>
<li><a href="../cuda-driver-api/index.html" title="The CUDA driver API.">CUDA Driver API</a></li>
<li><a href="../cuda-math-api/index.html" title="The CUDA math API.">CUDA Math API</a></li>
<li><a href="../cublas/index.html" title="The CUBLAS library is an implementation of BLAS (Basic Linear Algebra Subprograms) on top of the NVIDIA CUDA runtime. It allows the user to access the computational resources of NVIDIA Graphical Processing Unit (GPU), but does not auto-parallelize across multiple GPUs.">CUBLAS</a></li>
<li><a href="../cufft/index.html" title="The CUFFT library user guide.">CUFFT</a></li>
<li><a href="../curand/index.html" title="The CURAND library user guide.">CURAND</a></li>
<li><a href="../cusparse/index.html" title="The CUSPARSE library user guide.">CUSPARSE</a></li>
<li><a href="../npp/index.html" title="NVIDIA NPP is a library of functions for performing CUDA accelerated processing. The initial set of functionality in the library focuses on imaging and video processing and is widely applicable for developers in these areas. NPP will evolve over time to encompass more of the compute heavy tasks in a variety of problem domains. The NPP library is written to maximize flexibility, while maintaining high performance.">NPP</a></li>
<li><a href="../thrust/index.html" title="The Thrust getting started guide.">Thrust</a></li>
<li><a href="../cuda-samples/index.html" title="This document contains a complete listing of the code samples that are included with the NVIDIA CUDA Toolkit. It describes each code sample, lists the minimum GPU specification, and provides links to the source code and white papers if available.">CUDA Samples</a></li>
<li><a href="../cuda-compiler-driver-nvcc/index.html" title="This document is a reference guide on the use of the CUDA compiler driver nvcc. Instead of being a specific CUDA compilation driver, nvcc mimics the behavior of the GNU compiler gcc, accepting a range of conventional compiler options, such as for defining macros and include/library paths, and for steering the compilation process.">NVCC</a></li>
<li><a href="../cuda-gdb/index.html" title="The NVIDIA tool for debugging CUDA applications running on Linux and Mac, providing developers with a mechanism for debugging CUDA applications running on actual hardware. CUDA-GDB is an extension to the x86-64 port of GDB, the GNU Project debugger.">CUDA-GDB</a></li>
<li><a href="../cuda-memcheck/index.html" title="CUDA-MEMCHECK is a suite of run time tools capable of precisely detecting out of bounds and misaligned memory access errors, checking device allocation leaks, reporting hardware errors and identifying shared memory data access hazards.">CUDA-MEMCHECK</a></li>
<li><a href="../nsight-eclipse-edition-getting-started-guide/index.html" title="Nsight Eclipse Edition getting started guide">Nsight Eclipse Edition</a></li>
<li><a href="../profiler-users-guide/index.html" title="This is the guide to the Profiler.">Profiler</a></li>
<li><a href="../cuda-binary-utilities/index.html" title="The application notes for cuobjdump and nvdisasm.">CUDA Binary Utilities</a></li>
<li><a href="../floating-point/index.html" title="A number of issues related to floating point accuracy and compliance are a frequent source of confusion on both CPUs and GPUs. The purpose of this white paper is to discuss the most common issues related to NVIDIA GPUs and to supplement the documentation in the CUDA C Programming Guide.">Floating Point and IEEE 754</a></li>
<li><a href="../incomplete-lu-cholesky/index.html" title="In this white paper we show how to use the CUSPARSE and CUBLAS libraries to achieve a 2x speedup over CPU in the incomplete-LU and Cholesky preconditioned iterative methods. We focus on the Bi-Conjugate Gradient Stabilized and Conjugate Gradient iterative methods, that can be used to solve large sparse nonsymmetric and symmetric positive definite linear systems, respectively. Also, we comment on the parallel sparse triangular solve, which is an essential building block in these algorithms.">Incomplete-LU and Cholesky Preconditioned Iterative Methods</a></li>
<li><a href="../libnvvm-api/index.html" title="The libNVVM API.">libNVVM API</a></li>
<li><a href="../libdevice-users-guide/index.html" title="The libdevice library is an LLVM bitcode library that implements common functions for GPU kernels.">libdevice User's Guide</a></li>
<li><a href="../nvvm-ir-spec/index.html" title="NVVM IR is a compiler IR (internal representation) based on the LLVM IR. The NVVM IR is designed to represent GPU compute kernels (for example, CUDA kernels). High-level language front-ends, like the CUDA C compiler front-end, can generate NVVM IR.">NVVM IR</a></li>
<li><a href="../cupti/index.html" title="The CUPTI API.">CUPTI</a></li>
<li><a href="../debugger-api/index.html" title="The CUDA debugger API.">Debugger API</a></li>
<li><a href="../gpudirect-rdma/index.html" title="A tool for Kepler-class GPUs and CUDA 5.0 enabling a direct path for communication between the GPU and a peer device on the PCI Express bus when the devices share the same upstream root complex using standard features of PCI Express. This document introduces the technology and describes the steps necessary to enable a RDMA for GPUDirect connection to NVIDIA GPUs within the Linux device driver model.">RDMA for GPUDirect</a></li>
</ul>
<div class="category"><span class="twiddle">▼</span><a href="index.html" title="CUDA Math API">CUDA Math API</a></div>
<ul>
<li><a href="modules.html#modules">1. Modules</a><ul>
<li><a href="group__CUDA__MATH.html#group__CUDA__MATH">1.1. Mathematical Functions</a></li>
<li><a href="group__CUDA__MATH__SINGLE.html#group__CUDA__MATH__SINGLE">1.2. Single Precision Mathematical Functions</a></li>
<li><a href="group__CUDA__MATH__DOUBLE.html#group__CUDA__MATH__DOUBLE">1.3. Double Precision Mathematical Functions</a></li>
<li><a href="group__CUDA__MATH__INTRINSIC__SINGLE.html#group__CUDA__MATH__INTRINSIC__SINGLE">1.4. Single Precision Intrinsics</a></li>
<li><a href="group__CUDA__MATH__INTRINSIC__DOUBLE.html#group__CUDA__MATH__INTRINSIC__DOUBLE">1.5. Double Precision Intrinsics</a></li>
<li><a href="group__CUDA__MATH__INTRINSIC__INT.html#group__CUDA__MATH__INTRINSIC__INT">1.6. Integer Intrinsics</a></li>
<li><a href="group__CUDA__MATH__INTRINSIC__CAST.html#group__CUDA__MATH__INTRINSIC__CAST">1.7. Type Casting Intrinsics</a></li>
</ul>
</li>
<li><a href="notices-header.html#notices-header">Notices</a><ul></ul>
</li>
</ul>
</nav>
<nav id="search-results">
<h2>Search Results</h2>
<ol></ol>
</nav>
<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/omniture/s_code_us_dev_aut1-nolinktrackin.js"></script>
<script language="JavaScript" type="text/javascript" charset="utf-8" src="../common/scripts/omniture/omniture.js"></script>
<noscript><a href="http://www.omniture.com" title="Web Analytics"><img src="http://omniture.nvidia.com/b/ss/nvidiacudadocs/1/H.17--NS/0" height="1" width="1" border="0" alt=""></img></a></noscript>
<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>
</body>
</html>
