I observed the following and would be thankful for an explanation.
$amount = 4.56;
echo ($amount * 100) % 5;
outputs : 0
However,
$amount = 456;
echo $amount % 5;
outputs : 1
I tried this code on two separate PHP installations, with the same result. Thanks for your help!
I strongly suspect this is because 4.56 can't be exactly represented as a binary floating point number, so a value very close to it is used instead. When multiplied by 100, that comes to 455.999(something), and then the modulo operator truncates down to 455 before performing the operation.
I don't know the exact details of PHP floating point numbers, but the closest IEEE-754 double to 4.56 is 4.55999999999999960920149533194489777088165283203125.
So here's something to try:
$amount = 455.999999999;
echo $amount % 5;
I strongly suspect that will print 0 too. From some PHP arithmetic documentation:
Operands of modulus are converted to integers (by stripping the decimal part) before processing.
Use fmod to avoid this problem.
Related
How can i do modulo arithmetic with decimal value since PHP only can do modulo with integer?
Example case:
echo 1.92 % 1000; // (int) 1, expected result should be 1.92
is there any library to do this correctly?
More info about this modulo arithmetic problem: https://bugs.php.net/bug.php?id=34399
There is also a floating point fmod() function
echo fmod(1.92, 1000)
http://php.net/manual/en/function.fmod.php
I think you wanted this one, this returns float result?
I am new to php and was doing some mathematics and found this weird thing happening.
$numOfDiffChars = 62;
$id = 285355773910;
$remainder = $id % $numOfDiffChars;
echo "Remainder: ".$remainder." ID: ".$id." NumOfElems: ".$numOfDiffChars." ",($id - floor($id/$numOfDiffChars)*$numOfDiffChars);
The answer is as follows:
Remainder: 10 ID: 285355773910 NumOfElems: 62 26
which states that % operator gives the remainder 10 whereas mathematically its 26. What could be the reason for this? Is it just some error that I committed or is there a logic?
I am not quite sure, but if your using a 32-bit machine the problem could be that the integer $id is out of bound and therefore interpreted as a floating point.
http://php.net/manual/en/language.types.integer.php
have you tried fmod function find example on --->
http://www.php.net/manual/en/function.fmod.php
From php.net
Note that operator % (modulus) works just with integers (between -214748348 and 2147483647) while fmod() works with short and large numbers.
This is killing me! I've never had so much trouble and I can't figure out what I'm doing wrong here.
If I have a number, say 2.32, and I want to do math with it it won't work out. The very simplest example:
$income = $commission; //Commission is 2.32, retrieved from XML
echo "income: $income<br>";
$income100 = $income*100;
echo "income100: $income100<br>";
The result I get is:
income: 2.32
income100: 200
How can I use a decimal number accurately with math without it changing it?
Thanks so much!
You need to assign $income in the following manner to get rid of the underlying SimpleXMLElement:
$income = (float) $commission;
Example of what happens when you don't:
$x = simplexml_load_string("<a>2.4</a>");
echo $x * 100; // output: 200
Besides using floats as Tim said, also make sure to use the BC Math functions when performing arithmetic operation on floating point numbers. Specifically bcmul():
$income100 = bcmul($income, 100);
The problem with floating-point numbers is that you cannot represent decimal numbers with them (unless it can be written as a/b for integer a and b, and even then only if abs(a) < pow(2,52) and b is a power of 2).
You may be better off using string functions to get an integer value:
$tmp = explode(".",$commission);
$tmp = intval($tmp[0].str_pad(substr($tmp[1],0,2),2,"0"));
This will split up the integer part from the decimal part, ensure the decima part is two digits long, and shove it on the end of the integer part, thus effectively multiplying the original number by 100.
I think the easiest solution would be to cast it to a float with floatval()
$income = floatval($comission)
leave the rest of the code as is and it should work as intended.
I've been wrestling with PHP's ceil() function giving me slightly wrong results - consider the following:
$num = 2.7*3; //float(8.1)
$num*=10; //float(81)
$num = ceil($num); //82, but shouldn't this be 81??
$num/=10; //float(8.2)
I have a number which may have any number of decimal places, and I need it rounded up to one decimal place.
i.e 8.1 should be 8.1, 8.154 should be 8.2, and 8 should be left as 8.
How I've been getting there is to take the number, multiply by 10, ceil() it, then divide by ten but as you can see I'm getting an extra .1 added in some circumstances.
Can anyone tell my why this is happening, and how to fix it?
Any help greatly appreciated
EDIT: had +=10 instead of *=10 :S
EDIT 2:
I didn't explicitly mention this but I need the decimal to ALWAYS round UP, never down - this answer is closest so far:
rtrim(rtrim(sprintf('%.1f', $num), '0'), '.');
However rounds 3.84 down to 3.8 when I need 3.9.
Sorry this wasn't clearer :(
Final Edit:
What I ended up doing was this:
$num = 2.7*3; //float(8.1)
$num*=10; //float(81)
$num = ceil(round($num, 2)); //81 :)
$num/=10; //float(8.1)
Which works :)
This is more than likely due to floating point error.
http://support.microsoft.com/kb/42980
http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.html
http://joshblog.net/2007/01/30/flash-floating-point-number-errors/
http://en.wikipedia.org/wiki/Floating_point
You may have luck trying this procedure instead.
<?php
$num = 2.7*3;
echo rtrim(rtrim(sprintf('%.1f', $num), '0'), '.');
Floats can be a fickle thing. Not all real numbers can be properly represented in a finite number of binary bits.
As it turns out, a decimal section of 0.7 is one of those numbers (comes out 0.10 with an infinity repeating "1100" after it). You end up with a number that's ever so slightly above 0.7, so when you multiply by 10, you have a one's digit slightly above 7.
What you can do is make a sanity check. Take you float digit and subtract it's integer form. If the resulting value is less than, say, 0.0001, consider it to be an internal rounding error and leave it as-is. If the result is greater than 0.0001, apply ceil() normally.
Edit: A fun example you can do if you're on windows to show this is to open up the built in calculator application. Put in "4" then apply a square root function (with x^y where y=0.5). You'll see it properly displays "2". Now, subtract 2 from it and you'll see that you don't have 0 as a result. This is caused by internal rounding errors when it attempted to compute the square root of 4. When displaying the number 2 earlier, it knew that those very distant trailing digits were probably a rounding error, but when those are all that's left, it gets a bit confused.
(Before anybody gets onto me about this, I understand that this is oversimplified, but nonetheless I consider it a decent example.)
Convert your number to a string and ceil the string.
function roundUp($number, $decimalPlaces){
$multi = pow(10, $decimalPlaces);
$nrAsStr = ($number * $multi) . "";
return ceil($nrAsStr) / $multi;
}
The problem is that floating point numbers are RARELY what you expect them to be. Your 2.7*3 is probably coming out to be something like 81.0000000000000000001, which ceil()'s up to 82. For this sort of thing, you'll have to wrap your ceil/round/floor calls with some precision checks, to handle those extra microscopic differences.
Use %f instead of %.1f.
echo rtrim(rtrim(sprintf('%f', $num), '0'), '.');
Why not try this:
$num = 2.7*3;
$num *= 100;
$num = floor($num);
$num /= 10;
$num = ceil($num);
$num /= 10;
How does one divide numbers but exclude the remainder in PHP?
Just cast the resulting value to an int.
$n = (int) ($i / $m);
Interesting functions (depending on what you want to achieve and if you expect negative integers to get devided) are floor(), ceil() and round().
PHP 7 has a new built-in function for this named intdiv.
Example:
$result = intdiv(13, 2);
The value of $result in this example will be 6.
You can find the full documentation for this function in the PHP documentation.
For most practical purposes, the accepted answer is correct.
However, for builds where integers are 64 bits wide, not all possible integer values are representable as a double-precision float; See my comment on the accepted answer for details.
A variation of
$n = ($i - $i % $m) / $m;
(code taken from KingCrunch's comment under another answer) will avoid this problem depending on the desired rounding behavior (bear in mind that the result of the modulus operator may be negative).
In addition to decisions above like $result = intval($a / $b) there is one particular case:
If you need an integer division (without remainder) by some power of two ($b is 2 ^ N) you can use bitwise right shift operation:
$result = $a >> $N;
where $N is number from 1 to 32 on 32-bit operating system or 64 for 64-bit ones.
Sometimes it's useful because it's fastest decision for case of $b is some power of two.
And there's a backward (be careful due to overflow!) operation for multiplying by power of two:
$result = $a << $N;
Hope this helps for someone too.
or you could just do intval(13 / 2)
gives 6
use modulo in php:
$n = $i % $m;