File Manager

003 File Manager

Current Path: /usr/local/share/doc/mpdecimal/libmpdec

usr / local / share / doc / mpdecimal / libmpdec /

📁 ..
📄 README.txt(88 B)
📁 _static
📄 arithmetic.html(109.46 KB)
📄 assign-convert.html(56.83 KB)
📄 attributes.html(24.85 KB)
📄 context.html(37.84 KB)
📄 decimals.html(8.45 KB)
📄 functions.html(58.37 KB)
📄 index.html(16.95 KB)
📄 memory.html(15.59 KB)
📄 objects.inv(1.83 KB)
📄 search.html(2.76 KB)
📄 searchindex.js(30.97 KB)
📄 various.html(40.5 KB)

Editing: arithmetic.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<title>Arithmetic Functions &#8212; mpdecimal 2.5.1 documentation</title>
 <link rel="stylesheet" href="_static/mpdecimal-doc.css" type="text/css" />
 <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
 
 <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
 <script src="_static/jquery.js"></script>
 <script src="_static/underscore.js"></script>
 <script src="_static/doctools.js"></script>
 <script src="_static/language_data.js"></script>
 
 <link rel="search" title="Search" href="search.html" />
 <link rel="next" title="Various Functions" href="various.html" />
 <link rel="prev" title="Attributes of a Decimal" href="attributes.html" /> 
 </head><body>
 <div class="related" role="navigation" aria-label="related navigation">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="various.html" title="Various Functions"
 accesskey="N">next</a></li>
 <li class="right" >
 <a href="attributes.html" title="Attributes of a Decimal"
 accesskey="P">previous</a> |</li>
 <li><a href="http://www.bytereef.org/mpdecimal/index.html">project home</a></li>
 
 </ul>
 </div>
 <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
 <div class="sphinxsidebarwrapper">
 <h3><a href="index.html">Table of Contents</a></h3>
 <ul>
<li><a class="reference internal" href="#">Arithmetic Functions</a><ul>
<li><a class="reference internal" href="#basic-arithmetic">Basic Arithmetic</a><ul>
<li><a class="reference internal" href="#add">add</a></li>
<li><a class="reference internal" href="#subtract">subtract</a></li>
<li><a class="reference internal" href="#multiply">multiply</a></li>
<li><a class="reference internal" href="#divide">divide</a></li>
<li><a class="reference internal" href="#fused-multiply-add">fused-multiply-add</a></li>
</ul>
</li>
<li><a class="reference internal" href="#integer-division">Integer Division</a><ul>
<li><a class="reference internal" href="#divide-integer">divide-integer</a></li>
<li><a class="reference internal" href="#remainder">remainder</a></li>
<li><a class="reference internal" href="#remainder-near">remainder-near</a></li>
<li><a class="reference internal" href="#divmod">divmod</a></li>
</ul>
</li>
<li><a class="reference internal" href="#powers-and-logarithms">Powers and Logarithms</a><ul>
<li><a class="reference internal" href="#exp">exp</a></li>
<li><a class="reference internal" href="#ln">ln</a></li>
<li><a class="reference internal" href="#log10">log10</a></li>
<li><a class="reference internal" href="#power">power</a></li>
<li><a class="reference internal" href="#square-root">square-root</a></li>
<li><a class="reference internal" href="#inverse-square-root">inverse-square-root</a></li>
</ul>
</li>
<li><a class="reference internal" href="#sign-and-absolute">Sign and Absolute</a><ul>
<li><a class="reference internal" href="#minus">minus</a></li>
<li><a class="reference internal" href="#plus">plus</a></li>
<li><a class="reference internal" href="#abs">abs</a></li>
</ul>
</li>
<li><a class="reference internal" href="#comparisons">Comparisons</a><ul>
<li><a class="reference internal" href="#compare">compare</a></li>
<li><a class="reference internal" href="#compare-signal">compare-signal</a></li>
<li><a class="reference internal" href="#compare-total">compare-total</a></li>
<li><a class="reference internal" href="#compare-total-magnitude">compare-total-magnitude</a></li>
<li><a class="reference internal" href="#cmp">cmp</a></li>
<li><a class="reference internal" href="#cmp-total">cmp-total</a></li>
<li><a class="reference internal" href="#cmp-total-magnitude">cmp-total-magnitude</a></li>
<li><a class="reference internal" href="#max">max</a></li>
<li><a class="reference internal" href="#max-mag">max-mag</a></li>
<li><a class="reference internal" href="#min">min</a></li>
<li><a class="reference internal" href="#min-mag">min-mag</a></li>
</ul>
</li>
<li><a class="reference internal" href="#closest-numbers">Closest Numbers</a><ul>
<li><a class="reference internal" href="#next-minus">next-minus</a></li>
<li><a class="reference internal" href="#next-plus">next-plus</a></li>
<li><a class="reference internal" href="#next-toward">next-toward</a></li>
</ul>
</li>
<li><a class="reference internal" href="#quantizing-and-normalizing">Quantizing and Normalizing</a><ul>
<li><a class="reference internal" href="#quantize">quantize</a></li>
<li><a class="reference internal" href="#rescale">rescale</a></li>
<li><a class="reference internal" href="#same-quantum">same-quantum</a></li>
<li><a class="reference internal" href="#reduce">reduce</a></li>
</ul>
</li>
<li><a class="reference internal" href="#integral-values">Integral Values</a><ul>
<li><a class="reference internal" href="#round-to-integral-exact">round-to-integral-exact</a></li>
<li><a class="reference internal" href="#round-to-integral-value">round-to-integral-value</a></li>
<li><a class="reference internal" href="#floor">floor</a></li>
<li><a class="reference internal" href="#ceiling">ceiling</a></li>
<li><a class="reference internal" href="#truncate">truncate</a></li>
</ul>
</li>
<li><a class="reference internal" href="#scale">Scale</a><ul>
<li><a class="reference internal" href="#logb">logb</a></li>
<li><a class="reference internal" href="#scaleb">scaleb</a></li>
</ul>
</li>
<li><a class="reference internal" href="#integer-functions">Integer Functions</a><ul>
<li><a class="reference internal" href="#powmod">powmod</a></li>
</ul>
</li>
</ul>
</li>
</ul>

<h4>Previous topic</h4>
 <a href="attributes.html"
 title="previous chapter">Attributes of a Decimal</a>
 <h4>Next topic</h4>
 <a href="various.html"
 title="next chapter">Various Functions</a>
<div id="searchbox" style="display: none" role="search">
 <h3 id="searchlabel">Quick search</h3>
 <div class="searchformwrapper">
 <form class="search" action="search.html" method="get">
 <input type="text" name="q" aria-labelledby="searchlabel" />
 <input type="submit" value="Go" />
 </form>
 </div>
</div>
<script>$('#searchbox').show(0);</script>
 </div>
 </div>

<div class="document">
 <div class="documentwrapper">
 <div class="bodywrapper">
 <div class="body" role="main">
 
 <div class="section" id="arithmetic-functions">
<h1>Arithmetic Functions</h1>
<div class="section" id="basic-arithmetic">
<h2>Basic Arithmetic</h2>
Most of these functions are part of the specification, and some descriptions
contain direct quotes.
<div class="section" id="add">
<h3>add</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qadd(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_add(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a + b.
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qadd_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qadd_i32(mpd_t *result, const mpd_t *a, int32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qadd_i64(mpd_t *result, const mpd_t *a, int64_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qadd_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qadd_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qadd_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 const mpd_context_t *ctx, uint32_t *status);

void mpd_add_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 mpd_context_t *ctx);
void mpd_add_i32(mpd_t *result, const mpd_t *a, int32_t b,
 mpd_context_t *ctx);
void mpd_add_i64(mpd_t *result, const mpd_t *a, int64_t b,
 mpd_context_t *ctx);
void mpd_add_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 mpd_context_t *ctx);
void mpd_add_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 mpd_context_t *ctx);
void mpd_add_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a + b.
<div class="versionchanged">
Changed in version 2.4.0: All functions are now available in both the 64-bit and 32-bit builds.
</div>
</div>
<div class="section" id="subtract">
<h3>subtract</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qsub(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_sub(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a - b.
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qsub_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qsub_i32(mpd_t *result, const mpd_t *a, int32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qsub_i64(mpd_t *result, const mpd_t *a, int64_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qsub_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qsub_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qsub_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 const mpd_context_t *ctx, uint32_t *status);

void mpd_sub_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 mpd_context_t *ctx);
void mpd_sub_i32(mpd_t *result, const mpd_t *a, int32_t b,
 mpd_context_t *ctx);
void mpd_sub_i64(mpd_t *result, const mpd_t *a, int64_t b,
 mpd_context_t *ctx);
void mpd_sub_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 mpd_context_t *ctx);
void mpd_sub_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 mpd_context_t *ctx);
void mpd_sub_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a - b.
<div class="versionchanged">
Changed in version 2.4.0: All functions are now available in both the 64-bit and 32-bit builds.
</div>
</div>
<div class="section" id="multiply">
<h3>multiply</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qmul(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_mul(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a * b.
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qmul_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qmul_i32(mpd_t *result, const mpd_t *a, int32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qmul_i64(mpd_t *result, const mpd_t *a, int64_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qmul_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qmul_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qmul_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 const mpd_context_t *ctx, uint32_t *status);

void mpd_mul_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 mpd_context_t *ctx);
void mpd_mul_i32(mpd_t *result, const mpd_t *a, int32_t b,
 mpd_context_t *ctx);
void mpd_mul_i64(mpd_t *result, const mpd_t *a, int64_t b,
 mpd_context_t *ctx);
void mpd_mul_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 mpd_context_t *ctx);
void mpd_mul_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 mpd_context_t *ctx);
void mpd_mul_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a * b.
<div class="versionchanged">
Changed in version 2.4.0: All functions are now available in both the 64-bit and 32-bit builds.
</div>
</div>
<div class="section" id="divide">
<h3>divide</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qdiv(mpd_t *q, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_div(mpd_t *q, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a / b.
<div class="versionchanged">
Changed in version 2.5.0: If <code class="xref c c-macro docutils literal notranslate">MPD_Malloc_error</code> occurs for extremely large precisions, the
function now retries the operation in case the result is exact and fits
in a much lower precision.
</div>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qdiv_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qdiv_i32(mpd_t *result, const mpd_t *a, int32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qdiv_i64(mpd_t *result, const mpd_t *a, int64_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qdiv_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qdiv_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_qdiv_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 const mpd_context_t *ctx, uint32_t *status);

void mpd_div_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b,
 mpd_context_t *ctx);
void mpd_div_i32(mpd_t *result, const mpd_t *a, int32_t b,
 mpd_context_t *ctx);
void mpd_div_i64(mpd_t *result, const mpd_t *a, int64_t b,
 mpd_context_t *ctx);
void mpd_div_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b,
 mpd_context_t *ctx);
void mpd_div_u32(mpd_t *result, const mpd_t *a, uint32_t b,
 mpd_context_t *ctx);
void mpd_div_u64(mpd_t *result, const mpd_t *a, uint64_t b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to a / b.
<div class="versionchanged">
Changed in version 2.4.0: All functions are now available in both the 64-bit and 32-bit builds.
</div>
</div>
<div class="section" id="fused-multiply-add">
<h3>fused-multiply-add</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qfma(mpd_t *r, const mpd_t *a, const mpd_t *b, const mpd_t *c,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_fma(mpd_t *r, const mpd_t *a, const mpd_t *b, const mpd_t *c,
 mpd_context_t *ctx);
</pre></div>
</div>
Set r to a * b + c with a single, final rounding.
</div>
</div>
<div class="section" id="integer-division">
<h2>Integer Division</h2>
<div class="section" id="divide-integer">
<h3>divide-integer</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qdivint(mpd_t *q, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_divint(mpd_t *q, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set q to the integer part of a / b.
</div>
<div class="section" id="remainder">
<h3>remainder</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qrem(mpd_t *r, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_rem(mpd_t *r, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set r to the remainder of a / b.
</div>
<div class="section" id="remainder-near">
<h3>remainder-near</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qrem_near(mpd_t *r, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_rem_near(mpd_t *r, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set r to a - b * n, where n is the integer nearest the exact value
of a / b. If two integers are equally near then the even one is chosen.
</div>
<div class="section" id="divmod">
<h3>divmod</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qdivmod(mpd_t *q, mpd_t *r, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_divmod(mpd_t *q, mpd_t *r, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set q and r to the integer part and remainder of a / b. This
function is not part of the standard.
</div>
</div>
<div class="section" id="powers-and-logarithms">
<h2>Powers and Logarithms</h2>
<div class="section" id="exp">
<h3>exp</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qexp(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_exp(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to e ** a. Results are correctly rounded if the allcr
field in the context is set to 1.
</div>
<div class="section" id="ln">
<h3>ln</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qln(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_ln(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to the natural logarithm of a. Results are correctly rounded
if the allcr field in the context is set to 1.
<div class="versionchanged">
Changed in version 2.4.0: This function is now thread-safe.
</div>
</div>
<div class="section" id="log10">
<h3>log10</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qlog10(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_log10(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to the base-10 logarithm of a. Results are correctly rounded
if the allcr field in the context is set to 1.
<div class="versionchanged">
Changed in version 2.4.0: This function is now thread-safe.
</div>
</div>
<div class="section" id="power">
<h3>power</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qpow(mpd_t *result, const mpd_t *base, const mpd_t *exp,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_pow(mpd_t *result, const mpd_t *base, const mpd_t *exp,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to base ** exp. Integer powers are exact, provided that that
the result is finite and fits into prec.
Results are not correctly rounded, even if the allcr context field is set
to 1. This might change in a future release. The error of the function is less
than 0.5ULP+t (1ULP+t for directed rounding modes), where t has a maximum
of 0.1ULP, but is almost always less than 0.01ULP.
<div class="versionchanged">
Changed in version 2.4.0: This function is now thread-safe.
</div>
</div>
<div class="section" id="square-root">
<h3>square-root</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qsqrt(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_sqrt(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to the square root of a. This function is always correctly
rounded and always uses the <code class="xref c c-macro docutils literal notranslate">ROUND_HALF_EVEN</code> mode.
<div class="versionchanged">
Changed in version 2.5.0: If <code class="xref c c-macro docutils literal notranslate">MPD_Malloc_error</code> occurs for extremely large precisions, the
function now retries the operation in case the result is exact and fits
in a much lower precision.
</div>
</div>
<div class="section" id="inverse-square-root">
<h3>inverse-square-root</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qinvroot(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_invroot(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to the reciprocal of the square root of a. The function always
uses the <code class="xref c c-macro docutils literal notranslate">ROUND_HALF_EVEN</code> mode. Results are not correctly rounded,
even if the allcr context field is set to 1. This might change in a future
release.
</div>
</div>
<div class="section" id="sign-and-absolute">
<h2>Sign and Absolute</h2>
<div class="section" id="minus">
<h3>minus</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qminus(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_minus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to - a. The operation is context sensitive.
</div>
<div class="section" id="plus">
<h3>plus</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qplus(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_plus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to + a. The operation is context sensitive.
</div>
<div class="section" id="abs">
<h3>abs</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qabs(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_abs(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to the absolute value of a. For negative numbers,
<code class="xref c c-func docutils literal notranslate">mpd_qabs</code> is the same as <code class="xref c c-func docutils literal notranslate">mpd_qminus</code>, for positive
numbers the same as <code class="xref c c-func docutils literal notranslate">mpd_qplus</code>.
</div>
</div>
<div class="section" id="comparisons">
<h2>Comparisons</h2>
<div class="section" id="compare">
<h3>compare</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_qcompare(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
int mpd_compare(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to -1 if a is less than b, 0 if a is equal to b and 1
if a is greater than b. For convenience, the result is also returned as
a C integer. The <code class="xref c c-macro docutils literal notranslate">MPD_Invalid_Operation</code> condition is added to status
if at least one of the operands is a signaling NaN. In this case, result is
set to NaN and <code class="xref c c-macro docutils literal notranslate">INT_MAX</code> is returned.
</div>
<div class="section" id="compare-signal">
<h3>compare-signal</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_qcompare_signal(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
int mpd_compare_signal(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Same as <code class="xref c c-func docutils literal notranslate">mpd_qcompare</code>, except that the <code class="xref c c-macro docutils literal notranslate">MPD_Invalid_Operation</code>
condition is also added to status if at least one of the operands is a quiet
NaN.
</div>
<div class="section" id="compare-total">
<h3>compare-total</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_compare_total(mpd_t *result, const mpd_t *a, const mpd_t *b);
</pre></div>
</div>
Compare a and b using a total ordering. This function is always quiet.
</div>
<div class="section" id="compare-total-magnitude">
<h3>compare-total-magnitude</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_compare_total_mag(mpd_t *result, const mpd_t *a, const mpd_t *b);
</pre></div>
</div>
Compare the magnitude of a and b using a total ordering. This function
is always quiet.
</div>
<div class="section" id="cmp">
<h3>cmp</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_qcmp(const mpd_t *a, const mpd_t *b, uint32_t *status);
int mpd_cmp(const mpd_t *a, const mpd_t *b, mpd_context_t *ctx);
</pre></div>
</div>
Same as <code class="xref c c-func docutils literal notranslate">mpd_qcompare_signal</code>, but without the decimal result operand.
</div>
<div class="section" id="cmp-total">
<h3>cmp-total</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_cmp_total(const mpd_t *a, const mpd_t *b);
</pre></div>
</div>
Same as <code class="xref c c-func docutils literal notranslate">mpd_compare_total</code>, but without the decimal result operand.
</div>
<div class="section" id="cmp-total-magnitude">
<h3>cmp-total-magnitude</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_cmp_total_mag(const mpd_t *a, const mpd_t *b);
</pre></div>
</div>
Same as <code class="xref c c-func docutils literal notranslate">mpd_compare_total_mag</code>, but without the decimal result operand.
</div>
<div class="section" id="max">
<h3>max</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qmax(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_max(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to the maximum of a and b. If one of the operands is a quiet NaN
and the other is numeric, the numeric operand is returned.
</div>
<div class="section" id="max-mag">
<h3>max-mag</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qmax_mag(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_max_mag(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Same as <code class="xref c c-func docutils literal notranslate">mpd_qmax</code>, but the numerical comparison takes place with the
signs of the operands set to 0 (positive).
</div>
<div class="section" id="min">
<h3>min</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qmin(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_min(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to the minimum of a and b. If one of the operands is a quiet NaN
and the other is numeric, the numeric operand is returned.
</div>
<div class="section" id="min-mag">
<h3>min-mag</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qmin_mag(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_min_mag(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Same as <code class="xref c c-func docutils literal notranslate">mpd_qmin</code>, but the numerical comparison takes place with the
signs of the operands set to 0 (positive).
</div>
</div>
<div class="section" id="closest-numbers">
<h2>Closest Numbers</h2>
<div class="section" id="next-minus">
<h3>next-minus</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qnext_minus(mpd_t *result, const mpd_t *a,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_next_minus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
The closest representable number that is smaller than a.
</div>
<div class="section" id="next-plus">
<h3>next-plus</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qnext_plus(mpd_t *result, const mpd_t *a,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_next_plus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
The closest representable number that is larger than a.
</div>
<div class="section" id="next-toward">
<h3>next-toward</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qnext_toward(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_next_toward(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Representable number closest to a that is in the direction towards b.
</div>
</div>
<div class="section" id="quantizing-and-normalizing">
<h2>Quantizing and Normalizing</h2>
<div class="section" id="quantize">
<h3>quantize</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qquantize(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_quantize(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to the number that is equal in value to a, but has the exponent of b.
</div>
<div class="section" id="rescale">
<h3>rescale</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qrescale(mpd_t *result, const mpd_t *a, mpd_ssize_t exp,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_rescale(mpd_t *result, const mpd_t *a, mpd_ssize_t exp,
 mpd_context_t *ctx);
</pre></div>
</div>
Set result to the number that is equal in value to a, but has the exponent exp.
Special numbers are copied without signaling. This function is not part of the
standard. It is also not equivalent to the <code class="xref c c-func docutils literal notranslate">rescale</code> function that was removed
from the standard.
</div>
<div class="section" id="same-quantum">
<h3>same-quantum</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>int mpd_same_quantum(const mpd_t *a, const mpd_t *b);
</pre></div>
</div>
Return 1 if a and b have the same exponent, 0 otherwise.
</div>
<div class="section" id="reduce">
<h3>reduce</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qreduce(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_reduce(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
If a is finite after applying rounding and overflow/underflow checks, result
is set to the simplest form of a with all trailing zeros removed.
</div>
</div>
<div class="section" id="integral-values">
<h2>Integral Values</h2>
<div class="section" id="round-to-integral-exact">
<h3>round-to-integral-exact</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qround_to_intx(mpd_t *result, const mpd_t *a,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_round_to_intx(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Round to an integer, using the rounding mode of the context. Only a signaling
NaN causes an <code class="xref c c-macro docutils literal notranslate">MPD_Invalid_operation</code> condition.
</div>
<div class="section" id="round-to-integral-value">
<h3>round-to-integral-value</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qround_to_int(mpd_t *result, const mpd_t *a,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_round_to_int(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Same as <code class="xref c c-func docutils literal notranslate">mpd_qround_to_intx</code>, but the <code class="xref c c-macro docutils literal notranslate">MPD_Inexact</code> and
<code class="xref c c-macro docutils literal notranslate">MPD_Rounded</code> flags are never set.
</div>
<div class="section" id="floor">
<h3>floor</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qfloor(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_floor(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to the floor of a. Not part of the standard.
<div class="versionchanged">
Changed in version 2.5.0: The function now sets <code class="xref c c-macro docutils literal notranslate">MPD_Invalid_operation</code> if a is special.
Previously it followed <code class="xref c c-func docutils literal notranslate">mpd_round_to_int</code>, for which the specification
allows special values.
</div>
</div>
<div class="section" id="ceiling">
<h3>ceiling</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qceil(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_ceil(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
Set result to the ceiling of a. Not part of the standard.
<div class="versionchanged">
Changed in version 2.5.0: The function now sets <code class="xref c c-macro docutils literal notranslate">MPD_Invalid_operation</code> if a is special.
Previously it followed <code class="xref c c-func docutils literal notranslate">mpd_round_to_int</code>, for which the specification
allows special values.
</div>
</div>
<div class="section" id="truncate">
<h3>truncate</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qtrunc(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_trunc(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx);
</pre></div>
</div>
Set result to the truncated value of a. Not part of the standard.
<div class="versionchanged">
Changed in version 2.5.0: The function now sets <code class="xref c c-macro docutils literal notranslate">MPD_Invalid_operation</code> if a is special.
Previously it followed <code class="xref c c-func docutils literal notranslate">mpd_round_to_int</code>, for which the specification
allows special values.
</div>
</div>
</div>
<div class="section" id="scale">
<h2>Scale</h2>
<div class="section" id="logb">
<h3>logb</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qlogb(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_logb(mpd_t *result, const mpd_t *a, mpd_context_t *ctx);
</pre></div>
</div>
If a is NaN, the general rules apply. If a is infinite, result is +Infinity.
If a is zero, result is -Infinity and <code class="xref c c-macro docutils literal notranslate">MPD_Invalid_operation</code> is added
to status. Otherwise, result is the same as the adjusted exponent of a, or
<code class="xref c c-macro docutils literal notranslate">floor(log10(a))</code>.
</div>
<div class="section" id="scaleb">
<h3>scaleb</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qscaleb(mpd_t *result, const mpd_t *a, const mpd_t *b,
 const mpd_context_t *ctx, uint32_t *status);
void mpd_scaleb(mpd_t *result, const mpd_t *a, const mpd_t *b,
 mpd_context_t *ctx);
</pre></div>
</div>
b must be an integer with exponent 0. If a is infinite, result is set
to a. Otherwise, result is a with the value of b added to the exponent.
</div>
</div>
<div class="section" id="integer-functions">
<h2>Integer Functions</h2>
<div class="section" id="powmod">
<h3>powmod</h3>
<div class="highlight-c notranslate"><div class="highlight"><pre>void mpd_qpowmod(mpd_t *result, const mpd_t *base, const mpd_t *exp,
 const mpd_t *mod, const mpd_context_t *ctx,
 uint32_t *status);
void mpd_powmod(mpd_t *result, const mpd_t *base, const mpd_t *exp,
 const mpd_t *mod, mpd_context_t *ctx);
</pre></div>
</div>
Set result to (base ** exp) % mod. All operands must be integers.
The function fails if result does not fit in the current prec.
</div>
</div>
</div>

</div>
 </div>
 </div>
 <div class="clearer"></div>
 </div>
 <div class="related" role="navigation" aria-label="related navigation">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="various.html" title="Various Functions"
 >next</a></li>
 <li class="right" >
 <a href="attributes.html" title="Attributes of a Decimal"
 >previous</a> |</li>
 <li><a href="http://www.bytereef.org/mpdecimal/index.html">project home</a></li>
 
 </ul>
 </div>
 <div class="footer" role="contentinfo">
 &#169; Copyright 2010-2020, Stefan Krah.
 Created using <a href="http://sphinx-doc.org/">Sphinx</a> 2.4.4.
 </div>
 </body>
</html>

003 File Manager

Editing: arithmetic.html

Upload File

Create Folder