Encontrando numeros primos con la criba de Eratostenes

Conceptos bsicos
Los nmeros naturales son los nmeros que utilizamos a diario
para contar: 1, 2, 3, 4, 5, 6, etc.
Estn formados por el nmero 1, los nmeros primos y los nmeros
compuestos.
Los nmeros primos son los nmeros que tienen 2 divisores:
Slo pueden dividirse en forma exacta por la unidad y por s
mismos.
Los primos menores que 10 son extraordinarios: El 2 es el nico
primo par. El 2 y el 3 son los nicos primos contiguos. El 5 es el
nico primo terminado en 5. Por ltimo: 3, 5 y 7 forman la nica
trada de primos gemelos en toda la recta numrica.


Los nmeros compuestos son los que tienen ms de 2
divisores. Los divisores de un nmero son los nmeros que
pueden dividirlo en forma exacta (Sin generar resto).
El teorema fundamental de la aritmtica muestra que
los primos son los ladrillos bsicos con los que estn
construidos los enteros. Dice:

Todo entero positivo mayor que uno puede ser escrito
de forma nica como el producto de primos,
con los factores primos en el producto en orden de
tamao no decreciente.
(Euclides, Elementos).
El teorema fundamental de la aritmtica
[
=
i
e
i
i
p n
(a) n! y (n! + 1) no tienen factores comunes.
(b) O bien (n! + 1) es primo o bien es factorizable:
(b.1) Si (n! + 1) es primo queda demostrada
la afirmacin.
(b.2) Si (n! + 1) puede descomponerse en factores,
por (a) ninguno de ellos puede dividir a n!
De modo que cualquier factor de (n! + 1) estar entre n y (n! + 1).
(b.2.1) Si el factor es primo queda demostrada la afirmacin.
(b.2.2) Si el factor no es primo, entonces por el mismo
argumento
(b.2), ser mayor que n y podemos volver a descomponerlo hasta
encontrar finalmente un primo mayor que n.
Cuntos primos existen?
Euclides demostr que siempre existe al
menos un primo entre n y (n! + 1) de la
siguiente manera:
Por ejemplo, hay nueve primos entre 9.999.900 y 10.000.000:

9.999.901 9.999.907 9.999.929 9.999.931
9.999.937 9.999.943 9.999.971 9.999.973
9.999.991.

Pero entre los cien enteros siguientes, desde 10.000.000 a
10.000.100, hay solo dos:

10.000.019 y 10.000.079.

Ausencia aparente de un patrn regular en la
secuencia de nmeros primos
Los matemticos griegos probaron, alrededor del 300 antes de
nuestra era, que existen infinitos primos y que estn
espaciados de manera irregular, es decir que la distancia entre
dos primos consecutivos puede ser arbitrariamente larga.
The Counting Prime Function
. a igual o menores primos # ) ( x x t
As los primos menores o iguales a 25 son 2, 3, 5, 7, 11,
13, 17, 19 y 23 de modo que t(25) = 9.
"Cuntos primos menores que un nmero x hay?"
La distribucin de nmeros primos parece ser aleatoria. Por
ejemplo, hay probablemente infinitos primos gemelos y
existen gaps arbitrariamente largos entre primos.
"It is evident that the primes are randomly distributed
but, unfortunately we don't know what 'random'
means".

R.C. Vaughan
Sin embargo, la funcin (x) exhibe un sorprendente "buen
comportamiento".
"Here is order extracted from confusion, providing a moral lesson on
how individual eccentricities can exist side by side with law and order".
The Mathematical Experience by Philip J Davis & Reuben Hersh

"For me, the smoothness with which this curve climbs is
one of the most astonishing facts in mathematics."

Don Zagier, "The first 50 million primes"
Mathematical Intelligencer, 0 (1977) 1-19


n t(n) n/t(n)
10 4 2.5
100 25 4.0
1000 168 6.0
10,000 1,229 8.1
100,000 9,592 10.4
1,000,000 78,498 12.7
10,000,000 664,579 15.0
100,000,000 5,761,455 17.4
1,000,000,000 50,847,534 19.7
10,000,000,000 455,052,512 22.0
Observemos que cuando pasamos de un orden de magnitud al
siguiente el cociente n/t(n) se incrementa aproximadamente 2.3.

Sabiendo que Ln 10 = 2.30258... Gauss formul la conjetura de
que t(n) es aproximadamente igual a n/Ln n.

22.0 - 19.7 = 2.3
En 1798 Legendre publica la primera
conjetura significativa sobre la forma
funcional de t(x), cuando en su libro
Essai sur la Thorie des Nombres
escribe que:

08366 1
) (
. x - Ln
x
x = t
Legendre
http://mathworld.wolfram.com/PrimeNumberTheorem.html

Zagier en su artculo dice al respecto:
"within the accuracy of our picture, the two coincide exactly."

The logarithmic integral function Li(x)
}
=
x
u Ln
du
x Li
2
) (
Se sabe que Li(x) no es siempre mayor que t(x), pero eso
ocurre por primera vez alrededor de 10
320
!
Antes de la existencia de los
ordenadores...Tablas de D. N.
Lehmer: primos hasta 10.006.721
reference
1 4 antiquity
2 25 L. Pisano (1202; Beiler)
3 168 F. van Schooten (1657; Beiler)
4 1229 F. van Schooten (1657; Beiler)
5 9592 T. Brancker (1668; Beiler)
6 78498 A. Felkel (1785; Beiler)
7 664579 J. P. Kulik (1867; Beiler)
8 5761455 Meissel (1871; corrected)
9 50847534 Meissel (1886; corrected)
10 455052511 Lehmer (1959; corrected)
11 4118054813 Bohmann (1972; corrected)
12 37607912018
13 346065536839
14 3204941750802 Lagarias et al. (1985)
15 29844570422669 Lagarias et al. (1985)
16 279238341033925 Lagarias et al. (1985)
17 2623557157654233 M. Deleglise and J. Rivat (1994)
18 24739954287740860 M. Deleglise (June 19, 1996)
19 234057667276344607 M. Deleglise (June 19, 1996)
20 2220819602560918840 M. Deleglise (June 19, 1996)
21 21127269486018731928 project (Dec. 2000)
22 201467286689315906290 P. Demichel and X. Gourdon (Feb. 2001)
23
Prime Counting Function -- from Wolfram MathWorld.htm
El nmero de primos que no excede a x es
asinttico a x/log x. En otras palabras, la
probabilidad de que "un nmero x escogido
al azar sea primo es 1/log x".
El teorema de los nmeros primos:
En 1896, de la Valee Poussin y Hadamard probaron
simultneamente lo que se haba sospechado durante
mucho tiempo, el teorema de los nmeros primos:
x
x
x
ln
~ ) ( t
El teorema nos dice que x/log x es, hasta cierto punto, una buena
aproximacin a (x) . Al decir que "a(x) es asinttico a b(x)" o
"a(x) ~ b(x)" decimos que el lmite de a(x)/b(x) es 1 cuando x
tiende a infinito. Pero, observemos que a(x) ~ b(x) no significa
que a(x) - b(x) sea pequeo.
x t(x) x/log x x/(log x -1)
1000 168 145 169
10000 1229 1086 1218
100000 9592 8686 9512
1000000 78498 72382 78030
10000000 664579 620420 661459
100000000 5761455 5428681 5740304
El teorema de los nmeros primos implica que podemos
usar x/(log x - a) (con cualquier constante a) para aproximar
t(x). Chebychev demostr que la mejor eleccin era a = 1.
}
=
x
u Ln
du
x Li
2
) (
Que Li(x) sea asinttica con t(x) es impresionante,
pero lo que nos gustara es estimar t(x) lo mejor
posible.
NUMEROS PRIMOS MENORES A X
x pi(x)
10 4
100 25
1,000 168
10,000 1,229
100,000 9,592
1,000,000 78,498
10,000,000 664,579
100,000,000 5,761,455
1,000,000,000 50,847,534
10,000,000,000 455,052,511
100,000,000,000 4,118,054,813
1,000,000,000,000 37,607,912,018
10,000,000,000,000 346,065,536,839
100,000,000,000,000 3,204,941,750,802
1,000,000,000,000,000 29,844,570,422,669
10,000,000,000,000,000 279,238,341,033,925
100,000,000,000,000,000 2,623,557,157,654,233
1,000,000,000,000,000,000 24,739,954,287,740,860
10,000,000,000,000,000,000 234,057,667,276,344,607
100,000,000,000,000,000,000 2,220,819,602,560,918,840
1,000,000,000,000,000,000,000 21,127,269,486,018,731,928
10,000,000,000,000,000,000,000 201,467,286,689,315,906,290
100,000,000,000,000,000,000,000 1,925,320,391,606,803,968,923

Algunas curiosidades sobre los
nmeros primos
Primos en la naturaleza
Algunos insectos utilizan los nmeros primos como proteccin. Las
ccadas pasan exactamente 13 o 17 aos bajo tierra como larvas
succionando races. Despus se transforman en adultos, salen de la tierra
y se aparean.
Tanto el 13 como el 17 son nmeros primos. El resultado es que los
parsitos o predadores con un ciclo vital de, por ejemplo dos o tres aos,
casi nunca coinciden con un enjambre
Cdigos secretos
Multiplicar dos nmeros primos es fcil, pero no tanto hacer los contrario:
descomponer un nmero en sus factores primos. En el caso de nmeros
realmente grandes, es casi imposible.
En realidad, es tan difcil, que hace que los nmeros primos sean perfectos
para crear cdigos secretos indescifrables.
Cuando haces una compra por Internet, tus datos quedan ocultos por un
cdigo creado de esta manera:
La "cerradura" para el cdigo es un nmero enorme y la "llave" est
formada por los factores primos de ese nmero

Aplicaciones en la computacin
El algoritmo RSA se basa en la obtencin de la clave pblica
mediante la multiplicacin de dos nmeros grandes
(mayores que 10
100
) que sean primos. La seguridad de este
algoritmo radica en que no hay maneras rpidas de
factorizar un nmero grande en sus factores primos
utilizando computadoras tradicionales. La computacin
cuntica podra ofrecer una solucin a este problema de
factorizacin.
Los primos de Mersenne se encuentran entre los ms
grandes primos hallados. Actualmente el primo de
Mersenne ms alto encontrado cuadragsimo quinto es el
nmero 2
43.112.609
1 que tiene 12.978.189 dgitos y fue
descubierto el 23 de agosto de 2008 gracias al proyecto de
computacin distribuida GIMPS.

La criba de Eratstenes es un antiguo y efectivo mtodo para
hallar nmeros primos. Consiste en una tabla de nmeros
naturales dispuestos en columnas. Primero se tachan todos los
mltiplos de 2. Luego se tachan todos los mltiplos del
siguiente nmero no tachado anteriormente y as sucesivamente.
Los nmeros que quedan sin tachar son los nmeros primos.
Para determinar si un nmero es primo se sabe que no hace
falta dividirlo por todos los nmeros menores a l. Basta con
dividirlo por los nmeros impares mayores que 1 y menores o
iguales a la raz cuadrada del nmero. Si no se encuentra ningn
divisor entonces el nmero es primo. Si se encuentra un divisor,
o si el nmero es par y mayor que 2, entonces el nmero es
compuesto.

Funcionamiento de la criba de Eratosthenes
Funcionamiento de la criba de Eratosthenes
Utilizando el algoritmo de Eratstenes el
pseudocdigo serial es el siguiente:
/*Inicializacin del arreglo*/
for(i=2;i < N;i++)
marker[i]=1;
marker [0]=0;
marker [1]=0;

/* Marca con Cero los multiplos de cada primo hasta la raz del numero original*/
for(i=2;i<n;i++)
if(marker[i]==1)
for(j=2;i<=Sqrt(N)/i;j++)
marker [j*i]=0;

/*cuenta los numeros primos encontrados*/
for(i=2;i<num;i++)
if(marker[i]==1)
cont++;

/*se crea arreglo para los numeros primos encontrados*/
Primo=(int*)calloc(cont,sizeof(int));
j=0;
for(i=2;i<num;i++)
if(marker[i]==1){
Primo[j]=i
J++;}


/*se marcan los numeros no primos*/
For(i=0;j<cont;j++){
If((num+1)%Primo[j]==0)
first =(num + 1)/ Primo[j];
else
first = ((num + 1)/Primo[j])+ 1;
for(i= first;i<=NUM/Primo[j];i++)
marker [Primo[j]*i]=0;


/*se cuentan los numeros primos encontrados y se imprimen*/
Cont = 0;
For(i=0;i<NUM;i++)
If(marker[i] == 1){
Cont++;
Printf(%d\t,i);
Ultimo = i;
}
Printf(\n%d\n, cont);
Printf(primo mas grande %d, ultimo);
Printf(tiempo:%f\n,(clock()-ti)/(double)CLOCKS_PER_SEC);



Utilizando el algoritmo de Eratstenes el
pseudocdigo paralelo es el siguiente:
Entrada = atoi(argv[1]); /* Numero de entrada */

raiz = (int) sqrt((double) Entrada); /* Raiz del numero original */

n = (int) sqrt((double) raiz); /* Raiz de la raiz del numero original */

marker=(int*)calloc(Entrada,sizeof(int));

for(i = 2; i < Entrada; i++) /*Inicializacion de marker */
marker[i] = 1;
marker[0] = 0;
marker[1] = 0;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD, &id);
MPI_Comm_size(MPI_COMM_WORLD, &np);

/*Se marcan los mltiplos de los primos hasta raiz del numero original*/
for(i = 2; i <= n; i++)
if(marker[i] == 1)
for(j = 2; j <= raiz/i; j++)
marker[j * i] = 0; /* marca con cero los que no son primos */

/*Cuenta cuantos primos se encontraron hasta raz del nmeros original*/

for(i = 2; i <raiz; i++)
if(marker[i] == 1)
contador ++;
/*El arreglo de los nmeros primos encontrados hasta raz de el numero original*/
Primo = (int*)calloc(contador,sizeof(int));
j = 0;
for(i = 2; i < raiz; i++)
if(marker[i] == 1)
Primo[j] = i;/* Se introducen los nmeros primos al arreglo */
j++;

/* Se divide los datos y cada procesador calcula el incio y fin de los datos que le tocan */


size = Entrada - raiz;
s_size = floor(size / np);
n_size = s_size * np; *********************
inicio = Entrada - n_size;
if(id==0)
mi_inicio = raiz + 1;
mi_fin = inicio + s_size;
Else
mi_inicio = (s_size * id) + inicio + 1;
mi_fin = (s_size * (id + 1)) + inicio;
/*los procesadores marcan los numeros no primos en su parte del arreglo*/

mi_contador = mi_fin - mi_inicio + 1;
for(j = 0; j < contador; j++)
{
/* revisa si el primer numero del arreglo es multiplo del primo */

if(mi_inicio % Primo[j] == 0)
first = mi_inicio / Primo[j];
Else
first = (mi_inicio / Primo[j]) + 1;

for(i = first; i <= mi_fin / Primo[j]; i++)
{
if(marker[Primo[j] * i] == 1)
{
marker[Primo[j] * i]=0; /* pone cero a los multiplos */
mi_contador--;
MPI_Reduce(&mi_contador, &total, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);

/*Cada procesador cuenta los primos que encontro*/
total+=contador-1;

/* Cada procesador Imprime el ultimo numeros primos */
for(i = mi_fin; i >= mi_inicio; i--){
if(marker[i] == 1){
printf("ID %d: Valor del ultimo primo encontrado: %d\n", id, i);
break;

if(id == 0)
{
printf("\nPrimos encontrados Menores a: %d Son %d\n",Entrada,total);
printf("Tiempo : %f\n",(clock()-ti) / (double)
free(marker);
free(Primo);
MPI_Finalize();
Compilar y Ejecutar programa paralelo
mpcc -o final ultimofin.c -lm -lmpi
mprun -np 2 -l "calafia 2" final 100000000
5762209 ) 100000000 (
100000000
2
~ =
}
u Ln
du
Li
5428681
100000000 ln
100000000
~ ) 100000000 ( ~ t
Ejecucin de experimnto
El experimentos se ejecut para:
Entrada = 100,000,000
Se encontraron 5,761,455 primos
- El primo mas grande encontrado fue: 99,999,989
Recordando el teorema de los nmeros primos
Existe una diferencia de 5761455 5428681 = 332774
Versin mejorada
Existe una diferencia de 5761455 5762209 = 754
MEDIDAS DE DESEMPEO
Objetivos:

Estimacin de desempeo de algoritmos paralelos.
Comparacin con algoritmos seriales.

Factores intuitivos para evaluar El desempeo:

Tiempo de ejecucin.
Utilizacin de los recursos disponibles.
82.329
37.351
27.182
22.595
19.952
17.398 15.888
15.609
0
10
20
30
40
50
60
70
80
90
100
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
82.329 37.351 27.182 22.595 19.952 17.398 15.888 15.609
Tiempo promedio de 10 ejecuciones
Secuencial
71.74
SPEEDUP ABSOLUTO
SPEEDUP
Es una medida de la mejora de rendimiento (performance) de una aplicacin al
aumentar la cantidad de procesadores (comparado con el rendimiento al utilizar
un solo procesador).

SPEEDUP ABSOLUTO





Siendo:
T0 el tiempo del mejor algoritmo SERIAL que resuelve el problema (considerando
el tiempo de ejecucin, o sea el algoritmo ms rpido).
Tp el tiempo del algoritmo paralelo ejecutado sobre N procesadores.
P
P
T
T
S
0
=
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
0.871381895 1.920698241 2.63924656 3.175038725 3.595629511 4.123462467 4.515357503 4.596066372
0.87
1.92
2.64
3.18
3.60
4.12
4.52
4.60
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5
5
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
SPEEDUP ABSOLUTO
SPEEDUP ABSOLUTO Sp = T0 / Tp
Secuencial
71.74
SPEEDUP RELATIVO
Relativo: Cuantas veces es mas rpido un programa paralelo con P
procesadores respecto del mismo programa ejecutado con un procesador.
2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
2.204198013 3.028805827 3.643682231 4.126353248 4.732095643 5.181835347 5.274457044
2.20
3.03
3.64
4.13
4.73
5.18
5.27
0
1
2
3
4
5
6
2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
Motivos que impiden el crecimiento lineal del SPEEDUP:
Demoras introducidas por las comunicaciones.
Overhead en intercambio de datos.
Overhead en trabajo de sincronizacin.
Existencia de tareas no paralelizables.
Cuellos de botella en el acceso al hardware necesario.

Los factores mencionados incluso pueden producir que el uso de ms procesadores
sea contraproducente para la desempeo de la aplicacin.
SPEEDUP
LEY DE AMDAHL (1967):
La parte serial de un programa determina una cota inferior para el tiempo de
ejecucin, an cuando se utilicen al mximo tcnicas de paralelismo.
Sea P la fraccin de un programa que es paralelizable, y sea S = 1 P la parte secuencial
restante, entonces el speedup al trabajar con N procesadores estar acotado por:
SN <= 1 / (S + P / N)
El valor asinttico para SN es 1/S.

Ejemplo:

Si solo el 50% de un programa es paralelizable, S = P = , se tiene que SN = 2 / (1 + 1/N)
que ser <=2 (valor asinttico), independientemente de N (cantidad de procesadores
utilizados)
Speed up Esperado (2 procesadores)
( )
|
|
.
|

\
|

= + =
p
T T
T
p
T
T T
p
pf
pf
sf p
1
1
1
( )
778 . 68
2
1
1
351 . 37 74 . 71
=
|
.
|

\
|

=
pf
T
pf sf pf sf
T T T T T T = + =
1 1
962 . 2 778 . 68 74 . 71 = =
sf
T
9587 . 0
74 . 71
778 . 68
1
= = =
f
p
f
P
T
T
P
0413 . 0 9587 . 0 1 = =
f
S
9206 . 1
2
9587 . 0
0413 . 0
1 1
=
|
.
|

\
|
+
=
|
|
.
|

\
|
+
=
p
f
f
p
S
P
P
S
S
Speed up Esperado (8 procesadores)
( )
|
|
.
|

\
|

= + =
p
T T
T
p
T
T T
p
pf
pf
sf p
1
1
1
( )
149 . 64
8
1
1
609 . 15 74 . 71
=
|
.
|

\
|

=
pf
T
pf sf pf sf
T T T T T T = + =
1 1
591 . 7 149 . 64 74 . 71 = =
sf
T
894 . 0
74 . 71
149 . 64
1
= = =
f
p
f
P
T
T
P 1058 . 0 894 . 0 1 = =
f
S
596 . 4
8
894 . 0
1058 . 0
1 1
=
|
.
|

\
|
+
=
|
|
.
|

\
|
+
=
p
f
f
p
S
P
P
S
S
2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
1.92 2.63 3.17 3.59 4.12 4.51 4.59
Speed up Esperado
1.92
2.63
3.17
3.59
4.12
4.51
4.596
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5
5
2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
EFICIENCIA
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
0.871381895 0.960349121 0.879748853 0.793759681 0.719125902 0.687243745 0.645051072 0.574508297
0.87
0.96
0.88
0.79
0.72
0.69
0.65
0.57
0
0.2
0.4
0.6
0.8
1
1.2
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
COSTO
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador
82.329 74.702 81.546 90.38 99.76 104.388 111.216 124.872
82.329
74.702
81.546
90.38
99.76
104.388
111.216
124.872
0
20
40
60
80
100
120
140
1 procesador 2 procesador 3 procesador 4 procesador 5 procesador 6 procesador 7 procesador 8 procesador