Que faire avec Java BigDecimal la performance?

Donc ma réponse était juste à plat de mal, parce que mon test a été écrit mal. Je suppose que je suis le seul qui doit avoir été critiqué, pas OP 😉 Cela peut avoir été l'un des premiers benchmarks que j'ai jamais écrit... eh bien, c'est la façon dont vous apprenez. Plutôt que de supprimer la réponse, voici les résultats, si je ne suis pas en mesure de quelque chose de mal. Quelques remarques:

• Précalculer les tableaux donc je ne plaisante pas avec les résultats en générant eux
• Ne pas jamais appel BigDecimal.doubleValue(), comme il est extrêmement lent
• Ne plaisante pas avec les résultats en ajoutant des BigDecimals. Il suffit de retourner une valeur, et d'utiliser une instruction if pour empêcher l'optimisation du compilateur. Assurez-vous de faire travailler la plupart du temps pour permettre à la branche de prédiction afin d'éliminer la partie du code.

Tests:

• BigDecimal: faites le calcul exactement comme vous l'avez suggéré, il
• BigDecNoRecip: (1/b) * c = c/b, il suffit de faire c/b
• Double: faire le calcul avec des doubles

Voici le résultat:

 0% Scenario{vm=java, trial=0, benchmark=Double} 0.34 ns; ?=0.00 ns @ 3 trials
33% Scenario{vm=java, trial=0, benchmark=BigDecimal} 356.03 ns; ?=11.51 ns @ 10 trials
67% Scenario{vm=java, trial=0, benchmark=BigDecNoRecip} 301.91 ns; ?=14.86 ns @ 10 trials

    benchmark      ns linear runtime
       Double   0.335 =
   BigDecimal 356.031 ==============================
BigDecNoRecip 301.909 =========================

vm: java
trial: 0

Voici le code:

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.Random;
import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;
public class BigDecimalTest {
public static class Benchmark1 extends SimpleBenchmark {
private static int ARRAY_SIZE = 131072;
private Random r;
private BigDecimal[][] bigValues = new BigDecimal[3][];
private double[][] doubleValues = new double[3][];
@Override
protected void setUp() throws Exception {
super.setUp();
r = new Random();
for(int i = 0; i < 3; i++) {
bigValues[i] = new BigDecimal[ARRAY_SIZE];
doubleValues[i] = new double[ARRAY_SIZE];
for(int j = 0; j < ARRAY_SIZE; j++) {
doubleValues[i][j] = r.nextDouble() * 1000000;
bigValues[i][j] = BigDecimal.valueOf(doubleValues[i][j]); 
}
}
}
public double timeDouble(int reps) {
double returnValue = 0;
for (int i = 0; i < reps; i++) {
double a = doubleValues[0][reps & 131071];
double b = doubleValues[1][reps & 131071];
double c = doubleValues[2][reps & 131071];
double division = a * (1/b) * c; 
if((i & 255) == 0) returnValue = division;
}
return returnValue;
}
public BigDecimal timeBigDecimal(int reps) {
BigDecimal returnValue = BigDecimal.ZERO;
for (int i = 0; i < reps; i++) {
BigDecimal a = bigValues[0][reps & 131071];
BigDecimal b = bigValues[1][reps & 131071];
BigDecimal c = bigValues[2][reps & 131071];
BigDecimal division = a.multiply(BigDecimal.ONE.divide(b, MathContext.DECIMAL64).multiply(c));
if((i & 255) == 0) returnValue = division;
}
return returnValue;
}
public BigDecimal timeBigDecNoRecip(int reps) {
BigDecimal returnValue = BigDecimal.ZERO;
for (int i = 0; i < reps; i++) {
BigDecimal a = bigValues[0][reps & 131071];
BigDecimal b = bigValues[1][reps & 131071];
BigDecimal c = bigValues[2][reps & 131071];
BigDecimal division = a.multiply(c.divide(b, MathContext.DECIMAL64));
if((i & 255) == 0) returnValue = division;
}
return returnValue;
}
}
public static void main(String... args) {
Runner.main(Benchmark1.class, new String[0]);
}
}

En supposant que vous pouvez fonctionner jusqu'à un certain arbitraire, mais connu de précision (un milliardième de cent) et une valeur maximale, vous avez besoin de la poignée (un de trillions de trillions de dollars?) vous pouvez écrire une classe qui stocke cette valeur comme un nombre entier de milliardièmes de cent. Vous aurez besoin de deux longs pour le représenter. Qui devrait être peut-être dix fois plus lent que l'utilisation de double; une centaine de fois plus rapide que BigDecimal.

La plupart des opérations sont la simple exécution de l'opération sur chaque partie et renormer. La Division est un peu plus compliqué, mais pas beaucoup.

EDIT:En réponse à l'observation. Vous devrez mettre en place un bitshift fonctionnement de votre classe (facile que de le long que le multiplicateur pour le haut de long est une puissance de deux). Faire de décalage de la division, le diviseur jusqu'à ce qu'il n'est pas beaucoup plus grand que le dividende; soustraire décalé diviseur dividende et incrémenter le résultat (avec les maj). Répétez.

MODIFIER à NOUVEAU:Vous pouvez trouver BigInteger fait ce que vous avez besoin ici.

Vous pouvez déplacer de point fixe de mathématiques. Juste à la recherche de quelques bibliothèques de la droite maintenant.
sur le site de sourceforge point fixe je n'ai pas regardé en profondeur encore. beartonics

Avez-vous testé avec org.jscience.de l'économie.de l'argent? depuis qu'il a assuré de l'exactitude. Le point fixe ne seront plus précis que le nombre de bits attribués à chaque morceau, mais il est rapide.

Quelle est la version du JDK/JRE utilisez-vous?

Aussi, vous pouvez essayer ArciMath BigDecimal pour voir si leurs vitesses pour vous.

Edit:

Je me souviens avoir lu quelque part (je crois que c'était Efficace Java) que le BigDecmal classe a changé de se JNI appelé à une bibliothèque C pour tous les produits Java à un certain point... et il a obtenu plus rapidement à partir de cela. Il se pourrait donc que toute précision arbitraire de la bibliothèque que vous utilisez ne va pas vous obtenir la vitesse dont vous avez besoin.

Only 10x performance increase desired for something that is 1000x slower than primitive?!.

Jetant un peu plus de matériel à ce qui pourrait être moins cher (en tenant compte de la probabilité d'avoir une monnaie erreur de calcul).

facile... de votre tour de résultats souvent permettra d'éliminer le type de données double de l'erreur.
si vous faites le calcul du bilan, vous devez également envisager qui sera propriétaire de la plus/moins sou causés par l'arrondissement.

bigdeciaml calcul a produit plus de/moins de penny trop, songez à 100/3 cas.

Pouvez-vous fournir plus de perspicacité que le but de ce calcul?

Ce que votre affaire est un compromis entre la vitesse et la précision. Combien grande sera la perte de précision si vous êtes passé à un primitif?

Je pense que dans certains cas l'utilisateur peut être à l'aise avec moins de précision en échange de vitesse, tant qu'ils peuvent examiner le calcul précis en cas de besoin. Cela dépend vraiment de ce que vous allez utiliser ce calcul pour.

Peut-être vous pouvez permettre à l'utilisateur de prévisualiser le résultat rapidement en utilisant un double, puis demande la plus précise de la valeur à l'aide de BigDecimal si elles le désirent?

Peut-être que vous devriez regarder dans l'obtention de l'accélération matérielle arithmétique décimale?

http://speleotrove.com/decimal/

Il semble que la solution la plus simple est d'utiliser BigInteger plutôt longue à mettre en place au pesto de solution. Si il semble désordonné, il serait facile d'écrire une classe qui encapsule BigInteger pour masquer le réglage de précision.

Sur une JVM 64 bits de la création de votre BigDecimal comme ci-dessous rend environ 5x plus rapide:

BigDecimal bd = new BigDecimal(Double.toString(d), MathContext.DECIMAL64);