Newsgroup: it.comp.lang.javascript
Titolo: Torniamo a Netscape 2 ?

Se qualche cliente ci chiedesse di fare i calcoli balistici per un 
missile, raccomandiamogli di usare Netscape 2 per il tutto.
Poco fa, mentre preparavo un po' FAQ per Go!OnLine ho deciso di parlare 
anche del famoso "problema" dei numeri in virgola mobile per cui 0.229*
100 restituisce 22.900000000000002 
Vari thread sull'argomento si trovano facilmente con Google, l'ultimo su 
un post di Wallace dal subject "Arrotondamento Strano!".
Comunque, mentre scrivevo che qui abbiamo riscontrato il "problema" su 
praticamente qualsiasi browser avessimo sottomano e su varie piattaforme 
HW/SW ho deciso di fare la prova del nove ed ho aperto anche 
Netscape3.01 e Netscape2 che ho installati (non chiedetemi perche', 
nostalgia forse :-)... ebbene non ci crederete, ma non sono riuscito a 
far fallire Netscape2!!!!
E si che ho provato varie operazioni che mi davano risultati falsati 
negli altri browser.
Peccatato che anche lui faccia Math.round(-2.5) = 2 
:-(((
p.s. per Zer0
Prima di bacchettarmi di nuovo, nota le virgolette attorno alla parola 
"problema" :-))
-- 
Ciao, Riccardo
------------------------------------------------------------------------
http://www.jsdir.com
 ---- Bring Your Site To Life!!!!
------------------------------------------------------------------------
http://www.dev2dev.it
 - La rete ha connesso nuove particelle - D2D006
------------------------------------------------------------------------
Per rispondere: togli il PUNTO e metti un .

 "problema" :-))
Non bastano. Le bacchettate sono indipendenti da questo.
Si potrebbe solo agire statisticamente e scrivere uno "Zer0 Validator" che
autoapprende dalle casistiche.
E comunque, come si dice dalle mie parti: quando "ha voglia di zucca gialla"
non c'e' nulla da fare...

 Peccatato che anche lui faccia Math.round(-2.5) = 2
Scusa? Math.round(-2.5) dovrebbe tornare -2 (e non -3, siamo sui numeri
negativi!!)??
Ciao,
Marco
-- 
//\/\ Marco (LM) Lamberto
      e-mail:            
marcol...@despammed.com
      SIForge.org     -  
http://www.siforge.org/

 l'errore), non ha parlato di -3.
Credevo fosse un typo (2 per -2). Chiedo scusa.;) 


 non c'e' nulla da fare...
E che vor di'?


 negativi!!)??
Perche' dovrebbe tornare -2?
Ho sbagliato, in effetti, ho dimenticato il segno -
Dovevo scrivere:
"Peccatato che anche lui faccia Math.round(-2.5) = -2 "
Ma secondo me (ed Excel) dovrebbe tornare -3, perche' (ed un amico mi 
conferma in questo istante su ICQ) se non ricordo male 
nell'arrotondamento si opera sempre e comunque sul valore assoluto 
CONSERVANDO il segno.


 IE5 N4 N7 MOZ1.3 OP6 N3 N2 Phoenix
Sorry, non mi ero accorto dell'errore, intendevo (ripeto):
" Math.round(-2.5) = -2 "


 " Math.round(-2.5) = -2 "
Secondo me questo è il risultato corretto, nonostante quello che ne dice
Excel. La regola generale è che, se la cifra decimale è 5, il numero si deve
arrotondare all'intero superiore; e l'intero superiore è -2 e non -3.
D'altra parte Math.round dovrebbe essere del tutto equivalente a:
    Math.floor(x + 0.5)
qualunque sia x (positivo o negativo).
Lo stesso risultato (-2) si ha anche in altri linguaggi che hanno maggiori
pretese in fatto di precisione; per  esempio in java.
Maurizio.

 E che vor di'?
Pardon. Il modo romagnolo meno volgare di fare un cocktail tra: "quando ha i
cazzi suoi", "quando ha voglia di trovar da dire a tutti costi" e "tutto
questo, tra l'altro, deve proprio dirlo a me". La traslazione ironica e'
lavoro del ricevente.

 pretese in fatto di precisione; per  esempio in java.
Oh, finalmente non diremo più che questi linguaggi (Java e JavaScript) hanno
in
comune solo le prime 4 lettere, ma anche dei Mega bachi giganti carnivori :)
Oddio mai come quello di VBScript che addirittura sbaglia pure con i numeri
positivi! Infatti Round(2.5,1) ha il coraggio di restituire 2
P.S.
Sarà il caso di spiegare come stanno le cose,
allora vediamo di scrivere "La regola generale":
Il sistema di numerazione decimale è un sistema posizionale a base 10, cioè
con sequenze di 10 cifre {0,1,2,3,4,5,6,7,8,9} (che chiameremo C), si
possono rappresentare tutti i numeri. Grazie a Dio o agli indiani, 10 è un
numero pari e la sua metà è 5 che chiameremo M, pertanto si possono fare due
sotto-insiemi composti da M cifre l'uno: C1{0,1,2,3,4} e C2{5,6,7,8,9}.
Consideriamo per semplicità il caso di un numero con un solo decimale:
±xy.z     dove x,y,z ? C (?="appartiene a") e ± è il segno + o -
Arrotondare questo numero a intero, vuol dire sostituirlo con l'intero più
vicino (che chiameremo I). Quindi avremo 2 casi:
-    se z ? C1 sarà sufficiente eliminarlo e avremo: I=±xy
-    se z ? C2 bisogna eliminarlo e incrementare: I=±(xy+1)
Facciamo qualche esempio numerico:
+10.2=>10      10.5=>10+1=11       -2.2=>-2       -2.8=>-(2+1)=-3
Il numero -2.5 rientra nel secondo caso e buonanotte!!!
Però qualcuno ha i bachi nel computer e in testa?!?
Gianni

 se z ? C2 bisogna eliminarlo e incrementare: I=±(xy+1)
Questa è la tua interpretazione di "arrotondare all'intero più vicino". In
realtà 5 sta esattamente in mezzo e non è più vicino a niente; come si fa a
dire che 2.5 è più vicino a 3 che a 2? Se la matematica non è un'opinione,
3-2.5 = 0.5 e 2.5-2 = 0.5. Cioè 2.5 è ugualmente vicino tanto a 3 che a 2
per cui è necessaria una convenzione (che è appunto quella di arrotondare
all'intero superiore).
Faccio solo notare come seguendo il tuo modo di ragionare si arriverebbe ad
un'anomalia che mostro con un esempio. Limitandoci ad una sola cifra
decimale, i numeri che si arrotondano a 1 sono tutti i numeri compresi fra
0.5 e 1.4 (10 numeri). In generale un numeri che vengono arrotondati ad n
sono quelli compresi fra n - 0.5 e n + 0.4. Secondo il tuo modo di vedere,
invece, a 0 verrebbero arrotondati solo i numeri compresi fra 0.4 e -0.4
(solo 9 numeri).
Maurizio.

 all'intero superiore).
Uhm, in questo potrei essere d'accordo con Gianni dato che prima 5 è il 6°
numero decimale che si può incocciare (se includiamo 0)
{ 2.0, 2.1, 2.2, 2.3, 2.4 }
{ 2.5, 2.6, 2.7, 2.8, 2.9 }
Per il resto concordo sul fatto che vedere i post di Gianni è come sentirsi
un martello pneumatico su parti delicate del corpo che non sto a citare.
Ciao ciao!
Claudio Di Vicino
Homepage: 
http://www.kynes.it

[ ...cut, calmati e cambia spacciatore... ]
L'esempio di cui discutiamo, perche' e' ovvio che non parliamo di bug, e'
presentato anche nella reference di js.
Premesso che io ricordo la "regola" come la ricorda Maurizio e che allo
stesso modo si comportano vari linguaggi di programmazione (Java, C#,
Javascript, JScript, VB, VBScript e chi ha voglia di fare altre prove le
faccia).
La nostra "regola", ma chiamiamola convenzione, salta comunque in alcuni di
questi: C# con Math.Round(2.5,0) risponde 2 come VB e il suo derivato, a
differenza di Javascript e figlio.
Fine premesse. Consideriamo che il fine di un arrotondamento e'
semplicemente quello di fare l'errore minore possibile.
Qui scattano le convenzioni perche' nel caso di 2.5 come di -2.5 l'errore
che si commetterebbe scegliendo uno o l'altro intero (maggiore e minore) e'
lo stesso.
Alcuni in Fisica addirittura hanno l'abitudine di scegliere sempre l'intero
pari per comodita' di calcolo.
La discussione sarebbe interessante se fosse sullo scopo delle convenzioni
usate.

 100 restituisce 22.900000000000002 
Se ti serve per scrivere un articolo, ti consiglio di spulciarti qualche 
documentazione tecnica a riguardo sulla gestione dei numeri in floating 
point. Anche la doc di JScript ha qualche accenno, se non erro.
-- 
C'ya,
ZER0
  :. job profile - coder.gfxer.webDesigner
"when you eliminate the impossible, whatever remains, however 
improbable, must be the truth" (S.H.)

 Maurizio.
Gianni
P.S.
Ahh, mi devo essere contagiato :)
Ci riprovo scrivendo quello che mi ha spiegato il mio nipotino :))
Siamo tutti d’accordo che la semplice definizione di arrotondamento non è
sufficiente in questo caso, e per questa strada non ne usciamo vivi;
tuttavia non è vero che dobbiamo gridare alla convenzione a tutti i costi!
Proviamo ad usare il buon senso!
Infatti perché privilegiare gli arrotondamenti per eccesso (che è quello che
stanno facendo chi adotta "la convenzione del miticoMauri").
Infatti, dato un numero intero considerando per semplicità la sequenza dei
suoi primi dieci decimali si ha:
{±x.0 ±x.1 ±x.2 ±x.3 ±x.4 ±x.5 ±x.6 ±x.7 ±x.8 ±x.9}
Dovrebbe essere logico a tutti che, tra le altre cose, 5 di questi numeri
sono destinati ad essere arrotondati per difetto e gli altri 5 per eccesso
e NON 4 e 6 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Quasi quasi faccio una nuova proposta di convenzione che chiameremo
"Gianni convention" (adesso mio nipote non centra....):
Arrotondiamo i numeri pari per difetto e quelli dispari per eccesso :))
IO NON LO SO!!!!!!!! Forse ci sarebbero meno discussioni!?!

 che non sto a citare.
:"((    :"((    :"((
Questa generalizzazione e diffamazione gratuita non l'ho molto gradita e la
ritengo non esattamente veritiera! Basti guardare l'abbondanza delle mie
risposte e la generosità nel postare le soluzioni in forma di codice e di
consigli...
Killato!

 usate.
Esatto, che scopo ha questo razzismo! Ci sono quei poveri numeri decimali
negativi arrotondati per difetto che si sentono tanto "inferiori"...   ;-)

 Killato!
Peccato, non leggerai il mio post :P
Però se io rispondo a qualcuno, è un peccato che tu rispondi con una
soluzione simile o uguale alla mia, non ti pare? Perderesti tempo..

 {2.0,2.1,2.2,2.3,2.4} {2.5} {2.6,2.7,2.8,2.9,3.0}
Beh, non mi sembra molto lecito, poi 3.0 si ripeterebbe nel prossimo
intervallo?
{3.0,3.1,3.2,3.3,3.4}...
Dopotutto le cifre decimali sono 10, e se consideriamo un certo intervallo
dove le cifre decimali compaiono un'unica volta, lo zero non puň che
apparire solo in 2.0, 3.0, come inizio della stringa

 CONSERVANDO il segno.
Spiacente, ti sbagli: il segno conta; prova con Java e vedrai che sarà
uguale pure lì
L'idea è che tu aggiungi 0.5 e togli le cifre decimali, qualunque sia
il segno :P

 Capito?
-2
Trattandosi di numeri negativi .3 è maggiore di .5 :P

 il segno :P
"Aggiungi" anche se i numeri sono minori di zero?
Attenzione che qui non si scherza... il "+" è sottinteso, il "-" no :-)
Se tanto mi da tanto dovrei sottrarre... il che equivale a dire 
"arrotondare il valore assoluto conservando il segno" come mi sembra sia 
la procedura corretta.
Mi arrotondi questi?
-0.5
-0.6
-0.7
-0.8
-0.9
-1.0
-1.1
-1.2
-1.3
-1.4
-1.5
-1.6
-1.7
-1.8
-1.9
-2.0
-2.1
Non con il computer, ma "secondo te" :-)


 point. Anche la doc di JScript ha qualche accenno, se non erro.
No, niente di cosi' complesso, solo una faq di una 15-ina di righe.
Che ne pensi tu della questione Math.round(-2.5)=-2 o -3 ?


 il segno :P
E lì il bug! Inece deve essere:
public static long round(double a)
{
    return (a>0)?(long)Math.floor(a+0.5):(long)Math.ceil(a-0.5);
}
Però i diritti d'autore li ho regalati al miticoMauri!

 la procedura corretta.
Bravo Ric!
public static long round(double a)
{
    return (a>0)?(long)Math.floor(a+0.5):(long)Math.ceil(a-0.5);
}
Perň i diritti d'autore li ho regalati al miticoMauri!

 e NON 4 e 6!!! Sarebbe ingiustificato avere una preferenza!
Ma cos'e' democrazia o matematica?
Per par condicio allora togli pure lo zero visto che anche con lui
"l'errore" sarebbe lo stesso e i conti ti tornano.
Ne abbiamo quattro e quattro e due che possono scegliere (il cinque col buon
senso l'altro, lo zero, poverino, e' rimasto incastrato dal sistema).

 Che ne pensi tu della questione Math.round(-2.5)=-2 o -3 ?
Ovviamente non la penso come te. :)
Se non confondo i post, sono dello stesso parere di Maurizio, Andrea e 
Catarsi.


> Che ne pensi tu della questione Math.round(-2.5)=-2 o -3 ?
Anch'io sono curioso di sapere cosa ne pensa ZER0 e sono sicuro
che non mi deluderà! Comunque non ti basta quello che dicono:
Ansi C, C++, Pascal, Fortram, Delphi e Php e anche MatLab ???

 veramente fatta, io perdo ogni speranza verso il genere umano!
Perdila, allora.


 o altrui.
A sarcasmo e saccenza (????) ha risposto con "cretino" ora si arrangi!

 A sarcasmo e saccenza (????) ha risposto con "cretino" ora si arrangi!
Ma ti sei reso conto del reply che gli hai fatto? E' stato fin troppo un 
signore, al contrario di te, ed e' rimasto nel "politically correct" 
della nettiquette, sempre al contrario di te.


 Perdila, allora.
:"((

 Ansi C, C++, Pascal, Fortram, Delphi e Php e anche MatLab
...continui imperterrito a pensarlo.

 ...continui imperterrito a pensarlo.
Fino alla morte :))

 
Concordo pienamente con te. Basta guardare la descrizione dell'oggetto 
Math nella specifica di ECMAScript:
ECMA-232 Edition 3 - December 1999
http://www.mozilla.org/js/language/E262-3.pdf
Al paragrafo 15.8.2.15 si legge:
"round (x)
Returns the number value that is closest to x and is equal to a 
mathematical integer. If two integer number values
are equally close to x, then the result is the number value that is 
closer to [più infinito]. If x is already an integer, the result is
x.
[...]
NOTE Math.round(3.5) returns 4, but Math.round(–3.5) returns –3."
Gaetano Bigliardi

 della nettiquette, sempre al contrario di te.
Spero che almeno agli amici o le persone che legge sempre ascolti. Io
gliel'ho detto con tono 'politically-totally-incorrect' e se l'č presta.
Fortuna che mi ha killato cosě anche se gli rispondo male lui non legge piů
:P

 che chiameremo "Gianni convention"
Proposta legittima. Peccato che non viene usata da javascript nè dalla
maggior parte dei linguaggi o degli applicativi. Per quello che mi è dato da
vedere è usata solo da Excel.
Maurizio.

 Maurizio.
Gianni

 volgari che tanto ti hanno ferito e scandalizzato!
Ragassuoli... calma eh?
Non vi facevo cosi' incazzosi... ce l'ho con tutti e due... anzi per 
sedare gli animi:
         visto
che qui siamo in democrazia
         visto
che il NG non è moderato
         visto
e considerato che la Rete e' anarchica
         visto
che sono un Terrorista (L'Espresso docet :-)
        decido
che HO RAGIONE IO e tutti e due nell'angolo dietro la lavagna!
Di corsa... marsh!!!!
:-)


 Ovviamente non la penso come te. :)
Lo so... volevo solo una conferma scritta :-))


 della nettiquette, sempre al contrario di te.
UFFA! Allora io non ho insultato e/o offeso con parole scurrili!
Dacci un'occhiata: news:LHIoa.65270$
T34.1...@news2.tin.it
La mia si è limitata ad una lunga irrisione ricca di smile (e simili), di
battute, di esempi e di test, come ho già detto al diretto interessato era
dovuta all'incredulità della cosa! Mi sto ancora dando i pizzicotti :-D
Il miticoMauri (termine che si e' guadagnato successivamente) ha avuto
una reazione un po' diversa, probabilmente perche' ha degli amici che
lavorano alla Sun :))

, gianni20000
@
katamail.com
 says...

In tutta sincerita' non mi sento di appoggiarmi a nessun linguaggio di 
programmazione.
Dietro c'e' sempre un programmatore e non e' escluso che ci sia qualche 
"scuola di pensiero" o qualche particolare ragione (nonche' validissimo 
motivo che pero' ignoro) per cui il risultato non sia volutamente quello 
che ho riscontrato.
La mia idea di "fidarmi" di excel deriva da una precisa constatazione: 
sia dato per scontato che noi programmatori dobbiamo sapere 
perfettamente come funzionano le cose, dovremmo essere in grado di 
capire perche' un linguaggio ci da un particolare risultato e trattarlo 
di conseguenza, Excel invece, orientato all'utilizzatore finale, 
dovrebbe gia' di suo integrare eventuali correttivi... pensate un po' 
che succederebbe, se excel avesse torto, negli usi finanziari/monetari.
Non credo che un analista, bancario, promotore, quel che sia debba 
andare a preoccuparsi di controllare "come" arrotonda il programma... il 
programma deve gia' di suo arrotondare per bene.
Fermi docet (approssimazioni del risultato).


:-DD      ROTFL!

 NOTE Math.round(3.5) returns 4, but Math.round(–3.5) returns –3."
Appunto!
E non e' una contraddizione? "closest" vuol dire piu' vicino, non certo 
"piu' vicino maggiore o uguale".
D'altronde anche la reference 1.3 (netscape) recita:
-----------------------------------
Returns the value of a number rounded to the nearest integer.
Syntax round( x)
Description If the fractional portion of number is .5 or greater, the 
argument is rounded to the next higher integer. If the fractional 
portion of number is less than .5, the
argument is rounded to the next lower integer.
Examples
//Returns the value 20
x=Math.round(20.49)
//Returns the value 21
x=Math.round(20.5)
//Returns the value -20
x=Math.round(-20.5)
//Returns the value -21
x=Math.round(-20.51)
----------------------------------------------
E si contraddice anche questa!!!!!
Perche' prima parla di "nearest" e poi e poi spiega perfettamente che fa 
in tutt'altro modo!
IMHO!


 programma deve gia' di suo arrotondare per bene.
Adesso che servirebbe un Ingegnere (con le PALLE pero') tutti latitanti 
eh? :-))


 in tutt'altro modo!
l'intero più vicino a -20.51 è proprio -21.
Invece -20.5 è equidistante da -21 e da -20, per cui prendo il numero 
maggiore, proprio -20. Io non ci trovo contraddizioni.
Gaetano

 eh? :-))
Ehh     :"((

 maggiore, proprio -20. Io non ci trovo contraddizioni.
Io invece si, e grossa pure: supponi che per un motivo qualsiasi uno 
decide di lavorare in valore assoluto (ipotesi: tutti i valori sono <=0) 
e di ripescare il segno alla fine dei conti e straconti, per quale 
motivo dovrebbe ritrovarsi alla fine un risultato diverso che se avesse 
continuato a lavorare con il segno?
Per esempio per tracciare un grafico potrebbe essere utile traslare in 
basso (o a sx forse è piu' appropriato dire cosi') l'origine degli assi, 
non trovi che un'eventuale "media dei valori arrotondati" ne 
risulterebbe falsata?
Banalmente: se la precisione dello strumento di misura non apprezza i 
decimi si deve arrotondare per forza (salvo poi evidenziare la 
tolleranza) ed in questo caso arrotondando per eccesso invece che per 
difetto (parlo di valori reali, non assoluti) falserebbe le misure.


> Ora una cortesia: porta rispetto e smettila di affibbiare soprannomi.
Giusto miticoCatarsi   :))
Scherzo non ti incazzare pure tu...

 difetto (parlo di valori reali, non assoluti) falserebbe le misure.
Falsare una misura e' la natura stessa dell'arrotondamento, ma cerca di
farlo causando il minor danno possibile. Quando la cifra interessata, ovvero
la discriminante dell'arrotondamento, e' 1||2||3||4 siamo piu' vicini
all'intero inferiore per i numeri positivi, e a quello superiore per i
negativi. Quando e' 6||7||8||9 il contrario. Quando e' 0 siamo coincidenti
ad uno degli estremi del nostro intervallo (e non c'e' arrotondamento ne'
errore), quando e' 5 siamo equidistanti dagli estremi. L'errore commesso
sarebbe lo stesso, quindi abbiamo una scelta che puo' essere arbitraria o
ben ponderata.
Qualche post fa citavo proprio di fisici (non ricordo l'ambito) che
sceglievano di arrotondare sempre al numero pari per comodita' di calcolo,
la Netscape ha scelto per javascript l'intero maggiore forse per un motivo
simile al paragrafo che ho citato per toFixed.
P.S. per altro tuo post: continuo a preferire l'opinione di un matematico a
quella di un ingegnere...

 di valori reali, non assoluti) falserebbe le misure.
Forse non ho capito bene la domanda, ma credo di aver già risposto citando
la teoria degli errori. Le misure non sono falsate, sono soltanto affette da
errori sia se si arrotonda per eccesso o per difetto.
Maurizio.

 anche MatLab se non ti basta c'è anche Excel :))
Qual è il modo corretto?
Non so in C99, ma in nelle precedenti versioni del C e C++ non era prevista
una funzione round. Per arrotondare si usava la formula: (int)(x + 0.5). Ho
4 compilatori diversi a portata di mano (IBM e Borland) ma in nessuno vi è
la funzione round.
In Pascal non vi è un maniera standard di arrotondare. Nel vecchio Turbo
Pascal (e immagino in tutte le versioni del Pascal della Borland) veniva
usato il tuo metodo (cito testualmente):
| se Num > 0, allora Round(Num) = Trunc(Num + 0.5)
| se Num < 0, allora Round(Num) = Trunc(Num - 0.5)
Nel Pascal Microsoft (MSPascal) invece:
| The effect of ROUND on a number with fractional
| part of 5 varies with the implementation
Il Fortran che conosco io è molto vecchio e in questo Fortran non ho mai
trovato una funziona di arrotondamento. Infatti per arrotondare ho sempre
usato la solita formula: IFIX(X + 0.5)
Maurizio.

 
Questo dipende dal calcolo che devi fare. Non è detto che fa funzione 
round sia quella che fa al caso tuo. Se preferisci puoi utilizzare una 
tua funzione personalizzata:
function Round(x)
{
   if (x >= 0)
     return Math.round(x);
   else
     return -(Math.round(-x))
}
Questa funzione arrotonda per eccesso per x >= 0 e per difetto per x < 
0. Tutte le definizioni che ho trovato in giro però utilizzano round 
come da definizione classica. Ad esempio:
http://www.mcs.surrey.ac.uk/Personal/R.Knott/Fibonacci/fibFormulae.html
Viene utilizzata la formula:
round(x) = floor(x + 1/2)
Oppure qua:
http://www.cg.tuwien.ac.at/courses/Visualisierung/2002-2003/Beispiel1/7-KuehschelmL-EckerS/Homepage/html/ray_8h.html
viene utilizzata la macro:
#define 	ROUND(x)   (((fabs(x - floor(x))) < 0.5) ? floor(x) : ceil(x))
Gaetano

 trovato una funziona di arrotondamento.
Eh, vabbe', sempre con lo stesso criterio, io ho provato con:
       WRITE(*,50)
50    FORMAT(F4.0)
In fine ci sono Delphi, MatLab e PhP ma loro hanno la classica funzione
round() e quindi non ci sono problemi...

  }
Questa è solo una funzione che non arrotonda ma stampa un certo numero 
di caratteri come specificato.
Se fai:
float f = -2.5;
int i = f;
printf("%d", i);
viene stampato -2. Quindi internamente il computer quando effettua una 
conversione utilizza l'arrotondamento classico. La funzione round viene 
definita in quel modo "poco intuitivo" proprio perché serve per 
calcolare gli errori di calcolo numerico che vengono propagati durante 
l'esecuzione di una computazione.
Se non ti fidi ritrovo il mio libro di Analisi Numerica e cercherò di 
esprimermi in modo più approfondito.
Comunque non vedo perché ci debba essere tanta animazione per la scelta 
di una funzione di arrotondatento piuttosto che un'altra. Se Math.round 
non è la funzione giusta per risolvere un certo problema si può 
scriverne una personalizzata. Nessuno è in errore e tutti possono 
utilizzare la funzione che più preferiscono :-)
Gaetano

 quella di un ingegnere...
Infatti, per questo motivo sto cercando di tirar fuori una "teoria" 
invece di affidarmi ai linguaggi, visto che non ho sottomano alcun 
libro.
E per lo stesso motivo propendo per la "tesi" di excel per le 
motivazioni che ho espresso altrove.
Da ieri tentenno se chiedere in it.scienza.matematica ma ci faremmo una 
figura barbina a non saper arrotondare :-)
Va da se che spulciando nei loro vecchi post non ne ho tirato fuori 
nulla di definitivo :-((


 motivazioni che ho espresso altrove.
Quanto ti ho scritto sopra non e' legato ai linguaggi: e' una considerazione
matematica, magari mia, ma che non credo distante dalla realta'.

 Gaetano
Gianni

 ......cosa ne deduci?!?
Usando il mio compilatore (Visual C++ 7.0) viene stampato 2. Ne deduco 
che il mio esempio precedente in realta non č corretto e di questo mi 
scuso:-(
Comunque cerco di confutare la tua affermazione. Tu dici: "esiste un 
unico modo di attotondare: il modo in cui viene fatto in Excel, C, 
ecc..". Qui ti sbagli. Leggendo ad esempio qui:
Rounding Modes
http://www.gnu.org/manual/glibc-2.2.5/html_node/Rounding.html
si evince che c'č una specifica denominata IEEE 754 che prevede 4 
"rouding mode":
- round to nearest;
- round towards plus Infinity;
- round towards minus Infinity;
- round towards zero.
In particolare il modo in cui viene arrotondato un risultato in C 
dipende da come č impostato il rounding mode.
Il modo di arrotondare di JavaScript si chiama esattamente:
"round to nearest, and if two are equally near towards plus infinity"
Quindi Math.round(2.5) restituisce 3 e Math.round(-2.5) restituisce -2.
Qui c'č una pagina interessante che parla di come avvengono gli 
attotondamenti in Pascal e in Delphi:
Pascal/Delphi Rounding and Truncation Page.
http://www.merlyn.demon.co.uk/pas-chop.htm
In particolare la procedura Round utilizza il meto "round to nearest" 
che in caso di equidistanza arrotonda al numero pari:
Round(2.5) -> 2
Round(3.5) -> 4
Round(-2.5) -> -2
Round(-3.5) -> -4
Qui c'č un'altra pagina che descrive i soliti rounding mode per un 
particolare compilatore Fortran della IBM:
XL Fortran 7.1 - User's Guide
http://scv.bu.edu/SCV/IBMSP/IBMdocs/xlf7.1/UG45
.
http://scv.bu.edu/SCV/IBMSP/IBMdocs/xlf7.1/UG45
.
Per ultimo e forse il piů utile, qui viene spiegato tutto 
sull'arrotondamento in JavaScript.
JavaScript Rounding
http://www.merlyn.demon.co.uk/js-round.htm
Gaetano Bigliardi

[...]
Bene.
E speriamo che qualche documento o pubblicazione trovata qua e la' convinca
anche chi non si fida della propria logica.

 Usando il mio compilatore (Visual C++ 7.0) viene stampato 2. [...]
naturalmente intendevo 12 e non 2.
Gaetano

 anche chi non si fida della propria logica.
Della propria ???
Non credo che ti stia riferendo a me, visto che è dall'iniziono che sostengo
la mia
logica e ragione e mi fido e come :))

 Sono perplesso, l'ho detto all'inizio e lo ripeto :)
Se ti consola, come scrivero' tra poco in un post a Riccardo, ho chiesto 
ulteriore conferma ad una "Dottoressa in Matematica" e mi ha confermato 
che, matematicamente parlando, la convenzione maggiormente usata e' 
quella del -2.5 = -2 in fase di arrotondamento. Aggiungendo, anche lei, 
che si tratta pur sempre di una convenzione e di un'approssimazione.
-- 
C'ya,
ZER0
  :. job profile - coder.gfxer.webDesigner
"when you eliminate the impossible, whatever remains, however 
improbable, must be the truth" (S.H.)

 eh? :-))
Come ho appena detto al Catarsi:
Ho chiesto informazioni sul thread in questione ad una "Dottoressa in 


 convenzione e di un'approssimazione.
Oooooh!!!!
Questo mi basta per chiudere la questione, niente di meglio che un 
parere autorevole, specialmente se sottolinea il fatto che si tratta di 
una convenzione... d'ora in poi 
"la matematica non e' (sempre!) un'opinione" :-))
'azzo pero' che mega thread e' uscito per un post che voleva essere 
piu' che altro scherzoso ^_^


 :P
Gia', ma se io ti quoto legge i miei post.. :DDDD
Cmq direi che il discorso si e' ormai concluso. Poi, tutto questo 
putiferio per un arrotondamento m'e' parso un po' eccessivo.. se non 
altro sono fuoriusciti un paio di post veramente interessanti su 
disquisizioni matematiche che fa sempre piacere leggere, anche se - 
ahime' - ormai la mia "elasticita' matematica" e' quel che e'.. 
Urgerebbe un bel ripasso. :)


 UFFA! Allora io non ho insultato e/o offeso con parole scurrili!
Gianni, scusa un attimo: A prescindere da tutto, ti sei reso conto che 
non c'e' un utente dell'NG che ti ha detto "il tono del tuo post era 
pienamente giustificato"..? Ma anzi, direi che ti hanno fatto tutti 
notare il contrario?
Ti sei reso conto che la tua reazione e' stata DECISAMENTE esagerata? 
Ora, "potevi ritenerti offeso" per qualcosa che Maurizio ha scritto, ed 
e' legittimo.. ma c'e' modo e modo di rispondere.


 Comunque suggeriscimi un pò tu ;))
Ah, io non ho bisogno di pusher, son fuori gia' di mio ;)


 una convenzione... 
Beh, questo mi pare cmq che sia fuoriuscito anche dai post di Maurizio e 
Andrea Scartabelli, no? Ed anche con fior fiore di spiegazioni..
Tra parentesi, se ci tieni gli chiedo una "documentazione" piu' 
dettagliata alla dottoressa in questione (evita battute.. :P ), ma temo 
cmq che non otterrai molto di piu' di quanto abbiano gia' scritto i due 
individui sopracitati.


 :-(((
Per aggiungere carne al fuoco ho trovato il sito che tratta della 
specifica IEEE 754 che descrive come si rappresentano i numeri in 
virgola mobile. Avevo già nominato la specifica IEEE 754 ma senza un 
puntatore diretto.
IEEE 754: Standard for Binary Floating-Point Arithmetic
http://grouper.ieee.org/groups/754/
Qui si trova documentazione sulla medesima specifica:
http://cch.loria.fr/documentation/IEEE754/http://grouper.ieee.org/groups/754/
Inoltre gli stessi "rounding mode" definiti dalla specifica IEEE 754 
sono gli stessi che vendono usati nella classe Java BigDecimal:
http://java.sun.com/j2se/1.4.1/docs/api/java/math/BigDecimal.html
Anche se ralativa a Java e non a JavaScript ritengo che tale 
documentazione possa essere utile dato che l'argomento è di ordine 
generale e negli altri post si sono tirati in ballo altri linguaggi di 
programmazione.
In particolare è utile la documentazione dei rounding mode:
ROUND_CEILING
Rounding mode to round towards positive infinity.
ROUND_DOWN
Rounding mode to round towards zero.
ROUND_FLOOR
Rounding mode to round towards negative infinity.
ROUND_HALF_DOWN
Rounding mode to round towards "nearest neighbor" unless both neighbors 
are equidistant, in which case round down.
ROUND_HALF_EVEN
Rounding mode to round towards the "nearest neighbor" unless both 
neighbors are equidistant, in which case, round towards the even neighbor.
ROUND_HALF_UP
Rounding mode to round towards "nearest neighbor" unless both neighbors 
are equidistant, in which case round up.
ROUND_UNNECESSARY
Rounding mode to assert that the requested operation has an exact 
result, hence no rounding is necessary.
ROUND_UP
Rounding mode to round away from zero.
Quello utilizzato dal metodo Math.round() di JavaScript è quello che qui 
viene descritto come "round half up". Proprio su questo rounding mode 
viene detto:
"Note that this is the rounding mode that most of us were taught in 
grade school."
Interessante invece la nota al modo "round half even" (descritto per 
primo in questo thread da Andrea Scartabelli):
"Note that this is the rounding mode that minimizes cumulative error 
when applied repeatedly over a sequence of calculations."
Ovvero il modo che consente di ottenere il minor errore durante i 
calcoli è proprio round half even, lo stesso delle funzioni Round di 
Pascal e di VBScript, ad esempio. Ovvero risulta:
Round(2.5) = 2
Round(3.5) = 4
Round(-2.5) = -2
Round(-3.5) = -4
Nell'utilizzo della classe BigDecimal il rounding mode deve essere 
impostato _esplicitamente_. Inoltre BigDecimal ha una rappresentazione 
interna decimale e non binaria, per cui vengono evitati i problemi di 
rappresentazione che tu descrivi. Infatti nella descrizione del 
costruttore della classe, uno che prende in ingresso un double e uno che 
prende in ingresso una stringa:
"public BigDecimal(double val)
Translates a double into a BigDecimal. The scale of the BigDecimal is 
the smallest value such that (10scale * val) is an integer.
Note: the results of this constructor can be somewhat unpredictable. One 
might assume that new BigDecimal(.1) is exactly equal to .1, but it is 
actually equal to 
.1000000000000000055511151231257827021181583404541015625. This is so 
because .1 cannot be represented exactly as a double (or, for that 
matter, as a binary fraction of any finite length). Thus, the long value 
that is being passed in to the constructor is not exactly equal to .1, 
appearances notwithstanding.
     The (String) constructor, on the other hand, is perfectly 
predictable: new BigDecimal(".1") is exactly equal to .1, as one would 
expect. Therefore, it is generally recommended that the (String) 
constructor be used in preference to this one."
Spero che tutto questo materiale sia utile. Per ultimo traggo io una 
umile conclusione: i metodi di arrotondamento sono molteplici e a 
seconda del caso d'uso è necessario scegliere quello più adatto.
Gaetano Bigliardi

 seconda del caso d'uso è necessario scegliere quello più adatto.
Mi va benissimo quanto hai scritto (non ho tempo di approfondire 
purtroppo).
Allora possiamo concludere che da questo punto di vista Netscape 2 è "il 
migliore" 
:-)))
