Newsgroup: it.comp.lang.c
Titolo: aiuto su programmino

Sapreste dirmi dove sbaglio?
grazie
#include <stdio.h>
#include <math.h>
/* Calcola le soluzioni delle equazioni di secondo ordine */
main()
{
  double a, b, c;
  float x1, x2, d;
  printf("Introdurre il valore di a\n");
  scanf("%f", &a);
  printf("Introdurre il valore di b\n");
  scanf("%f", &b);
  printf("Introdurre il valore di c\n");
  scanf("%f", &c);
  if (b*b-4*a*c >=0)
   {
     x1 = (-b-(sqrt((b*b)-(4*a*c))))/(2*a);
     x2 = (-b+(sqrt((b*b)-(4*a*c))))/(2*a);
   }
  else
   {
     printf("\n x1= %f\n x2= %f", x1, x2);
   }
}
--
Per rispondere via e-mail togliere XX  dall'indirizzo
-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
Homepage:
httrp://
members.xoom.it/giacopiane

    }
Logica sbagliata: stampi il risultato se e solo se non e' possibile 
calcolarlo :P Metti quella printf nel ramo IF.
Nel ramo damo ELSE piuttosto metti un messaggio di errore.
Ci sono un paio di errori concettuali nel programma:
- non ha senso calcolarsi 2 volte il delta, fallo una volta sola e 
  memorizzalo
- se delta e' uguale a zero, non serve calcolare le 2 soluzioni, te ne basta 
  una
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

}
Se (b*b-4*a*c >=0), non stampi il risultato.
Se !(b*b-4*a*c >=0), il risultato non esiste, ma lo stampi.
by LjL
ljl...@tiscalinet.it

   una
Bisogna pero' anche ricordare che controllare l'uguaglianza
a zero di un numero in floating point e' una operazione mooolto
pericolosa, da evitare se non si sa esattamente cosa si sta facendo.
Per esempio:
if (100 * 0.018 - 2 * 0.9 == 0.0)
e' tipicamente falso, nonostante in teoria 100*0.18=2*0.9=1.8
nei casi pratici (algoritmi numerici) l'uguaglianza a zero
di una variabile x va controllata con un test del tipo
if (fabs(x)< Eps)
dove Eps e' costante floating point opportunamente piccola,
scelta assennatamente in base alla precisione di macchina
e ai calcoli che si stanno facendo.
ciao,
g.

 if (fabs(x)< Eps)
Ricordo che lo  standard mette a disposizione  FLT_EPSILON (float.h) che
rappresenta il piu` piccolo numero tale che 1.0 + FLT_EPSILON != 1.0.
Il confronto con zero puo` essere quindi fatto come:
if (fabs(x) < FLT_EPSILON)
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Se alla sera, dopo una strepitosa vittoria, guardandoti allo
specchio dovessi notare un secondo paio di palle, che il tuo 
cuore non si riempia d'orgoglio, perche` vuol dire che ti 
stanno inculando -- Saggio Cinese

 if (fabs(x) < FLT_EPSILON)
Se usi i double dovresti usare  DBL_EPSILON che ovviamente e' molto
piu' piccolo di FLT_EPSILON
Comunque
fare (fabs(x) < DBL_EPSILON) alla cieca e' comunque
pericoloso.
Per esempio, sulla mia macchina (gcc 2.95) l'errore commesso
su 100.0 * 0.018 - 2.0 * 0.9;
e' esattamente uguale DBL_EPSILON quindi casomai
bisognerebbe controllare  fabs(x) <= DBL_EPSILON.
Poi se hai piu' operazioni puoi avere piu' errore:
Quindi 100.0*(100 * 0.018 - 2 * 0.9) invece di essere 0
e' uguale a 100 volte DBL_EPSILON, pur rimanendo un valore
dell'ordine di 2.2 * 10^(-14) quindi in molti casi pratici
assimilabile a zero.
Per questo dicevo che il modo di controllare
se un double e' (quasi)zero dipende strettamente da quello
che uno ci vuol fare e da come e' stato prodotto il
numero.
(Abbiate pazienza per la pedanteria, ma e' saltato fuori
l'esercitatore di Analisi Numerica che era in me una decina di
anni fa...)
Ciao,
g.