# remainder

## NAME



           drem, dremf, dreml, remainder, remainderf, remainderl - floating-
           point remainder function
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



           **#include <math.h>**
    
           **double remainder(double** _x_**, double** _y_**);**
           **float remainderf(float** _x_**, float** _y_**);**
           **long double remainderl(long double** _x_**, long double** _y_**);**
    
           /* Obsolete synonyms */
           **[[deprecated]] double drem(double** _x_**, double** _y_**);**
           **[[deprecated]] float dremf(float** _x_**, float** _y_**);**
           **[[deprecated]] long double dreml(long double** _x_**, long double** _y_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **remainder**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
                   || _XOPEN_SOURCE >= 500
                   || /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    
           **remainderf**(), **remainderl**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
                   || /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    
           **drem**(), **dremf**(), **dreml**():
               /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    


## DESCRIPTION



           These functions compute the remainder of dividing _x_ by _y_.  The
           return value is _x-n*y_ , where _n_ is the value _x / y_ , rounded to the
           nearest integer.  If the absolute value of _x-n*y_ is 0.5, _n_ is
           chosen to be even.
    
           These functions are unaffected by the current rounding mode (see
           fenv(3)).
    
           The **drem**() function does precisely the same thing.
    


## RETURN VALUE



           On success, these functions return the floating-point remainder,
           _x-n*y_.  If the return value is 0, it has the sign of _x_.
    
           If _x_ or _y_ is a NaN, a NaN is returned.
    
           If _x_ is an infinity, and _y_ is not a NaN, a domain error occurs,
           and a NaN is returned.
    
           If _y_ is zero, and _x_ is not a NaN, a domain error occurs, and a NaN
           is returned.
    


## ERRORS



           See math_error(7) for information on how to determine whether an
           error has occurred when calling these functions.
    
           The following errors can occur:
    
           Domain error: _x_ is an infinity and _y_ is not a NaN
                  _errno_ is set to **EDOM**(but see BUGS).  An invalid floating-
                  point exception (**FE_INVALID**) is raised.
    
                  These functions do not set _errno_ for this case.
    
           Domain error: _y_ is zero
                  _errno_ is set to **EDOM**.  An invalid floating-point exception
                  (**FE_INVALID**) is raised.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌──────────────────────────────────────┬───────────────┬─────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **drem**(), **dremf**(), **dreml**(),            │ Thread safety │ MT-Safe │
           │ **remainder**(), **remainderf**(),           │               │         │
           │ **remainderl**()                         │               │         │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           **remainder**()
           **remainderf**()
           **remainderl**()
                  C11, POSIX.1-2008.
    
           **drem**()
           **dremf**()
           **dreml**()
                  None.
    


## BUGS



           Before glibc 2.15, the call
    
               remainder(nan(""), 0);
    
           returned a NaN, as expected, but wrongly caused a domain error.
           Since glibc 2.15, a silent NaN (i.e., no domain error) is
           returned.
    
           Before glibc 2.15, _errno_ was not set to **EDOM** for the domain error
           that occurs when _x_ is an infinity and _y_ is not a NaN.
    


## EXAMPLES



           The call "remainder(29.0, 3.0)" returns -1.
    


* * *