Scala e Java BigDecimal

Question

Voglio passare da Java a un linguaggio di scripting per i moduli basati su Math nella mia app. Ciò è dovuto alla leggibilità e ai limiti funzionali di Java math.

Per es, in Java ho questo:

BigDecimal x = new BigDecimal("1.1"); 
BigDecimal y = new BigDecimal("1.1"); 
BigDecimal z = x.multiply(y.exp(new BigDecimal("2")); 

Come si può vedere, senza BigDecimal overloading degli operatori, formule semplici si complicano reale veloce.

Con il doppio, questo sembra buono, ma ho bisogno della precisione.

Speravo in Scala avrei potuto fare questo:

var x = 1.1; 
var y = 0.1; 
print(x + y); 

E di default che avrei avuto un comportamento simile decimale, ahimè Scala non usa il calcolo decimale per difetto.

Poi faccio questo a Scala:

var x = BigDecimal(1.1); 
var y = BigDecimal(0.1); 
println(x + y); 

E io ancora ottenere un risultato impreciso.

C'è qualcosa che non sto facendo bene in Scala?

Forse dovrei usare Groovy per massimizzare la leggibilità (utilizza i decimali per impostazione predefinita)?

Answer 1

non so Scala, ma in Java new BigDecimal(1.1) inizializza il BigDecimal con un valore double e quindi non è esattamente pari a 1.1. In Java devi invece usare new BigDecimal("1.1"). Forse ciò aiuterà anche in Scala.

Answer 2

modificare il codice Scala a questo:

var x = BigDecimal("1.1"); // note the double quotes 
var y = BigDecimal("0.1"); 
println(x + y); 

e funzionerà esattamente come avviene in Java.

Answer 3

scala> implicit def str2tbd(str: String) = new { 
    |  def toBD = BigDecimal(str) 
    | } 
str2tbd: (str: String)java.lang.Object{def toBD: scala.math.BigDecimal} 

scala> var x = "1.1".toBD 
x: scala.math.BigDecimal = 1.1 

scala> var y = "0.1".toBD 
y: scala.math.BigDecimal = 0.1 

scala> x + y 
res0: scala.math.BigDecimal = 1.2 

scala> implicit def str2bd(str: String) = BigDecimal(str) 
str2bd: (str: String)scala.math.BigDecimal 

scala> x + y + "1.2345566" 
res1: scala.math.BigDecimal = 2.4345566 

scala> 

Answer 4

Scala è decisamente la stessa di Java in questo senso.

Come per la risposta di Joachim, scrivendo val x = BigDecimal(1.1)

è equivalente a scrivere

val d : Double = 1.1 
val x = BigDecimal(d) 

Il problema, naturalmente, è che il doppio d ha già l'errore di arrotondamento, quindi sei inizializzazione x con dati sbagliati.

Utilizzare invece il costruttore che accetta una stringa e tutto andrà bene.

Dato il tuo esempio, staresti meglio usando val s invece di var s, e puoi tranquillamente lasciare il punto e virgola anche in Scala.

Answer 5

È possibile memorizzare valori come Integer/String (senza precisione) internamente e utilizzare scale (questa è una trascrizione da Scala REPL):

scala> val Scale = 2 
Scale: Int = 2 

scala> val x = BigDecimal(110, Scale) 
x: scala.math.BigDecimal = 1.10 

scala> val y = BigDecimal(303, Scale) 
y: scala.math.BigDecimal = 3.03 

scala> (x+y, (x+y).scale) 
res0: (scala.math.BigDecimal, Int) = (4.13,2) 

scala> (x*2, (x*2).scale) 
res1: (scala.math.BigDecimal, Int) = (2.20,2) 

Oppure, se si vuole analizzare una stringa, è possibile controllare l'arrotondamento :

scala> val z = BigDecimal("8.937").setScale(Scale, BigDecimal.RoundingMode.FLOOR)  
z: scala.math.BigDecimal = 8.93 

scala> val z = BigDecimal("8.937").setScale(Scale, BigDecimal.RoundingMode.CEILING) 
z: scala.math.BigDecimal = 8.94 

Answer 6

so che questa domanda è vecchio e ha risposto, ma un'altra opzione, se siete aperti a diversi linguaggi (come il PO sembrava essere), sarebbe quella di utilizzare Clojure. Clojure ha, IMO, alcuni dei sintassi semplice per BigDecimal matematica (notare le finali M s - che indica BigDecimal):

user=> (def x 1.1M) 
#'user/x 
user=> (def y 1.1M) 
#'user/y 
user=> (def z (* x (.pow y 2))) 
#'user/z 
user=> z 
1.331M 
user=> (type z) 
java.math.BigDecimal 

mi piace Clojure per la matematica in quanto il valore predefinito è di precisione in molti casi, ad esempio, il suo uso di Ratio:

user=> (/ 60 14) 
30/7 
user=> (type (/ 60 14)) 
clojure.lang.Ratio