Imposta tutte le operazioni BigDecimal con una certa precisione?

Question

Il mio programma Java è incentrato su calcoli di alta precisione, che devono essere precisi con almeno 120 posizioni decimali.
Conseguentemente, tutti i numeri non interi saranno rappresentati da BigDecimals nel programma.

Ovviamente ho bisogno di specificare l'accuratezza del arrotondamento per le BigDecimals, al fine di evitare espressioni infinite decimali ecc
Attualmente, lo trovo un fastidio enorme di dover specificare l'accuratezza ad ogni istanziazione o operazione matematica di un BigDecimal .

C'è un modo per impostare una 'precisione globale' per tutti i calcoli BigDecimal?
(come il Context.prec() per il modulo decimale in python)

Grazie

---

Spec:
Java jre7 SE
di Windows 7 (32)

Answer 1

(quasi) Original

non è così semplice, ma è possibile creare un MathContext e passarlo a tutti i vostri BigDecimal costruttori ei metodi di esecuzione delle operazioni.

Rivisto

In alternativa, è possibile estendere BigDecimal e sovrascrivere eventuali operazioni che si desidera utilizzare, fornendo il diritto MathContext, e utilizzando la versione arrotondamento di divide:

public class MyBigDecimal extends BigDecimal { 

     private static MathContext context = new MathContext(120, RoundingMode.HALF_UP); 

     public MyBigDecimal(String s) { 
      super(s, context); 
     } 
     public MyBigDecimal(BigDecimal bd) { 
      this(bd.toString()); // (Calls other constructor) 
     } 
     ... 
     public MyBigDecimal divide(BigDecimal divisor){ 
      return new MyBigDecimal(super.divide(divisor, context)); 
     } 
     public MyBigDecimal add(BigDecimal augend){ 
      return new MyBigDecimal(super.add(augend)); 
     } 
     ... 
} 

Answer 2

È possibile utilizzare il Funzione BigDecimal setScale!

BigDecimal db = new BigDecimal(<number>).setScale(120, BigDecimal.ROUND_HALF_UP); (or down) 

Answer 3

si potrebbe creare un classe che estende BigDecimal e imposta automaticamente la precisione per te. Allora ti limiti a usare quella lezione.

public class MyBigDecimal extends BigDecimal { 
     public MyBigDecimal(double d) { 
      super(d); 
      this.setScale(120, BigDecimal.ROUND_HALF_UP); 
     } 
     ... 
} 

Answer 4

È possibile creare un wrapper per BigDecimals, che farà questo lavoro:

class BigDecimalWrapper { 
    BigDecimal bd; 

    BigDecimalWrapper add(BigDecimalWrapper another) { 
     BigDecimal r = this.bd.add(another.bd); 
     r.setScale(...); 
     bd = r; 
     return this; 
    } 
    // and so on for other operations 
} 

In questo caso non c'è bisogno di ignorare tutte le operazioni di BigDecimal (ad estendere caso), solo quelli usate. Ti dà il controllo su tutte le istanze e non impone di seguire il contratto BigDecimal.

Answer 5

Creare una classe BigDecimalFactory con metodi factory statici corrispondenti a tutti i costruttori che accettano MathContext - tranne che l'istanza MathContext è all'interno della fabbrica e staticamente inizializzato al momento dell'avvio. Ecco un frammento:

public class BigDecimalFactory { 
    public static BigDecimal newInstance (BigInteger unscaledVal, int scale) { 
     return new BigDecimal (unscaledVal, scale, _mathContext); 
    } 

    // . . . other factory methods for other BigDecimal constructors 

    private static final MathContext _mathContext = 
     new MathContext (120, BigDecimal.ROUND_HALF_UP); 
} 

Answer 6

C'è un modo per impostare un 'accuratezza globale' per tutti i calcoli BigDecimal?

No.

Dovrete creare una classe wrapper che ha una MathContext come attributo in più. Sarà necessario:

• uso questo mc per ogni operazione matematica che altrimenti utilizzare la semantica di default, e

• creare e restituire un altro caso avvolto ogni volta che l'operazione avvolto restituisce un'istanza regolare.

(Come variante, è possibile implementare un 'globale' MathContext utilizzando una statica, ma avrai ancora bisogno di usare wrappering per garantire che il mc viene utilizzato.)

(estensione BigDecimal sarebbe . lavoro troppo, e che è più ordinato sostenibile di una classe wrapper)

---

Hai detto che in un commento:

Non voglio davvero scrivere il mio modulo Decimal, voglio solo capire perché BigDecimal è così poco collaborativo.

(domande di design può rispondere solo definitivamente dal team di progettazione. Tuttavia ...)

Come per tutte le classi di utilità complicate, la progettazione di BigDecimal è un compromesso che è stato progettato per soddisfare le requisiti di una vasta gamma di casi d'uso. È anche un compromesso tra le meta-esigenze in competizione (parola sbagliata) di "potenza" e "semplicità".

Quello che hai è un caso d'uso che non è particolarmente ben supportato. Ma sospetto che se fosse ben supportato (ad esempio con un globale MathContext che controlla tutto o uno MathContext collegato a ciascun BigDecimal), ciò introdurrebbe ogni sorta di altre complessità; per esempio. occuparsi di operazioni in cui sono presenti due o più oggetti contestuali concorrenti da considerare. Tali problemi potrebbero essere affrontati ... ma sono suscettibili di portare a "sorprese" per il programmatore, e questa non è una buona cosa.

L'approccio attuale è semplice e facile da capire e, se hai bisogno di qualcosa di più complicato, puoi implementarlo ... fornendo esplicitamente un MathContext per le operazioni che lo richiedono.