```
If you are running a php version older than 5.6, you can calculate $a ** $b by using exp($b*log($a))
```

Remember basic arithmetic from school? These work just like those.

Example | Name | Result |
---|---|---|

-$a | Negation | Opposite of .$a |

$a + $b | Addition | Sum of and $a.$b |

$a - $b | Subtraction | Difference of and $a.$b |

$a * $b | Multiplication | Product of and $a.$b |

$a / $b | Division | Quotient of and $a.$b |

$a % $b | Modulus | Remainder of divided by $a.$b |

$a ** $b | Exponentiation | Result of raising to the $a'th power. Introduced in PHP 5.6.$b |

The division operator ("/") returns a float value unless the two operands are integers (or strings that get converted to integers) and the numbers are evenly divisible, in which case an integer value will be returned.

Operands of modulus are converted to integers (by stripping the decimal part) before processing.

The result of the modulus operator *%* has the same sign
as the dividend — that is, the result of *$a % $b*
will have the same sign as ` $a`. For example:

```
<?php
```

echo (5 % 3)."\n"; // prints 2

echo (5 % -3)."\n"; // prints 2

echo (-5 % 3)."\n"; // prints -2

echo (-5 % -3)."\n"; // prints -2

?>

See also the manual page on Math functions.

add a note
### User Contributed Notes 12 notes

```
If you are running a php version older than 5.6, you can calculate $a ** $b by using exp($b*log($a))
```

```
A very simple yet maybe not obvious use of the modulus (%) operator is to check if an integer is odd or even.
```

<?php

if (($a % 2) == 1)

{ echo "$a is odd." ;}

if (($a % 2) == 0)

{ echo "$a is even." ;}

?>

This is nice when you want to make alternating-color rows on a table, or divs.

<?php

for ($i = 1; $i <= 10; $i++) {

if(($i % 2) == 1) //odd

{echo "<div class=\"dark\">$i</div>";}

else //even

{echo "<div class=\"light\">$i</div>";}

}

?>

```
When dealing purely with HTML, especially tables, or other things in "grids" the modulous operator is really useful for splitting up the data with a seperator.
```

This snippet reads any gif files from the directory the script is in, prints them out and puts in a break every 5th image.

<?php

$d = dir('./');

$i = 0;

while(false !== ($e = $d->read())){

if(strpos($e,'.gif')){

++$i;

echo '<img src="'.$e.'"/>'.chr(10);

if(!($i%5))

echo '<br/>';

}

}

?>

For tables just put </tr><tr> in place of the break.

```
Note that operator % (modulus) works just with integers (between -214748348 and 2147483647) while fmod() works with short and large numbers.
```

Modulus with non integer numbers will give unpredictable results.

```
It is worth noticing that when working with large numbers, most noticably using the modulo operator, the results depend on your CPU architecture. Therefore, running a decent 64-bit machine will be to your advantage in case you have to perform complex mathematical operations. Here is some example code - you can compare its output on x86 and x86_64 machines:
```

<?php

/* tested under PHP 5.2.6-1 with Suhosin-Patch 0.9.6.2 (cli) on both i386 and amd64, Debian lenny/sid */

$a = 2863311530;

$b = 256;

$c = $a % $b;

echo "$c <br />\n";

echo (2863311530 % 256)." <br />\n"; /* directly with no variables, just to be sure */

?>

The code is expected to produce '170' if working correctly (try it in spreadsheet software).

```
The % operator doesn't behave as many people with a maths background would expect, when dealing with negative numbers. For example, -1 mod 8 = 7, but in PHP, -1 % 8 = -1.
```

The following function has the expected behaviour:

function mod($a, $n) {

return ($a % $n) + ($a < 0 ? $n : 0);

}

mod(-1, 8) returns 7 as expected.

```
Be careful when using % with large numbers.
```

The code:

<?php

echo 3333333333 % 3

?>

puts out -1 instead of zero!

(Due to the overflow)

```
It appears floating-point infinity (INF) is not returned from divide by zero (in PHP 5.0.0). Instead a warning is given and Boolean FALSE is returned.
```

I searched the various manuals and did not find relevant explanation, so am adding this.

```
a real simple method to reset an integer to a the next lowest multiple of a divisor
```

$startSeq = $startSeq - ($startSeq % $entriesPerPage);

if $startSeq was already a multiple, then " $startSeq % $entriesPerPage " will return 0 and $startSeq will not change.

```
For larger numbers (above PHP_INT_MAX), use fmod() rather than %.
```

The other operators (+-*/) work correctly with floats and integer overflow, but % uses integer wrap. Eg.

<?php

var_dump(0xffffffff % 2);

//Prints int(-1) which is WRONG

var_dump(intval(fmod(0xffffffff,2)));

//Prints int(1) which is the right answer

?>

(The reason this matters is that PHP's float is actually a double, and can accurately represent integers up to 52-bits, even on 32-bit systems)

```
not listed here is the absolutely useless unary plus.
```

<?php

$a = -3;

$a = +$a;

var_dump( $a ); // int(-3)

```
<?php
```

//using range function()

//$numbers = array;range = value

$numbers= range (1,100);

// foreach ($array as $value)

//{Do something with $value}

foreach ($numbers as $value)

{echo "<p>This is number: $value</P>";}

?>