remquo(), remquof(), remquol()

Compute the floating point remainder

Synopsis:

#include <math.h>

double remquo( double x, 
               double y,
               int *quo );

float remquof( float x, 
               float y,
               int *quo );

long double remquol( long double x, 
                     long double y,
                     int *quo );

Arguments:

x: The numerator of the division.
y: The denominator.
quo: A pointer to a location where the function can store the sign and at least the last three bits of x / y.

Library:

libm: The general-purpose math library.
libm-sve: (QNX Neutrino 7.1 or later) A library that optimizes the code for ARMv8.2 chips that have Scalable Vector Extension hardware.

Your system requirements will determine how you should work with these libraries:

If you want only selected processes to run with the SVE version, you can include both libraries in your OS image and use the -l m or -l m-sve option to qcc to link explicitly against the appropriate one.
If you want all processes to use the SVE version, include libm-sve.so in your OS image and set up a symbolic link from libm.so to libm-sve.so. Use the -l m option to qcc to link against the library.

Note: Compile your program with the -fno-builtin option to prevent the compiler from using a built-in version of the function.

Description:

The remquo(), remquof(), and remquol() functions compute the floating-point remainder of the division operation x / y, as remainder() does. Additionally, they store the sign and at least the three of the last bits of x / y in the location that quo points to, sufficient to determine the octant of the result within a period. The current rounding mode doesn't affect these functions.

These functions are useful when you're using periodic functions where the period is exactly representable as a floating-point value. For example, if you're calculating sin(πx) for a very large x, calling sin() directly may result in a large error; if you first reduce the function's argument with remquo(), you can use the low-order bits of the quotient to determine the sign and the octant of the result within the period, and use the remainder to calculate the value with high precision.

To check for error situations, use feclearexcept() and fetestexcept(). For example:

Call feclearexcept(FE_ALL_EXCEPT) before calling remquo(), remquof(), or remquol().
On return, if fetestexcept(FE_ALL_EXCEPT) is nonzero, then an error has occurred.

Returns:

The floating point remainder r = x - ny, where y is nonzero.

If:	These functions return:	Errors:
`x` is Inf	NaN	FE_INVALID
`x` or `y` is NaN	NaN	—
`x` isn't NaN, and `y` is zero	NaN	FE_INVALID

These functions raise FE_INEXACT if the FPU reports that the result can't be exactly represented as a floating-point number.

Classification:

C11, POSIX 1003.1

Safety:
Cancellation point	No
Interrupt handler	Yes
Signal handler	Yes
Thread	Yes