## BIG **Kind**: global class **this**: {BIG} * [BIG](#BIG) * [new BIG()](#new_BIG_new) * _instance_ * [.zero()](#BIG+zero) ⇒ * [.one()](#BIG+one) ⇒ * [.iszilch()](#BIG+iszilch) ⇒ * [.isunity()](#BIG+isunity) ⇒ * [.cswap()](#BIG+cswap) * [.cmove()](#BIG+cmove) * [.copy()](#BIG+copy) ⇒ * [.hcopy()](#BIG+hcopy) ⇒ * [.rcopy()](#BIG+rcopy) ⇒ * [.norm()](#BIG+norm) ⇒ * [.fshr()](#BIG+fshr) ⇒ * [.shr()](#BIG+shr) ⇒ * [.fshl()](#BIG+fshl) ⇒ * [.shl()](#BIG+shl) ⇒ * [.nbits()](#BIG+nbits) ⇒ * [.toString()](#BIG+toString) ⇒ * [.add()](#BIG+add) ⇒ * [.or()](#BIG+or) ⇒ * [.plus()](#BIG+plus) ⇒ * [.inc()](#BIG+inc) ⇒ * [.sub()](#BIG+sub) ⇒ * [.rsub()](#BIG+rsub) ⇒ * [.dec()](#BIG+dec) ⇒ * [.minus()](#BIG+minus) ⇒ * [.imul()](#BIG+imul) ⇒ * [.tobytearray()](#BIG+tobytearray) * [.toBytes()](#BIG+toBytes) * [.muladd()](#BIG+muladd) * [.pmul()](#BIG+pmul) ⇒ * [.pxmul()](#BIG+pxmul) ⇒ * [.div3()](#BIG+div3) ⇒ * [.mod2m()](#BIG+mod2m) ⇒ * [.invmod2m()](#BIG+invmod2m) ⇒ * [.mod()](#BIG+mod) ⇒ * [.div()](#BIG+div) ⇒ * [.parity()](#BIG+parity) ⇒ * [.bit()](#BIG+bit) ⇒ * [.lastbits()](#BIG+lastbits) ⇒ * [.jacobi()](#BIG+jacobi) ⇒ * [.invmodp()](#BIG+invmodp) ⇒ * [.powmod()](#BIG+powmod) ⇒ * _static_ * [.frombytearray()](#BIG.frombytearray) ⇒ * [.smul()](#BIG.smul) ⇒ * [.comp()](#BIG.comp) ⇒ * [.random()](#BIG.random) ⇒ * [.randomnum()](#BIG.randomnum) ⇒ * [.mul()](#BIG.mul) ⇒ * [.sqr()](#BIG.sqr) ⇒ * [.modmul()](#BIG.modmul) ⇒ * [.modsqr()](#BIG.modsqr) ⇒ * [.modneg()](#BIG.modneg) ⇒ * [.invmod256()](#BIG.invmod256) ⇒ ### new BIG() General purpose Constructor ### biG.zero() ⇒ set to zero **Kind**: instance method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} ### biG.one() ⇒ set to one **Kind**: instance method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} ### biG.iszilch() ⇒ test for zero **Kind**: instance method of [BIG](#BIG) **Returns**: True if zero **this**: {BIG} ### biG.isunity() ⇒ test for unity **Kind**: instance method of [BIG](#BIG) **Returns**: True if one **this**: {BIG} ### biG.cswap() Conditional swap of two BIGs depending on d using XOR - no branches **Kind**: instance method of [BIG](#BIG) **this**: {BIG} **Parameter**: b BIG number **Parameter**: d BIG number ### biG.cmove() Conditional move of BIG depending on d using XOR - no branches **Kind**: instance method of [BIG](#BIG) **this**: {BIG} **Parameter**: b BIG number **Parameter**: d BIG number ### biG.copy() ⇒ Copy from another BIG **Kind**: instance method of [BIG](#BIG) **Returns**: The BIG object **this**: {BIG} **Parameter**: y BIG number ### biG.hcopy() ⇒ copy from bottom half of ctx.DBIG **Kind**: instance method of [BIG](#BIG) **Returns**: The new BIG object **this**: {BIG} **Parameter**: y BIG number ### biG.rcopy() ⇒ copy from ROM **Kind**: instance method of [BIG](#BIG) **Returns**: The BIG object **this**: {BIG} **Parameter**: y BIG number in ROM ### biG.norm() ⇒ normalise BIG - force all digits < 2^BASEBITS **Kind**: instance method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} ### biG.fshr() ⇒ Quick Fast shifts a BIG right by a small number of bits - input must be normalised, output will be normalised **Kind**: instance method of [BIG](#BIG) **Returns**: r The shifted out part **this**: {BIG} **Parameter**: k Number of bits to shift ### biG.shr() ⇒ General shift right by k bits **Kind**: instance method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} **Parameter**: k Number of bits to shift ### biG.fshl() ⇒ Fast shifts a BIG left by a small number of bits - input must be normalised, output will be normalised **Kind**: instance method of [BIG](#BIG) **Returns**: r The shifted out part **this**: {BIG} **Parameter**: k Number of bits to shift ### biG.shl() ⇒ General shift left by k bits **Kind**: instance method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} **Parameter**: k Number of bits to shift ### biG.nbits() ⇒ length in bits **Kind**: instance method of [BIG](#BIG) **Returns**: The number of bigs in BIG object **this**: {BIG} ### biG.toString() ⇒ Convert to string **Kind**: instance method of [BIG](#BIG) **Returns**: string representation of a BIG number **this**: {BIG} ### biG.add() ⇒ Sum two BIG mumbers **Kind**: instance method of [BIG](#BIG) **Returns**: this+=y **this**: {BIG} **Parameter**: y BIG object ### biG.or() ⇒ OR two BIG mumbers **Kind**: instance method of [BIG](#BIG) **Returns**: this|=y **this**: {BIG} **Parameter**: y BIG object ### biG.plus() ⇒ Sum two BIG mumbers **Kind**: instance method of [BIG](#BIG) **Returns**: this+x **this**: {BIG} **Parameter**: x BIG object ### biG.inc() ⇒ Sum BIG and integer **Kind**: instance method of [BIG](#BIG) **Returns**: this+=i **this**: {BIG} **Parameter**: i Integer to add ### biG.sub() ⇒ Subtract BIG from one another **Kind**: instance method of [BIG](#BIG) **Returns**: this-=y **this**: {BIG} **Parameter**: y BIG object ### biG.rsub() ⇒ Reverse subtract BIG from one another **Kind**: instance method of [BIG](#BIG) **Returns**: this=x-this **this**: {BIG} **Parameter**: x BIG object ### biG.dec() ⇒ Subtract integer from BIG **Kind**: instance method of [BIG](#BIG) **Returns**: this-=i **this**: {BIG} **Parameter**: i Integer to subtract ### biG.minus() ⇒ Subtract BIG **Kind**: instance method of [BIG](#BIG) **Returns**: New BIG object **this**: {BIG} **Parameter**: x BIG object ### biG.imul() ⇒ Multiply by small integer **Kind**: instance method of [BIG](#BIG) **Returns**: this*c **this**: {BIG} **Parameter**: c small integer ### biG.tobytearray() convert this BIG to byte array **Kind**: instance method of [BIG](#BIG) **this**: {BIG} ### biG.toBytes() convert this to byte array **Kind**: instance method of [BIG](#BIG) **this**: {BIG} ### biG.muladd() this[i]+=x*y+c, and return high part **Kind**: instance method of [BIG](#BIG) **this**: {BIG} ### biG.pmul() ⇒ multiply by larger int **Kind**: instance method of [BIG](#BIG) **Returns**: carry value **this**: {BIG} **Parameter**: c large integer ### biG.pxmul() ⇒ multiply by still larger int - results requires a DBIG **Kind**: instance method of [BIG](#BIG) **Returns**: DBIG object **this**: {BIG} **Parameter**: c large integer ### biG.div3() ⇒ divide by 3 **Kind**: instance method of [BIG](#BIG) **Returns**: carry value **this**: {BIG} ### biG.mod2m() ⇒ set x = x mod 2^m **Kind**: instance method of [BIG](#BIG) **Returns**: BIG object **this**: {BIG} **Parameter**: m Exponent ### biG.invmod2m() ⇒ a=1/a mod 2^256. This is very fast! **Kind**: instance method of [BIG](#BIG) **Returns**: BIG object **this**: {BIG} ### biG.mod() ⇒ reduce this mod m **Kind**: instance method of [BIG](#BIG) **Returns**: BIG object **this**: {BIG} ### biG.div() ⇒ this/=m1 **Kind**: instance method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} **Paramter**: m1 divisor ### biG.parity() ⇒ return parity of this **Kind**: instance method of [BIG](#BIG) **Returns**: BIG object **this**: {BIG} ### biG.bit() ⇒ return n-th bit of this **Kind**: instance method of [BIG](#BIG) **Returns**: bit value **this**: {BIG} **Parameter**: nth bit to return ### biG.lastbits() ⇒ return last n bits of this **Kind**: instance method of [BIG](#BIG) **Returns**: bit values **this**: {BIG} **Parameter**: n bits to return ### biG.jacobi() ⇒ Jacobi Symbol (this/p) **Kind**: instance method of [BIG](#BIG) **Returns**: 0, 1 or -1 **this**: {BIG} **Parameter**: p BIG number ### biG.invmodp() ⇒ this=1/this mod p. Binary method **Kind**: instance method of [BIG](#BIG) **Returns**: BIG object **this**: {BIG} **Parameter**: p The BIG Modulus ### biG.powmod() ⇒ Exponentation modulo m **Kind**: instance method of [BIG](#BIG) **Returns**: this^e mod m **this**: {BIG} **Parameter**: e1 BIG number **Parameter**: m The BIG Modulus ### BIG.frombytearray() ⇒ convert from byte array to BIG **Kind**: static method of [BIG](#BIG) **Returns**: BIG object **this**: {BIG} **Parameter**: b Bytearray ### BIG.smul() ⇒ return a*b where product fits a BIG **Kind**: static method of [BIG](#BIG) **Returns**: a*b **this**: {BIG} **Parameter**: a BIG number **Parameter**: b BIG number ### BIG.comp() ⇒ Compare a and b **Kind**: static method of [BIG](#BIG) **Returns**: 0 if a==b, -1 if ab **this**: {BIG} **Parameter**: a BIG number (normalised) **Parameter**: b BIG number (normalised ### BIG.random() ⇒ Get 8*MODBYTES size random number **Kind**: static method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} **Parameter**: rng Cryptographically Secure Random Number Generator ### BIG.randomnum() ⇒ Create random BIG in portable way, one bit at a time **Kind**: static method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} **Parameter**: rng Cryptographically Secure Random Number Generator **Parameter**: q The BIG Modulus ### BIG.mul() ⇒ Multiple two BIG numbers **Kind**: static method of [BIG](#BIG) **Returns**: a*b as a DBIG number **this**: {BIG} **Parameter**: a BIG number **Parameter**: b BIG number ### BIG.sqr() ⇒ Square two BIG numbers **Kind**: static method of [BIG](#BIG) **Returns**: a*2 as a DBIG number **this**: {BIG} **Parameter**: a BIG number ### BIG.modmul() ⇒ Multiple two BIG numbers modulo m **Kind**: static method of [BIG](#BIG) **Returns**: a1*b1 mod m as a BIG number **this**: {BIG} **Parameter**: a1 BIG number **Parameter**: b1 BIG number **Parameter**: m The BIG Modulus ### BIG.modsqr() ⇒ Square a BIG number modulo m **Kind**: static method of [BIG](#BIG) **Returns**: a*2 mod m as a BIG number **this**: {BIG} **Parameter**: a1 BIG number **Parameter**: m The BIG Modulus ### BIG.modneg() ⇒ Inversion **Kind**: static method of [BIG](#BIG) **Returns**: -a1 mod m **this**: {BIG} **Parameter**: a1 BIG number **Parameter**: m The BIG Modulus ### BIG.invmod256() ⇒ Arazi and Qi inversion mod 256 **Kind**: static method of [BIG](#BIG) **Returns**: BIG number **this**: {BIG} **Parameter**: a BIG number