extended_euclid_algorithm.cpp File Reference

GCD using [extended Euclid's algorithm] (https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm) More...

#include <algorithm>
#include <iostream>

Include dependency graph for extended_euclid_algorithm.cpp:

Functions
template<typename T , typename T2 >
void	update_step (T *r, T *r0, const T2 quotient)
template<typename T1 , typename T2 >
void	extendedEuclid_1 (T1 A, T1 B, T1 *GCD, T2 *x, T2 *y)
template<typename T , typename T2 >
void	extendedEuclid (T A, T B, T *GCD, T2 *x, T2 *y)
int	main ()
	Main function.

Detailed Description

GCD using [extended Euclid's algorithm] (https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm)

Finding coefficients of a and b ie x and y in Bézout's identity

\[\text{gcd}(a, b) = a \times x + b \times y \]

This is also used in finding Modular multiplicative inverse of a number. (A * B)M == 1 Here B is the MMI of A for given M, so extendedEuclid (A, M) gives B.

Function Documentation

extendedEuclid()

template<typename T , typename T2 >

void extendedEuclid	(	T	A,
		T	B,
		T *	GCD,
		T2 *	x,
		T2 *	y )

Implementation using recursive algorithm

Parameters

[in]	A	unsigned
[in]	B	unsigned
[out]	GCD	unsigned
[in,out]	x	signed
[in,out]	y	signed

                                                    {
    if (B > A)
        std::swap(A, B);  // Ensure that A >= B
 
    if (B == 0) {
        *GCD = A;
        *x = 1;
        *y = 0;
    } else {
        extendedEuclid(B, A % B, GCD, x, y);
        T2 temp = *x;
        *x = *y;
        *y = temp - (A / B) * (*y);
    }
}

Here is the call graph for this function:

extendedEuclid_1()

template<typename T1 , typename T2 >

void extendedEuclid_1	(	T1	A,
		T1	B,
		T1 *	GCD,
		T2 *	x,
		T2 *	y )

Implementation using iterative algorithm from Wikipedia

Parameters

[in]	A	unsigned
[in]	B	unsigned
[out]	GCD	unsigned
[out]	x	signed
[out]	y	signed

                                                         {
    if (B > A)
        std::swap(A, B);  // Ensure that A >= B
 
    T2 s = 0, s0 = 1;
    T2 t = 1, t0 = 0;
    T1 r = B, r0 = A;
 
    while (r != 0) {
        T1 quotient = r0 / r;
        update_step(&r, &r0, quotient);
        update_step(&s, &s0, quotient);
        update_step(&t, &t0, quotient);
    }
    *GCD = r0;
    *x = s0;
    *y = t0;
}

Here is the call graph for this function:

main()

int main

(

void

)

Main function.

           {
    uint32_t a, b, gcd;
    int32_t x, y;
    std::cin >> a >> b;
    extendedEuclid(a, b, &gcd, &x, &y);
    std::cout << gcd << " " << x << " " << y << std::endl;
    extendedEuclid_1(a, b, &gcd, &x, &y);
    std::cout << gcd << " " << x << " " << y << std::endl;
    return 0;
}

Here is the call graph for this function:

update_step()

template<typename T , typename T2 >

void update_step ( T * r, T * r0, const T2 quotient )

inline

function to update the coefficients per iteration

\[r_0,\,r = r,\, r_0 - \text{quotient}\times r\]

Parameters

[in,out]	r	signed or unsigned
[in,out]	r0	signed or unsigned
[in]	quotient	unsigned

                                                        {
    T temp = *r;
    *r = *r0 - (quotient * temp);
    *r0 = temp;
}