Logarithme d'un BigDecimal

Question

Comment puis-je calculer le logarithme d'un BigDecimal? Personne ne sait de toute algorithmes que je peux utiliser?

Mes recherches sur google à ce jour a venir avec le (inutile) idée de le convertir à un lit double et l'utilisation des Mathématiques.journal.

Je vais vous donner de la précision de la réponse demandée.

edit: tout à base de le faire. Si c'est plus facile dans la base x, je vais le faire.

Answer 1

Java Number Cruncher: La Java Guide du Programmeur pour le Calcul Numérique fournit une solution à l'aide de la Méthode de Newton. Le code Source du livre est disponible ici. Les mesures suivantes ont été prises à partir du chapitre 12.5 Grand Decmial Fonctions (p330 & p331):

/**
 * Compute the natural logarithm of x to a given scale, x > 0.
 */
public static BigDecimal ln(BigDecimal x, int scale)
{
    // Check that x > 0.
    if (x.signum() <= 0) {
        throw new IllegalArgumentException("x <= 0");
    }

    // The number of digits to the left of the decimal point.
    int magnitude = x.toString().length() - x.scale() - 1;

    if (magnitude < 3) {
        return lnNewton(x, scale);
    }

    // Compute magnitude*ln(x^(1/magnitude)).
    else {

        // x^(1/magnitude)
        BigDecimal root = intRoot(x, magnitude, scale);

        // ln(x^(1/magnitude))
        BigDecimal lnRoot = lnNewton(root, scale);

        // magnitude*ln(x^(1/magnitude))
        return BigDecimal.valueOf(magnitude).multiply(lnRoot)
                    .setScale(scale, BigDecimal.ROUND_HALF_EVEN);
    }
}

/**
 * Compute the natural logarithm of x to a given scale, x > 0.
 * Use Newton's algorithm.
 */
private static BigDecimal lnNewton(BigDecimal x, int scale)
{
    int        sp1 = scale + 1;
    BigDecimal n   = x;
    BigDecimal term;

    // Convergence tolerance = 5*(10^-(scale+1))
    BigDecimal tolerance = BigDecimal.valueOf(5)
                                        .movePointLeft(sp1);

    // Loop until the approximations converge
    // (two successive approximations are within the tolerance).
    do {

        // e^x
        BigDecimal eToX = exp(x, sp1);

        // (e^x - n)/e^x
        term = eToX.subtract(n)
                    .divide(eToX, sp1, BigDecimal.ROUND_DOWN);

        // x - (e^x - n)/e^x
        x = x.subtract(term);

        Thread.yield();
    } while (term.compareTo(tolerance) > 0);

    return x.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
}

Answer 2

Un hacky peu algorithme qui fonctionne très bien pour un grand nombre utilise la relation log(AB) = log(A) + log(B). Voici comment le faire en base 10 (que vous pouvez trivialement de convertir n'importe quel autre logarithme en base):

1. Compter le nombre de chiffres après la virgule dans la réponse. C'est la partie intégrante de votre logarithme, plus un. Exemple: floor(log10(123456)) + 1 6, depuis 123456 a 6 chiffres.

2. Vous pouvez vous arrêter là si vous avez besoin de la partie entière du logarithme: il suffit de soustraire 1 à partir du résultat de l'étape 1.

3. Pour obtenir la partie fractionnaire du logarithme, diviser le nombre par 10^(number of digits), puis calculer le journal de l'utilisation de math.log10() (ou que ce soit; l'utilisation d'une simple série d'approximation, si rien d'autre n'est disponible), et l'ajouter à la partie entière. Exemple: pour obtenir la partie fractionnaire de l' log10(123456), calculez math.log10(0.123456) = -0.908..., et l'ajouter à la suite de l'étape 1: 6 + -0.908 = 5.092, ce qui est log10(123456). Notez que vous êtes tout simplement de virer de bord sur un point décimal à l'avant du grand nombre; il y a probablement un bon moyen pour optimiser ce dans votre cas d'utilisation, et pour les très grands nombres, vous n'avez même pas besoin de s'embêter à saisir tous les chiffres -- log10(0.123) est une excellente approximation log10(0.123456789).

Answer 3

Vous pourrait se décomposer à l'aide de

log(a * 10^b) = log(a) + b * log(10)

Fondamentalement, b+1 va être le nombre de chiffres dans le nombre et a sera une valeur entre 0 et 1 dont on peut calculer le logarithme de par l'utilisation régulière double de l'arithmétique.

Ou il y a des mathématiques astuces que vous pouvez utiliser, par exemple, les logarithmes de nombres proches de 1 peut être calculée par une extension de la série

ln(x + 1) = x - x^2/2 + x^3/3 - x^4/4 + ...

En fonction du type de numéro que vous essayez de prendre le logarithme de l', il y a peut être quelque chose comme cela, vous pouvez utiliser.

EDIT: Pour obtenir le logarithme en base 10, vous pouvez diviser le logarithme naturel en ln(10), ou même pour toute autre base.

Answer 4

C'est ce que j'ai trouvé:

//http://everything2.com/index.pl?node_id=946812        
public BigDecimal log10(BigDecimal b, int dp)
{
	final int NUM_OF_DIGITS = dp+2; // need to add one to get the right number of dp
	                                //  and then add one again to get the next number
	                                //  so I can round it correctly.

	MathContext mc = new MathContext(NUM_OF_DIGITS, RoundingMode.HALF_EVEN);

	//special conditions:
	// log(-x) -> exception
	// log(1) == 0 exactly;
	// log of a number lessthan one = -log(1/x)
	if(b.signum() <= 0)
		throw new ArithmeticException("log of a negative number! (or zero)");
	else if(b.compareTo(BigDecimal.ONE) == 0)
		return BigDecimal.ZERO;
	else if(b.compareTo(BigDecimal.ONE) < 0)
		return (log10((BigDecimal.ONE).divide(b,mc),dp)).negate();

	StringBuffer sb = new StringBuffer();
	//number of digits on the left of the decimal point
	int leftDigits = b.precision() - b.scale();

	//so, the first digits of the log10 are:
	sb.append(leftDigits - 1).append(".");

	//this is the algorithm outlined in the webpage
	int n = 0;
	while(n < NUM_OF_DIGITS)
	{
		b = (b.movePointLeft(leftDigits - 1)).pow(10, mc);
		leftDigits = b.precision() - b.scale();
		sb.append(leftDigits - 1);
		n++;
	}

	BigDecimal ans = new BigDecimal(sb.toString());

	//Round the number to the correct number of decimal places.
	ans = ans.round(new MathContext(ans.precision() - ans.scale() + dp, RoundingMode.HALF_EVEN));
	return ans;
}

Answer 5

Une implémentation Java de Meower68 pseudcode qui j'ai testé avec quelques chiffres:

public static BigDecimal log(int base_int, BigDecimal x) {
        BigDecimal result = BigDecimal.ZERO;

        BigDecimal input = new BigDecimal(x.toString());
        int decimalPlaces = 100;
        int scale = input.precision() + decimalPlaces;

        int maxite = 10000;
        int ite = 0;
        BigDecimal maxError_BigDecimal = new BigDecimal(BigInteger.ONE,decimalPlaces + 1);
        System.out.println("maxError_BigDecimal " + maxError_BigDecimal);
        System.out.println("scale " + scale);

        RoundingMode a_RoundingMode = RoundingMode.UP;

        BigDecimal two_BigDecimal = new BigDecimal("2");
        BigDecimal base_BigDecimal = new BigDecimal(base_int);

        while (input.compareTo(base_BigDecimal) == 1) {
            result = result.add(BigDecimal.ONE);
            input = input.divide(base_BigDecimal, scale, a_RoundingMode);
        }

        BigDecimal fraction = new BigDecimal("0.5");
        input = input.multiply(input);
        BigDecimal resultplusfraction = result.add(fraction);
        while (((resultplusfraction).compareTo(result) == 1)
                && (input.compareTo(BigDecimal.ONE) == 1)) {
            if (input.compareTo(base_BigDecimal) == 1) {
                input = input.divide(base_BigDecimal, scale, a_RoundingMode);
                result = result.add(fraction);
            }
            input = input.multiply(input);
            fraction = fraction.divide(two_BigDecimal, scale, a_RoundingMode);
            resultplusfraction = result.add(fraction);
            if (fraction.abs().compareTo(maxError_BigDecimal) == -1){
                break;
            }
            if (maxite == ite){
                break;
            }
            ite ++;
        }

        MathContext a_MathContext = new MathContext(((decimalPlaces - 1) + (result.precision() - result.scale())),RoundingMode.HALF_UP);
        BigDecimal roundedResult = result.round(a_MathContext);
        BigDecimal strippedRoundedResult = roundedResult.stripTrailingZeros();
        //return result;
        //return result.round(a_MathContext);
        return strippedRoundedResult;
    }