Scl_mpz.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of BORDERBASIX software. *
*      (C) B. Mourrain, GALAAD, INRIA                                *
**********************************************************************
History: 
$Id: Scl_mpz.hpp,v 1.1.1.1 2006/10/06 08:01:40 trebuche Exp $
**********************************************************************/
#ifndef _SCL_MPZ_H_
#define _SCL_MPZ_H_
//----------------------------------------------------------------------
#include <string>
#include "Scl.hpp"
//----------------------------------------------------------------------
typedef MP_INT   MPZ;
#define _MPZ_
//----------------------------------------------------------------------
//  template<> inline
//  shared_object<MPZ>::rep::~rep()           
//  {
//    //COUT <<"Delete mpz"<<endl;
//    mpz_clear(&obj);
//  }
//----------------------------------------------------------------------
template<> inline Scl<MPZ>::~Scl ( )      
{ 
  //COUT <<"Delete mpz"<<endl;
  mpz_clear(&rep());
}
//----------------------------------------------------------------------
template<> inline
void Scl<MPZ>::init ( )                   
{ 
  //COUT <<"Init mpz"<<endl;
  mpz_init(&rep());
}
//------------------- Scl<T> (...) -------------------------------------
template<> inline
Scl<MPZ>::Scl () //: data()            
{
  //COUNT<MPZ>(' ');
  mpz_init(&rep());
}
//----------------------------------------------------------------------
template<> inline
Scl<MPZ>::Scl (signed long int sl): data()  {mpz_init_set_si(&rep(),sl);}
//----------------------------------------------------------------------
template<> inline
Scl<MPZ>::Scl (unsigned long int ul): data() {mpz_init_set_ui(&rep(),ul);}
//----------------------------------------------------------------------
template<> inline
Scl<MPZ>::Scl (int si): data()               {mpz_init_set_si(&rep(), si);}
//----------------------------------------------------------------------
template<> inline
Scl<MPZ>::Scl (const char *str, unsigned int base): data()
{
  if (mpz_init_set_str(&rep(), str, base))
    std::cerr << "Scl<MPZ>: The string " << str
         << " is not a valid number in base " << base << std::endl;
}
//----------------------------------------------------------------------
template<> inline
Scl<MPZ>::Scl (const Scl<MPZ> & rhs)
{
  //COUT <<"Init mpz"<<endl;
  //COUNT<MPZ>('c');
  mpz_init_set(&rep(), &rhs.rep());      
}
//{ data=b.data;}
//----------------------------------------------------------------------
template<> inline 
Scl<MPZ> Scl<MPZ>::operator =  (const Scl<MPZ>& rhs)
{
  //COUNT<MPZ>('=');
  if (this != &rhs) mpz_set(&rep(), &rhs.rep()); 
  return *this;
}
// == ------------------------------------------------------------------
template<> inline 
bool Scl<MPZ>::operator == (const Scl<MPZ>& rhs) const
{
  return mpz_cmp(&rep(), &rhs.rep()) == 0;
}

template<> inline 
bool Scl<MPZ>::operator == (long sl) const {
  return mpz_cmp_si(&rep(), sl) == 0;
}

template<> inline 
bool Scl<MPZ>::operator == (int si) const {
  return mpz_cmp_si(&rep(), (long) si) == 0;
}

template<> inline 
bool Scl<MPZ>::operator == (unsigned long ul) const
{
  return mpz_cmp_ui(&rep(), ul) == 0;
}

// != ------------------------------------------------------------------
template<> inline 
bool Scl<MPZ>::operator != (const Scl<MPZ>& rhs) const
{
  return mpz_cmp(&rep(), &rhs.rep()) != 0;
}

template<> inline 
bool Scl<MPZ>::operator != (long sl) const {
  return mpz_cmp_si(&rep(), sl) != 0;
}

template<> inline
bool Scl<MPZ>::operator != (int si) const {
  return mpz_cmp_si(&rep(), (long) si) != 0;
}

template<> inline 
bool Scl<MPZ>::operator != (unsigned long ul) const
{
  return mpz_cmp_ui(&rep(), ul) != 0;
}
// > -------------------------------------------------------------------
template<> inline 
bool Scl<MPZ>::operator > (const Scl<MPZ>& rhs) const
{
  return mpz_cmp(&rep(), &rhs.rep()) > 0;
}

template<> inline 
bool Scl<MPZ>::operator > (long sl) const {
  return mpz_cmp_si(&rep(), sl) > 0;
}

template<> inline 
bool Scl<MPZ>::operator > (int si) const {
  return mpz_cmp_si(&rep(), (long) si) > 0;
}

template<> inline 
bool Scl<MPZ>::operator > (unsigned long ul) const
{
  return mpz_cmp_ui(&rep(), ul) > 0;
}
// <= --------------------------------------------------------------------
template<> inline 
bool Scl<MPZ>::operator >= (const Scl<MPZ>& rhs) const
{
  return mpz_cmp(&rep(), &rhs.rep()) >= 0;
}

template<> inline 
bool Scl<MPZ>::operator >= (long sl) const {
  return mpz_cmp_si(&rep(), sl) >= 0;
}

template<> inline 
bool Scl<MPZ>::operator >= (int si) const
{
  return mpz_cmp_si(&rep(), (long) si) >= 0;
}

template<> inline 
bool Scl<MPZ>::operator >= (unsigned long ul) const
{
  return mpz_cmp_ui(&rep(), ul) >= 0;
}

// < -------------------------------------------------------------------
template<> inline 
bool Scl<MPZ>::operator < (const Scl<MPZ>& rhs) const
{
  return mpz_cmp(&rep(), &rhs.rep()) < 0;
}

template<> inline 
bool Scl<MPZ>::operator < (long sl) const {
  return mpz_cmp_si(&rep(), sl) < 0;
}

template<> inline 
bool Scl<MPZ>::operator < (int si) const
{
  return mpz_cmp_si(&rep(), (long) si) < 0;
}

template<> inline 
bool Scl<MPZ>::operator < (unsigned long ul) const
{
  return mpz_cmp_ui(&rep(), ul) < 0;
}

// <= ------------------------------------------------------------------

template<> inline 
bool Scl<MPZ>::operator <= (const Scl<MPZ>& rhs) const
{
  return mpz_cmp(&rep(), &rhs.rep()) <= 0;
}

template<> inline 
bool Scl<MPZ>::operator <= (long sl) const {
  return mpz_cmp_si(&rep(), sl) <= 0;
}

template<> inline 
bool Scl<MPZ>::operator <= (int si) const
{
  return mpz_cmp_si(&rep(), (long) si) <= 0;
}

template<> inline 
bool Scl<MPZ>::operator <= (unsigned long ul) const
{
  return mpz_cmp_ui(&rep(), ul) <= 0;
}

// = -------------------------------------------------------------------
template<> inline 
Scl<MPZ>  Scl<MPZ>::operator =  (unsigned long ul)
{
  mpz_set_ui(&rep(), ul); return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator =  (long sl)
{
  mpz_set_si(&rep(), sl);  return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator = (int ul)
{
  mpz_init_set_si(&(this->rep()), ul);  return *this;
}
// += -------------------------------------------------------------------
template<> inline 
Scl<MPZ> Scl<MPZ>::operator += (const Scl<MPZ>& rhs)
{
  mpz_add(&rep(), &rep(), &rhs.rep());  return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator += (unsigned long ul)
{
  mpz_add_ui(&rep(), &rep(), ul); return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator += (long sl)
{
  if (sl >= 0)
    mpz_add_ui(&rep(), &rep(), (unsigned long) sl);
  else
    mpz_sub_ui(&rep(), &rep(), ((unsigned long) -sl));
  return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator += (int ul)
{
  *this += Scl<MPZ>(ul);  return *this;
}

// -= -------------------------------------------------------------------
template<> inline 
Scl<MPZ> Scl<MPZ>::operator -= (const Scl<MPZ>& rhs)
{
  mpz_sub(&rep(), &rep(), &rhs.rep()); return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator -= (unsigned long ul)
{
  mpz_sub_ui(&rep(), &rep(), ul); return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator -= (long sl)
{
  if (sl >= 0)
    mpz_sub_ui(&rep(), &rep(), (unsigned long) sl);
  else
    mpz_add_ui(&rep(), &rep(), (unsigned long) sl);
  return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator -= (int ul)
{
  *this -= Scl<MPZ>(ul); return *this;
}
// *= -----------------------------------------------------------------
template<> inline 
Scl<MPZ> Scl<MPZ>::operator *= (const Scl<MPZ>& rhs)
{
  mpz_mul(&rep(), &rep(), &rhs.rep()); return *this;
}
template<> inline 
Scl<MPZ> Scl<MPZ>::operator *= (unsigned long ul)
{
  mpz_mul_ui(&rep(), &rep(), ul); return *this;
}
template<> inline 
Scl<MPZ> Scl<MPZ>::operator *= (long sl)
{
  if (sl >= 0)
    mpz_mul_ui(&rep(), &rep(), (unsigned long) sl);
  else
    {
      rep()._mp_size = -rep()._mp_size;
      mpz_mul_ui(&rep(), &rep(), ((unsigned long) -sl));
    }
  return *this; 
}
template<> inline 
Scl<MPZ> Scl<MPZ>::operator *= (int ul)
{
   if (ul >= 0)
     mpz_mul_ui(&rep(), &rep(), (unsigned long) ul);
   else {
     mpz_mul_ui(&rep(), &rep(), (unsigned long) (-ul));
     mpz_neg(&rep(), &rep());
   }
   return *this;
}
// /= ------------------------------------------------------------------
template<> inline 
Scl<MPZ> Scl<MPZ>::operator /= (const Scl<MPZ>& rhs)
{
  mpz_div(&rep(), &rep(), &rhs.rep());
  //mpz_divexact(&rep(), &rep(), &rhs.rep()); 
  return *this;
}
template<> inline 
Scl<MPZ> Scl<MPZ>::operator /= (unsigned long ul)
{
  mpz_div_ui(&rep(), &rep(), ul); return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator /= (long sl)
{
  if (sl >= 0)
    mpz_div_ui(&rep(), &rep(), (unsigned long) sl);
  else
    {
      rep()._mp_size = -rep()._mp_size;
      mpz_div_ui(&rep(), &rep(), ((unsigned long) -sl));
    }
  return *this;
}

// %= ------------------------------------------------------------------
template<> inline 
Scl<MPZ> Scl<MPZ>::operator %= (const Scl<MPZ>& rhs)
{
  mpz_mod(&rep(), &rep(), &rhs.rep()); return *this;
}

template<> inline 
Scl<MPZ> Scl<MPZ>::operator %= (unsigned long ul)
{
  mpz_mod_ui(&rep(), &rep(), ul); return *this;
}

//======================================================================
// ARITHMETIC OPERATORS
//======================================================================
 Scl<MPZ> operator +(const Scl<MPZ>& a1, const Scl<MPZ>& a2) 
 {
   Scl<MPZ> result;
   mpz_add(&result.rep(), &a1.rep(), &a2.rep());
   return result;
 }

 //----------------------------------------------------------------------
 Scl<MPZ> operator -(const Scl<MPZ>& a1, const Scl<MPZ>& a2) 
 {
   Scl<MPZ> result;
   mpz_sub(&result.rep(), &a1.rep(), &a2.rep());
   return result;
 }

//----------------------------------------------------------------------
 Scl<MPZ> operator *(const Scl<MPZ>& a1, const Scl<MPZ>& a2) 
 {
   Scl<MPZ> result;
   mpz_mul(&result.rep(), &a1.rep(), &a2.rep());
   return result;
 }

//----------------------------------------------------------------------
Scl<MPZ> operator / (const Scl<MPZ>& a, const Scl<MPZ>& b)
{
    Scl<MPZ> r;
    mpz_div(&r.rep(),&a.rep(),&b.rep());
    return r;
  }

//----------------------------------------------------------------------
Scl<MPZ> operator % (const Scl<MPZ>& a, const Scl<MPZ>& b)
{
    Scl<MPZ> r;
    mpz_mod(&r.rep(),&a.rep(),&b.rep());
    return r;
 }
//======================================================================
template<> inline 
void Scl<MPZ>::operator ++ ( )
{
  mpz_add_ui(&rep(), &rep(), 1);
}
//----------------------------------------------------------------------
template<> inline 
void Scl<MPZ>::operator -- ( )
{
  mpz_sub_ui(&rep(), &rep(), 1);
}
//======================================================================
inline void convert(Scl<MPZ>& n, char *s) 
{
  mpz_init_set_str(&n.rep(), s, 10);
}
//======================================================================
// INPUT OUTPUT
//======================================================================
std::ostream& operator << (std::ostream& os, const Scl<MPZ>& b)
{
  mpz_out_str(stdout, 10, &b.rep());
  return os;
}
//----------------------------------------------------------------------
std::istream& operator >> (std::istream& is, Scl<MPZ>& b)
{
  std::string s;is >> s;
  mpz_init_set_str(&b.rep(),s.c_str(), 10);
  return is;
}
//======================================================================
// SPECIAL FUNCTIONS
//======================================================================
template<> inline void
Scl<MPZ>::Div2Exp (unsigned long exponent_of_2)
{
  mpz_div_2exp(&rep(), &rep(), exponent_of_2);
}

template<> inline 
void Scl<MPZ>::GCD (const Scl<MPZ>& b2)
{
    mpz_gcd (&rep(), &rep(), &b2.rep());
}


template<> inline void
Scl<MPZ>::Mod2Exp (unsigned long exponent_of_2)
{
  mpz_mod_2exp(&rep(), &rep(), exponent_of_2);
}

template<> inline void
Scl<MPZ>::Mul2Exp (unsigned long exponent_of_2)
{
  mpz_mul_2exp(&rep(), &rep(), exponent_of_2);
}

template<> inline void
Scl<MPZ>::PowMod (const Scl<MPZ>& exp, const Scl<MPZ>& m)
{
  mpz_powm(&rep(), &rep(), &exp.rep(), &m.rep());
}

template<> inline void
Scl<MPZ>::PowMod (unsigned long exp, const Scl<MPZ>& m)
{
  mpz_powm_ui(&rep(), &rep(), exp, &m.rep());
}

template<> inline void
Scl<MPZ>::abs ( )
{
  if (rep()._mp_size < 0)
    rep()._mp_size = - rep()._mp_size;
}

template<> inline void
Scl<MPZ>::factorial (unsigned long n)
{
  mpz_fac_ui(&rep(), n);
}

template<> inline 
Scl<MPZ>& Scl<MPZ>::negate ( )
{
  rep()._mp_size = - rep()._mp_size; return *this;
}

template<> inline
Scl<MPZ>& Scl<MPZ>::pow (int exp)
{
  mpz_pow_ui(&rep(), &rep(), exp); return *this;
}

template<> inline
Scl<MPZ>& Scl<MPZ>::pow (unsigned long base, unsigned long exp)
{
  mpz_ui_pow_ui(&rep(), base, exp); return *this;
}

template<> inline void
Scl<MPZ>::quo (const Scl<MPZ>& divisor)
{
  mpz_mdiv (&rep(), &rep(), &divisor.rep());
}

template<> inline void
Scl<MPZ>::quo (unsigned long divisor)
{
  mpz_mdiv_ui(&rep(), &rep(), divisor);
}

template<> inline void
Scl<MPZ>::rem (const Scl<MPZ>& divisor)
{
  mpz_mmod(&rep(), &rep(), &divisor.rep());
}

template<> inline unsigned long
Scl<MPZ>::rem (unsigned long divisor)
{
  return mpz_mmod_ui(&rep(), &rep(), divisor);
}

template<> inline void
Scl<MPZ>::sqrt ( )
{
  mpz_sqrt(&rep(), &rep());
}

inline void
SqrtRem (Scl<MPZ>& sqrt, Scl<MPZ>& rem, const Scl<MPZ>& b)
{
  mpz_sqrtrem(&sqrt.rep(), &rem.rep(), &b.rep());
}
 
inline void
QuoRem (Scl<MPZ>& q, Scl<MPZ>& r, const Scl<MPZ>& divdend, const Scl<MPZ>& divisor)
{
  mpz_mdivmod(&q.rep(), &r.rep(), &divdend.rep(), &divisor.rep());
}

inline unsigned long
QuoRem (Scl<MPZ>& q, Scl<MPZ>& r, const Scl<MPZ>& divdend, unsigned long divisor)
{
  return mpz_mdivmod_ui(&q.rep(), &r.rep(), &divdend.rep(), divisor);
}

inline void
DivMod (Scl<MPZ>& q, Scl<MPZ>& r, const Scl<MPZ>& divdend, const Scl<MPZ>& divisor)
{
  mpz_divmod(&q.rep(), &r.rep(), &divdend.rep(), &divisor.rep());
}

inline void
DivMod (Scl<MPZ>& q, Scl<MPZ>& r, const Scl<MPZ>& divdend, unsigned long divisor)
{
  mpz_divmod_ui(&q.rep(), &r.rep(), &divdend.rep(), divisor);
}

inline 
void ExtGCD (Scl<MPZ>& gcd, Scl<MPZ>& a, Scl<MPZ>& b, 
         const Scl<MPZ>& x, const Scl<MPZ>& y)
{
  mpz_gcdext(&gcd.rep(), &a.rep(), &b.rep(), &x.rep(), &y.rep());
}

inline 
void HalfExtGCD (Scl<MPZ>& gcd, Scl<MPZ>& a, 
         const Scl<MPZ>& x, const Scl<MPZ>& y)
{
    mpz_gcdext(&gcd.rep(), &a.rep(), 0, &x.rep(), &y.rep());
}

inline unsigned long BigIntToUL (const Scl<MPZ>& b)
{
  return mpz_get_ui(&b.rep());
}
//-------------------------- BigIntToSL ---------------------------------
inline signed long BigIntToSL (const Scl<MPZ>& b)
{
  return mpz_get_si(&b.rep());
}
//-------------------------- log(...) -----------------------------------
inline size_t log (const Scl<MPZ>& b)
{
  return mpz_size(&b.rep());
}

inline size_t log (const Scl<MPZ>& b, int base)
{
  assert(base >= 2 && base <= 36);
  return mpz_sizeinbase(&b.rep(), base);
}
//-------------------------- sign ---------------------------------------------
inline int sign (const Scl<MPZ>& b)
{
  if (b.rep()._mp_size == 0)
    return 0;
  else
    return b.rep()._mp_size > 0 ? 1 : -1;
}
//-------------------------- compare (...) ------------------------------------
inline int compare (const Scl<MPZ>& b1, const Scl<MPZ>& b2)
{
  return mpz_cmp(&b1.rep(), &b2.rep());
}

inline int compare (const Scl<MPZ>& b, unsigned long ul)
{
  return mpz_cmp_ui(&b.rep(), ul);
}

inline int compare (const Scl<MPZ>& b, long sl)
{
  return mpz_cmp_si(&b.rep(), sl);
}
//-------------------------- IsPositive etc. ----------------------------------
inline bool IsPositive (const Scl<MPZ>& b) {
  return b.rep()._mp_size > 0;
}

inline bool IsNegative (const Scl<MPZ>& b) {
  return b.rep()._mp_size < 0;
}

inline bool IsZero (const Scl<MPZ>& b) {
  return b.rep()._mp_size == 0;
}

inline bool IsOne(const Scl<MPZ>& b) {
  return b.rep()._mp_size == 1 && b.rep()._mp_d[0] == 1;
}

inline bool IsMinusOne (const Scl<MPZ>& b) {
  return b.rep()._mp_size == -1 && b.rep()._mp_d[0] == 1;
}

inline bool IsOdd (const Scl<MPZ>& b) {
  return b.rep()._mp_size != 0 && (b.rep()._mp_d[0] & ((mp_limb_t) 1));
}

inline bool IsEven (const Scl<MPZ>& b) {
  return b.rep()._mp_size == 0 || (b.rep()._mp_d[0] ^ ((mp_limb_t) 0));
}

inline bool IsPerfectSquare (const Scl<MPZ>& b)
{
  return mpz_perfect_square_p(&b.rep());
}

inline bool IsProbablyPrime (const Scl<MPZ>& b, int reps /* = 25 */)
{
  return mpz_probab_prime_p(&b.rep(), reps);
}

bool has_positive_sign(const Scl<MPZ>& x){
    return (x.rep()._mp_size > 0);
}

//----------------------------------------------------------------------
#endif // //SCL_MPZ_H