void extended_gcd_Test() {
    std::cout << "extended gcd ... ";
    int gcd, x, y;
    bool pass = true;
    extended_gcd(10,2,gcd,x,y);
    pass &= (gcd==2)&&((10*x + 2*y) == gcd);
    extended_gcd(3458,4864,gcd,x,y);
    pass &= (gcd==38)&&((3458*x + 4864*y) == gcd);
    if(pass) std::cout << "PASS" << std::endl;
    else std::cout << "FAIL" << std::endl;
}
vector <int> residue(int p,int N,int a)
{
    int g=primitive_root(p);
    long long m=discrete_log(g,a,p);
    vector<int> ret;
    if (a==0)
    {
        ret.push_back(0);
        return ret;
    }
    if (m==-1) return ret;
    long long A=N,B=p-1,C=m,x,y;
    long long d=extended_gcd(A,B,x,y);
    if (c%d!=0) return ret;
    x=x*(C/d)%B;
    long long delta=B/d;
    for (int i=0;i<d;i++)
    {
        x=((x+delta)%B+B)%B;
        ret.push_back((int)pow_mod(g,x,p));
    }
    sort(ret.begin(),ret.end());
    ret.erase(unqinue(ret.begin(),ret.end()),ret.end());
    return ret;
}
static std::pair<T, T> extended_gcd(T a, T b) {
    if(b == 0) {
        return std::pair<T, T>(1, 0);
    }
    const auto p = extended_gcd(b, a % b);
    return std::pair<T, T>(p.second, p.first - a / b * p.second);
}
    long long extended_gcd(long long a, long long b, long long& x, long long& y){
        if (!b){
            y = 0, x = 1;
            return a;
        }

        long long g = extended_gcd(b, a % b, y, x);
        y -= ((a / b) * x);
        return g;
    }
Esempio n. 5
0
INT base::invert_mod(base &p)
{
	base u, v, g;
	
	// cout << "base::invert_mod() this=" << *this << endl;
	extended_gcd(p, u, v, g, 0);
	// cout << "base::invert_mod(): gcd = " << g << " = " << u << " * " << *this << " + " << v << " * " << p << endl;
	if (!g.is_one()) {
		return FALSE;
		}
	swap(u);
	// normalize(p);
	return TRUE;
}
int main()
{
    long long int a, b, x, y, r;
    while(scanf("%lld %lld", &a, &b) == 2)
    {
        x = a;
        y = b;
        while(y > 0)
        {
            r = x % y;
            x = y;
            y = r;
        }
        extended_gcd(a, b);
        printf("%lld %lld %lld\n", lastx, lasty, x);
    }
    return 0;
}
Esempio n. 7
0
INT unipoly::is_squarefree(INT verbose_level)
{
	INT f_v = (verbose_level >= 1);
	unipoly a, u, v, g;
	INT d;
	
	a = *this;
	a.derive();
	if (f_v) {
		cout << "unipoly::is_squarefree() derivative p' = " << a << endl;
		}
	extended_gcd(a, u, v, g, verbose_level - 2);
	if (f_v) {
		cout << "unipoly::is_squarefree() gcd(p, p') = " << g << endl;
		}
	d = g.degree();
	if (d >= 1)
		return FALSE;
	else
		return TRUE;
}
 long long mod_inverse(long long a, long long m){
     long long x, y;
     extended_gcd(a, m, x, y);
     return (x + m) % m;
 }
inline long long inverse(int k){
	extended_gcd(k,P); return (x%P+P)%P;
}
void extended_gcd(const int a,const int b){
	if(!b){ x=1; y=0; return; }
	extended_gcd(b,a%b);
	t=x; x=y; y=t-a/b*y;
}
Esempio n. 11
0
 LL modinv(LL a_,LL m_){  //ax === gcd(a,m) (mod m)
   return (extended_gcd(a_,m_).first % m_ + m_) % m_;
 }
Esempio n. 12
0
 pair<LL,LL> extended_gcd(LL a_,LL b_){  //ax+by = gcd(a,b)
   if(!b_) return make_pair(1,0);
   pair<LL,LL> retval = extended_gcd(b_,a_%b_);
   return make_pair(retval.second,retval.first - ((a_/b_) * retval.second));
 }
Esempio n. 13
0
/* ----------------------------------------------------------------------------
 * Funktion: calculate_rsa_keys
 * ------------------------------------------------------------------------- */
extern void calculate_rsa_keys(void)
{
    int p = 0;            /* p und q sind zwei zufällig ausgewählte Primzahlen */
    int q = 0;            /* im Intervall von 2 bis LIMIT */
    int phi_n;            /* Wert der Eulerschen phi-Funktion: (p - 1) * (q - 1) */
    int e = 0;            /* Exponent des öffentlichen Schlüssels */
    int d = 0;            /* Exponent des privaten Schlüssels */
    int n;                /* RSA-Modul */
    int gcd;              /* ggt von e und n */
    int d_and_k[2] = {0}; /* Hilfsvektor, um die beiden Werte d und k, die im
                           * erweiterten Euklidschen Algorithmus berechnet werden, 
                           * zurückzugeben. */ 
    BOOL found_e;         /* TRUE, wenn ein teilerfremdes e zu n gefunden wurde,
                           * FALSE sonst. */
    
    /* Berechnung der Primzahlen von 2 bis PRIME_LIMIT */
    generate_primes(PRIME_LIMIT);
    
    /* 
     * Wähle zwei zufällige Primzahlen, so dass deren Produkt (das RSA-Modul)
     * größer als der ASCII-Wert des größten zu verschlüsselnden 
     * Zeichens ist und kleiner als die Zahl (PRIME_LIMIT), die die 
     * RSA-Schlüssel nicht überschreiten dürfen. 
     */
    n = 0;
    while (n <= MAX_CHAR || n >= PRIME_LIMIT)
    {
        p = get_random_prime(LIMIT); 
        q = get_random_prime(LIMIT);   
        n = p * q;
    }
#ifdef DEBUG
    DPRINT(p);
    DPRINT(q);
    DPRINT(n);
#endif 

    /* Berechne die eulersche Phi-Funktion von p und q */
    phi_n = (p - 1) * (q - 1);
#ifdef DEBUG
    DPRINT(phi_n);
#endif 

    /* 
     * Wähle eine zu phi_n teilerfremde Zahl e und berechne d, so dass gilt:
     * d > 1, e != d, e * d + k * phi_n = 1 = ggt(e, phi_n)
     */
    gcd = -1;
    while (d <= 1 || d == e || gcd != 1)
    {
        /*
         * Wähle eine Primzahl e, so dass e kleiner ist als phi_n und 
         * e kein Teiler von phi_n ist --> e und phi_n sind teilerfremd. 
         */
        found_e = FALSE;
        while (found_e == FALSE)
        {
            e = get_random_prime(phi_n);
            if (e < phi_n && phi_n % e != 0)
            {
                found_e = TRUE;
            }
        }
#ifdef DEBUG
        DPRINT(e);
#endif 
        /*
         * Bestimme die Zahl d mit dem erweiterten euklidschen Algorithmus, 
         * so dass gilt: e * d + k * phi_n = 1 = ggT(e, phi_n)
         */
        gcd = extended_gcd(e, phi_n, d_and_k);
        d = d_and_k[0];
    }
#ifdef DEBUG
    DPRINT(phi_n);
    DPRINT(e);
    DPRINT(n);
    DPRINT(d);
#endif

    /* Globale Variablen auf die generierten Schlüsselwerte setzen */
    rsa_modul = n;
    public_exponent = e;
    secret_exponent = d;

#ifdef DEBUG
    printf("Es wurde folgendes Schluesselpaar erzeugt:\n");
    printf("oeffentlicher Schluessel: (%4d, %4d)\n", e, n);
    printf("privater Schluessel     : (%4d, %4d)\n", d, n);
    printf("\n");
#endif
}
Esempio n. 14
0
LL inv(LL a,LL n)
{
	LL xx,yy,d=extended_gcd(a,n,xx,yy);
	return (xx%n+n)%n;
}