{FF}
* [FF](#FF)
* [new FF()](#new_FF_new)
* _instance_
* [.set(m)](#FF+set)
* [.copy(b)](#FF+copy)
* [.rcopy(b)](#FF+rcopy)
* [.dsucopy()](#FF+dsucopy)
* [.dscopy()](#FF+dscopy)
* [.sducopy()](#FF+sducopy)
* [.iszilch()](#FF+iszilch)
* [.shrw()](#FF+shrw)
* [.shlw()](#FF+shlw)
* [.parity()](#FF+parity)
* [.radd()](#FF+radd)
* [.rinc()](#FF+rinc)
* [.rsub()](#FF+rsub)
* [.rdec()](#FF+rdec)
* [.add()](#FF+add)
* [.sub()](#FF+sub)
* [.revsub()](#FF+revsub)
* [.inc()](#FF+inc)
* [.rnorm()](#FF+rnorm)
* [.shl()](#FF+shl)
* [.shr()](#FF+shr)
* [.toString()](#FF+toString)
* [.toBytes()](#FF+toBytes)
* [.karmul()](#FF+karmul)
* [.lmul()](#FF+lmul)
* [.mod()](#FF+mod)
* [.reduce(N, ND)](#FF+reduce) ⇒
* [.dmod(b)](#FF+dmod) ⇒
* [.invmodp()](#FF+invmodp)
* [.nres()](#FF+nres)
* [.invmod2m()](#FF+invmod2m)
* [.randomnum()](#FF+randomnum)
* [.modmul()](#FF+modmul)
* [.modsqr()](#FF+modsqr)
* [.skpow(e, p)](#FF+skpow)
* [.skspow(e, p)](#FF+skspow)
* [.power(e, p)](#FF+power)
* [.pow(e, p)](#FF+pow)
* [.pow2(e, y, f, p)](#FF+pow2)
* [.cfactor(s)](#FF+cfactor) ⇒
* _static_
* [.comp(a, b)](#FF.comp) ⇒
* [.cswap()](#FF.cswap)
* [.mul()](#FF.mul)
* [.sqr()](#FF.sqr)
* [.prime(p, rmg)](#FF.prime)
### new FF()
Creates an instance of FF.
### fF.set(m)
set to integer
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| m | Integer value to be set to |
### fF.copy(b)
copy from FF b
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| b | FF element to copy from |
### fF.rcopy(b)
copy from FF b
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| b | FF element to copy from |
### fF.dsucopy()
x=y<{FF}
### fF.dscopy()
x=y
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.sducopy()
x=y>>n
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.iszilch()
test equals 0
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.shrw()
shift right by BIGBITS-bit words
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.shlw()
shift left by BIGBITS-bit words
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.parity()
extract last bit
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.radd()
recursive add
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.rinc()
recursive inc
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.rsub()
recursive sub
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.rdec()
recursive dec
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.add()
simple add
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.sub()
simple sub
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.revsub()
reverse sub
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.inc()
increment/decrement by a small integer
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.rnorm()
normalise - but hold any overflow in top part unless n<0
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.shl()
shift left by one bit
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.shr()
shift right by one bit
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.toString()
Convert to Hex String
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.toBytes()
Convert FFs to/from byte arrays
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.karmul()
z=x*y, t is workspace
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.lmul()
return low part of product this*y
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.mod()
Set b=b mod c
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.reduce(N, ND) ⇒
return this mod modulus
**Kind**: instance method of [FF](#FF)
**Returns**: this mod N
**this**: {FF}
| Param | Description |
| --- | --- |
| N | Mmodulus |
| ND | Montgomery Constant |
### fF.dmod(b) ⇒
Reduces a double-length FF with respect to a given modulus
**Kind**: instance method of [FF](#FF)
**Returns**: this mod N
**this**: {FF}
| Param | Description |
| --- | --- |
| b | Mmodulus |
### fF.invmodp()
Set return=1/this mod p. Binary method - aFF](#FF)
**this**: {FF}
### fF.nres()
nresidue mod m
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.invmod2m()
U=1/a mod 2^m - Arazi & Qi
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.randomnum()
generate random x
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.modmul()
this*=y mod p
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.modsqr()
this*=y mod p
**Kind**: instance method of [FF](#FF)
**this**: {FF}
### fF.skpow(e, p)
this=this^e mod p using side-channel resistant Montgomery Ladder, for large e
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| e | exponent |
| p | modulus |
### fF.skspow(e, p)
this=this^e mod p using side-channel resistant Montgomery Ladder, for short e
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| e | exponent |
| p | modulus |
### fF.power(e, p)
raise to an integer power - right-to-left method
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| e | exponent |
| p | modulus |
### fF.pow(e, p)
this=this^e mod p, faster but not side channel resistant
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| e | exponent |
| p | modulus |
### fF.pow2(e, y, f, p)
double exponentiation r=x^e.y^f mod p
**Kind**: instance method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| e | exponent |
| y | FF instance |
| f | exponent |
| p | modulus |
### fF.cfactor(s) ⇒
Test if an FF has factor in common with integer s
**Kind**: instance method of [FF](#FF)
**Returns**: true or false
**this**: {FF}
| Param | Description |
| --- | --- |
| s | integerexponent |
### FF.comp(a, b) ⇒
compare a and b - must be normalised, and of same length
**Kind**: static method of [FF](#FF)
**Returns**: zero of error codetrue or false
**this**: {FF}
| Param | Description |
| --- | --- |
| a | FF number |
| b | FF number |
### FF.cswap()
in-place swapping using xor - side channel resistant - lengths must be the same
**Kind**: static method of [FF](#FF)
**this**: {FF}
### FF.mul()
z=x*y. Assumes x and y are of same length.
**Kind**: static method of [FF](#FF)
**this**: {FF}
### FF.sqr()
z=x^2
**Kind**: static method of [FF](#FF)
**this**: {FF}
### FF.prime(p, rmg)
Miller-Rabin test for primality.
**Kind**: static method of [FF](#FF)
**this**: {FF}
| Param | Description |
| --- | --- |
| p | FF instance to be tested |
| rmg | an instance of a Cryptographically Secure Random Number Generator |