La sigla PEMDAS è un acronimo che sta per P (parentesi), E (esponenti), M (moltiplicazione), D (divisione), A (addizione) e S (sottrazione). L'ordine delle lettere aiuta ad eseguire i calcoli correttamente. Tuttavia alcune calcolatrici consentono ad esempio la moltiplicazione implicita. Quindi due calcolatrici possono dare addirittura risultati diversi se alla base della progettazione del software si da una maggiore precedenza alla moltiplicazione implicita. Facciamo un esempio di due calcolatrici:

1) Esempio con precedenza alla moltiplicazione implicita:

6 / 2(1 + 2) = 1

2) Stesso esempio ma con le regole del PEMDAS 

6 / 2 * (1 + 2) = 9

La soluzione corretta di 6 / 2 * (1 + 2) seguirebbe questo ordine:

1. Risolvere le parentesi: 6 / 2 * 3 
2. Risolvere gli esponenti. In questo caso non ne abbiamo.
3. Risolvere le moltiplicazioni: 18/2
4. Risolvere le divisioni: 9

Se su un calcolatore è prevista la moltiplicazione implicita potremo ottenere perciò due risultati diversi. Ecco perché è importante applicare le regole del PEMDAS in un linguaggio di programmazione; infatti, se provassimo a far eseguire al PHP la stessa espressione aritmetica darebbe come risultato 9 che è appunto quello corretto. Nel secondo esempio, invece, generebbe un errore di sintassi. In PHP scriveremo:

// Output 9
echo 6 / 2 * (1+2);

// Errore di sintassi per il PHP
echo 6 / 2(1+2);

// Output 1
echo 6 / (2 * (1+2));

Ecco una lista di esempi in PHP ma le regole di base valgono per qualsiasi linguaggio di programmazione o calcolo matematico:

echo "<p>PEMDAS = parentesi, esponenti, moltiplicazioni, divisioni, addizioni, sottrazioni. 
Le regole di precedenza nella risoluzione delle espressioni aritmetiche.</p>";

// Output 32
echo "5 * 6 + 3 - 1 = ";
echo 5 * 6 + 3 - 1;
echo "<br>";

// Output 44
echo "5 * (6 + 3) - 1 = ";
echo 5 * (6 + 3) - 1;
echo "<br>";

// Output 32
echo "(5 * 6) + 3 - 1 = ";
echo (5 * 6) + 3 - 1;
echo "<br>";

// Output 32
echo "3 + 5 * 6 - 1 = ";
echo 3 + 5 * 6 - 1;
echo "<br>";

// Output 9
echo "6 / 2 * (1+2) = ";
echo 6 / 2 * (1+2);
echo "<br>";

// Output 25
echo "5**2 = ";
echo 5**2;
echo "<br>";

// Output 224
echo "5**2 * (6 + 3) - 1 = ";
echo 5**2 * (6 + 3) - 1;
echo "<br>";

// Output 152
echo "5**2 * 6 + 3 - 1 = ";
echo 5**2 * 6 + 3 - 1;
echo "<br>";

Facciamo un altro esempio più complesso:

36 – 2 * (20 + 12 / 4 * 3 – 2^2) + 10

Risoluzione con PEMDAS:

1. 36 – 2 * (20 + 12 / 4 * 3 – 4) + 10 
2. 36 – 2 * (20 + 36/4 – 4) + 10 
3. 36 – 2 * (20 + 9 – 4) + 10
4. 36 – 2 * (25) + 10
5. = -4

Risoluzione con PHP

// Output -4
echo "36 - 2 * (20 + 12 / 4 * 3 - pow(2,2)) + 10 = ";
echo 36 - 2 * (20 + 12 / 4 * 3 - pow(2,2)) + 10;
echo "<br>";

PEMDAS è la regola base che ci viene insegnata a scuola ed è utilizzata dalla maggior parte degli strumenti di calcolo; tuttavia esistono differenze che bisogna tenere a mente quando si utilizza un calcolatore. Essendo appunto una convenzione universalmente accettata non ne costituisce però una regola matematica riguardo alla sua adozione. Prendiamo ad esempio la calcolatrice di Windows. Se io scrivessi nella calcolatrice standard la seguente espressione aritmetica 2 + 1 * 3 avrei come risultato 9 e in quella scientifica 5:

Non è un bug ma due modi di sviluppo software differenti che fanno uso di una notazione non standard che nulla c'entra con la teoria matematica. La versione standard della calcolatrice divide in due operazioni l'espressione aritmetica ed è perciò corretta nella sua logica nel dare quel risultato; di conseguenza, anche tra calcolatrici di due sistemi operativi differenti potrei ottenere risultati differenti. Tutto dipende quindi dallo sviluppo software del calcolatore. Le calcolatrici scientifiche solitamente seguono le regole del PEMDAS che è ormai diventato uno standard de facto a tutti gli effetti. Anche nella programmazione software l'utilizzo delle parentesi aiuta quindi a ridurre le ambiguità e a creare programmi più affidabili.