je pense qu'un programmeur aurait dû implémenter sa propre bibliothèque bignum une fois, donc bienvenue ici.

(bien sûr, plus tard, vous obtiendrez que BigInteger est mieux, et utilisez ceci, mais c'est une expérience d'apprentissage précieuse.)

(vous pouvez suivre le code source de cette vie de cours sur github . En outre, je remade ceci (un peu poli) dans un 14-partie de la série de blog .)

la Création d'un simple Grand nombre de classe en Java

Alors, de quoi avons-nous besoin?

D'abord, une représentation du nombre,

basé sur les types de données que Java nous donne.

comme vous pensez que la conversion décimale est la partie la plus compliquée, restons en mode décimal. Pour plus d'efficacité, nous ne stockerons pas de vrais chiffres décimaux, mais travaillerons dans la base 1 000 000 000 = 10^9 < 2^30 . Cela s'inscrit dans un Java int (jusqu'à 2^31 ou 2^32 ), et le produit de deux tels chiffres s'adapte bien dans une Java long .

final static int BASE = 1000000000;
final static int BASE_DECIMAL_DIGITS = 9;

puis les chiffres-tableau:

private int[] digits;

est - ce que nous stockons les chiffres en petit-ou grand endian, c'est-à-dire les plus grandes parties en premier ou en dernier? Cela n'a pas vraiment d'importance, donc nous décidons sur big-endian puisque c'est ainsi que les humains veulent le lire. (Pour l'instant, nous nous concentrons sur les valeurs-plus tard, nous ajouterons un bit de signe pour les nombres négatifs.)

pour les tests, nous ajoutons un constructeur qui permet d'initialiser à partir d'un tel int[].

/**
 * creates a DecimalBigInt based on an array of digits.
 * @param digits a list of digits, each between 0 (inclusive)
 *    and {@link BASE} (exclusive).
 * @throws IllegalArgumentException if any digit is out of range.
 */
public DecimalBigInt(int... digits) {
    for(int digit : digits) {
        if(digit < 0 ||  BASE <= digit) {
            throw new IllegalArgumentException("digit " + digit +
                                               " out of range!");
        }
    }
    this.digits = digits.clone();
}

comme bonus supplémentaire, ce constructeur est également utilisable pour un seul int (si plus petit que BASE ), et même pour le no int (que nous interpréterons comme 0). Ainsi, nous pouvons maintenant faire ceci:

DecimalBigInt d = new DecimalBigInt(7, 5, 2, 12345);
System.out.println(d);

cela nous donne de.fencing_game.paul.examples.DecimalBigInt@6af62373 , pas si utile. Ainsi, nous ajoutons une toString() méthode:

/**
 * A simple string view for debugging purposes.
 * (Will be replaced later with a real decimal conversion.)
 */
public String toString() {
    return "Big" + Arrays.toString(digits);
}

la sortie est maintenant Big[7, 5, 2, 12345] , ce qui est plus utile pour tester, n'est-ce pas?

Deuxièmement, la conversion de format décimal.

nous sommes chanceux ici: notre base (10^9) est une puissance de la base que nous voulons convertir de (10). Ainsi, nous avons toujours le même nombre (9) de décimales représentant un chiffre "notre format". (Bien sûr, au début, il n' peut-être certains chiffres moins.) Dans le code suivant, decimal est une chaîne de chiffres décimaux.

 int decLen = decimal.length();
 int bigLen = (decLen-1) / BASE_DECIMAL_DIGITS + 1;

cette formule étrange est une écriture Java int bigLen = ceil(decLen/BASE_DECIMAL_DIGITS) . (J'espère que c'est correct, nous le testerons plus tard.)

 int firstSome = decLen - (bigLen-1) * BASE_DECIMAL_DIGITS;

longueur du premier bloc de chiffres décimaux comprise entre 1 et 9 (inclusivement).

nous créons notre tableau:

 int[] digits = new int[bigLen];

Boucle à travers les chiffres à créer:

 for(int i = 0; i < bigLen ; i++) {

chacun de nos chiffres est représenté par un bloc de chiffres dans le numéro original:

    String block =
        decimal.substring(Math.max(firstSome + (i-1)*BASE_DECIMAL_DIGITS, 0),
                          firstSome +   i  *BASE_DECIMAL_DIGITS);

(le Math.max est nécessaire ici pour le premier bloc plus court.) Nous utilisons maintenant la fonction habituelle de parsing entier, et mettons le résultat dans le tableau:

    digits[i] = Integer.parseInt(block);
}

à partir du tableau maintenant créé, nous créons notre Décimalbigint objet:

return new DecimalBigInt(digits);

voyons si cela fonctionne:

DecimalBigInt d2 = DecimalBigInt.valueOf("12345678901234567890");
System.out.println(d2);

sortie:

Big[12, 345678901, 234567890]

semble à droite: -) nous devrions le tester avec d'autres nombres (de longueur différente) aussi.

la prochaine partie sera le formatage décimal, cela devrait être encore plus facile.

troisième, conversion au format décimal.

nous devons produire notre individu chiffres en 9 chiffres décimaux chacun. Pour cela, nous pouvons utiliser la classe Formatter , qui supporte les chaînes de format de type printf.

une variante simple serait celle-ci:

public String toDecimalString() {
    Formatter f = new Formatter();
    for(int digit : digits) {
        f.format("%09d", digit);
    }
    return f.toString();
}

cela renvoie 000000007000000005000000002000012345 et 000000012345678901234567890 pour nos deux numéros. Cela fonctionne pour un aller-retour (i.e. l'alimenter à la méthode valueOf donne un objet équivalent), mais les zéros de tête ne sont pas vraiment agréable à regarder (et pourrait créer une confusion avec octal nombre.) Nous devons donc séparer notre belle boucle pour chaque boucle et utiliser une chaîne de formatage différente pour les premiers chiffres et les suivants.

public String toDecimalString() {
    Formatter f = new Formatter();
    f.format("%d", digits[0]);
    for(int i = 1 ; i < digits.length; i++) {
        f.format("%09d", digits[i]);
    }
    return f.toString();
}

Addition.

commençons par l'addition, car c'est simple (et nous pouvons en utiliser des parties pour la multiplication plus tard).

/**
 * calculates the sum of this and that.
 */
public DecimalBigInt plus(DecimalBigInt that) {
    ...
}

je veux des noms de méthode que vous pouvez lire comme vous liriez la formule, donc plus , minus , times au lieu de add , subtract , multiply .

alors, comment fonctionne l'addition? Il fonctionne de la même façon que nous l'avons appris à l'école pour les nombres décimaux supérieurs à 9: ajouter les chiffres correspondants, et si pour certains alors le résultat est plus grand que 10 (ou BASE dans notre cas), porter un au chiffre suivant. Cela peut causer le nombre résultant d'avoir un chiffre de plus que les originaux.

cas où les deux numéros ont le même nombre de chiffres. Alors il ressemble tout simplement à ceci:

int[] result = new int[this.digits.length];
int carry = 0;
for(int i = this.digits.length-1; i > 0; i--) {
    int digSum = carry + this.digits[i] + that.digits[i];
    result[i] = digSum % BASE;
    carry = digSum / BASE;
}
if(carry > 0) {
    int[] temp = new int[result.length + 1];
    System.arraycopy(result, 0, temp, 1, result.length);
    temp[0] = carry;
    result = temp;
}
return new DecimalBigInt(result);

(nous allons de droite à gauche, donc nous pouvons reporter tout débordement au chiffre suivant. Ce serait un peu plus joli si nous avions décidé d'utiliser le format Little Endian.)

Si les deux nombres n'ont pas le même nombre de chiffres, il devient un peu plus compliqué.

pour faire aussi simple que possible, nous le divisons en plusieurs méthodes:

Cette méthode permet d'ajouter un chiffre à un élément du tableau (qui peut déjà contenir une valeur non nulle), et stocke le résultat dans le tableau. S'il y avait débordement, nous le portons au chiffre suivant (qui a un indice de moins, pas un de plus) au moyen d'un appel récursif. De cette façon, nous nous assurons que nos chiffres de rester toujours dans la plage valide.

/**
 * adds one digit from the addend to the corresponding digit
 * of the result.
 * If there is carry, it is recursively added to the next digit
 * of the result.
 */
private void addDigit(int[] result, int resultIndex,
                      int addendDigit)
{
    int sum = result[resultIndex] + addendDigit;
    result[resultIndex] = sum % BASE;
    int carry = sum / BASE;
    if(carry > 0) {
        addDigit(result, resultIndex - 1, carry);
    }
}

le suivant fait la même chose pour un tableau entier de chiffres à ajouter:

/**
 * adds all the digits from the addend array to the result array.
 */
private void addDigits(int[] result, int resultIndex,
                       int... addend)
{
    addendIndex = addend.length - 1;
    while(addendIndex >= 0) {
        addDigit(result, resultIndex,
                 addend[addendIndex]);
        addendIndex--;
        resultIndex--;
    }
}

maintenant nous pouvons implémenter notre méthode plus :

/**
 * calculates the sum of this and that.
 */
public DecimalBigInt plus(DecimalBigInt that) {
    int[] result = new int[Math.max(this.digits.length,
                                    that.digits.length)+ 1];

    addDigits(result, result.length-1, this.digits);
    addDigits(result, result.length-1, that.digits);

    // cut of leading zero, if any
    if(result[0] == 0) {
        result = Arrays.copyOfRange(result, 1, result.length);
    }
    return new DecimalBigInt(result);
}

nous pourrions faire un peu mieux ici si nous regardons avant si le débordement est tout à fait possible et seulement alors créer le tableau un plus grand que nécessaire.

AH, un test: d2.plus(d2) donne Big[24, 691357802, 469135780] , qui semble droit.

Multiplication.

souvenons-nous de retourner à l'école, comment avons-nous multiplié plus de chiffres sur le papier?

123 * 123
----------
      369   <== 123 * 3
     246    <== 123 * 2
    123     <== 123 * 1
  --------
    15129

ainsi, nous devons multiplier chaque chiffre[i] du premier numéro avec chaque chiffre[j] du deuxième numéro, et ajouter le produit dans le chiffre[i+j] du résultat (et faire attention à porter). Bien sûr, ici, les indices sont comptés à partir de la droite, pas de gauche. (maintenant j'aurais vraiment aimé avoir utilisé des petits nombres-endian.)

puisque le produit de deux de nos chiffres peut sortir de la gamme de int , nous utilisons long pour la multiplication.

/**
 * multiplies two digits and adds the product to the result array
 * at the right digit-position.
 */
private void multiplyDigit(int[] result, int resultIndex,
                           int firstFactor, int secondFactor) {
    long prod = (long)firstFactor * (long)secondFactor;
    int prodDigit = (int)(prod % BASE);
    int carry = (int)(prod / BASE);
    addDigits(result, resultIndex, carry, prodDigit);
}

maintenant nous pouvons voir pourquoi j'ai déclaré ma méthode addDigits pour prendre un paramètre resultIndex . (Et je viens de changer le dernier argument d'une varargs paramètre, pour être en mesure d'écrire ce mieux ici.)

ainsi, ici la méthode de la multiplication croisée:

private void multiplyDigits(int[] result, int resultIndex,
                            int[] leftFactor, int[] rightFactor) {
    for(int i = 0; i < leftFactor.length; i++) {
        for(int j = 0; j < rightFactor.length; j++) {

            multiplyDigit(result, resultIndex - (i + j),
                          leftFactor[leftFactor.length-i-1],
                          rightFactor[rightFactor.length-j-1]);
        }
    }
}

j'espère que j'ai bien calculé l'indice. Avec un petit-endian représentation, ça aurait été multiplyDigit(result, resultIndex + i + j, leftFactor[i], rightFactor[j]) - plus clair, n'est-ce pas?

notre méthode times n'a plus qu'à attribuer le tableau de résultats, invoquer multiplyDigits et envelopper le résultat.

/**
 * returns the product {@code this × that}.
 */
public DecimalBigInt times(DecimalBigInt that) {
    int[] result = new int[this.digits.length + that.digits.length];
    multiplyDigits(result, result.length-1, 
                   this.digits, that.digits);

    // cut off leading zero, if any
    if(result[0] == 0) {
        result = Arrays.copyOfRange(result, 1, result.length);
    }
    return new DecimalBigInt(result);
}

Pour les essais, d2.times(d2) donne Big[152, 415787532, 388367501, 905199875, 19052100] , qui est le même que mon Emacs calc calcule ici.

comparaison

nous voulons pouvoir comparer deux de nos objets. Si, nous implémentons Comparable<DecimalBigInt> et sa méthode compareTo.

public int compareTo(DecimalBigInt that) {

Comment savoir si un de nos nombres est plus grand qu'un autre? Tout d'abord, nous comparons la longueur des tableaux. Comme nous avons pris soin de ne pas induire des zéros (avons-nous?), le long de tableau devrait avoir le plus grand nombre.

    if(this.digits.length < that.digits.length) {
        return -1;
    }
    if (that.digits.length < this.digits.length) {
        return 1;
    }

si la longueur est la même,nous pouvons comparer les éléments. Puisque nous utilisons big endian (i.e. la grande fin vient en premier ), nous commençons par le commencement.

    for(int i = 0; i < this.digits.length; i++) {
        if(this.digits[i] < that.digits[i]) {
            return -1;
        }
        if(that.digits[i] < this.digits[i]) {
            return 1;
        }
    }

si tout était pareil, évidemment nos nombres sont identiques, et nous pouvons retourner 0 .

    return 0;
}

equals + hashCode()

toute bonne classe immuable doit mettre en œuvre equals() et hashCode() d'une manière appropriée (et compatible).

pour notre hashCode() , nous résumons simplement les chiffres, en les multipliant par un petit prime pour s'assurer que le changement de chiffre n'entraîne pas le même code de hachage:

/**
 * calculates a hashCode for this object.
 */
public int hashCode() {
    int hash = 0;
    for(int digit : digits) {
        hash = hash * 13 + digit;
    }
    return hash;
}

dans la méthode equals() nous pouvons tout simplement déléguer à la méthode compareTo, au lieu d'implémenter à nouveau le même algorithme:

/**
 * compares this object with another object for equality.
 * A DecimalBigInt is equal to another object only if this other
 * object is also a DecimalBigInt and both represent the same
 * natural number.
 */
public boolean equals(Object o) {
    return o instanceof DecimalBigInt &&
        this.compareTo((DecimalBigInt)o) == 0;
}

---

donc, assez pour aujourd'hui. La soustraction (et peut-être les nombres négatifs) et la division sont plus compliquées, donc je les Omets pour le moment. pour le calcul de la factoriel de 90 cela devrait suffire.

Calcul de gros factorielles:

ici la fonction factorielle:

/**
 * calculates the factorial of an int number.
 * This uses a simple iterative loop.
 */
public static DecimalBigInt factorial(int n) {
    DecimalBigInt fac = new DecimalBigInt(1);
    for(int i = 2; i <= n; i++) {
        fac = fac.times(new DecimalBigInt(i));
    }
    return fac;
}

cela nous donne

fac(90) = 1485715964481761497309522733620825737885569961284688766942216863704985393094065876545992131370884059645617234469978112000000000000000000000

conversion de représentations arbitraires-radix

poussé par la question suivante de frodosamoa, j'ai écrit ma réponse sur la façon de convertir de nombre arbitraire (de position) systèmes dans lesquels nous pouvons (OU voulons) calculer . (Dans l'exemple, j'ai converti de trinaire à décimal, alors que la question était d'environ décimal À binaire.)

ici nous voulons convertir d'un système de nombre arbitraire (d'accord, avec radix entre 2 et 36, donc nous pouvons utiliser Character.digit() pour convertir des chiffres simples en ints) à notre système avec radix BASE (=1.000.000.000, mais ce n'est pas vraiment important ici).

Fondamentalement, nous utilisons Horner scheme pour calculer la valeur du polynôme avec les chiffres comme coefficients au point donné par le radix.

sum[i=0..n] digit[i] * radix^i

peut être calculé avec cette boucle:

value = 0;
for  i = n .. 0
  value = value * radix + digit[i]
return value

étant donné que nos chaînes de saisie sont big-endian, nous n'avons pas à compter vers le bas, mais pouvons utiliser un simple amélioré pour boucle. (Il semble plus laid en Java, puisque nous n'avons aucun opérateur en surcharge, et pas d'autoboxing de l'int à notre Type décimalbigint.)

public static DecimalBigInt valueOf(String text, int radix) {
    DecimalBigInt bigRadix = new DecimalBigInt(radix);
    DecimalBigInt value = new DecimalBigInt(); // 0
    for(char digit : text.toCharArray()) {
       DecimalBigInt bigDigit =
           new DecimalBigInt(Character.digit(digit, radix));
       value = value.times(bigRadix).plus(bigDigit);
    }
    return value;
}

Dans ma mise en œuvre effective j'ai ajouté un peu de vérification des erreurs (et à l'exception de jeter) pour s'assurer que nous avons vraiment un numéro de série valide, et bien sûr un commentaire de documentation.

---

conversion en un système de position arbitraire est plus compliqué, car il implique le reste et la division (par l'arbitraire radix), que nous n'avons pas les mettre en œuvre - donc pas pour l'instant. Ce sera fait quand j'aurai une bonne idée de comment faire la division. (Nous n'avons besoin ici que d'une division par de petits nombres (un chiffre), ce qui peut être plus facile qu'une division générale.)

Division par petits nombres

à l'école, j'ai appris longue division . Voici un exemple pour un petit (à un chiffre) diviseur, dans la notation que nous utilisons ici en Allemagne (avec annotations sur les calculs de fond, que nous n'écririons normalement pas), en système décimal:

 12345 : 6 = 02057     1 / 6 =  0
-0┊┊┊┊                 0 * 6 =  0
──┊┊┊┊
 12┊┊┊                12 / 6 =  2
-12┊┊┊                 2 * 6 = 12
 ──┊┊┊
  03┊┊                 3 / 6 =  0
 - 0┊┊                 0 * 6 =  0
  ──┊┊
   34┊                34 / 6 =  5
  -30┊                 5 * 6 = 30
   ──┊
    45                45 / 6 =  7
   -42                 7 * 6 = 42
    ──
     3     ==> quotient 2057, remainder 3.

de Cuse, nous n'avons pas besoin de calculer ces produits (0, 12, 0, 30, 42) et soustraire si nous avons un natif reste de l'opération. Puis il ressemble comme ceci (bien sûr, nous n'aurions pas besoin ici d'écrire les opérations):

 12345 : 6 = 02057     1 / 6 =  0,   1 % 6 = 1
 12┊┊┊                12 / 6 =  2,  12 % 6 = 0
  03┊┊                 3 / 6 =  0,   3 % 6 = 3
   34┊                34 / 6 =  5,  34 % 6 = 4
    45                45 / 6 =  7,  45 % 6 = 3
     3
           ==> quotient 2057, remainder 3.

cela ressemble déjà assez à Division courte , si nous écrivons dans un autre format.

nous pouvons observer (et prouver) ce qui suit:

si nous avons un nombre à deux chiffres x avec le premier chiffre plus petit que notre diviseur d, x / d est un nombre à un chiffre, et x % d est aussi un nombre à un chiffre plus petit que D. Ceci, avec l'induction, montre que nous n'avons besoin que de diviser (avec le reste) les nombres à deux chiffres par notre diviseur.

revenant à nos grands nombres avec base radix: tous les numéros à deux chiffres peuvent être représentés comme un Java long , et là nous avons natif / et % .

/**
 * does one step in the short division algorithm, i.e. divides
 *  a two-digit number by a one-digit one.
 *
 * @param result the array to put the quotient digit in.
 * @param resultIndex the index in the result array where
 *             the quotient digit should be put.
 * @param divident the last digit of the divident.
 * @param lastRemainder the first digit of the divident (being the
 *           remainder of the operation one digit to the left).
 *           This must be < divisor.
 * @param divisor the divisor.
 * @returns the remainder of the division operation.
 */
private int divideDigit(int[] result, int resultIndex,
                        int divident, int lastRemainder,
                        int divisor) {
    assert divisor < BASE;
    assert lastRemainder < divisor;

    long ent = divident + (long)BASE * lastRemainder;

    long quot = ent / divisor;
    long rem = ent % divisor;

    assert quot < BASE;
    assert rem < divisor;

    result[resultIndex] = (int)quot;
    return (int)rem;
}

Nous allons maintenant appeler cette méthode dans une boucle, toujours nourrir le résultat de l'appel précédent comme lastRemainder .

/**
 * The short division algorithm, like described in
 * <a href="http://en.wikipedia.org/wiki/Short_division">Wikipedia's
 *   article <em>Short division</em></a>.
 * @param result an array where we should put the quotient digits in.
 * @param resultIndex the index in the array where the highest order digit
 *     should be put, the next digits will follow.
 * @param divident the array with the divident's digits. (These will only
 *          be read, not written to.)
 * @param dividentIndex the index in the divident array where we should
 *         start dividing. We will continue until the end of the array.
 * @param divisor the divisor. This must be a number smaller than
 *        {@link #BASE}.
 * @return the remainder, which will be a number smaller than
 *     {@code divisor}.
 */
private int divideDigits(int[] result, int resultIndex,
                         int[] divident, int dividentIndex,
                         int divisor) {
    int remainder = 0;
    for(; dividentIndex < divident.length; dividentIndex++, resultIndex++) {
        remainder = divideDigit(result, resultIndex,
                                divident[dividentIndex],
                                remainder, divisor);
    }
    return remainder;
}

cette méthode renvoie encore un int, le reste.

maintenant, nous voulons avoir une méthode publique retournant un caractère décimal, donc nous en créer un. Il a la tâche de vérifier les arguments, de créer un tableau pour la méthode de travail, de jeter le reste, et de créer une Décimalbigint à partir du résultat. (Le constructeur supprime un zéro principal qui peut être présent.)

/**
 * Divides this number by a small number.
 * @param divisor an integer with {@code 0 < divisor < BASE}.
 * @return the integer part of the quotient, ignoring the remainder.
 * @throws IllegalArgumentException if the divisor is <= 0 or >= BASE.
 */
public DecimalBigInt divideBy(int divisor)
{
    if(divisor <= 0 || BASE <= divisor) {
        throw new IllegalArgumentException("divisor " + divisor +
                                           " out of range!");
    }

    int[] result = new int[digits.length];
    divideDigits(result, 0,
                 digits, 0,
                 divisor);
    return new DecimalBigInt(result);
}

nous avons aussi une méthode similaire, qui retourne le reste à la place:

/**
 * Divides this number by a small number, returning the remainder.
 * @param divisor an integer with {@code 0 < divisor < BASE}.
 * @return the remainder from the division {@code this / divisor}.
 * @throws IllegalArgumentException if the divisor is <= 0 or >= BASE.
 */
public int modulo(int divisor) {
    if(divisor <= 0 || BASE <= divisor) {
        throw new IllegalArgumentException("divisor " + divisor +
                                           " out of range!");
    }
    int[] result = new int[digits.length];
    return divideDigits(result, 0,
                        digits, 0,
                        divisor);
}

Ces méthodes peuvent être invoquées comme ceci:

    DecimalBigInt d3_by_100 = d3.divideBy(100);
    System.out.println("d3/100 = " + d3_by_100);
    System.out.println("d3%100 = " + d3.modulo(100));

Conversion en Radix arbitraire

Maintenant, nous avons les bases pour convertir arbitraire radix. Bien sûr, pas vraiment arbitraire, seuls les rayons plus petits que BASE sont autorisés, mais cela ne devrait pas être un trop gros problème.

comme déjà répondu dans une autre réponse sur la conversion des nombres, nous devons faire" division, reste, Multiplier, Ajouter. La partie" Multiplier-Ajouter " n'est en fait que la compilation des différents chiffres, de sorte que nous pouvons la remplacer par un simple tableau-accès.

comme nous avons toujours besoin à la fois du quotient et du reste, nous n'utiliserons pas les méthodes publiques modulo et divideBy , mais appellerons plutôt à plusieurs reprises la méthode divideDigits .

/**
 * converts this number to an arbitrary radix.
 * @param radix the target radix, {@code 1 < radix < BASE}.
 * @return the digits of this number in the base-radix system,
 *     in big-endian order.
 */
public int[] convertTo(int radix)
{
    if(radix <= 1 || BASE <= radix) {
        throw new IllegalArgumentException("radix " + radix +
                                           " out of range!");
    }

D'abord, un cas spécial de manipulation pour 0.

    // zero has no digits.
    if(digits.length == 0)
        return new int[0];

ensuite, nous créons un tableau pour les chiffres de résultat (assez long), et quelques autres variables.

    // raw estimation how many output digits we will need.
    // This is just enough in cases like BASE-1, and up to
    // 30 digits (for base 2) too much for something like (1,0,0).
    int len = (int) (Math.log(BASE) / Math.log(radix) * digits.length)+1;
    int[] rDigits = new int[len];
    int rIndex = len-1;
    int[] current = digits;
    int quotLen = digits.length;

quotLen est le nombre de chiffres (à l'exclusion des zéros) dans le dernier quotient. Si c'est 0, on a fini.

    while(quotLen > 0)  {

un nouveau tableau pour le quotient suivant.

        int[] quot = new int[quotLen];

Le quotient et le reste de l'opération. Le quotient est maintenant en quot , le reste dans rem .

        int rem = divideDigits(quot, 0,
                               current, current.length - quotLen,
                               radix);

nous mettons le reste dans le tableau de sortie (le remplir à partir du dernier chiffre).

        rDigits[rIndex] = rem;
        rIndex --;

puis on échange les tableaux pour le tour suivant.

        current = quot;

S'il y a des zéros de tête dans le quotient (il y en aura au plus un, car radix est plus petit que BASE), nous réduisons la taille du quotient par un. La matrice suivante sera plus petite.

        if(current[0] == 0) {
            // omit leading zeros in next round.
            quotLen--;
        }
    }

après la boucle il peut y avoir des zéros de tête dans le tableau de rDigits, et nous les Coupons.

    // cut of leading zeros in rDigits:
    while(rIndex < 0 || rDigits[rIndex] == 0) {
        rIndex++;
    }
    return Arrays.copyOfRange(rDigits, rIndex, rDigits.length);
}

C'est ça. Il ressemble un peu compliqué, bien. Voici un exemple d'utilisation:

    System.out.println("d4 in base 11: " +
                       Arrays.toString(d4.convertTo(11)));
    System.out.println("d5 in base 7: " +
                       Arrays.toString(d5.convertTo(7)));

ces caractères [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0] et [1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0] , juste les mêmes nombres que nous avons parsés avant (à partir d'une chaîne, cependant).

sur cette base nous pouvons aussi formater comme une chaîne de caractères:

/**
 * Converts the number to a String in a given radix.
 * This uses {@link Character.digit} to convert each digit
 * to one character.
 * @param radix the radix to use, between {@link Character.MIN_RADIX}
 *   and {@link Character.MAX_RADIX}.
 * @return a String containing the digits of this number in the
 *   specified radix, using '0' .. '9' and 'a' .. 'z' (as much as needed).
 */
public String toString(int radix) {
    if(radix < Character.MIN_RADIX || Character.MAX_RADIX < radix) {
        throw new IllegalArgumentException("radix out of range: " + radix);
    }
    if(digits.length == 0)
        return "0";
    int[] rdigits = convertTo(radix);
    StringBuilder b = new StringBuilder(rdigits.length);
    for(int dig : rdigits) {
        b.append(Character.forDigit(dig, radix));
    }
    return b.toString();
}