Fraction and remainder related functions#

Integral and fractional part of a floating point number: \(\mathrm{modf}(x)\)#

ctx.modf(x)#

where ctx is math53, ctxboost or ctxflint.

Returns (as a tuple) frac(\(x\)) and trunc(\(x\)) in ip, \(|x| <\) MaxLongint

Decomposes given floating point value num into integral and fractional parts, each having the same type and sign as num. The integral part (in floating-point format) is stored in the object pointed to by iptr.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

If num is \(\pm 0\), \(\pm 0\) is returned, and \(\pm 0\) is stored in *iptr.
If num is \(\pm \inf\), \(\pm 0\) is returned, and \(\pm \inf\) is stored in *iptr.
If num is NaN, NaN is returned, and NaN is stored in *iptr.

The returned value is exact, the current rounding mode is ignored.

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.Modf(0.5)
xreal('5.2359877559829887307E-1')
>>> xreal.Modf('0.51')
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.Modf(0.5)
Gpr('5.2359877559829887307E-1')
>>> Gpr.Modf('0.51')
Gpr('5.3518479027559984754E-1')

Floating point remainder: \(\mathrm{fmod}(x, y)\)#

ctx.fmod(x, y)#

where ctx is fpm, mpm, ipm, dec, gmp or apm. See also Mpmath [706].

!!! TypeError: unsupported operand type(s) for %: ‘ivmpf’ and ‘ivmpf’ !!!

!!! TypeError: unsupported operand type(s) for %: ‘arb3_t’ and ‘arb3_t’ !!!

Converts \(x\) and \(y\) to mpmath numbers and returns \(x \mod y\). For mpmath numbers, this is equivalent to x % y.

>>> from xlcalcnet import fp, mp, iv, dp, gp, ap
>>> for ctx in [fp, mp, dp, gp]: ctx.dps = 15;  print(repr(ctx.fmod(100, +ctx.pi)))
2.6106277387164134
mpf('2.6106277387164134')
Decimal('2.61062773871651')
mpfr('2.6106277387164134')

You can use fmod() to compute fractional parts of numbers:

>>> for ctx in [fp, mp, dp, gp]: ctx.dps = 15;  print(repr(ctx.fmod(10.25, 1)), end=', ')
0.25, mpf('0.25'), Decimal('0.25'), mpfr('0.25'),

where ctx is math53, ctxboost or ctxflint.

Returns \(x\) mod \(y\), \(y \ne 0\), sign(result) = sign(\(x\)).

The floating-point remainder of the division operation x / y calculated by this function is exactly the value x - rem * y, where rem is x / y with its fractional part truncated.

The returned value has the same sign as x and is less than y in magnitude.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

If x is \(\pm 0\) and y is not zero, \(\pm 0\) is returned.
If x is \(\pm \inf\) and y is not NaN, NaN is returned and FE_INVALID is raised.
If y is \(\pm 0\) and x is not NaN, NaN is returned and FE_INVALID is raised.
If y is \(\pm \inf\) and x is finite, x is returned.
If either argument is NaN, NaN is returned.

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.Fmod(0.5, 2)
xreal('5.2359877559829887307E-1')
>>> xreal.Fmod('0.51', 2)
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.Fmod(0.5, 2)
Gpr('5.2359877559829887307E-1')
>>> Gpr.Fmod('0.51', 2)
Gpr('5.3518479027559984754E-1')

IEEE floating point remainder: \(\mathrm{remainder}(x, y)\)#

ctx.remainder(x, y)#

where ctx is math53, ctxboost or ctxflint.

Returns the IEEE754 remainder x REM y = x - rmNearest(x/y)*y.

The IEEE floating-point remainder of the division operation x / y calculated by this function is exactly the value x - quo * y, where the value quo is the integral value nearest the exact value x / y. When |quo - x / y| = 0.5, the value quo is chosen to be even.

In contrast to std::fmod, the returned value is not guaranteed to have the same sign as x.

If the returned value is zero, it will have the same sign as x.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

The current rounding mode has no effect.
FE_INEXACT is never raised, the result is always exact.
If x is \(\pm \inf\) and y is not NaN, NaN is returned and FE_INVALID is raised.
If y is \(\pm 0\) and x is not NaN, NaN is returned and FE_INVALID is raised.
If either argument is NaN, NaN is returned.

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.Remainder(0.5, 2)
xreal('5.2359877559829887307E-1')
>>> xreal.Remainder('0.51', 2)
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.Remainder(0.5, 2)
Gpr('5.2359877559829887307E-1')
>>> Gpr.Remainder('0.51', 2)
Gpr('5.3518479027559984754E-1')

IEEE floating point remainder and part of quotient: \(\mathrm{remquo}(x, y)\)#

ctx.remquo(x, y)#

where ctx is math53, ctxboost or ctxflint.

Returns the IEEE754 remainder x REM y = x - rmNearest(x/y)*y.

Computes the floating-point remainder of the division operation \(x / y\) as the std::remainder function does. Additionally, the sign and at least three of the last bits of \(x / y\) will be stored in quo, sufficient to determine the octant of the result within a period.(formally, stores a value whose sign is the sign of \(x / y\) and whose magnitude is congruent modulo \(2^n\) to the magnitude of the integral quotient of \(x / y\), where \(n\) is an implementation-defined integer greater than or equal to 3).

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

The current rounding mode has no effect.

FE_INEXACT is never raised.

If x is \(\pm \inf\) and y is not NaN, NaN is returned and FE_INVALID is raised.

If y is \(\pm 0\) and x is not NaN, NaN is returned and FE_INVALID is raised.

If either x or y is NaN, NaN is returned.

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.Remainder(0.5, 2)
xreal('5.2359877559829887307E-1')
>>> xreal.Remainder('0.51', 2)
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.Remainder(0.5, 2)
Gpr('5.2359877559829887307E-1')
>>> Gpr.Remainder('0.51', 2)
Gpr('5.3518479027559984754E-1')

Fraction and remainder related functions

Contents

Fraction and remainder related functions#

Integral and fractional part of a floating point number: \(\mathrm{modf}(x)\)#

Floating point remainder: \(\mathrm{fmod}(x, y)\)#

IEEE floating point remainder: \(\mathrm{remainder}(x, y)\)#

IEEE floating point remainder and part of quotient: \(\mathrm{remquo}(x, y)\)#