mie::Fp Class Reference

#include <zm2.h>

Inheritance diagram for mie::Fp:

Collaboration diagram for mie::Fp:

Classes
struct	Dbl

Public Types
enum	{ N = 32 / sizeof(Unit) }
typedef mie::Unit	value_type

Public Member Functions
	Fp ()
MIE_FORCE_INLINE	Fp (int x)
MIE_FORCE_INLINE	Fp (const std::string &str)
MIE_FORCE_INLINE	Fp (const mie::Unit *x)
	Fp (const mie::Vuint &rhs)
void	set (int x)
void	set (const std::string &str)
void	set (const mie::Vuint &x)
MIE_FORCE_INLINE bool	isZero () const
MIE_FORCE_INLINE void	clear ()
Unit	getLow () const
bool	isOdd () const
mie::Vuint	get () const
void	inverse ()
std::string	toString (int base=10) const
MIE_FORCE_INLINE const Unit &	operator[] (size_t i) const
MIE_FORCE_INLINE Unit &	operator[] (size_t i)
MIE_FORCE_INLINE size_t	size () const
Public Member Functions inherited from mie::local::addsubmul< Fp, local::comparable< Fp, local::hasNegative< Fp, local::inversible< Fp > > > >
MIE_FORCE_INLINE Fp &	operator+= (const N &rhs)
MIE_FORCE_INLINE Fp &	operator-= (const Fp &rhs)
MIE_FORCE_INLINE Fp &	operator*= (const Fp &rhs)
Public Member Functions inherited from mie::local::hasNegative< Fp, local::inversible< Fp > >
MIE_FORCE_INLINE Fp	operator- () const
Public Member Functions inherited from mie::local::inversible< Fp >
MIE_FORCE_INLINE void	inverse ()
MIE_FORCE_INLINE Fp &	operator/= (const Fp &x)

Static Public Member Functions
static int	compare (const Fp &x, const Fp &y)
static void	_3z_add_2xC (Fp &z, const Fp &x)
static void	_2z_add_3x (Fp &z, const Fp &x)
static void	fromMont (Fp &y, const Fp &x)
static void	toMont (Fp &y, const Fp &x)
static void	inv (Fp &out, const Fp &x)
static void	divBy2 (Fp &z, const Fp &x)
static void	divBy4 (Fp &z, const Fp &x)
static void	fast_modp (Fp &z)
template<class T >
static MIE_FORCE_INLINE void	setDirect (Fp &out, const T &in)
static void	setModulo (const mie::Vuint &p, int mode, bool useMulx=true, bool definedBN_SUPPORT_SNARK=false)
static const mie::Vuint &	getModulo ()
static const Fp &	getDirectP (int n)
static const mie::Vuint &	getMontgomeryR ()
static void	square (Fp &out, const Fp &x)
static bool	squareRoot (Fp &y, const Fp &x)

Static Public Attributes
static void(*	add )(Fp &out, const Fp &x, const Fp &y)
static void(*	addNC )(Fp &out, const Fp &x, const Fp &y) = &Fp_addNC_C
static void(*	subNC )(Fp &out, const Fp &x, const Fp &y) = &Fp_subNC_C
static void(*	shr1 )(Fp &out, const Fp &x)
static void(*	shr2 )(Fp &out, const Fp &x)
static void(*	sub )(Fp &out, const Fp &x, const Fp &y)
static void(*	neg )(Fp &out, const Fp &x) = &Fp_negC
static void(*	mul )(Fp &out, const Fp &x, const Fp &y)
static int(*	preInv )(Fp &r, const Fp &x)
static mie::Fp *	halfTbl_

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

Detailed Description

Definition at line 15 of file zm2.h.

Member Typedef Documentation

value_type

mie::Unit mie::Fp::value_type

Definition at line 20 of file zm2.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
N

Definition at line 25 of file zm2.h.

         {
        N = 32 / sizeof(Unit)
    };

Constructor & Destructor Documentation

Fp() [1/5]

mie::Fp::Fp ( )

inline

Definition at line 28 of file zm2.h.

    {
    }

Fp() [2/5]

MIE_FORCE_INLINE mie::Fp::Fp ( int x )

inline

Definition at line 31 of file zm2.h.

    {
        set(x);
    }

Fp() [3/5]

MIE_FORCE_INLINE mie::Fp::Fp ( const std::string & str )

inlineexplicit

Definition at line 35 of file zm2.h.

    {
        set(str);
    }

Fp() [4/5]

MIE_FORCE_INLINE mie::Fp::Fp ( const mie::Unit * x )

inlineexplicit

Definition at line 39 of file zm2.h.

    {
        std::copy(x, x + N, v_);
    }

Fp() [5/5]

mie::Fp::Fp ( const mie::Vuint & rhs )

inline

Definition at line 43 of file zm2.h.

    {
        set(rhs);
    }

Member Function Documentation

_2z_add_3x()

static void mie::Fp::_2z_add_3x ( Fp & z, const Fp & x )

inlinestatic

Definition at line 108 of file zm2.h.

    {
        addNC(z, x, z);
        addNC(z, z, z);
        addNC(z, z, x);
        fast_modp(z);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_3z_add_2xC()

static void mie::Fp::_3z_add_2xC ( Fp & z, const Fp & x )

inlinestatic

Definition at line 98 of file zm2.h.

    {
        addNC(z, z, x);
        addNC(z, z, z);
        addNC(z, z, x);
        fast_modp(z);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

MIE_FORCE_INLINE void mie::Fp::clear ( )

inline

Definition at line 135 of file zm2.h.

    {
        std::fill(v_, v_ + N, 0);
    }

Here is the caller graph for this function:

compare()

static int mie::Fp::compare ( const Fp & x, const Fp & y )

inlinestatic

Definition at line 79 of file zm2.h.

    {
        return mie::local::PrimitiveFunction::compare(&x[0], N, &y[0], N);
    }

Here is the call graph for this function:

divBy2()

static void mie::Fp::divBy2 ( Fp & z, const Fp & x )

inlinestatic

Definition at line 216 of file zm2.h.

    {
        unsigned int i = x[0] & 0x1;
        shr1(z, x);
        addNC(z, z, halfTbl_[i]);
    }

Here is the caller graph for this function:

divBy4()

static void mie::Fp::divBy4 ( Fp & z, const Fp & x )

inlinestatic

Definition at line 223 of file zm2.h.

    {
        unsigned int i = x[0] & 0x3;
        shr2(z, x);
        addNC(z, z, quarterTbl_[i]);
    }

Here is the caller graph for this function:

fast_modp()

static void mie::Fp::fast_modp ( Fp & z )

inlinestatic

Definition at line 231 of file zm2.h.

    {
        uint64_t t = z.v_[3] >> 61;
        z -= getDirectP((int)t);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

fromMont()

static void mie::Fp::fromMont ( Fp & y, const Fp & x )

inlinestatic

Definition at line 139 of file zm2.h.

    {
        mul(y, x, one_);
    }

Here is the caller graph for this function:

get()

mie::Vuint mie::Fp::get ( ) const

inline

Definition at line 158 of file zm2.h.

    {
        Fp t;
        fromMont(t, *this);
        mie::Vuint ret(t.v_, N);
        return ret;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getDirectP()

const Fp & Fp::getDirectP ( int n )

static

Definition at line 126 of file zm2.cpp.

{
    assert(0 <= n && (size_t)n < pTblSize);
    return s_pTbl[n];
}

Here is the caller graph for this function:

getLow()

Unit mie::Fp::getLow ( ) const

inline

Definition at line 148 of file zm2.h.

    {
        Fp t;
        fromMont(t, *this);
        return t.v_[0];
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getModulo()

static const mie::Vuint & mie::Fp::getModulo ( )

inlinestatic

Definition at line 262 of file zm2.h.

{ return p_; }

Here is the caller graph for this function:

getMontgomeryR()

static const mie::Vuint & mie::Fp::getMontgomeryR ( )

inlinestatic

Definition at line 264 of file zm2.h.

{ return montgomeryR_; }

Here is the caller graph for this function:

inv()

static void mie::Fp::inv ( Fp & out, const Fp & x )

inlinestatic

Definition at line 165 of file zm2.h.

    {
#ifdef MIE_USE_X64ASM
        Fp r;
        int k = preInv(r, x);
#else
        static const Fp p(&p_[0]);
        Fp u, v, r, s;
        u = p;
        v = x;
        r.clear();
        s.clear(); s[0] = 1; // s is real 1
        int k = 0;
        while (!v.isZero()) {
            if ((u[0] & 1) == 0) {
                shr1(u, u);
                addNC(s, s, s);
            } else if ((v[0] & 1) == 0) {
                shr1(v, v);
                addNC(r, r, r);
            } else if (v >= u) {
                subNC(v, v, u);
                addNC(s, s, r);
                shr1(v, v);
                addNC(r, r, r);
            } else {
                subNC(u, u, v);
                addNC(r, r, s);
                shr1(u, u);
                addNC(s, s, s);
            }
            k++;
        }
        if (r >= p) {
            subNC(r, r, p);
        }
        assert(!r.isZero());
        subNC(r, p, r);
#endif
        /*
            xr = 2^k
            R = 2^256
            get r2^(-k)R^2 = r 2^(512 - k)
        */
        mul(out, r, invTbl_[k]);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

inverse()

void mie::Fp::inverse ( )

inline

Definition at line 211 of file zm2.h.

    {
        inv(*this, *this);
    }

Here is the call graph for this function:

isOdd()

bool mie::Fp::isOdd ( ) const

inline

Definition at line 154 of file zm2.h.

    {
        return (getLow() & 1) != 0;
    }

Here is the call graph for this function:

isZero()

MIE_FORCE_INLINE bool mie::Fp::isZero ( ) const

inline

Definition at line 127 of file zm2.h.

    {
        Unit t = 0;
        for (size_t i = 0; i < N; i++) {
            t |= v_[i];
        }
        return t == 0;
    }

Here is the caller graph for this function:

operator[]() [1/2]

MIE_FORCE_INLINE Unit & mie::Fp::operator[] ( size_t i )

inline

Definition at line 252 of file zm2.h.

{ return v_[i]; }

operator[]() [2/2]

MIE_FORCE_INLINE const Unit & mie::Fp::operator[] ( size_t i ) const

inline

Definition at line 251 of file zm2.h.

{ return v_[i]; }

set() [1/3]

void mie::Fp::set ( const mie::Vuint & x )

inline

Definition at line 70 of file zm2.h.

    {
        assert(x < getModulo());
        mie::Vuint y(x);
//      count++;std::cout << "count=" << count << ", x=" << x << std::endl;
        y *= getMontgomeryR();
        y %= getModulo();
        setDirect(*this, y);
    }

Here is the call graph for this function:

set() [2/3]

void mie::Fp::set ( const std::string & str )

inline

Definition at line 66 of file zm2.h.

    {
        set(mie::Vuint(str));
    }

set() [3/3]

void mie::Fp::set ( int x )

inline

Definition at line 47 of file zm2.h.

    {
        if (x == 0) {
            clear();
        } else if (x == 1) {
            const mie::Vuint& r = getMontgomeryR();
            assert(r.size() == N);
            std::copy(&r[0], &r[0] + N, v_);
        } else if (x > 0) {
            v_[0] = x;
            std::fill(v_ + 1, v_ + N, 0);
            mul(*this, *this, montgomeryR2_);
        } else {
            v_[0] = -x;
            std::fill(v_ + 1, v_ + N, 0);
            mul(*this, *this, montgomeryR2_);
            neg(*this, *this);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setDirect()

template<class T >

static MIE_FORCE_INLINE void mie::Fp::setDirect ( Fp & out, const T & in )

inlinestatic

Definition at line 238 of file zm2.h.

    {
        const size_t n = in.size();
//      assert(n <= N);
        if (n < N) {
            std::copy(&in[0], &in[0] + n, out.v_);
            std::fill(out.v_ + n, out.v_ + N, 0);
        } else {
            // ignore in[i] for i >= N
            std::copy(&in[0], &in[0] + N, out.v_);
        }
    }

Here is the caller graph for this function:

setModulo()

void Fp::setModulo ( const mie::Vuint & p, int mode, bool useMulx = true, bool definedBN_SUPPORT_SNARK = false )

static

Definition at line 3592 of file zm2.cpp.

{
#ifdef DEBUG_COUNT
    puts("DEBUG_COUNT mode on!!!");
#endif
#ifdef BN_SUPPORT_SNARK
    const bool scipr = true;
#else
    const bool scipr = false;
#endif
    if (scipr != definedBN_SUPPORT_SNARK) {
        fprintf(stderr, "use -DBN_SUPPORT_SNARK for all sources\n");
        exit(1);
    }
    static bool init = false;
    if (init) return;
    init = true;
    if (p.size() != Fp::N) {
        mie::local::errExit("not support p for Fp::setModulo");
    }
    p_ = p;
 
    // Fp_mul
    {
        typedef mie::ZmZ<Vuint, MontgomeryTest> ZN;
        ZN::setModulo(Vuint(1) << (sizeof(Unit) * 8));
        ZN t(p);
        t = -t;
        t.inverse();
        pp_mont = t[0];
        pN = p << 256;
        p_add1_div4_ = (p + 1) / 4;
    }
 
    // we can't use Fp before setting Fp_mul* variables!!!
    montgomeryR_ = (Vuint(1) << 256) % p;
    {
        typedef mie::ZmZ<mie::Vuint, MontgomeryDummy> Z;
        Z::setModulo(p);
        Z t(montgomeryR_);
        Fp::setDirect(montgomeryR2_, t * t);
    }
    one_.clear();
    one_[0] = 1;
 
    Fp_emu::setModulo(p);
    try {
        // setup code and data area
        const int PageSize = 4096;
        const size_t codeSize = PageSize * 9;
        const size_t dataSize = PageSize * 1;
 
        static std::vector<Xbyak::uint8> buf;
        buf.resize(codeSize + dataSize + PageSize);
        Xbyak::uint8 *const codeAddr = Xbyak::CodeArray::getAlignedAddress(&buf[0], PageSize);
        Xbyak::CodeArray::protect(codeAddr, codeSize, true);
        s_data = Xbyak::CastTo<Data*>(codeAddr + codeSize);
 
//      printf("codeAddr=%p, dataAddr=%p\n", codeAddr, s_data);
        if ((size_t)codeAddr & 0xffffffff00000000ULL || (size_t)s_data & 0xffffffff00000000ULL) {
            // printf("\naddress of code and data is over 4GB!!!\n");
        }
 
        // setup data
        s_pTbl = s_data->pTbl;
        Fp::halfTbl_ = s_data->halfTbl;
        Fp::quarterTbl_ = s_data->quarterTbl;
        bn::FpDbl::pNTbl_ = s_data->pNTbl;
 
        for (size_t i = 0; i < pTblSize; i++) {
            Fp::setDirect(s_pTbl[i], p * int(i));
        }
        /*
            for option1
            lower 192-bits of pNTbl_[1] = 0
            lower 192-bits of pNTbl_[2] = 0
        */
        Fp::Dbl::pNTbl_[0].setDirect(pN);
        for (size_t h = 1; h < pNtblSize; ++h) {
            Fp::Dbl::pNTbl_[h].setDirect(pN >> h);
        }
        setTablesForDiv(p);
 
        // setup code
        static PairingCode code(codeSize, codeAddr);
        code.init(p_, mode, useMulx);
        {
            Fp t(2);
            for (int i = 0; i < 512; i++) {
                invTbl_[511 - i] = t;
                t += t;
            }
        }
        return;
    } catch (std::exception& e) {
        fprintf(stderr, "setModulo ERR:%s\n", e.what());
    }
    ::exit(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

size()

MIE_FORCE_INLINE size_t mie::Fp::size ( ) const

inline

Definition at line 253 of file zm2.h.

{ return N; }

square()

static void mie::Fp::square ( Fp & out, const Fp & x )

inlinestatic

Definition at line 282 of file zm2.h.

{ mul(out, x, x); }

Here is the caller graph for this function:

squareRoot()

static bool mie::Fp::squareRoot ( Fp & y, const Fp & x )

inlinestatic

Definition at line 297 of file zm2.h.

    {
        Fp t;
        t = mie::power(x, p_add1_div4_);
        if (t * t != x) return false;
        y = t;
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

toMont()

static void mie::Fp::toMont ( Fp & y, const Fp & x )

inlinestatic

Definition at line 143 of file zm2.h.

    {
        mul(y, x, montgomeryR2_);
    }

toString()

std::string mie::Fp::toString ( int base = 10 ) const

inline

Definition at line 250 of file zm2.h.

{ return get().toString(base); }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & os, const Fp & x )

friend

Definition at line 116 of file zm2.h.

    {
        return os << x.toString(os.flags() & std::ios_base::hex ? 16 : 10);
    }

operator>>

std::istream & operator>> ( std::istream & is, Fp & x )

friend

Definition at line 120 of file zm2.h.

    {
        std::string str;
        mie::local::getDigits(is, str);
        x.set(str);
        return is;
    }

Member Data Documentation

add

void(* mie::Fp::add) (Fp &out, const Fp &x, const Fp &y)

static

Definition at line 83 of file zm2.h.

addNC

void(* Fp::addNC)(Fp &out, const Fp &x, const Fp &y) = &Fp_addNC_C

static

Definition at line 86 of file zm2.h.

halfTbl_

Fp * Fp::halfTbl_

static

Definition at line 270 of file zm2.h.

mul

void(* mie::Fp::mul) (Fp &out, const Fp &x, const Fp &y)

static

Definition at line 93 of file zm2.h.

neg

void(* Fp::neg)(Fp &out, const Fp &x) = &Fp_negC

static

Definition at line 92 of file zm2.h.

preInv

int(* Fp::preInv)(Fp &r, const Fp &x)=0

static

Definition at line 94 of file zm2.h.

shr1

void(* Fp::shr1)(Fp &out, const Fp &x)=0

static

Definition at line 88 of file zm2.h.

shr2

void(* Fp::shr2)(Fp &out, const Fp &x)=0

static

Definition at line 89 of file zm2.h.

sub

void(* mie::Fp::sub) (Fp &out, const Fp &x, const Fp &y)

static

Definition at line 91 of file zm2.h.

subNC

void(* Fp::subNC)(Fp &out, const Fp &x, const Fp &y) = &Fp_subNC_C

static

Definition at line 87 of file zm2.h.

---

The documentation for this class was generated from the following files:

• libraries/fc/libraries/ff/depends/ate-pairing/include/zm2.h
• libraries/fc/libraries/ff/depends/ate-pairing/src/zm2.cpp