eqEOS

Equation Operating System (EOS) Parser.

Defined (1)

The class is defined in the following location(s).

/deprecated/includes/eos.class.php  
  1. class eqEOS { 
  2.     /**#@+ 
  3.      *Private variables 
  4.      */ 
  5.     private $postFix; 
  6.     private $inFix; 
  7.     /**#@-*/ 
  8.     /**#@+ 
  9.      * Protected variables 
  10.      */ 
  11.     //What are opening and closing selectors 
  12.     protected $SEP = array('open' => array('(', '['), 'close' => array(')', ']')); 
  13.     //Top presedence following operator - not in use 
  14.     protected $SGL = array('!'); 
  15.     //Order of operations arrays follow 
  16.     protected $ST = array('^'); 
  17.     protected $ST1 = array('/', '*', '%'); 
  18.     protected $ST2 = array('+', '-'); 
  19.     //Allowed functions 
  20.     protected $FNC = array('sin', 'cos', 'tan', 'csc', 'sec', 'cot'); 
  21.     /**#@-*/ 
  22.     /** 
  23.      * Construct method 
  24.      * 
  25.      * Will initiate the class.  If variable given, will assign to 
  26.      * internal variable to solve with this::solveIF() without needing 
  27.      * additional input.  Initializing with a variable is not suggested. 
  28.      * 
  29.      * @see eqEOS::solveIF() 
  30.      * @param String $inFix Standard format equation 
  31.      */ 
  32.     public function __construct($inFix = null) { 
  33.         $this->inFix = (isset($inFix)) ? $inFix : null; 
  34.         $this->postFix = array(); 
  35.     } 
  36.      
  37.     /** 
  38.      * Check Infix for opening closing pair matches. 
  39.      * 
  40.      * This function is meant to solely check to make sure every opening 
  41.      * statement has a matching closing one, and throws an exception if 
  42.      * it doesn't. 
  43.      * 
  44.      * @param String $infix Equation to check 
  45.      * @throws Exception if malformed. 
  46.      * @return Bool true if passes - throws an exception if not. 
  47.      */ 
  48.     private function checkInfix($infix) { 
  49.         if(trim($infix) == "") { 
  50.             throw new Exception("No Equation given", EQEOS_E_NO_EQ); 
  51.             return false; 
  52.         } 
  53.         //Make sure we have the same number of '(' as we do ')' 
  54.         // and the same # of '[' as we do ']' 
  55.         if(substr_count($infix, '(') != substr_count($infix, ')')) { 
  56.             throw new Exception("Mismatched parenthesis in '{$infix}'", EQEOS_E_NO_SET); 
  57.             return false; 
  58.         } elseif(substr_count($infix, '[') != substr_count($infix, ']')) { 
  59.             throw new Exception("Mismatched brackets in '{$infix}'", EQEOS_E_NO_SET); 
  60.             return false; 
  61.         } 
  62.         $this->inFix = $infix; 
  63.         return true; 
  64.     } 
  65.  
  66.     /** 
  67.      * Infix to Postfix 
  68.      * 
  69.      * Converts an infix (standard) equation to postfix (RPN) notation. 
  70.      * Sets the internal variable $this->postFix for the eqEOS::solvePF() 
  71.      * function to use. 
  72.      * 
  73.      * @link http://en.wikipedia.org/wiki/Infix_notation Infix Notation 
  74.      * @link http://en.wikipedia.org/wiki/Reverse_Polish_notation Reverse Polish Notation 
  75.      * @param String $infix A standard notation equation 
  76.      * @return Array Fully formed RPN Stack 
  77.      */ 
  78.     public function in2post($infix = null) { 
  79.         // if an equation was not passed, use the one that was passed in the constructor 
  80.         $infix = (isset($infix)) ? $infix : $this->inFix; 
  81.          
  82.         //check to make sure 'valid' equation 
  83.         $this->checkInfix($infix); 
  84.         $pf = array(); 
  85.         $ops = new phpStack(); 
  86.         $vars = new phpStack(); 
  87.  
  88.         // remove all white-space 
  89.         preg_replace("/\s/", "", $infix); 
  90.  
  91.         // Create postfix array index 
  92.         $pfIndex = 0; 
  93.  
  94.         //what was the last character? (useful for decerning between a sign for negation and subtraction) 
  95.         $lChar = ''; 
  96.  
  97.         //loop through all the characters and start doing stuff ^^ 
  98.         for($i=0;$i<strlen($infix);$i++) { 
  99.             // pull out 1 character from the string 
  100.             $chr = substr($infix, $i, 1); 
  101.              
  102.             // if the character is numerical 
  103.             if(preg_match('/[0-9.]/i', $chr)) { 
  104.                 // if the previous character was not a '-' or a number 
  105.                 if((!preg_match('/[0-9.]/i', $lChar) && ($lChar != "")) && (@$pf[$pfIndex]!="-")) 
  106.                     $pfIndex++;    // increase the index so as not to overlap anything 
  107.                 // Add the number character to the array 
  108.                 @$pf[$pfIndex] .= $chr; 
  109.             } 
  110.             // If the character opens a set e.g. '(' or '[' 
  111.             elseif(in_array($chr, $this->SEP['open'])) { 
  112.                 // if the last character was a number, place an assumed '*' on the stack 
  113.                 if(preg_match('/[0-9.]/i', $lChar)) 
  114.                     $ops->push('*'); 
  115.  
  116.                 $ops->push($chr); 
  117.             } 
  118.             // if the character closes a set e.g. ')' or ']' 
  119.             elseif(in_array($chr, $this->SEP['close'])) { 
  120.                 // find what set it was i.e. matches ')' with '(' or ']' with '[' 
  121.                 $key = array_search($chr, $this->SEP['close']); 
  122.                 // while the operator on the stack isn't the matching pair...pop it off 
  123.                 while($ops->peek() != $this->SEP['open'][$key]) { 
  124.                     $nchr = $ops->pop(); 
  125.                     if($nchr) 
  126.                         $pf[++$pfIndex] = $nchr; 
  127.                     else { 
  128.                         throw new Exception("Error while searching for '". $this->SEP['open'][$key] ."' in '{$infix}'.", EQEOS_E_NO_SET); 
  129.                         return false; 
  130.                     } 
  131.                 } 
  132.                 $ops->pop(); 
  133.             } 
  134.             // If a special operator that has precedence over everything else 
  135.             elseif(in_array($chr, $this->ST)) { 
  136.                 $ops->push($chr); 
  137.                 $pfIndex++; 
  138.             } 
  139.             // Any other operator other than '+' and '-' 
  140.             elseif(in_array($chr, $this->ST1)) { 
  141.                 while(in_array($ops->peek(), $this->ST1) || in_array($ops->peek(), $this->ST)) 
  142.                     $pf[++$pfIndex] = $ops->pop(); 
  143.  
  144.                 $ops->push($chr); 
  145.                 $pfIndex++; 
  146.             } 
  147.             // if a '+' or '-' 
  148.             elseif(in_array($chr, $this->ST2)) { 
  149.                 // if it is a '-' and the character before it was an operator or nothingness (e.g. it negates a number) 
  150.                 if((in_array($lChar, array_merge($this->ST1, $this->ST2, $this->ST, $this->SEP['open'])) || $lChar=="") && $chr=="-") { 
  151.                     // increase the index because there is no reason that it shouldn't.. 
  152.                     $pfIndex++; 
  153.                     $pf[$pfIndex] = $chr;  
  154.                 } 
  155.                 // Otherwise it will function like a normal operator 
  156.                 else { 
  157.                     while(in_array($ops->peek(), array_merge($this->ST1, $this->ST2, $this->ST))) 
  158.                         $pf[++$pfIndex] = $ops->pop(); 
  159.                     $ops->push($chr); 
  160.                     $pfIndex++; 
  161.                 } 
  162.             } 
  163.             // make sure we record this character to be refered to by the next one 
  164.             $lChar = $chr; 
  165.         } 
  166.         // if there is anything on the stack after we are done...add it to the back of the RPN array 
  167.         while(($tmp = $ops->pop()) !== false) 
  168.             $pf[++$pfIndex] = $tmp; 
  169.  
  170.         // re-index the array at 0 
  171.         $pf = array_values($pf); 
  172.          
  173.         // set the private variable for later use if needed 
  174.         $this->postFix = $pf; 
  175.  
  176.         // return the RPN array in case developer wants to use it fro some insane reason (bug testing ;] 
  177.         return $pf; 
  178.     } //end function in2post 
  179.  
  180.     /** 
  181.      * Solve Postfix (RPN) 
  182.      *  
  183.      * This function will solve a RPN array. Default action is to solve 
  184.      * the RPN array stored in the class from eqEOS::in2post(), can take 
  185.      * an array input to solve as well, though default action is prefered. 
  186.      * 
  187.      * @link http://en.wikipedia.org/wiki/Reverse_Polish_notation Postix Notation 
  188.      * @param Array $pfArray RPN formatted array. Optional. 
  189.          * @return Float Result of the operation. 
  190.      */ 
  191.     public function solvePF($pfArray = null) { 
  192.         // if no RPN array is passed - use the one stored in the private var 
  193.         $pf = (!is_array($pfArray)) ? $this->postFix : $pfArray; 
  194.          
  195.         // create our temporary function variables 
  196.         $temp = array(); 
  197.         $tot = 0; 
  198.         $hold = 0; 
  199.  
  200.         // Loop through each number/operator  
  201.         for($i=0;$i<count($pf); $i++) { 
  202.             // If the string isn't an operator, add it to the temp var as a holding place 
  203.             if(!in_array($pf[$i], array_merge($this->ST, $this->ST1, $this->ST2))) { 
  204.                 $temp[$hold++] = $pf[$i]; 
  205.             } 
  206.             // ...Otherwise perform the operator on the last two numbers  
  207.             else { 
  208.                 switch ($pf[$i]) { 
  209.                     case '+': 
  210.                         @$temp[$hold-2] = $temp[$hold-2] + $temp[$hold-1]; 
  211.                         break; 
  212.                     case '-': 
  213.                         @$temp[$hold-2] = $temp[$hold-2] - $temp[$hold-1]; 
  214.                         break; 
  215.                     case '*': 
  216.                         @$temp[$hold-2] = $temp[$hold-2] * $temp[$hold-1]; 
  217.                         break; 
  218.                     case '/': 
  219.                         if($temp[$hold-1] == 0) { 
  220.                             throw new Exception("Division by 0 on: '{$temp[$hold-2]} / {$temp[$hold-1]}' in {$this->inFix}", EQEOS_E_DIV_ZERO); 
  221.                             return false; 
  222.                         } 
  223.                         @$temp[$hold-2] = $temp[$hold-2] / $temp[$hold-1]; 
  224.                         break; 
  225.                     case '^': 
  226.                         @$temp[$hold-2] = pow($temp[$hold-2], $temp[$hold-1]); 
  227.                         break; 
  228.                     case '%': 
  229.                         if($temp[$hold-1] == 0) { 
  230.                             throw new Exception("Division by 0 on: '{$temp[$hold-2]} % {$temp[$hold-1]}' in {$this->inFix}", EQEOS_E_DIV_ZERO); 
  231.                             return false; 
  232.                         } 
  233.                         @$temp[$hold-2] = bcmod($temp[$hold-2], $temp[$hold-1]); 
  234.                         break; 
  235.                 } 
  236.                 // Decrease the hold var to one above where the last number is  
  237.                 $hold = $hold-1; 
  238.             } 
  239.         } 
  240.         // return the last number in the array  
  241.         return $temp[$hold-1]; 
  242.  
  243.     } //end function solvePF 
  244.  
  245.  
  246.     /** 
  247.      * Solve Infix (Standard) Notation Equation 
  248.      * 
  249.      * Will take a standard equation with optional variables and solve it. Variables 
  250.      * must begin with '&' will expand to allow variables to begin with '$' (TODO) 
  251.      * The variable array must be in the format of 'variable' => value. If 
  252.      * variable array is scalar (ie 5), all variables will be replaced with it. 
  253.      * 
  254.      * @param String $infix Standard Equation to solve 
  255.      * @param String|Array $vArray Variable replacement 
  256.      * @return Float Solved equation 
  257.      */ 
  258.     function solveIF($infix, $vArray = null) { 
  259.         $infix = ($infix != "") ? $infix : $this->inFix; 
  260.          
  261.         //Check to make sure a 'valid' expression 
  262.         $this->checkInfix($infix); 
  263.  
  264.         $ops = new phpStack(); 
  265.         $vars = new phpStack(); 
  266.  
  267.         //remove all white-space 
  268.         preg_replace("/\s/", "", $infix); 
  269.         if(DEBUG) 
  270.             $hand=fopen("eq.txt", "a"); 
  271.  
  272.         //Find all the variables that were passed and replaces them 
  273.         while((preg_match('/(.) {0, 1}[&$]([a-zA-Z]+)(.) {0, 1}/', $infix, $match)) != 0) { 
  274.  
  275.             //remove notices by defining if undefined. 
  276.             if(!isset($match[3])) { 
  277.                 $match[3] = ""; 
  278.             } 
  279.  
  280.             if(DEBUG) 
  281.                 fwrite($hand, "{$match[1]} || {$match[3]}\n"); 
  282.             // Ensure that the variable has an operator or something of that sort in front and back - if it doesn't, add an implied '*' 
  283.             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 
  284.                 $front = "*"; 
  285.             else 
  286.                 $front = ""; 
  287.  
  288.             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 
  289.                 $back = "*"; 
  290.             else 
  291.                 $back = ""; 
  292.              
  293.             //Make sure that the variable does have a replacement 
  294.             if(!isset($vArray[$match[2]]) && (!is_array($vArray != "") && !is_numeric($vArray))) { 
  295.                 throw new Exception("Variable replacement does not exist for '". substr($match[0], 1, -1) ."' in {$this->inFix}", EQEOS_E_NO_VAR); 
  296.                 return false; 
  297.             } elseif(!isset($vArray[$match[2]]) && (!is_array($vArray != "") && is_numeric($vArray))) { 
  298.                 $infix = str_replace($match[0], $match[1] . $front. $vArray. $back . $match[3], $infix); 
  299.             } elseif(isset($vArray[$match[2]])) { 
  300.                 $infix = str_replace($match[0], $match[1] . $front. $vArray[$match[2]]. $back . $match[3], $infix); 
  301.             } 
  302.         } 
  303.  
  304.         if(DEBUG) 
  305.             fwrite($hand, "$infix\n"); 
  306.  
  307.         // Finds all the 'functions' within the equation and calculates them  
  308.         // NOTE - when using function, only 1 set of paranthesis will be found, instead use brackets for sets within functions!!  
  309.         while((preg_match("/(". implode("|", $this->FNC) . ")\(([^\)\(]*(\([^\)]*\)[^\(\)]*)*[^\)\(]*)\)/", $infix, $match)) != 0) { 
  310.             $func = $this->solveIF($match[2]); 
  311.             switch($match[1]) { 
  312.                 case "cos": 
  313.                     $ans = cos($func); 
  314.                     break; 
  315.                 case "sin": 
  316.                     $ans = sin($func); 
  317.                     break; 
  318.                 case "tan": 
  319.                     $ans = tan($func); 
  320.                     break; 
  321.                 case "sec": 
  322.                     $tmp = cos($func); 
  323.                     if($tmp == 0) { 
  324.                         throw new Exception("Division by 0 on: 'sec({$func}) = 1/cos({$func})' in {$this->inFix}", EQEOS_E_DIV_ZERO); 
  325.                         return false; 
  326.                     } 
  327.                     $ans = 1/$tmp; 
  328.                     break; 
  329.                 case "csc": 
  330.                     $tmp = sin($func); 
  331.                     if($tmp == 0) { 
  332.                         throw new Exception("Division by 0 on: 'csc({$func}) = 1/sin({$func})' in {$this->inFix}", EQEOS_E_DIV_ZERO); 
  333.                         return false; 
  334.                     } 
  335.                     $ans = 1/$tmp; 
  336.                     break; 
  337.                 case "cot": 
  338.                     $tmp = tan($func); 
  339.                     if($tmp == 0) { 
  340.                         throw new Exception("Division by 0 on: 'cot({$func}) = 1/tan({$func})' in {$this->inFix}", EQEOS_E_DIV_ZERO); 
  341.                         return false; 
  342.                     } 
  343.                     $ans = 1/$tmp; 
  344.                     break; 
  345.                 default: 
  346.                     break; 
  347.             } 
  348.             $infix = str_replace($match[0], $ans, $infix); 
  349.         } 
  350.         if(DEBUG) 
  351.             fclose($hand); 
  352.         return $this->solvePF($this->in2post($infix)); 
  353.  
  354.  
  355.     } //end function solveIF 
  356. } //end class 'eqEOS'