Namespaces
Variants

std:: remainder, std:: remainderf, std:: remainderl

From 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)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definido en el encabezado <cmath>
(1)
float remainder ( float x, float y ) ;

double remainder ( double x, double y ) ;

long double remainder ( long double x, long double y ) ;
(hasta C++23)
constexpr /*floating-point-type*/

remainder ( /*floating-point-type*/ x,

/*floating-point-type*/ y ) ;
(desde C++23)
float remainderf ( float x, float y ) ;
(2) (desde C++11)
(constexpr desde C++23)
long double remainderl ( long double x, long double y ) ;
(3) (desde C++11)
(constexpr desde C++23)
Sobrecarga SIMD (desde C++26)
Definido en el encabezado <simd>
template < class V0, class V1 >

constexpr /*math-common-simd-t*/ < V0, V1 >

remainder ( const V0 & v_x, const V1 & v_y ) ;
(S) (desde C++26)
Definido en el encabezado <cmath>
template < class Integer >
double remainder ( Integer x, Integer y ) ;
(A) (constexpr desde C++23)
1-3) Calcula el resto IEEE de la operación de división de punto flotante x / y . La biblioteca proporciona sobrecargas de std::remainder para todos los tipos de punto flotante sin calificación cv como el tipo de los parámetros. (since C++23)
S) La sobrecarga SIMD realiza un std::remainder elemento por elemento en v_x y v_y .
(Consulte math-common-simd-t para su definición.)
(desde C++26)
A) Se proporcionan sobrecargas adicionales para todos los tipos enteros, los cuales son tratados como double .
(since C++11)

El resto de punto flotante IEEE de la operación de división x / y calculado por esta función es exactamente el valor x - quo * y , donde el valor quo es el valor integral más cercano al valor exacto x / y . Cuando |quo - x / y| = ½ , el valor quo se elige para que sea par.

A diferencia de std::fmod , el valor devuelto no está garantizado que tenga el mismo signo que x .

Si el valor devuelto es cero, tendrá el mismo signo que x .

Contenidos

Parámetros

x, y - valores de punto flotante o enteros

Valor de retorno

Si tiene éxito, retorna el resto de punto flotante IEEE de la división x / y como se definió anteriormente.

Si ocurre un error de dominio, se devuelve un valor definido por la implementación (NaN donde esté soportado).

Si ocurre un error de rango debido a subdesbordamiento, se devuelve el resultado correcto.

Si y es cero, pero no se produce el error de dominio, se devuelve cero.

Manejo de errores

Los errores se reportan como se especifica en math_errhandling .

Puede ocurrir un error de dominio si y es cero.

Si la implementación soporta aritmética de punto flotante IEEE (IEC 60559),

  • El modo de redondeo actual rounding mode no tiene efecto.
  • FE_INEXACT nunca se activa, el resultado siempre es exacto.
  • Si x es ±∞ y y no es NaN, se retorna NaN y se activa FE_INVALID .
  • Si y es ±0 y x no es NaN, se retorna NaN y se activa FE_INVALID .
  • Si cualquier argumento es NaN, se retorna NaN.

Notas

POSIX requiere que ocurra un error de dominio si x es infinito o y es cero.

std::fmod , pero no std::remainder , es útil para realizar el ajuste silencioso de tipos de punto flotante a tipos enteros sin signo: ( 0.0 <= ( y = std:: fmod ( std:: rint ( x ) , 65536.0 ) ) ) ? y : 65536.0 + y está en el rango [ - 0.0 , 65535.0 ] , que corresponde a unsigned short , pero std :: remainder ( std:: rint ( x ) , 65536.0 ) está en el rango [ - 32767.0 , + 32768.0 ] , que está fuera del rango de signed short .

Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su primer argumento num1 y segundo argumento num2 :

  • Si num1 o num2 tiene tipo long double , entonces std :: remainder ( num1, num2 ) tiene el mismo efecto que std :: remainder ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • En caso contrario, si num1 y/o num2 tiene tipo double o un tipo entero, entonces std :: remainder ( num1, num2 ) tiene el mismo efecto que std :: remainder ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • En caso contrario, si num1 o num2 tiene tipo float , entonces std :: remainder ( num1, num2 ) tiene el mismo efecto que std :: remainder ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(hasta C++23)

Si num1 y num2 tienen tipos aritméticos, entonces std :: remainder ( num1, num2 ) tiene el mismo efecto que std :: remainder ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , donde /*common-floating-point-type*/ es el tipo de punto flotante con el mayor rango de conversión de punto flotante y mayor subrango de conversión de punto flotante entre los tipos de num1 y num2 , los argumentos de tipo entero se consideran con el mismo rango de conversión de punto flotante que double .

Si no existe tal tipo de punto flotante con el mayor rango y subrango, entonces la resolución de sobrecarga no resulta en un candidato utilizable de las sobrecargas proporcionadas.

(desde C++23)

Ejemplo

Ejecutar este código 
#include <cfenv>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "remainder(+5.1, +3.0) = " << std::remainder(5.1, 3) << '\n'
              << "remainder(-5.1, +3.0) = " << std::remainder(-5.1, 3) << '\n'
              << "remainder(+5.1, -3.0) = " << std::remainder(5.1, -3) << '\n'
              << "remainder(-5.1, -3.0) = " << std::remainder(-5.1, -3) << '\n';
    // special values
    std::cout << "remainder(-0.0, 1.0) = " << std::remainder(-0.0, 1) << '\n'
              << "remainder(5.1, Inf) = " << std::remainder(5.1, INFINITY) << '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "remainder(+5.1, 0) = " << std::remainder(5.1, 0) << '\n';
    if (fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
}

Salida posible: 

remainder(+5.1, +3.0) = -0.9
remainder(-5.1, +3.0) = 0.9
remainder(+5.1, -3.0) = -0.9
remainder(-5.1, -3.0) = 0.9
remainder(-0.0, 1.0) = -0
remainder(5.1, Inf) = 5.1
remainder(+5.1, 0) = -nan
    FE_INVALID raised

Véase también

(C++11)
calcula el cociente y el resto de la división entera
(función)
(C++11) (C++11)
resto de la operación de división de punto flotante
(función)
(C++11) (C++11) (C++11)
resto con signo así como los tres últimos bits de la operación de división
(función)
Documentación C para remainder