View Full Version : FAR GIRARE UN PROGRAMMA IN C
ciao a tutti;
ho window vista e col blocco note ho scritto un programma in linguaggio C. Alla fine la pagina di blocco note l'ho salvata sul desktop col nome "program".
ora ho l'intenzione di far "girare" questo mio programma dal ms dos ma non so come fare.
se c'è qualcuno di gentile che potrà aiutarmi ne sarò molto grato.
ciao Marco
DanieleC88
16-10-2008, 23:38
Mi sa che hai le idee un po' confuse sul C... Prova a scaricare Code::Blocks e prova a compilare il programma... ;)
Ciao,
Linux è il sistema che piu si adatta alla programmazione C perchè unix è nativamente compatibile con questo linguaggio.
Soprattutto se devi imparare il C, linux è il posto migliore per iniziare.
||ElChE||88
17-10-2008, 02:36
Ciao,
Linux è il sistema che piu si adatta alla programmazione C perchè unix è nativamente compatibile con questo linguaggio.
Soprattutto se devi imparare il C, linux è il posto migliore per iniziare.
Dovrebbe cambiare sistema operativo per una cosa che è semplicissima da fare anche in Windows? :doh:
Quoto DanieleC88.
cdimauro
17-10-2008, 08:11
Ciao,
Linux è il sistema che piu si adatta alla programmazione C perchè unix è nativamente compatibile con questo linguaggio.
Soprattutto se devi imparare il C, linux è il posto migliore per iniziare.
wlog, lascia perdere. Sarai anche un buon matematico, ma l'informatica non è decisamente il tuo forte. :p
DanieleC88
17-10-2008, 15:02
Linux è il sistema che piu si adatta alla programmazione C perchè unix è nativamente compatibile con questo linguaggio.
Soprattutto se devi imparare il C, linux è il posto migliore per iniziare.
Non cambia molto in realtà, se si attiene allo standard del linguaggio può programmare perfettamente nello stesso modo sia sotto Linux che sotto Windows. Certo, con una tipica installazione di Linux si ritroverebbe praticamente tutti gli strumenti necessari già pronti, ma se deve installare un sistema operativo per imparare un linguaggio non ne vale la pena... :)
se sei in ambiente windows, devi trovarti un compilatore, o meglio un IDE, con cui compilare linkare ed eseguire i progammi, in alternativa, puoi trovare compilatori a riga di comando, ed eseguire i programmi sotto il prompt di dos
Ciao,
Linux è il sistema che piu si adatta alla programmazione C perchè unix è nativamente compatibile con questo linguaggio.
Soprattutto se devi imparare il C, linux è il posto migliore per iniziare.
:rotfl:
ormai sto forum lo frequento più per farmi due risate che altro :D
Io ho iniziato con il compilatore di Borland. Ma credo che sia a pagamento :p
Prova a fare una ricerca su google su compilatori C o C++ gratuiti sotto windows.
Io ho iniziato con il compilatore di Borland. Ma credo che sia a pagamento :p
Prova a fare una ricerca su google su compilatori C o C++ gratuiti sotto windows.
:fagiano:
http://www.microsoft.com/downloads/details.aspx?FamilyID=e6e1c3df-a74f-4207-8586-711ebe331cdc&DisplayLang=en
variabilepippo
17-10-2008, 20:09
Soprattutto se devi imparare il C, linux è il posto migliore per iniziare.
E perché?! Il linguaggio C è relativamente indipendente dal sistema operativo e su Windows esistono molti più compilatori/debugger/IDE di quanti ne esistano per Linux. :muro:
soly
ciao a tutti;
ho window vista e col blocco note ho scritto un programma in linguaggio C. Alla fine la pagina di blocco note l'ho salvata sul desktop col nome "program".
ora ho l'intenzione di far "girare" questo mio programma dal ms dos ma non so come fare.
se c'è qualcuno di gentile che potrà aiutarmi ne sarò molto grato.
ciao Marco
Scarica un compilatore, un IDE, usando google e...compila :D
Mattyfog
17-10-2008, 20:30
quoto daniele c88
E perché?! Il linguaggio C è relativamente indipendente dal sistema operativo e su Windows esistono molti più compilatori/debugger/IDE di quanti ne esistano per Linux. :muro:
:confused: il java è portabile, e può essere scritto una sola volta per farlo girare su tutte le piattaforme che supportano la jvm, ma il C è molto dipendente dal s.o. utilizzato, basta vedere istruzioni del tipo:
clrscr();
valide per ambiente Windows, ma incompatibili in ambiente Unix
a parte questo, non importa l'SO ch utilizzi, il C lo puoi imparare lo stesso :)
variabilepippo
18-10-2008, 09:28
Con "indipendente" non intendevo portabile o non portabile, ma mi riferivo al fatto che il C puoi usarlo in Windows, in Linux, su microprocessori e su una miriade di sistemi operativi (molti più di quelli che supportano una JVM, peraltro). In parole povere si può studiare il C tranquillamente su Windows, dunque senza dover cambiare sistema operativo come suggerito da qualcuno...
può essere scritto una sola volta per farlo girare su tutte le piattaforme che supportano la jvm
Ciò vale per un "Hello World", forse... :)
Ciò vale per un "Hello World", forse... :)
perché dici questo? il java è multipiatta proprio per quello, certo, sono un n00b, ma credo di aver capito che sia portabile, ovviamente nei limiti della jvm, se è buggata non ci puoi fare nulla
variabilepippo
18-10-2008, 09:50
perché dici questo?
Perché la JVM di riferimento (Sun) esiste solo per Windows, Linux, Solaris, OS X, per tutti gli altri sistemi operativi devi usare implementazioni: non ufficiali, limitate, incompatibili, inaffidabili, incomplete, etc. Su Wikipedia puoi leggere "Di conseguenza, le diverse JVM non sono totalmente compatibili tra loro ed occorre fare attenzione nello scrivere i programmi, se si vuole che essi funzionino su ogni JVM", senza considerare che possono sorgere problemi di compatibilità tra versioni differenti della stessa JVM o tra JVM che girano su sistemi operativi differenti. Inoltre, nello sviluppo di programmi non banali, può capitare che sia necessario ricorrere a codice nativo e quindi la "portabilità totale ed automatica" va a donne di facili costumi...
Perché la JVM di riferimento (Sun) esiste solo per Windows, Linux, Solaris, OS X, per tutti gli altri sistemi operativi devi usare implementazioni: non ufficiali, limitate, incompatibili, inaffidabili, incomplete, etc. Su Wikipedia puoi leggere "Di conseguenza, le diverse JVM non sono totalmente compatibili tra loro ed occorre fare attenzione nello scrivere i programmi, se si vuole che essi funzionino su ogni JVM", senza considerare che possono sorgere problemi di compatibilità tra versioni differenti della stessa JVM o tra JVM che girano su sistemi operativi differenti. Inoltre, nello sviluppo di programmi non banali, può capitare che sia necessario ricorrere a codice nativo e quindi la "portabilità totale ed automatica" va a donne di facili costumi...
e anche il Java mi è calato :D
variabilepippo
18-10-2008, 09:58
e anche il Java mi è calato
Java non è assolutamente da buttare, ma pensare che qualsiasi programma sia portabile al 100% su qualsiasi piattaforma solo perché sia stato sviluppato in Java equivale a credere in un mito. Bisogna prendere le opportune precauzioni e provvedere ai rimedi del caso, di sicuro meno di quelli necessari ad uno sviluppatore C/C++ per ottenere la portabilità del codice, ma comunque non trascurabili al crescere della complessità dell'applicazione...
E perché?! Il linguaggio C è relativamente indipendente dal sistema operativo e su Windows esistono molti più compilatori/debugger/IDE di quanti ne esistano per Linux. :muro:
provate a calcolare:
(1-(1+x))/x
per x molto piccoli. Windows vi darà dei risultati a caso.
Poi windows mette le mani sulla memoria, e a me questo non va.
provate a calcolare:
(1-(1+x))/x
per x molto piccoli. Windows vi darà dei risultati a caso.
Poi windows mette le mani sulla memoria, e a me questo non va.
#include<iostream>
using namespace std;
int main() {
double x=0.5,ris;
ris=(1-(1+x))/x;
cout<<ris;
cin.get();
return 0;
}
OUTPUT
-1
a me sembra vada bene
a me sembra vada bene
per molto piccoli intendo vicino all'epsilon macchina. 0.5 è decine di ordini di grandezza piu grande, cioè è GIGANTE.
using namespace std;
cout<<ris;
cin.get();
a cosa servono ste righe?
per molto piccoli intendo vicino all'epsilon macchina. 0.5 è decine di ordini di grandezza piu grande, cioè è GIGANTE.
non hai specificato, ho improvvisato :D
non hai specificato, ho improvvisato :D
ehhehe non ti preoccupare.
Fattostà che sotto linux con gcc quella espressione rispetta l'esatto numero di cifre decimali, mentre sotto windows può darti il risultato che più gli sta simpatico.
Sembra una banalità, ma è comune su molti manuali questo esempio per dimostrare che si possono far divergere metodi numerici che in realtà convergerebbero sotto linux.
:rotfl:
ormai sto forum lo frequento più per farmi due risate che altro :D
ehehehh si in effetti se non devi fare nessun programma serio non la noti la differenza :)
ehhehe non ti preoccupare.
Fattostà che sotto linux con gcc quella espressione rispetta l'esatto numero di cifre decimali, mentre sotto windows può darti il risultato che più gli sta simpatico.
Sembra una banalità, ma è comune su molti manuali questo esempio per dimostrare che si possono far divergere metodi numerici che in realtà convergerebbero sotto linux.
le solide fondamenta UNIX non sono fragili come quelle del DOS :fuck: Microsozz Winsozz :D
provate a calcolare:
(1-(1+x))/x
per x molto piccoli. Windows vi darà dei risultati a caso. non c'è bisogno di calcolarlo, fa -1 :rolleyes:
Poi windows mette le mani sulla memoria, e a me questo non va. CHE??? :D
a cosa servono ste righe?
ehehehh si in effetti se non devi fare nessun programma serio non la noti la differenza :)
ignoranza e fanboysmo: ti commenti da solo :asd:
PS: ma tu credi che un programma chiami delle API per fare dei calcoli in virgola mobile, e per questo attribuisci al sistema operativo la colpa dei risultati inesatti? :D
le solide fondamenta UNIX non sono fragili come quelle del DOS :fuck: Microsozz Winsozz :D non capisco se questa è una frase ironica :mbe:
non capisco se questa è una frase ironica :mbe:
è solo la verità, però è inutile che ti spieghi il perché, mi basta vedere il tuo avatar per capire che difenderai a ogni costo Windows :D
non c'è bisogno di calcolarlo, fa -1 :rolleyes:
tu lo sai perchè fai i calcoli in modo simbolico. Secondo questo ragionamento allora smettiamo di usare i calcolatori, e limitiamoci a carta, penna e abaco!
Ti faccio un esempio pratico:
[(e^x+y'(y''+1)/y''']^p
E' una equazione differenziale in un intorno di 0. Ti sfido io a vedere ad occhio che fa 1.
La prassi la vorrebbe elevare a potenza p per calcolarne la convergenza (rappresenta anche una matrice nello spazio delle forme differenziali).
Nella realtà converge a 0 con il metodo delle minime differenze.
Sotto linux converge a 0.
Sotto windows diverge.
CHE??? :D
Voglio avere un numero casuale, dipendendente dalla funzione di stato del sistema, che non sia generato dalla funzione di sistema, perchè ho scoperto che si può calcolare l'output della funzione random usando un Linear feedback shift register: è un caso veramente successo alla fine degli anni 80-inizio 90, infatti nuovi metodi matematici permisero di scoprire che alcune funzioni random in realtà potevano essere previste conoscendo un numero finito di output.
Sotto linux dichiaro una variabile e la leggo senza inizializzarla.
Sotto windows sono fottuto, non posso avere accesso ad una funzione casuale senza scrivermela da solo (e nessuno in questo forum è in grado di farlo).
a cosa servono ste righe?
scusate se rispondo adesso, ma non mi ero accorto della modifica:
using namespace std;
serve per includere l'header iostream, da quando sono stati introdotti i namespace, gli header hanno perso l'estensione .h, e il nome delle principali librerie c++ è std;
cout<<ris;
serve per stapare a schermo il risultato, altrimenti come controllo se funziona?
cin.get();
serve per non far chiudere la finestra, prima di aver letto, cioé si chiude dopo aver premuto un tasto
ignoranza e fanboysmo: ti commenti da solo :asd:
ehheeh, no l'ho dovuto imparare a forza quando ho provato a scrivere del codice per una macchina (il piu potente supercomputer italiano, il CINECA) e ho visto che i risultati andavano a puttane.
PS: ma tu credi che un programma chiami delle API per fare dei calcoli in virgola mobile, e per questo attribuisci al sistema operativo la colpa dei risultati inesatti? :D
Io non so perchè succeda, posso fornirti degli esempi numerici però in cui succede che windows stupri i dati.
scusate se rispondo adesso, ma non mi ero accorto della modifica:
using namespace std;
serve per includere l'header iostream, da quando sono stati introdotti i namespace, gli header hanno perso l'estensione .h, e il nome delle principali librerie c++ è std;
cout<<ris;
serve per stapare a schermo il risultato, altrimenti come controllo se funziona?
cin.get();
serve per non far chiudere la finestra, prima di aver letto, cioé si chiude dopo aver premuto un tasto
azz io allora mi sa che programmo il C vecchio!
#include <stdio.h>
int main() {
double x=0.000000005,ris;
ris=(1-(1+x))/x;
printf("%.16f \n", ris);
return 0;
}
per la finestra, lanciando io da terminale, rimane automaticamente aperta.
Dove trovo un manuale che mi permetta di aggiornarmi alle nuove procedure di C?
azz io allora mi sa che programmo il C vecchio!
#include <stdio.h>
int main() {
double x=0.000000005,ris;
ris=(1-(1+x))/x;
printf("%.16f \n", ris);
return 0;
}
per la finestra, lanciando io da terminale, rimane automaticamente aperta.
Dove trovo un manuale che mi permetta di aggiornarmi alle nuove procedure di C?
io purtroppo, finché non mi compro un pc mio, devo usare winsozz, e ameno che non lavoro col prompt di dos, la finestra si chiude da sola.
per il manuale, posso dirti che qui:
http://www.cplusplus.com/reference/
trovi tutto quello che c'è da sapere sul c++: metodi, librerie etc., se cerchi un manuale in italiano che spieghi i passaggi da C al C++, non conosco nulla io
ehheeh, no l'ho dovuto imparare a forza quando ho provato a scrivere del codice per una macchina (il piu potente supercomputer italiano, il CINECA) e ho visto che i risultati andavano a puttane. :blah:
sempre colpa di Windows, mai colpa dei propri programmi che chissà che razza di bug contenevano, oh no :rolleyes:
pur di non ammettere la fallacia dei propri "capolavori" darebbero colpa al sistema operativo, che in quel caso non interviene per nulla :asd:
Io non so perchè succeda, posso fornirti degli esempi numerici però in cui succede che windows stupri i dati. non mi servono: ho compilato ed eseguito il tuo inutilissimo capolavoro (inutilissimo perché non c'è bisogno di fare calcoli per sapere che quell'espressione fa -1 :fagiano: ) sia su Windows che su Linux e indovina un po' che viene? :rolleyes:
azz io allora mi sa che programmo il C vecchio! eh si, adesso è da un po' che c'hanno aggiunto due + davanti :fagiano:
io purtroppo, finché non mi compro un pc mio, devo usare winsozz, e ameno che non lavoro col prompt di dos, la finestra si chiude da sola.
per il manuale, posso dirti che qui:
http://www.cplusplus.com/reference/
trovi tutto quello che c'è da sapere sul c++: metodi, librerie etc., se cerchi un manuale in italiano che spieghi i passaggi da C al C++, non conosco nulla io
Scusami forse ci siamo intesi male: ma il codice di prima era c++ o c?
Perchè a me il c++ non interessa, però se hanno aggiornato il c son cazzi!
:blah:
sempre colpa di Windows, mai colpa dei propri programmi che chissà che razza di bug contenevano, oh no :rolleyes:
pur di non ammettere la fallacia dei propri "capolavori" darebbero colpa al sistema operativo, che in quel caso non interviene per nulla :asd:
Ti ho già dato l'esempio teorico in cui Windows sbaglia. Ti ho dato DUE esempi pratici.
Cosa vuoi di piu???
non mi servono: ho compilato ed eseguito il tuo inutilissimo capolavoro (inutilissimo perché non c'è bisogno di fare calcoli per sapere che quell'espressione fa -1 :fagiano: ) sia su Windows che su Linux e indovina un po' che viene? :rolleyes:
Ma non capisci? E' un esempio teorico per farti capire che windows sbaglia!
Comunque se l'hai fatto giusto, cioè hai messo l'errore vicino all'epsilon macchina, allora il computer sbaglia risultato.
eh si, adesso è da un po' che c'hanno aggiunto due + davanti :fagiano:
Tienitelo pure il c++, io mi tengo il mio c che è piu performante.
Metterci 7 giorni per una simulazione, o metterne 6 fa una bella differenza! Per di piu i bindings MPI funzionano meglio su C!
ho ripreso i miei vecchi appunti di laboratorio di calcolo numerico: A fare la differenza sono le implementazioni delle approssimazioni secondo IEEE. Sotto linux sono piu rigorose.
Comunque se l'hai fatto giusto, cioè hai messo l'errore vicino all'epsilon macchina, allora il computer sbaglia risultato.
Mi sembra molto strano.
Il problema potrebbe derivare dall'usare Windows a 32 bit e Linux a 64 bit o qualcosa di simile. Può essere?
wlog
Scusami forse ci siamo intesi male: ma il codice di prima era c++ o c?
Perchè a me il c++ non interessa, però se hanno aggiornato il c son cazzi!
Dubito si aggiorni un linguaggio. Casomai ne creano uno nuovo basato su quelle fondamenta!
Comunque quello era C++ non C
variabilepippo
18-10-2008, 12:19
Ti ho già dato l'esempio teorico in cui Windows sbaglia. Ti ho dato DUE esempi pratici.
Cosa vuoi di piu???
Ma non capisci? E' un esempio teorico per farti capire che windows sbaglia!
Comunque se l'hai fatto giusto, cioè hai messo l'errore vicino all'epsilon macchina, allora il computer sbaglia risultato.
Prima di fare affermazioni tanto strampalate dovresti chiarirti le idee su quali siano i compiti (e dunque i possibili errori) del programmatore, quelli del compilatore e quelli del sistema operativo. :muro:
Mi sembra molto strano.
Il problema potrebbe derivare dall'usare Windows a 32 bit e Linux a 64 bit o qualcosa di simile. Può essere?
No, TI spiego grosso modo il problema:
I numeri reali ovviamente sono infiniti per qualsiasi intorno sferico di raggio > 0, in particolare R ha infiniti numeri, mentre gli FP32 sono finiti. Si possono decidere vari modi di rappresentare gli FP32, ma quello standard è una rappresentazione "spalmata". Preso un numero R, e detta dR la sua variazione infinitesimale rappresentante l'errore di rappresentazione, si cerca di conservare ||dR||/||R|| piu piccolo possibile, invece del semplice ||dR||. Questo vuol dire che tra 0 e 1 ci sono piu FP che tra 1 e 2.
quindi 1+1/3 darà un risultato diverso di 4/3 (anche se di pochissimo, per vedere una reale differenza dovete usare numeri molto grandi rispetto a numeri molto piccoli).
Per arginare questo problema si sono scelti due diversi approcci: uno "informatico" che argina poco o nulla il problema ma è molto facile da implementare, ed è quello usato da Win, e uno inventato dai fisici che è piu difficile da implementare ma rappresenta i numeri con l'esatto numero di cifre decimali esatte e tratta meglio l'errore.
La differenza fondamentale credo risieda nel fatto che mentre l'approccio informatico esegue operazione per operazione, l'approccio fisico mantiene una visuale piu grande su tutta l'espressione. Ma non sono sicuro perchè il corso lo feci 2 anni fa.
Passare da 32 a 64 bit vuol dire che l'epsilon sarà piu piccolo, ma l'errore c'è comunque.
Dubito si aggiorni un linguaggio. Casomai ne creano uno nuovo basato su quelle fondamenta!
Comunque quello era C++ non C
Beh ad esempio C l'hanno aggiornato piu volte:
A) A scuola il compilatore non mi permette di dichiarare la variabile di inizializzazione dentro al for, a casa si.
for (int i=0 ....
invece di
int i;
for (i=0 ...
B) A casa il compilatore conosce già alcuni valori, come ad esempio PI oppure e ... A scuola no
Prima di fare affermazioni tanto strampalate dovresti chiarirti le idee su quali siano i compiti (e dunque i possibili errori) del programmatore, quelli del compilatore e quelli del sistema operativo. :muro:
Beh magari potresti illuminarmi tu, lo ammetto io stesso che di informatica ne so poco.
Non so il perchè di preciso, ma windows stupra i miei FP, linux no.
Windows stupra anche le mie variabili non inizializzate, linux no.
Un altro esempio per i miscredenti: Metodo di montecarlo per simulare Pi.
Prendi un quadrato di lato 1, iscrivi un quarto di circonferenza (centro in 0.0, estremi in 1.0 e 0.1) e spara una serie di numeri casuali uniformemenete distribuiti tra 0.0 e 1.1. Conta quanti numeri risiedono nel cerchio, e dividili per il numero totale di numeri generati, il rapporto tende a pi/4 per il crescere dei numeri provati.
Esempio in matlab (da convetire in c, adesso non ho voglia):
inside=0;
iter = 10000; %inserire qui il numero di iterazioni
a=[0:0.01:pi/2];
plot(cos(a), sin(a));
axis equal
hold on
grid on
for i=0:iter
x=random('unif', 0, 1, [1 2]);
if ( x*x' <= 1 )
plot(x(1), x(2), '.r');
inside=inside+1;
else
plot(x(1), x(2), '.g');
end
end
pi/4-(inside/iter)
provare per credere, linux converge linearmente invece che sublinearmente come windows.
No, TI spiego grosso modo il problema:
I numeri reali ovviamente sono infiniti per qualsiasi intorno sferico di raggio > 0, in particolare R ha infiniti numeri, mentre gli FP32 sono finiti. Si possono decidere vari modi di rappresentare gli FP32, ma quello standard è una rappresentazione "spalmata". Preso un numero R, e detta dR la sua variazione infinitesimale rappresentante l'errore di rappresentazione, si cerca di conservare ||dR||/||R|| piu piccolo possibile, invece del semplice ||dR||. Questo vuol dire che tra 0 e 1 ci sono piu FP che tra 1 e 2.
quindi 1+1/3 darà un risultato diverso di 4/3 (anche se di pochissimo, per vedere una reale differenza dovete usare numeri molto grandi rispetto a numeri molto piccoli).
Per arginare questo problema si sono scelti due diversi approcci: uno "informatico" che argina poco o nulla il problema ma è molto facile da implementare, ed è quello usato da Win, e uno inventato dai fisici che è piu difficile da implementare ma rappresenta i numeri con l'esatto numero di cifre decimali esatte e tratta meglio l'errore.
La differenza fondamentale credo risieda nel fatto che mentre l'approccio informatico esegue operazione per operazione, l'approccio fisico mantiene una visuale piu grande su tutta l'espressione. Ma non sono sicuro perchè il corso lo feci 2 anni fa.
Passare da 32 a 64 bit vuol dire che l'epsilon sarà piu piccolo, ma l'errore c'è comunque.
Ma la rappresentazione dei numeri floating point dipende dall'hardware, non dall'OS!
Che compilatori usi sotto linux? E con windows?
variabilepippo
18-10-2008, 12:56
Non so il perchè di preciso, ma windows stupra i miei FP, linux no.
Windows stupra anche le mie variabili non inizializzate, linux no.
Windows e Linux sono sistemi operativi dunque si "limitano" ad eseguire su una data architettura ciò che il programmatore ha scritto ed il compilatore ha poi tradotto in codice macchina.
Se il programmatore usa un linguaggio low-level come il C senza conoscerne le peculiarità e magari usa compilatori differenti per generare l'eseguibile non può poi prendersela con Windows/Linux se i risultati non sono quelli attesi...
Beh ad esempio C l'hanno aggiornato piu volte:
A) A scuola il compilatore non mi permette di dichiarare la variabile di inizializzazione dentro al for, a casa si.
for (int i=0 ....
invece di
int i;
for (i=0 ...
B) A casa il compilatore conosce già alcuni valori, come ad esempio PI oppure e ... A scuola no
Il compilatore che usi a scuola è per lo standard ANSI C, quello che hai a casa probabilmente è per il C99.
Ma la rappresentazione dei numeri floating point dipende dall'hardware, non dall'OS!
Che compilatori usi sotto linux? E con windows?
Sotto linux uso gcc, sotto win non lo so, è a scuola al momento. Lunedi ti posso dire.
Windows e Linux sono sistemi operativi dunque si "limitano" ad eseguire su una data architettura ciò che il programmatore ha scritto ed il compilatore ha poi tradotto in codice macchina.
Se il programmatore usa un linguaggio low-level come il C senza conoscerne le peculiarità e magari usa compilatori differenti per generare l'eseguibile non può poi prendersela con Windows/Linux se i risultati non sono quelli attesi...
ma quindi la peculiarità di windows è sbagliare i calcoli?
Giuro non capisco.
variabilepippo
18-10-2008, 13:13
ma quindi la peculiarità di windows è sbagliare i calcoli?
Ma riesci a capire ciò che viene scritto?!
Tutti ti stanno dicendo che Windows (come Linux) non fa altro che agire da tramite tra il codice (scritto dal programmatore e compilato da un compilatore) e l'hardware che lo eseguirà.
Il problema non è il sistema operativo, ma ciò che gli viene "passato". Prima di assumere che sia l'incolpevole sistema operativo a commettere errori dovresti valutare le tue conoscenze e considerare che poche conoscenze implicano tanti errori. :rolleyes:
Ma riesci a capire ciò che viene scritto?!
Tutti ti stanno dicendo che Windows (come Linux) non fa altro che agire da tramite tra il codice (scritto dal programmatore e compilato da un compilatore) e l'hardware che lo eseguirà.
Il problema non è il sistema operativo, ma ciò che gli viene "passato". Prima di assumere che sia l'incolpevole sistema operativo a commettere errori dovresti valutare le tue conoscenze e considerare che poche conoscenze implicano tanti errori. :rolleyes:
Secondo me c'entra ma mo mando una mail al mio prof cosi mi potrà dare delucidazioni.
Comunque gcc non esiste per windows quindi compilare sotto Win darà di sicuro problemi.
E poi non è vero che il sistema operativo non c'entra nulla:
Metti che uno debba fare 2/3+1/3. Una implementazione intelligente farà (2+1)/3 riducendo gli errori.
Quella cosa di inizializzare le variabili non è una diretta conseguenza di usare windows?
variabilepippo
18-10-2008, 13:23
Comunque gcc non esiste per windows quindi compilare sotto Win darà di sicuro problemi.
Ne esistono diversi porting: MinGW e l'implementazione fornita in CygWin su tutti.
E poi non è vero che il sistema operativo non c'entra nulla:
Metti che uno debba fare 2/3+1/3. Una implementazione intelligente farà (2+1)/3 riducendo gli errori.
Ma cosa stai dicendo!? Quella che tu chiami "implementazione intelligente" non è altro che una possibile ottimizzazione del compilatore, non del sistema operativo che ha ben altre cose a cui pensare!
Quella cosa di inizializzare le variabili non è una diretta conseguenza di usare windows?
Un sistema operativo non sa (e non deve sapere) cos'è una variabile, le variabili inizializzate o meno esistono per i programmatori e per i compilatori.
Secondo me c'entra ma mo mando una mail al mio prof cosi mi potrà dare delucidazioni.
Comunque gcc non esiste per windows quindi compilare sotto Win darà di sicuro problemi.
Volendo c'è un suo porting, in minGW
E poi non è vero che il sistema operativo non c'entra nulla:
Metti che uno debba fare 2/3+1/3. Una implementazione intelligente farà (2+1)/3 riducendo gli errori.
Questo non è assolutamente compito del sistema operativo. Se l'operazione è codificata completamente il compilatore può fare qualcosa, se invece è eseguita a runtime non credo che ci sia nulla che faccia una cosa simile.
Ne esistono diversi porting: MinGW e l'implementazione fornita in CygWin su tutti.
Si in uni usiamo quello, ma l'errore persiste.
Si in uni usiamo quello, ma l'errore persiste.
Potrei vedere il codice C (Non matlab) che causa l'errore?
Potrei vedere il codice C (Non matlab) che causa l'errore?
sicuro! Dai miei appunti:
#include <stdio.h>
int main() {
double x=thc, ris;
ris=(1-(1+x))/x;
printf("%.16f \n", ris);
return 0;
}
Al posto di thc (The Hideous Costant) devi mettere la metà del piu piccolo float rappresentabile, che non mi ricordo adesso quanto valga, per ottenere inf NaN o 0 invece di 1.
wlog
Beh ad esempio C l'hanno aggiornato piu volte:
A) A scuola il compilatore non mi permette di dichiarare la variabile di inizializzazione dentro al for, a casa si.
Codice:
for (int i=0 ....
invece di
Codice:
int i;
for (i=0 ...
B) A casa il compilatore conosce già alcuni valori, come ad esempio PI oppure e ... A scuola no
Questi comunque sia credo non si chiamino aggiornamenti, ma bensì librerie che sono o meno implementate nel copilatore o nel sistema operativo che stai utilizzando. Pure io nel mio pc non devo aggiungere la "stdlib.h" per aggiungere il codice system ("pause") mentre all'uni è necessario.
variabilepippo
Windows e Linux sono sistemi operativi dunque si "limitano" ad eseguire su una data architettura ciò che il programmatore ha scritto ed il compilatore ha poi tradotto in codice macchina.
Se il programmatore usa un linguaggio low-level come il C senza conoscerne le peculiarità e magari usa compilatori differenti per generare l'eseguibile non può poi prendersela con Windows/Linux se i risultati non sono quelli attesi...
Quoto quanto detto. Il sistema operativo non centra nulla o quasi. Conta l'architettura del calcolatore sul quale stai lavorando!
wlog
Comunque gcc non esiste per windows quindi compilare sotto Win darà di sicuro problemi.
mmm...cazzate! :D
khelidan1980
18-10-2008, 13:45
Tienitelo pure il c++, io mi tengo il mio c che è piu performante.
Metterci 7 giorni per una simulazione, o metterne 6 fa una bella differenza! Per di piu i bindings MPI funzionano meglio su C!
Quello è C++,a livello di performance non cambia niente C++ è un superset del C e probabilmente i tuoi bindings funzioneranno uguale
DanieleC88
18-10-2008, 13:58
il C è molto dipendente dal s.o. utilizzato, basta vedere istruzioni del tipo:
clrscr();
valide per ambiente Windows, ma incompatibili in ambiente Unix
E ti sembra un'istruzione standard quella? :D
DanieleC88
18-10-2008, 13:59
è solo la verità, però è inutile che ti spieghi il perché, mi basta vedere il tuo avatar per capire che difenderai a ogni costo Windows :D
Guarda che da Windows 2000 in poi non ha senso parlare di DOS... :O
DanieleC88
18-10-2008, 14:14
E poi non è vero che il sistema operativo non c'entra nulla:
Metti che uno debba fare 2/3+1/3. Una implementazione intelligente farà (2+1)/3 riducendo gli errori.
E invece è proprio vero, non c'entra nulla. Il sistema operativo al massimo si occuperà di ripartire in modo intelligente i tempi di esecuzione tra i vari processi, ma non si metterà certo ad intercettare operazioni matematiche. Quando il tuo processo fa qualche calcolo, sappi che è lui ed esclusivamente lui ad approfittare della tua CPU. Il sistema operativo non ha nemmeno bisogno di sapere cosa stia facendo il tuo programma. Al massimo dipende dal compilatore. ;)
Mezzetti0903
18-10-2008, 14:15
Scusatemi...allora
i conti li fa la macchina quindi se tu ottieni dei risultati diversi a parità di algoritmo dipende dalla macchina...magari a scuola hai intel e a casa AMD e hanno implementazioni diverse delle operazioni sui floating point....
l'unica cosa che può dipendere dal compilatore è "l'algoritmo" usato per le espressioni ma dato che uno standard è uno standard e gli operatori hanno una loro precedenza l'algoritmo sarà verosimilmente lo stesso su ogni compilatore....
Mezzetti0903
18-10-2008, 14:17
E invece è proprio vero, non c'entra nulla. Il sistema operativo al massimo si occuperà di ripartire in modo intelligente i tempi di esecuzione tra i vari processi, ma non si metterà certo ad intercettare operazioni matematiche. Quando il tuo processo fa qualche calcolo, sappi che è lui ed esclusivamente lui ad approfittare della tua CPU. Il sistema operativo non ha nemmeno bisogno di sapere cosa stia facendo il tuo programma. Al massimo dipende dal compilatore. ;)
il compilatore non può fare quello...la priorità è dell'operatore di divisione... poi fa il PIU...quella che descrivi tu non è una ottimizzazione del compilatore ma una ottimizzazione che dovrebbe fare il programmatore per ridurre l'errore.
Magari matlab fa cose del genere ma un compilatore normale penso non si PERMETTEREBBE mai di toccare ciò che IO ordino (implicitamente con la precedenza degli operatori).
i conti li fa la macchina quindi se tu ottieni dei risultati diversi a parità di algoritmo dipende dalla macchina...magari a scuola hai intel e a casa AMD e hanno implementazioni diverse delle operazioni sui floating point....
è proprio così! Dipende dall'architettura della macchina su cui lavori!
jappilas
18-10-2008, 14:26
Quoto quanto detto. Il sistema operativo non centra nulla o quasi. Conta l'architettura del calcolatore sul quale stai lavorando!è proprio così! Dipende dall'architettura della macchina su cui lavori!in più, a volte si mettono di mezzo idiosincrasie inerenti allo specifico modello e revisione, della cpu target - che fanno sì che codice compilato per un' altro modello, o per la generica famiglia, e/o con un compilatore ( + runtime library) non aggiornato che, non essendone a conoscenza, non vi può applicare eventuali workaround, produca risultati non sovrapponibili...
a titolo esemplificativo, alcune serie di cpu intel basate su architettura conroe sono affette, tra gli altri errata, dall' interessante AQ20
AQ20 - FP Inexact-Result Exception Flag May Not Be Set
Problem: When the result of a floating-point operation is not exactly representable in the destination format (1/3 in binary form, for example), an inexact-result (precision) exception occurs. When this occurs, the PE bit (bit 5 of the FPU status word) is normally set by the processor. Under certain rare conditions, this bit may not be set when this rounding occurs.
This erratum can occur if one of the following FST instructions is one or two instructions after the floating point operation which causes the precision exception:
<...>
Workaround: This condition can be avoided by inserting either three NOPs or three nonfloating-point non-Jcc instructions between the two floating-point instructions.
in sostanza, il bit nella status word che rileva se si è verificato un errore di arrotondamento (plausibilmente utile nel caso la precisione non sia sufficiente a rappresentare un numero la cui ultima cifra significativa sia di ordine molto basso) non viene settato in presenza di una certa sequenza di istruzioni floating point, questo dovrebbe voler dire non accorgersi dell' errore e non poter gestire la situazione nelle operazioni successive...
a parte ciò, faccio comunque notare che l' argomento originario del thread era un altro.. :O
DanieleC88
18-10-2008, 15:17
il compilatore non può fare quello...la priorità è dell'operatore di divisione... poi fa il PIU...quella che descrivi tu non è una ottimizzazione del compilatore ma una ottimizzazione che dovrebbe fare il programmatore per ridurre l'errore.
Non parlo di ottimizzazioni, ma di codice generato, la precedenza degli operatori non c'entra un bel niente... Ok, facciamo il ragionamento opposto che forse è più chiaro: dimmi in che momento interviene il tuo sistema operativo nel modificare il risultato delle operazioni. :D
sicuro! Dai miei appunti:
#include <stdio.h>
int main() {
double x=thc, ris;
ris=(1-(1+x))/x;
printf("%.16f \n", ris);
return 0;
}
Al posto di thc (The Hideous Costant) devi mettere la metà del piu piccolo float rappresentabile, che non mi ricordo adesso quanto valga, per ottenere inf NaN o 0 invece di 1.
Sul mio PC utilizzando FLT_MIN come THC sia su linux (gcc) che su windows (visual C) ottengo 0.
Però insisto nell'affermare che questo è dovuto all'errore introdotto dalla codifica in virgola mobile.
Se devo fare la prova con qualche altro valore di THC dimmi pure.
DanieleC88
18-10-2008, 15:21
un compilatore normale penso non si PERMETTEREBBE mai di toccare ciò che IO ordino (implicitamente con la precedenza degli operatori).
Ti sbagli, un assemblatore fa quello, non un compilatore. Il C non è un linguaggio imperativo, e ci sono diversi modi di fare le stesse cose. Se io voglio moltiplicare un numero per due, come lo traduco questo in assembly? Così?
MUL EAX, 2
Oppure così?
SHL EAX, 1
Cambia il risultato? Qual'è più efficiente? Quale dovrebbe scegliere un compilatore intelligente? :D
E qui chiudo, perché come giustamente leggo che jappilas ci fa notare, non era questo l'argomento del thread... se sei interessato continuiamo altrove. ;)
variabilepippo
18-10-2008, 16:54
un compilatore normale penso non si PERMETTEREBBE mai di toccare ciò che IO ordino (implicitamente con la precedenza degli operatori).
Il caso proposto da wlog era 2/3 + 1/3 vs (2+1)/3 e, visto che il risultato è identico, l'esatta codifica in linguaggio macchina dipenderà dal compilatore e dal livello di ottimizzazione prescelto. Per casi così semplici i compilatori solitamente precalcolano il risultato e generano la costante a compile-time.
E ti sembra un'istruzione standard quella? :D
l'istruzione fà parte dell'header conio.h, conforme alle norme ISO C++98, quindi sì, è una istruzione standard
EDIT:
@wlog: il mio codice era in c++, quindi sei a posto
variabilepippo
18-10-2008, 17:46
l'istruzione fà parte dell'header conio.h, conforme alle norme ISO C++98, quindi sì, è una istruzione standard
Ho sottomano lo standard ISO/IEC 14882 e l'header conio.h non risulta tra quelli standard, in quale pagina ci sarebbe il riferimento a tale header?
C++ Library Headers
<algorithm> <iomanip> <list> <queue> <streambuf>
<bitset> <ios> <locale> <set> <string>
<complex> <iosfwd> <map> <sstream> <typeinfo>
<deque> <iostream> <memory> <stack> <utility>
<exception> <istream> <new> <stdexcept> <valarray>
<fstream> <iterator> <numeric> <strstream> <vector>
<functional> <limits> <ostream>
Headers for C Library Facilities
<cassert> <ciso646> <csetjmp> <cstdio> <ctime>
<cctype> <climits> <csignal> <cstdlib> <cwchar>
<cerrno> <clocale> <cstdarg> <cstring> <cwctype>
<cfloat> <cmath> <cstddef>
Ho sottomano lo standard ISO/IEC 14882 e l'header conio.h non risulta tra quelli standard, in quale pagina c'è il riferimento a tale header?
quoto wikipedia
"Most C compilers that target DOS, Windows 3.x, Phar Lap, DOSX, OS/2, or Win32 have this header and supply the concomitant library functions in the default C library."
potrebbe anche darsi che mi sbagli, non sono esperto come voi, ma il senso di quello che dicevo rimane
||ElChE||88
18-10-2008, 17:53
l'istruzione fà parte dell'header conio.h, conforme alle norme ISO C++98, quindi sì, è una istruzione standard
Spiacente,
conio.h is a header file used in old MS-DOS compilers to create text user interfaces, however, it is not part of the C programming language, the C standard library, ISO C or required by POSIX.
variabilepippo
18-10-2008, 17:57
"Most C compilers that target DOS, Windows 3.x, Phar Lap, DOSX, OS/2, or Win32 have this header and supply the concomitant library functions in the default C library."
Ed il fatto che "molti compilatori C" abbiano tale file lo rende automaticamente parte dello standard (come hai affermato)?! :confused: E detto tra noi su Wikipedia vengono scritte tante fesserie, quando si fa riferimento a qualcosa di ufficiale è bene evitare gli articoli di Wikipedia come fonte.
conio.h NON è standard, nel post precedente ho riportato gli header elencati nello standard citato.
Ed il fatto che "molti compilatori C" abbiano tale file lo rende automaticamente parte dello standard (come hai affermato)?! :confused: E detto tra noi su Wikipedia vengono scritte tante fesserie, quando si fa riferimento a qualcosa di ufficiale è bene evitare gli articoli di Wikipedia come fonte.
conio.h NON è standard, nel post precedente ho riportato gli header elencati nello standard citato.
non il fatto che molti compilatori lo abbiamo, ma il fatto che molti compilatori lo abbiano tra le librerie standard
variabilepippo
18-10-2008, 18:05
Prima hai scritto:
l'istruzione fà parte dell'header conio.h, conforme alle norme ISO C++98, quindi sì, è una istruzione standard
e ciò è palesemente falso.
Poi hai abbassato il tiro:
il fatto che molti compilatori lo abbiano tra le librerie standard
Quali siano gli header (non librerie) standard è scritto, guarda caso, nello standard... Non sono i compilatori a definire cosa sia standard e cosa no, ma i comitati di standardizzazione. Chi produce compilatori può decidere di aggiungere librerie/header extra, ma questi (tra i quali conio.h) restano comunque NON-standard.
||ElChE||88
18-10-2008, 18:05
conio.h di GCC non ha clrscr(). :asd:
Proprio standard. :asd:
Prima hai scritto:
e ciò è palesemente falso.
Poi hai abbassato il tiro:
Quali siano gli header (non librerie) standard è scritto, guarda caso, nello standard... Non sono i compilatori a definire cosa sia standard e cosa no, ma i comitati di standardizzazione. Chi produce compilatori può decidere di aggiungere librerie/header extra, ma questi (tra i quali conio.h) restano comunque NON-standard.
ho capito, quello che dici, ho scritto "non il fatto che molti compilatori lo abbiamo, ma il fatto che molti compilatori lo abbiano tra le librerie standard" per farti capire il motivo per cui pensavo facesse parte degli standard c++ 98
DanieleC88
18-10-2008, 19:35
Be' ora sai che è invece un'estensione (originariamente proprietaria, e della Borland). Non è standard purtroppo come vedi. :)
ciao ;)
Sul mio PC utilizzando FLT_MIN come THC sia su linux (gcc) che su windows (visual C) ottengo 0.
Però insisto nell'affermare che questo è dovuto all'errore introdotto dalla codifica in virgola mobile.
Se devo fare la prova con qualche altro valore di THC dimmi pure.
Ciao prova FLT_MIN/2 e 2FLT_MIN (o 10FLT_MIN).
Ma ti viene 0? come intero? non credo... se è un FP posta le cifre....
Il caso proposto da wlog era 2/3 + 1/3 vs (2+1)/3 e, visto che il risultato è identico, l'esatta codifica in linguaggio macchina dipenderà dal compilatore e dal livello di ottimizzazione prescelto. Per casi così semplici i compilatori solitamente precalcolano il risultato e generano la costante a compile-time.
Esatto.
Esiste tutta una classe di operatori logici (tra cui somma e addizione) che possono essere compilati per poter eseguire piu istruzioni per ciclo.
E' il motivo per cui le microarchitetture x86 vanno molto male coi goto e i cicli for: Impediscono di precalcolare le successive istruzioni rompendo la linearità del codice, fattore fondamentale per permettere al calcolatore di fare delle ipotesi sulle future righe di codice.
Scusatemi...allora
i conti li fa la macchina quindi se tu ottieni dei risultati diversi a parità di algoritmo dipende dalla macchina...magari a scuola hai intel e a casa AMD e hanno implementazioni diverse delle operazioni sui floating point....
Ciao in teoria il risultato dovrebbe essere Windows 2000 vs Knoppinx 1999 su P4 prescott...
Però in effetti il calcolo lo fece il prof, io mi sono fidato... lunedi vi saprò dire di piu.
variabilepippo
18-10-2008, 20:04
Ma ti viene 0? come intero? non credo... se è un FP posta le cifre....
Ci vuoi spiegare o no in che modo/perché il sistema operativo, a parità di codice/compilatore/architettura/..., secondo le tue "teorie" dovrebbe incidere sulla precisione dei calcoli?! :confused:
Il codice
#include <stdio.h>
#include <float.h>
int main(void){
double x=FLT_MIN/2;
printf("%.16f \n", (1-(1+x))/x);
return 0;
}
compilato con qualsiasi compilatore per Windows restituisce:
0.0000000000000000
Secondo i tuoi calcoli quanto dovrebbe venire? Il risultato non cambia se x vale FLT_MIN, DLB_MIN, FLT_MIN, 10*FLT_MIN, ...
Algobardo
18-10-2008, 20:10
Ti sbagli, un assemblatore fa quello, non un compilatore. Il C non è un linguaggio imperativo, e ci sono diversi modi di fare le stesse cose. Se io voglio moltiplicare un numero per due, come lo traduco questo in assembly? Così?
MUL EAX, 2
Oppure così?
SHL EAX, 1
Cambia il risultato? Qual'è più efficiente? Quale dovrebbe scegliere un compilatore intelligente? :D
E qui chiudo, perché come giustamente leggo che jappilas ci fa notare, non era questo l'argomento del thread... se sei interessato continuiamo altrove. ;)
Se il compilatore legge l'espressione e, come hai detto tu in un altro thread, non la manipola allora la sequenza di istruzioni macchina da generare sarà la stessa (se vuole moltiplicare con lo shift invece che con la MUL non cambia nulla). Da ciò segue che l'errore algoritmico sarà lo stesso sia se compilo con il compilatore A o che compilo ocn il compilatore B dato che ciò che conta è la sequenza delle operazioni svolte.
Secondo i tuoi calcoli quanto dovrebbe venire? Il risultato non cambia se x vale FLT_MIN, DLB_MIN, FLT_MIN, 10*FLT_MIN, ...
http://www.hwupgrade.it/forum/showpost.php?p=24621129&postcount=43
Prova a farlo a mano, e vedrai che dovrebbe venire 1.
Ragazzi io sotto ubuntu non FLT_MIN... mi stampereste il suo valore????
Mi sa che il problema sta nel fatto che FLT_MIN è un float a 32 bit, mentre voi lavorate su double....
Ok ragazzi scoperto lo sgamo: dovevo includere una libreria... fatto questo bisogna correggere %.16f con %.100f e vedrete anche voi la differenza mostruosa...
Per farlo in modo scientifico poi voi aumentate piano piano il valore FLT_MIN e vedrete che da un numero completamente sbagliato piano piano ci si avvicinerà a 1... ma linux lo farà molto piu velocemente di win....
Non sapevo che in C si potessero rappresentare numeri molto piu piccoli che in matlab...
DanieleC88
18-10-2008, 20:38
Se il compilatore legge l'espressione e, come hai detto tu in un altro thread, non la manipola allora la sequenza di istruzioni macchina da generare sarà la stessa (se vuole moltiplicare con lo shift invece che con la MUL non cambia nulla). Da ciò segue che l'errore algoritmico sarà lo stesso sia se compilo con il compilatore A o che compilo ocn il compilatore B dato che ciò che conta è la sequenza delle operazioni svolte.
Che c'entra, ho fatto apposta un esempio dove il risultato è lo stesso con due vie diverse. Rileggi il punto della questione: il dilemma era "su Windows ottengo un risultato, su Linux ne leggo un altro"; ora, il linguaggio è lo stesso ed il codice pure. Cambiano, a quanto sembra, il compilatore ed il sistema operativo. Non mi risulta che il sistema operativo possa interferire con le operazioni matematiche di un programma, quindi lo escludo dalle possibili cause. Resta il compilatore (e/o le sue librerie di runtime). :D
Se mi dici in che modo Windows può influire sul risultato di tali operazioni, sarò felice di cambiare idea ed allargare le mie conoscenze. :)
variabilepippo
18-10-2008, 20:40
atto questo bisogna correggere %.16f con %.100f e vedrete anche voi la differenza mostruosa...
Qual è la differenza ed a cosa è dovuta? Quale è la massima precisione di un float? E di un double?
Se mi dici in che modo Windows può influire sul risultato di tali operazioni, sarò felice di cambiare idea ed allargare le mie conoscenze
Quoto.
Qual è la differenza ed a cosa è dovuta? Quale è la massima precisione di un float? E di un double?
Ciao,
il link con una spiegazione banale (ai limiti delle mie capacità) l'ho messo..
La differenza in cosa? tra %.16 e %.100?
O nei numeri? Se nei numeri è perchè windows non tratta bene i float.
Massima precisione?
Impossibile dirlo... varia da troppe cose.... Si può dire per la singola macchina (o classe di macchine con la stessa architettura/compilatore)
Se mi dici in che modo Windows può influire sul risultato di tali operazioni, sarò felice di cambiare idea ed allargare le mie conoscenze. :)
Ciao,
riposto la spiegazione approssimativa:
http://www.hwupgrade.it/forum/showpost.php?p=24621129&postcount=43
E mi dilungo:
La IEEE mette degli standard, e ognuno deve piu o meno aderire a quegli standard, di sicuro con almeno l'interoperabilità in modo da non essere rifiutato dal mercato.
Ma come con il tcp/ip che ha uno stack diverso da OS a OS, cosi la gestione dei float varia da OS a OS...
||ElChE||88
18-10-2008, 20:48
O nei numeri? Se nei numeri è perchè windows non tratta bene i float.
...
Ancora?
Si a quanto ne so mi pare non abbiamo cambiato.
Comunque se non mi credi sii libero di provare tu il codice.
||ElChE||88
18-10-2008, 20:51
Si a quanto ne so mi pare non abbiamo cambiato.
Comunque se non mi credi sii libero di provare tu il codice.
Provato:
Windows Vista 64:
0.0000000000000000000000000000000000000 eccetera...
Ubuntu:
0.0000000000000000000000000000000000000 eccetera....
Provato:
0.0000000000000000000000000000000000000 eccetera...
Allora ho ragione io, quindi Windows addirittura è INFINITI ordini di grandezza piu sbagliato perchè linux mi da:
0.000000000000000000000000000000000000011754943508222875079687365372222456778186655567720875215087517062784172594547271728515625000000
Pessimo risultato per Microsoft a quanto pare. Di sicuro una piattaforma da evitare se si fa ricerca.
Ubuntu:
0.0000000000000000000000000000000000000 eccetera....
Hai provato in 10 secondi?
Veloce cavolo...
Comunque ti invito a riprovare il risultato, dato che a me viene completamente diverso.
khelidan1980
18-10-2008, 20:58
Hai provato in 10 secondi?
Veloce cavolo...
Comunque ti invito a riprovare il risultato, dato che a me viene completamente diverso.
ma guarda a dire la verità è il tuo risultato ad essere non giusto.almeno "diverso" su ubuntu:
0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
variabilepippo
18-10-2008, 20:59
O nei numeri? Se nei numeri è perchè windows non tratta bene i float.
La spiegazione non spiega nulla, anche perché il fatto che il sistema operativo possa influire sulla "precisione dei float" è una balla. Come ti ho già detto il sistema operativo, qualunque esso sia, si limita a far eseguire il codice all'hardware.
cosi la gestione dei float varia da OS a OS...
Da bravo matematico ci posti un riferimento attendibile, una dimostrazione, etc. Oppure bisogna accettare questa affermazione come un assioma?
ma guarda a dire la verità è il tuo risultato ad essere non giusto.almeno "diverso" su ubuntu:
Ciao,
no il mio risultato è corretto, coincide con ciò che il mio manuale di algebra numerica e l'implementazione IEEE 1294 prevede
Da bravo matematico ci posti un riferimento attendibile, una dimostrazione, etc. Oppure bisogna accettare questa affermazione come un assioma?
Ma vi propongo di accettarla sperimentalmente: fate girare il codice e guardate la differenza.
khelidan1980
18-10-2008, 21:03
Ciao,
no il mio risultato è corretto, coincide con ciò che il mio manuale di algebra numerica e l'implementazione IEEE 1294 prevede
coinciderà con quello che vuoi ma sta di fatto che sul mio Ubuntu Linux quel codice da 0.0........ecc....
||ElChE||88
18-10-2008, 21:04
Pessimo risultato per Microsoft a quanto pare. Di sicuro una piattaforma da evitare se si fa ricerca.
:)
Edit: riuppo
khelidan1980
18-10-2008, 21:06
:)
Edit: riuppo
perchè hai tolto l'immagine?"rendeva l'idea" ;)
coinciderà con quello che vuoi ma sta di fatto che sul mio Ubuntu Linux quel codice da 0.0........ecc....
Ciao,
il codice l'ho modificato, dei aumentare il numero davanti a %.16f fino a che non ti stampa delle cifre siginificative
Non esiste un modo per stampare direttamente in notazione esponenziale in C? Cosi sarà piu facile per tutti vedere l'errore...
Sono sicuro ci sia ma non mi ricordo dove....
||ElChE||88
18-10-2008, 21:08
perchè hai tolto l'immagine?"rendeva l'idea" ;)
Rendeva anche il mio nome e cognome. :asd:
Ora metto una ancora più precisa.
:)
Edit: riuppo
Ciao,
lo so che per chi non abbia studiato queste cose nel dettaglio sia difficile da comprendere da quello che dico, ma sono sicuro che seguendo le mie indicazioni anche tu potrai capire. Tutto risiede nel fatto che l'algebra macchina non è ne commutativa ne associativa...
variabilepippo
18-10-2008, 21:12
Ho provato su Ubuntu e qualsiasi combinazione di modificatori di formato, tipo di dato (float/double) e valori limite (FLT_MIN, DBL_MIN, etc) produce soltanto ZERI.
Per esempio:
#include <stdio.h>
#include <float.h>
int main(void){
float x = FLT_MIN;
printf("%0.1000f \n", (1-(1+x))/x);
return 0;
}
produce:
0.000000000000000000000000...seguono SOLO zeri
o so che per chi non abbia studiato sia difficile da comprendere da quello che dico
Inizio a dubitare un'attività da troll... Visto che tu hai studiato, ci dimostri perché i risultati coincidono a tutti tranne che a te?
khelidan1980
18-10-2008, 21:13
Ciao,
il codice l'ho modificato, dei aumentare il numero davanti a %.16f fino a che non ti stampa delle cifre siginificative
Non esiste un modo per stampare direttamente in notazione esponenziale in C? Cosi sarà piu facile per tutti vedere l'errore...
Sono sicuro ci sia ma non mi ricordo dove....
certo con la e al posto della f nella formattazione dell'output
DanieleC88
18-10-2008, 21:14
Non esiste un modo per stampare direttamente in notazione esponenziale in C?
Usa i double e stampa con %e.
||ElChE||88
18-10-2008, 21:14
Ciao,
lo so che per chi non abbia studiato queste cose nel dettaglio sia difficile da comprendere da quello che dico, ma sono sicuro che seguendo le mie indicazioni anche tu potrai capire. Tutto risiede nel fatto che l'algebra macchina non è ne commutativa ne associativa...
Ciao,
lo so che per chi non abbia studiato queste cose nel dettaglio sia difficile da comprendere da quello che dico, ma sono sicuro che seguendo le mie indicazioni anche tu potrai capire. Tutto risiede nel fatto che stai confondendo ciò che dipende dal sistema operativo con ciò che dipende dalla macchina...
http://img37.picoodle.com/img/img37/3/10/18/f_Untitled1m_333ff21.jpg
PS: variabilepippo se non fixi il layout ti prendiamo a bastonate. :asd:
PS2: in arrivo la versione con gli esponenziali
Algobardo
18-10-2008, 21:14
Che c'entra, ho fatto apposta un esempio dove il risultato è lo stesso con due vie diverse. Rileggi il punto della questione: il dilemma era "su Windows ottengo un risultato, su Linux ne leggo un altro"; ora, il linguaggio è lo stesso ed il codice pure. Cambiano, a quanto sembra, il compilatore ed il sistema operativo. Non mi risulta che il sistema operativo possa interferire con le operazioni matematiche di un programma, quindi lo escludo dalle possibili cause. Resta il compilatore (e/o le sue librerie di runtime). :D
Se mi dici in che modo Windows può influire sul risultato di tali operazioni, sarò felice di cambiare idea ed allargare le mie conoscenze. :)
No, io sono perfettamente d'accordo con te per quanto riguarda il sistema operativo, io ci aggiungo anche io compilatore...
-la valutazione di una espressione con compilatori diversi su una stessa macchina da lo stesso risultato-
le uniche cose che possono influire solo le ALU
khelidan1980
18-10-2008, 21:16
Ciao,
lo so che per chi non abbia studiato queste cose nel dettaglio sia difficile da comprendere da quello che dico, ma sono sicuro che seguendo le mie indicazioni anche tu potrai capire. Tutto risiede nel fatto che l'algebra macchina non è ne commutativa ne associativa...
con tutta la buona volontà sulla mia macchina posso stampare diecimila cifre ma son tutti zero
DanieleC88
18-10-2008, 21:16
Ho provato su Ubuntu e qualsiasi combinazione di modificatori di formato, tipo di dato (float/double) e valori limite (FLT_MIN, DBL_MIN, etc) produce soltanto ZERI.
Madonna, gli zeri mettili in un CODE invece che un QUOTE, sennò il layout muore. :asd:
variabilepippo
18-10-2008, 21:19
lo so che per chi non abbia studiato queste cose nel dettaglio sia difficile da comprendere da quello che dico
Ti sto rispondendo "da Ubuntu", se posti il codice che secondo te dovrebbe mostrare la differenza tra Windows e Linux posso compilarlo e indicare l'output.
||ElChE||88
18-10-2008, 21:19
Non esiste un modo per stampare direttamente in notazione esponenziale in C? Cosi sarà piu facile per tutti vedere l'errore...
Fatto:
http://img33.picoodle.com/img/img33/3/10/18/f_Untitled1m_f451ec8.jpg
Ora tutti possiamo vedere il tuo errore.
khelidan1980
18-10-2008, 21:19
certo che non abbiamo un azz di meglio da fare al sabato sera??:asd: :asd:
Inizio a dubitare un'attività da troll... Visto che tu hai studiato, ci dimostri perché i risultati coincidono a tutti tranne che a te?
Ciao,
quella frase l'ho editata perchè hai ragione tu era OFFENSIVA ed infatti mi SCUSO. Ma garantisco che NON ERA ASSOLUTAMENTE mia intenzione offendere nessuno e voglio ripetere a tutti che questa è una semplice discussione amichevole, alla fine della quale qualcuno di noi (probabilmente io, oppure voi) ne uscirà sapendo qualcosa di nuovo.
Detto questo la prima cosa che mi viene in mente è che magari FLT_MIN sia troppo piccolo per la vostra macchina perchè, ad esempio, potrebbe adottare una approssimazione lower bound invece della classica.
Provate quindi piano piano ad aumentare di un ordine di grandezza alla volta FLT_MIN.
Oppure stampatevi FLT_MIN e guardate a che cifra decimale si posiziona la prima cifra significativa, e poi impostate la stampa con l'esatto numero davanti a %f
Purtroppo io adesso devo uscire, vi giuro che stanotte, o al piu domani, risponderò a tutte le vostre obiezioni.
DanieleC88
18-10-2008, 21:23
le uniche cose che possono influire solo le ALU
E allora siamo d'accordissimo. :)
I numeri in virgola mobile hanno precisione limitata, quindi è normale che se wlog stampa il numero non approssimato ottiene errori di conversione, risiede tutto nella rappresentazione dell'informazione (che è una cosa cruciale per capire come funziona un calcolatore). Includevo il compilatore perché magari compilatori che si appoggiano a librerie di runtime diverse hanno printf() che gestiscono in modo diverso la stampa di numeri con virgola mobile, poteva essere l'unica cosa plausibile a questo punto. :p
variabilepippo
18-10-2008, 21:25
Ripeto:
1) Posta il codice che dovrebbe mostrare l'errore di Windows ed il corretto funzionamento di Linux
2) Nel postare il codice indica anche quelli che secondo te sono i valori corretti per l'output
||ElChE||88
18-10-2008, 21:32
Io ancora non riesco a capire in che modo il sistema operativo influenzi le operazioni con i FP.
Se c'è una differenza la "colpa" dovrebbe essere del compilatore.
variabilepippo
18-10-2008, 21:39
Io ancora non riesco a capire in che modo il sistema operativo influenzi le operazioni con i FP.
Se c'è una differenza la "colpa" dovrebbe essere del compilatore.
Del compilatore e/o del programmatore, come sostengo dall'inizio della discussione... ;)
DanieleC88
18-10-2008, 21:41
Con questo codice:
#include <stdio.h>
#include <float.h>
#define PRECISION "1000"
int main()
{
long double x = 0.000000005, ris;
ris = (1.0f - (1.0f + x)) / x;
printf("Operazione wlog:\t%." PRECISION "Le\n", ris);
printf("\n");
printf("FLT_MIN:\t\t%." PRECISION "f\n", FLT_MIN);
printf("\n");
printf("FLT_MIN / 2.0f:\t\t%." PRECISION "f\n", (FLT_MIN / 2.0f));
return 0;
}
ottengo:
Operazione wlog: -9.9999999999406117407157318366373033313720952719449996948242187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01
FLT_MIN: 0.0000000000000000000000000000000000000117549435082228750796873653722224567781866555677208752150875170627841725945472717285156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2: 0.0000000000000000000000000000000000000058774717541114375398436826861112283890933277838604376075437585313920862972736358642578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Questo su Linux. Adesso riavvio e provo a compilarlo con Visual C++ per vedere le differenze. :D
variabilepippo
18-10-2008, 21:49
Compilatore Microsoft:
Operazione wlog: -9.99999993922529030000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000e-001
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
50000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
MinGW:
Operazione wlog: -1.#QNAN000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000e+000
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
50000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
Compilatore Borland:
Operazione wlog: -9.999999999940611741000000000000000000000e-01
FLT_MIN: 0.0000000000000000000000000000000000000118
FLT_MIN / 2.0f: 0.0000000000000000000000000000000000000059
Compilatore Digital Mars
Operazione wlog: -9.99999999994061174090000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000e-01
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
07900000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
53980000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
Pelles C:
Operazione wlog: -1.00000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000e+00
FLT_MIN: 0.000000000000000000000000000000000000011754943508222876
11663300000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111438
05831600000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
OpenWatcom:
Operazione wlog: 2.345427393076821494766200000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000e-148
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
08000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
53990000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
Cygwin:
http://img253.imageshack.us/img253/4830/catturauk5.png
Come detto più volte la "colpa" è dei compilatori e dei programmatori, non dei sistemi operativi...
Algobardo
18-10-2008, 22:00
Compilatore Microsoft:
Operazione wlog: -9.99999993922529030000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000e-001
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
50000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
MinGW:
Operazione wlog: -1.#QNAN000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000e+000
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
50000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
Compilatore Borland:
Operazione wlog: -9.999999999940611741000000000000000000000e-01
FLT_MIN: 0.0000000000000000000000000000000000000118
FLT_MIN / 2.0f: 0.0000000000000000000000000000000000000059
Compilatore Digital Mars
Operazione wlog: -9.99999999994061174090000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000e-01
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
07900000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
53980000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
Pelles C:
Operazione wlog: -1.00000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000e+00
FLT_MIN: 0.000000000000000000000000000000000000011754943508222876
11663300000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111438
05831600000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
OpenWatcom:
Operazione wlog: 2.345427393076821494766200000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000e-148
FLT_MIN: 0.000000000000000000000000000000000000011754943508222875
08000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.000000000000000000000000000000000000005877471754111437
53990000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000
Cygwin:
http://img253.imageshack.us/img253/4830/catturauk5.png
Come detto più volte la "colpa" è dei compilatori e dei programmatori, non dei sistemi operativi...
Aspè....
x = 0.000000005
non è detto che quel valore sia rappresentabile in floating point...
quindi il problema potrebbe risiedere lì oppure i vari compilatori compilano effettivamente con una sequenza di operazioni diverse...
puoi provare a mettere un valore rappresentabile??
DanieleC88
18-10-2008, 22:09
Operazione wlog: -9.9999999999406117407157318366373033313720952719449996948242187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01
FLT_MIN: 0.0000000000000000000000000000000000000117549435082228750796873653722224567781866555677208752150875170627841725945472717285156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2: 0.0000000000000000000000000000000000000058774717541114375398436826861112283890933277838604376075437585313920862972736358642578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Microsoft Visual C++:
Operazione wlog: -9.99999993922529030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-001
FLT_MIN: 0.00000000000000000000000000000000000001175494350822287500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.00000000000000000000000000000000000000587747175411143750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
MinGW:
Operazione wlog: -1.#QNAN000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+000
FLT_MIN: 0.00000000000000000000000000000000000001175494350822287500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.00000000000000000000000000000000000000587747175411143750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Risultati identici sui due diversi compilatori (eccetto il primo che è approssimato a -1 e non ha cifre decimali in MinGW).
Disassemblaggio da Visual C++:
ris = (1.0f - (1.0f + x)) / x;
004113C7 fld1
004113C9 fadd qword ptr [x]
004113CC fld1
004113CE fsubrp st(1),st
004113D0 fdiv qword ptr [x]
004113D3 fstp qword ptr [ris]
Quindi, calcola (1.0f + x), poi carica 1.0f e vi sottrae la precedente operazione, poi divide tutto per x e lo salva in ris.
printf("FLT_MIN / 2.0f:\t\t%." PRECISION "f\n", (FLT_MIN / 2.0f));
00411447 mov esi,esp
00411449 sub esp,8
0041144C fld qword ptr [__real@3800000000000000 (415760h)]
00411452 fstp qword ptr [esp]
00411455 push offset string "FLT_MIN / 2.0f:\t\t%.1000f\n" (41573Ch)
0041145A call dword ptr [__imp__printf (4182BCh)]
Qui invece è evidente che precalcola il valore di (FTL_MIN / 2.0f) e lo carica sullo stack appena prima di invocare la printf(), quindi nessun intervento del sistema operativo.
Analisi con objdump del codice di GCC:
8048438: b8 00 d0 61 84 mov eax,0x8461d000
804843d: ba 11 77 cc ab mov edx,0xabcc7711
8048442: b9 e3 3f 00 00 mov ecx,0x3fe3
8048447: 89 45 e8 mov DWORD PTR [ebp-0x18],eax
804844a: 89 55 ec mov DWORD PTR [ebp-0x14],edx
804844d: 89 4d f0 mov DWORD PTR [ebp-0x10],ecx
8048450: db 6d e8 fld TBYTE PTR [ebp-0x18]
8048453: d9 e8 fld1
8048455: de c1 faddp st(1),st
8048457: d9 e8 fld1
8048459: de e1 fsubp st(1),st
804845b: db 6d e8 fld TBYTE PTR [ebp-0x18]
804845e: de f9 fdivrp st(1),st
8048460: db 7d d8 fstp TBYTE PTR [ebp-0x28]
8048463: c7 04 24 38 86 04 08 mov DWORD PTR [esp],0x8048638
804846a: e8 9d fe ff ff call 804830c <printf@plt>
Le istruzioni in virgola mobile sono quasi le stesse.
Poi:
804854b: dd 05 c0 86 04 08 fld QWORD PTR ds:0x80486c0
8048551: dd 5c 24 04 fstp QWORD PTR [esp+0x4]
8048555: c7 04 24 9c 86 04 08 mov DWORD PTR [esp],0x804869c
804855c: e8 ab fd ff ff call 804830c <printf@plt>
La stampa di (FTL_MIN / 2.0f) avviene anche stavolta precaricando dalla sezione dati un valore già computato.
Non vedo differenze sostanziali, l'arcano segreto dovrebbe quindi risiedere nella printf() che stampa il tutto. :)
Domani stampo anche da Windows i dati contenuti in memoria nelle variabili che contengono il risultato. ;)
variabilepippo
18-10-2008, 22:23
Aggiungo che è possibile impostare, tramite l'istruzione fldcw o la funzione _controlfp_s, la precisione della FPU, se per esempio nel codice di Daniele si aggiunge _controlfp(_MCW_PC, _PC_24); si otterrà:
Operazione wlog: 0.00000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000e+000
FLT_MIN: 0.00000000000000000000000000000000000001175494350822287
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.00000000000000000000000000000000000000587747175411143
5000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000
Algobardo
18-10-2008, 22:53
Microsoft Visual C++:
Operazione wlog: -9.99999993922529030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-001
FLT_MIN: 0.00000000000000000000000000000000000001175494350822287500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.00000000000000000000000000000000000000587747175411143750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
MinGW:
Operazione wlog: -1.#QNAN000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+000
FLT_MIN: 0.00000000000000000000000000000000000001175494350822287500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
FLT_MIN / 2.0f: 0.00000000000000000000000000000000000000587747175411143750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Risultati identici sui due diversi compilatori (eccetto il primo che è approssimato a -1 e non ha cifre decimali in MinGW).
Disassemblaggio da Visual C++:
ris = (1.0f - (1.0f + x)) / x;
004113C7 fld1
004113C9 fadd qword ptr [x]
004113CC fld1
004113CE fsubrp st(1),st
004113D0 fdiv qword ptr [x]
004113D3 fstp qword ptr [ris]
Quindi, calcola (1.0f + x), poi carica 1.0f e vi sottrae la precedente operazione, poi divide tutto per x e lo salva in ris.
printf("FLT_MIN / 2.0f:\t\t%." PRECISION "f\n", (FLT_MIN / 2.0f));
00411447 mov esi,esp
00411449 sub esp,8
0041144C fld qword ptr [__real@3800000000000000 (415760h)]
00411452 fstp qword ptr [esp]
00411455 push offset string "FLT_MIN / 2.0f:\t\t%.1000f\n" (41573Ch)
0041145A call dword ptr [__imp__printf (4182BCh)]
Qui invece è evidente che precalcola il valore di (FTL_MIN / 2.0f) e lo carica sullo stack appena prima di invocare la printf(), quindi nessun intervento del sistema operativo.
Adesso riavvio di nuovo ed esamino il codice generato da GCC. :asd:
Era quello che volevo fare io ma sulla macchina qua sotto non ho installato nulla...anzi...ho appena installato MinGW....
oltre al disassemblato di GCC puoi aggiungere due stampe?
1) la stampa byteperbyte di x e di ris (stampali come due interi oppure come 8char)
2) la stampa di x (quella in formato esponenziale)
ottimizzando la compilazione su Visual C++ la sequenza delle operazioni rimane la stessa (cioè quella descritta dall'espressione)? e su GCC?
DanieleC88
18-10-2008, 23:18
oltre al disassemblato puoi aggiungere due stampe?
Troppo tardi, ormai sono già su Linux... intanto aggiungo al codice su GCC, poi magari ripeterò il tutto su Windows domani (ammesso che me ne ricordi :asd: ).
Tanto per cominciare ho creato questa funzione:
void printhex(const unsigned char *ptr, size_t len)
{
int n;
printf("0x");
for (n = (len - 1); n >= 0; --n)
{
printf("%02X", ptr[n]);
}
printf("\n");
}
E ho aggiunto in testa al main:
long double flt_min, flt_min_half;
ris = (1.0f - (1.0f + x)) / x;
printf("Valore ris:\t\t");
printhex((const unsigned char *) &ris, sizeof(ris));
flt_min = FLT_MIN;
printf("Valore flt_min:\t\t");
printhex((const unsigned char *) &flt_min, sizeof(flt_min));
flt_min_half = (FLT_MIN / 2.0f);
printf("Valore flt_min_half:\t");
printhex((const unsigned char *) &flt_min_half, sizeof(flt_min_half));
printf("\n");
Ottengo su GCC:
Valore ris: 0xBFD5BFFEFFFFFFFFF9785E7E
Valore flt_min: 0x00003F818000000000000000
Valore flt_min_half: 0x00003F808000000000000000
Invece con Visual C++:
Valore ris: 0xBFEFFFFFFCBCB800
Valore flt_min: 0x3810000000000000
Valore flt_min_half: 0x3800000000000000
Notare: GCC per questioni di allineamento utilizza long double di 96 bit/12 byte, quindi le prime quattro cifre esadecimali nell'output di GCC sono da considerarsi "junk data". Visual C++, invece, usa precisamente 64 bit/8 byte per lo stesso tipo numerico. Ecco la perdita di precisione... e dipende dal sistema operativo? No, dal compilatore! :D
Ultima nota sul perché ftl_min ed flt_min_half abbiano una parte decimale diversa nelle due rappresentazioni: nella prima è su 80 bit, dove la mantissa esplicita il primo bit normalizzato (per motivazioni storiche, più che altro); nella seconda su 64 bit il numero normalizzato ha il primo bit 1 implicito, perciò la mantissa è una serie di zeri. ;)
variabilepippo
18-10-2008, 23:26
Ora vedo di disassemblare questo codice e allego le novità al post di prima.
Con gcc test.c -save-temps -masm=intel possibilmente... ;)
DanieleC88
18-10-2008, 23:35
Con gcc test.c -save-temps -masm=intel possibilmente... ;)
Ricevuto... :)
DanieleC88
18-10-2008, 23:48
Fatto. :)
DanieleC88
19-10-2008, 00:18
Aggiornata la printhex(), la mia CPU è little endian, quindi stavo stampando al contrario... :muro:
In più GCC mi aveva comodamente generato l'output in assembly Intel e io sono andato a ri-disassemblarlo... vabbe', sono un idiota. :D
ciao ;)
ok, provate a fare un ultima prova: Aumentate a step di un ordine di grandezza alla volta il valore di FLT_MIN e guardate quale converge piu velocemente.
ok, provate a fare un ultima prova: Aumentate a step di un ordine di grandezza alla volta il valore di FLT_MIN e guardate quale converge piu velocemente.
||ElChE||88
19-10-2008, 04:44
ok, provate a fare un ultima prova: Aumentate a step di un ordine di grandezza alla volta il valore di FLT_MIN e guardate quale converge piu velocemente.
Susu, rassegnati. :)
Leggiti i post sopra e vedrai che tutto dipende dal compilatore, non da Windows o Linux.
variabilepippo
19-10-2008, 08:51
Aspè....
x = 0.000000005
non è detto che quel valore sia rappresentabile in floating point...
quindi il problema potrebbe risiedere lì .
Il minimo valore rappresentabile da un float è definito da FLT_MIN in float.h, per esempio Visual C++ lo definisce come
#define FLT_MIN 1.175494351e-38F /* min positive value */
x = 0.000000005 è un numero enorme rispetto a FLT_MIN = 0.00000000000000000000000000000000000001175494350822287. ;)
oppure i vari compilatori compilano effettivamente con una sequenza di operazioni diverse..
I compilatori compilano effettivamente con sequenze di operazioni diverse (dovute a scelte progettuali, tecniche di ottimizzazione adottate, incompatibilità con lo standard, modalità di compilazione, bug, ...), è una ovvietà: a parità di sorgente ogni compilatore genera codice macchina diverso. Hai mai provato a compilare un progetto non banale o a chiedere al compilatore di generare anche il codice Assembly? Nel codice sono definite le porzioni di codice specifiche per ogni compilatore mediante direttive del preprocessore al fine di ottenere lo stesso risultato con compilatori diversi.
Esempio preso a caso:
#if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
return((res->floatval == ctxt->context->proximityPosition) &&
(!xmlXPathIsNaN(res->floatval)));
#else
return(res->floatval == ctxt->context->proximityPosition);
#endif
Susu, rassegnati. :)
Leggiti i post sopra e vedrai che tutto dipende dal compilatore, non da Windows o Linux.
ehehehh mai! Lunedi faccio le prove a scuola e vi dico!
variabilepippo
19-10-2008, 11:16
ehehehh mai! Lunedi faccio le prove a scuola e vi dico!
Il codice proposto è stato compilato su Windows e su Linux, con compilatori diversi, da 3/4 utenti diversi ed i risultati sono stati pubblicati sul forum. Secondo te cosa indicano quei dati?
Se ti fosse sfuggito ti ricordo che è possibile impostare, via codice, la precisione dei calcoli a virgola mobile intermedi. Su Windows il valore di default è 53 bits, ma può essere portata a 64 bits. Il resto è a carico dell'hardware...
Algobardo
19-10-2008, 11:33
Il minimo valore rappresentabile da un float è definito da FLT_MIN in float.h, per esempio Visual C++ lo definisce come
#define FLT_MIN 1.175494351e-38F /* min positive value */
x = 0.000000005 è un numero enorme rispetto a FLT_MIN = 0.00000000000000000000000000000000000001175494350822287. ;)
Che il minimo sia quello non significa che sia rappresentabile...in questo caso ci salva il fatto che prima del 5 ci sono solo 0.
I compilatori compilano effettivamente con sequenze di operazioni diverse (dovute a scelte progettuali, tecniche di ottimizzazione adottate, incompatibilità con lo standard, modalità di compilazione, bug, ...), è una ovvietà: a parità di sorgente ogni compilatore genera codice macchina diverso. Hai mai provato a compilare un progetto non banale o a chiedere al compilatore di generare anche il codice Assembly? Nel codice sono definite le porzioni di codice specifiche per ogni compilatore mediante direttive del preprocessore al fine di ottenere lo stesso risultato con compilatori diversi.
Esempio preso a caso:
#if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
return((res->floatval == ctxt->context->proximityPosition) &&
(!xmlXPathIsNaN(res->floatval)));
#else
return(res->floatval == ctxt->context->proximityPosition);
#endif
si, ma qua stiamo parlando di una espressione, finora i compilati hanno le stesse istruzioni macchina e la stessa sequenza.
Il codice proposto è stato compilato su Windows e su Linux, con compilatori diversi, da 3/4 utenti diversi ed i risultati sono stati pubblicati sul forum. Secondo te cosa indicano quei dati?
Ciao!
Beh fino a ieri eravate tutti a dirmi che faceva 0 o addirittura 1!!!
Se ti fosse sfuggito ti ricordo che è possibile impostare, via codice, la precisione dei calcoli a virgola mobile intermedi. Su Windows il valore di default è 53 bits, ma può essere portata a 64 bits. Il resto è a carico dell'hardware...
53 bits vengono usati per le cifre, gli altri undici servono per la notazione! Cosi vuole lo standard IEEE... comunque dove si imposta sta cosa?
Che il minimo sia quello non significa che sia rappresentabile...in questo caso ci salva il fatto che prima del 5 ci sono solo 0.
Tutti i numeri piu grandi del float min (e anche molti piu piccoli) sono rappresentabili con un certo errore.
variabilepippo
19-10-2008, 12:14
Che il minimo sia quello non significa che sia rappresentabile...in questo caso ci salva il fatto che prima del 5 ci sono solo 0.
Non capisco cosa vuoi dire.
Beh fino a ieri eravate tutti a dirmi che faceva 0 o addirittura 1!!!
Ti abbiamo detto e ti ripetiamo che dipende dal codice e dal compilatore, non dal sistema operativo. Abbiamo cambiato il codice e dunque cambiano anche i risultati.
Puoi cortesemente darci un riferimento (un paper, una pagina Web, ...) dove si spiega perché Linux sarebbe più bravo nel fare i conti rispetto a Windows?
53 bits vengono usati per le cifre, gli altri undici servono per la notazione! Cosi vuole lo standard IEEE... comunque dove si imposta sta cosa?
Dove sta scritto che "così vuole lo standard IEEE"? Le precisioni a 53 o a 64 bits sono indipendenti e si impostano come illustrato nei post precedenti.
si, ma qua stiamo parlando di una espressione, finora i compilati hanno le stesse istruzioni macchina e la stessa sequenza.
Lo stesso standard ANSI C prevede implementazioni diverse:
"The floating-point model is intended to clarify the description of each floating-point characteristic and
does not require the floating-point arithmetic of the implementation to be identical".
Figuriamoci quanta libertà si prendono i compilatori in questi casi... :)
Come giustifichi, a parità di sorgente, i risultati diversi?
Algobardo
19-10-2008, 12:26
Come giustifichi, a parità di sorgente, i risultati diversi?
1) Rappresentazione dello 0.000005 (magari c'è una scelta tra due numeri vicini ed i compilatori scelgono numeri diversi) (per questo ho chiesto a daniele di stampare x byte per byte)
2) Precisione impostata sulla FPU (anche se possibile non penso sia la reale causa). Nota che nel momento in cui noi scriviamo 1.0 il compilatore potrebbe considerarlo float o double (non mi pare sia standardizzata la cosa e noi siamo ambigui non specificando) e quindi modificare la precisione della FPU di nascosto.
3) Implementazione della printf (infatti ho chiesto lo stampato byte per byte di ris).
La sequenza delle operazioni decompilate è la stessa, se non è per uno di questi motivi semplicemente non me lo spiego....
VC++
fld1
fadd qword ptr [x]
fld1
fsubrp st(1),st
fdiv qword ptr [x]
fstp qword ptr [ris]
GCC
fld1
faddp st(1),st
fld1
fsubp st(1),st
fld TBYTE PTR [ebp-0x18]
fdivrp st(1),st
fstp TBYTE PTR [ebp-0x28]
Non capisco cosa vuoi dire.
Secondo le regole della notazione scientifica abbiamo (conserviamo solo 5 cifre):
0.12345678901234567890 = 0.12346e00
Mentre
0.00000000005 = 0.5e-10
Quindi come vedi il secondo numero pur essendo piu piccolo ha un errore inferiore
Ti abbiamo detto e ti ripetiamo che dipende dal codice e dal compilatore, non dal sistema operativo. Abbiamo cambiato il codice e dunque cambiano anche i risultati.
Puoi cortesemente darci un riferimento (un paper, una pagina Web, ...) dove si spiega perché Linux sarebbe più bravo nel fare i conti rispetto a Windows?
Mo lo cerco!
Dove sta scritto che "così vuole lo standard IEEE"? Le precisioni a 53 o a 64 bits sono indipendenti e si impostano come illustrato nei post precedenti.
http://en.wikipedia.org/wiki/IEEE_754#Basic_formats
Ecco, 53 bits per le cifre, 11 per la virgola e l'esponente. Cosi vuole lo standard.
Mi linkeresti i post precedenti comunque? ho paura di essermelo perso!
ciao ragazzi,
mi è venuto in mente un altro metodo per mettere alla prova la gestione dei FP: fare la tangente di pi/2.
Il problema è che non mi compila... come mai?
#include <stdio.h>
#include <float.h>
#include <math.h>
#define PI 3.14159265358979323846264338327
int main() {
printf(" %.100f \n", tanf(PI/2.0));
return 0;
}
mascarpone@mascarpone-desktop:~/Desktop$ gcc prova.c
/tmp/cc5uyn7l.o: In function `main':
prova.c:(.text+0x1a): undefined reference to `tanf'
collect2: ld returned 1 exit status
mascarpone@mascarpone-desktop:~/Desktop$
ciao ragazzi,
mi è venuto in mente un altro metodo per mettere alla prova la gestione dei FP: fare la tangente di pi/2.
Il problema è che non mi compila... come mai?
#include <stdio.h>
#include <float.h>
#include <math.h>
#define PI 3.14159265358979323846264338327
int main() {
printf(" %.100f \n", tanf(PI/2.0));
return 0;
}
mascarpone@mascarpone-desktop:~/Desktop$ gcc prova.c
/tmp/cc5uyn7l.o: In function `main':
prova.c:(.text+0x1a): undefined reference to `tanf'
collect2: ld returned 1 exit status
mascarpone@mascarpone-desktop:~/Desktop$
Stai usando math.h ma non hai detto al compilatore che quando fa il link deve tenere conto anche di quella libreria. Aggiungi -lm al comando per compilare e vedrai che funziona.
DanieleC88
19-10-2008, 13:25
Beh fino a ieri eravate tutti a dirmi che faceva 0 o addirittura 1!!!
Infatti quell'espressione fa ancora 1. Togli la forzatura imposta manualmente sulla precisione delle cifre e vedrai un bell'uno. Se è per questo, prova a stampare 0.2 con lo stesso metodo e vedi che ti esce... le approssimazioni sono una cosa normalissima. ;)
DanieleC88
19-10-2008, 13:35
Ho aggiunto la stampa dei valori delle variabili anche su Visual C++ e i risultati sono... questi (http://www.hwupgrade.it/forum/showpost.php?p=24628199&postcount=129).
Ho calcolato dei valori con dei long double, che in GCC sono di 80 bit, in VC++ di 64 bit. Ecco la differenza di precisione. :p
DanieleC88
19-10-2008, 13:38
E per la gioia di wlog:
0.2: 2.00000002980232240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-001
Che sono quelle cifre in più dopo la virgola? OMG! Windows ha messo le mani nella mia memoria! :asd:
Scherzo, eh, non t'offendere. :)
ciao ;)
Stai usando math.h ma non hai detto al compilatore che quando fa il link deve tenere conto anche di quella libreria. Aggiungi -lm al comando per compilare e vedrai che funziona.
sono uno zappaterra...
mascarpone@mascarpone-desktop:~/Desktop$ ./a.out
16331778728383844.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
a voi quanto viene la tanf di pi/2?
Infatti quell'espressione fa ancora 1. Togli la forzatura imposta manualmente sulla precisione delle cifre e vedrai un bell'uno. Se è per questo, prova a stampare 0.2 con lo stesso metodo e vedi che ti esce... le approssimazioni sono una cosa normalissima. ;)
lo so che in algebra esatta fa 1... solo che noi vogliamo che il risultato finale sia calcolato a pc!
voglio vederti fare una simulazione di montecarlo a mano :P :D
DanieleC88
19-10-2008, 14:01
lo so che in algebra esatta fa 1... solo che noi vogliamo che il risultato finale sia calcolato a pc!
Ti sto dicendo infatti che è calcolato a PC, ma che per forza di cose viene un risultato approssimato (per colpa della rappresentazione dei dati). Quindi, se tu forzi la stampa del numero non approssimato con una certa precisione ti verrà un risultato diverso a seconda della quantità di bit che il tuo tipo di dati utilizza nei calcoli, altrimenti vedrai un 1, che è la giusta approssimazione del risultato (ed è anche il valore più preciso).
ciao ;)
ecco un altro interessante programma:
#include <stdio.h>
#include <stdlib.h>
#define PI 3.14159265358979323846264338327
int main() {
int i, count = 0;
double x, y;
for (i=0; i<1000; i++) {
x=drand48();
y=drand48();
// printf("%f - %f - ", x, y);
if (x*x+y*y < 1) count++;
}
count=4*count/1000;
printf("%.16f %.16f %.16f \n", count, PI, PI-count );
return 0;
}
Simulazione di montecarlo per calcolare pi greco.
Due domande:
A) Non mi ricordo.... drand va inizializzata???
B) Come mai Pi me lo stampa:
86191978822782218663259283772171115826714322906857831407766949968523921657761949942445464432410624.0000000000000000
invece di
314.....
cdimauro
19-10-2008, 15:16
Basta con questi esercizietti: stiamo ancora aspettando la DIMOSTRAZIONE che Windows alteri le operazioni matematiche, mentre Linux no.
Ti sono state fornite AMPIE prove del contrario, ma la tua tesi rimane ancora campata per aria.
Ti do un paio di dritte.
In primo luogo vatti a ripassare la definizione di sistema operativo, che per un programmatore è ben nota, ma che per un matematico che ha sempre vissuto nel suo mondo ideale e da poco s'è affacciato a quello reale molto probabilmente sarà sconosciuta.
In secondo luogo dovresti portarmi un risultato riproducibile che dimostri che è il s.o. ad alterare i dati.
In questo caso penso ti sarà sufficiente trovare un qualche bug nello scheduler (magari nella sezione di context switch), negli handler di interrupt, ecc., visto che sono i posti più papabili per un errore di questo tipo.
Anche perché è da una quindicina d'anni buona che i calcoli matematici NON sono più demandati alle funzioni di libreria esposte dal s.o., ma vengono eseguiti direttamente d'hardware (visto che l'FPU è integrata nella CPU; ovviamente mi riferisco ai sistemi desktop: in quelli embedded o similari la FPU spesso continua a essere un sogno).
Ultima cosa: non c'è scritto da nessuna parte che un linguaggio debba sottostare pienamente agli standard IEEE in materia di calcoli in virgola mobile. In genere ciò è lasciato all'implementazione.
Ma non solo: all'interno della stessa implementazione del linguaggio non è detto che venga seguito lo standard. Vedi, ad esempio, i calcoli FP delle unità SIMD (SSE), che in tante situazioni vengono eseguiti in maniera più "rilassata" (mi riferisco alle specifiche IEEE) rispetto a quelli eseguiti con la FPU.
Questo, però, dimostra un'altra cosa: non solo tutto ciò non dipende dal s.o., ma nemmeno dal compilatore. E' "colpa" dell'architettura della CPU.
Ultima cosa: non c'è scritto da nessuna parte che un linguaggio debba sottostare pienamente agli standard IEEE in materia di calcoli in virgola mobile. In genere ciò è lasciato all'implementazione..
Il funzionamento di molti algoritmi si basa su due assiomi direttamente derivati dalle specifiche IEEE, per questo sono cosi anal sul rispettarle.
Per quanto riguarda l'approccio che dovrebbe essere piu pratico, ti do perfettamente ragione.
#include <stdio.h>
#include <stdlib.h>
#define PI 3.14159265358979323846264338327
int main() {
int i, count = 0;
double x, y;
for (i=0; i<1000; i++) {
x=drand48();
y=drand48();
// printf("%f - %f - ", x, y);
if (x*x+y*y < 1) count++;
}
count=4*count/1000;
printf("%.16f %.16f %.16f \n", count, PI, PI-count );
return 0;
}
Non scrivo una riga di C da quasi un lustro quindi potrei dire una cavolata ma f è per i float a precisione singola mentre tu stai usando dei double. Forse la d potrebbe essere Double... non ricordo :p
DanieleC88
19-10-2008, 15:33
Non scrivo una riga di C da quasi un lustro quindi potrei dire una cavolata ma f è per i float a precisione singola mentre tu stai usando dei double. Forse la d potrebbe essere Double... non ricordo :p
No, la %d stampa interi, a lui forse possono interessare di più %e o %g. :)
O anche %lf, se non vuole rappresentazioni esponenziali o approssimate. ;)
Il funzionamento di molti algoritmi si basa su due assiomi direttamente derivati dalle specifiche IEEE, per questo sono cosi anal sul rispettarle. :eek:
significa che programmi col didietro? :asd:
senti, che ne dici piuttosto di rispondere a tutto quello che non hai quotato dell'ultimo messaggio di cdimauro, in particolare la prima parte:
Basta con questi esercizietti: stiamo ancora aspettando la DIMOSTRAZIONE che Windows alteri le operazioni matematiche, mentre Linux no.
? :rolleyes:
PS: e scusa se è da ieri che io ormai non partecipo più al thread, ma oltre ad aver avuto molto da fare ho notato che una caterva di altre persone ti stavano già bastonando a sufficienza :asd:
:eek:
significa che programmi col didietro? :asd:
no in inglese vuol dire essere pignoli in senso cattivo
senti, che ne dici piuttosto di rispondere a tutto quello che non hai quotato dell'ultimo messaggio di cdimauro, in particolare la prima parte:
PS: e scusa se è da ieri che io ormai non partecipo più al thread, ma oltre ad aver avuto molto da fare ho notato che una caterva di altre persone ti stavano già bastonando a sufficienza :asd:
ma se ho pure risposto alla battutina acida
In primo luogo vatti a ripassare la definizione di sistema operativo, che per un programmatore è ben nota, ma che per un matematico che ha sempre vissuto nel suo mondo ideale e da poco s'è affacciato a quello reale molto probabilmente sarà sconosciuta.
Con una risposta rilassata perchè volevo abbassare il tono della discusisone!
Purtroppo sotto mano non ho una copia di windows, come ho già detto domani vado in università dove ho sia win che linux.
Purtroppo sotto mano non ho una copia di windows, come ho già detto domani vado in università dove ho sia win che linux. hai sostenuto la tua tesi finora e con fermezza, quindi ora vogliamo sapere su quali basi e vogliamo saperlo ora. non ti serve Windows per esporre la tua dimostrazione: eventualmente hai in MSDN tutta la documentazione necessaria online, ed in caso ci stanno pure i manuali delle architetture Intel online sul sito della Intel (che non dovrebbero servirti visto che si parla solo del sistema operativo). stupiscici :)
mi dispiace ma qui niubbi e lamer devono morire :asd:
variabilepippo
19-10-2008, 19:55
Purtroppo sotto mano non ho una copia di windows, come ho già detto domani vado in università dove ho sia win che linux.
Ed a cosa ti servono Windows e Linux?! Noi vogliamo sapere come, quando e perché Linux "sa fare i calcoli meglio di" Windows... Aspettiamo un riferimento (paper, articolo, libro, ...) che spieghi in che modo un sistema operativo, a parità di codice macchina/hardware, influenzi i risultati.
Spero sia chiara la questione. :)
cdimauro
19-10-2008, 20:06
ma se ho pure risposto alla battutina acida
[...]
Con una risposta rilassata perchè volevo abbassare il tono della discusisone!
Proprio alla mia "battuta" (che non era solo tale, ma anche e soprattutto un invito a seguire il consiglio) non hai risposto. :O
Purtroppo sotto mano non ho una copia di windows, come ho già detto domani vado in università dove ho sia win che linux.
Come ti hanno già detto, non credo ti servirà.
aiuto aiuto mi attaccano da tutte le parti!
http://software.intel.com/en-us/articles/intel-fortran-compiler-default-floating-point-precision-differs-between-linuxmac-os-and-windows
http://ds9a.nl/fp/
eheheheh
cdimauro
19-10-2008, 20:15
aiuto aiuto mi attaccano da tutte le parti!
http://software.intel.com/en-us/articles/intel-fortran-compiler-default-floating-point-precision-differs-between-linuxmac-os-and-windows
E' un limite del compilatore Fortran, non del s.o..
Non a caso parla di DEFAULT (quindi valore PREDEFINITO) del s.o.., non di valore IMPOSTO (ma soprattutto NON MODIFICABILE) dal s.o..
Tant'è che altri linguaggi e/o compilatori posso usare gli extended che mi consentono di utilizzare tranquillamente i float a 80 bit e con 64 bit di mantissa.
http://ds9a.nl/fp/
eheheheh
Questo non dice proprio nulla sull'argomento in questione.
variabilepippo
19-10-2008, 20:18
http://software.intel.com/en-us/arti...os-and-windows
Questa sarà la quarta volta che ti dico che è possibile modificare le impostazioni di default con UNA riga di codice (http://msdn.microsoft.com/en-us/library/e9b52ceh(VS.80).aspx).
_MCW_PC (Precision control)
_PC_24 (24 bits)
_PC_53 (53 bits) (default)
_PC_64 (64 bits)
Questa sarà la quarta volta che ti dico che è possibile modificare le impostazioni di default con UNA riga di codice (http://msdn.microsoft.com/en-us/library/e9b52ceh(VS.80).aspx).
scusami quel link è molto interessante e me l'ero perso, questo thread per davvero sta crescendo molto in fretta. Forse in effetti è da quello che nasce la differenza tra i comportamenti osservati a scuola tra windows e linux. Devi ammettere che quello è una istruzione cosi particolare che è improbabile che un normale matematico conosca. Da noi purtroppo gli informatici non ci sono.
Seconda cosa: passare da 53 a 64 bit è un trucchetto che conoscevo anche io, ma come ti ho detto non è gratis: gli 11 bit normalmente non è che non vengano usati, ma si usano per rappresentare esponente e posizione della virgola. Passare a 64 bit permetterà una rappresentazione piu fedele dei numeri molto piccoli, ma sarà piu imprecisa sui numeri molto grandi.
cdimauro
19-10-2008, 20:38
scusami quel link è molto interessante e me l'ero perso, questo thread per davvero sta crescendo molto in fretta. Forse in effetti è da quello che nasce la differenza tra i comportamenti osservati a scuola tra windows e linux. Devi ammettere che quello è una istruzione cosi particolare che è improbabile che un normale matematico conosca. Da noi purtroppo gli informatici non ci sono.
Allora avevo ragione: http://www.hwupgrade.it/forum/showpost.php?p=24603441&postcount=5 :cool: :p
Seconda cosa: passare da 53 a 64 bit è un trucchetto che conoscevo anche io, ma come ti ho detto non è gratis: gli 11 bit normalmente non è che non vengano usati, ma si usano per rappresentare esponente e posizione della virgola. Passare a 64 bit permetterà una rappresentazione piu fedele dei numeri molto piccoli, ma sarà piu imprecisa sui numeri molto grandi.
Falso anche questo: perché con la precisione estesa non solo la mantissa da 53 diventa a 64 bit, ma l'esponente passa da 11 a 16 bit.
E in ogni caso, chi se ne frega. Prima ti stracciavi le vesti perché "Windows era limitato" (mentre gli altri s.o. no).
Adesso scopri che le impostazioni di default possono essere tranquillamente aggirate, ma non ti sta bene lo stesso.
A questo punto non si capisce dov'è che tu voglia andare a parare... :rolleyes:
rеpne scasb
19-10-2008, 20:50
■
rеpne scasb
19-10-2008, 20:58
■
Hai le idee confuse. Per chiarirti le idee ti consiglio la lettura dello standard IEEE 754 a cui le FPU x86 aderiscono.
ARINOTA A MARGINE: numeri rappresentabili in funzione del numero di bit su FPU x86:
32 - da 1.18x10^-38 a 3.40x10^38
64 - 2.23x10^-308 a 1.79x10^308
80 - 3.37x10^-4932 a 1.18x10^4932
Grazie mille per le precisazioni, sei molto gentile.
Ragazzi domani vi giuro che parlo col mio prof e gli chiedo.
Grazie mille per le precisazioni, sei molto gentile.
Ragazzi domani vi giuro che parlo col mio prof e gli chiedo.
Ok, facci sapere quello che ti risponde.
DanieleC88
19-10-2008, 21:49
Credevo di aver dimostrato bene nella pratica, qualche pagina fa e una volta per tutte, dov'erano le differenze tra Windows e Linux, ma a quanto pare non è bastato... :D
Credevo di aver dimostrato bene nella pratica, qualche pagina fa e una volta per tutte, dov'erano le differenze tra Windows e Linux, ma a quanto pare non è bastato... :D
si ma tu usavi una macchina virtuale, non vale :D:D Non mi fido perchè il SO non ha diretto accesso all'HW
variabilepippo
19-10-2008, 22:10
si ma tu usavi una macchina virtuale, non vale Non mi fido perchè il SO non ha diretto accesso all'HW
Nei miei test io non ho usato macchine virtuali, almeno di quelli avresti potuto fidarti... ;)
Spero sia chiaro che lo scopo di un sistema operativo non sia quello di manomettere i calcoli, visto che i calcoli, in ultima istanza, vengono effettuati dall'hardware e non dal software (a meno di operare in emulazione).
Nei miei test io non ho usato macchine virtuali, almeno di quelli avresti potuto fidarti... ;)
Spero sia chiaro che lo scopo di un sistema operativo non sia quello di manomettere i calcoli, visto che i calcoli, in ultima istanza, vengono effettuati dall'hardware e non dal software (a meno di operare in emulazione).
Allora. Mi sa che avete ragione. MA PRIMA di arrivare ad ammetterlo voglio giocare ogni singola possibile carta. E mi è avanzato l'asso di briscola: chiedere al prof. Eheheheh :p
DanieleC88
19-10-2008, 22:17
si ma tu usavi una macchina virtuale, non vale :D:D Non mi fido perchè il SO non ha diretto accesso all'HW
Guarda che era ||ElChe||88 quello della macchina virtuale, io non ne ho mai usate in vita mia... Anzi, ho detto più volte "ora riavvio che vado a disassemblare su Visual C++", "un attimo che torno su Linux e aggiungo questo per GCC"... Rileggi i messaggi di qualche pagina fa, ho spiegato anche da dove nasceva la differenza nella precisione, ed era "colpa" di un diverso compilatore. :D
ciao ;)
cdimauro
19-10-2008, 22:32
Allora. Mi sa che avete ragione. MA PRIMA di arrivare ad ammetterlo voglio giocare ogni singola possibile carta. E mi è avanzato l'asso di briscola: chiedere al prof. Eheheheh :p
Ci starei attento nel definire "asso di briscola" un prof. Bisogna vedere che prof, visto che le università sono piene di gente che non sono finite lì per meriti, e alcuni dovrebbe andare ad arare i campi (a mani nude, perché la zappa è uno strumento troppo complicato da usare; e poi si evitano danni peggiori :asd:). :O
variabilepippo
19-10-2008, 22:36
E mi è avanzato l'asso di briscola: chiedere al prof.
Credo che il parere del tuo prof conti quanto il 2 di spade con briscola a coppe... Ti è stato dimostrato con diversi approcci quali sono i fattori che incidono sulla precisione dei calcoli ed i sistemi operativi non sono tra questi. :rolleyes:
non ha ancora risposto la mail... spettate...
DanieleC88
20-10-2008, 16:58
E chi si muove? :D
ora chissà che gli ha scritto :rolleyes:
ora chissà che gli ha scritto :rolleyes:
eheheeh
Buonasera prof,
sono lo studente #123456, volevo chiederle una cosa: lei conosce qualche motivo per cui una computazione floating point sotto windows possa essere meno precisa della stessa sotto linux? Mi pare ci avesse accennato qualcosa durante il suo corso....
Grazie mille
khelidan1980
20-10-2008, 19:07
adesso seriamente se una cosa fosse vera ti sembra normale che non ci sia in giro nemmeno un paper,qualcosa?Credo qualcuno si sia già scontrato con questioni riguardanti la precisione dei floating point
dato che siamo OT (anche se mi ha affascinato):
ora capisco come un cluster di win ccs sia riuscito ad umiliare un cluster linux (pari hw, con un codice cfd) in un test fatto da hp (ovviamente lo zampino ms :D )...
dimentica le cifre e fa prima!!!!
bio
ps: ovviamente scherzo... :D ma non sul fatto il cluster windows ha "umiliato" (non ricordo i numeri ma erano mooolto vicini) quello linux...
dato che siamo OT (anche se mi ha affascinato):
ora capisco come un cluster di win ccs sia riuscito ad umiliare un cluster linux (pari hw, con un codice cfd) in un test fatto da hp (ovviamente lo zampino ms :D )...
dimentica le cifre e fa prima!!!!
bio
ps: ovviamente scherzo... :D ma non sul fatto il cluster windows ha "umiliato" (non ricordo i numeri ma erano mooolto vicini) quello linux...
A proposito di cluster, in Ferrari (dove di sicuro non possono permettersi errori nei conti) usano Windows http://www.mclips.it/archive/2008/10/19/windows-hpc-server-2008-prestazioni-da-formula-1.aspx
A proposito di cluster, in Ferrari (dove di sicuro non possono permettersi errori nei conti) usano Windows http://www.mclips.it/archive/2008/10/19/windows-hpc-server-2008-prestazioni-da-formula-1.aspx
Di sicuro però si possono permettere di farsi sponsorizzare da M$ in cambio del ritorno economico!
I 5 piu potenti supercalcolatori al mondo usano linux...
E li usano persono mooolto piu competenti del team ferrari...
Di sicuro però si possono permettere di farsi sponsorizzare da M$ in cambio del ritorno economico!
I 5 piu potenti supercalcolatori al mondo usano linux...
E li usano persono mooolto piu competenti del team ferrari...
ci sono usi e usi...e i risultati su windows sono stati dimostrati da molti test....e oserei dire che se su windows sbagliassero, nessuno lo userebbe :D
per esempio alla ferrari usano lo stesso software cfd che usiamo noi...
forse con qualche differenza :D (licenze, cluster)...
forse non solo :sofico:
bio
||ElChE||88
20-10-2008, 21:31
Di sicuro però si possono permettere di farsi sponsorizzare da M$ in cambio del ritorno economico!
O magari per le loro esigenze va meglio Windows. :)
DanieleC88
20-10-2008, 21:32
ora capisco come un cluster di win ccs sia riuscito ad umiliare un cluster linux (pari hw, con un codice cfd) in un test fatto da hp (ovviamente lo zampino ms :D )...
Umiliare rispetto a cosa? Anche stavolta numeri in virgola mobile?
Wlog non mischiare pere e mele.
Il problema che riporti tu è dovuto ai compilatori usati.
Anche sotto linux puoi trovare lo stesso problema. Basta prendere un compliatore C differente. Nel senso che usa politiche differenti per trattari i numeri in virgola mobile.
Se ad esempio riesci a prendere due compilatori della stessa Software House, uno scritto per Linux e uno scritto per Windows, avranno stessi pregi e stessi difetti. O entranmi sbagliano, o entrambi indovinano sugli esempi che hai postato.
Forse per Linux esistono compilatori C migliori che per Windows. Ma questo non è una colpa che puoi attribuire a tutto il SO, ma a chi ha implementato quel compilatore per quel SO.
Umiliare rispetto a cosa? Anche stavolta numeri in virgola mobile?
ho toccato un nervo dolente per un linuxaro? avere windows che su un cluster ha performance migliori di linux?
in questo caso aggiungo...in altri pure, in altri casi non sarà così...
windows non significa solo xp home...significa una serie di prodotti dedicati all'hpc molto validi (pur essendo made in microsoft)...linux ovviamente ha pure molti vantaggi...ma ad ognuno il proprio campo di applicazione...
bio
DanieleC88
21-10-2008, 08:20
ho toccato un nervo dolente per un linuxaro? avere windows che su un cluster ha performance migliori di linux?
Ma fammi il piacere, se è tutta la discussione che sto difendendo Windows... :D
Sono "Linuxaro", sì, ma mi piace pensare che potrò essere un "informatico" in un futuro, e la prima cosa per diventarlo è essere obiettivi. Semplicemente, come prima non ho accettato la tesi di wlog che non era supportata da alcuna vera motivazione, sto chiedendo anche a te la stessa cosa, e cioè di dare motivazioni/dati/definizioni dei problemi affrontati per cui le "performance" di Windows siano risultate così "superiori" da diventare "umilianti".
E poi bisogna vedere che tipo di performance si sta misurando, e se sono mission-critical in qualche contesto. Insomma, come affermazione potrai ammettere che la tua sapeva molto di fanboy (non sto dicendo che tu lo sia). Ti ho solo invitato, quindi, a renderci più acculturati, come prima avevo fatto con wlog.
ciao ;)
E poi bisogna vedere che tipo di performance si sta misurando
i test che ho visto sono prettamente di prestazioni su un software specifico di fluidodinamica, dove la parallelizzazione su windows ha avuto tempi di calcolo inferiori...
ma era solo una mezza provocazione dopo un thread passato a dare contro al calcolo numerico su windows :D
oltre a ferrari (che di modelli complessi ne fa girare abbastanza) un'altra azienda italiana che fa solo simulazioni cfd/fem ha fatto un nuovo cluster windows (dismettendo il vecchio cluster linux)...
e il raffrondo anche su modelli molto piccoli (esecuzione in circa 2 minuti sul mio pc) ha dimostrato che vista è + veloce di linux con l'MPI (alla faccia di wlog che lo dice + interfacciabile su linux :D )...
bio
DanieleC88
21-10-2008, 19:34
Bene, ora abbiamo imparato che non solo Windows consente alla macchina di avere la stessa potenza di calcolo di Linux, ma che addirittura la migliora! :ciapet:
Be', sarà vero, nel qual caso tanto di cappello alla Microsoft. Ma per il motivo di cui sopra non accetto a priori le affermazioni del tipo "Tizio mi ha detto che Caio ha visto che l'azienda Sempronio ha messo Windows perché è risultato migliore". :D
Anche la mia, intesi, è solo una provocazione, dopo un'intera discussione a favore del calcolo numerico su Windows (rileggila bene :D).
ciao ;)
DanieleC88
21-10-2008, 19:34
EDIT: doppio, sorry.
e il raffrondo anche su modelli molto piccoli (esecuzione in circa 2 minuti sul mio pc) ha dimostrato che vista è + veloce di linux con l'MPI (alla faccia di wlog che lo dice + interfacciabile su linux :D )...
bio
Quindi quelli del cineca (i proprietari del piu grande supercomputer italiano) hanno preso una cantonata.
Mò vaglielo a spiegare tu... Digli: uè ragazzi la ferrari mi ha detto che windows è meglio!
windows non significa solo xp home...
bio
significa anche BSOD :D:D:D:D:D
Quindi quelli del cineca (i proprietari del piu grande supercomputer italiano) hanno preso una cantonata.
ho sempre detto dipende, anche perchè probabilmente l'ottimizzazione del software è la responsabile di questa differenza...
Mò vaglielo a spiegare tu... Digli: uè ragazzi la ferrari mi ha detto che windows è meglio!
penso proprio dipenda dall'ottimizzazione del software...quindi ad ogni caso il suo..
significa anche BSOD :D:D:D:D:D
qualche annetto che anche con xp i bsod sono spariti :D
bio
^TiGeRShArK^
22-10-2008, 12:17
significa anche BSOD :D:D:D:D:D
certo che bisogna essere davvero dei geni ad avere delle BSOD nel 2008 :asd:
certo che bisogna essere davvero dei geni ad avere delle BSOD nel 2008 :asd:
lascia stare che programmare con le schede grafiche è figo si, ma al primo buffer overflow l'X server va a puttane... sto riavviano ogni 15 minuti...
lascia stare che programmare con le schede grafiche è figo si, ma al primo buffer overflow l'X server va a puttane... sto riavviano ogni 15 minuti...
Ecco perché preferisco i linguaggi managed...
^TiGeRShArK^
22-10-2008, 14:29
Ecco perché preferisco i linguaggi managed...
si può usare anche python con CUDA, ma i kernel, se non ricordo male, vanno passati per forza da una funzione C....
^TiGeRShArK^
22-10-2008, 14:31
cmq ho appena trovato questa:
http://www.txcorp.com/technologies/GPULib/index.php
che forse potrebbe servire :p
si dovrebbe interfacciare anche con matlab....
Ecco perché preferisco windows...
Fixed... a proposito di linux bashing :asd:
Scommettiamo che su Win non si doveva riavviare alcunchè? :asd:
Fixed... a proposito di linux bashing :asd:
Scommettiamo che su Win non si doveva riavviare alcunchè? :asd:
Eh? Mi puoi spiegare cosa volevi dire?
Che io preferisca Windows non è un mistero, però qui non mi pare c'entri molto.
Però potresti approfondire cosa succede con Vista dato che ha i driver video in User Mode. Non credo ci sarebbe stata una BSOD...
DanieleC88
22-10-2008, 15:43
Bah, un thread nato per aiutare un poveretto ad iniziare a programmare in C è finito ad essere il solito thread del tipo "scommettiamo che il mio OS ce l'ha più lungo del tuo?"... per giunta senza dare motivazioni plausibili né in un caso né nell'altro. Che pena. :rolleyes:
^TiGeRShArK^
22-10-2008, 15:48
Bah, un thread nato per aiutare un poveretto ad iniziare a programmare in C è finito ad essere il solito thread del tipo "scommettiamo che il mio OS ce l'ha più lungo del tuo?"... per giunta senza dare motivazioni plausibili né in un caso né nell'altro. Che pena. :rolleyes:
Io almeno gli ho postato qualche link utile :O
e comunque io ce l'ho + lungo di qualsiasi OS :O
:asd:
DanieleC88
22-10-2008, 15:50
Io almeno gli ho postato qualche link utile :O
Be' almeno non è stato tutto inutile il thread. :D
e comunque io ce l'ho + lungo di qualsiasi OS :O
:asd:
LOL :asd:
Eh? Mi puoi spiegare cosa volevi dire?
Che io preferisca Windows non è un mistero, però qui non mi pare c'entri molto.
Però potresti approfondire cosa succede con Vista dato che ha i driver video in User Mode. Non credo ci sarebbe stata una BSOD...
Non ce l'avevo con te, mi sono ispirato alla tua frase per quotare wlog: infatti lui è partito dicendo che linux è sempre migliore per programmare in C, ma ora ha addirittura ammesso che basta fare un errore in CUDA per dover riavviare l'interfaccia grafica.
Cosa che dubito fortemente accada anche in windows.
Tutto qua.
PS: io non parteggio per nessun OS eh :stordita:
Non ce l'avevo con te, mi sono ispirato alla tua frase per quotare wlog: infatti lui è partito dicendo che linux è sempre migliore per programmare in C, ma ora ha addirittura ammesso che basta fare un errore in CUDA per dover riavviare l'interfaccia grafica.
Cosa che dubito fortemente accada anche in windows.
Tutto qua.
PS: io non parteggio per nessun OS eh :stordita:
Ok ;)
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.