[REGEX] Controllare sintassi di un'espressione matematica

[alde90]

Salve a tutti!!

Chiedo scusa ai mod se ho sbagliato sezione, ma non sapevo dove altro postare

Vorrei realizzare una regexp che controlla la sintassi di un'espressione matematica (come dal titolo del resto )

Se si trattasse di una roba del tipo

2+5*(3^2-(3+5*2))

non avrei nessun problema (fermo restando che sono ancora a 0 con lo sviluppo ), ma ciò che voglio fare è leggermente più complesso: vorrei poter far "matchare" tutte le funzioni matematiche (seno, coseno, tangente, logaritmi, ...)

Stavo ragionando in questo senso: poichè qualsiasi espressione matematica può essere vista come somma (o prodotto o divisione o sottrazione) di espressioni semplici e/o funzioni, e a sua volta la funzione contiene un'espressione, mi trovo un pò in crisi perchè tutto è ricorsivo:

           Espressione <-----
           /         \       |
Esp. Semplice     Funzione---

ecco spero sia più chiaro con questo simil-schema (in pratica, design pattern Composite)

quindi, ipotizzando un controllo sull'espressione, mi risulterebbe che

Espressione=[0-9]|FUNZ(Espressione)

(dove funz non è altro che un insieme di tutte le possibili funzioni matematiche.

Qualcuno ha qualche idea??

Grazie in anticipo per le risposte

[alde90]

Rettifico il problema: il problema grosso è quello di controllare la chiusura delle parentei

in breve,

(2+(4*3+5*(2+4)))

è corretta,

2+4*3+(1+5

no.

Ho letto che bisogna utilizzare le regexp ricorsive per fare una cosa del genere (lo sospettavo, ma speravo di no). Qualcuno sa come diavolo fare a trasformarla in una regexp "normale"??

[ibykos]

Ciao!

Stai affrontando un problema classico dei corsi di "linguaggi e traduttori".

Si tratta di un problema ricorsivo, come hai osservato tu stesso, che credo vada oltre la potenza espressiva delle espressioni regolari.

Per risolvere questo problema in maniera tradizionale è opportuno

1) scaricare le librerie opportune per il linguaggio scelto

C: Lex & yacc o flex e byson

Java: jflex e cup

2) definire una semplice grammatica

O meglio, trattandosi di un problema classico, cercare una soluzione in giro.

3) incartare quanto sviluppato in un'unica funzione.

Spero di essere stato utile.

A presto.

[alde90]

Cio ibykos, grazie della risposta.

Sì, è vero che è un problema ricorsivo, ma è anche vero che (almeno a quanto ho letto in giro) alcune implementazioni permettono anche regexp ricorsive (presumo il perl)

Qui ho trovato il principio, poi googlando un pò si dovrebbe trovare il resto.

La regex (tratto dal link prima) è la seguente:

^((?:[^()]|\((?1)\))*+)$

Con la spiegazione:

^             Beginning of the string
(             Start the "balanced substring" group (to be called recursively)
  (?:         Start the "minimal balanced substring" group
    [^()]     Minimal balanced substring is either a non-paren character
    |         or
    \((?1)\)  a set of parens containing a balanced substring
  )           Finish the "minimal balanced substring" group
  *           Our balanced substring is a maximal sequence of minimal
              balanced substrings
  +           Don't backtrack once we've matched a maximal sequence
)             Finish the "balanced substring" pattern
$             End of the string

[alde90]

PS: ho trovato anche questo appena adesso

[ibykos]

Grazie, non sapevo che con le regexp si potessero fare cose così avanzate.
Solo una domanda, per cosa vuoi utilizzare questo script?
Lo chiedo soltanto per capire se è un qualcosa che richiede tanti sviluppi futuri (allora diventa un casino mettere mano alla regexp per modificarla) o se una volta finita l'implementazione il lavoro finisce lì.
Ciao!

[alde90]

Nulla di tutto ciò: curiosità personale

no avevo fatto un'implementazione in Java di riconoscitore di espressioni, e volevo fare una regex per controllare il tutto (anche per capire un po' di più il casino delle regex)

Quindi manco l'implementazione arrivavo a fare (e poi le regex esistono anche senza linguaggi di programmazione un essere umano le legge e confronta la stringa

O è superman, o è il Prof (di Mignolo con il prof), o è Harry Potter o è Chuck Norris. Nessun altro è in grado di farlo

[ibykos]

Questo è un esempio un po' scarso, ma dai un'occhiata a quanto è più comprensibile una grammatica scritta con gli strumenti classici:

import java_cup.runtime.*;
  terminal PIU, MENO, PER, DIVISO, NUMERO, TONDAO, TONDAC, UGUALE; 
  non terminal expr_list, expr, exp, e, t, f;

  start with expr_list;
  expr_list ::= expr_list expr | expr;

  expr ::= e UGUALE {: System.out.println("Riconosciuta un'espressione"); :};
  e ::= e PIU t| e MENO t| t ;
  t ::= t PER f| t DIVISO f|f;
  f ::= TONDAO e TONDAC| NUMERO ;

Tutto l'esempio, funzionante dopo lunga e difficile istallazione delle librerie, lo trovi qui.
Dalle stesse parti trovi anche la teoria e come istallare le librerie.

A presto.