Comment gérer arbitrairement grands entiers

Si vous avez besoin de plus de 32-bits que vous pourriez envisager d'utiliser des entiers 64 bits (long long), ou de l'utilisation ou de l'écriture d'une précision arbitraire bibliothèque de mathématiques, par exemple,GNU MP.

OriginalL'auteur Barry Kelly

Si vous êtes dans une langue (à des fins d'apprentissage, je suppose), je pense que je serais probablement écrire un peu BCD bibliothèque. Stocker tout votre BCD chiffres à l'intérieur des tableaux d'octets.

En fait, aujourd'hui, de gigantesques capacités de stockage, vous pouvez simplement utiliser un tableau d'octets, où chaque octet tient juste à un chiffre (0-9). Ensuite, vous écrivez votre propre routine d'ajouter, de soustraire multiplier et de diviser vos tableaux d'octets.

(Fracture est la plus difficile, mais je parie que vous pouvez trouver un certain code là, quelque part.)

Je peux vous donner quelques Java-comme psuedocode mais ne peuvent pas vraiment faire C++ à partir de zéro à ce point:

class BigAssNumber {
    private byte[] value;

    //This constructor can handle numbers where overflows have occurred.
    public BigAssNumber(byte[] value) {
        this.value=normalize(value);
    }

    //Adds two numbers and returns the sum.  Originals not changed.
    public BigAssNumber add(BigAssNumber other) {
        //This needs to be a byte by byte copy in newly allocated space, not pointer copy!
        byte[] dest = value.length > other.length ? value : other.value;         

        //Just add each pair of numbers, like in a pencil and paper addition problem.
        for(int i=0; i<min(value.length, other.value.length); i++)
            dest[i]=value[i]+other.value[i];

        //constructor will fix overflows.
        return new BigAssNumber(dest);
    }

    //Fix things that might have overflowed  0,17,22 will turn into 1,9,2        
    private byte[] normalize(byte [] value) {
        if (most significant digit of value is not zero)
            extend the byte array by a few zero bytes in the front (MSB) position.

        //Simple cheap adjust.  Could lose inner loop easily if It mattered.
        for(int i=0;i<value.length;i++)
            while(value[i] > 9) {
                value[i] -=10;
                value[i+1] +=1;
            }
        }
    }
}

J'utilise le fait que nous avons beaucoup de chambre supplémentaire dans un octet pour vous aider à gérer plus les débordements de manière générique. Peut travailler pour la soustraction trop, et de l'aide à certains multiplie les.

OriginalL'auteur Bill K

D'autres affiches ont donné des liens vers des bibliothèques qui va le faire pour vous, mais il semble que vous essayez de construire ce dans votre langue. Ma première pensée est: êtes-vous sûr que vous besoin de faire cela? La plupart des langues serait d'utiliser un add-on de la bibliothèque comme d'autres l'ont suggéré.

En supposant que vous êtes l'écriture d'un compilateur et vous avez besoin de cette fonctionnalité, vous pouvez mettre en œuvre entier des fonctions arithmétiques arbitrairement pour les grandes valeurs de l'assemblée.

Par exemple, un simple (mais non optimale) la mise en œuvre serait de représenter les nombres en Binaire Codé Décimal. L'arithmétique des fonctions pourrait utiliser les mêmes algorithmes que vous utiliseriez si vous faites le calcul avec le crayon et le papier.

Aussi, pensez à utiliser spécialisé pour un type de données pour ces grands nombres entiers. De cette façon "normale" des entiers pouvez utiliser le standard de 32 bits de l'arithmétique.

OriginalL'auteur Clayton

Si je devais mettre en œuvre ma propre langue et souhaitez soutenir longueur arbitraire de chiffres, je vais utiliser une langue cible avec le carry/emprunter concept. Mais depuis il n'y a pas de HLL qui implémente cette sans de graves implications sur les performances (comme des exceptions), je vais certainement aller à la mettre en œuvre dans l'assemblée. Il va probablement prendre une seule instruction (comme JC en x86) pour vérifier débordement et de le manipuler (comme dans l'ADC x86), qui est un compromis acceptable pour un langage de mise en œuvre de précision arbitraire. Ensuite, je vais utiliser quelques fonctions écrites en assemblée au lieu de régulièrement des opérateurs, si vous pouvez utiliser la surcharge pour une plus élégant de sortie, même mieux. Mais je n'attends pas générés C++ pour être facile à entretenir (ou destiné à être maintenu) comme langue cible.

Ou, il suffit d'utiliser une bibliothèque qui a plus de cloches et de sifflets que vous avez besoin et l'utiliser pour toutes vos numéros.

Comme une approche hybride, détecter le dépassement de montage et d'appeler une fonction de la bibliothèque si dépassement au lieu de rouler votre propre mini-bibliothèque.

OriginalL'auteur artificialidiot