What is the best function or method for computing modulus (Remainder of $a divided by $b) in PHP?

Question

PHP provides different functions for computing modulus:

1. Modulus operator %: echo ($a % $b);
2. fmod()
3. bcmod()
4. gmp_mod()

Which function should be used that considered safe and efficient? considering the (devision by zero issue that described here: Division by zero error while using modulus and floating numbers?

Answer 1

1. Only the modulus operator (%), and fmod are native

2. The modulus operator cannot handle numbers beyond 2^32 (on PHP running x86 architecture)

3. fmod runs faster than bcmod/gmp_mod ~benchmark

4. bcmod doesn't work with floats ~here

I believe it is best to use fmod, simply because it's within Math Functions, runs way faster than other function, and most importantly, can handle large numbers and floats.

If you don't plan on using numbers past the limit or floats, use % as it should be the fastest.

Answer 2

All functions are safe to use provide one knows what is doing:

1. Modulus operator: is fast, precise but you need to stay under the max int. There is no division by zero issue whatsoever in this terms.

2. fmod: stil fast, floating point operation speed is no longer an issue in the past 10 years, but is tricky. Floating point numbers can reach much higher values but their precision not. So working with big numbers will increasingly introduce rounding errors. So will not solve anything the modulus operator lacks instead will introduce precision issues.

3. bcmod and gmp_mod are simmilar. The difference is that this functions use different implementation (modules) of arbitrary precision arithmetic. Their usage differs, but their results not: Theoretically the size of the numbers supported by this libraries is only limited by the amount of free memory, so practically the result will be always good and precise, however the algorithms used are overkill both computationally and from memory point of view.

Answer 3

You can still use the modulus operator and it can still be safe provided you plan to expect a zero at some point, as shown below.

if ($y > 0) {
  // Do the calculation
}
else {
  // Do this instead
}

For just hiding the warnings could also use an Error Control Operator. By using the @ Operator, the error is suppressed.

However with % an integer can only get so large before it gets converted into a float, hence the introduction of bcmod and fmod but please note they both have their own limitations.

I'd reccommend GMP or perhaps take a look at one of the other enhanced maths functions, there is also BCMath

Since you mentioned something safe there is a class for this: Eval Math

Here's an example using fmod

<?php
echo fmod('4294967296', 34);
?>

outputs 18

Answer 4

Note that fmod is NOT equivalent to this basic function:

    <?php 
    function modulo($a, $b) { 
    return $a - $b * floor($a / $b); 
    } 
    ?> 

because fmod() will return a value with the same sign as $a. In other words the floor() function is not correct as it rounds towards -INF instead of towards zero.

To emulate fmod($a, $b) the correct way is:

    <?php 
    function fmod($a, $b) { 
    return $a - $b * (($b < 0) ? ceil($a / $b) : floor($a / $b))); 
    } 
    ?> 

Note that both functions will throw a DIVISION BY ZERO if $b is null.

The first function modulo() above is the mathematical function which is useful for working on cyclic structures (such as calender computions or trignonometric functions :

    - fmod($a, 2*PI) returns a value in [0..2*PI) if $a is positive 
    - fmod($a, 2*PI) returns a value in [-2*PI..0] if $a is negative 
    - modulo($a, 2*PI) returns a value always in [0..2*PI) independantly of the sign of $a