Comment créer une calculatrice en PHP à l'aide de l'algorithme Shunting Yard ?

Comment créer une calculatrice en PHP ?

En PHP, la création d'une calculatrice nécessite d'analyser et d'évaluer des expressions mathématiques saisies par un utilisateur. Cela peut être difficile, car cela implique de gérer les entrées de l'utilisateur et d'appliquer des opérations mathématiques.

Utiliser l'algorithme de triage de manœuvre

Une approche recommandée consiste à exploiter l'algorithme de triage de manœuvre. Cet algorithme convertit les expressions mathématiques en notation polonaise inversée (RPN), qui est plus facile à évaluer.

Exemple de mise en œuvre

Voici un exemple simplifié utilisant l'algorithme Shunting Yard :

// Terminal expression abstract class
abstract class TerminalExpression {

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

    public function isOperator() {
        return false;
    }

    public function isParenthesis() {
        return false;
    }

    public function isNoOp() {
        return false;
    }
}

// Operator expression abstract class
abstract class Operator extends TerminalExpression {

    public function isOperator() {
        return true;
    }
}

// Stack implementation
class Stack {

    private $data = [];

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

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

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

// Math class for evaluation
class Math {

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

    private function parse($expression) {
        $tokens = $this->tokenize($expression);
        $output = new Stack();
        $operators = new Stack();

        foreach ($tokens as $token) {
            $type = TerminalExpression::factory($token);

            if ($type->isOperator()) {
                $this->parseOperator($type, $output, $operators);
            } elseif ($type->isParenthesis()) {
                $this->parseParenthesis($type, $output, $operators);
            } else {
                $output->push($type);
            }
        }

        while (($op = $operators->pop())) {
            if ($op->isParenthesis()) {
                throw new RuntimeException('Mismatched Parenthesis');
            }
            $output->push($op);
        }

        return $output;
    }

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

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

$math = new Math();
$answer = $math->evaluate('(2 + 3) * 4');
var_dump($answer); // int(20)

Cet exemple montre comment utiliser l'algorithme Shunting Yard pour analyser et évaluer une expression mathématique simple.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!