bn::Fp6T< T > Struct Template Reference

#include <bn.h>

Inheritance diagram for bn::Fp6T< T >:

Collaboration diagram for bn::Fp6T< T >:

Classes
struct	Dbl

Public Types
typedef T	Fp2
typedef T::Fp	Fp
typedef ParamT< Fp2 >	Param
typedef Fp2::Dbl	Fp2Dbl

Public Member Functions
	Fp6T ()
	Fp6T (int x)
	Fp6T (const Fp2 &a, const Fp2 &b, const Fp2 &c)
	Fp6T (const Fp &a0, const Fp &a1, const Fp &a2, const Fp &a3, const Fp &a4, const Fp &a5)
void	clear ()
Fp *	get ()
const Fp *	get () const
Fp2 *	getFp2 ()
const Fp2 *	getFp2 () const
void	set (const Fp2 &v0, const Fp2 &v1, const Fp2 &v2)
bool	isZero () const
void	inverse ()
bool	operator== (const Fp6T &rhs) const
bool	operator!= (const Fp6T &rhs) const
Public Member Functions inherited from mie::local::addsubmul< Fp6T< T >, mie::local::hasNegative< Fp6T< T > > >
MIE_FORCE_INLINE T &	operator+= (const N &rhs)
MIE_FORCE_INLINE T &	operator-= (const T &rhs)
MIE_FORCE_INLINE T &	operator*= (const T &rhs)
Public Member Functions inherited from mie::local::hasNegative< Fp6T< T > >
MIE_FORCE_INLINE T	operator- () const

Static Public Member Functions
static void	addC (Fp6T &z, const Fp6T &x, const Fp6T &y)
static void	subC (Fp6T &z, const Fp6T &x, const Fp6T &y)
static void	neg (Fp6T &z, const Fp6T &x)
static void	mulC (Fp6T &z, const Fp6T &x, const Fp6T &y)
static void	square (Fp6T &z, const Fp6T &x)
static void	pointDblLineEvalWithoutPC (Fp6T &l, Fp2 *R)
static void	mulFp6_24_Fp_01 (Fp6T &l, const Fp *P)
static void	pointDblLineEvalC (Fp6T &l, Fp2 *R, const Fp *P)
static void	pointAddLineEvalWithoutP (Fp6T &l, Fp2 *R, const Fp2 *Q)
static void	pointAddLineEval (Fp6T &l, Fp2 *R, const Fp2 *Q, const Fp *P)
static void	mul_Fp_b (Fp6T &z, const Fp &x)
static void	mul_Fp_c (Fp6T &z, const Fp &x)

Public Attributes
Fp2	a_
Fp2	b_
Fp2	c_

Static Public Attributes
static void(*	add )(Fp6T &z, const Fp6T &x, const Fp6T &y)
static void(*	sub )(Fp6T &z, const Fp6T &x, const Fp6T &y)
static void(*	mul )(Fp6T &z, const Fp6T &x, const Fp6T &y)
static void(*	pointDblLineEval )(Fp6T &l, Fp2 *R, const Fp *P)
static void(*	pointDblLineEvalWithoutP )(Fp6T &l, Fp2 *R)

Friends
std::ostream &	operator<< (std::ostream &os, const Fp6T &x)
std::istream &	operator>> (std::istream &is, Fp6T &x)

Detailed Description

template<class T>
struct bn::Fp6T< T >

Definition at line 836 of file bn.h.

Member Typedef Documentation

Fp

template<class T >

T::Fp bn::Fp6T< T >::Fp

Definition at line 839 of file bn.h.

Fp2

template<class T >

T bn::Fp6T< T >::Fp2

Definition at line 838 of file bn.h.

Fp2Dbl

template<class T >

Fp2::Dbl bn::Fp6T< T >::Fp2Dbl

Definition at line 841 of file bn.h.

Param

template<class T >

ParamT<Fp2> bn::Fp6T< T >::Param

Definition at line 840 of file bn.h.

Constructor & Destructor Documentation

Fp6T() [1/4]

template<class T >

bn::Fp6T< T >::Fp6T ( )

inline

Definition at line 843 of file bn.h.

{ }

Fp6T() [2/4]

template<class T >

bn::Fp6T< T >::Fp6T ( int x )

inline

Definition at line 844 of file bn.h.

        : a_(x)
        , b_(0)
        , c_(0)
    {
    }

Fp6T() [3/4]

template<class T >

bn::Fp6T< T >::Fp6T ( const Fp2 & a, const Fp2 & b, const Fp2 & c )

inline

Definition at line 850 of file bn.h.

        : a_(a)
        , b_(b)
        , c_(c)
    {
    }

Fp6T() [4/4]

template<class T >

bn::Fp6T< T >::Fp6T ( const Fp & a0, const Fp & a1, const Fp & a2, const Fp & a3, const Fp & a4, const Fp & a5 )

inline

Definition at line 856 of file bn.h.

        : a_(a0, a1)
        , b_(a2, a3)
        , c_(a4, a5)
    {
    }

Member Function Documentation

addC()

template<class T >

static void bn::Fp6T< T >::addC ( Fp6T< T > & z, const Fp6T< T > & x, const Fp6T< T > & y )

inlinestatic

Definition at line 884 of file bn.h.

    {
        Fp2::add(z.a_, x.a_, y.a_);
        Fp2::add(z.b_, x.b_, y.b_);
        Fp2::add(z.c_, x.c_, y.c_);
    }

clear()

template<class T >

void bn::Fp6T< T >::clear ( )

inline

Definition at line 862 of file bn.h.

    {
        a_.clear();
        b_.clear();
        c_.clear();
    }

get() [1/2]

template<class T >

Fp * bn::Fp6T< T >::get ( )

inline

Definition at line 869 of file bn.h.

{ return a_.get(); }

Here is the caller graph for this function:

get() [2/2]

template<class T >

const Fp * bn::Fp6T< T >::get ( ) const

inline

Definition at line 870 of file bn.h.

{ return a_.get(); }

getFp2() [1/2]

template<class T >

Fp2 * bn::Fp6T< T >::getFp2 ( )

inline

Definition at line 871 of file bn.h.

{ return &a_; }

getFp2() [2/2]

template<class T >

const Fp2 * bn::Fp6T< T >::getFp2 ( ) const

inline

Definition at line 872 of file bn.h.

{ return &a_; }

inverse()

template<class T >

void bn::Fp6T< T >::inverse ( )

inline

Definition at line 937 of file bn.h.

    {
        Fp6T z;
        Fp2 t0, t1, t2, t4, t5;
        Fp2::mul(t0, b_, c_);
        Fp2::mul_xi(z.a_, t0);
        Fp2::square(t0, a_);
        Fp2::sub(z.a_, t0, z.a_);
        Fp2::square(t1, b_);
        Fp2::mul(t5, a_, c_);
        Fp2::sub(z.c_, t1, t5);
        Fp2::square(t2, c_);
        Fp2::mul(t4, a_, b_);
        Fp2::mul_xi(z.b_, t2);
        z.b_ -= t4;
        Fp2::mul(t1, a_, z.a_);
        Fp2::mul(t5, c_, z.b_);
        Fp2::mul_xi(t4, t5);
        t1 += t4;
        Fp2::mul(t5, b_, z.c_);
        Fp2::mul_xi(t4, t5);
        t1 += t4;
        t1.inverse();
        Fp2::mul(a_, z.a_, t1);
        Fp2::mul(b_, z.b_, t1);
        Fp2::mul(c_, z.c_, t1);
    }

Here is the caller graph for this function:

isZero()

template<class T >

bool bn::Fp6T< T >::isZero ( ) const

inline

Definition at line 879 of file bn.h.

    {
        return a_.isZero() && b_.isZero() && c_.isZero();
    }

mul_Fp_b()

template<class T >

static void bn::Fp6T< T >::mul_Fp_b ( Fp6T< T > & z, const Fp & x )

inlinestatic

Definition at line 1149 of file bn.h.

    {
        Fp2::mul_Fp_0(z.b_, z.b_, x);
    }

mul_Fp_c()

template<class T >

static void bn::Fp6T< T >::mul_Fp_c ( Fp6T< T > & z, const Fp & x )

inlinestatic

Definition at line 1153 of file bn.h.

    {
        Fp2::mul_Fp_0(z.c_, z.c_, x);
    }

mulC()

template<class T >

static void bn::Fp6T< T >::mulC ( Fp6T< T > & z, const Fp6T< T > & x, const Fp6T< T > & y )

inlinestatic

Definition at line 904 of file bn.h.

    {
        Dbl zd;
        Dbl::mul(zd, x, y);
        Dbl::mod(z, zd);
    }

Here is the call graph for this function:

mulFp6_24_Fp_01()

template<class T >

static void bn::Fp6T< T >::mulFp6_24_Fp_01 ( Fp6T< T > & l, const Fp * P )

inlinestatic

Definition at line 1074 of file bn.h.

    {
        Fp2::mul_Fp_0(l.c_, l.c_, P[0]);
        Fp2::mul_Fp_0(l.b_, l.b_, P[1]);
    }

Here is the caller graph for this function:

neg()

template<class T >

static void bn::Fp6T< T >::neg ( Fp6T< T > & z, const Fp6T< T > & x )

inlinestatic

Definition at line 896 of file bn.h.

    {
        Fp2::neg(z.a_, x.a_);
        Fp2::neg(z.b_, x.b_);
        Fp2::neg(z.c_, x.c_);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

template<class T >

bool bn::Fp6T< T >::operator!= ( const Fp6T< T > & rhs ) const

inline

Definition at line 969 of file bn.h.

{ return !operator==(rhs); }

Here is the call graph for this function:

operator==()

template<class T >

bool bn::Fp6T< T >::operator== ( const Fp6T< T > & rhs ) const

inline

Definition at line 965 of file bn.h.

    {
        return a_ == rhs.a_ && b_ == rhs.b_ && c_ == rhs.c_;
    }

Here is the caller graph for this function:

pointAddLineEval()

template<class T >

static void bn::Fp6T< T >::pointAddLineEval ( Fp6T< T > & l, Fp2 * R, const Fp2 * Q, const Fp * P )

inlinestatic

Definition at line 1143 of file bn.h.

    {
        pointAddLineEvalWithoutP(l, R, Q);
        // # 13, #19
        mulFp6_24_Fp_01(l, P);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

pointAddLineEvalWithoutP()

template<class T >

static void bn::Fp6T< T >::pointAddLineEvalWithoutP ( Fp6T< T > & l, Fp2 * R, const Fp2 * Q )

inlinestatic

Definition at line 1094 of file bn.h.

    {
        Fp2 t1, t2, t3, t4;
        Fp2Dbl T1, T2;
        // # 1
        Fp2::mul(t1, R[2], Q[0]);
        Fp2::mul(t2, R[2], Q[1]);
        // # 2
        Fp2::sub(t1, R[0], t1);
        Fp2::sub(t2, R[1], t2);
        // # 3
        Fp2::square(t3, t1);
        // # 4
        Fp2::mul(R[0], t3, R[0]);
        Fp2::square(t4, t2);
        // # 5
        t3 *= t1;
        t4 *= R[2];
        // # 6
        t4 += t3;
        // # 7
        t4 -= R[0];
        // # 8
        t4 -= R[0];
        // # 9
        R[0] -= t4;
        // # 10
        Fp2Dbl::mulOpt1(T1, t2, R[0]);
        Fp2Dbl::mulOpt1(T2, t3, R[1]);
        // # 11
        Fp2Dbl::sub(T2, T1, T2);
        // # 12
        Fp2Dbl::mod(R[1], T2);
        Fp2::mul(R[0], t1, t4);
        Fp2::mul(R[2], t3, R[2]);
        // # 14
        Fp2::neg(l.c_, t2);
        // # 15
        Fp2Dbl::mulOpt1(T1, t2, Q[0]);
        Fp2Dbl::mulOpt1(T2, t1, Q[1]);
        // # 16
        Fp2Dbl::sub(T1, T1, T2);
        // # 17
        Fp2Dbl::mod(t2, T1);
        // ### @note: Be careful, below fomulas are typo.
        // # 18
        Fp2::mul_xi(l.a_, t2);
        l.b_ = t1;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

pointDblLineEvalC()

template<class T >

static void bn::Fp6T< T >::pointDblLineEvalC ( Fp6T< T > & l, Fp2 * R, const Fp * P )

inlinestatic

Definition at line 1079 of file bn.h.

    {
        pointDblLineEvalWithoutP(l, R);
        // # 16, #17
        mulFp6_24_Fp_01(l, P);
    }

Here is the call graph for this function:

pointDblLineEvalWithoutPC()

template<class T >

static void bn::Fp6T< T >::pointDblLineEvalWithoutPC ( Fp6T< T > & l, Fp2 * R )

inlinestatic

Definition at line 1001 of file bn.h.

    {
        Fp2 t0, t1, t2, t3, t4, t5;
        Fp2Dbl T0, T1, T2;
        // X1, Y1, Z1 == R[0], R[1], R[2]
        // xp, yp = P[0], P[1]
 
        // # 1
        Fp2::square(t0, R[2]);
        Fp2::mul(t4, R[0], R[1]);
        Fp2::square(t1, R[1]);
        // # 2
        Fp2::add(t3, t0, t0);
        Fp2::divBy2(t4, t4);
        Fp2::add(t5, t0, t1);
        // # 3
        t0 += t3;
        // # 4
#ifdef BN_SUPPORT_SNARK
        if (ParamT<Fp2>::b == 82) {
            // (a + bu) * (9 - u) = (9a + b) + (9b - a)u
            t3.a_ = t0.b_;
            t3.b_ = t0.a_;
            Fp2::mul_xi(t0, t3);
            t2.a_ = t0.b_;
            t2.b_ = t0.a_;
        } else {
            // (a + bu) * binv_xi
            Fp2::mul(t2, t0, ParamT<Fp2>::b_invxi);
        }
#else
        // (a + bu)(1 - u) = (a + b) + (b - a)u
        Fp::add(t2.a_, t0.a_, t0.b_);
        Fp::sub(t2.b_, t0.b_, t0.a_);
#endif
        // # 5
        Fp2::square(t0, R[0]);
        Fp2::add(t3, t2, t2);
        // ## 6
        t3 += t2;
        Fp2::addNC(l.c_, t0, t0);
        // ## 7
        Fp2::sub(R[0], t1, t3);
        Fp2::addNC(l.c_, l.c_, t0);
        t3 += t1;
        // # 8
        R[0] *= t4;
        Fp2::divBy2(t3, t3);
        // ## 9
        Fp2Dbl::square(T0, t3);
        Fp2Dbl::square(T1, t2);
        // # 10
        Fp2Dbl::addNC(T2, T1, T1);
        Fp2::add(t3, R[1], R[2]);
        // # 11
#ifdef BN_SUPPORT_SNARK
        Fp2Dbl::add(T2, T2, T1);
#else
        Fp2Dbl::addNC(T2, T2, T1);
#endif
        Fp2::square(t3, t3);
        // # 12
        t3 -= t5;
        // # 13
        T0 -= T2;
        // # 14
        Fp2Dbl::mod(R[1], T0);
        Fp2::mul(R[2], t1, t3);
        t2 -= t1;
        // # 15
        Fp2::mul_xi(l.a_, t2);
        Fp2::neg(l.b_, t3);
    }

Here is the call graph for this function:

set()

template<class T >

void bn::Fp6T< T >::set ( const Fp2 & v0, const Fp2 & v1, const Fp2 & v2 )

inline

Definition at line 873 of file bn.h.

    {
        a_ = v0;
        b_ = v1;
        c_ = v2;
    }

square()

template<class T >

static void bn::Fp6T< T >::square ( Fp6T< T > & z, const Fp6T< T > & x )

inlinestatic

Definition at line 914 of file bn.h.

    {
        assert(&z != &x);
        Fp2 v3, v4, v5;
        Fp2::add(v4, x.a_, x.a_);
        Fp2::mul(v4, v4, x.b_);
        Fp2::square(v5, x.c_);
        Fp2::mul_xi(z.b_, v5);
        z.b_ += v4;
        Fp2::sub(z.c_, v4, v5);
        Fp2::square(v3, x.a_);
        Fp2::sub(v4, x.a_, x.b_);
        v4 += x.c_;
        Fp2::add(v5, x.b_, x.b_);
        Fp2::mul(v5, v5, x.c_);
        Fp2::square(v4, v4);
        Fp2::mul_xi(z.a_, v5);
        z.a_ += v3;
        z.c_ += v4;
        z.c_ += v5;
        z.c_ -= v3;
    }

Here is the caller graph for this function:

subC()

template<class T >

static void bn::Fp6T< T >::subC ( Fp6T< T > & z, const Fp6T< T > & x, const Fp6T< T > & y )

inlinestatic

Definition at line 890 of file bn.h.

    {
        Fp2::sub(z.a_, x.a_, y.a_);
        Fp2::sub(z.b_, x.b_, y.b_);
        Fp2::sub(z.c_, x.c_, y.c_);
    }

Friends And Related Symbol Documentation

operator<<

template<class T >

std::ostream & operator<< ( std::ostream & os, const Fp6T< T > & x )

friend

Definition at line 970 of file bn.h.

    {
        return os << "[" << x.a_ << ",\n " << x.b_ << ",\n " << x.c_ << "]";
    }

operator>>

template<class T >

std::istream & operator>> ( std::istream & is, Fp6T< T > & x )

friend

Definition at line 974 of file bn.h.

    {
        char c1, c2, c3, c4;
        is >> c1 >> x.a_ >> c2 >> x.b_ >> c3 >> x.c_ >> c4;
        if (c1 == '[' && c2 == ',' && c3 == ',' && c4 == ']') return is;
        throw std::ios_base::failure("bad Fp6");
    }

Member Data Documentation

a_

template<class T >

Fp2 bn::Fp6T< T >::a_

Definition at line 842 of file bn.h.

add

template<class T >

void(* bn::Fp6T< T >::add) (Fp6T &z, const Fp6T &x, const Fp6T &y)

static

Definition at line 982 of file bn.h.

b_

template<class T >

Fp2 bn::Fp6T< T >::b_

Definition at line 842 of file bn.h.

c_

template<class T >

Fp2 bn::Fp6T< T >::c_

Definition at line 842 of file bn.h.

mul

template<class T >

void(* bn::Fp6T< T >::mul) (Fp6T &z, const Fp6T &x, const Fp6T &y)

static

Definition at line 984 of file bn.h.

pointDblLineEval

template<class T >

void(* bn::Fp6T< T >::pointDblLineEval) (Fp6T &l, Fp2 *R, const Fp *P)

static

Definition at line 986 of file bn.h.

pointDblLineEvalWithoutP

template<class T >

void(* bn::Fp6T< T >::pointDblLineEvalWithoutP) (Fp6T &l, Fp2 *R)

static

Definition at line 987 of file bn.h.

sub

template<class T >

void(* bn::Fp6T< T >::sub) (Fp6T &z, const Fp6T &x, const Fp6T &y)

static

Definition at line 983 of file bn.h.

---

The documentation for this struct was generated from the following file:

• libraries/fc/libraries/ff/depends/ate-pairing/include/bn.h