Newsgroup: it.comp.lang.c
Titolo: Chi me lo spiega ?

******************** if (valore[serie] % 2 =0) **********************
	{
	pari++;
	valore[serie]=vett_pari[pari];
	}
else
	{
	dispari++;
	valore[serie]=vett_disp[dispari];
	}
/* Stampa del risultato */
for (pari =0,dispari=0; pari<CICLO,dispari<CICLO;pari++,dispari++)
printf ("\n%f		%f",vett_pari[pari],vett_disp[dispari]);
}
Grazie a chiunque mi risponderà.
Big Pincer                    
 
-- 
 
http://www.geocities.com/soho/studios/7157
 
ICQ : 8972934
Please...                                   
Per rispondere in e-mail cancellate BOGAMI

>******************** if (valore[serie] % 2 =0) **********************
Non puoi fare il modulo di un float.
-- 
Simone

dunque... innanzi tutto ... dato che usi il pari e il dispari come
contatori, dichiararli e usarli float ti da' notevoli problemi... poi
ha dichiarato un float esose che pero' non usi... quindi e' inutile
- poi... siccome non ha senso parlare di numeri pari e dispari se questi
sono numeri decimali (2.5 non e' ne' pari ne' dispari, dato che non e'
divisibile esattamente per 2), l'operatore modulo agisce solo su valori
interi... questo implica che:
1) o casti il float dell'array da float a integer...
2) o senno' lavori con numeri interi
nella versione che ti ho rielaborato, il cast elimina la parte decimale, 
cosi' che 2.5 appaia come 2 e risulti quindi come pari e 3.754 appaia come
3 e quindi come dispari... pero' in linea di principio (dal punto di vista
puramente matematico) e' un errore
- poi... grave errore...
valore[serie]=vett_pari[pari]; 
e' errato... tu cosi' assegni al valore[serie] il valore del vettore 
pari... devi fare il contrario...senno' ti trovi con il vettore valore
vuotato...:)
- l'incremento del contatore pari o dispari deve essere fatto DOPO 
l'assegnazione... altrimenti ti ritrovi con il primo valore
di ogni array pari o dispari nella posizione [1] anziche' nella 
posizione [0] dell'array...
- non vorrei errare (puo' darsi mi sia scappata mentre facevo C&P) 
ma mancava una linea di if dopo il primo for della
valutazione dei dati...
- ultima cosa... nel print dei dati finali... ho messo lo \n alla fine
della stringa di formattazione... senno' su unix ti trovi ad avere il
prompt appiccicato all'ultima linea dei dati... decisamente brutto
questo il programma
-------------------------- CUT HERE ---------------------
#include <stdio.h>
#define CICLO 10
float valore[CICLO];
int pari,dispari;
float vettore[CICLO],vett_pari[CICLO],vett_disp[CICLO];
int serie;
main ()
{
/* Lettura dati in ingresso */
for (serie =0; serie<CICLO; serie++)
        {
        printf ("Inserisci il valore N. %d ",serie);
        scanf ("%f", &valore[serie]);
        }
/* valutazione dei dati */
pari=0;
dispari=0;
for (serie=0; serie<CICLO; serie++)
if ((int)valore[serie]%2==0) 
        {
        vett_pari[pari]=valore[serie];
        pari++;
        }
else
        {
        vett_disp[dispari]=valore[serie];
        dispari++;
        }
/* Stampa del risultato */
for (pari =0,dispari=0; pari<CICLO,dispari<CICLO;pari++,dispari++)
printf ("%f           %f\n",vett_pari[pari],vett_disp[dispari]);
}
-------------------------- CUT HERE -----------------------------
questo il risultato:
Inserisci il valore N. 0 1.24
Inserisci il valore N. 1 3.54
Inserisci il valore N. 2 1
Inserisci il valore N. 3 2.3
Inserisci il valore N. 4 -2
Inserisci il valore N. 5 1
Inserisci il valore N. 6 1
Inserisci il valore N. 7 2
Inserisci il valore N. 8 66
Inserisci il valore N. 9 5
2.300000           1.240000
-2.000000           3.540000
2.000000           1.000000
66.000000           1.000000
0.000000           1.000000
0.000000           5.000000
0.000000           0.000000
0.000000           0.000000
0.000000           0.000000
0.000000           0.000000
il C... brutta bestia...
---------------------------
quela:~# mount -t vfat /dev/hda1 /windows
mount: error mounting /dev/hda1... mmmh...It's full of rubbish !!
Try this instead:     mke2fs -c /dev/hda1 <block size>
It will work better !
---------------------------
                                          Stefano Borini

il C... brutta bestia...
Eh, già :))
Grazie ancora


...

Solo per completezza, visto che non e` necessariamente
applicabile al problema originale...:
puoi si` (trasformandolo implicitamente in double), ma non con
l'operatore %; devi invece usare la funzione standard
    double fmod(double x, double y)
che calcola e ritorna il valore (double) f tale che:
    x = i * y + f
con i intero, f dello stesso segno di x, e fabs(x)<fabs(y).
Alez

 invece si opera su dati interi ?
dunque... il fatto e' che non si usa mai un dato float per contatore, per
una semplice ragione... se tu prendi una calcolatrice e inizi a fare, ad
esempio, la radice di 2, poi il numero che ottieni ancora estrai la radice
e poi ancora e ancora... e ad un certo punto (quando hai un numero del
tipo 0.000000002 ada esempio) ricominci ad elevare al quadrato... la
matematica ti dice che dovresti ad un certo punto riottenere due... il
calcolo numerico no... questo perche' la tua calcolatrice non lavora con
cifre infinite, ma si limita a mostrarne al massimo 8 o 10 (ma
internamente lavora fino a 11-15, a seconda del modello) questo equivale a
dire che tutte le volte che tratti con un numero decimale illimitato
periodico o no, inevitabilmente commetti un errore dovuto al fatto che
oltre la 11-15 cifra puo' esserci qualcosa ma il tuo calcolatore la
trascura...questo implica che i calcoli successivi sono affetti da un
errore che, nel peggiore dei casi (problema mal condizionato) esplode fino
a produrre un risultato del tutto errato (anche di molto).
questo implica che, lavorando con dei float come contatori, puoi, a causa
del fatto che il computer e' in fondo una calcolatrice (e viceversa :) )
ottenere un dato del tipo count=13.999999999
se tu ora facessi un ciclo che termina per count == 14 ... l'uguaglianza
non sarebbe rispettata e il ciclo sarebbe infinito... dando problemi non
da poco... dovresti fare un controllo a meno di una tolleranza.. ma detto
tra noi ... sarebbe una pazzia...
per questo si opera con dati interi... i float e i double sono usati solo
ed esclusivamente se devi fare dei calcoli matematici (seno, coseno,
logaritmi... ecc...) 
per quanto riguarda il resto intero, essendo la divisione con modulo
basata essenzialmente sul fatto che si opera con dati interi (come alle
elementari si faceva la divisione con quoziente e resto) l'operatore
agisce su dati interi... e' l'operatore che e' definito cosi'. Opera su
dati interi e restituisce un resto intero... se fossimo in c++ potresti
fare un overload dell'operatore %, cioe' ridefinire lo stesso operatore in
modo che operi diversamente a seconda dei dati che gli dai in pasto.... ma
non chiedermi di piu' perche' lo sto studiando proprio ora il c++ e
probabilmente potrei dirti una cavolata...
divertiti...:) e se hai bisogno mailami pure...
				saluti
 
					Stefano Borini

Per rispondere in e-mail cancellate BOGAMI
Ciao. Non mastico il C da circa 8 mesi, ma ugualmente vorrei poterti
aiutare.
L'espressione che vuoi fare ha "tipi" differenti, in particolare usi
un floating point e due interi. 
Queste cose si possono fare usando l'operatore di "cast" ovvero
forzando la rappresentazione di un numero e uniformando cosi' il
cacolo dei tipi.
In pratica, fino a qui dovresti aver dovuto scrivere:
         if (valore[serie] % 2.0 =0)
Attenzione poi perche' un segno di uguale (=) cosi' da solo significa
l'assegnazione di un valore ad una variabile.  Per il controllo di
uguaglianza si usa ==
Inoltre controlla che l'operatore % (mod - resto intero della
divisione ) puo' applicarsi solo a due numeri interi, nel qual caso ti
suggerirei una soluzione niente affatto ottimale e brillante che e':
        if ((int)valore[serie] % 2 == 0) 
Non prendere per oro colato quanto ti dico, perche' sono fuori
esercizio da un po'.