Tfactor.H

Go to the documentation of this file.

#ifndef CmpqsFactor_header
#define CmpqsFactor_header

#include <cstdlib>
#include <iosfwd>
#include <gmp.h>
#include "utils.H"
#include "mpz_wrapper.H"
using namespace my_mpz_wrapper;

using std::ostream;
using std::istream;

using std::cout;
using std::cerr;

extern const int SingleLargePrime_Threshold;


class CmpqsFactortypes
{
 public:
  enum Factortype { empty, static_prime, single_large_prime, double_large_prime, Factortype_size };
};

class CmpqsFactor : public CmpqsFactortypes
{
 private:

  unsigned int p1,p2; // with p1<=p2

  static double rejected_dlp_counter;

 public:

  static mpz_t DLP_Threshold; // Double-Large-Prime-Threshold; will be initialized in main()

  static inline bool DLP_rejected(const mpz_t n)
   {
     if (mpz_cmp(n,DLP_Threshold)>0)
      {
        rejected_dlp_counter+=1.0;
        return true;
      }
      // also reject probably primes (but do not count them)
      return mpz_probab_prime_p(n,10)!=0;
   }

  bool DLP_get_using_pollard_rho(const mpz_t n); // is somewhat slower than SQUFOF!

  bool DLP_get(const mpz_t n); // using SQUFOF (with fallback to pollard rho)

  inline const CmpqsFactor& operator= (const unsigned int x)
   { p1=0; p2=x; return *this; }

  inline int int_value() const
   {
     // return an integer value (or exit with a error message)
     if (p1)
      {
        cerr << "Cannot assign two integers to a single integer value!" << endl;
        exit(1);
        return 0;
      }
     return p2;
   }

  inline int LP1() const { return p1; }

  inline int LP2() const { return p2; }

  inline void set_for_search(const unsigned int x)
   { 
     // we insert it reverse sorted (to be able to search for x)
     p1=x; p2=0;
   }

  inline void swap(void) { unsigned int h=p1; p1=p2; p2=h; }

  inline void assign_to_mpz(mpz_t x) const
   {
     if (p1==0) { mpz_set_ui(x,p2); return; }
     if (p2==0) { mpz_set_ui(x,p1); return; }
     mpz_set_ui(x,p1); mpz_mul_ui(x,x,p2);
   }

  inline Factortype Type() const
   {
     if (p1>p2)
      { cerr << "CmpqsFactor: unordered factors!" << endl; }
     if (p1==0 && p2==0) return empty;
     if (p1==0 && p2==1) return static_prime;
     if (p1==0) return single_large_prime;
     return double_large_prime;
   }

  inline bool IsTypeOf(const Factortype givenType) const
   {
     return Type()==givenType;
   }

  inline bool DLP_divisible_by(const unsigned int x) const
   { return p1==x || p2==x; }

  inline bool operator< (const CmpqsFactor &x) const
   {
     if (p1==x.p1) return p2<x.p2;
     else return p1<x.p1;
   }

  inline bool operator== (const CmpqsFactor &x) const
   {
     return (p1==x.p1 && p2==x.p2); // componentwise identity
   }

  inline bool operator!= (const CmpqsFactor &x) const
   {
     return !((*this)==x);
   }

  inline int operator/ (const unsigned int u) const
   {
     // return p1*p2/u, in other words: just the other factor...
     if (p1==u) return p2;
     if (p2==u) return p1;
     cerr << "CmpqsFactor: invalid division!" << endl;
     exit(1);
     return 0;
   }

  friend ostream& operator<< (ostream &ostr, const CmpqsFactor &x);

  friend istream& operator>> (istream &istr, CmpqsFactor &x);
};


inline ostream& operator<< (ostream &ostr, const CmpqsFactor &x)
{
   if (x.p1) ostr << x.p1 << "*" << x.p2;
   else ostr << x.p2;
   return ostr;
}

#endif

---