Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicit e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
Paint XY -Sistemi & Grafici da File- - Funzioni.h

Funzioni.h

Caricato da: Dany
Scarica il programma completo

  1. //Funzioni:
  2. #include <cmath>
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. //Funzione "Pi di x", ovvero quanti numeri primi da 1 a x.
  7. int Primidi (int a)
  8. {
  9.     int b,d,c;
  10.     b=1;
  11.     d=0;
  12.     while (b<a)
  13.     {
  14.             b++;
  15.             c=2;
  16.             while (((b%c)!=0) && (c<=b))
  17.             c++;
  18.             if (c>=b)
  19.             {
  20.                 d++;
  21.             }
  22.     }
  23.     return d;
  24. }
  25. //Calcola numero divisori
  26. int numdiv (int a)
  27. {
  28.         if (a<0)
  29.                 a=-a;
  30.     int b,c=0;
  31.     b=1;
  32.     while (a>=b)
  33.     {
  34.         if (a%b ==0)
  35.         {
  36.                 c++;
  37.                 b++;
  38.         }
  39.         else b++;  
  40.     }
  41.     return c;
  42. }
  43. //Fattoriale
  44. double facto(int a)
  45. {
  46.       if (a>0)
  47.       {
  48.       int i;
  49.       float b=1;
  50.       for (i=1;i<=a;i++)
  51.       {
  52.           b=b*i;
  53.       }
  54.       return b;
  55.       }
  56. }
  57. //Associa funzioni a char
  58. float Fun (char a , float x)
  59. {
  60.       /*Trigonometria*/
  61.       if (a=='s')
  62.          return sin(x);
  63.       if (a=='c')
  64.          return cos(x);
  65.       if (a=='t')
  66.          return tan(x);
  67.       if (a=='a')
  68.          return asin(x);
  69.       if (a=='b')
  70.          return acos(x);
  71.       if (a=='d')
  72.          return atan(x);
  73.       if (a=='h')
  74.          return sinh(x);
  75.       if (a=='i')
  76.          return cosh(x);
  77.       if (a=='j')
  78.          return tanh(x);
  79.       /*Logaritmi*/
  80.       if (a=='L')
  81.          return log10(x);
  82.       if (a=='N')
  83.          return log(x);
  84.       if (a=='D')
  85.          return (log(x))/(log(2.0));
  86.       /*Varie*/
  87.       if (a=='A')
  88.          return fabs(x);
  89.       if (a=='I')
  90.          return (int(x));
  91.       if (a=='P')
  92.          return Primidi(int(x));
  93.       if (a=='!')
  94.          return facto(int(x));
  95.       if (a=='V')
  96.          return numdiv(int(x));
  97.       /*Algebra*/
  98.       if (a=='R')
  99.          return sqrt(x);
  100.       if (a=='C')
  101.          return pow(float(x),float((1/3.0)));
  102.       if (a=='Q')
  103.          return pow(float(x),float((1/5.0)));
  104. }
  105. //Funione a tre parametri char che come risultato rid il carattere-funzione da mettere nell'rpn
  106. char charfun (char a, char b, char c)
  107. {
  108.         int bo=0;
  109.         /*Trigonometria*/
  110.         if ((a=='s')&&(b=='i')&&(c=='n')){bo++;
  111.                 return 's';}
  112.         if ((a=='c')&&(b=='o')&&(c=='s')){bo++;
  113.                 return 'c';}
  114.         if ((a=='t')&&(b=='a')&&(c=='n')){bo++;
  115.                 return 't';}
  116.         if ((a=='a')&&(b=='s')&&(c=='i')){bo++;
  117.                 return 'a';}
  118.         if ((a=='a')&&(b=='c')&&(c=='s')){bo++;
  119.                 return 'b';}
  120.         if ((a=='a')&&(b=='t')&&(c=='g')){bo++;
  121.                 return 'd';}
  122.         if ((a=='s')&&(b=='n')&&(c=='h')){bo++;
  123.                 return 'h';}
  124.         if ((a=='c')&&(b=='s')&&(c=='h')){bo++;
  125.                 return 'i';}
  126.         if ((a=='t')&&(b=='a')&&(c=='h')){bo++;
  127.                 return 'j';}
  128.         /*Logaritmi*/
  129.         if ((a=='l')&&(b=='o')&&(c=='g')){bo++;
  130.                 return 'L';}
  131.         if ((a=='l')&&(b=='o')&&(c=='n')){bo++;
  132.                 return 'N';}
  133.         if ((a=='l')&&(b=='o')&&(c=='d')){bo++;
  134.                 return 'D';}
  135.         /*Varie*/
  136.         if ((a=='a')&&(b=='s')&&(c=='s')){bo++;
  137.                 return 'A';}
  138.         if ((a=='i')&&(b=='n')&&(c=='t')){bo++;
  139.                 return 'I';}
  140.         if ((a=='q')&&(b=='r')&&(c=='m')){bo++;
  141.                 return 'P';}
  142.         if ((a=='f')&&(b=='a')&&(c=='c')){bo++;
  143.                 return '!';}
  144.         if ((a=='d')&&(b=='i')&&(c=='v')){bo++;
  145.                 return 'V';}
  146.         /*Algebra*/
  147.         if ((a=='r')&&(b=='a')&&(c=='d')){bo++;
  148.                 return 'R';}
  149.         if ((a=='r')&&(b=='a')&&(c=='c')){bo++;
  150.                 return 'C';}
  151.         if ((a=='r')&&(b=='a')&&(c=='q')){bo++;
  152.                 return 'Q';}
  153.         if (bo==0)
  154.         {
  155.                 return NULL;
  156.         }
  157.  
  158. }
  159. //Converte le ascisse in coordinate x per la finestra
  160. int conx(double s,float max)
  161. {
  162.         int con;
  163.         con=int(500+(s*500/max));      
  164.         return con;
  165. }
  166. //Converte le ordinate in coordinate y per la finestra
  167. int cony(double s,float max)
  168. {
  169.         int con;
  170.         con=int(500-(s*500/max));
  171.         return con;
  172. }
  173. //Controlla se il carattere nello stack una funzione
  174. int chkfun (char a)
  175. {
  176.         if ((a=='s')||(a=='c')||(a=='t')||(a=='a')||(a=='b')||(a=='d')||(a=='h')||(a=='i')||(a=='j')||
  177.                         (a=='L')||(a=='N')||(a=='D')||
  178. (a=='A')||(a=='I')||(a=='P')||(a=='!')||(a=='V')||
  179.         (a=='R')||(a=='C')||(a=='Q'))
  180.         {
  181.                 return 1;
  182.         }
  183.         else
  184.                 return 2;
  185. }
  186. //Controlla se (nella Function Window) nella conversione RPN, un carattere una costante (o una variabile) o un'operatore
  187. int chkchar(char a)    
  188. {  
  189.         if ((('0'<=a)&&(a<='9'))||(a=='x')||(a=='X')||(a=='p')||(a=='e')||(a=='y'))       //Il carattere una cifra, una costante o la variabile x.
  190.         {
  191.                 return 1;
  192.         }
  193.         if ((a=='+')||(a=='-')||(a=='*')||(a=='/')||(a=='^')||(a=='%'))                //Il carattere un operatore
  194.         {
  195.                 return 2;
  196.         }
  197.         else
  198.                 return 3;
  199. }
  200. //Controlla la precedenza tra 2 operatori
  201. bool precedence(char op1, char op2)
  202. {
  203.         int first=0;
  204.         if ((op1=='+')||(op1=='-'))
  205.         {
  206.                 first=1;
  207.         }
  208.         if ((op1=='*')||(op1=='/')||(op1=='%'))
  209.         {
  210.                 first=2;
  211.         }
  212.         if ((op1=='^')||(chkfun(op1)==1))
  213.         {
  214.                 first=3;
  215.         }
  216.         /*******************/
  217.         int second=0;
  218.         if ((op2=='+')||(op2=='-'))
  219.         {
  220.                 second=1;
  221.         }
  222.         if ((op2=='*')||(op2=='/')||(op2=='%'))
  223.         {
  224.                 second=2;
  225.         }
  226.         if ((op2=='^')||(chkfun(op2)==1))
  227.         {
  228.                 second=3;
  229.         }
  230.         if ((first == second)||( first < second))
  231.                 return false;
  232.         else
  233.                 return true;
  234. }
  235. //Conta le cifre di un numero intero
  236. float numcif (int a)
  237. {
  238.         double aa=a;
  239.        if (a<0)
  240.        {
  241.           aa=-a;
  242.        }
  243.        double b;
  244.            float c;
  245.        b=log10(aa);
  246.        c=ceil(b);
  247.        if (c==b)
  248.        {
  249.           c++;
  250.        }
  251.        if (a==0)
  252.        {
  253.           c=1;
  254.        }
  255.        return c;
  256. }
  257. //Distanza tra due punti:
  258. float dist(POINT a,POINT b)
  259. {
  260.         float result;
  261.         result=(a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
  262.         result=sqrt(result);
  263.         return result;
  264. }
  265. //Solve RPN
  266. float SolveRPN(string rpn,float x,float y)
  267. {
  268.         stack <float> numbers;
  269.         string longNumber = "";
  270.         float  result=0,prev=0,postv=0;
  271.         int chkop=0;
  272.         for (unsigned int h = 0; h < rpn.size(); h++)
  273.         {
  274.                 /*Il carattere letto e' un numero. Questo numero viene memorizzato
  275.                 * nella stringa di appoggio.
  276.                 * Se il prossimo carattere e' un numero,vuol dire che nella
  277.                 * stringa c'e un numero lungo perche' nella funzione di conversione
  278.                 * dopo ogni numero inserito nella stringa di output veniva messo anche
  279.                 * il simbolo di spazio. La prossima cifra del numero sara' aggiunta
  280.                 * alla fine della stringa di appoggio all'aumentare dell'indice.
  281.                 * Se il prossimo carattere non e' un numero, la stringa d'appoggio
  282.                 * viene convertita in un numero vero e memorizzata nello stack. */
  283.                 if(chkchar(rpn[h])==1)
  284.                 {
  285.                         if (isdigit(rpn[h]))
  286.                         {
  287.                                 longNumber += rpn[h];
  288.                         }
  289.  
  290.                         if ((rpn[h]=='x')||(rpn[h]=='X'))                         //sostitusco alla x nell'espressione il valore effettivo della x
  291.                         {
  292.                                 numbers.push(x);
  293.                         }
  294.  
  295.                         if ((rpn[h]=='y'))                         //sostitusco alla x nell'espressione il valore effettivo della x
  296.                         {
  297.                                 numbers.push(y);
  298.                         }
  299.  
  300.  
  301.                         if (rpn[h]=='e')                       //sostituisco alla e nell'espressione il valore della costante
  302.                         {
  303.                                 numbers.push(2.71828);
  304.                         }
  305.  
  306.                         if (rpn[h]=='p')                 //sostituisco alla p nell'espressione il valore della costante
  307.                         {
  308.                                 numbers.push(3.14159);
  309.                         }
  310.                         //Se il carattere successivo non una cifra e diverso dalla virgola:
  311.                         if((!isdigit(rpn[h + 1]))&& (rpn[h+1]!='.')&&(rpn[h]!='x')&&(rpn[h]!='X')&&(rpn[h]!='e')&&(rpn[h]!='p')&&(rpn[h]!='y'))  
  312.                         {
  313.                                 numbers.push(atof(longNumber.c_str()));
  314.                                 longNumber = "";
  315.                         }
  316.                         if (rpn[h+1]=='.')    //Se il carattere successivo la virgola:
  317.                         {
  318.                                 numbers.push(atof(longNumber.c_str()));    //legge la parte precedente a questa (la parte intera )
  319.                                 longNumber = "";
  320.                                 prev = numbers.top();
  321.                                 numbers.pop();
  322.                                 int count=2;
  323.                                 while (isdigit(rpn[count+h]))      //Legge la parte successiva e la memorizza come numero
  324.                                 {
  325.                                         longNumber += rpn[h+count];
  326.                                         count++;
  327.                                 }
  328.                                 h=h+count;
  329.                                 postv=(atof(longNumber.c_str()));
  330.                                 longNumber="";
  331.                                 /*somma la parte precedente a quella successiva
  332.                                 fratto 10^il numero di cifre che ha es:
  333.                                 2.985     prev=2   postv=985
  334.                                 985 ha tre cifre quindi 985/10^3=0.985
  335.                                 li sommo e ottengo 2.985*/
  336.                                 numbers.push(prev+(postv/pow(10,numcif(postv))));      
  337.                                 postv=0;prev=0;
  338.                         }
  339.                 }
  340.                
  341.                 if (chkchar(rpn[h])==2)    //Il carattere un operatore:
  342.                 {      
  343.                         chkop++;                //Controlla se vi un operatore            
  344.                         result = numbers.top();
  345.                         numbers.pop();
  346.                         if (numbers.empty())       //se c' un operatore all'inizio, come se ci fosse lo 0 (es.-6=0-6)
  347.                         {                       //pertanto aggiungo lo 0
  348.                                 numbers.push(0.0);
  349.                         }
  350.                         /*****OPERATORS****************************************/
  351.                         switch(rpn[h])
  352.                         {
  353.                                 case '+':
  354.                                         result = numbers.top() + result ;
  355.                                 break;
  356.                                 case '-':
  357.                                         result = numbers.top() - result ;
  358.                                 break;
  359.                                 case '*':
  360.                                         result = numbers.top() * result ;
  361.                                 break;
  362.                                 case '/':
  363.                                         result = numbers.top() / result ;
  364.                                 break;
  365.                                 case '^':
  366.                                         result = pow(numbers.top() , result) ;
  367.                                 break;
  368.                                 case '%'://Operatore modulo
  369.                                         if (((int) numbers.top()!=0)&&((int) result!=0))
  370.                                         result =int(numbers.top()) % int(result) ;
  371.                                 break;
  372.                         }
  373.                         numbers.pop();
  374.                         numbers.push(result);
  375.                 }
  376.                 if (chkfun(rpn[h])==1)                       //Se c' un carattere che corrisponde a una funzione:
  377.                 {
  378.                         /*La funzione 'Fun', dato un carattere
  379.                         *corrispondente a una funzione e un valore
  380.                         *float, ne calcola la funzione corrispondente.*/
  381.                         result=Fun(rpn[h],numbers.top());        //Fun dichiarata in 'funzioni.h'
  382.                         numbers.pop();
  383.                         numbers.push(result);
  384.                 }
  385.                 if (chkop==0)    //Se nell'espressione non vi alcun  operatore, allora vi deve essere un solo numero, perci lo si associa a result
  386.                 //infatti chkop si incrementa se il carattere un operatore(vedi sopra)
  387.                         result= numbers.top();
  388.         }
  389.        
  390.         return result;
  391. }
  392. //Calcola RPN
  393. string FoundRPN(char in[])
  394. {
  395. string rpn="";
  396. stack <char> operators;       //Dichiaro stack che conterr gli operatori:            
  397. /*****************************************************************************/
  398. //CONVERTO LA STRINGA IN NOTAZIONE INFISSA IN RPN
  399. int h=0;
  400. for (h=0;h<=99;h++)
  401. {
  402.                                                 /* Se il carattere e' un numero, questo viene aggiunto alla fine  
  403.                                         * della stringa di output. Se il prossimo carattere non e' un
  404.                                         * numero, viene aggiunto il simbolo di spazio per la migliore
  405.                                         * leggibilita' dell'espressione in output */
  406.                                         if (chkchar(in[h])==1)
  407.                                         {
  408.                                                         rpn+=in[h];
  409.  
  410.                                                 if ((!isdigit(in[h + 1]))&&(in[h+1]!='.')&&(in[h+1]!=','))
  411.                                                 {
  412.                                                         rpn+=" ";
  413.                                                 }
  414.                                                 if ((in[h+1]=='.')||(in[h+1]==','))
  415.                                                 {
  416.                                                         rpn+=".";
  417.                                                 }
  418.                                         }
  419.                                        
  420.                                         /* Il carattere letto e' un operatore.
  421.                                         *               Se lo stack per gli operatori e' vuoto o il carattere
  422.                                         * precedente era la parentesi aperta o l'operatore letto ha
  423.                                         * una precedenza minore rispetto a quella dell'operatore inserito
  424.                                         * prima, l'operatore letto viene inserito normalmente nello stack.
  425.                                         *               Altrimenti se l'operatore letto ha una precedenza maggiore
  426.                                         * rispetto a quella dell'operatore inserito prima, dallo stack
  427.                                         * viene tolto l'operatore con la precedenza maggiore e viene messo
  428.                                         * nella stringa di output. */
  429.                                         if (chkchar(in[h])==2)
  430.                                         {
  431.                                                 bool usc=false;
  432.                                                 while (usc==false)
  433.                                                 {
  434.                                                         if ((operators.empty())||(operators.top()=='(')||(precedence(in[h],operators.top())))
  435.                                                         {
  436.                                                                 if ((chkchar(in[h-1])==1)||(in[h-1]==')'))
  437.                                                                         operators.push(in[h]);
  438.                                                                 usc=true;
  439.                                                         }
  440.                                                         else if (!precedence(in[h], operators.top()))
  441.                                                         {
  442.  
  443.                                                                 rpn+=operators.top();
  444.                                                                 rpn +=" ";
  445.                                                                 operators.pop();
  446.                                                         }
  447.                                                 }
  448.                                         }
  449.                                         /* Se il carattere è la s, il successivo è la i e quello ancora è la n, allora c'è la funzione sin:  ecc.....
  450.                                         La funzione 'charfun': data una serie di tre caratteri, se corrispondono a una funzione, copia il carattere corrispondente
  451.                                         alla funzione nello stack*/
  452.                                         char chf=charfun(in[h],in[h+1],in[h+2]);
  453.                                         if (chf!=0)
  454.                                                 operators.push(chf);
  455.                                         /*              Se il carattere letto e' una parentesi aperta, questa viene
  456.                                         * messa nello stack.
  457.                                         *               Se e' una parentesi chiusa, vuol dire che tutti gli operatori
  458.                                         * rimasti nello stack fino alla parentesi aperta vanno copiati nella
  459.                                         * stringa di output. La parentesi aperta viene cancellata dallo stack
  460.                                         * e dopo si contunua a leggere la stringa di input */
  461.                                         if (in[h]=='(')
  462.                                         {
  463.                                                 operators.push(in[h]);
  464.                                         }
  465.                                         /*Se il carattere è il meno e precedentemente non vi è alcun valore, vuol dire che si intende
  466.                                         *il negartivo di un valore es:-5, allora sostituisco al '-' ---->  '0-'   */
  467.                                         if ((in[h]=='-')&&(chkchar(in[h-1])!=1))
  468.                                         {
  469.                                                         rpn+='0';
  470.                                                         rpn+=' ';
  471.                                                         operators.push('-');
  472.                                         }
  473.                                         if(in[h] == ')')
  474.                                         {
  475.                                                 while(operators.top() != '(')   //In pratica scorre nello stack verso sinistra copiando gli operatori incontrati.
  476.                                                 {
  477.                                                         rpn+=operators.top();
  478.                                                         rpn+=" ";
  479.                                                         operators.pop();
  480.                                                 }
  481.                                                 operators.pop();      //Cancella la parentesi aperta
  482.                                         }
  483. }
  484.                                 /* Tutti gli operatori rimasti nello stack vanno copiati nella
  485.                                         stringa di output e poi cancellati dallo stack */
  486.  
  487.                                 while(!operators.empty())
  488.                                 {
  489.                                         rpn+=operators.top();
  490.                                         rpn+=" ";
  491.                                         operators.pop();
  492.                 }
  493. //////////////////Eventuale break point per verificare rpn.
  494.                                 rpn+=" ";
  495.         return rpn;
  496. }