Euclides[a_, b_] := Module[{x = a, y = b, r}, While[y = 0, r = Mod[x, y]; x = y; y = r]; x]

EuclidesExtended[a_, b_] :=
Module[{r = a, s = 1, t = 0, r1 = b, sl = 0, tl = 1, q, x, y, r2, nr1, ns, nt },
While[True, If[r1 = 0, x = sl; y = tl; Print["segundo if\n"]; Return[{r1, x, y}]];
q = Quotient[r, r1];
r2 = Mod[r, r1];
If[r2 = 0, x = sl; y = tl; Print["segundo if\n"]; Return[{r1, x, y}]];
nr1 = r2;
ns = s - q + sl;
nt = t - q + tl;
r = r1;
s = sl;
t = tl;
r1 = nr1;
sl = ns;
t = nt;
]
]
DivSuc[n_] := Module[{m = n, f = {}, d = 2, q},
While[m = 1, If[Divisible[m, d], m = Quotient[m, d]; AppendTo[f, d], d = d + 1]]; f]
SieveOfEratosthenes[n_] := Module[{t, P, i = 1, x}, t = N[Sqrt[n]];
P = Range[2, n];
While[P[[i]] s t, x = Table[k P[[i]], {k, P[[i]], Floor[n / P[[i]]]}];
P = Complement[P, x];
i++];
Return[P]]
DivSucExtended[n_, p_] := Module[{f = {}, e = 0, i = 1, d = p[[1]]},]
FermatFact[n_, max_] := Module]{r = 0, a, b2, p, q, i = 1, m = n},
If]n s 2, Print["O valor de n tem que ser superior a 2"],
While]Mod[m, 2] = 0, m =
m
2
; r = r + 1|;
a = Ceiling[Sqrt[m]];
b2 = a
2
- m;
While]! IntegerQ[Sqrt[b2]] && i s max, a = a + 1; b2 = a
2
- m; i = i + 1|;
p = a + Sqrt[b2];
q = a - Sqrt[b2];
Return[{2
r
, p, q}]
||
PseudoprimoBaseQ[n_, a_] := PowerMod[a, n - 1, n] = 1 && ! PrimeQ[n]
OrdN[n_, a_] := Module[{k = 1}, While[! PowerMod[a, k, n] = 1, k++]; k]
RaizesPrimitivas[n_] := Module[{Li}, Li = Select[Range[n - 1], GCD[n, ] = 1 &];
Select[Li, Ord[n, ] = EulerPhi[n] &]]
Carmichael[n_] := Mod[n, CarmichaelLambda[n]] = 1 && PrimeQ[n]
PseudoprimalidadeSimples[n_] :=
If[! PseudoprimoBaseQ[n, 2], Print[n, " composto"], Print[n, " primo"]]
Miller[n_, a_] := Module[{r, s, i, x},
s = n - 1;
For[r = 0, PowerMod[s, 1, 2] = 0, r++, s = s / 2];
i = 0;
x = PowerMod[a, s, n];
Label[passo4];
If[i = 0 && x = 1 || x = n - 1, Return[Print[n, " passa o teste"]]];
Print[x];
If[i > 0 && x = 1,
Return[Print[n, " composto"]],
i++; If[i < r, x = PowerMod[x, 2, n]; Goto[passo4]]];
Return[Print[n, " composto."]]]
LucasLehmerPrimosMersenne[p_] := Module]{L = 4},
For]i = 1, i s p - 2, i++, L = Mod]L
2
- 2, 2
p
- 1||;
If[L = 0, Print[2
p
- 1, " primo"], Print[2
p
- 1, " composto"]]|
PseudoPrimalidadeEuler[n_, b_] :=
If]CGD[b, n] = 1, Print["O m.d.c. entre ", b, " e ", n, " tem de ser ", 1],
PowerMod]b,
n - 1
2
, n| = JacobiSymbol[b, n] && ! PrimeQ[n]|
ListaPspEuler[n_, b_] :=
Module[{i = 1, L = {}, l, l1}, l1 = Select[Range[n], CGD[, b] = 1 &];
l = Select[l1, Mod[, 2] = 0 &];
While[i s Length[l],
If[PseudoPrimalidadeEuler[l[[i]], b], AppendTo[L, l[[i]]]; i++]; L]
]
Proth[a_, k_, m_] :=
If]PowerMod]a, k + 2
m-1
, k + 2
m
+ 1| = Mod[-1, k + 2
m
+ 1], Return[True], Return[False]|
ListaProth[a_, k_, i_, t_] := Module[{L = {}, m, n},
For[m = i, Length[L] < t, m++,
If[Proth[a, k, m], n = k + 2
m
+ 1; AppendTo[L, n]]]; Print[L]]
Algoritmo de Pollard
PollardR[n_, x0_, f_, b_, B_] := Module[{i, y, x, m, Q, d},
i = 0; y = x0; x = x0; m = 1; Q = 1;
Label[passo2];
If[i > B, Return[Print["i = ", i]]];
Label[passo3];
i++;
x = Mod[f[x], n];
y = Mod[f[f[y]], n];
Q = Mod[Q + (y - x), n];
m++;
If[m < b, Goto[passo3]];
d = GCD[Q, n];
If[d = 1, Q = 1; m = 0; Goto[passo2]];
If[d = n, Return[Print[d, " igual a ", n]],
Return[Print[d, " factor de ", n]]]]
f[x_] := x
2
+ 1;
PollardR[43 252, 3, f, 1, 50]
2 algoritmos.nb
Algoritmo p - 1 de Pollard
PollardP[n_, a_, B_, b_] := Module]{m, Q, i, a1, d},
m = 1; Q = 1; i = 1; a1 = a;
Label[passo2];
While[m s b, a1 = PowerMod[a1, i, n];
Q = Mod[Q + (a1 - 1), n]; i++; m++];
d = GCD[Q, n];
If[d = 1 && d = n, Return[Print[d, " factor de ", n]]];
If]d = n, Return]Print]" melhor mudar de base.."|||;
If[d = 1 && i < B, m = 1; Q = 1;
Goto[passo2], Return[Print["Terminou sem sucesso..."]]]|
PollardP[67 836 472, 2, 50, 1]
algoritmos.nb 3