std:: modf, std:: modff, std:: modfl

Parameter

Rückgabewert

Wenn keine Fehler auftreten, gibt den Bruchteil von num mit demselben Vorzeichen wie num zurück. Der ganzzahlige Teil wird in den Wert geschrieben, auf den iptr zeigt.

Die Summe des zurückgegebenen Werts und des in * iptr gespeicherten Werts ergibt num (unter Berücksichtigung von Rundung).

Fehlerbehandlung

Diese Funktion unterliegt keinen der in math_errhandling spezifizierten Fehlern.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

• Wenn num ±0 ist, wird ±0 zurückgegeben und ±0 wird in * iptr gespeichert.
• Wenn num ±∞ ist, wird ±0 zurückgegeben und ±∞ wird in * iptr gespeichert.
• Wenn num NaN ist, wird NaN zurückgegeben und NaN wird in * iptr gespeichert.
• Der zurückgegebene Wert ist exakt, der aktuelle Rundungsmodus wird ignoriert.

Hinweise

Diese Funktion verhält sich, als wäre sie wie folgt implementiert:

double modf(double num, double* iptr)
{
#pragma STDC FENV_ACCESS ON
    int save_round = std::fegetround();
    std::fesetround(FE_TOWARDZERO);
    *iptr = std::nearbyint(num);
    std::fesetround(save_round);
    return std::copysign(std::isinf(num) ? 0.0 : num - (*iptr), num);
}

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr Argument num vom Ganzzahltyp std :: modf ( num, iptr ) dieselbe Wirkung hat wie std :: modf ( static_cast < double > ( num ) , iptr ) .

Beispiel

#include <cmath>
#include <iostream>
#include <limits>
int main()
{
    double f = 123.45;
    std::cout << "Given the number " << f << " or " << std::hexfloat
              << f << std::defaultfloat << " in hex,\n";
    double f3;
    double f2 = std::modf(f, &f3);
    std::cout << "modf() makes " << f3 << " + " << f2 << '\n';
    int i;
    f2 = std::frexp(f, &i);
    std::cout << "frexp() makes " << f2 << " * 2^" << i << '\n';
    i = std::ilogb(f);
    std::cout << "logb()/ilogb() make " << f / std::scalbn(1.0, i) << " * "
              << std::numeric_limits<double>::radix
              << "^" << std::ilogb(f) << '\n';
    // special values
    f2 = std::modf(-0.0, &f3);
    std::cout << "modf(-0) makes " << f3 << " + " << f2 << '\n';
    f2 = std::modf(-INFINITY, &f3);
    std::cout << "modf(-Inf) makes " << f3 << " + " << f2 << '\n';
}

Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/ilogb() make 1.92891 * 2^6
modf(-0) makes -0 + -0
modf(-Inf) makes -INF + -0

Siehe auch