mie::ZmZ< V, Tag > Class Template Reference

#include <zm.h>

Inheritance diagram for mie::ZmZ< V, Tag >:

Collaboration diagram for mie::ZmZ< V, Tag >:

Public Types
typedef void	base_type
typedef V::value_type	value_type

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

Static Public Member Functions
static int	compare (const ZmZ &x, const ZmZ &y)
static void	add (ZmZ &out, const ZmZ &x, const ZmZ &y)
static void	sub (ZmZ &out, const ZmZ &x, const ZmZ &y)
static void	neg (ZmZ &out, const ZmZ &x)
static void	mul (ZmZ &out, const ZmZ &x, const ZmZ &y)
static void	inv (ZmZ &out, const ZmZ &x)
static void	setModulo (const V &m)
static const V &	getModulo ()

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

Detailed Description

template<class V = Vuint, class Tag = Vuint>
class mie::ZmZ< V, Tag >

Z/mZ class by Vuint

Note

Tag is prepared for multi instances of different m

Definition at line 1169 of file zm.h.

Member Typedef Documentation

base_type

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::base_type

Definition at line 1174 of file zm.h.

value_type

template<class V = Vuint, class Tag = Vuint>

V::value_type mie::ZmZ< V, Tag >::value_type

Definition at line 1175 of file zm.h.

Constructor & Destructor Documentation

ZmZ() [1/3]

template<class V = Vuint, class Tag = Vuint>

mie::ZmZ< V, Tag >::ZmZ ( int x = 0 )

inline

Definition at line 1184 of file zm.h.

    {
        set(x);
    }

ZmZ() [2/3]

template<class V = Vuint, class Tag = Vuint>

mie::ZmZ< V, Tag >::ZmZ ( const std::string & str )

inlineexplicit

Definition at line 1188 of file zm.h.

    {
        set(str);
    }

ZmZ() [3/3]

template<class V = Vuint, class Tag = Vuint>

mie::ZmZ< V, Tag >::ZmZ ( const V & rhs )

inline

Definition at line 1192 of file zm.h.

        : v_(rhs)
    {
        modulo();
    }

Member Function Documentation

add()

template<class V = Vuint, class Tag = Vuint>

static void mie::ZmZ< V, Tag >::add ( ZmZ< V, Tag > & out, const ZmZ< V, Tag > & x, const ZmZ< V, Tag > & y )

inlinestatic

Definition at line 1236 of file zm.h.

    {
        V::add(out.v_, x.v_, y.v_);
        if (out.v_ >= m_) {
            out.v_ -= m_;
        }
    }

clear()

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::clear ( )

inline

Definition at line 1287 of file zm.h.

{ v_ = 0; }

compare()

template<class V = Vuint, class Tag = Vuint>

static int mie::ZmZ< V, Tag >::compare ( const ZmZ< V, Tag > & x, const ZmZ< V, Tag > & y )

inlinestatic

Definition at line 1232 of file zm.h.

    {
        return V::compare(x.v_, y.v_);
    }

get()

template<class V = Vuint, class Tag = Vuint>

const V & mie::ZmZ< V, Tag >::get ( ) const

inline

Definition at line 1288 of file zm.h.

{ return v_; }

getModulo()

template<class V = Vuint, class Tag = Vuint>

static const V & mie::ZmZ< V, Tag >::getModulo ( )

inlinestatic

Definition at line 1335 of file zm.h.

    {
        return m_;
    }

inv()

template<class V = Vuint, class Tag = Vuint>

static void mie::ZmZ< V, Tag >::inv ( ZmZ< V, Tag > & out, const ZmZ< V, Tag > & x )

inlinestatic

Definition at line 1292 of file zm.h.

    {
        assert(!x.isZero());
        ZmZ a = 1;
        if (a.v_ == x.v_) {
            out = a;
            return;
        }
 
        V t;
        ZmZ q;
        V::div(&q.v_, t, m_, x.v_);
        assert(!t.isZero()); // because m_ is prime
        V s = x.v_;
        ZmZ b = -q;
 
        for (;;) {
            V::div(&q.v_, s, s, t);
            if (s.isZero()) {
                out = b;
                return;
            }
            a -= b * q;
 
            V::div(&q.v_, t, t, s);
            if (t.isZero()) {
                out = a;
                return;
            }
            b -= a * q;
        }
    }

Here is the call graph for this function:

isZero()

template<class V = Vuint, class Tag = Vuint>

bool mie::ZmZ< V, Tag >::isZero ( ) const

inline

Definition at line 1286 of file zm.h.

{ return v_.isZero(); }

Here is the caller graph for this function:

mul()

template<class V = Vuint, class Tag = Vuint>

static void mie::ZmZ< V, Tag >::mul ( ZmZ< V, Tag > & out, const ZmZ< V, Tag > & x, const ZmZ< V, Tag > & y )

inlinestatic

Definition at line 1265 of file zm.h.

    {
#if 0 // for only FixedBuffer(this code is dangerous and not good)
        const size_t xn = x.size();
        const size_t yn = y.size();
 
        V *t = new(MIE_ALLOCA_(sizeof(value_type) * (xn + yn))) V;
        t->forceAlloc(xn + yn);
        V::mul(&(*t)[0], &x[0], xn, &y[0], yn);
        t->trim();
        V::div(0, out.v_, *t, m_);
        out.v_.trim();
#else
        V::mul(out.v_, x.v_, y.v_);
        out.modulo();
#endif
    }

Here is the call graph for this function:

neg()

template<class V = Vuint, class Tag = Vuint>

static void mie::ZmZ< V, Tag >::neg ( ZmZ< V, Tag > & out, const ZmZ< V, Tag > & x )

inlinestatic

Definition at line 1257 of file zm.h.

    {
        if (x.isZero()) {
            out = x;
        } else {
            V::sub(out.v_, m_, x.v_);
        }
    }

Here is the call graph for this function:

operator[]() [1/2]

template<class V = Vuint, class Tag = Vuint>

value_type & mie::ZmZ< V, Tag >::operator[] ( size_t i )

inline

Definition at line 1329 of file zm.h.

{ return v_[i]; }

operator[]() [2/2]

template<class V = Vuint, class Tag = Vuint>

const value_type & mie::ZmZ< V, Tag >::operator[] ( size_t i ) const

inline

Definition at line 1328 of file zm.h.

{ return v_[i]; }

set() [1/6]

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::set ( const std::string & str )

inline

Definition at line 1212 of file zm.h.

    {
        v_.set(str);
        modulo();
    }

set() [2/6]

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::set ( const uint32_t * x, size_t size )

inline

Definition at line 1217 of file zm.h.

    {
        v_.set(x, size);
        modulo();
    }

Here is the call graph for this function:

set() [3/6]

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::set ( const uint64_t * x, size_t size )

inline

Definition at line 1222 of file zm.h.

    {
        v_.set(x, size);
        modulo();
    }

Here is the call graph for this function:

set() [4/6]

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::set ( const V & rhs )

inline

Definition at line 1227 of file zm.h.

    {
        v_ = rhs;
        modulo();
    }

set() [5/6]

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::set ( const ZmZ< V, Tag > & x )

inline

Definition at line 1197 of file zm.h.

{ v_ = x.v_; }

Here is the caller graph for this function:

set() [6/6]

template<class V = Vuint, class Tag = Vuint>

void mie::ZmZ< V, Tag >::set ( int x )

inline

Definition at line 1198 of file zm.h.

    {
        if (x == 0) {
            v_.clear();
        } else if (x > 0) {
            v_.set(x);
        } else {
            if (x == -2147483647 - 1 || m_ < -x) {
                local::errExit("x is too small");
            }
            v_ = m_;
            v_ -= -x;
        }
    }

setModulo()

template<class V = Vuint, class Tag = Vuint>

static void mie::ZmZ< V, Tag >::setModulo ( const V & m )

inlinestatic

Definition at line 1331 of file zm.h.

    {
        m_ = m;
    }

Here is the caller graph for this function:

size()

template<class V = Vuint, class Tag = Vuint>

size_t mie::ZmZ< V, Tag >::size ( ) const

inline

Definition at line 1330 of file zm.h.

{ return v_.size(); }

Here is the caller graph for this function:

sub()

template<class V = Vuint, class Tag = Vuint>

static void mie::ZmZ< V, Tag >::sub ( ZmZ< V, Tag > & out, const ZmZ< V, Tag > & x, const ZmZ< V, Tag > & y )

inlinestatic

Definition at line 1243 of file zm.h.

    {
        if (x.v_ < y.v_) {
            if (&out != &y) {
                V::add(out.v_, x.v_, m_);
                out.v_ -= y.v_;
            } else {
                V t = x.v_ + m_;
                out.v_ = t - y.v_;
            }
        } else {
            V::sub(out.v_, x.v_, y.v_);
        }
    }

Here is the caller graph for this function:

toString()

template<class V = Vuint, class Tag = Vuint>

std::string mie::ZmZ< V, Tag >::toString ( int base = 10 ) const

inline

Definition at line 1324 of file zm.h.

    {
        return v_.toString(base);
    }

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator<<

template<class V = Vuint, class Tag = Vuint>

std::ostream & operator<< ( std::ostream & os, const ZmZ< V, Tag > & x )

friend

Definition at line 1282 of file zm.h.

    {
        return os << x.v_;
    }

---

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

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