Namespaces
Variants

    std:: frexp, std:: frexpf, std:: frexpl

    From ru.cppreference.net
    C++
    Numerics library
    Common mathematical functions
    Nearest integer floating point operations
    (C++11)
    (C++11)
    (C++11) (C++11) (C++11)
    Floating point manipulation functions
    (C++11) (C++11)
    (C++11)
    (C++11)
    frexp
    (C++11) (C++11)
    (C++11)
    Classification and comparison
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    Types
    (C++11)
    (C++11)
    (C++11)
    Macro constants
    Определено в заголовке <cmath>
    (1)
    float frexp ( float num, int * exp ) ;

    double frexp ( double num, int * exp ) ;

    long double frexp ( long double num, int * exp ) ;
    		(до C++23)
    constexpr /* floating-point-type */
    frexp ( /* floating-point-type */ num, int * exp ) ;
    		(начиная с C++23)
    float frexpf ( float num, int * exp ) ;
    		(2) (начиная с C++11)
    (constexpr начиная с C++23)
    long double frexpl ( long double num, int * exp ) ;
    		(3) (начиная с C++11)
    (constexpr начиная с C++23)
    Определено в заголовке <cmath>
    template < class Integer >
    double frexp ( Integer num, int * exp ) ;
    		(A) (constexpr начиная с C++23)
    1-3) Разлагает заданное значение с плавающей точкой num на нормализованную мантиссу и целочисленный показатель степени двойки. Библиотека предоставляет перегрузки std::frexp для всех типов с плавающей точкой без cv-квалификаторов в качестве типа параметра num . (начиная с C++23)
    A) Дополнительные перегрузки предоставляются для всех целочисленных типов, которые трактуются как double .
    		(since C++11)

    Содержание

    Параметры

    num - значение с плавающей точкой или целочисленное значение
    exp - указатель на целочисленное значение для сохранения экспоненты

    Возвращаемое значение

    Если num равен нулю, возвращает ноль и сохраняет ноль в * exp .

    В противном случае (если num не равен нулю), если ошибок не возникает, возвращает значение x в диапазоне (-1, -0.5], [0.5, 1) и сохраняет целочисленное значение в * exp такое, что x×2 (*exp)
    == num     .

    Если значение, которое должно быть сохранено в * exp , выходит за пределы диапазона int , поведение не определено.

    Обработка ошибок

    Эта функция не подвержена никаким ошибкам, указанным в math_errhandling .

    Если реализация поддерживает арифметику с плавающей запятой IEEE (IEC 60559),

    • Если num равен ±0, он возвращается без изменений, и в * exp сохраняется ​ 0 ​ .
    • Если num равен ±∞, он возвращается, и в * exp сохраняется неопределённое значение.
    • Если num является NaN, возвращается NaN, и в * exp сохраняется неопределённое значение.
    • Исключения с плавающей точкой не возникают.
    • Если FLT_RADIX равен 2 (или степени двойки), возвращаемое значение является точным, текущий режим округления игнорируется.

    Примечания

    В двоичной системе (где FLT_RADIX равен 2 ), std::frexp может быть реализована как 

    {
    *exp = (value == 0) ? 0 : (int)(1 + std::logb(value));
    return std::scalbn(value, -(*exp));
}
    **Примечание:** Весь код C++ оставлен без изменений, как и требовалось, поскольку он находится внутри тегов `
    ` и содержит C++ специфичные термины. HTML разметка также сохранена в оригинальном виде.

    Функция std::frexp вместе со своей парной функцией, std::ldexp , может использоваться для манипуляции представлением числа с плавающей запятой без прямых битовых операций.

    Дополнительные перегрузки не обязаны быть предоставлены в точности как (A) . Они лишь должны быть достаточными для обеспечения того, чтобы для их аргумента num целочисленного типа std :: frexp ( num, exp ) имел тот же эффект, что и std :: frexp ( static_cast < double > ( num ) , exp ) .

    Пример

    Сравнивает различные функции декомпозиции чисел с плавающей запятой:

    Запустить этот код 
    #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';
}

    Возможный вывод: 

    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

    Смотрите также

    (C++11) (C++11)
    		умножает число на 2 в целочисленной степени
    (функция)
    (C++11) (C++11) (C++11)
    		извлекает экспоненту числа
    (функция)
    (C++11) (C++11) (C++11)
    		извлекает экспоненту числа
    (функция)
    (C++11) (C++11)
    		разлагает число на целую и дробную части
    (функция)
    Документация C для frexp