Installer

npm install --save bn.js

Usage

 const BN = require ( 'bn.js' ) ;

var a = new BN ( 'dead' , 16 ) ;
var b = new BN ( '101010' , 2 ) ;

var res = a . add ( b ) ;
console . log ( res . toString ( 10 ) ) ;  // 57047

Remarque : les décimales ne sont pas supportées dans cette bibliothèque.

Commanditaires

Mon travail Open Source est soutenu par Scout APM et d'autres sponsors.

Notation

Préfixes

Il existe plusieurs préfixes aux instructions qui affectent leur fonctionnement. En voici la liste dans l'ordre d'apparition dans le nom de la fonction :

i - effectue une opération sur place, en stockant le résultat dans l'objet hôte (sur lequel la méthode a été invoquée). Pourrait être utilisé pour éviter les coûts d’attribution de numéros
u - non signé, ignore le signe des opérandes lors de l'exécution de l'opération ou renvoie toujours une valeur positive. Le deuxième cas s'applique aux opérations de réduction comme mod() . Dans de tels cas, si le résultat est négatif, un module sera ajouté au résultat pour le rendre positif.

Postfixes

n - l'argument de la fonction doit être un simple nombre JavaScript. Les décimales ne sont pas prises en charge. Le nombre transmis doit être inférieur à 0x4000000 (67_108_864). Sinon, une erreur est générée.
rn - l'argument et la valeur de retour de la fonction sont de simples nombres JavaScript. Les décimales ne sont pas prises en charge.

Exemples

a.iadd(b) - effectue une addition sur a et b , en stockant le résultat dans a
a.umod(b) - réduit a modulo b , renvoyant une valeur positive
a.iushln(13) - décale les bits d' a vers la gauche de 13

Instructions

Les préfixes/postfixes sont mis entre parenthèses à la fin de la ligne. endian - peut être soit le (petit-boutiste), soit be (gros-boutiste).

Utilitaires

a.clone() - numéro de clone
a.toString(base, length) - convertir en chaîne de base et compléter avec des zéros
a.toNumber() - convertir en numéro Javascript (limité à 53 bits)
a.toJSON() - convertir en chaîne hexadécimale compatible JSON (alias de toString(16) )
a.toArray(endian, length) - converti en byte Array , et éventuellement zéro en longueur, en lançant s'il dépasse déjà
a.toArrayLike(type, endian, length) - converti en une instance de type , qui doit se comporter comme un Array
a.toBuffer(endian, length) - convertir en tampon Node.js (si disponible). length en octets. Pour des raisons de compatibilité avec Browserify et des outils similaires, utilisez plutôt ceci : a.toArrayLike(Buffer, endian, length)
a.bitLength() - obtient le nombre de bits occupés
a.zeroBits() - renvoie le nombre de bits zéro conséquents moins significatifs (exemple : 1010000 a 4 bits zéro)
a.byteLength() - renvoie le nombre d'octets occupés
a.isNeg() - vrai si le nombre est négatif
a.isEven() - pas de commentaires
a.isOdd() - pas de commentaires
a.isZero() - pas de commentaires
a.cmp(b) - compare les nombres et renvoie -1 (a < b), 0 (a == b) ou 1 (a > b) selon le résultat de la comparaison ( ucmp , cmpn )
a.lt(b) - a inférieur à b ( n )
a.lte(b) - a inférieur ou égal b ( n )
a.gt(b) - a supérieur à b ( n )
a.gte(b) - a supérieur ou égal b ( n )
a.eq(b) - a est égal b ( n )
a.toTwos(width) - convertit en représentation en complément à deux, où width est la largeur en bits
a.fromTwos(width) - conversion à partir d'une représentation en complément à deux, où width est la largeur en bits
BN.isBN(object) - renvoie true si l' object fourni est une instance BN.js
BN.max(a, b) - renvoie a si a plus grand que b
BN.min(a, b) - renvoie a si a est inférieur à b

Arithmétique

a.neg() - signe négatif ( i )
a.abs() - valeur absolue ( i )
a.add(b) - addition ( i , n , in )
a.sub(b) - soustraction ( i , n , in )
a.mul(b) - multiplier ( i , n , in )
a.sqr() - carré ( i )
a.pow(b) - élever a à la puissance b
a.div(b) - diviser ( divn , idivn )
a.mod(b) - reduct ( u , n ) (mais pas umodn )
a.divmod(b) - quotient et module obtenus en divisant
a.divRound(b) - division arrondie

Opérations sur les bits

a.or(b) - ou ( i , u , iu )
a.and(b) - and ( i , u , iu , andln ) (REMARQUE : andln sera remplacé par andn à l'avenir)
a.xor(b) - xor ( i , u , iu )
a.setn(b, value) - définit le bit spécifié sur value
a.shln(b) - décalage vers la gauche ( i , u , iu )
a.shrn(b) - décalage vers la droite ( i , u , iu )
a.testn(b) - teste si le bit spécifié est défini
a.maskn(b) - effacer les bits avec des index supérieurs ou égaux à b ( i )
a.bincn(b) - ajoutez 1 << b au nombre
a.notn(w) - not (pour la largeur spécifiée par w ) ( i )

Réduction

a.gcd(b) - PGCD
a.egcd(b) - Résultats GCD étendus ( { a: ..., b: ..., gcd: ... } )
a.invm(b) - inverse a modulo b

Réduction rapide

Lorsque vous effectuez de nombreuses réductions en utilisant le même modulo, il peut être avantageux d'utiliser quelques astuces : comme la multiplication de Montgomery ou l'utilisation d'un algorithme spécial pour Mersenne Prime.

Contexte de réduction

Pour activer cette astuce, il faut créer un contexte de réduction :

 var red = BN . red ( num ) ;

où num est juste une instance BN.

Ou:

 var red = BN . red ( primeName ) ;

Où primeName est l’un de ces Mersenne Primes :

'k256'
'p224'
'p192'
'p25519'

Ou:

 var red = BN . mont ( num ) ;

Pour réduire les chiffres avec l'astuce de Montgomery. .mont() est généralement plus rapide que .red(num) , mais plus lent que BN.red(primeName) .