From 69edce189ee6e1a648e0e050557899cb28795ff1 Mon Sep 17 00:00:00 2001
From: Shobhit Srivastava <shobhit@yugasasoftware.com>
Date: Wed, 31 May 2017 12:30:45 +0530
Subject: [PATCH 1/2] Issue issue-79-Fixed-Min-Max by username: Fixed all
 instances of foo bug.

---
 CHANGELOG.txt                    |   0
 README.txt                       |   0
 includes/mathfield.math_expr.inc | 209 +++++++++++++++++++++++++++++++++++++++
 js/mathfield.js                  |   0
 mathfield.api.php                |   0
 mathfield.info                   |   0
 mathfield.install                |   0
 mathfield.module                 |   0
 mathfield.test                   |   0
 9 files changed, 209 insertions(+)
 mode change 100644 => 100755 CHANGELOG.txt
 mode change 100644 => 100755 README.txt
 mode change 100644 => 100755 includes/mathfield.math_expr.inc
 mode change 100644 => 100755 js/mathfield.js
 mode change 100644 => 100755 mathfield.api.php
 mode change 100644 => 100755 mathfield.info
 mode change 100644 => 100755 mathfield.install
 mode change 100644 => 100755 mathfield.module
 mode change 100644 => 100755 mathfield.test

diff --git a/CHANGELOG.txt b/CHANGELOG.txt
old mode 100644
new mode 100755
diff --git a/README.txt b/README.txt
old mode 100644
new mode 100755
diff --git a/includes/mathfield.math_expr.inc b/includes/mathfield.math_expr.inc
old mode 100644
new mode 100755
index c0d0482..7567c85
--- a/includes/mathfield.math_expr.inc
+++ b/includes/mathfield.math_expr.inc
@@ -24,6 +24,215 @@ class MathfieldMathExpr extends ctools_math_expr {
     return FALSE;
   }
 
+    function nfx($expr) {
+
+        $index = 0;
+        $stack = new ctools_math_expr_stack;
+        $output = array(); // postfix form of expression, to be passed to pfx()
+        $expr = trim(strtolower($expr));
+
+        $ops   = array('+', '-', '*', '/', '^', '_');
+        $ops_r = array('+'=>0,'-'=>0,'*'=>0,'/'=>0,'^'=>1); // right-associative operator?
+        $ops_p = array('+'=>0,'-'=>0,'*'=>1,'/'=>1,'_'=>1,'^'=>2); // operator precedence
+
+        $expecting_op = false; // we use this in syntax-checking the expression
+                               // and determining when a - is a negation
+
+        if (preg_match("/[^\w\s+*^\/()\.,-]/", $expr, $matches)) { // make sure the characters are all good
+            return $this->trigger("illegal character '{$matches[0]}'");
+        }
+
+        while(1) { // 1 Infinite Loop ;)
+            $op = substr($expr, $index, 1); // get the first character at the current index
+            // find out if we're currently at the beginning of a number/variable/function/parenthesis/operand
+            $ex = preg_match('/^([a-z]\w*\(?|\d+(?:\.\d*)?|\.\d+|\()/', substr($expr, $index), $match);
+            //===============
+            if ($op == '-' and !$expecting_op) { // is it a negation instead of a minus?
+                $stack->push('_'); // put a negation on the stack
+                $index++;
+            } elseif ($op == '_') { // we have to explicitly deny this, because it's legal on the stack
+                return $this->trigger("illegal character '_'"); // but not in the input expression
+            //===============
+            } elseif ((in_array($op, $ops) or $ex) and $expecting_op) { // are we putting an operator on the stack?
+                if ($ex) { // are we expecting an operator but have a number/variable/function/opening parethesis?
+                    $op = '*'; $index--; // it's an implicit multiplication
+                }
+                // heart of the algorithm:
+                while($stack->count > 0 and ($o2 = $stack->last()) and in_array($o2, $ops) and ($ops_r[$op] ? $ops_p[$op] < $ops_p[$o2] : $ops_p[$op] <= $ops_p[$o2])) {
+                    $output[] = $stack->pop(); // pop stuff off the stack into the output
+                }
+                // many thanks: http://en.wikipedia.org/wiki/Reverse_Polish_notation#The_algorithm_in_detail
+                $stack->push($op); // finally put OUR operator onto the stack
+                $index++;
+                $expecting_op = false;
+            //===============
+            } elseif ($op == ')' and $expecting_op) { // ready to close a parenthesis?
+                while (($o2 = $stack->pop()) != '(') { // pop off the stack back to the last (
+                    if (is_null($o2)) return $this->trigger("unexpected ')'");
+                    else $output[] = $o2;
+                }
+                if (preg_match("/^([a-z]\w*)\($/", $stack->last(2), $matches)) { // did we just close a function?
+                  /*  $fnn = $matches[1]; // get the function name
+                    $arg_count = $stack->pop(); // see how many arguments there were (cleverly stored on the stack, thank you)
+                    $output[] = $stack->pop(); // pop the function and push onto the output
+                    if (in_array($fnn, $this->fb)) { // check the argument count
+                        if($arg_count > 1)
+                            return $this->trigger("too many arguments ($arg_count given, 1 expected)");
+                    } elseif (array_key_exists($fnn, $this->f)) {
+                        if ($arg_count != count($this->f[$fnn]['args']))
+                            return $this->trigger("wrong number of arguments ($arg_count given, " . count($this->f[$fnn]['args']) . " expected)");
+                    } else { // did we somehow push a non-function on the stack? this should never happen */
+                    $fnn = $matches[1]; // get the function name
+                 $arg_count = $stack->pop(); // see how many arguments there were (cleverly stored on the stack, thank you)
+                 $output[] = $stack->pop(); // pop the function and push onto the output
+               if (!in_array($fnn, $this->fb)){
+                   if (array_key_exists($fnn, $this->f)) {
+                     if ($arg_count != count($this->f[$fnn]['args']))
+                        return $this->trigger("wrong number of arguments ($arg_count given, " . count($this->f[$fnn]['args']) . " expected)");
+                    }
+                      else {
+                        return $this->trigger("internal error");
+                    }
+                    }
+
+                }
+                $index++;
+            //===============
+            } elseif ($op == ',' and $expecting_op) { // did we just finish a function argument?
+                while (($o2 = $stack->pop()) != '(') {
+                    if (is_null($o2)) return $this->trigger("unexpected ','"); // oops, never had a (
+                    else $output[] = $o2; // pop the argument expression stuff and push onto the output
+                }
+                // make sure there was a function
+                if (!preg_match("/^([a-z]\w*)\($/", $stack->last(2), $matches))
+                    return $this->trigger("unexpected ','");
+                $stack->push($stack->pop()+1); // increment the argument count
+                $stack->push('('); // put the ( back on, we'll need to pop back to it again
+                $index++;
+                $expecting_op = false;
+            //===============
+            } elseif ($op == '(' and !$expecting_op) {
+                $stack->push('('); // that was easy
+                $index++;
+                $allow_neg = true;
+            //===============
+            } elseif ($ex and !$expecting_op) { // do we now have a function/variable/number?
+                $expecting_op = true;
+                $val = $match[1];
+                if (preg_match("/^([a-z]\w*)\($/", $val, $matches)) { // may be func, or variable w/ implicit multiplication against parentheses...
+                    if (in_array($matches[1], $this->fb) or array_key_exists($matches[1], $this->f)) { // it's a func
+                        $stack->push($val);
+                        $stack->push(1);
+                        $stack->push('(');
+                        $expecting_op = false;
+                    } else { // it's a var w/ implicit multiplication
+                        $val = $matches[1];
+                        $output[] = $val;
+                    }
+                } else { // it's a plain old var or num
+                    $output[] = $val;
+                }
+                $index += strlen($val);
+            //===============
+            } elseif ($op == ')') { // miscellaneous error checking
+                return $this->trigger("unexpected ')'");
+            } elseif (in_array($op, $ops) and !$expecting_op) {
+                return $this->trigger("unexpected operator '$op'");
+            } else { // I don't even want to know what you did to get here
+                return $this->trigger("an unexpected error occurred");
+            }
+            if ($index == strlen($expr)) {
+                if (in_array($op, $ops)) { // did we end with an operator? bad.
+                    return $this->trigger("operator '$op' lacks operand");
+                } else {
+                    break;
+                }
+            }
+            while (substr($expr, $index, 1) == ' ') { // step the index past whitespace (pretty much turns whitespace
+                $index++;                             // into implicit multiplication if no operator is there)
+            }
+
+        }
+        while (!is_null($op = $stack->pop())) { // pop everything off the stack and push onto output
+            if ($op == '(') return $this->trigger("expecting ')'"); // if there are (s on the stack, ()s were unbalanced
+            $output[] = $op;
+        }
+        return $output;
+    }
+
+    // evaluate postfix notation
+    function pfx($tokens, $vars = array()) {
+
+        if ($tokens == false) return false;
+
+        $stack = new ctools_math_expr_stack;
+
+        foreach ($tokens as $token) { // nice and easy
+            // if the token is a binary operator, pop two values off the stack, do the operation, and push the result back on
+            if (in_array($token, array('+', '-', '*', '/', '^'))) {
+                if (is_null($op2 = $stack->pop())) return $this->trigger("internal error");
+                if (is_null($op1 = $stack->pop())) return $this->trigger("internal error");
+                switch ($token) {
+                    case '+':
+                        $stack->push($op1+$op2); break;
+                    case '-':
+                        $stack->push($op1-$op2); break;
+                    case '*':
+                        $stack->push($op1*$op2); break;
+                    case '/':
+                        if ($op2 == 0) return $this->trigger("division by zero");
+                        $stack->push($op1/$op2); break;
+                    case '^':
+                        $stack->push(pow($op1, $op2)); break;
+                }
+            // if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
+            } elseif ($token == "_") {
+                $stack->push(-1*$stack->pop());
+            // if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
+            } elseif (preg_match("/^([a-z]\w*)\($/", $token, $matches)) { // it's a function!
+                $fnn = $matches[1];
+                if (in_array($fnn, $this->fb)) { // built-in function:
+                   /* if (is_null($op1 = $stack->pop())) return $this->trigger("internal error");
+                    $fnn = preg_replace("/^arc/", "a", $fnn); // for the 'arc' trig synonyms
+                    if ($fnn == 'ln') $fnn = 'log';
+                    eval('$stack->push(' . $fnn . '($op1));'); // perfectly safe eval()*/
+                     if ($stack->count>1){//Support more than 2 arguments
+                   //Pop all elements to build op1
+                   $op1 = implode(',', array_slice($stack->stack, 0, $stack->count));
+                      $stack->count = 0;//Reset counter/Empty stack
+                 }
+                  elseif (is_null($op1 = $stack->pop())) {
+                   return $this->trigger("internal error");
+                 }
+                  $fnn = preg_replace("/^arc/", "a", $fnn); // for the 'arc' trig synonyms
+                 if ($fnn == 'ln') $fnn = 'log';
+                  eval('$stack->push(' . $fnn . '('.$op1.'));'); // perfectly safe eval()
+                } elseif (array_key_exists($fnn, $this->f)) { // user function
+                    // get args
+                    $args = array();
+                    for ($i = count($this->f[$fnn]['args'])-1; $i >= 0; $i--) {
+                        if (is_null($args[$this->f[$fnn]['args'][$i]] = $stack->pop())) return $this->trigger("internal error");
+                    }
+                    $stack->push($this->pfx($this->f[$fnn]['func'], $args)); // yay... recursion!!!!
+                }
+            // if the token is a number or variable, push it on the stack
+            } else {
+                if (is_numeric($token)) {
+                    $stack->push($token);
+                } elseif (array_key_exists($token, $this->v)) {
+                    $stack->push($this->v[$token]);
+                } elseif (array_key_exists($token, $vars)) {
+                    $stack->push($vars[$token]);
+                } else {
+                    return $this->trigger("undefined variable '$token'");
+                }
+            }
+        }
+        // when we're out of tokens, the stack should have a single element, the final result
+        if ($stack->count != 1) return $this->trigger("internal error");
+        return $stack->pop();
+    }
+
 }
 
 /**
diff --git a/js/mathfield.js b/js/mathfield.js
old mode 100644
new mode 100755
diff --git a/mathfield.api.php b/mathfield.api.php
old mode 100644
new mode 100755
diff --git a/mathfield.info b/mathfield.info
old mode 100644
new mode 100755
diff --git a/mathfield.install b/mathfield.install
old mode 100644
new mode 100755
diff --git a/mathfield.module b/mathfield.module
old mode 100644
new mode 100755
diff --git a/mathfield.test b/mathfield.test
old mode 100644
new mode 100755
-- 
1.9.1


From af1f6d4414273cae699bf5ecdce0470418c0500f Mon Sep 17 00:00:00 2001
From: Shobhit Srivastava <shobhit@yugasasoftware.com>
Date: Wed, 31 May 2017 12:33:29 +0530
Subject: [PATCH 2/2] Issue issue-79-Fixed-Min-Max by username: Shobhit
 Srivastav.

---
 includes/mathfield.math_expr.inc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/includes/mathfield.math_expr.inc b/includes/mathfield.math_expr.inc
index 7567c85..8c17ea7 100755
--- a/includes/mathfield.math_expr.inc
+++ b/includes/mathfield.math_expr.inc
@@ -232,7 +232,6 @@ class MathfieldMathExpr extends ctools_math_expr {
         if ($stack->count != 1) return $this->trigger("internal error");
         return $stack->pop();
     }
-
 }
 
 /**
-- 
1.9.1