bn::ecop Namespace Reference

Functions
template<class FF >
void	copy (FF *out, const FF *in)
template<class Fp >
bool	isOnECJac3 (const Fp *P)
template<class Fp >
bool	isOnECHom2 (const Fp *P)
template<class Fp >
bool	isOnECHom3 (const Fp *P)
template<class Fp >
bool	isOnTwistECJac3 (const Fp2T< Fp > *P)
template<class Fp >
bool	isOnTwistECHom2 (const Fp2T< Fp > *P)
template<class Fp >
bool	isOnTwistECHom3 (const Fp2T< Fp > *P)
template<class FF >
void	NormalizeJac (FF *out, const FF *in)
template<class FF >
void	NormalizeHom (FF *out, const FF *in)
template<class FF >
void	ECDouble (FF *out, const FF *in)
template<class FF >
void	ECAdd (FF *out, const FF *a, const FF *b)
template<class FF , class INT >
void	ScalarMult (FF *out, const FF *in, const INT &m)
template<class Fp >
void	FrobEndOnTwist_1 (Fp2T< Fp > *Q, const Fp2T< Fp > *P)
template<class Fp >
void	FrobEndOnTwist_2 (Fp2T< Fp > *Q, const Fp2T< Fp > *P)
template<class Fp >
void	FrobEndOnTwist_8 (Fp2T< Fp > *Q, const Fp2T< Fp > *P)

Function Documentation

copy()

template<class FF >

void bn::ecop::copy ( FF * out, const FF * in )

inline

Definition at line 2350 of file bn.h.

{
    out[0] = in[0];
    out[1] = in[1];
    out[2] = in[2];
}

Here is the caller graph for this function:

ECAdd()

template<class FF >

void bn::ecop::ECAdd ( FF * out, const FF * a, const FF * b )

inline

Definition at line 2526 of file bn.h.

{
    if (a[2].isZero()) {
        copy(out, b);
        return;
    }
    if (b[2].isZero()) {
        copy(out, a);
        return;
    }
    FF Z1Z1, Z2Z2, U1, U2, t0, S1, t1, S2, H, t2, I, J, t3, r, V, t4, t5;
    FF t6, t7, t8, t9, t10, t11, t12, t13, t14;
    FF::square(Z1Z1, a[2]);
    FF::square(Z2Z2, b[2]);
    FF::mul(U1, a[0], Z2Z2);
    FF::mul(U2, b[0], Z1Z1);
    FF::mul(t0, b[2], Z2Z2);
    FF::mul(S1, a[1], t0);
    FF::mul(t1, a[2], Z1Z1);
    FF::mul(S2, b[1], t1);
    FF::sub(H, U2, U1);
    FF::sub(t3, S2, S1);
 
    if (H.isZero()) {
        if (t3.isZero()) {
            ECDouble(out, a);
        } else {
            out[2].clear();
        }
        return;
    }
 
    FF::add(t2, H, H);
    FF::square(I, t2);
    FF::mul(J, H, I);
    FF::add(r, t3, t3);
    FF::mul(V, U1, I);
    FF::square(t4, r);
    FF::add(t5, V, V);
    FF::sub(t6, t4, J);
    FF::sub(out[0], t6, t5);
    FF::sub(t7, V, out[0]);
    FF::mul(t8, S1, J);
    FF::add(t9, t8, t8);
    FF::mul(t10, r, t7);
    FF::sub(out[1], t10, t9);
    FF::add(t11, a[2], b[2]);
    FF::square(t12, t11);
    FF::sub(t13, t12, Z1Z1);
    FF::sub(t14, t13, Z2Z2);
    FF::mul(out[2], t14, H);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ECDouble()

template<class FF >

void bn::ecop::ECDouble ( FF * out, const FF * in )

inline

Definition at line 2497 of file bn.h.

{
    FF A, B, C, D, E, F, t0, t1, t2, t3, t4, t5, t6, t7, t8;
    FF::square(A, in[0]);
    FF::square(B, in[1]);
    FF::square(C, B);
    FF::add(t0, in[0], B);
    FF::square(t1, t0);
    FF::sub(t2, t1, A);
    FF::sub(t3, t2, C);
    FF::add(D, t3, t3);
    FF::add(E, A, A);
    FF::add(E, E, A);
    FF::square(F, E);
    FF::add(t4, D, D);
    FF::sub(out[0], F, t4);
    FF::sub(t5, D, out[0]);
    t6 = C; t6 += t6; t6 += t6; t6 += t6; // t6 = 8*C
    FF::mul(t7, E, t5);
    FF::mul(t8, in[1], in[2]);
    FF::sub(out[1], t7, t6);
    FF::add(out[2], t8, t8);
}

Here is the caller graph for this function:

FrobEndOnTwist_1()

template<class Fp >

void bn::ecop::FrobEndOnTwist_1	(	Fp2T< Fp > *	Q,
		const Fp2T< Fp > *	P )

Definition at line 2650 of file bn.h.

{
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    // applying Q[0] <- P[0]^q
#ifdef BN_SUPPORT_SNARK
    Q[0].a_ = P[0].a_;
    Fp::neg(Q[0].b_, P[0].b_);
 
    // Q[0] *= xi^((p-1)/3)
    Q[0] *= Param::gammar[1];
 
    // applying Q[1] <- P[1]^q
    Q[1].a_ = P[1].a_;
    Fp::neg(Q[1].b_, P[1].b_);
 
    // Q[1] *= xi^((p-1)/2)
    Q[1] *= Param::gammar[2];
#else
    Q[0].a_ = P[0].a_;
    Fp::neg(Q[0].b_, P[0].b_);
    Fp2::mul_Fp_1(Q[0], Param::W2p.b_);
    Q[1].a_ = P[1].a_;
    Fp::neg(Q[1].b_, P[1].b_);
    Q[1] *= Param::W3p;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

FrobEndOnTwist_2()

template<class Fp >

void bn::ecop::FrobEndOnTwist_2	(	Fp2T< Fp > *	Q,
		const Fp2T< Fp > *	P )

Definition at line 2679 of file bn.h.

{
#ifdef BN_SUPPORT_SNARK
    Fp2T<Fp> scratch[2];
    FrobEndOnTwist_1(scratch, P);
    FrobEndOnTwist_1(Q, scratch);
#else
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    Fp2::mul_Fp_0(Q[0], P[0], Param::Z);
    Fp2::neg(Q[1], P[1]);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

FrobEndOnTwist_8()

template<class Fp >

void bn::ecop::FrobEndOnTwist_8	(	Fp2T< Fp > *	Q,
		const Fp2T< Fp > *	P )

Definition at line 2694 of file bn.h.

{
#ifdef BN_SUPPORT_SNARK
    Fp2T<Fp> scratch2[2], scratch4[2], scratch6[2];
    FrobEndOnTwist_2(scratch2, P);
    FrobEndOnTwist_2(scratch4, scratch2);
    FrobEndOnTwist_2(scratch6, scratch4);
    FrobEndOnTwist_2(Q, scratch6);
#else
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    Fp2::mul_Fp_0(Q[0], P[0], Param::Z);
    Q[1] = P[1];
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

isOnECHom2()

template<class Fp >

bool bn::ecop::isOnECHom2 ( const Fp * P )

inline

Definition at line 2380 of file bn.h.

{
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    return P[1] * P[1] == P[0] * P[0] * P[0] + Param::b;
}

Here is the caller graph for this function:

isOnECHom3()

template<class Fp >

bool bn::ecop::isOnECHom3 ( const Fp * P )

inline

Definition at line 2392 of file bn.h.

{
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    if (P[2] == 0) return true;
 
    Fp ZZZ;
    Fp::square(ZZZ, P[2]);
    Fp::mul(ZZZ, ZZZ, P[2]);
    ZZZ *= Param::b;
    return P[1] * P[1] * P[2] == P[0] * P[0] * P[0] + ZZZ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isOnECJac3()

template<class Fp >

bool bn::ecop::isOnECJac3 ( const Fp * P )

inline

Definition at line 2361 of file bn.h.

{
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    if (P[2] == 0) return true;
 
    Fp Z6p_2;
    Fp::square(Z6p_2, P[2]);
    Fp::mul(Z6p_2, Z6p_2, P[2]);
    Fp::square(Z6p_2, Z6p_2);
    Z6p_2 *= Param::b;
    return P[1] * P[1] == P[0] * P[0] * P[0] + Z6p_2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isOnTwistECHom2()

template<class Fp >

bool bn::ecop::isOnTwistECHom2 ( const Fp2T< Fp > * P )

inline

Definition at line 2427 of file bn.h.

{
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    return P[1] * P[1] == (P[0] * P[0] * P[0] + Param::b_invxi);
}

Here is the caller graph for this function:

isOnTwistECHom3()

template<class Fp >

bool bn::ecop::isOnTwistECHom3 ( const Fp2T< Fp > * P )

inline

Definition at line 2439 of file bn.h.

{
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
    if (P[2] == 0) return true;
    return P[1] * P[1] * P[2] == (P[0] * P[0] * P[0] + Param::b_invxi * P[2] * P[2] * P[2]);
}

Here is the caller graph for this function:

isOnTwistECJac3()

template<class Fp >

bool bn::ecop::isOnTwistECJac3 ( const Fp2T< Fp > * P )

inline

Definition at line 2409 of file bn.h.

{
    typedef Fp2T<Fp> Fp2;
    typedef ParamT<Fp2> Param;
 
    if (P[2] == 0) return true;
    Fp2 Z6p;
    Fp2::square(Z6p, P[2]);
    Fp2::mul(Z6p, Z6p, P[2]);
    Fp2::square(Z6p, Z6p);
    return P[1] * P[1] == P[0] * P[0] * P[0] + Param::b_invxi * Z6p;
}

Here is the caller graph for this function:

NormalizeHom()

template<class FF >

void bn::ecop::NormalizeHom ( FF * out, const FF * in )

inline

Definition at line 2475 of file bn.h.

{
    if (in[2] == 0) {
        out[0].clear();
        out[1].clear();
        out[2].clear();
    } else if (in[2] == 1) {
        copy(out, in);
    } else {
        FF A = in[2];
        A.inverse();
        FF::mul(out[0], in[0], A);
        FF::mul(out[1], in[1], A);
        out[2] = 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeJac()

template<class FF >

void bn::ecop::NormalizeJac ( FF * out, const FF * in )

inline

Definition at line 2451 of file bn.h.

{
    if (in[2] == 0) {
        out[0].clear();
        out[1].clear();
        out[2].clear();
    } else if (in[2] == 1) {
        copy(out, in);
    } else {
        FF A, AA, t0;
        A = in[2];
        A.inverse();
        FF::square(AA, A);
        FF::mul(out[0], in[0], AA);
        FF::mul(t0, AA, A);
        FF::mul(out[1], in[1], t0);
        out[2] = 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScalarMult()

template<class FF , class INT >

void bn::ecop::ScalarMult ( FF * out, const FF * in, const INT & m )

inline

Definition at line 2590 of file bn.h.

{
    typedef typename mie::util::IntTag<INT> Tag;
    typedef typename Tag::value_type value_type;
 
    if (m == 0) {
        out[0].clear();
        out[1].clear();
        out[2].clear();
        return;
    }
    FF inCopy[3];
    if (out == in) {
        ecop::copy(inCopy, in);
        in = inCopy;
    }
 
    const int mSize = (int)Tag::getBlockSize(m);
    const int vSize = (int)sizeof(value_type) * 8;
    const value_type mask = value_type(1) << (vSize - 1);
    assert(mSize > 0); // if mSize == 0, it had been returned.
    /*
        Extract and process for MSB of most significant word.
    */
    value_type v = Tag::getBlock(m, mSize - 1);
    int j = 0;
 
    while ((v != 0) && (!(v & mask))) {
        v <<= 1;
        ++j;
    }
 
    v <<= 1;
    ++j;
    ecop::copy(out, in);
    /*
        Process for most significant word.
    */
    for (; j != vSize; ++j, v <<= 1) {
        ECDouble(out, out);
        if (v & mask) {
            ECAdd(out, out, in);
        }
    }
 
    /*
        Process for non most significant words.
    */
    for (int i = mSize - 2; i >= 0; --i) {
        v = Tag::getBlock(m, i);
        for (j = 0; j != vSize; ++j, v <<= 1) {
            ECDouble(out, out);
            if (v & mask) {
                ECAdd(out, out, in);
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: