| #ifndef FP48_YYY_H |
| #define FP48_YYY_H |
| |
| #include "fp16_YYY.h" |
| |
| using namespace amcl; |
| |
| namespace YYY { |
| /** |
| @brief FP12 Structure - towered over three FP16 |
| */ |
| |
| #define FP48_ZERO 0 |
| #define FP48_ONE 1 |
| #define FP48_SPARSER 2 |
| #define FP48_SPARSE 3 |
| #define FP48_DENSE 4 |
| |
| |
| typedef struct |
| { |
| FP16 a; /**< first part of FP12 */ |
| FP16 b; /**< second part of FP12 */ |
| FP16 c; /**< third part of FP12 */ |
| int type; |
| } FP48; |
| |
| extern const XXX::BIG Fra; /**< real part of BN curve Frobenius Constant */ |
| extern const XXX::BIG Frb; /**< imaginary part of BN curve Frobenius Constant */ |
| |
| /* FP48 prototypes */ |
| /** @brief Tests for FP48 equal to zero |
| * |
| @param x FP48 number to be tested |
| @return 1 if zero, else returns 0 |
| */ |
| extern int FP48_iszilch(FP48 *x); |
| /** @brief Tests for FP48 equal to unity |
| * |
| @param x FP48 number to be tested |
| @return 1 if unity, else returns 0 |
| */ |
| extern int FP48_isunity(FP48 *x); |
| /** @brief Copy FP48 to another FP48 |
| * |
| @param x FP48 instance, on exit = y |
| @param y FP48 instance to be copied |
| */ |
| extern void FP48_copy(FP48 *x,FP48 *y); |
| /** @brief Set FP48 to unity |
| * |
| @param x FP48 instance to be set to one |
| */ |
| extern void FP48_one(FP48 *x); |
| |
| /** @brief Set FP48 to zero |
| * |
| @param x FP48 instance to be set to zero |
| */ |
| extern void FP48_zero(FP48 *x); |
| |
| /** @brief Tests for equality of two FP48s |
| * |
| @param x FP48 instance to be compared |
| @param y FP48 instance to be compared |
| @return 1 if x=y, else returns 0 |
| */ |
| extern int FP48_equals(FP48 *x,FP48 *y); |
| /** @brief Conjugation of FP48 |
| * |
| If y=(a,b,c) (where a,b,c are its three FP16 components) on exit x=(conj(a),-conj(b),conj(c)) |
| @param x FP48 instance, on exit = conj(y) |
| @param y FP48 instance |
| */ |
| extern void FP48_conj(FP48 *x,FP48 *y); |
| /** @brief Initialise FP48 from single FP16 |
| * |
| Sets first FP16 component of an FP48, other components set to zero |
| @param x FP48 instance to be initialised |
| @param a FP16 to form first part of FP48 |
| */ |
| extern void FP48_from_FP16(FP48 *x,FP16 *a); |
| /** @brief Initialise FP48 from three FP16s |
| * |
| @param x FP48 instance to be initialised |
| @param a FP16 to form first part of FP48 |
| @param b FP16 to form second part of FP48 |
| @param c FP16 to form third part of FP48 |
| */ |
| extern void FP48_from_FP16s(FP48 *x,FP16 *a,FP16* b,FP16 *c); |
| /** @brief Fast Squaring of an FP48 in "unitary" form |
| * |
| @param x FP48 instance, on exit = y^2 |
| @param y FP16 instance, must be unitary |
| */ |
| extern void FP48_usqr(FP48 *x,FP48 *y); |
| /** @brief Squaring an FP48 |
| * |
| @param x FP48 instance, on exit = y^2 |
| @param y FP48 instance |
| */ |
| extern void FP48_sqr(FP48 *x,FP48 *y); |
| /** @brief Fast multiplication of two sparse FP24s that arises from ATE pairing line functions |
| * |
| @param x FP48 instance, on exit = x*y |
| @param y FP48 instance, of special form |
| */ |
| extern void FP48_smul(FP48 *x,FP48 *y); |
| |
| /** @brief Fast multiplication of what may be sparse multiplicands |
| * |
| @param x FP48 instance, on exit = x*y |
| @param y FP48 instance, of special form |
| */ |
| extern void FP48_ssmul(FP48 *x,FP48 *y); |
| /** @brief Full unconditional Multiplication of two FP24s |
| * |
| @param x FP48 instance, on exit = x*y |
| @param y FP48 instance, the multiplier |
| */ |
| extern void FP48_mul(FP48 *x,FP48 *y); |
| /** @brief Inverting an FP48 |
| * |
| @param x FP48 instance, on exit = 1/y |
| @param y FP48 instance |
| */ |
| extern void FP48_inv(FP48 *x,FP48 *y); |
| /** @brief Raises an FP48 to the power of a BIG |
| * |
| @param r FP48 instance, on exit = y^b |
| @param x FP48 instance |
| @param b BIG number |
| */ |
| extern void FP48_pow(FP48 *r,FP48 *x,XXX::BIG b); |
| |
| //extern void FP48_ppow(FP48 *r,FP48 *x,XXX::BIG b); |
| |
| /** @brief Raises an FP48 instance x to a small integer power, side-channel resistant |
| * |
| @param x FP48 instance, on exit = x^i |
| @param i small integer exponent |
| @param b maximum number of bits in exponent |
| */ |
| extern void FP48_pinpow(FP48 *x,int i,int b); |
| |
| /** @brief Raises an FP48 instance x to a BIG power, compressed to FP16 |
| * |
| @param c FP16 instance, on exit = x^(e mod r) as FP16 |
| @param x FP48 input |
| @param e BIG exponent |
| @param r BIG group order |
| */ |
| extern void FP48_compow(FP16 *c,FP48 *x,XXX::BIG e,XXX::BIG r); |
| |
| /** @brief Calculate Pi x[i]^b[i] for i=0 to 15, side-channel resistant |
| * |
| @param r FP48 instance, on exit = Pi x[i]^b[i] for i=0 to 15 |
| @param x FP48 array with 16 FP48s |
| @param b BIG array of 16 exponents |
| */ |
| extern void FP48_pow16(FP48 *r,FP48 *x,XXX::BIG *b); |
| |
| |
| /** @brief Raises an FP48 to the power of the internal modulus p, using the Frobenius |
| * |
| @param x FP48 instance, on exit = x^p^n |
| @param f FP2 precalculated Frobenius constant |
| @param n power of p |
| */ |
| extern void FP48_frob(FP48 *x,FP2 *f,int n); |
| |
| /** @brief Reduces all components of possibly unreduced FP48 mod Modulus |
| * |
| @param x FP48 instance, on exit reduced mod Modulus |
| */ |
| extern void FP48_reduce(FP48 *x); |
| /** @brief Normalises the components of an FP48 |
| * |
| @param x FP48 instance to be normalised |
| */ |
| extern void FP48_norm(FP48 *x); |
| /** @brief Formats and outputs an FP48 to the console |
| * |
| @param x FP48 instance to be printed |
| */ |
| extern void FP48_output(FP48 *x); |
| /** @brief Formats and outputs an FP48 instance to an octet string |
| * |
| Serializes the components of an FP48 to big-endian base 256 form. |
| @param S output octet string |
| @param x FP48 instance to be converted to an octet string |
| */ |
| extern void FP48_toOctet(octet *S,FP48 *x); |
| /** @brief Creates an FP48 instance from an octet string |
| * |
| De-serializes the components of an FP48 to create an FP48 from big-endian base 256 components. |
| @param x FP48 instance to be created from an octet string |
| @param S input octet string |
| |
| */ |
| extern void FP48_fromOctet(FP48 *x,octet *S); |
| /** @brief Calculate the trace of an FP48 |
| * |
| @param t FP16 trace of x, on exit = tr(x) |
| @param x FP48 instance |
| |
| */ |
| extern void FP48_trace(FP16 *t,FP48 *x); |
| |
| /** @brief Conditional copy of FP48 number |
| * |
| Conditionally copies second parameter to the first (without branching) |
| @param x FP48 instance, set to y if s!=0 |
| @param y another FP48 instance |
| @param s copy only takes place if not equal to 0 |
| */ |
| extern void FP48_cmove(FP48 *x,FP48 *y,int s); |
| } |
| #endif |