Newsgroup: it.comp.programmare.win32
Titolo: Espressione

Se io faccio inserire una operazione all'interno di una textbox, diciamo
qualcosa tipo 1+1+1, esiste una funzione che mi possa fornire il risultato?
Quindi 3. Altrimenti, come potrei fare avendo espressioni all'interno di
stringhe o array di caratteri ad ottenerne il risultato?
Grazie.
Luca Carlon

 stringhe o array di caratteri ad ottenerne il risultato?
analizzi la stringa carattere per carattere e ti ricostruisci i numeri e i
segni di operazioni


wrote:

Hai bisogno di un parser che analizzi funzioni matematiche. Non ho mai
avuto necessità di usare simili funzioni ma credo che su un qualunque
sito di programmazione tu possa trovarne parecchi (è un classico
temino d'esame d'informatica).
Nel mio bookmark ho:
http://www.freecode.com/
http://www.codeproject.com/
http://www.codeguru.com/
http://www.programmersheaven.com/
Ciao
Stefano "HappyMan" (Lago Maggiore - NO)
--
Personal Web 
http://www.sgr.info
Email 
happyman...@libero.it
 [Togliere nospam per scrivermi]
Salsa Web 
http://happyman.n3.net
 [Foto salseri/e & I.A.B.L.A. Ring]

 temino d'esame d'informatica).
Cos'è questo parser? Un header, una funzione? Cosa?
Grazie a tutti per le risposte.
Luca Carlon

 Cos'è questo parser? Un header, una funzione? Cosa?
un header dovrebbe essere fatto come non ho mai visto fare in vita mia...
:)
e' quello che chiedevi, una funzione che accetta una stringa e restituisce
il valore numerico
ciao
Ermando

 il valore numerico
Si, ho trovato questo che i avete consegliato. Grazie.
Luca Carlon

 
http://www.programmersheaven.com/
Ho trovato quello di cui avevo bisogno su 
www.planet-sorce.code.com
. Ma se
io volessi scrivermelo da me, mi daresti un consiglio su come fare? Diciamo
un suggerimento.
Grazie.
Luca Carlon

io volessi scrivermelo da me, mi daresti un consiglio su come fare?
Cerca su 
www.programmazione.it
, c'è la spiegazione di come funziona un
parser.
-- 
Marco Barisione (ICQ 84277092)

un suggerimento.
Cerca informazioni sulla teoria dei linguaggi e le macchine a stati.


 Cerca informazioni sulla teoria dei linguaggi e le macchine a stati.
Io a 16 anni non ne sapevo nulla di queste cose ma il mio parser era alla 
pari (anzi meglio) di quello 'nativo' del linguaggio che usavo... 8)
-- 
Luc.

 Luc.
Bravo. Ma non aggiunge alcuna informazione oltre a quella che hai piu di
sedici anni

 sedici anni
Tutto successe dodici anni fa. 
-- 
Luc.

 wrote in message
news:4cqd8.5526$v7.2...@twister1.libero.it...

La cosa non è particolarmente difficile, pero' l'implementazione e'
abbastanza
lunghetta e richiede una certa familiarita' con le strutture ad albero.
Metti il caso semplice di prodotti, quozienti,somme e sotrazioni; per il
resto e'
uguale devi solo rispettare le regole dell' aritmetica.
Prendi la stringa ad esempio 3+2*1+2 e la esamini per ogni + o - dividi
la stringa nella
parte destra e sinistra rispetto al segno, in questo caso:
   +
  3  2*1+2
al secondo passaggio:
   +
  /  \
 3    +
     /  \
   2*1   2
poi applichi la stessa cosa per i prodotti e i quozienti:
   +
  /  \
 3    +
     /  \
    *    2
   / \
  2   1
Ovviamente la procedura va applicata ricorsivamente a partire dalla
stringa iniziale.
A questo punto devi avere una funzione diciamo EsaminaNodo che applicata
al nodo di un albero(la radice inizialmente) ti applica l'operazione
contenuta
nel nodo ai risultati della stessa funzione applicata al nodo sinistro e
destro
rispettivamente.
Devi solo avere dimestichezza con puntatori, alberi e ricorsione.
Ciao!!
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Devi solo avere dimestichezza con puntatori, alberi e ricorsione.
Esatto, ma ti assicuro che si può fare anche senza, ad esempio con 
'string substitution' (più semplice anche se un po più lento).
-- 
Luc.

 Tutto successe dodici anni fa.
Anche questo non aggiunge alcuna informazione.
Hai intenzione di continuare ?


 Diciamo un suggerimento.
Scritto qualche anno fa:
/*********************************************************
 * rdparser.c - parser di espressioni matematiche.       *
 *                                                       *
 * ALCLIB v.2.0 - Andrea Laforgia C Library              *
 * (C)1999 Andrea Laforgia (
andrea_...@bigfoot.com
) *
 *                                                       *
 * NOTE :                                                *
 * Il programma implementa un parser di tipo             *
 * recursive-descendant.                                 *
 *                                                       *
 * L'algoritmo di funzionamento si basa sulla            *
 * discesa ricorsiva per il riconoscimento dei           *
 * simboli terminali e la risoluzione delle              *
 * produzioni della grammatica adottata.                 *
 *                                                       *
 * La grammatica adottata e' la seguente :               *
 *                                                       *
 * espressione ::= espressione + espressione |           *
 *                 espressione - espressione |           *
 *                 fattore                               *
 *                                                       *
 * fattore ::= fattore * fattore |                       *
 *             fattore / fattore |                       *
 *             termine                                   *
 *                                                       *
 * termine ::= costante numerica |                       *
 *             funzione ( espressione ) |                *
 *             ( espressione )                           *
 *                                                       *
 * Il parser riconosce quattro semplici funzioni :       *
 *                                                       *
 * rq()   : estrae la radice quadrata.                   *
 * quad() : calcola il quadrato.                         *
 * ass()  : restituisce il valore assoluto.              *
 * neg()  : restituisce il valore negativo.              *
 *                                                       *
 * Ha, inoltre, alcune limitazioni :                     *
 * non consente l'uso di spazi bianchi,                  *
 * non gestisce la divisione per zero e                  *
 * gli argomenti negativi per rq().                      *
 *                                                       *
 * C'e' un piccolo bug, a dire il vero, scoperto in      *
 * seguito :                                             *
 *                                                       *     
 * la funzione termine() dovrebbe contemplare anche il   *
 * caso "espressione" evitando di implementare un "while"*
 * sia nella funzione espressione() che in fattore().    *
 *                                                       *
 * Ma nonostante questo il programma funziona bene.      *
 *                                                       *
 *********************************************************/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
typedef struct {
                 double num ;
                 char   nome_funz[10] ;
               } tipo_valore ;
typedef struct {
                 char * formula ;
                 int    indice ;
               } oggetto_formula ;
typedef enum { OP_ADDZ,   /* operatore di addizione */
               OP_SOTT,   /* operatore di sottrazione */
               OP_MOLT,   /* operatore di moltiplicazione */
               OP_DIVS,   /* operatore di divisione */
               OP_PARA,   /* operatore parentesi aperta  */
               OP_PARC,   /* operatore parentesi chiusa */
               NOMEFNZ,   /* identificatore di funzione */
               COSTNUM,   /* costante numerica */
               FINEFRM    /* fine formula */
             } tipo_token ;
void errore_sintassi ( oggetto_formula * f )
{
     int i ;
     puts ("errore di sintassi nella formula :") ;
     printf ( "%s\n", f->formula ) ;
     for (i = 0 ; i < f->indice-1 ; i++)
         putchar(' ');
     printf("^\n");
     exit ( 1 ) ;
}
tipo_token prossimo_token ( oggetto_formula * f, tipo_valore * v )
{
     char cnum[20] ;
     int i = 0 ;
     if ( f->formula[f->indice] )
     {
        if ( isdigit ( f->formula[f->indice] ) )
        {
           while ( isdigit ( f->formula[f->indice] ) && (i < 20) )
                 cnum[i++] = f->formula[f->indice++] ;
           cnum[i] = 0 ;
           v->num = atof ( cnum ) ;
           return COSTNUM ;
        }
        else
        if ( isalpha (f->formula[f->indice]) )
        {
           while ( (isalpha (f->formula[f->indice]) ||
                    isdigit (f->formula[f->indice])) &&
                   (i < 10) )
                 v->nome_funz[i++] = f->formula[f->indice++] ;
           v->nome_funz[i] = 0 ;
           if (f->formula[f->indice++] == '(')
              return NOMEFNZ ;
           else errore_sintassi ( f ) ;
        }
        else
        switch ( f->formula[f->indice++] )
        {
               case '+' : return OP_ADDZ ;
               case '-' : return OP_SOTT ;
               case '*' : return OP_MOLT ;
               case '/' : return OP_DIVS ;
               case '(' : return OP_PARA ;
               case ')' : return OP_PARC ;
               default  : errore_sintassi( f ) ;
        }
     }
     else return FINEFRM ;
}
int atteso ( oggetto_formula * f, const tipo_token t )
{
    int i = f->indice ;
    tipo_valore dummy ;
    tipo_token tk = prossimo_token ( f, &dummy ) ;
    if (tk == t) return 1 ;
    else
    {
       f->indice = i ;
       return 0 ;
    }
}
double termine ( oggetto_formula * f )
{
       tipo_token t ;
       tipo_valore v ;
       double x ;
       extern double espressione( oggetto_formula * f ) ;
       switch ( t = prossimo_token( f, &v ) )
       {
              case COSTNUM : return v.num ;
              case OP_PARA : x = espressione ( f ) ;
                             if ( atteso ( f, OP_PARC ) )
                                return x ;
                             else
                                errore_sintassi( f ) ;
              case NOMEFNZ : x = espressione ( f ) ;
                             if ( atteso ( f, OP_PARC ) )
                             {
                                if (!strcmp(v.nome_funz, "rq"))
                                   return sqrt ( x ) ;
                                else
                                if (!strcmp(v.nome_funz, "ass"))
                                   return abs ( x ) ;
                                else
                                if (!strcmp(v.nome_funz, "neg"))
                                   return ( -x ) ;
                                else
                                if (!strcmp(v.nome_funz, "quad"))
                                   return ( x*x ) ;
                             }
                             else errore_sintassi( f ) ;
              default : errore_sintassi( f ) ;
       }
}
double fattore ( oggetto_formula * f )
{
       double op1, op2 ;
       int attesoMOLT, attesoDIVS ;
       op1 = termine ( f ) ;
       while ( (attesoMOLT = atteso ( f, OP_MOLT )) ||
               (attesoDIVS = atteso ( f, OP_DIVS )) )
       {
          op2 = termine ( f ) ;
          if ( attesoMOLT ) op1 = op1 * op2 ;
          else
          if ( attesoDIVS ) op1 = op1 / op2 ;
       }
       return op1 ;
}
double espressione ( oggetto_formula * f )
{
       double op1, op2 ;
       int attesoADDZ, attesoSOTT ;
       op1 = fattore ( f ) ;
       while ( (attesoADDZ = atteso ( f, OP_ADDZ )) ||
               (attesoSOTT = atteso ( f, OP_SOTT )) )
       {
          op2 = fattore ( f ) ;
          if ( attesoADDZ ) op1 = op1 + op2 ;
          else
          if ( attesoSOTT ) op1 = op1 - op2 ;
       }
       return op1 ;
}
void assegna_formula ( oggetto_formula * f, const char * testo )
{
     f->indice = 0 ;
     f->formula = malloc ( strlen(testo) + 1 ) ;
     strcpy ( f->formula, testo ) ;
}
int main ( void )
{
    int counter = 0 ;
    oggetto_formula mia_formula ;
    assegna_formula ( &mia_formula,
                      "(neg(5)-rq(quad(5)-4*6*1))/(2*6)" ) ;
    printf ( "%f\n", espressione ( &mia_formula ) ) ;
    return 0 ;


 Hai intenzione di continuare ?
Hai intenzione di seguire anche gli altri rami del thread!?!?
Capisco che non ti sto simpatico (principio di inferiorità?), ma se la 
smettessi di rompere, magari...
-- 
Luc.

 ma se la smettessi di rompere, magari...
Non devi prenderla sul personale (inferiorita' ? ROTFL)...
E' che se evitassi di vantare i tuoi successi raggiunti
in giovane eta' su tutti i ng della gerarchi it.* in cui si
parla di programmazione, faresti a tutti un gran piacere 
(anche perche' la cosa non c'entra molto col tema del thread).
Forse vuoi sentirti dire : bravo !!!, ok te lo diciamo.
Ora basta pero'.


 Ora basta pero'.
Polemizzare con te č inutile, sei certamente il pių bravo di tutti a 
farlo sulla gerarchia it.*
-- 
Luc.

 farlo sulla gerarchia it.*
Non ambisco a un premio cosi' alto, anche se quelli come te
mi invitano a nozze :
Soggetto:Re: borland delphi o borland c++ per iniziare? 
Newsgroups:it.comp.programmare.win32
Data:2002-02-08 00:00:29 PST 
"Azz, ti ho battuto. Io ho iniziato a programmare ad 11 anni, il Natale
della I media. Beh, con l'assembler ho iniziato solo un anno dopo... 8)"
Soggetto:Re: Numeri Casuali"
Newsgroups:it.comp.lang.c++
Data:2001-11-16 03:20:08 PST
"PS: uno dei miei primi giochi implementati ad 11 anni su C64... 8-OOO"
Soggetto:Re: AIUTO ESAMI 2 
Newsgroups:it.comp.lang.c++
Data:2001-02-14 06:18:51 PST 
"Io ero in grado di fare programmi di discreta qualità già in prima
media (12 anni). In terza
media, grazie ad un mio programma per C64 sull'allora nascente CEE, ho
fatto vincere alla scuola un mitico Olivetti-M21."
Soggetto:Re: Giocare a 7 1/2 col C++ 
Newsgroups:it.comp.lang.c++
Data:2000/05/26 
"Non penso sia molto difficile, io lo feci in Basic una
dozzina di anni fa (a 15 anni) e non era venuto male"
Soggetto:Re: Espressione 
Newsgroups:it.comp.programmare.win32
Data:2002-02-22 08:09:55 PST
"Io a 16 anni non ne sapevo nulla di queste cose ma il mio parser era
alla
pari (anzi meglio) di quello 'nativo' del linguaggio che usavo... 8)"
eccetera.... eccetera.... eccetera....


 [CUT]
Sono un grande!!! 8-PPPPPPPPPPPPPPPPP
-- 
Luc.

 Scritto qualche anno fa:
[cut]
Grazie per la gentilezza.
Luca Carlon

 ha scritto nel messaggio
news:MPG.16e561d0f...@news.cis.dfn.de...

Infatti, per il momento delle tre voci conosco solo la prima :-)). Ho già
cominciato, vediamo cosa ne viene fuori. Secondo il teorema di Jacopini
tutto dovrebbe poter essere fatto con le strutture che già conosco, speriamo
che avesse ragione :-)).
Luca Carlon

 Infatti, per il momento delle tre voci conosco solo la prima :-)). 
E se vuoi imparare realmente qualcosa, fai bene a restare su quella....
