CODEWITHSUNDEEP
phpmath
JayGatz
JayGatz

Reputation: 271

PHP calculator not performing operations with floating point numbers

Why isn't this math expression parser and calculator in PHP performing operations on floating point operations? And how can I fix it to get it to perform operations with floating points.

By floating point operations, I mean

,

, or

Here is the code:

 <?php

 require_once 'math.php';

 $math = new Math();

 if(isset($_GET['calc'])){
     $answer = $math->calculate($_GET['calc']);
     echo $answer;
 }
 ?>
 <!Doctype HTML>
 <html lang="en">
      <head>
          <meta charset="utf-8" />
          <title>calculator</title>
  </head>
  <body>
     <form method="get">
        <input type="text" name="calc" autocomplete="off" autofocus />
     </form>
  </body>
 </html>

and here is math.php:

 <?php
 require_once 'stack.php';
 require_once 'terminalExpression.php';
 require_once 'expressions.php';

 class Math {

    protected $variables = array();

    public function calculate($string) {
        $stack = $this->parse($string);
        return $this->run($stack);
    }

    public function parse($string) {
        $tokens = $this->tokenize($string);
        $output = new Stack();
        $operators = new Stack();
        foreach ($tokens as $token) {
            $token = $this->extractVariables($token);
            $expression = TerminalExpression::factory($token);
            if ($expression->isOperator()) {
                 $this->parseOperator($expression, $output, $operators);
            } elseif ($expression->isParenthesis()) {
                $this->parseParenthesis($expression, $output, $operators);
            } else {
                $output->push($expression);
            }
        }
        while (($op = $operators->pop())) {
             if ($op->isParenthesis()) {
                 throw new RuntimeException('Mismatched Parenthesis');
             }
             $output->push($op);
         }
         return $output;
      }

     public function registerVariable($name, $value) {
        $this->variables[$name] = $value;
     }

     public function run(Stack $stack) {
        while (($operator = $stack->pop()) && $operator->isOperator()) {
             $value = $operator->operate($stack);
            if (!is_null($value)) {
                 $stack->push(TerminalExpression::factory($value));
            }
         }
         return $operator ? $operator->render() : $this->render($stack);
    }

    protected function extractVariables($token) {
        if ($token[0] == '$') {
            $key = substr($token, 1);
             return isset($this->variables[$key]) ? $this->variables[$key] : 0;
        }
         return $token;
    }

     protected function render(Stack $stack) {
        $output = '';
        while (($el = $stack->pop())) {
            $output .= $el->render();
         }
        if ($output) {
             return $output;
        }
         throw new RuntimeException('Could not render output');
     }

     protected function parseParenthesis(TerminalExpression $expression, Stack $output, Stack $operators) {
         if ($expression->isOpen()) {
             $operators->push($expression);
         } else {
              $clean = false;
              while (($end = $operators->pop())) {
                  if ($end->isParenthesis()) {
                     $clean = true;
                    break;
                  } else {
                     $output->push($end);
                 }
              }
              if (!$clean) {
            throw new RuntimeException('Mismatched Parenthesis');
        }
    }
}

protected function parseOperator(TerminalExpression $expression, Stack $output, Stack $operators) {
    $end = $operators->poke();
    if (!$end) {
        $operators->push($expression);
    } elseif ($end->isOperator()) {
        do {
            if ($expression->isLeftAssoc() && $expression->getPrecidence() <= $end->getPrecidence()) {
                $output->push($operators->pop());
            } elseif (!$expression->isLeftAssoc() && $expression->getPrecidence() < $end->getPrecidence()) {
                $output->push($operators->pop());
            } else {
                break;
            }
        } while (($end = $operators->poke()) && $end->isOperator());
        $operators->push($expression);
    } else {
        $operators->push($expression);
    }
}

protected function tokenize($string) {
    $parts = preg_split('((\d+|\+|-|\(|\)|\*|/)|\s+)', $string, null, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
    $parts = array_map('trim', $parts);
    return $parts;
}

 }
?>

stack.php is:

<?php
class Stack {

    protected $data = array();

     public function push($element) {
         $this->data[] = $element;
     }

     public function poke() {
         return end($this->data);
     }

     public function pop() {
         return array_pop($this->data);
    }

 }
?>

and terminalExpressions.php:

<?php
abstract class TerminalExpression {

protected $value = '';

public function __construct($value) {
    $this->value = $value;
}

public static function factory($value) {
    if (is_object($value) && $value instanceof TerminalExpression) {
        return $value;
    } elseif (is_numeric($value)) {
        return new Number($value);
    } elseif ($value == '+') {
        return new Addition($value);
    } elseif ($value == '-') {
        return new Subtraction($value);
    } elseif ($value == '*') {
        return new Multiplication($value);
    } elseif ($value == '/') {
        return new Division($value);
    } elseif (in_array($value, array('(', ')'))) {
        return new Parenthesis($value);
    }
    throw new Exception('Undefined Value ' . $value);
}

abstract public function operate(Stack $stack);

public function isOperator() {
    return false;
}

public function isParenthesis() {
    return false;
}

public function isNoOp() {
    return false;
}

public function render() {
    return $this->value;
}
}
?>

and lastly expressions.php:

<?php
class Parenthesis extends TerminalExpression {

protected $precidence = 6;

public function operate(Stack $stack) {
}

public function getPrecidence() {
    return $this->precidence;
}

public function isNoOp() {
    return true;
}

public function isParenthesis() {
    return true;
}

public function isOpen() {
    return $this->value == '(';
}

}

class Number extends TerminalExpression {

public function operate(Stack $stack) {
    return $this->value;
}

}

abstract class Operator extends TerminalExpression {

protected $precidence = 0;
protected $leftAssoc = true;

public function getPrecidence() {
    return $this->precidence;
}

public function isLeftAssoc() {
    return $this->leftAssoc;
}

public function isOperator() {
    return true;
}

 }

class Addition extends Operator {

protected $precidence = 4;

public function operate(Stack $stack) {
    return $stack->pop()->operate($stack) + $stack->pop()->operate($stack);
}

}

class Subtraction extends Operator {

protected $precidence = 4;

public function operate(Stack $stack) {
    $left = $stack->pop()->operate($stack);
    $right = $stack->pop()->operate($stack);
    return $right - $left;
}

}

class Multiplication extends Operator {

protected $precidence = 5;

public function operate(Stack $stack) {
    return $stack->pop()->operate($stack) * $stack->pop()->operate($stack);
}

}

 class Division extends Operator {

protected $precidence = 5;

public function operate(Stack $stack) {
    $left = $stack->pop()->operate($stack);
    $right = $stack->pop()->operate($stack);
    return $right / $left;
}

 }
    ?>

Upvotes: 0

Views: 367

Answers (2)

Patashu
Patashu

Reputation: 21773

Here we see that the tokenization is done by expecting one or more digits, a +, a -, a (, a ), a *, a / or one or more spaces:

$parts = preg_split('((\d+|\+|-|\(|\)|\*|/)|\s+)', $string, null, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);

So it will not recognize floating point values currently.

You need to change this

\d+

to your floating point numerical regex of choice, for example

((\d*)?\.)?\d+([eE][+\-]?\d+)?|[nN]a[nN]|[iI]nf(inity)?

is one I have used in the past to cover as many cases as possible.

Here it converts the token to a number if it is numeric, so if it parses but doesn't correctly turn into the right token/a number I would look here next:

public static function factory($value) {
    if (is_object($value) && $value instanceof TerminalExpression) {
        return $value;
    } elseif (is_numeric($value)) {
        return new Number($value);

Upvotes: 1

PHP lover
PHP lover

Reputation: 238

Patashu's solution is more complete but you still have to do more stuff to get it done.

If you only want the float numbers to work just change the line he mentioned

$parts = preg_split('((\d+|\+|-|\(|\)|\*|/)|\s+)', $string, null, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);

To this one

$parts = preg_split('(([0-9]*\.[0-9]+|[0-9]+|\+|-|\(|\)|\*|/)|\s+)', $string, null, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);

I tested it with your cases and it even works like this .2*.4+1.4

I repeat myself that this solution is only for float numbers and if you work on Patashu's answer you're going to make an amazing calculator ;)

Upvotes: 1

Related Questions