Newsgroup: it.comp.appl.access
Titolo: FUNZIONE ROUND ELIMINARE L'ARROTONDAMENTO

Ciao a tutti.
Uso la funzione round per calcolare l'Iva di una fattura ma in automatico mi 
arrotonda l'importo.
Cosa devo inserire nella formula
=Round([IMPONIBILE]*([ALIQUOTA]/100))
perchè mi compaia l'importo preciso senza arrotondamenti?
Grazie come sempre per i preziosi aiuti
-- 
Giorgia 

 perchè mi compaia l'importo preciso senza arrotondamenti?
Forse mi sfugge qualcosa ma...non usare la funzione Round, no? ;)
Alessio

Hal ha scritto:


Forse manca solo il numero di decmali desiderati:
  =Round([IMPONIBILE]*([ALIQUOTA]/100);2)
Ciao.
-Marco-
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Giorgia
Giorgia,
attenzione!!, la funzione round non arrotonda secondo le regole indicate dal 
comitato per l'euro.
Poniamo di avere un imponibile di 30,25 euro e un'aliquota del 10 % , ne 
risulta che:
30,25*10/100 = 3,025
Quindi devo applicare un'imposta arrotondata pari a 3,03 Euro.
Adesso prova a mettere nell'origine controllo di una casella testo la 
fornula:
=Round(30,25*10/100;2)  otterrai il risultato 3,02 che in base alle regole 
per l'arrotondamento è ERRATO!!
Morale; non utilizzare la funzione Round per arrotondamenti commerciali, non 
perchè abbia un bug o non funzioni, ma semplicemente perchè utilizza un tipo 
di arrotondamento non adatto!!
:-)
--
Giorgio Rancati
[Office Access MVP] 

 [Office Access MVP]
Ciao Giorgio   :-)
Una cosa curiosa, nella finestra immediata:
?Round(30.25*0.1 , 2)
 3,03
?Round(30.25*10/100 , 2)
 3,02
E' come se cambiasse il tipo di dato.
Bho'    ?
-- 
Lorenzo 

 Bho'    ?
ma no, questa è tutta un'altra storia :-)
Sia Round(30.25*0.1 , 2) che Round(30.25*10/100 , 2) utilizzano nel calcolo 
il tipo di dato Double.
Come saprai il tipo di dato Double è approssimato quindi non bisogna 
stupirsi se i due risultati sono diversi.
Per avere lo stesso risultato imponiamo un tipo di dato preciso che abbia la 
precedenza su tutti gli altri tipi, il decimal.
?Round(CDec(30.25)*0.1 , 2)
 3,02
?Round(CDec(30.25)*10/100 , 2)
 3,02
:-)
--


 [Office Access MVP]
-- 
Lorenzo 

 3,02
sì, come ho già detto dipende dal tipo di dato impreciso, evidentemente i 
risultati intermedi delle due espressioni differiscono, magari per 1 solo 
miliardesimo.
In questo caso Round(30.25*0.1 , 2) da un risultato errato rispetto al 
metodo Banker's rounding mentre eval("Round(30.25*0.1,2)") lo da corretto.
Non mi stupirei se con altri numeri la situazione si capovolga. Come detto 
sopra bisogna usare un tipo di dato preciso se si vuole ottenere un 
risultato preciso.


 wrote in message 
news:47bac005$0$4790$4faf...@reader4.news.tin.it...

= Round(Imponibile * Aliquota + 0.001, 2)
Se vuoi l'arrotondamento Euro a 2 decimali...
= Round(Imponibile * Aliquota + 0.0001, 3)
a tre decimali...
= Round(Imponibile * Aliquota + 0.00001, 4)
a quattro decimali.
Altra cosa più importante è definire:
Dim Imponibile as Currency, Aliquota As Currency
Bruno

 Dim Imponibile as Currency, Aliquota As Currency
umm a me non quadra
----
Sub TestCalcolo()
Dim Imponibile As Currency, Aliquota As Currency
Imponibile = 30.24
Aliquota = 0.1
Debug.Print "Imponibile = " & Imponibile & " Imposta = " & Aliquota
Debug.Print Round(Imponibile * Aliquota + 0.001, 2)
Imponibile = 30.34
Aliquota = 0.1
Debug.Print "Imponibile = " & Imponibile & " Imposta = " & Aliquota
Debug.Print Round(Imponibile * Aliquota + 0.001, 2)
End Sub
----
Risultati:
----
Imponibile = 30,24 Imposta = 0,1
 3,02
Imponibile = 30,34 Imposta = 0,1
 3,04
Ciao


 [Office Access MVP]
In effetti...
Il ragionamento non fa una piega però quel Round ci mette del suo:
Round(3.025,2) = 3.02
Round(3.035,2) = 3.04
Col che tutti i ragionamenti si vanno a far friggere!
Io in effetti, in contabilità, uso questa:
-------------------------------------------------------
Public Function EuroRound(ByVal ValueToRound, Optional DecimalDigit As Byte 
= 2)
ValueToRound = CDec(ValueToRound)
EuroRound = (Sgn(ValueToRound) * (Fix(Abs(ValueToRound) * 10 ^ DecimalDigit 
+ 0.5) / 10 ^ DecimalDigit))
End Function
-----------------------------------------------------
Bruno 

 -----------------------------------------------------
sì, vedo che è simile alla mia 
http://www.riolab.org/viewrisorsa.asp?id=109
L'importante è usare il tipo di dato Decimal
:-)


 piů vicina
Alla cifra pari!
Sě, in effetti č cosě. Ma dove sta scritto?
E in ogni caso, fosse anche documentato, che cazzata sarebbe?
Dovrebbe allora esistere anche un Round che arrotonda
alla cifra dispari piů vicina.
Piů ci guardi dentro alla matematica del VBA e piů ti
viene il vomito.
Ciao
Bruno

 viene il vomito.
Cerca "Gaussian rounding" o "Banker's rounding" e trovi un sacco di 
informazioni.
come ad esempio
----
Banker's rounding rounds .5 up sometimes and down sometimes. The convention 
is to round to the nearest even number, so that both 1.5 and 2.5 round to 2, 
and 3.5 and 4.5 both round to 4. Banker's rounding is symmetric.
http://support.microsoft.com/kb/196652/en-us
----
oppure
----
Banker's rounding
http://www.xbeat.net/vbspeed/i_BankersRounding.htm
----
Ciao


 [Office Access MVP]
Molto interessante e ... molto nuovo  per me.
La cosa strabiliante è che anche Mathematica usa
col suo Round[] il Banker's Rounding; però almeno lì
la circostanza è documentata.
L'unico Round() non ambiguo pare essere allora la
Worksheet Function di Excel.
Ciao
Bruno 

 ha scritto nel messaggio 
news:47bc337d$0$4788$4faf...@reader4.news.tin.it...

Io ho sempre usato senza problemi la seguente semplice formula per 
arrotondare a due decimali:
CCur(Importo / 100) * 100
pensate che non sia molto ortodosso?
saluti
thomas.az

 pensate che non sia molto ortodosso?
Ciao thomas,
dipende cosa devi arrotondare, se vuoi arrotonadre l'imposta IVA allora non 
va bene affatto!
:-)
Come puoi vedere da questo articolo:
----
http://support.microsoft.com:80/kb/196652/en-us
In Visual Basic for Applications, the following numeric functions perform 
banker's rounding: CByte(), CInt(), CLng(), CCur(), and Round().
----
anche la funzione Ccur() utilizza il metodo banker's rounding.
Basta fare una semplice prova
----
Dim Importo As Currency
Importo = 2.145
Debug.Print CCur(Importo / 100) * 100
Importo = 2.155
Debug.Print CCur(Importo / 100) * 100
----
Risultati
----
 2,14
 2,16


 ha scritto nel 
messaggio news:47bc6374$0$21207$5fc...@news.tiscali.it...

grazie Giorgio,
veramente molto istruttivo.
devo dirti però che sul mio pc l'anomalia la trovo su numero 2.155 che viene 
arrotondato a 2.15 mentre 2.145 viene correttamente arrotondato a a 2.15.
ti saluto
thomas.az

 
thomas.az
sì Thomas, come ho già detto a Lorenzo, la spiegazione di questo 
comportamento consiste nel tipo di dato approssimato Double.
Se guardi il mio esempio noterai che ho usato il tipo di dato Currency 
proprio per non ricadere nel dominio dei dati approssimati.
Quanto da te riscontrato è facilmente riproducibile con l'esempio qui sotto 
che a differenza del precedente utilizza il tipo di dato Double
----
Dim Importo As Double
Importo = 2.145
Debug.Print CCur(Importo / 100) * CDec(100)
Importo = 2.155
Debug.Print CCur(Importo / 100) * CDec(100)
----
Risultati
----
 2,15
 2,15
:-)


 2,15
oops. scusa, non vorrei confondere le idee con CDec che č rimasto per 
sbaglio.
Ecco quello che volevo mostrare.
----
Dim Importo As Double
Importo = 2.145
Debug.Print CCur(Importo / 100) * 100
Importo = 2.155
Debug.Print CCur(Importo / 100) * 100
----
Risultati
----
