PHP Basic Tutorials ,PHP Sources Code,PHP Online Example

Algorithms Arrays Passwords Uncategorized
Commerce Uncategorized
Databases Abstraction Layers Informix LDAP MS SQL MySQL ODBC PostgreSQL Uncategorized
Date & Time Calculators Conversion Translation Uncategorized
Discussion Chat Forums Guestbooks Polls Uncategorized
Email Validation Uncategorized
External Uncategorized
Files and Directories Uncategorized
Games Uncategorized
Graphics 3-D Graphs Resizing Thumbnails Uncategorized
HTML Forms Menus & Navigation Source Viewers Tables Templates Uncategorized
HTTP Authentication Cookies File Uploading Uncategorized
I18N Uncategorized
Math Uncategorized
Miscellaneous Uncategorized
Searching and Trees Uncategorized
Security Uncategorized
Text Uncategorized
Utilities Calendars Counters Link Checkers Weather Uncategorized
XML Uncategorized

php sample source codes
Age calculator (which works) <?php # Age script # based on (c) hagman 1998-2002 # at http://www.zend.com/codex.php?id=842&single=1, This one works - though!!! function age_calculator($day,$month,$year){ if (date("n") > $month) $age = (date("Y") - $year); elseif (date("n") == $month){ if (date("j") < $day) $age = (date("Y") - $year) - 1; else $age = (date("Y") - $year); } else $age = (date("Y") - $year) - 1; return $age; } ?>
Convert base 10 int to any other base up to 16. This function will take a take two integer values. The first is the base you want to convert to, the second is the base 10 number you are converting. <?php function convert ($iBase, $iNumber) { $aHexValues = array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'); $sReturn = ''; $iIndex = 0; while ($iNumber >= $iBase) { $iIndex = $iNumber % $iBase; $iNumber = floor($iNumber / $iBase); $sReturn = $aHexValues[$iIndex] . $sReturn; } $sReturn = $aHexValues[$iNumber] . $sReturn; return $sReturn; } ?>
The Greatest Common Denominator of two large numbers, using BCMath functions. Please read the PHP manual for BCMath requirements. It works even for those who cannot have GMP support in their PHP distribution, for instance due to the web host policy. <?php // The Greatest Common Denominator of two large numbers, using BCMath functions. // It works even for those who cannot have GMP support in their PHP distribution, for instance due to the web host policy. // You can see a demo here: // http://freephpcalculator.tk/ // License: free to do whatever you want with the code // even using it function bcgcd ($value1, $value2) { if ($value1 < $value2) // Swap $value1 and $value2 { $temp = $value1; $value1 = $value2; $value2 = $temp; } // We use the Euclid's algorithm // for finding the Greatest Common Denominator (GCD) $mod = 1; while ($mod != 0) { $mod = bcmod ($value1, $value2); $value1 = $value2; $value2 = $mod; } return $value1; } ?>
This script does Addition and Subtraction without once using the + or - operators. Good example of how to use bitwise operators. <?php if (isset($num1) && isset($num2)) { function BinaryAdd($num1,$num2) { $carry = $num1 & $num2; do { $carry = $carry << 1; $num1 = $num1 ^ $num2; $sum = $num1 ^ $carry; $num2 = $carry; $carry = $num1 & $num2; } while($carry != 0); return $sum; } function BinarySubtract($num1,$num2) { //Compute Two's Compliment $num2 = ~ $num2; $num2 = BinaryAdd($num2,1); $diff = BinaryAdd($num1,$num2); return $diff; } //Make sure form data is treated like an int $number1 = (int)$num1; $number2 = (int)$num2; $sum = BinaryAdd($number1,$number2); $diff = BinarySubtract($number1,$number2); echo "The Sum is $sum<BR>"; echo "The Difference is $diff"; } else { ?> <Form Action="<? echo $PHP_SELF ?>" Method=Post> Enter an Integer <Input Type=text name="num1"><BR> Enter a Second Integer <Input Type=text name="num2"><BR> <Input Type=Submit Value="Add and Subtract Them"> </Form> <? } ?>
this program prompts for means, standard dev, and sample sizes of both groups, and calculates the p-value of unpaired t-test of two independent group. <? //-------------pdf_helper.inc --------------// /* This code is to compute a p-value from means of two groups.(not the paired data) The paired t-test should be done with different df calculation p-value is area under the curve from t* to infinity. I used pdf of t distribution: y=gamma[(v+1)/2)]/[(1+(t^2/df)]^((-v-1)/2) where gamma(alpha)=integral of [x^(alpha-1)exp(-x)] from 0 to infinity There can be more than one form for distribution functions. They are actually the same distribution function but in different ways to express it. / //this function calculates t value(aka t statistics) function getT($n1, $n2, $sd1, $sd2, $mn1, $mn2, $df) { $var1=pow($sd1, 2); $var2=pow($sd2, 2); $pvar=(($n1-1)$var1+($n2-1)$var2)/$df; if ($pvar>0) $t=($mn1-$mn2)/sqrt($pvar(1/$n1+1/$n2)); else $t=-9999; //no value if ($t>9999.999) $t=9999.999; //no value if(($var1/$n1+$var2/$n2)>0) $t=($mn1-$mn2)/sqrt($var1/$n1+$var2/$n2); else $t=-9999; //no value $t=abs($t); //since it's one sided test, echo "t value $t<br>"; //we take the absolute value return $t; } //this function calculates area under the curve of gamma dist from 0 to 1 //function getGamma($alpha) { $height=0; $sum=0; $width=0.1; for($i=0; $i<101; $i++) $seg[$i]= $i/10; for($k=0; $k<100; $k++) { $mp=($seg[$k]+$seg[$k+1])/2; $height=pow($mp, $alpha-1)exp(-$mp); $sum=($height$width)+$sum; } return $sum; } //this integrates t function from t* to infinity function T_dist($df, $alpha1, $alpha2, $t) { /* t distribution integration / $sum=0; $t_seg[0]=$t; $t_height=0; $t_wd=(6-$t)/100; //I just took 6 instead of infinity since the difference is $temp=pi()$df; //insignificant for($j=1;$j<101; $j++) $t_seg[$j]=$t_seg[$j-1]+$t_wd; for ($l=0; $l<100; $l++) { $t_mp=($t_seg[$l]+$t_seg[$l+1])/2; $t_height=($alpha1/(sqrt($temp)$alpha2))pow(1/(1+(($t_mp$t_mp)/$df)), 1/2($df+1)); $sum=$t_height$t_wd+$sum; } return $sum2; } ?> //----------------mytest.php---------------// <html> <body> <? include("pdf_helper.inc"); //pdf_helper has formulas for several pdf(probability distribution functions) to derive p-values. //p value is area under t(t statistics) to infinity /***************************************************/ Values needed to be loaded from MySQL(the surveyor) ****************************************************/ $n1=3; $n2=3; //n1= number of samples in group1; n2=number of samples in group2 $mn1=0.0629; //mn1= mean from group1 $mn2=0.0775; // mn2= mean from group2 $sd1=.0258; // sd1= standard deviation of group1 $sd2=.0199; //sd2=standard deviation of group2 $w1=($sd1$sd1)/$n1; //w1 and w2 are temp variables to calcuate df(degrees of freedom) $w2=($sd2$sd2)/$n2; $df=pow(($w1+$w2), 2)/($w1$w1/($n1-1)+$w2*$w2/($n2-1)); //calculation of df $alpha1=($df+1)/2; $alpha2=$df/2; $t=getT($n1, $n2, $sd1, $sd2, $mn1, $mn2, $df); //calculates t statistics $pval=T_dist($df,getGamma($alpha1), getGamma($alpha2), $t); //calculates p-value echo "t statistics is $t<br>"; echo "p-value is $pval"; ?> </body> </html>
A function that converts numbers with decimal remainders to numbers with fractional remainders. <? function decimal_to_fraction ($number) { list ($whole, $numerator) = explode ('.', $number); $denominator = 1 . str_repeat (0, strlen ($numerator)); $GCD = GCD ($numerator, $denominator); $numerator /= $GCD; $denominator /= $GCD; return sprintf ('%d <sup>%d</sup>/<sub>%d</sub>', $whole, $numerator, $denominator); } function GCD ($a, $b) { while ( $b != 0) { $remainder = $a % $b; $a = $b; $b = $remainder; } return abs ($a); } /* DESCRIPTION ============================================================ Decimal_to_Fraction: A simple function that converts numbers with decimal remainders to numbers with fractional remainders. Includes a function to find the greatest common denominator. ============================================================ CREDITS ============================================================ Author: J. A. Greant ( zak@nucleus.com ) Version 1: June 9, 2000 ============================================================ NOTICES ============================================================ If you: Modify this code and want to share your changes :) Find a bug Have other questions or comments Please write: Zak Greant (zak@nucleus.com) ============================================================ USAGE EXAMPLES ============================================================ print Decimal_to_Fraction (1.2); // Should output 1 1/5 ============================================================ COPYRIGHT ============================================================ Copyright (c) 2000 J. A. Greant ( zak@nucleus.com ) All rights reserved. This function is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This function is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this function; if not, write to the: Free Software Foundation, Inc. 59 Temple Place, Suite 330 Boston, MA 02111-1307 USA http://www.gnu.org/ ============================================================ */ ?>
Two functions to convert an integer to its equivalent in the roman number- system or vice versa. <?PHP /* Decimal <--> Roman 1.1 Written by: Rasmus Rimestad Email: rasmusr@online.no Homepage: http://dikt.cjb.net Written: XXIV.VII.MMI This file includes two functions string dec2roman (integer $number) where $number is a number you want to convert to a roman one. integer roman2dec (string $linje) where $linje is the roman number you want to conver to an integer. / function dec2roman ($number) { # Making input compatible with script. $number = floor($number); if($number < 0) { $linje = "-"; $number = abs($number); } # Defining arrays $romanNumbers = array(1000, 500, 100, 50, 10, 5, 1); $romanLettersToNumbers = array("M" => 1000, "D" => 500, "C" => 100, "L" => 50, "X" => 10, "V" => 5, "I" => 1); $romanLetters = array_keys($romanLettersToNumbers); # Looping through and adding letters. while ($number) { for($pos = 0; $pos <= 6; $pos++) { # Dividing the remaining number with one of the roman numbers. $dividend = $number / $romanNumbers[$pos]; # If that division is >= 1, round down, and add that number of letters to the string. if($dividend >= 1) { $linje .= str_repeat($romanLetters[$pos], floor($dividend)); # Reduce the number to reflect what is left to make roman of. $number -= floor($dividend) $romanNumbers[$pos]; } } } # If I find 4 instances of the same letter, this should be done in a different way. # Then, subtract instead of adding (smaller number in front of larger). $numberOfChanges = 1; while($numberOfChanges) { $numberOfChanges = 0; for($start = 0; $start < strlen($linje); $start++) { $chunk = substr($linje, $start, 1); if($chunk == $oldChunk && $chunk != "M") { $appearance++; } else { $oldChunk = $chunk; $appearance = 1; } # Was there found 4 instances. if($appearance == 4) { $firstLetter = substr($linje, $start - 4, 1); $letter = $chunk; $sum = $firstNumber + $letterNumber * 4; $pos = array_search($letter, $romanLetters); # Are the four digits to be calculated together with the one before? (Example yes: VIIII = IX Example no: MIIII = MIV # This is found by checking if the digit before the first of the four instances is the one which is before the digits in the order # of the roman number. I.e. MDCLXVI. if($romanLetters[$pos - 1] == $firstLetter) { $oldString = $firstLetter . str_repeat($letter, 4); $newString = $letter . $romanLetters[$pos - 2]; } else { $oldString = str_repeat($letter, 4); $newString = $letter . $romanLetters[$pos - 1]; } $numberOfChanges++; $linje = str_replace($oldString, $newString, $linje); } } } return $linje; } function roman2dec ($linje) { # Fixing variable so it follows my convention $linje = strtoupper($linje); # Removing all not-roman letters $linje = ereg_replace("[^IVXLCDM]", "", $linje); print("\$linje = $linje<br>"); # Defining variables $romanLettersToNumbers = array("M" => 1000, "D" => 500, "C" => 100, "L" => 50, "X" => 10, "V" => 5, "I" => 1); $oldChunk = 1001; # Looping through line for($start = 0; $start < strlen($linje); $start++) { $chunk = substr($linje, $start, 1); $chunk = $romanLettersToNumbers[$chunk]; if($chunk <= $oldChunk) { $calculation .= " + $chunk"; } else { $calculation .= " + " . ($chunk - (2 * $oldChunk)); } $oldChunk = $chunk; } # Summing it up eval("\$calculation = $calculation;"); return $calculation; } # Implementation of the array_search function. Works only with numerical arrays. function array_search($searchString, $array) { foreach ($array as $content) { if($content == $searchString) { return $pos; } $pos++; } } ?>
An application for doing exact integer computations. Uses bcmath functions of PHP. The Euclidean Algorithm and the Sieve of Erotesthenes are implemented. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <HTML> <HEAD><TITLE>Number Theory Assistant</TITLE></HEAD> <BODY BGCOLOR="#336699" TEXT="FFFFFF" LINK="0000FF" VLINK="800080" ALINK="FF0000"> <CENTER> <TABLE BORDER="1"><TR><TD><FONT SIZE=+3><CENTER>Number Theory Assistant</FONT><BR>&copy Dr. Rama Rao</CENTER><P> <FONT SIZE=+1>TYPE THE NUMBERS AND CHOOSE AN OPERATION</FONT><P> <form action="/php/numth.php3" method="GET"> <input type="text" name="m">: = m<br> <input type="text" name="n">: = n<br> <input type="text" name="p">: = p<p> <FONT SIZE=+1>Choose an operation</FONT><P> <select multiple name="choice" size="9"> <option value="no1">m + n <option value="no2">m * n <option value="no3">quo(m / n) <option value="no4">m mod n <option value="no5">m ^ n <option value="no6">m ^ n mod p <option value="no7">gcd(m, n) <option value="no8">gcd = mx + ny <option value="no9">primes <= m </select> <input type="submit" value="Compute"> </form> </TD> <TD width="40%" VALIGN="TOP"> <FONT SIZE=+2>RESULTS</FONT><P> <? if ($choice == "no1") {echo bcadd($m,$n)."= m + n<br>";} if ($choice == "no2") {echo bcmul($m,$n)."= m * n<br>";} if ($choice == "no3") {echo bcdiv($m,$n)."= quo(m / n)<br>";} if ($choice == "no4") {echo bcmod($m,$n)."= m mod n<br>";} if ($choice == "no5") {echo bcpow($m,$n)."= m ^ n<br>";} if ($choice == "no6") {echo bcmod(bcpow($m,$n),$p)."= m ^ n mod p<br>";} if ($choice == "no7") { if ($m > $n): $a = $m; $b = $n; else: $a = $n; $b = $m; endif; do { $r = bcmod($a,$b); $q = bcdiv($a,$b);echo "$a=$q$b+$r<br>"; $a = $b; $b = $r; } while ($r!= 0); echo "gcd of $m and $n is $a"; } if ($choice == "no8") { if ($m > $n): $a = $m; $b = $n; else: $a = $n; $b = $m; endif; $ini1=array($a,1,0); $ini2=array($b,0,1); $x=$ini1; $y=$ini2; do { $r=bcmod($x[0],$y[0]); $q=bcdiv($x[0],$y[0]); $temp=$y; $y=array($r,$x[1]-bcmul($q,$y[1]),$x[2]-bcmul($q,$y[2]));$x=$temp; } while ($r!=0); echo "gcd($m,$n) = $x[0]"; echo "<BR>"; echo "$x[0] = ($x[1]) $ini1[0] + ($x[2]) * $ini2[0]"; } if ($choice == "no9") { $c=", "; $prime=array(2,3); $i=4; do { $rem=1; for ($j=0; $j<count($prime); $j++) { $rem=$rem*bcmod($i, $prime[$j]); } if ($rem != 0) {$prime[]=$i;} //only PHP4->{array_push($prime, $i);} $i++; } while ($i <= $m); function disp($entry) {echo $entry.", ";} array_walk($prime, 'disp'); print "<BR>There are ".count($prime)." primes."; } ?> </TD></TR></TABLE> </CENTER> </BODY></HTML>
This is a port of the FFT code in NR to PHP. The size of the input array must be an integer power of two. Main website at http://www.mathewbinkley.org/fft.php ################################################################### # PHP_Fourier 0.03 # Original Fortran source by Numerical Recipies # PHP port by Mathew Binkley (binkleym@nukote.com) ################################################################### ################################################################### # Fourier($data, $sign) - Performs the FFT on the complex # array $data # # Presumes that count($data) is an integer power of two # # $data[even] holds the real portion # $data[odd] hold the imaginary portion # # Example: (1 + 2i) -> $data[0] = 1; $data[1] = 2; # # $sign = 1 performs the Fourier Transform # $sign = -1 performs the Inverse Fourier Transform # # Use: # $fourier_array = Fourier($inputarray, 1); # ################################################################### function Fourier($input, $isign) { ##################################################################### # We need to shift the array up one because this script is a direct # port of the fortran program from NR. Should fix in future. ##################################################################### $data[0] = 0; for ($i = 0; $i < count($input); $i++) $data[($i+1)] = $input[$i]; $n = count($input); $j = 1; for ($i = 1; $i < $n; $i += 2) { if ($j > $i) { list($data[($j+0)], $data[($i+0)]) = array($data[($i+0)], $data[($j+0)]); list($data[($j+1)], $data[($i+1)]) = array($data[($i+1)], $data[($j+1)]); } $m = $n >> 1; while (($m >= 2) && ($j > $m)) { $j -= $m; $m = $m >> 1; } $j += $m; } $mmax = 2; while ($n > $mmax) { # Outer loop executed log2(nn) times $istep = $mmax << 1; $theta = $isign * 2pi()/$mmax; $wtemp = sin(0.5 $theta); $wpr = -2.0$wtemp$wtemp; $wpi = sin($theta); $wr = 1.0; $wi = 0.0; for ($m = 1; $m < $mmax; $m += 2) { # Here are the two nested inner loops for ($i = $m; $i <= $n; $i+= $istep) { $j = $i + $mmax; $tempr = $wr * $data[$j] - $wi * $data[($j+1)]; $tempi = $wr * $data[($j+1)] + $wi * $data[$j]; $data[$j] = $data[$i] - $tempr; $data[($j+1)] = $data[($i+1)] - $tempi; $data[$i] += $tempr; $data[($i+1)] += $tempi; } $wtemp = $wr; $wr = ($wr * $wpr) - ($wi * $wpi) + $wr; $wi = ($wi * $wpr) + ($wtemp * $wpi) + $wi; } $mmax = $istep; } for ($i = 1; $i < count($data); $i++) { $data[$i] *= sqrt(2/$n); # Normalize the data if (abs($data[$i]) < 1E-8) $data[$i] = 0; # Let's round small numbers to zero $input[($i-1)] = $data[$i]; # We need to shift array back (see beginning) } return $input; } ?>
Allows manipulation and display of a fraction. Useful for displaying float/double as a fraction as opposed to a decimal number, i.e. 1/2 instead of 0.5, or a better example is 1/3 instead of 0.333333. :-) /** * Fraction class * Author: Ferry Firmansjah (firmanf@bigfoot.com) * Version: 0.8 (getting there, but still not perfect yet) * Last update: 2001/05/28 * Description: * A class that represents a Fraction number. * The class can perform the more common mathematical * operations: addition, subtraction, multiplication, * division. The only caveat is that the other * argument also has to be a Fraction. * * The constructor is able to accept almost any variable * data type: string, double, integer, even another Fraction. * The class is also able to reduce the Fraction to * (practically) the lowest common denominator (using the * reduce() method call) using Euclid's Algorithm * (www.mcn.net/~jimloy/euclids.html). * * Changes: * For 0.8: * Pretty major reorganization of the classes: we now * use a factory to get the Fraction. * The advantages are: * - all Fraction has a reference to the factory that * created it. * - the factory also provides methods to manipulate * the Fraction class itself. * * Modification to fraction/Fraction class: * - class name changed to Fraction; 'fraction' will still * work. * - Fraction class constructor now accepts an optional * second parameter which is a reference to the fraction * factory/tool. * - Fraction class now correctly prints 0 if the fraction's * value is 0. * - a lot of the functionality has been moved to the * FractionTool class -- which should make the Fraction * class leaner. * - Fraction takes advantage of a singleton FractionTool * instance. * * Modification to fractionTool/FractionTool class: * - class name changed to FractionTool; 'fractionTool' will still * work. * - reduce corrected to work with negative numbers. * Previously, this would cause an infinite loop. * - upon instantiation, unserialize self to the global * constant variable 'FractionTool_instance'. If * fraction class needs this, then the FractionTool * can be retrieved by deserializing the 'FractionTool_instance' * constant variable. * * * For 0.7: * ======== * pack() is now replaced by reduce(). * toString() now does not automatically * reduce(). * * To do: * (1) Add other operations if needed. I don't know * how much interest there is for the more complex * operations, but it might be added in the future. * I just don't want the class to get too bloated. * / class Fraction { var $num = 1, $denom = 1; var $classname = "Fraction"; var $tool = null; /* * Creates a Fraction. This constructor accepts * a string, double, integer, or an array of * one, two or three elements. * e.g. $val1 = new Fraction("5 1/3"); * $val1 = new Fraction(1.25); * $val1 = new Fraction(20); * $val1 = new Fraction(array (5, 1, 3)); / function Fraction ($val, $tool=null) { $this->tool = $tool; if (is_string($val)) { if (ereg("^(-?[0-9]+)$", $val, $regs)) { $this->create(0, $regs[1],1); } elseif (ereg("^(-?[0-9]+)[ ]/[ ]([0-9]+)$",$val,$regs)) { $this->create(0, $regs[1], $regs[2]); } elseif (ereg("^(-?[0-9]+)[ ]+([0-9]+)[ ]/[ ]([0-9]+)$",$val,$regs)){ $this->create($regs[1], $regs[2], $regs[3]); } } elseif (is_double($val)) { $len = strlen($val); $pos = strpos($val, "."); $this->create(0, ((double)$val) pow (10, ($len - $pos - 1)) , pow (10, ($len - $pos - 1))); } elseif (is_int($val)) { $this->create(0, $val,1); } elseif (is_array($val)) { if (sizeof($val) == 1) { $this->create(0, $val[0], 1); } elseif (sizeof($val)==2) { $this->create(0, $val[0],$val[1]); } elseif (sizeof($val)>=3) { $this->create ($val[0], $val[1], $val[2]); } } elseif (is_bool($val)) { $this->create(0, ($val?$val:0), 1); } else { // don't know what to do... just return null return $this->create (0, 0, 1); } } /** Inner method that actually creates the Fraction. * This should not be called directly from outside of this class. / function create($whole, $num, $denom) { if ($denom == 0) { $denom = 1; } // negative? if ((($whole < 0) xor ($denom < 0)) xor ($num < 0)) { // yes make the numerator negative $this->num = -1 (abs($whole) * abs($denom) + abs($num)); } else { $this->num = (abs($whole) * abs($denom) + abs($num)); } // denom always positive $this->denom = abs($denom); } /** Subtract another Fraction/integer from this Fraction / function subtract ($other) { $this->getTool(); return ($this->tool->subtract(&$this, $other)); } /* * Adds another Fraction/integer to this Fraction. / function add ($other) { $this->getTool(); return ($this->tool->add(&$this, $other)); } /* Multiple this Fraction by another Fraction or whole number / function multiply ($other) { $this->getTool(); return ($this->tool->multiply(&$this, $other)); } /* Divide this Fraction by another Fraction or whole number / function divide ($other) { $this->getTool(); return ($this->tool->divide(&$this, $other)); } /* Whether the object is a Fraction or not / function isFraction ($other) { $this->getTool(); return ($this->tool->isFraction($other)); } /* Reduce the Fraction / function reduce () { $this->getTool(); $this->tool->reduce (&$this); } /* Returns a string representation of the Fraction. / function toString() { if (abs($this->num) >= abs($this->denom)) { if ($this->denom == 1) { return $this->num; } if ($this->isNegative()) { $whole = ceil ($this->num / $this->denom); } else { $whole = floor ($this->num / $this->denom); } $num = abs($this->num % $this->denom); } else { $num = $this->num; } return ((empty($whole)?(empty($num)?"0":""):$whole) . (empty($num)? "" : " " . $num ."/". $this->denom)); } /* Returns a double representation of the Fraction / function toDouble() { return (double) $this->num / $this->denom; } / * Whether this Fraction is equal to another Fraction. * Returns true or half. / function equals ($other) { $this->getTool(); if ($this->tool->isFraction($other)) { return ($this->tool->areEqual ($this, $other)); } elseif ($this->tool->canBeFraction($other)) { $tmp = $this->tool->createFraction($other); return ($this->equals($tmp)); } return false; } /* * Is this Fraction negative? * Returns true or false. / function isNegative () { return (($this->num < 0) xor ($this->denom < 0)); } function getTool() { if ($this->tool == null) { if (defined ("FractionTool_instance")) { $this->tool = unserialize (FractionTool_instance); } else { $this->tool = new FractionTool(); define ("FractionTool_instance", serialize($this->tool)); } } return $this->tool; } } /* * Fraction related tool. Used by Fraction, but * this class does not require Fraction. / class FractionTool { var $classname = "FractionTool"; / Constructor / function FractionTool(){ // create an instance, and store it in a global instance variable if (! defined ("FractionTool_instance")) { define ("FractionTool_instance", serialize($this)); } } function createFraction ($val) { return (new Fraction ($val, &$this)); } /* * Find the greatest common divisor (gcd) * using Euclid's Algorithm. (read it from * http://www.mcn.net/~jimloy/euclids.html) * Takes in 2 values (numerator and denominator) * and returns the greatest common divisor. * Ideally, the first parameter is the larger * number of the two, but it's not necessary. / function gcd ($a, $b) { if ($b < 0 \|\| $a < 0) { return $this->gcd(abs($a), abs($b)); } if ($b > $a) { return $this->gcd($b, $a); } $rem = $a % $b; return (($rem == 0)?$b:$this->gcd($b,$rem)); } /* * Lowest Common Denominator (lcd) or * Lowest Common Multiple (lcm) / function lcd ($a, $b) { return (($a $b) / $this->gcd($a, $b)); } /** Lowest Common Multiple (lcm), * another name for Lowest Common Denominator (lcd) / function lcm($a, $b) { return $this->lcd($a, $b); } /* Subtract the part (Fraction or whole number) from the whole (Fraction) / function subtract ($whole, $part) { if ($this->isFraction($whole) && ($this->isFraction($part) \|\| is_int($part))) { if (is_int($part)) { $whole->num -= $part $whole->denom; } else { $lcd = $this->lcd ($whole->denom, $part->denom); $whole->num = ($lcd / $whole->denom); $whole->denom = ($lcd / $whole->denom); $whole->num -= ($part->num * ($lcd / $part->denom)); $whole->reduce(); } } return $whole; } /** * Adds a Fraction to another Fraction or whole number. / function add ($other, $another) { if ($this->isFraction($other) && ($this->isFraction($another) \|\| is_int($another))) { if (is_int($another)) { $other->num += $another $other->denom; } else { $lcd = $this->lcd ($other->denom, $another->denom); $other->num = ($lcd / $other->denom); $other->denom = ($lcd / $other->denom); $other->num += ($another->num * ($lcd / $another->denom)); $other->reduce(); } } return $other; } /** Multiple a Fraction by another Fraction or whole number / function multiply ($other, $another) { if ($this->isFraction($other) && ($this->isFraction($another) \|\| is_int($another))) { if (is_int($another)) { $other->num = $another; } else { $other->num = $another->num; $other->denom = $another->denom; // reduce at the end as we usually get big numbers here $other->reduce(); } } return $other; } /** Divide the dividend Fraction by the divisor (Fraction or whole number) / function divide ($dividend, $divisor) { if ($this->isFraction($dividend) && ($this->isFraction($divisor) \|\| is_int($divisor))) { if (is_int($divisor)) { $dividend->denom = $divisor; } else { $dividend->num = $divisor->denom; $dividend->denom = $divisor->num; } } $dividend->reduce(); return $dividend; } /** * Whether 2 Fractions are equal. * Returns true or false. / function areEqual ($other, $another) { if ($this->isFraction($other) && $this->isFraction($another)) { $other->reduce(); $another->reduce(); return ($other->toString() == $another->toString()); } else { return false; } } /* Reduce the Fraction / function reduce (&$obj) { if ($this->isFraction($obj)) { $gcd = $this->gcd($obj->num, $obj->denom); $obj->num /= $gcd; $obj->denom /= $gcd; } return $obj; } /* * Whether the object is a Fraction. / function isFraction ($obj) { return (is_object($obj) && isset($obj->classname) && $obj->classname == "Fraction"); } /* * Whether the variable can be turned into a Fraction. */ function canBeFraction ($obj) { return (is_string($obj) \|\| is_double($obj) \|\| is_integer($obj) \|\| is_array($obj)); } } ?>
A simple class that finds the greatest common denominator for two integers. <? function GCD ($a, $b) { while ( $b != 0) { $remainder = $a % $b; $a = $b; $b = $remainder; } return abs ($a); } /* DESCRIPTION ============================================================ GCD: A simple function that finds the Greatest Common Denominator for two numbers. ============================================================ CREDITS ============================================================ Author: J. A. Greant ( zak@nucleus.com ) Version 1: June 9, 2000 ============================================================ NOTICES ============================================================ If you: Modify this code and want to share your changes :) Find a bug Have other questions or comments Please write: Zak Greant (zak@nucleus.com) ============================================================ USAGE EXAMPLES ============================================================ print GCD (12, 120); // Should output 12 ============================================================ COPYRIGHT ============================================================ Copyright (c) 2000 J. A. Greant ( zak@nucleus.com ) All rights reserved. This function is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This function is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this function; if not, write to the: Free Software Foundation, Inc. 59 Temple Place, Suite 330 Boston, MA 02111-1307 USA http://www.gnu.org/ ============================================================ */ ?>
simple function to determine if a number is even or odd. <?php /* is_even - returns 1 if number is even, returns 0 if it's odd ----- DESCRIPTION int is_even( [number] ) ----- EXAMPLE $number = 5; echo is_even($number); // returns 0 */ function is_even($num) { if(!is_int($num/2)) { return 1; } else { return 0; } } ?>
Simple linear regression class <?php /** * @author Son Nguyen * @since 11/18/2005 * @package Framework.Data * @subpackage Math / class CRegressionLinear { private $mDatas; /* constructor / function __construct($pDatas) { $this->mDatas = $pDatas; } /* get the coefficients / function calculate() { $n = count($this->mDatas); $vSumXX = $vSumXY = $vSumX = $vSumY = 0; foreach ($this->mDatas AS $x=>$y) { $vSumXY += $x$y; $vSumXX += $x$x; $vSumX += $x; $vSumY += $y; } // rof $a = ($n$vSumXY - $vSumX$vSumY)/($n$vSumXX - $vSumX$vSumX); $b = ($vSumY - $a$vSumX)/$n; return array($a,$b); } /** given x, return the prediction / function predict($x) { list($a,$b) = $this->calculate(); $y = $a$x+$b; return $y; } } ?>
With this class you can convert your integer/number to english fraction words. Ex. 1=>One, 250=>Two hundred fifty, 1000=>One thousand. Give it a try. <?php /*********************************************** * Snippet Name : Num2Words * * Scripted By : Hermawan Haryanto * * Website : http://hermawan.dmonster.com * * Email : hermawan@dmonster.com * * License : GPL (Gnu Public License) * **********************************************/ // START CONVERTION CLASS class num2words { var $numb = Array(); var $tail; var $number; var $currency; var $min; function num2words () { $this->numb = Array ("", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"); } function mod($a,$b) { return $a-$bfloor($a/$b); } function setTail($str) { $this->tail = $str; } function setNumber($int) { $int = trim($int); if (is_int(strpos($int,"-"))) { $this->number = substr($int,strpos($int,"-")+1,strlen($int)); $this->currency = "minus"; } else { $this->number = $int; } $this->setAsCurrency(); } function getCurrency() { return $this->currency; } function printCurrency() { print ucfirst(strtolower(trim($this->currency))); } function setAsCurrency() { $xpos = strpos($this->number,"."); if (is_int($xpos)) { $pecahan = round(substr($this->number,$xpos,strlen($this->number)),2); $sisa = substr($this->number,0,$xpos); } else { $pecahan = ""; $sisa = $this->number; } if ($sisa==0 \|\| $this->number==0) { $this->currency .= "zero ".$this->tail; } else { $trilion = floor($sisa/pow(10,12)); $sisa = $this->mod($sisa,1000000000000); $billion = floor($sisa/pow(10,9)); $sisa = $this->mod($sisa,1000000000); $million = floor($sisa/pow(10,6)); $sisa = $this->mod($sisa,1000000); $thousand = floor($sisa/pow(10,3)); $sisa = $this->mod($sisa,1000); $words = $this->ThreeDigit($trilion, "trilion"); $words .= $this->ThreeDigit($billion, "billion"); $words .= $this->ThreeDigit($million, "million"); $words .= $this->ThreeDigit($thousand, "thousand"); $words .= $this->ThreeDigit($sisa,""); $words .= " ".$this->tail; } if ($pecahan>0) { $words .= " and". $this->ThreeDigit(round($pecahan*100),"sen"); } $this->currency .= strtolower($words); } function ThreeDigit($amount, $suffix="") { $sisa = (int) $amount; $words = ""; if ($sisa < 20 && $sisa > 10) { if ($sisa==11) { $words = " eleven"; } elseif ($sisa == 12) { $words = " twelve"; } elseif ($sisa == 13) { $words = " thirteen"; } elseif ($sisa == 15) { $words = " fifteen"; } elseif ($sisa == 18) { $words = " eighteen"; } else { $words = " ".$this->numb[$sisa-10]."teen"; } if ($suffix != "") { $words .= " ".$suffix; } return $words; } $ratus = floor($sisa/100); if ($ratus <= 0) { $words .= ""; } else { $words .= " ".$this->numb[$ratus]." hundred"; } $sisa = $this->mod($sisa,100); if ($sisa < 20 && $sisa > 10) { if ($sisa == 11) { $words .= " eleven ". $suffix; } elseif ($sisa == 12) { $words .= " twelve"; } elseif ($sisa == 13) { $words .= " thirteen"; } elseif ($sisa == 15) { $words .= " fifteen"; } elseif ($sisa == 18) { $words .= " eighteen"; } else { $words .= " ".$this->numb[$sisa-10]."teen ". $suffix; } return $words; } $puluh = floor($sisa/10); if ($puluh == 0) { $words .= ""; } elseif ($puluh == 1) { $words .= " ten"; } elseif ($puluh == 2) { $words .= " twenty"; } elseif ($puluh == 3) { $words .= " thirty"; } elseif ($puluh == 5) { $words .= " fifty"; } elseif ($puluh == 5) { $words .= " eighty"; } else { $words .= " ".$this->numb[$puluh]."ty"; } $sisa = $this->mod($sisa,10); if ($sisa>0&&$sisa<=9) { $words .= " ".$this->numb[$sisa]; } if ($amount>0&&$amount<=1000) { $words .= " ".$suffix; } return $words; } } // END CONVERTION CLASS ?>
fmtnum() takes a number and formats it for easy reading. It can convert a number to scientic notation or return it with quantifier attached. For example, you could use it to format the number 12345678 into 1x10+7 or 12.34 M. /* Function: fmtnum ($data, $decimal, $format) Author: Matt Hoskins (matth@npgco.com) Date: 12/11/2002 License: GPL Description: numfmt() allows you to format large numbers into easily readable ones. For example: Input Returns ----- ------- 1500000000 1.50 G 1200000 1.20 M 1334 1.33 K By specifying the format as FMT_SCI, the function will return the number in scientic notation. You can also force the conversion into a specific type by specifying the format. Usage: int numfmt (int $data, [int $decimal], [string $format]) $data -- The number you want converted $decimal -- The number of decimal points to return. (defaults to 2, if not specified) $format -- Forces the function to return in the specified format. FMT_GIGA -- Returns with G postfix FMT_MEGA -- Returns with M postfix FMT_KILO -- Returns with K postfix FMT_SCI -- Returns in Scietific Notation Any feedback is greatly appreciated. / function fmtnum ($data) { $format = @func_get_arg(2); $decimal = @func_get_arg(1); if (!isset($decimal)) { $decimal = 2; } switch ($format) { case "FMT_GIGA": $data = sprintf("%0.".$decimal."f G", $data / 1000000000); break; case "FMT_MEGA": $data = sprintf("%0.".$decimal."f M", $data / 1000000); break; case "FMT_KILO": $data = sprintf("%0.".$decimal."f K", $data / 1000); break; case "FMT_SCI": if ($data < 1) { while ($data < 1) { $data = 10; $power++; } $data = sprintf("%0.".$decimal."f x 10<sup>-".$power."</sup>", $data); } elseif ($data > 10) { while ($data > 10) { $data /= 10; $power++; } $data = sprintf("%0.".$decimal."f x 10<sup>".$power."</sup>", $data); } break; default: if ($data > 1000000000 ) { $data = sprintf("%0.".$decimal."f G", $data / 1000000000); } elseif ($data > 1000000 ) { $data = sprintf("%0.".$decimal."f M", $data / 1000000); } elseif ( $data > 1000 ) { $data = sprintf("%0.".$decimal."f K", $data / 1000); } } return $data; }
Feed it "21" and it returns "21st". Prints any number with the appropriate English ordinal suffix. function ordinal($number) { // when fed a number, adds the English ordinal suffix. Works for any // number, even negatives if ($number % 100 > 10 && $number %100 < 14): $suffix = "th"; else: switch($number % 10) { case 0: $suffix = "th"; break; case 1: $suffix = "st"; break; case 2: $suffix = "nd"; break; case 3: $suffix = "rd"; break; default: $suffix = "th"; break; } endif; return "${number}<SUP>$suffix</SUP>"; }
The code fragment (function) allows to find the scheme of all possible combinations of a given number of elements and will return the array with all combinations. Optionally it allows to find also the combinations that dont include all elements. The examples show how to apply the code. Idea/basics of the code were taken from a nice contribution here: http://www.phpfreaks.com/phpref/21.php <?php //all functions //************* function getPermutations($length, $sublength, $index, $separator, $start) { $out_pattern = $out_scheme = array(); if ($sublength>$length) $sublength = $length; $max = factorial($length); echo "options = $sublength / $length, factorial = $max <br />\n"; //for ($a=0; $a<$length; $a++) $options[$a] = $pattern[$a] = $a; for ($a=$start; $a<($length+$start); $a++) $options[$a] = $pattern[$a] = $a; for ($x=0; $x<$max; $x++) { $N = $x; for ($i=1; $i<= $length;) { $pattern[($length+$start-$i)] = $N % $i; $N = $N/$i; $i++; } unset($perm); $b = $options; foreach($pattern AS $offset) { list($char) = array_splice($b, $offset, 1); $perm[] = $char; } $m = array_slice ($perm, 0, $sublength); $out_pattern[] = implode($m); $out_scheme[] = join($separator, $m); } if ($index==0) return array_unique($out_scheme); if ($index==1) return array_unique($out_pattern); } function factorial($s) { if($s) $r = $s * factorial($s - 1); else $r = 1; return $r; } //Basic example (output of scheme) //****************************** $items=5; //amount of elements $include=5; //amount of elements taken into account $index=0; //output index: 0=scheme with separator, 1=numbers only $separator='-'; //separator char for index=0 $start=1; //first number of scheme $results1 = getPermutations($items, $include, $index, $separator, $start); foreach ($results1 as $output) echo $output . "<br />\n"; //Example how to apply and include also combinations without all elements (output of scheme) //************************************************************************************** $items=4; $include=4; $index=0; $separator='-'; $start=1; $results2 = $temp = array(); for($a1=1; $a1<=$include; $a1++) { $temp = getPermutations($items, $a1, $index, $separator, $start); $results2 = array_merge($results2, $temp); } foreach ($results2 as $output) echo $output . "<br />\n"; //Example how to apply on a list of words //************************************* $words=array("fanta", "coke", "sprite", "budweiser"); $items=count($words); $include=3; //Note: output index has to be 0 $start=1; $separator='-'; $results3 = getPermutations($items, $include, 0, $separator, $start); for ($a2=($items+$start-1); $a2>=0; $a2--) $search[]=$a2; $replace=array_reverse($words); $results4=array(); for ($a1=0; $a1<count($results3); $a1++) { $results4[]=str_replace($search, $replace, $results3[$a1]); } //output with separator foreach ($results4 as $output) echo $output . "<br />\n"; //output without separator foreach ($results4 as $output) echo str_replace($separator, '', $output) . "<br />\n"; ?>
Find the PI value with these routines. Try come closer to 3.14159265358979323846!!! <?PHP class pisearch { // public vars var $max = 150000; function one() { /* PI Search! - method 1/ // In the books: 1+1/4+1/9+1/16+...=(PI^2)/6 // got from PHP doc -> PI: 3.14159265358979323846 // How much greater $max will, more exact the value will be for ($x = 1; $x <= $this->max; $x++) { $r = 1 / ($x $x); $s += $r; } return sqrt(6 * $s); //sqrt = x^(1/2) } function two() { /* PI Search! - method 2/ // In the books: PI /2 = (2/1)(2/3)(4/3)(4/5)(6/5)(6/7) // got from PHP doc -> PI: 3.14159265358979323846 // How much greater $max will, more exact the value will be // SOME values to make for {} work $dw = 1; $l = 1; $up = 2; $pi = 4; for ($x = 2; $x <= $this->max; $x++) { $l++; if ($l % 2 != 0) $up = $x + 1; elseif ($l % 2 == 0) $dw += 2; $pi = $pi ($up/$dw); if ($l == 4) $l = 0; } return $pi; } } ?>
Takes a number like 1000.000001 and rounds it to 1001, or 1000.9 and rounds it to 1001 I made this for my paginator which gets the total pages then divides by amount per page, sometimes it returns 1.1 or 1.00001 etc, so it rounds it up for a solid number to use for the paginator Heres a nice function I made for my pagination that rounds to the next number if the number is greater than the whole number. EX: 2.000001 will return 3 2.5 will return 3 2 will return 2 1.9 or 1.3 etc will return 2 Can use it as long as copyright remains intact. <?php function round_up($Number) { // Copyright Josh Acecool M http://www.acecoolco.com if ($Number > number_format($Number, "0")) { $Number = round($Number); $Number++; } else { $Number = number_format($Number, "0"); } return $Number; } ?>
Calculation of a determinant of a matrix of the any order on the first line function determinant($matrica) { $determinant=0; if (sizeof($matrica)==1) return $matrica[0][0]; for ($i=0; $i<sizeof($matrica); $i++) { // We form a minor $row_index=0; for ($j=0; $j<sizeof($matrica); $j++) { $column_index=0; if($j!=0) { for ($k=0; $k<sizeof($matrica); $k++) { if ($k!=$i) { $minor[$i][$row_index][$column_index]=$matrica[$j][$k]; $column_index++; } } $row_index++; } } // We form algebraic addition $algebraic_addition[$i]=pow(-1, (2+$i))determinant($minor[$i]); $determinant+=$matrica[0][$i]$algebraic_addition[$i]; } return $determinant; }
returns TRUE if the number is even, FALSE if not function is_even($number) { return $number%2==0?TRUE:FALSE; }
take for example, you want to have 2 significiant digits, then 3.34 => 3.3 0.003445 => 0.0034 345.45 => 340 1 => 1.0 0.02 => 0.020 3.45e-4 => 0.00034 0 => 0.0 this function works with any non-negtive numbers(including numbers in scientific format) function signify($number, $digits) { $number = (float)$number; $digits = (int)$digits; if($number) { $whole_part = pow(10, ceil(log10($number))); $ret = $whole_part * round($number/$whole_part, $digits); // fix scientific bug if($ret < 1) { $decimal_num = - floor(log10($ret)); $format = "%1.".($decimal_num + $digits - 1).'f'; $ret = sprintf("$format", $ret); } } // fix zero bug else { $ret = 0; } // deal with display $raw_len = strlen($ret); if(preg_match('/^0\.0*/', $ret, $out)) $raw_len -= strlen($out[0]); else $raw_len -= preg_match('/\./', $ret); if($raw_len < $digits) { if(preg_match('/\./', $ret)) $ret = $ret.str_repeat('0', ($digits - $raw_len)); else $ret = $ret.'.'.str_repeat('0', ($digits - $raw_len)); } return $ret; }
A simple Add, Subtract, Multiply, and Divide Calculator. This is a short example of a form, data validation, commenting, CSS, HTML, and rather neat code. Beginners may benifit from the source code contained within. <? /* Calculator - by Jason Garber www.ionzoft.com This is a short example of a form, data validation, commenting, and rather neat code. Started Coding at 9:09 Finished testing and debugging at 9:35 24 Minutes / //Get the double values of the inputs (convert them from string to double) $txtNUMER = doubleval($txtNUMER); $txtDENOM = doubleval($txtDENOM); //If the ACTION is SOLVE //Note: Action is an hidden input tag. It will NOT be present the first time the page is loaded if($ACTION == "SOLVE") { //What operator are we using? switch($cboOPER) { case 'ADD': $sOut = "$txtNUMER + $txtDENOM = " . ($txtNUMER + $txtDENOM); break; case 'SUB': $sOut = "$txtNUMER - $txtDENOM = " . ($txtNUMER - $txtDENOM); break; case 'MUL': $sOut = "$txtNUMER $txtDENOM = " . ($txtNUMER * $txtDENOM); break; case 'DIV': if($txtDENOM == 0) //Check for divide by 0 condition $sOut = "Error: Divide by Zero"; else $sOut = "$txtNUMER / $txtDENOM = " . ($txtNUMER / $txtDENOM); break; default: //If we are here, then someone was probably monkeying with the query string... $sOut = "Error: Invalid Operator"; } } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> <html> <head> <title>Calculator</title> <style type="text/css"> body { font-family: Tahoma; font-size: smaller; } </style> </head> <body> <h1>Calculator</h1> <h3 style="color: navy;">Enter your Calculation and click Solve:</h3> <br> <h4 style="color: red;"><?= $sOut?></h4> <form name="frmCalc" action="<?= $PHP_SELF?>" method="get"> <input type="Hidden" name="ACTION" value="SOLVE"> <table> <tr> <td></td> <td><input type="Text" name="txtNUMER" width="12" value="<?= $txtNUMER ?>"></td> </tr> <tr> <td> <select name="cboOPER" size="1"> <option value="ADD" <?= ($cboOPER == "ADD" ? "selected" : "")?>>+</option> <option value="SUB" <?= ($cboOPER == "SUB" ? "selected" : "")?>>-</option> <option value="MUL" <?= ($cboOPER == "MUL" ? "selected" : "")?>>*</option> <option value="DIV" <?= ($cboOPER == "DIV" ? "selected" : "")?>>/</option> </select> </td> <td><input type="Text" name="txtDENOM" width="12" value="<?= $txtDENOM ?>"></td> </tr> <tr> <td colspan="2"><hr width="100%"></td> </tr> <tr> <td></td> <td align="right"><input type="Submit" value="Solve"></td> </tr> </table> </form> </body> </html>
A simple function designed to calculate the standard deviation of an array of values. function standard_deviation($array) { //Get sum of array values while(list($key,$val) = each($array)) { $total += $val; } reset($array); $mean = $total/count($array); while(list($key,$val) = each($array)) { $sum += pow(($val-$mean),2); } $var = sqrt($sum/(count($array)-1)); return $var; }
Calculates the Standard Deviation of an array of numerical values. #This function returns the standard deviation of an array #of numerical values where $std is the array name. function standard_deviation($std) { $total; while(list($key,$val) = each($std)) { $total += $val; } reset($std); $mean = $total/count($std); while(list($key,$val) = each($std)) { $sum += pow(($val-$mean),2); } $var = sqrt($sum/(count($std)-1)); return $var; }
This is a statistic class that accepts one or two unidimensional arrays of data. It returns a stat array using the getStats() method. If only one array is sent, it will return the min,max, sum, median, average and standard deviation for this array. If two arrays are sent, in addition to these values for both arrays, a linear regression line is computed with its correlation r and 't'test. Median correction applied on 02/26/01. <?php /* * This is a statistic class that accepts one or two unidimensional arrays of data. * It returns a stat array using the getStats() method. * If only one array is sent, it will return the min,max, sum, median, average and standard * deviation for this array. If two arrays are sent, in addition to these values for both * arrays, a linear regression line is computed: m is the slope b is the Yaxis intersect, * r is the correlation, a measure of the quality of the data fit by the regression line (r=1 * being a perfect fit) and t is the "t"test, to test whether the association between X and Y * data is real or merely apparent, I leave the user to interpret this test himself. (See the * tutorial and the table at: http://www.bmj.com/collections/statsbk/apptabb.html). * The regression line will be calculated only if both arrays have the same number of samples. * Note that it is the responsibility of the user to make sure that his data are in linear form * (For the linear regression to work, Median and Average values should be close). * I tried to use the histogram class wrote by Jesus Castagnetto as an inheritance for * this script, but it was too complicated since that I needed two arrays. Probably the other * way around, using Stat1 as an inheritance for an histogram class, will be easier now. * Tested with PHP4 beta 4. * (c) Alain M. Samoun 3/12/00 alain@samoun.com * License: Same as the GNU's Free Software Foundation or the open source PHP license as you prefer;-). This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. / class Stat1 { / variables / var $N,$NY,$MINX,$MAXX,$MAXY,$MINY,$AVGX,$AVGY,$STDVX,$STDVY,$SUMX,$SUMY,$SUMX2,$SUMY2,$SUMXY; var $X = array(),$Y = array(); var $MEDX,$MEDY,$DEV,$m,$b,$r; var $STATS = array(); / Constructor / function Stat1($X="", $Y="",$DEV=0, $title="") { if ($X && $Y && $title) { $this->create($X,$Y,$title); } } / Create the class / function create($X,$Y,$title="") { / Check if we got a valid set of data/ (($this->N = count($X)) > 1) or die("Not enough data, number of values : ".$this->N."\n"); / initialize values / $this->MINX = (float) min($X); $this->MAXX= (float) max($X); / Compute X Median / # Sort values in array X $XX = $X; sort ($XX); if ($this->N%2 == 0){ $this->MEDX = (($XX[($this->N)/2])+($XX[-1+($this->N/2)]))/2; }else{ $this->MEDX = $XX[floor($this->N/2)]; } $this->NY = count($Y); $this->MINY = (float) min($Y); $this->MAXY= (float) max($Y); / Compute Y Median / # Sort values in array Y $YY = $Y; sort ($YY); if ($this->NY%2 == 0){ $this->MEDY = (($YY[($this->NY)/2])+($YY[-1+($this->NY/2)]))/2; }else{ $this->MEDY = $YY[floor($this->NY/2)]; } $this->setTitle($title); / stats / for ($i = 0; $i < $this->N ; $i++) { $this->SUMX += (float) $X[$i]; $this->SUMX2 += (float) pow($X[$i],2); $this->SUMXY += (float) $X[$i] (float)$Y[$i]; } $this->AVGX = (float) $this->SUMX/ (float) $this->N; $this->STDVX = (float) sqrt(($this->SUMX2 - $this->Npow($this->AVGX,2))/(float)($this->N - 1)); for ($i = 0; $i < $this->NY ; $i++) { $this->SUMY += (float) $Y[$i]; $this->SUMY2 += (float) pow($Y[$i],2); } $this->AVGY = (float) $this->SUMY/ (float)$this->NY; $this->STDVY = (float) sqrt(($this->SUMY2 - $this->NYpow($this->AVGY,2))/(float)($this->NY - 1)); if ($this->NY == $this->N){ $this->DEV = (float) (($this->SUMX2 * $this->N)- ($this->SUMX * $this->SUMX)); $this->m = (float)(($this->SUMXY * $this->N)- ($this->SUMX * $this->SUMY))/$this->DEV; $this->b = (float)(($this->SUMX2 * $this->SUMY)- ($this->SUMXY * $this->SUMX))/$this->DEV; $this->r = (float) ($this->SUMXY -($this->N * $this->AVGX * $this->AVGY))/(($this->N-1)$this->STDVX $this->STDVY); $this->t = (float) $this->r * sqrt(($this->N -2)/(1- pow($this->r,2))); } /* make the STATS array / $this->STATS = array ( N=>$this->N, NY=>$this->NY, MINX=>$this->MINX, MAXX=>$this->MAXX, SUMX=>$this->SUMX, MEDX=>$this->MEDX, AVGX=>$this->AVGX, STDVX=>$this->STDVX, MINY=>$this->MINY, MAXY=>$this->MAXY, SUMY=>$this->SUMY, MEDY=>$this->MEDY, AVGY=>$this->AVGY, STDVY=>$this->STDVY, m=>$this->m, b=>$this->b, r=>$this->r, t=>$this->t ); } / sets the Title / function setTitle($title) { $this->TITLE=$title; } / send back STATS array / function getStats() { return $this->STATS; } / simple printStats / function printStats() { $s = "Statistics for : ".$this->TITLE."\n"; $s .= "Number of data in X axis: $this->N \n"; $s .= sprintf("Min = %-2.4f\tMax = %-2.4f\tAvg = %-2.4f\tMED = %-2.4f\tStDev = %-2.4f \n",$this->MINX,$this->MAXX,$this->AVGX,$this->MEDX, $this->STDVX ); $s .= "\nNumber of data in Y axis: $this->NY \n"; $s .= sprintf("Min = %-2.4f\tMax = %-2.4f\tAvg = %-2.4f\tMED = %-2.4f\tStDev = %-2.4f \n",$this->MINY,$this->MAXY,$this->AVGY,$this->MEDY, $this->STDVY ); if($this->NY ==$this->N){ $s .= "\nLinear regression line: \n"; if ($this->b >=0){ $s .= "Y = $this->m X + $this->b with correlation (r)= $this->r\n \"t\"test (df=$this->N-2) = $this->t"; }else{ $s .= "Y = $this->m X $this->b with correlation (r)= $this->r\n \"t\"test (df=$this->N-2) = $this->t"; } } echo $s; } } / end of Stat1 class */ ?>
skewness , kurtosis and mean or average statistical function /* In this code fraction, there r 3 function that run on mean or average and skewness and kurtosis. Program by : dhiranuntk@hotmail.com Date : Feb.18,2001 / function mean(&$array) { $average = 0; while (list($key, $val)=each($array)) $average += $val; reset($array); $average /= count($array); return $average; } function skewnessandkurtosis($array, &$skew, &$kurt) { $skew = "N/A"; $kurt = "N/A"; $amount = count($array); if ($amount > 2) { for ($i = 0, $m2 =0,$m3=0,$m4=0; $i < $amount; $i++) { $array [$i] -= mean($array); $m2 += pow($array[$i], 2); $m3 += pow($array[$i], 3); $m4 += pow($array[$i], 4); } $m2 /= $amount; $m3 /= $amount; $m4 /= $amount; $skew = $m3 / pow($m2, 1.5); $skew = sqrt($amount($amount-1))/ ($amount-2); if ($amount > 3) { $kurt = ($m4/ pow($m2, 2))-3; $kurt = (($amount+1)$kurt)+6; $kurt = ($amount-1)/(($amount-2)($amount-3)); } } }
It takes in a string like 12345.123 and it will convert it to the normal money format 12,345.12 // This is a hack on cwe7g's comma integer script. // It takes in a string and adds comma's and also // adds the correct cents // // Ken Cochrane // Ken@PopcornMonsters.com // http://www.PopcornMonsters.com // // Current Version 1.1 // // What's new in Version 1.1 // - added support for negative numbers. function to_money($string) { $Negative = 0; //check to see if number is negative if(preg_match("/^\-/",$string)) { //setflag $Negative = 1; //remove negative sign $string = preg_replace("\|\-\|","",$string); } //look for commas in the string and remove them. $string = preg_replace("\|\,\|","",$string); //split the string into two First and Second // First is before decimal, second is after First.Second $Full = split("[\.]",$string); $Count = count($Full); if($Count > 1) { $First = $Full[0]; $Second = $Full[1]; $NumCents = strlen($Second); if($NumCents == 2) { //do nothing already at correct length } else if($NumCents < 2) { //add an extra zero to the end $Second = $Second . "0"; } else if($NumCents > 2) { //either string off the end digits or round up // I say string everything but the first 3 digits and then round // since it is rare that anything after 3 digits effects the round // you can change if you need greater accurcy, I don't so I didn't // write that into the code. $Temp = substr($Second,0,3); $Rounded = round($Temp,-1); $Second = substr($Rounded,0,2); } } else { //there was no decimal on the end so add to zeros $First = $Full[0]; $Second = "00"; } $length = strlen($First); if( $length <= 3 ) { //To Short to add a comma $string = $First . "." . $Second; // if negative flag is set, add negative to number if($Negative == 1) { $string = "-" . $string; } return $string; } else { $loop_count = intval( ( $length / 3 ) ); $section_length = -3; for( $i = 0; $i < $loop_count; $i++ ) { $sections[$i] = substr( $First, $section_length, 3 ); $section_length = $section_length - 3; } $stub = ( $length % 3 ); if( $stub != 0 ) { $sections[$i] = substr( $First, 0, $stub ); } $Done = implode( ",", array_reverse( $sections ) ); $Done = $Done . "." . $Second; // if negative flag is set, add negative to number if($Negative == 1) { $Done = "-" . $Done; } return $Done; } }

php.ComLanka.com PHP Tutorial ,PHP source code, PHP online example