mie::VuintT< Buffer > Struct Template Reference

#include <zm.h>

Inheritance diagram for mie::VuintT< Buffer >:

Collaboration diagram for mie::VuintT< Buffer >:

Public Types
typedef local::PrimitiveFunction	F
typedef Buffer::value_type	T

Public Member Functions
	VuintT (T x=0)
	VuintT (const std::string &str)
	VuintT (const uint32_t *x, size_t size)
	VuintT (const uint64_t *x, size_t size)
void	set (T x)
void	set (const uint32_t *x, size_t size)
void	set (const uint64_t *x, size_t size)
T	getAtWithCheck (size_t i) const
void	clear ()
std::string	toString (int base=10) const
void	set (const std::string &str, int base=0)
void	fromStr (const std::string &str, int base=10)
std::string	toStr (int base=10) const
size_t	size () const
bool	isZero () const
size_t	bitLen () const
bool	testBit (size_t i) const
void	trim ()
Public Member Functions inherited from mie::local::dividable< VuintT< Buffer >, local::addsubmul< VuintT< Buffer >, local::comparable< VuintT< Buffer >, local::shiftable< VuintT< Buffer >, Buffer > > > >
MIE_FORCE_INLINE VuintT< Buffer > &	operator/= (const VuintT< Buffer > &rhs)
MIE_FORCE_INLINE VuintT< Buffer > &	operator%= (const VuintT< Buffer > &rhs)
Public Member Functions inherited from mie::local::addsubmul< VuintT< Buffer >, local::comparable< VuintT< Buffer >, local::shiftable< VuintT< Buffer >, Buffer > > >
MIE_FORCE_INLINE VuintT< Buffer > &	operator+= (const N &rhs)
MIE_FORCE_INLINE VuintT< Buffer > &	operator-= (const VuintT< Buffer > &rhs)
MIE_FORCE_INLINE VuintT< Buffer > &	operator*= (const VuintT< Buffer > &rhs)
Public Member Functions inherited from mie::local::shiftable< VuintT< Buffer >, Buffer >
MIE_FORCE_INLINE VuintT< Buffer >	operator<< (size_t n) const
MIE_FORCE_INLINE VuintT< Buffer >	operator>> (size_t n) const
MIE_FORCE_INLINE VuintT< Buffer > &	operator<<= (size_t n)
MIE_FORCE_INLINE VuintT< Buffer > &	operator>>= (size_t n)

Static Public Member Functions
static int	compare (const VuintT &x, const VuintT &y)
static bool	add_in (VuintT &out, const VuintT &x, const VuintT &y)
static void	add (VuintT &out, const VuintT &x, const VuintT &y)
static void	add (VuintT &out, const VuintT &x, uint32_t y)
static bool	sub_in (VuintT &out, const VuintT &x, const VuintT &y)
static void	sub (VuintT &out, const VuintT &x, const VuintT &y)
static void	mul1 (VuintT &out, const VuintT &x, T y)
static void	mul (VuintT &out, const VuintT &x, const VuintT &y)
static T	div1 (VuintT *q, const VuintT &x, T y)
static bool	div (VuintT *q, VuintT &r, const VuintT &x, const VuintT &y)
static void	shlUnit (VuintT &out, const VuintT &x, size_t n)
static void	shlBit (VuintT &out, const VuintT &x, size_t n)
static void	shrUnit (VuintT &out, const VuintT &x, size_t n)
static void	shrBit (VuintT &out, const VuintT &x, size_t n)
static void	shl (VuintT &out, const VuintT &x, size_t n)
static void	shr (VuintT &out, const VuintT &x, size_t n)
static void	mul (T *out, const T *x, size_t xn, const T *y, size_t yn)
static void	div (T *q, T *x, size_t xn, const T *y, size_t yn)

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

Detailed Description

template<class Buffer>
struct mie::VuintT< Buffer >

unsigned integer with variable length

Definition at line 318 of file zm.h.

Member Typedef Documentation

F

template<class Buffer >

local::PrimitiveFunction mie::VuintT< Buffer >::F

Definition at line 322 of file zm.h.

T

template<class Buffer >

Buffer::value_type mie::VuintT< Buffer >::T

Definition at line 323 of file zm.h.

Constructor & Destructor Documentation

VuintT() [1/4]

template<class Buffer >

mie::VuintT< Buffer >::VuintT ( T x = 0 )

inline

Definition at line 325 of file zm.h.

    {
        set(x);
    }

VuintT() [2/4]

template<class Buffer >

mie::VuintT< Buffer >::VuintT ( const std::string & str )

inlineexplicit

Definition at line 329 of file zm.h.

    {
        set(str);
    }

VuintT() [3/4]

template<class Buffer >

mie::VuintT< Buffer >::VuintT ( const uint32_t * x, size_t size )

inline

Definition at line 333 of file zm.h.

    {
        set(x, size);
    }

Here is the call graph for this function:

VuintT() [4/4]

template<class Buffer >

mie::VuintT< Buffer >::VuintT ( const uint64_t * x, size_t size )

inline

Definition at line 337 of file zm.h.

    {
        set(x, size);
    }

Here is the call graph for this function:

Member Function Documentation

add() [1/2]

template<class Buffer >

static void mie::VuintT< Buffer >::add ( VuintT< Buffer > & out, const VuintT< Buffer > & x, const VuintT< Buffer > & y )

inlinestatic

Definition at line 564 of file zm.h.

    {
        bool c = add_in(out, x, y);
        if (c) {
            out.alloc(out.size() + 1);
            out[out.size() - 1] = 1;
        } else {
            out.trim();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

add() [2/2]

template<class Buffer >

static void mie::VuintT< Buffer >::add ( VuintT< Buffer > & out, const VuintT< Buffer > & x, uint32_t y )

inlinestatic

Definition at line 574 of file zm.h.

    {
        const size_t n = x.size();
        out.alloc(n);
        bool c = F::add1(&out[0], &x[0], n, y);
        if (c) {
            out.alloc(n + 1);
            out[n] = 1;
        }
    }

Here is the call graph for this function:

add_in()

template<class Buffer >

static bool mie::VuintT< Buffer >::add_in ( VuintT< Buffer > & out, const VuintT< Buffer > & x, const VuintT< Buffer > & y )

inlinestatic

Definition at line 547 of file zm.h.

    {
        const VuintT *px = &x;
        const VuintT *py = &y;
        if (y.size() > x.size()) {
            std::swap(px, py);
        }
        size_t max = px->size();
        size_t min = py->size();
        out.alloc(max);
        bool c = F::addN(&out[0], &(*px)[0], &(*py)[0], min);
        if (max > min) {
            c = F::add1(&out[min], &(*px)[min], max - min, c);
        }
        return c;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bitLen()

template<class Buffer >

size_t mie::VuintT< Buffer >::bitLen ( ) const

inline

Definition at line 526 of file zm.h.

    {
        if (isZero()) return 0;
 
        size_t size = this->size();
        T v = (*this)[size - 1];
        union di t;
        t.f = (double)v;
        size_t ret = 1 + (size_t(t.i >> 52) - (1 << 10) + 1) +
            (size - 1) * sizeof(T) * 8;
        return ret;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

template<class Buffer >

void mie::VuintT< Buffer >::clear ( )

inline

Definition at line 406 of file zm.h.

{ set((T)0); }

Here is the caller graph for this function:

compare()

template<class Buffer >

static int mie::VuintT< Buffer >::compare ( const VuintT< Buffer > & x, const VuintT< Buffer > & y )

inlinestatic

Definition at line 515 of file zm.h.

    {
        return F::compare(&x[0], x.size(), &y[0], y.size());
    }

Here is the call graph for this function:

div() [1/2]

template<class Buffer >

static void mie::VuintT< Buffer >::div ( T * q, T * x, size_t xn, const T * y, size_t yn )

inlinestatic

Definition at line 926 of file zm.h.

    {
        assert(xn >= yn && yn >= 2);
        if (q) {
            std::fill(q, q + xn - yn + 1, 0);
        }
        Buffer t;
        t.alloc(yn + 1);
        double yt = GetApp(y, yn, true);
        while (F::compare(x, xn, y, yn) >= 0) {
            size_t len = yn;
            double xt = GetApp(x, xn, false);
            if (F::compare(&x[xn - len], yn, y, yn) < 0) {
                xt *= double(1ULL << (sizeof(T) * 8 - 1)) * 2;
                len++;
            }
            T qt = T(xt / yt);
            if (qt == 0) qt = 1;
            F::mul1(&t[0], y, yn, qt);
            bool b = F::subN(&x[xn - len], &x[xn - len], &t[0], len);
            if (b) {
                assert(!b);
            }
            if (q) q[xn - len] += qt;
 
            while (xn >= yn && x[xn - 1] == 0) {
                xn--;
            }
        }
    }

div() [2/2]

template<class Buffer >

static bool mie::VuintT< Buffer >::div ( VuintT< Buffer > * q, VuintT< Buffer > & r, const VuintT< Buffer > & x, const VuintT< Buffer > & y )

inlinestatic

Parameters

q	[out] x / y if q != 0
r	[out] x % y

Return values

true	if y != 0 @retavl false if y == 0

Definition at line 661 of file zm.h.

    {
//std::cout << "x=" << x << std::endl;
//std::cout << "y=" << y << std::endl;
        assert(q != &r);
        const size_t xn = x.size();
        const size_t yn = y.size();
        if (yn == 1) {
            if (y[0] == 0) return false;
            r.set(div1(q, x, y[0]));
            return true;
        }
        int cmp = F::compare(&x[0], xn, &y[0], yn);
        if (cmp < 0) {
            if (&r != &x) {
                r = x;
            }
            if (q) q->clear();
        } else if (cmp == 0) {
            // imply &x == &y
            if (q) q->set(1);
            r.clear();
        } else {
            assert(&x != &y);
            VuintT qt;
            Unit *pqt = 0;
            bool directQ = false;
            if (q == 0) {
                pqt = 0;
            } else if (q != &x && q != &y) {
                q->alloc(xn - yn + 1);
                pqt = &(*q)[0];
                directQ = true;
            } else {
                qt.alloc(xn - yn + 1);
                pqt = &qt[0];
            }
            VuintT rt;
            Unit *prt = 0;
            bool directR = false;
            if (&r != &x && &r != &y) {
                r = x;
                directR = true;
                prt = &r[0];
            } else {
                rt = x;
                prt = &rt[0];
            }
            div(pqt, prt, xn, &y[0], yn);
            if (q) {
                if (directQ) {
                    q->trim();
                } else {
                    qt.trim();
                    q->moveFrom(qt);
                }
            }
            if (directR) {
                r.trim();
            } else {
                rt.trim();
                r.moveFrom(rt);
            }
        }
//puts("out");
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

div1()

template<class Buffer >

static T mie::VuintT< Buffer >::div1 ( VuintT< Buffer > * q, const VuintT< Buffer > & x, T y )

inlinestatic

Parameters

q	[out] q = x / y
x	[in]
y	[in] must be not zero

Returns

x % y

Definition at line 642 of file zm.h.

    {
        const size_t xn = x.size();
        T r;
        if (q) {
            q->alloc(xn); // assume q is not destroyed if q == x
            r = F::div1(&(*q)[0], &x[0], xn, y);
            q->trim();
        } else {
            r = F::mod1(&x[0], xn, y);
        }
        return r;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

fromStr()

template<class Buffer >

void mie::VuintT< Buffer >::fromStr ( const std::string & str, int base = 10 )

inline

Definition at line 510 of file zm.h.

    {
        set(str, base);
    }

getAtWithCheck()

template<class Buffer >

T mie::VuintT< Buffer >::getAtWithCheck ( size_t i ) const

inline

Definition at line 397 of file zm.h.

    {
        if (i >= this->size()) {
            return 0;
        } else {
            return (*this)[i];
        }
    }

Here is the call graph for this function:

isZero()

template<class Buffer >

bool mie::VuintT< Buffer >::isZero ( ) const

inline

Definition at line 521 of file zm.h.

    {
        return Buffer::size() == 1 && (*this)[0] == 0;
    }

Here is the caller graph for this function:

mul() [1/2]

template<class Buffer >

static void mie::VuintT< Buffer >::mul ( T * out, const T * x, size_t xn, const T * y, size_t yn )

inlinestatic

Definition at line 904 of file zm.h.

    {
        assert(xn > 0 && yn > 0);
        if (yn > xn) {
            std::swap(yn, xn);
            std::swap(x, y);
        }
 
        std::fill(&out[xn + 1], &out[xn + yn], 0);
        F::mul1(&out[0], x, xn, y[0]);
 
#if 1
        T *t2 = (T*)MIE_ALLOCA_(sizeof(T) * (xn + 1));
#else
        Buffer t2;
        t2.alloc(xn + 1);
#endif
        for (size_t i = 1; i < yn; i++) {
            F::mul1(&t2[0], x, xn, y[i]);
            F::addN(&out[i], &out[i], &t2[0], xn + 1);
        }
    }

Here is the call graph for this function:

mul() [2/2]

template<class Buffer >

static void mie::VuintT< Buffer >::mul ( VuintT< Buffer > & out, const VuintT< Buffer > & x, const VuintT< Buffer > & y )

inlinestatic

Definition at line 613 of file zm.h.

    {
        const size_t xn = x.size();
        const size_t yn = y.size();
 
        VuintT xt, yt;
        const Unit *px = &x[0], *py = &y[0];
        if (&out == &x) {
            xt = x;
            px = &xt[0];
        }
        if (&out == &y) {
            if (&x == &y) {
                py = px;
            } else {
                yt = y;
                py = &yt[0];
            }
        }
        out.alloc(xn + yn);
        mul(&out[0], px, xn, py, yn);
        out.trim();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

mul1()

template<class Buffer >

static void mie::VuintT< Buffer >::mul1 ( VuintT< Buffer > & out, const VuintT< Buffer > & x, T y )

inlinestatic

Definition at line 606 of file zm.h.

    {
        const size_t xn = x.size();
        out.alloc(xn + 1);
        F::mul1(&out[0], &x[0], xn, y);
        out.trim();
    }

Here is the call graph for this function:

set() [1/4]

template<class Buffer >

void mie::VuintT< Buffer >::set ( const std::string & str, int base = 0 )

inline

Definition at line 452 of file zm.h.

    {
        std::string t;
        if (str.size() >= 2 && str[0] == '0') {
            switch (str[1]) {
            case 'x':
                if (base != 0 && base != 16) local::errExit("bad base in set(str)");
                base = 16;
                t = str.substr(2);
                break;
            default:
                local::errExit("not support base in set(str) 0x");
            }
        }
        if (base == 0) {
            base = 10;
        }
        if (t.empty()) t = str;
 
        switch (base) {
        case 16:
            {
                std::vector<uint32_t> x;
                while (!t.empty()) {
                    size_t remain = std::min((int)t.size(), 8);
                    char *endp;
                    uint32_t v = strtoul(&t[t.size() - remain], &endp, 16);
                    if (*endp) goto ERR;
                    x.push_back(v);
                    t = t.substr(0, t.size() - remain);
                }
                set(&x[0], x.size());
            }
            break;
        default:
        case 10:
            {
                std::vector<uint32_t> x;
                while (!t.empty()) {
                    size_t remain = std::min((int)t.size(), 9);
                    char *endp;
                    uint32_t v = strtol(&t[t.size() - remain], &endp, 10);
                    if (*endp) goto ERR;
                    x.push_back(v);
                    t = t.substr(0, t.size() - remain);
                }
                clear();
                for (size_t i = 0, n = x.size(); i < n; i++) {
                    (*this) *= 1000000000;
                    (*this) += x[n - 1 - i];
                }
            }
            break;
        }
        return;
    ERR:
        throw std::invalid_argument(std::string("bad digit `") + str + "`");
    }

Here is the call graph for this function:

set() [2/4]

template<class Buffer >

void mie::VuintT< Buffer >::set ( const uint32_t * x, size_t size )

inline

Definition at line 346 of file zm.h.

    {
        Buffer::clear();
        if (size == 0) {
            set((T)0);
            return;
        }
#ifdef MIE_USE_UNIT32
        Buffer::alloc(size);
        for (size_t i = 0; i < size; i++) {
            (*this)[i] = x[i];
        }
#else
        Buffer::alloc((size + 1) / 2);
        for (size_t i = 0; i < size / 2; i++) {
            (*this)[i] = make64(x[i * 2 + 1], x[i * 2]);
        }
        if (size & 1) {
            (*this)[size / 2] = x[size - 1];
        }
#endif
        trim();
    }

Here is the call graph for this function:

set() [3/4]

template<class Buffer >

void mie::VuintT< Buffer >::set ( const uint64_t * x, size_t size )

inline

Definition at line 369 of file zm.h.

    {
        Buffer::clear();
        if (size == 0) {
            set((T)0);
            return;
        }
#ifdef MIE_USE_UNIT32
        Buffer::alloc(size * 2);
        for (size_t i = 0; i < size; i++) {
            uint32_t L, H;
            split64(&H, &L, x[i]);
            (*this)[i * 2 + 0] = L;
            (*this)[i * 2 + 1] = H;
        }
#else
        Buffer::alloc(size);
        for (size_t i = 0; i < size; i++) {
            (*this)[i] = x[i];
        }
#endif
        trim();
    }

Here is the call graph for this function:

set() [4/4]

template<class Buffer >

void mie::VuintT< Buffer >::set ( T x )

inline

Definition at line 341 of file zm.h.

    {
        Buffer::alloc(1);
        (*this)[0] = x;
    }

Here is the caller graph for this function:

shl()

template<class Buffer >

static void mie::VuintT< Buffer >::shl ( VuintT< Buffer > & out, const VuintT< Buffer > & x, size_t n )

inlinestatic

Definition at line 813 of file zm.h.

    {
        if (n == 0) {
            out = x;
        } else {
            const size_t unitSize = sizeof(T) * 8;
            size_t q = n / unitSize;
            size_t r = n % unitSize;
            const VuintT *p = &x;
            if (q) {
                shlUnit(out, x, q);
                p = &out;
            }
            if (r) {
                shlBit(out, *p, r);
            }
        }
    }

Here is the call graph for this function:

shlBit()

template<class Buffer >

static void mie::VuintT< Buffer >::shlBit ( VuintT< Buffer > & out, const VuintT< Buffer > & x, size_t n )

inlinestatic

Definition at line 757 of file zm.h.

    {
        const size_t unitSize = sizeof(T) * 8;
        assert(0 < n && n < unitSize);
        const size_t xn = x.size();
        out.alloc(xn);
 
        T prev = 0;
        size_t rn = unitSize - n;
        for (size_t i = 0; i < xn; i++) {
            T t = x[i];
            out[i] = (t << n) | (prev >> rn);
            prev = t;
        }
        prev >>= rn;
        if (prev) {
            out.alloc(xn + 1);
            out[xn] = prev;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

shlUnit()

template<class Buffer >

static void mie::VuintT< Buffer >::shlUnit ( VuintT< Buffer > & out, const VuintT< Buffer > & x, size_t n )

inlinestatic

Definition at line 743 of file zm.h.

    {
        const size_t xn = x.size();
        out.alloc(xn + n);
        for (int i = (int)xn - 1; i >= 0; i--) {
            out[i + n] = x[i];
        }
        std::fill(&out[0], &out[0] + n, 0);
        out.trim();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

shr()

template<class Buffer >

static void mie::VuintT< Buffer >::shr ( VuintT< Buffer > & out, const VuintT< Buffer > & x, size_t n )

inlinestatic

Definition at line 831 of file zm.h.

    {
        if (n == 0) {
            out = x;
        } else {
            const size_t unitSize = sizeof(T) * 8;
            size_t q = n / unitSize;
            size_t r = n % unitSize;
            const VuintT *p = &x;
            if (q) {
                shrUnit(out, x, q);
                p = &out;
            }
            if (r) {
                shrBit(out, *p, r);
            }
        }
    }

Here is the call graph for this function:

shrBit()

template<class Buffer >

static void mie::VuintT< Buffer >::shrBit ( VuintT< Buffer > & out, const VuintT< Buffer > & x, size_t n )

inlinestatic

Definition at line 798 of file zm.h.

    {
        const size_t unitSize = sizeof(T) * 8;
        assert(0 < n && n < unitSize);
        const size_t xn = x.size();
        T prev = 0;
        size_t rn = unitSize - n;
        out.alloc(xn);
        for (int i = (int)xn - 1; i >= 0; i--) {
            T t = x[i];
            out[i] = (t >> n) | (prev << rn);
            prev = t;
        }
        out.trim();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

shrUnit()

template<class Buffer >

static void mie::VuintT< Buffer >::shrUnit ( VuintT< Buffer > & out, const VuintT< Buffer > & x, size_t n )

inlinestatic

Definition at line 780 of file zm.h.

    {
        const size_t xn = x.size();
        if (xn <= n) {
            out = 0;
        } else {
            out.alloc(xn); // not on because of x may be equal to out
            const size_t on = xn - n;
            for (size_t i = 0; i < on; i++) {
                out[i] = x[i + n];
            }
            out.alloc(on);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

size()

template<class Buffer >

size_t mie::VuintT< Buffer >::size ( ) const

inline

Definition at line 519 of file zm.h.

{ return Buffer::size(); }

Here is the caller graph for this function:

sub()

template<class Buffer >

static void mie::VuintT< Buffer >::sub ( VuintT< Buffer > & out, const VuintT< Buffer > & x, const VuintT< Buffer > & y )

inlinestatic

Definition at line 597 of file zm.h.

    {
        bool c = sub_in(out, x, y);
        if (c) {
            local::errExit("can't sub");
        }
        out.trim();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

sub_in()

template<class Buffer >

static bool mie::VuintT< Buffer >::sub_in ( VuintT< Buffer > & out, const VuintT< Buffer > & x, const VuintT< Buffer > & y )

inlinestatic

Definition at line 584 of file zm.h.

    {
        const size_t xn = x.size();
        const size_t yn = y.size();
        assert(xn >= yn);
        out.alloc(xn);
        bool c = F::subN(&out[0], &x[0], &y[0], yn);
        if (xn > yn) {
            c = F::sub1(&out[yn], &x[yn], xn - yn, c);
        }
        return c;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

testBit()

template<class Buffer >

bool mie::VuintT< Buffer >::testBit ( size_t i ) const

inline

Definition at line 539 of file zm.h.

    {
        size_t unit_pos = i / (sizeof(T) * 8);
        size_t bit_pos  = i % (sizeof(T) * 8);
        T mask = T(1) << bit_pos;
        return ((*this)[unit_pos] & mask) != 0;
    }

Here is the caller graph for this function:

toStr()

template<class Buffer >

std::string mie::VuintT< Buffer >::toStr ( int base = 10 ) const

inline

Definition at line 514 of file zm.h.

{ return toString(base); }

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

template<class Buffer >

std::string mie::VuintT< Buffer >::toString ( int base = 10 ) const

inline

Definition at line 407 of file zm.h.

    {
        std::ostringstream os;
        switch (base) {
        case 10:
            {
                const uint32_t i1e9 = 1000000000U;
                static const VuintT zero = 0;
                VuintT x = *this;
 
                std::vector<uint32_t> t;
                while (x > zero) {
                    uint32_t r = (uint32_t)div1(&x, x, i1e9);
                    t.push_back(r);
                }
                if (t.empty()) {
                    return "0";
                }
                os << t[t.size() - 1];
                for (size_t i = 1, n = t.size(); i < n; i++) {
                    os << std::setfill('0') << std::setw(9) << t[n - 1 - i];
                }
            }
            break;
        case 16:
            {
                os << "0x" << std::hex;
                const size_t n = Buffer::size();
                os << (*this)[n - 1];
                for (size_t i = 1; i < n; i++) {
                    os << std::setfill('0') << std::setw(sizeof(Unit) * 2) << (*this)[n - 1 - i];
                }
            }
            break;
        default:
            local::errExit("toString not support base");
        }
        return os.str();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

trim()

template<class Buffer >

void mie::VuintT< Buffer >::trim ( )

inline

Definition at line 894 of file zm.h.

    {
        // remove leading zero
        assert(Buffer::size());
        int i = (int)Buffer::size() - 1;
        for (; i > 0; i--) {
            if ((*this)[i]) break;
        }
        Buffer::alloc(i ? i + 1: 1);
    }

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator<<

template<class Buffer >

std::ostream & operator<< ( std::ostream & os, const VuintT< Buffer > & x )

friend

Definition at line 728 of file zm.h.

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

operator>>

template<class Buffer >

std::istream & operator>> ( std::istream & is, VuintT< Buffer > & x )

friend

Definition at line 732 of file zm.h.

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

---

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

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