Newsgroup: it.comp.lang.c
Titolo: Notazione Polacca Inversa

Ciao a tutti.
Sapreste dirmi dove potrei trovare della documentazione
relativa alla cosiddetta 'notazione polacca inversa' ?
Devo scrivere una mini-calcolatrice che usi tale metodo,
ma non l'ho mai usata prima d'ora...
M'hanno detto di guardare sui manuali delle calcolatrici
HP, ma volevo sapere se c'era qualcosa di piu' esaustivo.
Grazie infinite,
E.
 
-------
Stat rosa pristina nomine, nomina nuda tenemus.

relativa alla cosiddetta 'notazione polacca inversa' ?
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
typedef enum { OP_ADDZ,
               OP_SOTT,
               OP_MOLT,
               OP_DIVS,
               COSTNUM,
               FINEFRM
             } object_t ;
void push ( double x, double * * stack )
{
     *(*stack)++ = x ;
}
double pop ( double * * stack )
{
    return *(--*stack) ;
}
object_t next_token ( char * * f, double * e )
{
     char cnum [20] ;
     int i = 0 ;
     while ( isspace ( **f ) ) ++(*f) ;
     if ( **f )
     {
        if ( isdigit ( **f ) )
        {
           while ( isdigit ( **f ) && (i < 20) )
                 cnum[i++] = *((*f)++) ;
           cnum[i] = 0 ;
           *e = atof ( cnum ) ;
           return COSTNUM ;
        }
        else
        switch ( *((*f)++) )
        {
               case '+' : return ( OP_ADDZ ) ;
               case '-' : return ( OP_SOTT ) ;
               case '*' : return ( OP_MOLT ) ;
               case '/' : return ( OP_DIVS ) ;
        }
     }
     else return FINEFRM ;
}
double risolvi ( char * f )
{
       double num ;
       double e, op1, op2 ;
       double * stack_opd = malloc ( 100 ) ;
       object_t t ;
       while ( ( t = next_token ( &f, &e ) ) != FINEFRM )
       {
             if ( t == COSTNUM ) push ( e, &stack_opd ) ;
             else
             {
                op2 = pop ( &stack_opd ) ;
                op1 = pop ( &stack_opd ) ;
                switch ( t )
                {
                       case OP_ADDZ : push ( op1 + op2, &stack_opd );
break ;
                       case OP_SOTT : push ( op1 - op2, &stack_opd );
break ;
                       case OP_MOLT : push ( op1 * op2, &stack_opd );
break ;
                       case OP_DIVS : push ( op1 / op2, &stack_opd );
break ;
                }
             }
       }
       return pop ( &stack_opd ) ;
}
int main ()
{
    char * mia_formula = "7 7 * 4 5 * 8 * - 2 8 * /" ;
    printf ( "\n%s = ", mia_formula ) ;
    printf ( "%f\n", risolvi ( mia_formula ) ) ;
    return 0 ;
}

HP, ma volevo sapere se c'era qualcosa di piu' esaustivo.
E' semplice: scrivi le espressioni come alberi e poi fai una visita
anticipata. Quello che ottieni e' l'espressione scritta in RPN

 HP, ma volevo sapere se c'era qualcosa di piu' esaustivo.
  Se hai sotto mano l'info-file del bison(1) puoi trovarci dentro una
(minima) spiegazione della grammatica per una calcolatrice RPN. Al
limite, puoi scaricartelo dal sito della GNU.
	Alla prossima,
		Marco

Prova a fare un giro qui:
http://www.hpmuseum.org/rpn.htm
Aldo

Grazie a tutti.
Ciao,


 [...]
Ti ringrazio !!!
Ma non avevo chiesto cosi' tanto, bastava un riferimento
alla documentazione...  :-)
Beh, in ogni caso ancora grazie mille e scusa per il disturbo!
Ti sono debitore...
Ave,


Non finirai mai di stupirmi!
-- 
*******************************************************
       "Dio non e' morto.
        E' vivo e sta lavorando
        a un progetto
        meno ambizioso"
				    graffito anonimo
  Reply to 
bia...@maganet.net
*******************************************************