integer.cc

Gambit 是一个游戏库理论软件

int operator <  (const gInteger&  x, const gInteger&  y)
{
  return compare(x, y) <  0; 
}

int operator <  (const gInteger&  x, long y)
{
  return compare(x, y) <  0; 
}

int operator <= (const gInteger&  x, const gInteger&  y)
{
  return compare(x, y) <= 0; 
}

int operator <= (const gInteger&  x, long y)
{
  return compare(x, y) <= 0; 
}

int operator >  (const gInteger&  x, const gInteger&  y)
{
  return compare(x, y) >  0; 
}

int operator >  (const gInteger&  x, long y)
{
  return compare(x, y) >  0; 
}

int operator >= (const gInteger&  x, const gInteger&  y)
{
  return compare(x, y) >= 0; 
}

int operator >= (const gInteger&  x, long y)
{
  return compare(x, y) >= 0; 
}


void  gInteger::operator += (const gInteger& y)
{
  add(*this, y, *this);
}

void  gInteger::operator += (long y)
{
  add(*this, y, *this);
}

void gInteger::operator ++ ()
{
  add(*this, 1, *this);
}


void  gInteger::operator -= (const gInteger& y)
{
  sub(*this, y, *this);
}

void  gInteger::operator -= (long y)
{
  sub(*this, y, *this);
}

void gInteger::operator -- ()
{
  add(*this, -1, *this);
}



void gInteger::operator *= (const gInteger& y)
{
  mul(*this, y, *this);
}

void gInteger::operator *= (long y)
{
  mul(*this, y, *this);
}


void  gInteger::operator &= (const gInteger& y)
{
  And(*this, y, *this);
}

void  gInteger::operator &= (long y)
{
  And(*this, y, *this);
}

void  gInteger::operator |= (const gInteger& y)
{
  Or(*this, y, *this);
}

void  gInteger::operator |= (long y)
{
  Or(*this, y, *this);
}


void  gInteger::operator ^= (const gInteger& y)
{
  Xor(*this, y, *this);
}

void  gInteger::operator ^= (long y)
{
  Xor(*this, y, *this);
}



void gInteger::operator /= (const gInteger& y)
{
  div(*this, y, *this);
}

void gInteger::operator /= (long y)
{
  div(*this, y, *this);
}


void gInteger::operator <<= (const gInteger&  y)
{
  lshift(*this, y, *this);
}

void gInteger::operator <<= (long  y)
{
  lshift(*this, y, *this);
}


void gInteger::operator >>= (const gInteger&  y)
{
  rshift(*this, y, *this);
}

void  gInteger::operator >>= (long y)
{
  rshift(*this, y, *this);
}

#ifdef __GNUG__
gInteger operator <? (const gInteger& x, const gInteger& y)
{
  return (compare(x.rep, y.rep) <= 0) ? x : y;
}

gInteger operator >? (const gInteger& x, const gInteger& y)
{
  return (compare(x.rep, y.rep) >= 0)?  x : y;
}
#endif


void gInteger::abs()
{
  ::abs(*this, *this);
}

void gInteger::negate()
{
  ::negate(*this, *this);
}


void gInteger::complement()
{
  ::complement(*this, *this);
}


int sign(const gInteger& x)
{
  return (x.rep->len == 0) ? 0 : ( (x.rep->sgn == 1) ? 1 : -1 );
}

int even(const gInteger& y)
{
  return y.rep->len == 0 || !(y.rep->s[0] & 1);
}

int odd(const gInteger& y)
{
  return y.rep->len > 0 && (y.rep->s[0] & 1);
}

char* Itoa(const gInteger& y, int base, int width)
{
  return Itoa(y.rep, base, width);
}



long lg(const gInteger& x) 
{
  return lg(x.rep);
}

// constructive operations 

#if defined(__GNUG__) && !defined(NO_NRV)

gInteger  operator +  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  add(x, y, r);
  return r;
}

gInteger  operator +  (const gInteger& x, long y)
{
  gInteger r;
  add(x, y, r);
  return r;
}

gInteger  operator +  (long  x, const gInteger& y)
{
  gInteger r;
  add(x, y, r);
  return r;
}

gInteger  operator -  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  sub(x, y, r);
  return r;
}

gInteger  operator -  (const gInteger& x, long y)
{
  gInteger r;
  sub(x, y, r);
  return r;
}

gInteger  operator -  (long  x, const gInteger& y)
{
  gInteger r;
  sub(x, y, r);
  return r;
}

gInteger  operator *  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  mul(x, y, r);
  return r;
}

gInteger  operator *  (const gInteger& x, long y)
{
  gInteger r;
  mul(x, y, r);
  return r;
}

gInteger  operator *  (long  x, const gInteger& y)
{
  gInteger r;
  mul(x, y, r);
  return r;
}

gInteger sqr(const gInteger& x) 
{
  gInteger r;
  mul(x, x, r);
  return r;
}

gInteger  operator &  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  And(x, y, r);
  return r;
}

gInteger  operator &  (const gInteger& x, long y)
{
  gInteger r;
  And(x, y, r);
  return r;
}

gInteger  operator &  (long  x, const gInteger& y)
{
  gInteger r; 
  And(x, y, r);
  return r;
}

gInteger  operator |  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  Or(x, y, r);
  return r;
}

gInteger  operator |  (const gInteger& x, long y)
{
  gInteger r;
  Or(x, y, r);
  return r;
}

gInteger  operator |  (long  x, const gInteger& y)
{
  gInteger r;
  Or(x, y, r);
  return r;
}

gInteger  operator ^  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  Xor(x, y, r);
  return r;
}

gInteger  operator ^  (const gInteger& x, long y)
{
  gInteger r;
  Xor(x, y, r);
  return r;
}

gInteger  operator ^  (long  x, const gInteger& y)
{
  gInteger r;
  Xor(x, y, r);
  return r;
}

gInteger  operator /  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  div(x, y, r);
  return r;
}

gInteger operator /  (const gInteger& x, long y)
{
  gInteger r;
  div(x, y, r);
  return r;
}

gInteger operator %  (const gInteger& x, const gInteger& y) 
{
  gInteger r;
  mod(x, y, r);
  return r;
}

gInteger operator %  (const gInteger& x, long y)
{
  gInteger r;
  mod(x, y, r);
  return r;
}

gInteger operator <<  (const gInteger& x, const gInteger& y)
{
  gInteger r;
  lshift(x, y, r);
  return r;
}

gInteger operator <<  (const gInteger& x, long y)
{
  gInteger r;
  lshift(x, y, r);
  return r;
}

gInteger operator >>  (const gInteger& x, const gInteger& y) 
{
  gInteger r;
  rshift(x, y, r);
  return r;
}

gInteger operator >>  (const gInteger& x, long y)
{
  gInteger r;
  rshift(x, y, r);
  return r;
}

gInteger pow(const gInteger& x, long y)
{
  gInteger r;
  pow(x, y, r);
  return r;
}

gInteger Ipow(long x, long y)
{
  gInteger r(x);
  pow(r, y, r);
  return r;
}

gInteger pow(const gInteger& x, const gInteger& y) 
{
  gInteger r;
  pow(x, y, r);
  return r;
}



gInteger abs(const gInteger& x) 
{
  gInteger r;
  abs(x, r);
  return r;
}

gInteger operator - (const gInteger& x)
{
  gInteger r;
  negate(x, r);
  return r;
}

gInteger operator ~ (const gInteger& x) 
{
  gInteger r;
  complement(x, r);
  return r;
}

gInteger  atoI(const char* s, int base) 
{
  gInteger r;
  r.rep = atoIntRep(s, base);
  return r;
}

gInteger  gcd(const gInteger& x, const gInteger& y)
{
  gInteger r;
  r.rep = gcd(x.rep, y.rep);
  return r;
}

#else /* NO_NRV */

gInteger  operator +  (const gInteger& x, const gInteger& y) 
{
  gInteger r; add(x, y, r); return r;
}

gInteger  operator +  (const gInteger& x, long y) 
{
  gInteger r; add(x, y, r); return r;
}

gInteger  operator +  (long  x, const gInteger& y) 
{
  gInteger r; add(x, y, r); return r;
}

gInteger  operator -  (const gInteger& x, const gInteger& y) 
{
  gInteger r; sub(x, y, r); return r;
}

gInteger  operator -  (const gInteger& x, long y) 
{
  gInteger r; sub(x, y, r); return r;
}

gInteger  operator -  (long  x, const gInteger& y) 
{
  gInteger r; sub(x, y, r); return r;
}

gInteger  operator *  (const gInteger& x, const gInteger& y) 
{
  gInteger r; mul(x, y, r); return r;
}

gInteger  operator *  (const gInteger& x, long y) 
{
  gInteger r; mul(x, y, r); return r;
}

gInteger  operator *  (long  x, const gInteger& y) 
{
  gInteger r; mul(x, y, r); return r;
}

gInteger sqr(const gInteger& x) 
{
  gInteger r; mul(x, x, r); return r;
}

gInteger  operator &  (const gInteger& x, const gInteger& y) 
{
  gInteger r; And(x, y, r); return r;
}

gInteger  operator &  (const gInteger& x, long y) 
{
  gInteger r; And(x, y, r); return r;
}

gInteger  operator &  (long  x, const gInteger& y) 
{
  gInteger r; And(x, y, r); return r;
}

gInteger  operator |  (const gInteger& x, const gInteger& y) 
{
  gInteger r; Or(x, y, r); return r;
}

gInteger  operator |  (const gInteger& x, long y) 
{
  gInteger r; Or(x, y, r); return r;
}

gInteger  operator |  (long  x, const gInteger& y) 
{
  gInteger r; Or(x, y, r); return r;
}

gInteger  operator ^  (const gInteger& x, const gInteger& y) 
{
  gInteger r; Xor(x, y, r); return r;
}

gInteger  operator ^  (const gInteger& x, long y) 
{
  gInteger r; Xor(x, y, r); return r;
}

gInteger  operator ^  (long  x, const gInteger& y) 
{
  gInteger r; Xor(x, y, r); return r;
}

gInteger  operator /  (const gInteger& x, const gInteger& y) 
{
  gInteger r; div(x, y, r); return r;
}

gInteger operator /  (const gInteger& x, long y) 
{
  gInteger r; div(x, y, r); return r;
}

gInteger operator %  (const gInteger& x, const gInteger& y) 
{
  gInteger r; mod(x, y, r); return r;
}

gInteger operator %  (const gInteger& x, long y) 
{
  gInteger r; mod(x, y, r); return r;
}

gInteger operator <<  (const gInteger& x, const gInteger& y) 
{
  gInteger r; lshift(x, y, r); return r;
}

gInteger operator <<  (const gInteger& x, long y) 
{
  gInteger r; lshift(x, y, r); return r;
}

gInteger operator >>  (const gInteger& x, const gInteger& y) 
{
  gInteger r; rshift(x, y, r); return r;
}

gInteger operator >>  (const gInteger& x, long y) 
{
  gInteger r; rshift(x, y, r); return r;
}

gInteger pow(const gInteger& x, long y) 
{
  gInteger r; pow(x, y, r); return r;
}

gInteger Ipow(long x, long y) 
{
  gInteger r(x); pow(r, y, r); return r;
}

gInteger pow(const gInteger& x, const gInteger& y) 
{
  gInteger r; pow(x, y, r); return r;
}



gInteger abs(const gInteger& x) 
{
  gInteger r; abs(x, r); return r;
}

gInteger operator - (const gInteger& x) 
{
  gInteger r; negate(x, r); return r;
}

gInteger operator ~ (const gInteger& x) 
{
  gInteger r; complement(x, r); return r;
}

gInteger  atoI(const char* s, int base) 
{
  gInteger r; r.rep = atoIntRep(s, base); return r;
}

gInteger  gcd(const gInteger& x, const gInteger& y) 
{
  gInteger r; r.rep = gcd(x.rep, y.rep); return r;
}

#endif  /* NO_NRV */

void gInteger::operator %= (const gInteger& y)
{
  *this = *this % y; // mod(*this, y, *this) doesn't work.
}

void gInteger::operator %= (long y)
{
  *this = *this % y; // mod(*this, y, *this) doesn't work.
}

gText ToText(const gInteger &i)
{
  return gText(Itoa(i));
}