nnnn?php /* * MODIFICATIONS * - Removed `\` for php5.2 support (does not support namespaces). * - Renamed with prefix to avoid naming collisions. * - Updated references to the EOS Stack class to reflect name changes. */ /** * Equation Operating System Classes. * * This class was created for the safe parsing of mathematical equations * in PHP. There is a need for a way to successfully parse equations * in PHP that do NOT require the use of `eval`. `eval` at its core * opens the system using it to so many security vulnerabilities it is oft * suggested /never/ to use it, and for good reason. This class set will * successfully take an equation, parse it, and provide solutions to the * developer. It is a safe way to evaluate expressions without putting * the system at risk. * * 2015/07 * - Added all real number factorial support * - Added gamma function to class * * 2014/08 * - Added scientific notation support * - Added basic factorial support * * 2013/06 UPDATE: * - Added 'abs' (absolute value) support per tjbaron's update. * * 2013/04 UPDATE: * - Moved to native class functions for PHP5 * - Removed deprecated `eregi` calls to `preg_match` * - Updated to PHPDoc comment syntax * - Added Exception throwing instead of silent exits * - Added additional variable prefix of '$', '&' is still allowed as well * - Fixed small implied multiplication problem * * @author Jon Lawrence * @copyright Copyright 2005-2015, Jon Lawrence * @license http://opensource.org/licenses/LGPL-2.1 LGPL 2.1 License * @package EOS * @version 2.2.1 */ require_once 'Stack.php'; /** * Equation Operating System (EOS) Parser * * An EOS that can safely parse equations from unknown sources returning * the calculated value of it. Can also handle solving equations with * variables, if the variables are defined (useful for the Graph creation * that the second and extended class in this file provides. {@see eqGraph}) * This class was created for PHP4 in 2005, updated to fully PHP5 in 2013. * * @author Jon Lawrence * @copyright Copyright �2005-2013, Jon Lawrence * @license http://opensource.org/licenses/LGPL-2.1 LGPL 2.1 License * @package Math * @subpackage EOS * @version 2.2.1 */ class NF_EOS_Parser { /** * No matching Open/Close pair */ const E_NO_SET = 5500; /** * Division by 0 */ const E_DIV_ZERO = 5501; /** * No Equation */ const E_NO_EQ = 5502; /** * No variable replacement available */ const E_NO_VAR = 5503; /** * Not a number */ const E_NAN = 5504; /** * @var bool Activate Debug output. * @see __construct() * @see solveIF() */ public static $debug = FALSE; /**#@+ *Private variables */ private $postFix; private $inFix; /**#@-*/ /**#@+ * Protected variables */ //What are opening and closing selectors protected $SEP = array('open' => array('(', '['), 'close' => array(')', ']')); //Top presedence following operator - not in use protected $SGL = array('!'); //Order of operations arrays follow protected $ST = array('^', '!'); protected $ST1 = array('/', '*', '%'); protected $ST2 = array('+', '-'); //Allowed functions protected $FNC = array('sin', 'cos', 'tan', 'csc', 'sec', 'cot', 'abs', 'log', 'log10', 'sqrt'); /**#@-*/ /** * Construct method * * Will initiate the class. If variable given, will assign to * internal variable to solve with this::solveIF() without needing * additional input. Initializing with a variable is not suggested. * * @see Parser::solveIF() * @param String $inFix Standard format equation */ public function __construct($inFix = null) { if(defined('DEBUG') && DEBUG) { self::$debug = true; } $this->inFix = (isset($inFix)) ? $inFix : null; $this->postFix = array(); } /** * Check Infix for opening closing pair matches. * * This function is meant to solely check to make sure every opening * statement has a matching closing one, and throws an exception if * it doesn't. * * @param String $infix Equation to check * @throws Exception if malformed. * @return Bool true if passes - throws an exception if not. */ private function checkInfix($infix) { if(trim($infix) == "") { throw new Exception("No Equation given", NF_EOS_Parser::E_NO_EQ); } //Make sure we have the same number of '(' as we do ')' // and the same # of '[' as we do ']' if(substr_count($infix, '(') != substr_count($infix, ')')) { throw new Exception("Mismatched parenthesis in '{$infix}'", NF_EOS_Parser::E_NO_SET); } elseif(substr_count($infix, '[') != substr_count($infix, ']')) { throw new Exception("Mismatched brackets in '{$infix}'", NF_EOS_Parser::E_NO_SET); } $this->inFix = $infix; return true; } /** * Infix to Postfix * * Converts an infix (standard) equation to postfix (RPN) notation. * Sets the internal variable $this->postFix for the Parser::solvePF() * function to use. * * @link http://en.wikipedia.org/wiki/Infix_notation Infix Notation * @link http://en.wikipedia.org/wiki/Reverse_Polish_notation Reverse Polish Notation * @param String $infix A standard notation equation * @throws Exception When parenthesis are mismatched. * @return Array Fully formed RPN Stack */ public function in2post($infix = null) { // if an equation was not passed, use the one that was passed in the constructor $infix = (isset($infix)) ? $infix : $this->inFix; //check to make sure 'valid' equation $this->checkInfix($infix); $pf = array(); $ops = new NF_EOS_Stack(); //$vars = new Stack(); // remove all white-space $infix = preg_replace("/\s/", "", $infix); // Create postfix array index $pfIndex = 0; //what was the last character? (useful for decerning between a sign for negation and subtraction) $lChar = ''; //loop through all the characters and start doing stuff ^^ for($i=0;$iSEP['open'])) { // if the last character was a number, place an assumed '*' on the stack if(preg_match('/[0-9.]/i', $lChar)) $ops->push('*'); $ops->push($chr); } // if the character closes a set e.g. ')' or ']' elseif(in_array($chr, $this->SEP['close'])) { // find what set it was i.e. matches ')' with '(' or ']' with '[' $key = array_search($chr, $this->SEP['close']); // while the operator on the stack isn't the matching pair...pop it off while($ops->peek() != $this->SEP['open'][$key]) { $nchr = $ops->pop(); if($nchr) $pf[++$pfIndex] = $nchr; else { throw new Exception("Error while searching for '". $this->SEP['open'][$key] ."' in '{$infix}'.", NF_EOS_Parser::E_NO_SET); } } $ops->pop(); } // If a special operator that has precedence over everything else elseif(in_array($chr, $this->ST)) { while(in_array($ops->peek(), $this->ST)) $pf[++$pfIndex] = $ops->pop(); $ops->push($chr); $pfIndex++; } // Any other operator other than '+' and '-' elseif(in_array($chr, $this->ST1)) { while(in_array($ops->peek(), $this->ST1) || in_array($ops->peek(), $this->ST)) $pf[++$pfIndex] = $ops->pop(); $ops->push($chr); $pfIndex++; } // if a '+' or '-' elseif(in_array($chr, $this->ST2)) { // if it is a '-' and the character before it was an operator or nothingness (e.g. it negates a number) if((in_array($lChar, array_merge($this->ST1, $this->ST2, $this->ST, $this->SEP['open'])) || $lChar=="") && $chr=="-") { // increase the index because there is no reason that it shouldn't.. $pfIndex++; $pf[$pfIndex] = $chr; } // Otherwise it will function like a normal operator else { while(in_array($ops->peek(), array_merge($this->ST1, $this->ST2, $this->ST))) $pf[++$pfIndex] = $ops->pop(); $ops->push($chr); $pfIndex++; } } // make sure we record this character to be referred to by the next one $lChar = $chr; } // if there is anything on the stack after we are done...add it to the back of the RPN array while(($tmp = $ops->pop()) !== false) $pf[++$pfIndex] = $tmp; // re-index the array at 0 $pf = array_values($pf); // set the private variable for later use if needed $this->postFix = $pf; // return the RPN array in case developer wants to use it fro some insane reason (bug testing ;] return $pf; } //end function in2post /** * Solve Postfix (RPN) * * This function will solve a RPN array. Default action is to solve * the RPN array stored in the class from Parser::in2post(), can take * an array input to solve as well, though default action is preferred. * * @link http://en.wikipedia.org/wiki/Reverse_Polish_notation Postix Notation * @param Array $pfArray RPN formatted array. Optional. * @throws Exception On division by zero. * @return Float Result of the operation. */ public function solvePF($pfArray = null) { // if no RPN array is passed - use the one stored in the private var $pf = (!is_array($pfArray)) ? $this->postFix : $pfArray; // create our temporary function variables $temp = array(); //$tot = 0; $hold = 0; // Loop through each number/operator for($i=0;$iST, $this->ST1, $this->ST2))) { $temp[$hold++] = $pf[$i]; } // ...Otherwise perform the operator on the last two numbers else { switch ($pf[$i]) { case '+': $temp[$hold-2] = $temp[$hold-2] + $temp[$hold-1]; break; case '-': $temp[$hold-2] = $temp[$hold-2] - $temp[$hold-1]; break; case '*': $temp[$hold-2] = $temp[$hold-2] * $temp[$hold-1]; break; case '/': if($temp[$hold-1] == 0) { throw new Exception("Division by 0 on: '{$temp[$hold-2]} / {$temp[$hold-1]}' in {$this->inFix}", NF_EOS_Parser::E_DIV_ZERO); } $temp[$hold-2] = $temp[$hold-2] / $temp[$hold-1]; break; case '^': $temp[$hold-2] = pow($temp[$hold-2], $temp[$hold-1]); break; case '!': $temp[$hold-1] = $this->factorial($temp[$hold-1]); $hold++; break; case '%': if($temp[$hold-1] == 0) { throw new Exception("Division by 0 on: '{$temp[$hold-2]} % {$temp[$hold-1]}' in {$this->inFix}", NF_EOS_Parser::E_DIV_ZERO); } $temp[$hold-2] = bcmod($temp[$hold-2], $temp[$hold-1]); break; } // Decrease the hold var to one above where the last number is $hold = $hold-1; } } // return the last number in the array return $temp[$hold-1]; } //end function solvePF public function solve($equation, $values = null) { if(is_array($equation)) { return $this->solvePF($equation); } else { return $this->solveIF($equation, $values); } } /** * Solve Infix (Standard) Notation Equation * * Will take a standard equation with optional variables and solve it. Variables * must begin with '&' or '$' * The variable array must be in the format of 'variable' => value. If * variable array is scalar (ie 5), all variables will be replaced with it. * * @param String $infix Standard Equation to solve * @param String|Array $vArray Variable replacement * @throws Exception On division by zero and on NaN and lack of variable replacement. * @return Float Solved equation */ function solveIF($infix, $vArray = null) { $infix = ($infix != "") ? $infix : $this->inFix; //Check to make sure a 'valid' expression $this->checkInfix($infix); //$ops = new Stack(); //$vars = new Stack(); $hand = null; //remove all white-space $infix = preg_replace("/\s/", "", $infix); if(NF_EOS_Parser::$debug) { $hand=fopen("eq.txt","a"); } //replace scientific notation with normal notation (2e-9 to 2*10^-9) $infix = preg_replace('/([\d])([eE])(-?\d)/', '$1*10^$3', $infix); if(NF_EOS_Parser::$debug) { fwrite($hand, "$infix\n"); } // Finds all the 'functions' within the equation and calculates them // NOTE - when using function, only 1 set of parenthesis will be found, instead use brackets for sets within functions!! //while((preg_match("/(". implode("|", $this->FNC) . ")\(([^\)\(]*(\([^\)]*\)[^\(\)]*)*[^\)\(]*)\)/", $infix, $match)) != 0) { //Nested parenthesis are now a go! while((preg_match("/(". implode("|", $this->FNC) . ")\(((?:[^()]|\((?2)\))*+)\)/", $infix, $match)) != 0) { $func = $this->solveIF($match[2], $vArray); switch($match[1]) { case "cos": $ans = cos($func); break; case "sin": $ans = sin($func); break; case "tan": $ans = tan($func); break; case "sec": $tmp = cos($func); if($tmp == 0) { throw new Exception("Division by 0 on: 'sec({$func}) = 1/cos({$func})' in {$this->inFix}", NF_EOS_Parser::E_DIV_ZERO); } $ans = 1/$tmp; break; case "csc": $tmp = sin($func); if($tmp == 0) { throw new Exception("Division by 0 on: 'csc({$func}) = 1/sin({$func})' in {$this->inFix}", NF_EOS_Parser::E_DIV_ZERO); } $ans = 1/$tmp; break; case "cot": $tmp = tan($func); if($tmp == 0) { throw new Exception("Division by 0 on: 'cot({$func}) = 1/tan({$func})' in {$this->inFix}", NF_EOS_Parser::E_DIV_ZERO); } $ans = 1/$tmp; break; case "abs": $ans = abs($func); break; case "log": $ans = log($func); if(is_nan($ans) || is_infinite($ans)) { throw new Exception("Result of 'log({$func}) = {$ans}' is either infinite or a non-number in {$this->inFix}", NF_EOS_Parser::E_NAN); } break; case "log10": $ans = log10($func); if(is_nan($ans) || is_infinite($ans)) { throw new Exception("Result of 'log10({$func}) = {$ans}' is either infinite or a non-number in {$this->inFix}", NF_EOS_Parser::E_NAN); } break; case "sqrt": if($func < 0) { throw new Exception("Result of 'sqrt({$func}) = i. We can't handle imaginary numbers", NF_EOS_Parser::E_NAN); } $ans = sqrt($func); break; default: $ans = 0; break; } $infix = str_replace($match[0], "({$ans})", $infix); } $infix = preg_replace('/[$&]/', "", $infix); //Find all the variables that were passed and replaces them while((preg_match('/([^a-zA-Z]){0,1}([a-zA-Z]+)([^a-zA-Z]){0,1}/', $infix, $match)) != 0) { //remove notices by defining if undefined. if(!isset($match[3])) { $match[3] = ""; } if(NF_EOS_Parser::$debug) fwrite($hand, "{$match[1]} || {$match[3]}\n"); // Ensure that the variable has an operator or something of that sort in front and back - if it doesn't, add an implied '*' if((!in_array($match[1], array_merge($this->ST, $this->ST1, $this->ST2, $this->SEP['open'])) && $match[1] != "") || is_numeric($match[1])) //$this->SEP['close'] removed $front = "*"; else $front = ""; if((!in_array($match[3], array_merge($this->ST, $this->ST1, $this->ST2, $this->SEP['close'])) && $match[3] != "") || is_numeric($match[3])) //$this->SEP['open'] removed $back = "*"; else $back = ""; //Make sure that the variable does have a replacement //First check for pi and e variables that wll automagically be replaced if(in_array(strtolower($match[2]), array('pi', 'e'))) { $t = (strtolower($match[2])=='pi') ? pi() : exp(1); $infix = str_replace($match[0], $match[1] . $front. $t. $back . $match[3], $infix); } elseif(!isset($vArray[$match[2]]) && (!is_array($vArray != "") && !is_numeric($vArray) && 0 !== $vArray)) { throw new Exception("Variable replacement does not exist for '". substr($match[0], 1, 1). $match[2] ."' in {$this->inFix}", NF_EOS_Parser::E_NO_VAR); } elseif(!isset($vArray[$match[2]]) && (!is_array($vArray != "") && is_numeric($vArray))) { $infix = str_replace($match[0], $match[1] . $front. $vArray. $back . $match[3], $infix); } elseif(isset($vArray[$match[2]])) { $infix = str_replace($match[0], $match[1] . $front. $vArray[$match[2]]. $back . $match[3], $infix); } } if(NF_EOS_Parser::$debug) fclose($hand); return $this->solvePF($this->in2post($infix)); } //end function solveIF /** * Solve factorial (!) * * Will take any real positive number and solve for it's factorial. Eg. * `5!` will become `1*2*3*4*5` = `120` For integers * and * 5.2! will become gamma(6.2) for non-integers * DONE: * Solve for non-integer factorials 2015/07/02 * * @param Float $num Non-negative real number to get factorial of * @throws Exception if number is at or less than 0 * @return Float Solved factorial */ protected function factorial($num) { if($num < 0) { throw new Exception("Factorial Error: Factorials don't exist for numbers < 0", NF_EOS_Parser::E_NAN); } //A non-integer! Gamma that sucker up! if(intval($num) != $num) { return $this->gamma($num + 1); } $tot = 1; for($i=1;$i<=$num;$i++) { $tot *= $i; } return $tot; } //end function factorial /** * Gamma Function * * Because we can. This function exists as a catch-all for different * numerical approx. of gamma if I decide to add any past Lanczos'. * This method is public because a function doesn't currently exist * within this parser to use it. That will change in the future. * * @param $z Number to compute gamma from * @return Float The gamma (hopefully, I'll test it after writing the code) */ public function gamma($z) { return $this->laGamma($z); } /** * Lanczos Approximation * * The Lanczos Approximation method of finding gamma values * * @link http://www.rskey.org/CMS/index.php/the-library/11 * @link http://algolist.manual.ru/maths/count_fast/gamma_function.php * @link https://en.wikipedia.org/wiki/Lanczos_approximation * @param float $z Number to obtain the gamma of * @return float Gamma of inputted number * @throws Exception if Number is less than or equal to 0 */ protected function laGamma($z) { //check validity of $z, throw error if not a valid number to be used with gamma if($z <= 0) { throw new Exception("Gamma cannot be calculated on numbers less than or equal to 0", NF_EOS_Parser::E_NAN); } // Set up coefficients $p = array( 0 => 1.000000000190015, 1 => 76.18009172947146, 2 => -86.50532032941677, 3 => 24.01409824083091, 4 => -1.231739572450155, 5 => 1.208650973866179E-3, 6 => -5.395239384953E-6 ); //formula: // ((sqrt(2pi)/z)(p[0]+sum(p[n]/(z+n), 1, 6)))(z+5.5)^(z+0.5)*e^(-(z+5.5)) // Break it down now... $g1 = sqrt(2*pi())/$z; //Next comes our summation $g2 =0; for($n=1;$n<=6;$n++) { $g2 += $p[$n]/($z+$n); } // Don't forget to add p[0] to it... $g2 += $p[0]; $g3 = pow($z+5.5, $z + .5); $g4 = exp(-($z+5.5)); //now just multiply them all together $gamma = $g1 * $g2 * $g3 * $g4; return $gamma; } } //end class 'Parser'