Guest User

Algebra Polinomi

a guest
Feb 22nd, 2011
278
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3.  
  4. #ifdef NULL
  5. #   undef NULL
  6. #   define NULL (void *) 0
  7. #endif
  8.  
  9. //Struttura Monomio
  10. struct mono {
  11.     int grado, coef;
  12.     int flag; //Il campo flag sarà utile per eseguire le operazioni
  13.     struct mono *next;
  14. };
  15.  
  16. typedef struct mono MONO;
  17.  
  18. /*
  19. Le due variabili head e headres sono rispettivamente
  20. la testa della lista contenente i polinomi in ingresso
  21. e la testa della lista contenente il polinomio in uscita,
  22. dopo aver eseguito le operazioni. Dichiarate a livello globale.
  23. */
  24.  
  25. MONO* head;
  26. MONO* headres;
  27.  
  28. //Inizio scrittura funzioni.
  29.  
  30. void mostra(curr) //Scorre la lista per visualizzare il polinomio a schermo, monomio per monomio.
  31. MONO* curr;
  32. {
  33.    
  34.     for (curr = head; curr != NULL; curr = curr->next)
  35.     {
  36. /*I seguenti if annidati servono per visualizzare 0 al posto di, ad esempio, 0x^5
  37.   o 5 al posto di 5x^0
  38. */
  39.    
  40.     if (curr->grado == 0)
  41.         {
  42.         if (curr->coef !=0)
  43.             {
  44.             printf("%d\n", curr->coef);
  45.             printf("\n\n--------------------------------------\n\n");
  46.             }
  47.         else if (curr->coef == 0)
  48.             {
  49.             printf("0\n");
  50.             }
  51.         }
  52.     else if (curr->grado != 0)
  53.         {
  54.         if (curr->coef != 0)
  55.             {
  56.             printf("%dx^%d\n", curr->coef, curr->grado);
  57.             }
  58.         else if (curr->coef == 0)
  59.             {
  60.             printf("0");
  61.             }
  62.         }
  63.    
  64.     }
  65. }
  66. //La funzione mostraresult è praticamente uguale a mostra, solo che usa headres.
  67. void mostraresult(result)
  68. MONO *result;
  69. {
  70.    
  71.     for (result = headres; result != NULL; result = result->next)
  72.     {
  73.    
  74.     if (result->grado == 0)
  75.         {
  76.         if (result->coef != 0)
  77.             {
  78.             printf("%d flag = %d\n",result->coef, result->flag);
  79.             printf("\n\n--------------------------------------\n\n");
  80.             }
  81.         else if (result->coef == 0)
  82.             {
  83.             printf("0 flag = %d\n",result->flag);
  84.             }
  85.  
  86.         }
  87.     else if (result->grado != 0)
  88.         {
  89.         if (result->coef != 0)
  90.             {
  91.             printf("%dx^%d flag = %d\n", result->coef, result->grado, result->flag);
  92.             }
  93.         else if (result->coef == 0)
  94.             {
  95.             printf("0 flag = %d\n",result->flag);
  96.             }
  97.         }
  98.     }
  99. }
  100.  
  101. /* La funzione crea, costruisce la lista a partire dai dati in input inseriti dall'utente,
  102.    come coefficente e grado. Il termine noto è flaggato a 1, gli altri a 0.
  103.    Questo è utile per capire dove inizia e dove finisce un polinomio, essendo un'unica lista.
  104. */
  105. int crea(curr, np)
  106. MONO *curr;
  107. int np;
  108. {
  109. int i, j, max, polimax=0;
  110.     head = NULL;
  111.    
  112.     for (i=1; i<=np; i++)
  113.     {
  114.         printf("Inserire il grado massimo del polinomio %d:\n", i);
  115.         scanf("%d", &max);
  116.         if (polimax < max) //Trova il massimo grado inserito dall'utente.
  117.             polimax = max;
  118.         for(j=0; j<=max; j++)
  119.         {
  120.         if (j == 0) {
  121.         printf("Inserire il termine noto (Polinomio %d)\n", i);
  122.         curr = (MONO *)malloc(sizeof(MONO));
  123.         scanf("%d", &curr->coef);
  124.         curr->grado = 0;
  125.         curr->flag = 1;
  126.         curr->next  = head; //Scorre la lista.
  127.         head = curr;
  128.                 }
  129.         else {
  130.  
  131.         printf("Inserire il coefficente del termine x^%d (Polinomio %d)\n", j, i);
  132.         curr = (MONO *)malloc(sizeof(MONO));
  133.             scanf("%d", &curr->coef);
  134.         curr->grado = j;
  135.         curr->flag = 0;
  136.         curr->next  = head;
  137.         head = curr;
  138.              }
  139.         }
  140.     printf("Inserimento polinomio %d terminato.\n\n", i);
  141.    
  142.     }
  143.     return polimax; //Ritorna il massimo grado tra tutti i polinomi inseriti. Utile per somma e differenza.
  144. }
  145.  
  146. /* La funzione derivata esegue la derivata del polinomio, assegnando al coefficente il prodotto tra coefficente
  147. e grado e cala il grado di una unità. La stampa della derivata è inclusa nella funzione
  148. */
  149.  
  150. void derivata(curr)
  151. MONO* curr;
  152. {
  153.  
  154.     for (curr = head; curr != NULL; curr = curr->next)
  155.     {
  156.         curr->coef = curr->coef * curr->grado;
  157.         curr->grado--;
  158.         if (curr->grado > 0) //Così non viene stampato il termine noto, dopo l'operazione di derivazione.
  159.             printf("%dx^%d\n", curr->coef, curr->grado);
  160.                  
  161.         else if (curr->grado == 0)
  162.             printf("%d\n", curr->coef);
  163.    
  164.     }
  165.  
  166. }
  167.  
  168.    
  169. /*
  170. La funzione flagga è scritta appositamente per le operazioni di somma e differenza,
  171. in modo da sommare e sottrarre solo monomi con lo stesso flag.
  172. */
  173.  
  174. void flagga(curr, pmax)
  175. MONO* curr;
  176. int pmax;
  177. {
  178.     //Assegna a termini con gradi diversi, flag diversi.
  179.     int i;
  180.     for (i=0; i<=pmax; i++)
  181.     {
  182.         for (curr = head; curr != NULL; curr = curr->next)
  183.         {
  184.             if (curr->grado == i)
  185.                 curr->flag = i+1;
  186.         }
  187.     }
  188. }
  189.  
  190. /*
  191. flaggaprodotto assegna al flag di ogni monomio appartenente allo stesso polinomio
  192. un flag uguale. Così possiamo moltiplicare i polinomi senza problemi.
  193. */
  194. void flaggaprodotto(curr, pmax)
  195. MONO* curr;
  196. int pmax;
  197. {
  198.    
  199.     int i;
  200.     for (i=0; i<=pmax; i++)
  201.     {
  202.         for (curr = head; curr != NULL; curr = curr->next)
  203.         {
  204.             if (curr->flag == 1)
  205.             {
  206.                 curr->flag = i;
  207.                 curr = curr->next;
  208.                 curr->flag = i;
  209.             }
  210.                
  211.            
  212.                
  213.         }
  214.     }
  215. }
  216.  
  217. /*
  218. La funzione somma fa uso di due variabili temporanee: gradtemp e coeftemp.
  219. In coeftemp vengono salvate le somme dei monomi con lo stesso grado, mentre
  220. in gradtemp il grado dei monomi sommati in quel ciclo.
  221. Viene creata una nuova lista: polisomma.
  222. */
  223.  
  224. MONO* somma(curr, pmax)
  225. MONO* curr;
  226. int pmax;
  227. {
  228.    
  229.     int i, gradtemp=0, coeftemp=0;
  230.     MONO * polisomma;
  231.     headres = NULL;
  232.     for (i=1; i<=pmax+1; i++)
  233.     {
  234.         for (curr = head; curr != NULL; curr = curr->next)
  235.         {
  236.             if (curr->flag == i)
  237.                 {
  238.                     coeftemp = coeftemp + curr->coef;
  239.                     gradtemp = curr->grado;
  240.                 }
  241.         }
  242.     polisomma = (MONO *)malloc(sizeof(MONO));
  243.     polisomma->grado = gradtemp;
  244.     polisomma->coef = coeftemp;
  245.     polisomma->next  = headres;
  246.     headres = polisomma;
  247.     coeftemp = 0;
  248.     gradtemp = 0;
  249.     }
  250.     return polisomma;
  251.    
  252. }
  253.  
  254. /*Simile alla somma, cambia solo l'assegnazione di coeftemp e gradtemp.
  255. La funzione differenza sottrae al primo polinomio inserito tutti gli altri inseriti
  256. successivamente.
  257. */
  258. MONO* differenza(curr, pmax)
  259. MONO* curr;
  260. int pmax;
  261. {
  262.    
  263.     int i, gradtemp=0, coeftemp=0;
  264.     MONO * polidiff;
  265.     headres = NULL;
  266.     for (i=1; i<=pmax+1; i++)
  267.     {
  268.         for (curr = head; curr != NULL; curr = curr->next)
  269.         {
  270.             if (curr->flag == i)
  271.                 {
  272.                     coeftemp = curr->coef - coeftemp;
  273.                     gradtemp = curr->grado;
  274.                 }
  275.         }
  276.     polidiff = (MONO *)malloc(sizeof(MONO));
  277.     polidiff->grado = gradtemp;
  278.     polidiff->coef = coeftemp;
  279.     polidiff->next  = headres;
  280.     headres = polidiff;
  281.     coeftemp = 0;
  282.     gradtemp = 0;
  283.     }
  284.     return polidiff;
  285. }
  286.  
  287.  
  288. /*MONO* prodotto(curr, pmax)
  289. MONO* curr;
  290. int pmax;
  291. {
  292.    
  293.     int i, gradtemp=0, coeftemp=1;
  294.     MONO * polidiff;
  295.     headres = NULL;
  296.     for (i=1; i<=pmax+1; i++)
  297.     {
  298.         for (curr = head; curr != NULL; curr = curr->next)
  299.         {
  300.             if (curr->flag == i)
  301.                 {
  302.                     poliprod = (MONO *)malloc(sizeof(MONO)
  303.                     coeftemp = curr->coef * coeftemp;
  304.                     gradtemp = curr->grado + gradtemp;
  305.                 }
  306.         }
  307.     polidiff = (MONO *)malloc(sizeof(MONO));
  308.     polidiff->grado = gradtemp;
  309.     polidiff->coef = coeftemp;
  310.     polidiff->next  = headres;
  311.     headres = polidiff;
  312.     coeftemp = 0;
  313.     gradtemp = 0;
  314.     }
  315.     return polidiff;
  316. }
  317. */
  318.                
  319. // Funzione principale.
  320. main()
  321. {
  322.     MONO *curr, *risultato;
  323.     int np, pmax, op;
  324.     printf("\nAlgebra dei polinomi.\nInserire un solo polinomio per calcolarne la derivata.\nInserire più di un polinomio per calcolare somma o differenza o prodotto.\n\n");
  325.     printf("Inserire il numero di polinomi sui quali si vuole operare:\n");
  326.     scanf("%d", &np);
  327.     if (np > 0)
  328.     {
  329.         pmax = crea(curr,np);
  330.         printf("Hai inserito il/i seguente/i polinomio/i:\n\n");
  331.         mostra(curr);
  332.         if (np == 1)
  333.         {
  334.             printf("Hai inserito un solo polinomio. La derivata è:\n");
  335.             derivata(curr);
  336.         }
  337.         else if (np > 1)
  338.         {
  339.             flagga(curr, pmax);
  340.             printf("Hai inserito più polinomi. Digita 1 per la somma, 2 per la differenza o 3 per il prodotto:\n");
  341.             scanf("%d", &op);
  342.        
  343.             switch (op)
  344.             {
  345.                 case 1:
  346.                     printf("\nLa somma dei polinomi è:\n");
  347.                     risultato = somma(curr, pmax);
  348.                     mostraresult(risultato);
  349.                     break;
  350.                 case 2:
  351.                     printf("\nLa differenza tra il primo polinomio e il secondo (o i successivi inseriti) è:\n");
  352.                     risultato = differenza(curr, pmax);
  353.                     mostraresult(risultato);
  354.                     break;
  355.                 /*case 3:
  356.                     prodotto!!!!!!
  357.                     break;*/
  358.                 default:
  359.                     printf("Scelta non valida!\n");
  360.                     break;
  361.             }
  362.         }
  363.     }
  364.     else
  365.         printf("Hai inserito il numero di polinomi pari a 0 o negativo!\n");
  366.    
  367.     return 0;
  368. }
RAW Paste Data