Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg

PHP : Function Reference : Mathematical Functions

Mathematical Functions


These math functions will only handle values within the range of the integer and float types on your computer (this corresponds currently to the C types long resp. double). If you need to handle bigger numbers, take a look at the arbitrary precision math functions.

See also the manual page on arithmetic operators.


No external libraries are needed to build this extension.


There is no installation needed to use these functions; they are part of the PHP core.

Runtime Configuration

This extension has no configuration directives defined in php.ini.

Resource Types

This extension has no resource types defined.

Predefined Constants

The constants below are always available as part of the PHP core.

Table 158. Math constants

Constant Value Description
M_PI 3.14159265358979323846 Pi
M_E 2.7182818284590452354 e
M_LOG2E 1.4426950408889634074 log_2 e
M_LOG10E 0.43429448190325182765 log_10 e
M_LN2 0.69314718055994530942 log_e 2
M_LN10 2.30258509299404568402 log_e 10
M_PI_2 1.57079632679489661923 pi/2
M_PI_4 0.78539816339744830962 pi/4
M_1_PI 0.31830988618379067154 1/pi
M_2_PI 0.63661977236758134308 2/pi
M_SQRTPI 1.77245385090551602729 sqrt(pi) [5.2.0]
M_2_SQRTPI 1.12837916709551257390 2/sqrt(pi)
M_SQRT2 1.41421356237309504880 sqrt(2)
M_SQRT3 1.73205080756887729352 sqrt(3) [5.2.0]
M_SQRT1_2 0.70710678118654752440 1/sqrt(2)
M_LNPI 1.14472988584940017414 log_e(pi) [5.2.0]
M_EULER 0.57721566490153286061 Euler constant [5.2.0]

Only M_PI is available in PHP versions up to and including PHP 4.0.0. All other constants are available starting with PHP 4.0.0. Constants labeled [5.2.0] were added in PHP 5.2.0.

Table of Contents

abs — Absolute value
acos — Arc cosine
acosh — Inverse hyperbolic cosine
asin — Arc sine
asinh — Inverse hyperbolic sine
atan2 — Arc tangent of two variables
atan — Arc tangent
atanh — Inverse hyperbolic tangent
base_convert — Convert a number between arbitrary bases
bindec — Binary to decimal
ceil — Round fractions up
cos — Cosine
cosh — Hyperbolic cosine
decbin — Decimal to binary
dechex — Decimal to hexadecimal
decoct — Decimal to octal
deg2rad — Converts the number in degrees to the radian equivalent
exp — Calculates the exponent of e
expm1 — Returns exp(number) - 1, computed in a way that is accurate even when the value of number is close to zero
floor — Round fractions down
fmod — Returns the floating point remainder (modulo) of the division of the arguments
getrandmax — Show largest possible random value
hexdec — Hexadecimal to decimal
hypot — Calculate the length of the hypotenuse of a right-angle triangle
is_finite — Finds whether a value is a legal finite number
is_infinite — Finds whether a value is infinite
is_nan — Finds whether a value is not a number
lcg_value — Combined linear congruential generator
log10 — Base-10 logarithm
log1p — Returns log(1 + number), computed in a way that is accurate even when the value of number is close to zero
log — Natural logarithm
max — Find highest value
min — Find lowest value
mt_getrandmax — Show largest possible random value
mt_rand — Generate a better random value
mt_srand — Seed the better random number generator
octdec — Octal to decimal
pi — Get value of pi
pow — Exponential expression
rad2deg — Converts the radian number to the equivalent number in degrees
rand — Generate a random integer
round — Rounds a float
sin — Sine
sinh — Hyperbolic sine
sqrt — Square root
srand — Seed the random number generator
tan — Tangent
tanh — Hyperbolic tangent

Code Examples / Notes » ref.math


while joogat's one line function is short, it is probably better to calculate factorial iteratively instead of recursively. keep in mind if you want large factorials, you'll need to use some sort of arbitrary precision integer or perhaps the BCMath functions. then again, unless you're trying to do large numbers (170! is the highest that you can do that does not return infinity) you probably won't notice any time difference.
function factorial($in) {
   // 0! = 1! = 1
   $out = 1;
   // Only if $in is >= 2
   for ($i = 2; $i <= $in; $i++) {
       $out *= $i;
   return $out;


well just a note.. maybe i'm a bit stupid.. but remember to use pow() rather than the "^" sign for exponents.. as it took me 5 minutes to figure out why it wasn't working.


Under some circumstances, it is appropriate to round floats to a given number of significant digits. This function will do it for you:
* Round to significant digits
* @param float   $f The number to be rounded
* @param integer $n Number of significant digits
function round_significant($f, $n)
   if ($f==0) return $f;
   return round($f, $n-floor(log10(abs($f)))-1);


Two functions I didn't find elsewhere... one to compute mean of an array of numbers, and another to computer variance of a sample of numbers. Both take an array of numbers as arguments. Not much error checking, or optimization...
(note: variance function uses the average function...)
function average($arr)
if (!count($arr)) return 0;
$sum = 0;
for ($i = 0; $i < count($arr); $i++)
$sum += $arr[$i];
return $sum / count($arr);
function variance($arr)
if (!count($arr)) return 0;
$mean = average($arr);
$sos = 0; // Sum of squares
for ($i = 0; $i < count($arr); $i++)
$sos += ($arr[$i] - $mean) * ($arr[$i] - $mean);
return $sos / (count($arr)-1);  // denominator = n-1; i.e. estimating based on sample
// n-1 is also what MS Excel takes by default in the
// VAR function
echo variance(array(4,6,23,15,18)); // echoes 64.7...correct value :)


To add to what Cornelius had, I have written a function that will take an array of numbers and return the least common multiple of them:
function lcm_arr($items){
//Input: An Array of numbers
//Output: The LCM of the numbers
while(2 <= count($items)){
array_push($items, lcm(array_shift($items), array_shift($items)));
return reset($items);
//His Code below with $'s added for vars
function gcd($n, $m) {
  $n=abs($n); $m=abs($m);
  if ($n==0 and $m==0)
      return 1; //avoid infinite recursion
  if ($n==$m and $n>=1)
      return $n;
  return $m<$n?gcd($n-$m,$n):gcd($n,$m-$n);
function lcm($n, $m) {
  return $m * ($n/gcd($n,$m));


to "convert" scientific notation to a float simply cast it:
$val = '3.5e4';
$val = (float) $val;
echo $val;


Tim's fix of Evan's ordinal function causes another problem, it no longer works for number above 100.  (E.g. it returns 111st instead of 111th).  
Here is a further modified version which should work for all numbers.
function ordinal($cardinal)    {
 $cardinal = (int)$cardinal;
 $digit = substr($cardinal, -1, 1);
 if ($cardinal <100) $tens = round($cardinal/10);
 else $tens = substr($cardinal, -2, 1);
 if($tens == 1)  {
   return $cardinal.'th';
 switch($digit) {
   case 1:
     return $cardinal.'st';
   case 2:
     return $cardinal.'nd';
   case 3:
     return $cardinal.'rd';
     return $cardinal.'th';


This might be useful in generating fractional numbers for construction, if only because most carpenters would rather put a nail in your foot than hear about any number that ends with .8125".
Since I couldn't figure out the fraction code above, this is my simple-minded take on the problem. Also, align by "char" doesn't seem to work yet in html, so it seems necessary to use tables (egad!) to make numbers align properly. The following code illustrates a way to make a dynamically sized table with aligned fractions from an array of random numbers. Since I don't care about fractions less than 1/16, this rounds them into oblivion. Also, it sorts the list from long to short and collates multiples in the array. One bit of cleverness here (gleaned from these pages) that might not be obvious: I'm using 1 *bitwise and* (1 &) to determine odd numbers.
If you copy and paste the following code, try refreshing the page a few times to see how the table adjusts itself.
// get some numbers to play with
$x = rand(0,130000)/10;
$y = rand(0,1200);
$z = rand(0,4)/64;
$array = array($x, $x, $x, $y, $y, $z, 324.19, 425/7, sqrt(2), pi(), pi());
// functions
function mult($n) { return intval (round ($n*16)); }
function frac($num) { $mod = fmod ($num,1)*16;
if (1 & $mod) { return " - ".$mod."/16"; }
else $mod = $mod/2;
if (1 & $mod) { return " - ".$mod."/8"; }
else $mod = $mod/2;
if (1 & $mod) { return " - ".$mod."/4"; }
else $mod = $mod/2;
if (1 & $mod) {return " - ".$mod."/2";}
// make a table
echo '<table>';
$array = array_map("mult", $array);
$array = (array_filter($array, strval)); //get rid of zeros
$array = (array_count_values ($array));
krsort ($array);
while (list ($key, $val) = each ($array)) {
$key = $key/16;
echo "<tr><td>$val</td><td>&nbsp; @ &nbsp;</td><td align=\"right\">".intval($key)." </td><td> ".frac($key)." </td></tr>";
echo '</table>';


This is an efficient method of calculating the binomial coefficient C(n,k). This code was derived from Owant: Mastering Algorithms with Perl.
  // calculate binomial coefficient
  function binomial_coeff($n, $k) {
     $j = $res = 1;
     if($k < 0 || $k > $n)
        return 0;
     if(($n - $k) < $k)
        $k = $n - $k;
     while($j <= $k) {
        $res *= $n--;
        $res /= $j++;
     return $res;
If you compiled php with --enable-bcmath, you can get full integer values of extremely large numbers by replacing:
$res *= $n--;
$res /= $j++;
$res = bcmul($res, $n--);
$res = bcdiv($res, $j++);

nazgul26 at_sign windfox dot net

This code will convert a decimal to it's fraction equivalent. The precision can be set by changing PRECISION.
define(PRECISION, .01);
$count = count($result);
$simp_fract = simplifyFraction($result,$count,1,$result[$count]);
echo $simpl_fract;
// Start of functions
  Converts a decimal to unsimplified fraction represented in an array
function decimalToFraction($decimal,$count,$result) {
$a = (1/$decimal);
$b = ( $a - floor($a)  );
if ($b > .01 && $count <= 5) decimalToFraction($b,$count,&$result);
$result[$count] = floor($a);
   Simplifies a fraction in an array form that is returned from  
function simplifyFraction($fraction,$count,$top,$bottom) {
$next = $fraction[$count-1];
$a = ($bottom * $next) + $top;
$top = $bottom;
$bottom = $a;
if ($count > 0) simplifyFraction($fraction,$count,$top,$bottom);
else {
return "<font size=1>$bottom/$top</font>";


Theres another faster way of doing even/odd number checking by using bitwise operators. Don't ask me how it works, I just found this out by experimenting with it (could the editor possibly explain?)
if ((1&$num)) {
echo "$num is odd";
if (!(1&$num)) {
echo "$num is even";
How it works is (1&$num) returns a 1 for odd numbers and returns 0 when it's an even number.


thearbitcouncil at gmail dot com, you could just use array_sum():
function average($arr)
  if (!is_array($arr)) return false;
  return array_sum($arr)/count($arr);
$array = array(5, 10, 15);
echo average($array); // 10


The reason the bitwise AND ("&") operator works to determine whether a number is odd or even is because odd numbers expressed in binary always have the rightmost (2^0) bit = 1 and even numbers always have the 2^0 bit = 0.
So if you do a " 1 & $num", it will return zero if the number is even (since xxxxxxx0 [the even number in binary] and 00000001 [the 1]) don't share any bits, and will return 1 if the number is odd (xxxxxx1 and 000001).
a clever way of doing things, but $num % 2 would work as well i think :).


The fastest O(1) factorial function has a lookup table of all the factorials that fit within the output range. With an array of the first 34 (float) or 170 (double) factorials, you get identical results in a fraction of the time.


The example for Factorials given above is wrong. Here a correct version, so that you do not have to reinvent the wheel again...
function mathFact( $s )
 $r = (int) $s;
 if ( $r < 2 )
   $r = 1;
 else {
   for ( $i = $r-1; $i > 1; $i-- )
     $r = $r * $i;
 return( $r );


Thanks to Chronial "at", I was able to create the binompdf(n, p, k) function.
function nCr($n, $k){
  if ($k > $n)
    return NaN;
  if (($n - $k) < $k)
    return nCr($n, ($n - $k));
  $return = 1;
  for ($i=0; $i<$k; $i++){
    $return *= ($n - $i) / ($i + 1);
  return $return;
function binompdf($n, $p, $k){
   $return = nCr($n, $k) * pow($p, $k) * pow((1 - $p), ($n - $k));
   return $return;


Please note that shorter is not always better
(meaning that really short faculty implementation above).
In my opinion, a clearer way to code this is, including a check
for negative or non-integer values.
In order to calculate the faculty of a positive integer,
an iterative way (which might be harder to understand)
is usually a bit faster, but I am using it only for small
values so it is not really important to me:
// Calculate the Faculty of a positive int-value
function iFaculty($a_iFac)
  if ($a_iFac > 0)
  return $a_iFac * $this->iFaculty($a_iFac - 1);
  elseif ($a_iFac == 0)
  return 1;
  return 0;  // Wrong argument!
I've also written another function to calculate the
binomial coefficient of 2 values, I didn't find it anywhere yet so I hope it might help someone (works fine with the above stated faculty-function and ready to be used inside of your own classes!)
// calculates the binomial coefficient "n over k" of 2 positive int values
// für n >= k
function iBinCoeff($a_iN, $a_iK)
// the binomial coefficient is defined as n! / [ (n-k)! * k! ]
return $this->iFaculty($a_iN) / ($this->iFaculty($a_iN - $a_iK) * $this->iFaculty($a_iK));


Occasionally a user must enter a number in a form. This function converts fractions to decimals and leaves decimals untouched. Of course, you may wish to round the final output, but that is not included here.
/*Some example values of $q
$q = "2.5";
$q = "2 1/2";
$q = "5/2";
function Deci_Con($q){
//check for a space, signifying a whole number with a fraction
if(strstr($q, ' ')){
$wa = strrev($q);
$wb = strrev(strstr($wa, ' '));
$whole = true;//this is a whole number
//now check the fraction part
if(strstr($q, '/')){
if($whole==true){//if whole number, then remove the whole number and space from the calculations
      $q = strstr($q, ' ');
$b = str_replace("/","",strstr($q, '/'));//this is the divisor
//isolate the numerator
$c = strrev($q);
$d = strstr($c, '/');
$e = strrev($d);
$a = str_replace("/","",$e);//the pre-final numerator
if($whole==true){//add the whole number to the calculations
$a = $a+($wb*$b);//new numerator is whole number multiplied by denominator plus original numerator    
$q = $a/$b;//this is now your decimal
return $q;
return $q;//not a fraction, just return the decimal


Method to convert an arbitrary decimal number to its most reduced fraction form (so a string is returned, this method would probably be used for output formatting purposes.)  There were other methods similar to this one on the page, but none did quite what I wanted.  It's maybe not the most elegant code, but it gets the job done.  Hope this helps someone.  An iterative form of Euclid's algorithm is used to find the GCD.
function dec2frac( $decimal )
 $decimal = (string)$decimal;
 $num = '';
 $den = 1;
 $dec = false;
 // find least reduced fractional form of number
 for( $i = 0, $ix = strlen( $decimal ); $i < $ix; $i++ )
   // build the denominator as we 'shift' the decimal to the right
   if( $dec ) $den *= 10;
   // find the decimal place/ build the numberator
   if( $decimal{$i} == '.' ) $dec = true;
   else $num .= $decimal{$i};
 $num = (int)$num;

 // whole number, just return it
 if( $den == 1 ) return $num;

 $num2 = $num;
 $den2 = $den;
 $rem  = 1;
 // Euclid's Algorithm (to find the gcd)
 while( $num2 % $den2 ) {
   $rem = $num2 % $den2;
   $num2 = $den2;
   $den2 = $rem;
 if( $den2 != $den ) $rem = $den2;

 // now $rem holds the gcd of the numerator and denominator of our fraction
 return ($num / $rem ) . "/" . ($den / $rem);
echo dec2frac( 10 );
echo dec2frac( .5 );
echo dec2frac( 5.25 );
echo dec2frac( .333333333 );


number median ( number arg1, number arg2 [, number ...] )
number median ( array numbers )
function median()
   $args = func_get_args();
       case 0:
           trigger_error('median() requires at least one parameter',E_USER_WARNING);
           return false;
       case 1:
           $args = array_pop($args);
           // fallthrough
           if(!is_array($args)) {
               trigger_error('median() requires a list of numbers to operate on or an array of numbers',E_USER_NOTICE);
               return false;
           $n = count($args);
           $h = intval($n / 2);
           if($n % 2 == 0) {
               $median = ($args[$h] + $args[$h-1]) / 2;
           } else {
               $median = $args[$h];
   return $median;


Just a simple function to find the ordinal ending to any number if you're printing for example: "The nth result is..."
function ordinal($num) {
$digit = substr($num,-1,1);
$ord = array(
0 => 'th',
1 => 'st',
2 => 'nd',
3 => 'rd',
4 => 'th',
5 => 'th',
6 => 'th',
7 => 'th',
8 => 'th',
9 => 'th'
$string = $num.$ord[$digit];
return $string;


In Evan's ordinal function, the line:
 $tens = substr($cardinal, -2, 1);
needs to be replaced by:
 $tens = round($cardinal/10);
or similar. At least on PHP 4.3.10,  substr("1", -2, 1)  returns '1' - so Evan's function gives "1th", as well as "11th".  This is contrary to the documentation, but is noted in the comments on the substr manual page.


If you're really concerned about speed, you could compute the factorial of large numbers using the Gamma function of n-1.
Integral y^(t-1)*Exp(-y) for y from 0 to Infinity
For Fibonacci numbers, there's a better-than-recursive way.
((1+sqrt(5))/2)^(n/sqrt(5)) - ((1-sqrt(5))/2)^(n/sqrt(5))


If you´re an aviator and needs to calculate windcorrection angles and groundspeed (e.g. during flightplanning) this can be very useful.
$windcorrection = rad2deg(asin((($windspeed * (sin(deg2rad($tt - ($winddirection-180))))/$tas))));
$groundspeed = $tas*cos(deg2rad($windcorrection)) + $windspeed*cos(deg2rad($tt-($winddirection-180)));
You can probably write these lines more beautiful, but they work!


If you need to deal with polar co-ordinates for somereason you will need to convert to and from x,y for input and output in most situations: here are some functions to convert cartesian to polar and polar to cartesian
//returns array of r, theta in the range of 0-2*pi (in radians)
function rect2polar($x,$y)
    if($y>0) $theta=pi()/2;
    else $theta=3*pi()/2;
    else if($x<0) $theta=atan($y/$x)+pi();
    else if($y<0) $theta=atan($y/$x)+2*pi();
    else $theta=atan($y/$x);
    return $polar;
else return false;
//r must be in radians, returns array of x,y
function polar2rect($r,$theta)
  return false;

jbeardsl found_at gte d0t net

I was looking for a truncate function. Not finding one, I wrote my own. Since it deals with everything as a number, I imagine it's faster than the alternative of using string functions. HTH...
function truncate ($num, $digits = 0) {
   //provide the real number, and the number of
   //digits right of the decimal you want to keep.
   $shift = pow(10, $digits);
   return ((floor($num * $shift)) / $shift);

moikboy nospam! moikboy nospam! hu

I think, this is the optimal code for calculating factorials:
function fact($int){
   if($int<2)return 1;
   return $f;
And another one for calculating the $int-th Fibonacci-number:
function fib($int){
   static $fibTable=array();
   return empty($fibTable[$int])?$fibTable[$int] = $int>1?fib($int-2)+fib($int-1):1:$fibTable[$int];


I see there are some factorial functions below.
I'll provide the best one:
function factorial($n){ $n=(int)$n;
 for(;$n>0;--$n) $f*=$n;
 return $f;


I needed to approximate an integral because i was not able to calculate it, so i wrote this function. It approximates an integral with the composite Simpson's rule.
More information on Simpson's rule:
function simpsonf($x){
// returns f(x) for integral approximation with composite Simpson's rule
  return(pow((1+pow($x, (-4))), 0.5));
function simpsonsrule($a, $b, $n){
// approximates integral_a_b f(x) dx with composite Simpson's rule with $n intervals
// $n has to be an even number
// f(x) is defined in "function simpsonf($x)"
     while($i <= ($n-1)){
     return('$n has to be an even number');


I needed a truncate function to operate on real numbers. I preferred not to use a string-manipulation method, so here's my solution. HTH...
function truncate ($num, $digits = 0) {
   //provide the real number, and the number of
   //digits right of the decimal you want to keep.
   $shift = pow(10 , $digits);
   return ((floor($num * $shift)) / $shift);


I found that when dealing with tables, a 'least common multiple' function is sometimes useful for abusing tablespan and the likes.
So here goes (you may choose to remove the first part of the gcd function if the function call is well-behaved):
function gcd(n, m) //greatest common divisor
n=abs(n); m=abs(m);
if (n==0 and m==0)
return 1; //avoid infinite recursion
if (n==m and n>=1)
return n;
return m<n?gcd(n-m,n):gcd(n,m-n);
function lcm(n, m) //least common multiple
return m*(n/gcd(n,m));
This may or may not be something to consider adding to the mathematical function library.

I found it kind of irritating that PHP had no native functionality for a calculating Factorials. Since I really didn't feel like loading the GMP library, I figured I'd write my own function.
function fact($s){$r=(int)$s; for ($i=$r;$i--;$i>1){$r=$r*$i;} return $r;}
I think that's right... I havn't tested it extensively but it should work.


I could not resist to do a simpler version of the ordinal function:
function ordinal($num)
$num = (int)$num;
$digit = substr($num, -1, 1);
$ord = "th";
case 1: $ord = "st"; break;
case 2: $ord = "nd"; break;
case 3: $ord = "rd"; break;
return $num.$ord;
One could replace the typecast with
if($num===NULL or $num==="")
{return NULL;}
to get an empty result instead of "0th" in case $num is empty too.


Here's yet another greatest common denominator (gcd) function, a reeeeally small one.
function gcd($n,$m){
if(!$m)return$n;return gcd($m,$n%$m);
It works by recursion. Not really sure about it's speed, but it's really small! This won't work on floating point numbers accurately though. If you want a floating point one, you need to have at least PHP 4, and the code would be
function gcd($n,$m){
if(!$m)return$n;return gcd($m,fmod($n,$m));


Here's a least common denominator (lcd) function:
$array = array(3,4,6,8,18,2);

function lcd($array,$x) {

$mod_sum = 0;

for($int=1;$int < count($array);$int++) {
$modulus[$int] = ($array[0]*$x) % ($array[$int]);
$mod_sum = $mod_sum + $modulus[$int];

if (!$mod_sum) {
echo "LCD: ".($array[0]*$x)."\n";

else {



Here is my factorial function which i think is very simple and without any confusion. email me comments if you like if i had something wrong.
function factorial($number)
$temp = 1;
while ($number > 1){
$temp *= $number--;
return $temp;

jerry dot wilborn

Here is how to calculate standard deviation in PHP where $samples is an array of incrementing numeric keys and the values are your samples:
$sample_count = count($samples);
for ($current_sample = 0; $sample_count > $current_sample; ++$current_sample) $sample_square[$current_sample] = pow($samples[$current_sample], 2);
$standard_deviation = sqrt(array_sum($sample_square) / $sample_count - pow((array_sum($samples) / $sample_count), 2));

11-apr-2007 07:55

Here is another way of calculating the nth term of the Fibonacci sequence, based on Binet's formula (see for more information on this).
In this example, it would display the 17th term of the Fibonacci sequence.
$n = 17; // Sets a value for $n, the nth term
$phi = (1 + sqrt(5)) / 2; // Sets the value of phi for use in the formula
$u = (pow($phi, $n) - pow(1 - $phi, $n)) / sqrt(5);
echo "U<sub>$n</sub> = $u";
Here is a script that lists the Fibonacci sequence from whatever two terms you specify, in this example from the 12th term to the 27th term (inclusive).
$f = 12; // Sets the 'f'th term, the term from which to start listing
$t = 27; //Sets the 't'th term, the term at which to stop listing
$phi = (1 + sqrt(5)) / 2; // Sets the value of phi for use in the formula
while($f <= $t) {
 $u = (pow($phi, $f) - pow(1 - $phi, $f)) / sqrt(5);
 echo "U<sub>$f</sub> = $u

jaakko dot mantila

Here is another payment function with working future value($fv) option:
function payment($r,$np,$pv,$fv,$prec) {
  /* Calculates the monthly payment
  ** $apr = the annual percentage rate of the loan.
  ** $n  = number of monthly payments (360 for a 30year loan)
  ** $pv    = present value or principal of the loan
  ** $fv  = future value of the loan (after payments)
  ** $prec = the precision you wish rounded to
  ** No Warranty is expressed or implied. **
if(!$fv) $fv = 0;
$mypmt=$r * (-$fv+pow((1+$r),$np)*$pv)/(-1+pow((1+$r),$np));
return round($mypmt, $prec);


here is an algorithm to calculate gcd of a number. This is Euclid algorithm i was studying in Maths. I've converted it in php for the fun.
if($a && $b)
 { $ax=$a; $bx=$b;
echo 'PGCD ('.$ax.' , '.$bx.' ) = '.$rx;


Here is a cleaner factorial function:
function factorial($s){
if($s) $r = $s * factorial($s - 1);
else $r = 1;
return $r;

chronial "at"

Here are are a nPr and a nPc function
(had to define NaN - don't know, how to this the "rigth" way)
define (NaN,acos(1.01));
function nCr($n,$r){
  if ($r > $n)
     return NaN;
  if (($n-$r) < $r)
     return nCr($n,($n-$r));
  $return = 1;
  for ($i=0;$i < $r;$i++){
     $return *= ($n-$i)/($i+1);
  return $return;
function nPr($n,$r){
  if ($r > $n)
     return NaN;
  if ($r)
     return $n*(nPr($n-1,$r-1));
     return 1;


for those looking for a credit card verification function i wrote a simple LUHN Formula algorithm:
$valid = 1;
$numOfDigits = 0 - strlen($ccNumber);
$i = -1;
while ($i>=$numOfDigits){
 if (($i % 2) == 0){
   $double = 2*(substr($ccNumber, $i, 1));
$total += substr($double,0,1);
if (strlen($double > 1)){
 $total += substr($double,1,1);
 } else {
   $total += substr($ccNumber, $i, 1);
if (($total % 10) != 0){
 $valid = 0;


For people interest in Differential Equations, I've done a function that receive a string like: x^2+x^3 and put it in
2x+3x^2 witch is the differantial of the previous equation.
In the code there is one thing missing: the $string{$i} is often going outOfBound (Uninitialized string offset: 6 in...)
if your error setting is set a little too high... I just dont know how to fix this.
So there is the code for differential equation with (+ and -) only:
function differentiel($equa)
$equa = strtolower($equa);
echo "Equation de depart: ".$equa."
$final = "";

for($i = 0; $i < strlen($equa); $i++)
//Make a new string from the receive $equa
if($equa{$i} == "x" && $equa{$i+1} == "^")
$final .= $equa{$i+2};
$final .= "x^";
$final .= $equa{$i+2}-1;
elseif($equa{$i} == "+" || $equa{$i} == "-")
$final .= $equa{$i};
elseif(is_numeric($equa{$i}) && $i == 0)
//gerer parenthese et autre terme generaux + gerer ^apres: 2^2
$final .= $equa{$i}."*";
elseif(is_numeric($equa{$i}) && $i > 0 && $equa{$i-1} != "^")
//gerer ^apres: 2^2
$final .= $equa{$i}."*";
elseif($equa{$i} == "^")
elseif(is_numeric($equa{$i}) && $equa{$i-1} == "^")
if($equa{$i} == "x")
$final .= 1;
$final .= $equa{$i};
//Manage multiplication add in the previous string $final
$finalMul = "";
for($i = 0; $i < strlen($final); $i++)
if(is_numeric($final{$i}) && $final{$i+1} == "*" && is_numeric($final{$i+2}))
$finalMul .= $final{$i}*$final{$i+2};
elseif($final{$i} == "*")
elseif(is_numeric($final{$i}) && $final{$i+1} != "*" && $final{$i-1} == "*")
$finalMul .= $final{$i};
echo "equa final: ".$finalMul;
I know this is not optimal but i've done this quick :)
If you guys have any comment just email me.
I also want to do this fonction In C to add to phpCore maybe soon...


For all you guys writing mortgage calculators out there:
function payment($apr,$n,$pv,$fv=0.0,$prec=2){
/* Calculates the monthly payment rouned to the nearest penny
** $apr = the annual percentage rate of the loan.
** $n   = number of monthly payments (360 for a 30year loan)
** $pv = present value or principal of the loan
** $fv  = future value of the loan
** $prec = the precision you wish rounded to
** No Warranty is expressed or implied. **

if ($apr !=0) {
$alpha = 1/(1+$apr/12);
$retval =  round($pv * (1 - $alpha) / $alpha /
(1 - pow($alpha,$n)),$prec) ;
} else {
$retval = round($pv / $n, $prec);


Converting non-standard form:
you can use something like this:
$v=sprintf ( "%2.9f", $v);

And the reason I needed a Factorial function is because I there were no nPr or nCr functions native to PHP, either.
function n_pick_r($n,$r){$n=(int)$n; $r=(int)$r;return (fact($n)/fact($n-$r));}
function n_choose_r($n,$r){$n=(int)$n; $r=(int)$r;return (n_pick_r($n,$r)/fact($r));}
Hope that helps someone!

evan broder

A slightly more complex but much more accurate cardinal=>ordinal function (the one below doesn't account for 11th, 12th, and 13th, which don't follow the usual rules):
function ordinal($cardinal)
$cardinal = (int)$cardinal;
$digit = substr($cardinal, -1, 1);
$tens = substr($cardinal, -2, 1);
if($tens == 1)
return $cardinal.'th';

case 1:
return $cardinal.'st';
case 2:
return $cardinal.'nd';
case 3:
return $cardinal.'rd';
return $cardinal.'th';


A function that simulates the sum operator. ( Be careful with the expression because it may cause a security hole; note the single quotes to don't parse the "$".
# @param string $expr expression to evaluate (for example (2*$x)^2+1)
# @param string $var  dummy variable (for example "x")
# @param integer    $start
# @param integer    $end
# @param integer    $step
function sum($expr,$var,$start,$end,$step = 1) {
$expr = str_replace(';','',$expr);
$var = str_replace('$','',$var);
$start = (int)$start; $end = (int)$end; $step = (int)$step; $sum = 0;

for ($i = $start; $i <= $end; $i = $i + $step) {
$_expr = str_replace('$'.$var,$i,$expr);
$_eval = '$_result = '.$_expr.'; return $_result;';
$_result = eval($_eval);
if($result === FALSE) return "SYNTAX ERROR : $expr";
$sum += $_result;
return (int)$sum;


@ Moikboy:
This may or may not be more simplified factorialization:
while ($fact>0)
echo $f;


* Function to calculate base36 values from a number. Very
* useful if you wish to generate IDs from numbers.
* @param $value The number
* @param $base The base to be applied (16, 36 or 64)
* @return The calculated string
* @author Shashank Tripathi (
* @version 0.1 - Let me know if something doesnt work

function base36($value, $base)
   $baseChars = array('0', '1', '2', '3', '4', '5',
                      '6', '7', '8', '9', 'a', 'b',
                      'c', 'd', 'e', 'f', 'g', 'h',
                      'i', 'j', 'k', 'l', 'm', 'n',
                      'o', 'p', 'q', 'r', 's', 't',
                      'u', 'v', 'w', 'x', 'y', 'z'
   $remainder = 0;
   $newval = "";
   while ( $value > 0 )
       $remainder = $value % $base;
       $value = ( ($value - $remainder)/ $base );
       $newval .= $baseChars[$remainder];
   return strrev($newval);

echo "The string for 46655, for instance, is " . base36(46655, 36);

Change Language

Follow Navioo On Twitter
.NET Functions
Apache-specific Functions
Alternative PHP Cache
Advanced PHP debugger
Array Functions
Aspell functions [deprecated]
BBCode Functions
BCMath Arbitrary Precision Mathematics Functions
PHP bytecode Compiler
Bzip2 Compression Functions
Calendar Functions
CCVS API Functions [deprecated]
Class/Object Functions
Classkit Functions
ClibPDF Functions [deprecated]
COM and .Net (Windows)
Crack Functions
Character Type Functions
Cybercash Payment Functions
Credit Mutuel CyberMUT functions
Cyrus IMAP administration Functions
Date and Time Functions
DB++ Functions
Database (dbm-style) Abstraction Layer Functions
dBase Functions
DBM Functions [deprecated]
dbx Functions
Direct IO Functions
Directory Functions
DOM Functions
DOM XML Functions
enchant Functions
Error Handling and Logging Functions
Exif Functions
Expect Functions
File Alteration Monitor Functions
Forms Data Format Functions
Fileinfo Functions
filePro Functions
Filesystem Functions
Filter Functions
Firebird/InterBase Functions
Firebird/Interbase Functions (PDO_FIREBIRD)
FriBiDi Functions
FrontBase Functions
FTP Functions
Function Handling Functions
GeoIP Functions
Gettext Functions
GMP Functions
gnupg Functions
Haru PDF Functions
hash Functions
Hyperwave Functions
Hyperwave API Functions
i18n Functions
IBM Functions (PDO_IBM)
iconv Functions
ID3 Functions
IIS Administration Functions
Image Functions
Imagick Image Library
Informix Functions
Informix Functions (PDO_INFORMIX)
Ingres II Functions
IRC Gateway Functions
PHP / Java Integration
JSON Functions
LDAP Functions
libxml Functions
Lotus Notes Functions
LZF Functions
Mail Functions
Mailparse Functions
Mathematical Functions
MaxDB PHP Extension
MCAL Functions
Mcrypt Encryption Functions
MCVE (Monetra) Payment Functions
Memcache Functions
Mhash Functions
Mimetype Functions
Ming functions for Flash
Miscellaneous Functions
mnoGoSearch Functions
Microsoft SQL Server Functions
Microsoft SQL Server and Sybase Functions (PDO_DBLIB)
Mohawk Software Session Handler Functions
mSQL Functions
Multibyte String Functions
muscat Functions
MySQL Functions
MySQL Functions (PDO_MYSQL)
MySQL Improved Extension
Ncurses Terminal Screen Control Functions
Network Functions
Newt Functions
NSAPI-specific Functions
Object Aggregation/Composition Functions
Object property and method call overloading
Oracle Functions
ODBC Functions (Unified)
ODBC and DB2 Functions (PDO_ODBC)
OpenAL Audio Bindings
OpenSSL Functions
Oracle Functions [deprecated]
Oracle Functions (PDO_OCI)
Output Control Functions
Ovrimos SQL Functions
Paradox File Access
Parsekit Functions
Process Control Functions
Regular Expression Functions (Perl-Compatible)
PDF Functions
PDO Functions
Phar archive stream and classes
PHP Options&Information
POSIX Functions
Regular Expression Functions (POSIX Extended)
PostgreSQL Functions
PostgreSQL Functions (PDO_PGSQL)
Printer Functions
Program Execution Functions
PostScript document creation
Pspell Functions
qtdom Functions
Rar Functions
GNU Readline
GNU Recode Functions
RPM Header Reading Functions
runkit Functions
SAM - Simple Asynchronous Messaging
Satellite CORBA client extension [deprecated]
SCA Functions
SDO Functions
SDO XML Data Access Service Functions
SDO Relational Data Access Service Functions
SESAM Database Functions
PostgreSQL Session Save Handler
Session Handling Functions
Shared Memory Functions
SimpleXML functions
SNMP Functions
SOAP Functions
Socket Functions
Standard PHP Library (SPL) Functions
SQLite Functions
SQLite Functions (PDO_SQLITE)
Secure Shell2 Functions
Statistics Functions
Stream Functions
String Functions
Subversion Functions
Shockwave Flash Functions
Swish Functions
Sybase Functions
TCP Wrappers Functions
Tidy Functions
Tokenizer Functions
Unicode Functions
URL Functions
Variable Handling Functions
Verisign Payflow Pro Functions
vpopmail Functions
W32api Functions
WDDX Functions
win32ps Functions
win32service Functions
xattr Functions
xdiff Functions
XML Parser Functions
XML-RPC Functions
XMLReader functions
XMLWriter Functions
XSL functions
XSLT Functions
YAZ Functions
YP/NIS Functions
Zip File Functions
Zlib Compression Functions
eXTReMe Tracker