Legen Sie alle BigDecimal-Operationen, um eine gewisse Genauigkeit?

Mein Java-Programm ist zentriert rund um die hohe Präzision der Berechnungen, die müssen genau sein, mindestens 120 Dezimalstellen.

Folgerichtig, sind alle nicht-ganze zahlen werden dargestellt, indem BigDecimals in das Programm.

Ich natürlich angeben müssen, die Genauigkeit der Rundung für die BigDecimals, um zu vermeiden, unendliche Dezimalzahl Ausdrücken etc.

Derzeit finde ich es ein massives ärgernis zu haben, um anzugeben, die Genauigkeit bei jeder Instanziierung oder die mathematische operation einer BigDecimal.

Gibt es eine Möglichkeit, um eine 'Globale Genauigkeit' für alle BigDecimal-Berechnungen?

(Wie die Context.prec() für die Dezimal - Modul in python)

Dank

Spezifikationen:

Java jre7 SE

Windows 7 (32)

InformationsquelleAutor Anti Earth | 2012-04-08

11

(Fast) Original

Nicht so einfach, aber du kannst ein MathContext und übergeben Sie es an alle Ihre BigDecimal Konstruktoren und die Methoden, die Durchführung von Operationen.

Überarbeitet

Alternativ können Sie verlängern BigDecimal und überschreiben alle Operationen, die Sie verwenden möchten, indem Sie ihm die richtigen MathContext, und mit der Rundung version von 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 ) );
      }
      ...
}
```
- Das ist genau das, was ich vermeiden möchte.
- Ich bin eigentlich mit einigen Schwierigkeiten mit der Klasse-Erweiterung. Wenn ich 2 BigDecimals für "1" und "3", die beide über eine Skala eingestellt, um 120... die Aufteilung "1" "3" produziert immer noch ein non-terminating decimal, auch wenn ich weisen Sie das Ergebnis einer Skalierung von 120, wie gut! (Was war das, was ich ursprünglich versucht, zu vermeiden; zusätzliche Parameter mathematische Operationen).
- Ich denke, dass Sie beheben können, die durch ähnlich überschreiben der divide - Methode für die Klasse.
- Ich wirklich nicht wollen, zu schreiben, dass meine eigenen Decimal-Modul, ich möchte nur verstehen, warum BigDecimal wird so unkooperativ./
- Es versucht so genau wie möglich, was bedeutet, versuchen, nie Runde, es sei denn, fragte. Die Kluft überschreiben ist einfach, dass Sie nur wickeln Sie die Rundung divide. Nun, ich denke, es wäre eine gute Idee, um Vorrang vor anderen Operationen verwenden, um sicherzustellen, dass Sie sind der Rückgabe eine Instanz der Klasse und nicht einer regelmäßigen BigDecimal.
- Yep. Es gibt keine Notwendigkeit, mich selbst zu überschreiben, einen Konstruktor als da ist? (Standardmäßig wird nicht ein string an den Konstruktor übergeben werden konvertiert, um ein BigDecimal-der genaue Wert der Zeichenfolge?) Dank
- Werden Sie außer Kraft setzen müssen (na gut, die Umsetzung, technisch Sie nie überschreiben eine Konstruktor) der string-Konstruktor. Konstruktoren nicht vererbt bekommen automatisch.
- Was auch immer Sie tun, nicht verwenden, meine factory-Ansatz! @StephenC die Kommentare dazu sind richtig - die MathContext übergeben den Konstruktoren hat keinen Einfluss auf die späteren Operationen, nur die Konvertierung erfolgt im Konstruktor.
- Ich werde ehrlich sein, ich habe jetzt keine Ideen, wie diese umzusetzen ist. Kann jemand geben einige Beispiel-code? (Karte Konstruktor und teilen überschreiben von Methoden?)
- Ich fügte hinzu, ein Beispiel in einem edit. Es ist nicht sehr kompliziert.
- Ich sehe. Ich bin immer noch nicht sicher, warum ich brauche, um superclass-Konstruktor. Ich brauche nicht exakt 120 Dezimalstellen Genauigkeit, nur bei mindestens 120. Sollte ich dann nur re-implementieren Sie die teilen-Funktion, die einzige Sorge, die wird nicht beenden Dezimalstellen, und haben den rest genau, um was es sich herausstellt?
- Leider müssen Sie immer noch Oberklasse den Konstruktor, wenn Sie wollen, zu einem number.divide(otherNumber); syntax, da braucht man number Typ MyBigDecimal und nicht BigDecimal. Eine weitere option ist das einfach nur vergessen Unterklassen und schreiben Sie eine static BigDecimal divide( BigDecimal a, BigDecimal b ){ a.divide(b,context);}; - Funktion und verwenden Sie es anstelle des einen zur Verfügung gestellt.
- Das ist genau das, was ich habe nachgedacht 🙂 Danke, sir!
- ein Konstruktor ist schlechte Terminologie. Konstruktoren sind nicht vererbbar, die in Java ...
InformationsquelleAutor trutheality
4

Erstellen Sie eine BigDecimalFactory Klasse mit der statischen factory-Methoden passend zu allen Konstruktoren akzeptieren, dass MathContext - außer, dass die MathContext Instanz innerhalb der Fabrik und statisch initialisiert beim Start. Hier ein fragment:
```
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);
}
```
- Das funktioniert nicht ... wenn ich das Lesen der javadoc richtig. Der Hauptgrund dafür ist, dass der Konstruktor Sie verwenden, verwendet die MathContext für die Konvertierung nur. Es ist nicht an das resultierende BigDecimal Objekt.
- Das bedeutet, dass die Präzision Einschränkung nicht gelten für Operationen, die auf die BigDecimal Instanzen erstellt mit der Fabrik ... es sei denn, Sie liefern den MathContext als argument, um zu relevanten Vorgang.
- Argh! Du hast Recht. Erwähnte ich Ihre Kommentare in einem der anderen threads in diesem post so, dass die Menschen wissen.
InformationsquelleAutor sparc_spread
3

Gibt es eine Möglichkeit, um eine 'Globale Genauigkeit' für alle BigDecimal-Berechnungen?

Nicht.

Müssen Sie erstellen Sie eine wrapper-Klasse, die eine MathContext als zusätzliches Attribut. Es müssen:
- verwenden Sie diese mc für jede mathematische operation, die andernfalls verwenden Sie die Standard-Semantik, und
- erstellen und bringe eine andere gewickelt Beispiel jedes mal, wenn Sie die verpackte operation liefert eine reguläre Instanz.
(Als Variante könnten Sie implementieren eine 'Globale' MathContext mit einem statischen, aber Sie werden immer noch auf wrappering, um sicherzustellen, dass die mc verwendet wird.)

(Erweiterung BigDecimal würde auch funktionieren, und das ist wohl sauberer als eine wrapper-Klasse.)

Sie sagte dies in einem Kommentar:

Ich wirklich nicht wollen, zu schreiben, dass meine eigenen Decimal-Modul, ich möchte nur verstehen, warum BigDecimal wird so unkooperativ.

(Design-Fragen können nur beantwortet werden endgültig durch das design-team. Jedoch ...)

Wie bei allen komplizierten utility-Klassen, die Gestaltung von BigDecimal ist ein Kompromiss, der ausgelegt ist, um die Anforderungen einer breiten Palette von Anwendungsfällen ab. Es ist auch ein Kompromiss zwischen den konkurrierenden meta-Anforderungen (Falsches Wort) von "Stärke" und "Einfachheit".

Was Sie haben, ist ein use-case, dass ist nicht besonders gut unterstützt. Aber ich vermute, dass, wenn es gut vertragen wurde (z.B. mit einem globalen MathContext alles kontrolliert oder eine MathContext an jeder BigDecimal), dann das einführen würde alle Arten von anderen Komplexitäten, z.B. Umgang mit Operationen, wo es zwei oder mehr konkurrierende Kontext-Objekte zu berücksichtigen. Solche Probleme gelöst werden könnten ... aber Sie sind haftbar zu führen, um "überraschungen" für den Programmierer, und das ist nicht eine gute Sache.

Der aktuelle Ansatz ist einfach und leicht zu verstehen, und wenn Sie etwas komplizierter, die Sie umsetzen können ... indem er explizit einen MathContext für die Vorgänge, die es erfordern.

InformationsquelleAutor Stephen C
2

Könnten Sie eine Klasse erstellen, die erweitert BigDecimal und legt die Präzision automatisch für Sie. Dann müssen Sie nur verwenden Sie diese Klasse.
```
public class MyBigDecimal extends BigDecimal {
      public MyBigDecimal(double d) {
           super(d);
           this.setScale(120, BigDecimal.ROUND_HALF_UP);
      }
      ...
}
```
- Dies funktioniert nur, wenn der wrapper auch wraps alle BigDecimal-Operationen, die eine neue Instanz erstellen.
- Das wird nicht funktionieren. Aus den JavaDocs auf 'setScale': "Beachten Sie, dass seit BigDecimal-Objekte sind unveränderlich, ruft dieser Methode nicht in das ursprüngliche Objekt verändert wird, im Gegensatz zu der üblichen Konvention, Methoden namens setX mutieren Feld X. Statt, setScale gibt ein Objekt mit der richtigen Waage; das zurückgegebene Objekt kann oder kann nicht neu zugewiesen werden." So der Aufruf in den Konstruktor wird nicht alles tun, zumindest in einigen Situationen.
InformationsquelleAutor twain249
0

Können Sie erstellen einen wrapper für die BigDecimals, die diesen job tun:
```
 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 diesem Fall werden Sie nicht haben, um überschreiben der Betrieb von BigDecimal (bei der Verlängerung der Fall ist), nur diejenigen, die Sie verwenden. Es gibt Ihnen die Kontrolle über alle Instanzen und nicht zwingen, zu Folgen BigDecimal-Vertrag.

InformationsquelleAutor Eugene Retunsky

Müssen Sie erstellen Sie Ihre eigenen wrapper-Klasse, die hat Ihre Standard-MathContext wie das vollständige Beispiel:

In diesem Beispiel habe ich die Bibliothek (https://projectlombok.org)

import lombok.AccessLevel;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BigDecimalFactory {

    //Seguindo a precisão máxima do PowerBuilder e Oracle Database
    public static final MathContext DEFAULT_CONTEXT = new MathContext(120 , RoundingMode.HALF_UP);
    private static final BigDecimalFactory FACTORY = new BigDecimalFactory();

    private class SBigDecimal extends BigDecimal {

        public SBigDecimal(BigDecimal bdNumber) {
            super(bdNumber.toPlainString());
        }

        public SBigDecimal(String stringNumber) {
            super(stringNumber);
        }

        @Override
        public BigDecimal divide(BigDecimal divisor) {
            return new SBigDecimal(super.divide(divisor, DEFAULT_CONTEXT).stripTrailingZeros());
        }

        @Override
        public BigDecimal divide(BigDecimal divisor, MathContext mc) {
            return new SBigDecimal(super.divide(divisor, mc));
        }

        @Override
        public BigDecimal divideToIntegralValue(BigDecimal divisor) {
            return new SBigDecimal(super.divideToIntegralValue(divisor));
        }

        @Override
        public BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc) {
            return new SBigDecimal(super.divideToIntegralValue(divisor, mc));
        }

        @Override
        public BigDecimal remainder(BigDecimal divisor) {
            return new SBigDecimal(super.remainder(divisor));
        }

        @Override
        public BigDecimal remainder(BigDecimal divisor, MathContext mc) {
            return new SBigDecimal(super.remainder(divisor, mc));
        }

        @Override
        public BigDecimal pow(int n) {
            return new SBigDecimal(super.pow(n));
        }

        @Override
        public BigDecimal pow(int n, MathContext mc) {
            return new SBigDecimal(super.pow(n, mc));
        }

        @Override
        public BigDecimal abs() {
            return new SBigDecimal(super.abs());
        }

        @Override
        public BigDecimal abs(MathContext mc) {
            return new SBigDecimal(super.abs(mc));
        }

        @Override
        public BigDecimal negate() {
            return new SBigDecimal(super.negate());
        }

        @Override
        public BigDecimal negate(MathContext mc) {
            return new SBigDecimal(super.negate(mc));
        }

        @Override
        public BigDecimal plus() {
            return new SBigDecimal(super.plus());
        }

        @Override
        public BigDecimal plus(MathContext mc) {
            return new SBigDecimal(super.plus(mc));
        }

        @Override
        public BigDecimal round(MathContext mc) {
            return new SBigDecimal(super.round(mc));
        }

        @Override
        public BigDecimal setScale(int newScale, RoundingMode roundingMode) {
            return new SBigDecimal(super.setScale(newScale, roundingMode));
        }

        @Override
        public BigDecimal setScale(int newScale, int roundingMode) {
            return new SBigDecimal(super.setScale(newScale, roundingMode));
        }

        @Override
        public BigDecimal setScale(int newScale) {
            return new SBigDecimal(super.setScale(newScale));
        }

        @Override
        public BigDecimal movePointLeft(int n) {
            return new SBigDecimal(super.movePointLeft(n));
        }

        @Override
        public BigDecimal movePointRight(int n) {
            return new SBigDecimal(super.movePointRight(n));
        }

        @Override
        public BigDecimal scaleByPowerOfTen(int n) {
            return new SBigDecimal(super.scaleByPowerOfTen(n));
        }

        @Override
        public BigDecimal stripTrailingZeros() {
            return new SBigDecimal(super.stripTrailingZeros());
        }

        @Override
        public BigDecimal min(BigDecimal val) {
            return new SBigDecimal(super.min(val));
        }

        @Override
        public BigDecimal max(BigDecimal val) {
            return new SBigDecimal(super.max(val));
        }

        @Override
        public BigDecimal ulp() {
            return new SBigDecimal(super.ulp());
        }

        @Override
        public BigDecimal add(BigDecimal augend, MathContext mc) {
            return new SBigDecimal(super.add(augend, mc));
        }

        @Override
        public BigDecimal subtract(BigDecimal subtrahend) {
            return new SBigDecimal(super.subtract(subtrahend));
        }

        @Override
        public BigDecimal subtract(BigDecimal subtrahend, MathContext mc) {
            return new SBigDecimal(super.subtract(subtrahend, mc));
        }

        @Override
        public BigDecimal multiply(BigDecimal multiplicand) {
            return new SBigDecimal(super.multiply(multiplicand));
        }

        @Override
        public BigDecimal multiply(BigDecimal multiplicand, MathContext mc) {
            return new SBigDecimal(super.multiply(multiplicand, mc));
        }

        @Override
        public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) {
            return new SBigDecimal(super.divide(divisor, scale, roundingMode));
        }

        @Override
        public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) {
            return new SBigDecimal(super.divide(divisor, scale, roundingMode));
        }

        @Override
        public BigDecimal divide(BigDecimal divisor, int roundingMode) {
            return new SBigDecimal(super.divide(divisor, roundingMode));
        }

        @Override
        public BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode) {
            return new SBigDecimal(super.divide(divisor, roundingMode));
        }

        @Override
        public BigDecimal add(BigDecimal augend) {
            return new SBigDecimal(super.add(augend));
        }
    }

    public BigDecimal internalCreate(String stringNumber) {
        return new SBigDecimal(stringNumber);
    }

    public static BigDecimal create(BigDecimal b) {
        return FACTORY.internalCreate(b.toString());
    }

    public static BigDecimal create(String stringNumber) {
        return FACTORY.internalCreate(stringNumber);
    }

    public static BigDecimal create(Long longNumber) {
        return FACTORY.internalCreate(longNumber.toString());
    }

    public static BigDecimal create(Integer doubleNumber) {
        return FACTORY.internalCreate(doubleNumber.toString());
    }

    public static BigDecimal create(Double doubleNumber) {
        return FACTORY.internalCreate(doubleNumber.toString());
    }

}

Test:

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public class JavaTeste {

    public static void main(String args[]){

        //1) With your own BigDecimal
        BigDecimal b1 = BigDecimalFactory.create("100");
        BigDecimal b2 = BigDecimalFactory.create("25");
        BigDecimal b3 = BigDecimalFactory.create("13");
        System.out.println(b1.divide(b2));
        System.out.println(b1.divide(b3));


        //2) Without your own BigDecimal
        MathContext mathContext = new MathContext(38, RoundingMode.HALF_UP);
        BigDecimal b01 = new BigDecimal("100", mathContext);
        BigDecimal b02 = new BigDecimal("25", mathContext);
        BigDecimal b03 = new BigDecimal("13", mathContext);
        System.out.println(b01.divide(b02));
        System.out.println(b01.divide(b03, mathContext));

        //3) And this just not work
        BigDecimal b001 = new BigDecimal("100");
        BigDecimal b002 = new BigDecimal("25");
        BigDecimal b003 = new BigDecimal("13");
        System.out.println(b001.divide(b002));
        System.out.println(b001.divide(b003));

    }

}

InformationsquelleAutor rafambbr

-4

Können Sie die BigDecimal setScale Funktion!
```
BigDecimal db = new BigDecimal(<number>).setScale(120, BigDecimal.ROUND_HALF_UP); (or down)
```
- Ich würde immer noch führen Sie dies bei jeder Instanziierung eines BigDecimal.
InformationsquelleAutor Kevin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.