No se encontró la página – El Internet de las Cosas https://monodelapila.com El Internet de las Cosas Wed, 17 May 2023 20:50:52 +0000 es-CO hourly 1 https://wordpress.org/?v=6.1.4 https://monodelapila.com/wp-content/uploads/sites/2/2023/11/cropped-Logo3-32x32.png No se encontró la página – El Internet de las Cosas https://monodelapila.com 32 32 Make&Put WordPress plugin https://monodelapila.com/wordpress/makeput-wordpress-plugin/ https://monodelapila.com/wordpress/makeput-wordpress-plugin/#respond Wed, 17 May 2023 19:52:28 +0000 https://monodelapila.com/?p=534 Leer más…]]> This plugin enables you to create custom buttons. You have the freedom to choose the color, size, font color, and rounded box shape. The plugin generates a shortcode that you can easily insert into your own posts and pages.

DONATION

If this plugin has been useful, consider supporting its improvement.





]]>
https://monodelapila.com/wordpress/makeput-wordpress-plugin/feed/ 0
Jugando con Python y números primos (III) https://monodelapila.com/python/jugando-con-python-y-numeros-primos-iii/ https://monodelapila.com/python/jugando-con-python-y-numeros-primos-iii/#respond Mon, 01 Nov 2021 19:44:47 +0000 https://monodelapila.com/?p=454 Leer más…]]> Promedios de las distancias
Johann Carl Friedrich Gauss
Johann Carl Friedrich Gauss

En las entradas anteriores generamos un archivo con los primeros números primos que se encuentran entre 1 y mil millones y construimos un pequeño programa en Python que genera las distancias entre ellos y las grafica por rangos. Observamos algo que hace unos añitos (220 mas o menos) Carl Friedrich Gauss había observado sin contar con nuestras sofisticadas herramientas.

En esta entrada vamos a intentar cuantificar qué tanto cambian las distancias entre los números primos a medida que tomamos rangos mas alejados de cero. Esto es, las distancias en los primeros 1000 primos, frente a las distancias en los siguientes mil y los siguientes. Vamos a hacer uso de un concepto estadístico muy sencillo que es el promedio. Esto no es nada diferente que una suma dividida por el número de elementos que sumamos. Miraremos el promedio de las distancias entre números primos, en cada uno de los rangos, tratando de encontrar un patrón en ello.

Para la estadística usaremos un módoulo de Python llamado Pandas. Respecto al uso de la libreria Pandas sugiero leer la excelente página de José Ricardo Zapata. Es una librería muy poderosa, tanto para calcular estadísticas como para gráficarlas. Pero nosotros sólo usaremos algunas mínimas funciones.

Intentemos calcular el promedio de las distancias entre números primos para los primeros 1000, los segundos mil, etc.

Comenzamos importando la libreria y asignándola al identificador pd:

import pandas as pd

Pandas reconoce dos tipos de entradas de datos: Series y DataFrame. La primera es un listado de valores como el que venimos usando. El segundo tipo es una tabla con varias columnas. Para calcular el promedio de nuestra lista de distancias basta con la instrucción:

print( pd.Series(sucesion).mean() )

pd. indica que estamos llamando a la libreria Pandas. Series. por que usaremos como datos de entrada una serie, esta es sucesion que creamos en la entrada anterior y finalmente usamos el metodo mean().

Para calcular el promedio de as distancias de los primeros mil números primos, usando algunas de las funciones creadas en la entrada anterior, hariamos:

#---------------------------------------------------------------
#--------------------PROGRAMA PRINCIPAL-------------------------
# Parametros
consecutivo_inicial = 1   # Desde cuál consecutivo comienza
cantidad = 1000    # Cuantos primos 

primos = lee_primos(cantidad, inicio=consecutivo_inicial)
sucesion = sucesion_distancias(primos)
promedio = pd.Series(sucesion).mean()
print( 'Promedio de distancias entre '+str(consecutivo_inicial)+' y '+str(consecutivo_inicial+cantidad)+': ',promedio )

y obtendremos como resultado:

Un número: 7.9. El promedio de la distancia entre los primeros mil primos. Pero lo realmente interesante sería tener varios promedios de distancias Hagamos un ciclo for para calcular tantos promedios como queramos:

#---------------------------------------------------------------
#--------------------PROGRAMA PRINCIPAL-------------------------
# Parametros
consecutivo_inicial = 1   # Desde cuál consecutivo comienza
cantidad = 1000    # Cuantos primos 
intervalo = 1000    # Espacio entre el comienzo de cada rango
numero_iteraciones = 10

final = consecutivo_inicial +(intervalo * numero_iteraciones)
for desde in range(consecutivo_inicial, final, intervalo):
    primos = lee_primos(cantidad, inicio=desde)
    sucesion = sucesion_distancias(primos)
    promedio = pd.Series(sucesion).mean()
    print( 'Promedio de distancias entre '+str(desde)+' y '+str(desde+intervalo)+': ',promedio )

En este ejemplo calcularemos los promedios de las distancias para los números primos entre 1 y 1001, entre 1001 y 2001, entre 2001 y 3001 y así hasta completar 10 promedios:

Parecería que la distancia entre primos tiene una tendencia a ir creciendo a medida que los examinamos en números mas grandes. Aprovechemos la función de graficar y dibujemos los promedios de las distancias. Para ello tan sólo almacenamos las distancias en una lista y luego llamamos a nuestra función grafica. El programa principal quedaría así:

#--------------------PROGRAMA PRINCIPAL-------------------------
# Parametros
consecutivo_inicial = 1   # Desde cuál consecutivo comienza
cantidad = 1000    # Cuantos primos promediará
intervalo = 1000    # Espacio entre el comienzo de cada rango
numero_iteraciones = 10
promedios = []      # Lista que almacenará los promedio

final = consecutivo_inicial +(intervalo * numero_iteraciones)
for desde in range(consecutivo_inicial, final, intervalo):
    primos = lee_primos(cantidad, inicio=desde)
    sucesion = sucesion_distancias(primos)
    promedio = pd.Series(sucesion).mean()
    print( 'Promedio de distancias entre '+str(desde)+' y '+str(desde+intervalo)+': ',promedio )
    promedios.append(promedio)
grafica(promedios)
plt.show()

Y el resultado sería como este:

Si, efectivamente la gráfica muestra que crece, pero parecería que se va aplanando en la parte alta. De nuevo no seamos tímidos e intentémoslo con muchos valores. ¿Que tal intervalos de a millón? ese es un buen promedio. Y dado que contamos con 50 millones de primos en nuestro archivo, hagamos la gráfica de 5 puntos con promedios cada diez millones de intervalos de un millón de primos. Los parámetros serían:

# Parametros
consecutivo_inicial = 1   # Desde cuál consecutivo comienza
cantidad = 1000000    # Cuantos primos graficará
intervalo = 10000000    # Espacio entre el comienzo de cada rango
numero_iteraciones = 5

Y el resultado nos da:

Efectivamente, crece y se aplana en la parte alta, parecería ser asintótica o sea que crece infinitamente pero acercándose siemre a un valor. Por supuesto esto no demuestra nada, sólo nos permite suponer. Si fuera asintótica, ¿a que valor tiende a hacercarse? ¿será a un valor primo?.

El programa completo queda de la siguiente manera:

import matplotlib.pyplot as plt
import math, time
import pandas as pd
import numpy as np

#------------ Funciones -----------------------------------
# Grafica
def grafica(sucesion,  desde=1):
    fig = plt.figure()
    ax = fig.add_subplot(211)
    ex = plt.subplot(1,1,1)
    plt.scatter(range(desde, len(sucesion)+desde), sucesion)
    plt.plot(range(desde, len(sucesion)+desde), sucesion, linewidth ='0.2')
    ex.set_title('Promedios de distancia entre primos') 
    
# Lee del archivo
def lee_primos(cantidad, inicio = 1):
    f_in = 'primos_hasta_1000000000.txt'
    f = open(f_in, 'r')
    contador = 0 # Numeros almacenados en la lista
    indice = 0 # Registros leídos del archivo
    primos = []
    
    for numero in f:
        if indice >= inicio:
            primos.append(int(numero))
            if contador == cantidad:
                break
            contador += 1
        indice += 1
    return primos

# Genera lista de distancias
def sucesion_distancias(lista_primos):
    sucesion = []
    anterior = lista_primos[0]
    for primo in lista_primos[1:len(primos)]:
        distancia = primo - anterior
        sucesion.append(distancia)
        anterior = primo
    return sucesion
#---------------------------------------------------------------
#--------------------PROGRAMA PRINCIPAL-------------------------
# Parametros
consecutivo_inicial = 1000000   # Desde cuál consecutivo comienza
cantidad = 2000    # Cuantos primos promediará
intervalo = 1000000    # Espacio entre el comienzo de cada rango
numero_iteraciones = 50
promedios = []      # Lista que almacenará los promedio

final = consecutivo_inicial +(intervalo * numero_iteraciones)
for desde in range(consecutivo_inicial, final, intervalo):
    primos = lee_primos(cantidad, inicio=desde)
    sucesion = sucesion_distancias(primos)
    promedio = pd.Series(sucesion).mean()
    print( 'Promedio de distancias entre '+str(desde)+' y '+str(desde+intervalo)+': ',promedio )
    promedios.append(promedio)
grafica(promedios)
plt.show()

Para terminar la entrada seamos más atrevidos y hagamos 50 puntos. Que tal los promedios de las distancias de millón de primos cada millón, desde 1 hasta 50 millones. Es una hermosa gráfica que se ve así:

Recordemos que el eje x representa el número del intervalo (o sea el primer intervalo, el segundo intervalo, el tercer intervalo y así sucesivamente) y el eje y es el promedio de las distancias en dicho intervalo. Para la gráfica anterior cada intervalo contenia un millón de números primos. Una más antes de cerrar, hasta 100 millones:

Cuál será la asíntota?


Buscando patrones Proximamente… Frecuecias de las distancias

]]>
https://monodelapila.com/python/jugando-con-python-y-numeros-primos-iii/feed/ 0
Jugando con Python y números primos (II) https://monodelapila.com/python/jugando-con-python-y-numeros-primos-ii/ https://monodelapila.com/python/jugando-con-python-y-numeros-primos-ii/#respond Sun, 24 Oct 2021 13:16:58 +0000 https://monodelapila.com/?p=438 Leer más…]]> Buscando patrones

Los número primos parecen impredecibles. ¿Cual es el patrón detrás de los números primos?. Desde hace milenios se está buscando este patrón. Pero hoy contamos con tecnología muy poderosa al alcance de la mano. Contamos con un archivo con gran cantidad de números primos que hicimos en la entrada anterior y con Python que nos permite hacer cálculos y gráficos a gran velocidad.

Busquemos, por ejemplo, la distancia que existe entre números primos. Los primeros números primos son 1, 2 y 3 hay una unidad de distancia entre ellos. Son consecutivos si los miramos en el conjunto de los números enteros. Mientras que 3, 5, 7 tienen dos unidades de distancia entre ellos. Entre 7 y 11 hay 4 unidades y entre 11 y 13 hay sólo 2 unidades de distancia, entre 13 y 17 hay 4 unidades y entre 17 y 19 hay 2. Una sucesión?: 1, 1, 2, 2, 4, 2, 4, 2. Graficando esto tendríamos:

Entendiendo que en el eje x tenemos el consecutivo o sea, el segundo primo (que es 2) tiene una distancia de 1 con el anterior, el tercer primo (que es 3) tiene una distancia de 1 con el anterior, el cuarto primo (que es 5) tiene una distancia de 2 con el anterior y así sucesivamente. El programa en Python que nos permite graficarlo es el siguiente:

import matplotlib.pyplot as plt
import math, time
import numpy as np

primos = [1,2,3,5,7,11,13,17,19]
sucesion = []
anterior = primos[0]
for primo in primos[1:len(primos)]:
    distancia = primo - anterior
    sucesion.append(distancia)
    anterior = primo
for x in sucesion:
    print(x)

# Grafica
fig, ax = plt.subplots()
plt.scatter(range(2, len(sucesion)+2), sucesion)
ax.set_xlabel('Consecutivo primo')
ax.set_ylabel('Distancia')
plt.show()

No tenemos en cuenta el primer primo y comenzamos a calcular distancias desde el segundo, por ello en el bucle for comenzamos en el elmento 1 no en el cero (0) que se lo hemos asignado a la variable anterior:

anterior = primos[0]
for primo in primos[1:len(primos)]:

Y por ello tambien al momento de graficar comenzamos por 2 y le sumamos 2 al final del eje en la línea:

plt.scatter(range(2, len(sucesion)+2), sucesion)

La función plt.scatter grafica los puntos. Recibe dos argumentos: la lista con los puntos para el eje x, y la lista con los puntos para el eje y. La lista para x la hacemos con la funcion range, dándole dos argumenos, inicio y final del rango: comienza en 2 y termina en la longitud mas 2 de la lista sucesion que contiene las distancias que queremos examinar. Para el eje y basta con darle la lista sucesion que creamos en el bucle for inicial.

Si trazamos una línea entre los puntos de pronto podremos ver mejor algún patrón escondido Ello lo hacemos con la función plt.plot. Agregamos la siguiente instrucción justo debajo de plt.scatter:

plt.plot(range(2, len(sucesion)+2), sucesion)

Y obtenemos la siguiente gráfica:

Recordemos que el eje x no representa un número primo sino un consecutivo (el primer primo, el segundo primo, el tercer primo,…, el i-esimo primo, etc.) y el eje y, la distancia entre el i-esimo número primo y el anterior.

¿No ve aún el patrón?, bueno 8 puntos son muy pocos. Pero no seamos tímidos, tenemos un archivo con 50 millones de puntos. Intentemos hacer el gráfico con ellos. A lo mejor detectamos algo.

Leyendo los puntos del archivo

En la entrada anterior generamos un archivo con gran cantidad de números primos. Si descomprimimos el archivo (se requiere espacio en disco por que tiene mas de 500 megas) tendremos un archivo con extensión htm. Es conveniente cambiar la extensión a .txt por razones de estandarización. Si usted mismo lo generó usando el programa de la entrada anterior, pues ya tendrá en su disco el archivo con el nombre que le haya asignado. Visualizar un archivo tan grande suele ser dificil con el block de notas, sugiero usar el software EditPad Lite que es muy liviano y gratuito para uso personal.

Para leer el archivo desde Python construiremos una función que nos permita leerlo y almacenar su contenido (total o parcialmente) en una lista.

def lee_primos(cantidad, inicio = 0):
    f_in = 'primos_hasta_1000000000.txt'
    f = open(f_in, 'r')
    contador = 0 # Numeros almacenados en la lista
    indice = 0 # Registros leídos del archivo
    primos = []
    
    for numero in f:
        if indice >= inicio:
            primos.append(int(numero))
            if contador == cantidad:
                break
            contador += 1
        indice += 1
    return primos

Esta función tendrá la flexibilidad para entregarnos un subconjunto de números primos. El primer parámetro permite indicarle cuantos números del archivo queremos extraer. El parámetro inicio, que es opcional y por omisión tiene el valor 1, permite indicarle desde cual queremos iniciar: el primero o el milésimo. Si llamamos la función:

lee_primos(500, inicio = 1000)

Estamos recuperando 500 números primos del archivo a partir del que se encuentra en la posición 1000. Mientras que si sólo escribimos:

lee_primos(500)

Estamos extractando los primeros 500 números primos.

Hagamos también una función para graficar de forma que podamos llamarla tantas veces como queramos:

# Grafica
def grafica(sucesion,  desde=1):
    fig = plt.figure()
    ax = fig.add_subplot(211)
    ex = plt.subplot(1,1,1)
    plt.scatter(range(desde, len(sucesion)+desde), sucesion)
    plt.plot(range(desde, len(sucesion)+desde), sucesion, linewidth ='0.2')
    ex.set_xlabel('Consecutivo primo')
    ex.set_ylabel('Distancia')
    ex.set_title('Distancia entre primos desde el '+str(desde)+' hasta '+str(desde+len(sucesion)-1))

Esta función recibe un parametro obligatorio y uno opcional. El obligatorio es la lista de distancias a graficar, se recibe en la variable sucesion. La segunda variable (opcional) indica en qué número debe comenzar el eje x, o sea desde cual consecutivo se envía la sucesión.

El cálculo de la distancia entre números primos es el ciclo for que vimos al iniciar esta entrada. Haremos una función con este bucle para poderlo reusar:

# Genera lista de distancias
def sucesion_distancias(lista_primos):
    sucesion = []
    anterior = lista_primos[0]
    for primo in lista_primos[1:len(primos)]:
        distancia = primo - anterior
        sucesion.append(distancia)
        anterior = primo
    return sucesion

Listo. Sólo nos queda el programa principal, Definiremos unos parámetros como el número de puntos a graficar y desde cual consecutivo comenzaremos:

# Parametros
consecutivo_inicial = 1000   # Desde cuál consecutivo comienza
cantidad = 100    # Cuantos primos graficará

Para este ejemplo estamos graficando 100 puntos comenzando por el primo ubicado en la posición mil. A continuación llamamos a la función lee_primos y almacenamos la lista generada en la variable sucesion.Esta variable la usamos como entrada en la función grafica, por último mostramos la gráfica con plt.show().

primos = lee_primos(cantidad, inicio=consecutivo_inicial)
sucesion = sucesion_distancias(primos)
grafica(sucesion, desde = consecutivo_inicial)

plt.show()

El programa completo sería el siguiente:

import matplotlib.pyplot as plt
import math, time
import numpy as np

#------------ Funciones -----------------------------------
# Grafica
def grafica(sucesion,  desde=1):
    fig = plt.figure()
    ax = fig.add_subplot(211)
    ex = plt.subplot(1,1,1)
    plt.scatter(range(desde, len(sucesion)+desde), sucesion)
    plt.plot(range(desde, len(sucesion)+desde), sucesion, linewidth ='0.2')
    ex.set_xlabel('Consecutivo primo')
    ex.set_ylabel('Distancia')
    ex.set_title('Distancia entre primos desde el '+str(desde)+' hasta '+str(desde+len(sucesion)-1))
    

# Lee del archivo
def lee_primos(cantidad, inicio = 1):
    f_in = 'primos_hasta_1000000000.txt'
    f = open(f_in, 'r')
    contador = 0 # Numeros almacenados en la lista
    indice = 0 # Registros leídos del archivo
    primos = []
    
    for numero in f:
        if indice >= inicio:
            primos.append(int(numero))
            if contador == cantidad:
                break
            contador += 1
        indice += 1
    return primos

# Genera lista de distancias
def sucesion_distancias(lista_primos):
    sucesion = []
    anterior = lista_primos[0]
    for primo in lista_primos[1:len(primos)]:
        distancia = primo - anterior
        sucesion.append(distancia)
        anterior = primo
    return sucesion
#---------------------------------------------------------------
# Parametros
consecutivo_inicial = 1000   # Desde cuál consecutivo comienza
cantidad = 100    # Cuantos primos graficará
primos = lee_primos(cantidad, inicio=consecutivo_inicial)
sucesion = sucesion_distancias(primos)
grafica(sucesion, desde = consecutivo_inicial)

plt.show()

Y obtenemos nuestra gráfica de 100 puntos comenzando en el milesimo primo:

Dijimos que no seríamos tímidos, podemos intentarlo con un millón de puntos:

# Parametros
consecutivo_inicial = 1000   # Desde cuál consecutivo comienza
cantidad = 1000000    # Cuantos primos graficará

Se ven algunas cosas interesantes. Muchas distancias están entre 2 y 60, un poco menos entre 60 y 100 y pocas son mayores que 100. ¿Será así para el intervalo entre digasmos 10 millones y 11 millones?. Miremos:

Aquí se ven muchos puntos con distancias entre 2 y 100, no tantos entre 100 y 150 y pocos mayores que 150. Significa esto que cada vez hay mas distancia entre los números primos?, en consecuencia hay menos números en intervalos superiores?

Tendremos que hacer conteos para averiguarlo, pero esta entrada ya está muy larga, lo dejamos para la próxima semana.


Generando Números Primos Promedios de las distancias

]]>
https://monodelapila.com/python/jugando-con-python-y-numeros-primos-ii/feed/ 0
Jugando con Python y números primos (I) https://monodelapila.com/python/jugando-con-python-y-numeros-primos/ https://monodelapila.com/python/jugando-con-python-y-numeros-primos/#respond Mon, 18 Oct 2021 19:36:45 +0000 https://monodelapila.com/?p=420 Leer más…]]> Generando números primos.

Los números primos son el misterio de las matemáticas. Son esos números que solo se pueden dividir por 1 y por ellos mismo. En general no tenian mucha utilidad hasta que comenzaron a usarse para criptografía. Pero siempre han despertado la curiosidad de los aficionados a las matemáicas en razón a que su distribución en la recta de números enteros no parece tener un patrón, parecerían puestos al azar.

Eratóstenes enseñando en Alejandría

Doscientos años antes de Cristo el matemático griego Eratóstenes de Cirene se entretenia calculando números primos. Creó una técnica para encontrar los números primos en un rango de números, a esto se le llama la criba de Eratóstenes. El método es sencillo y perfecto para comenzar a jugar con Python. Imagine que tiene una lista de números del 1 al 100 y desea conocer cuales de ellos son primos. El método consiste en suponer que todos son primos y empezar a descartar, al finalizar, los no descartados, serán los primos.

Apliquemos el método describiéndolo de forma narrativa y luego haremos un programa para cálcular los números primos que se encuetran en digamos un rango entre 1 y mil millones usando Python y nuestro modesto portatil.

El método comienza con la certeza que el 1 y el 2 son primos. En principio todos los números están marcados como candidatos a primos pero no tenemos dudas que estos dos lo son. Ubicados en el número 2, multiplicamos a si mismo y a los números que le siguen por 2 hasta llegar a nuestro límite (100 para nuestro ejemplo inicial) el resultado lo desmarcamos, ya no será candidato a número primo. De tal forma que quedan desmarcados el 4,6,8,10,12,14,16,… etc, todos los pares. Pasamos al siguiente número no desmarcado, el 3 y multiplicamos los números que le siguen por 3, el resultado lo desmarcamos, quedando descartados todos los números múltiplos de 3: 9,12 (ya habia sido desmarcado), 15,18,21…. etc, el siguiente número no desmarcado es el 5, al aplicar el método se desmarcarán todos los múltiplos de 5 (los terminados en 0 o en 5: 10,15,20,25,30,…etc.) el método continua y no es necesario llegar a 100 basta con llegar al número cuyo cuadrado sea mayor que el límite, para nuestro ejemplo el límite es 100 y dado que 10 al cuadrado da 100. Al llegar a 10 ya habremos desmarcado todos los necesarios, los que quedan marcados son los números primos de 1 a 100.

Ahora llevemos el método a un programa en Python. Se deberá definir un límite del rango a examinar, a esa variable la llamaremos limite. Se puede ver que se requerirán dos bucles uno que recorra los números del 2 hasta la raiz cuadrada del límite y otro desde el número que estamos examinando hasta el límite. Además Python permite definir rangos de forma muy sencilla: range(1,limite). Bueno vamos en orden:

1. Librerias. Importamos las librerias math y time. La primera porque requerimos hacer operaciones matemáticas y la segunda por que calcularemos el tiempo que tarda nuestro programa en generar los números en un rango dado.

import math, time

2. Parámetros. Definimos las varibales que usaremos: limite: para el rango de números, el nombre del archivo donde guardaremos los primos encontrados y el número hasta el cual recorreremos uno de los bucles (la raiz cuadrada del límite).

import math, time

limite = 1000000
cuadrado_limite = int( limite**(1/2) ) # Lo convertimos a entero para evitar problemas en los bucles
nombre_archivo = 'primos_hasta_'+str(limite)+'.txt'
inicio = time.time() # Tiempo en el cual comienza la ejecución

3. Crear la criba. Crearemos una lista del tamaño que queramos. Será nuestra criba. Esta lista estará llena de unos (1s) y la posición en la lista dirá a qué número nos referimos. De tal forma que todas las posiciones inicialmente tendrán un 1, indicando que son candidatos a primos. En la medida que descartemos números, el contenido de la posición respectiva la reemplazaremos por un cero (0).

# Crea lista de unos
criba = list((1,1,1)) # Inicializa la lista con los unos correspondientes a la posición 0, 1 y 2
for i in range(0, limite - 1 ):
    criba.append(1)

4. Recorremos la criba. Con un bucle for recorremos desde el número 2 hasta la raiz cuadrada del límite. Dentro de este bucle creamos otro que recorre desde el número en que vamos hasta un número que al multiplicarlo por el número en que vamos no supere el límite.

Multiplicamos estos dos índices y en la posición de la lista correspondiente al resultado de la multiplicación cambiamos el número (inicialmente era un 1) por un cero. Descartándolo como número primo.

for index in range(2, cuadrado_limite): 
    if (criba[index] == 1 )
        for index2 in range(index,math.floor(len(criba)/index)):
            criba[index*index2] = 0

5. Guardamos los resultados. Ya tenemos una lista de python llamada criba que contiene ceros y unos (podriamos hacerlo con True y False, probablemente sería un uso más eficiente de la memoria). La posición donde encontremos un 1 será un número primo. Ahora guardemos los resultados en un archivo de texto. Pero antes imprimamos en patalla el tiempo de finalización y el transcurrido (en segundos):

#Resultados
print('Fin: ',time.time())
print('Tiempo transcurrido: ',time.time() - inicio)

Por supuesto un equipo con mejor desempeño de procesador será más rápido y uno con suficiente memoria RAM permitirá hacer cribas muy grandes.

Para imprimir los resultados sólo debemos recorrer la lista llamada criba. Lo hacemos con un ciclo for con dos indices, el primero captura del consecutivo del for y el segundo el valor de la lista:

f = open(nombre_archivo, "w")
for i,x in enumerate(criba):
    if x ==1:
        f.write(str(i)+'\n')
f.close()

Ahora todo junto

El código completo sería el siguiente:

#Generación de números primos con el método de Criba de Eratóstenes
import math, time

limite = 1000000000
nombre_archivo = 'primos_hasta_'+str(limite)+'.txt'
inicio = time.time()
print('Inicio: ',inicio)

cuadrado_limite = int( limite**(1/2) )
# Crea lista de unos
criba = list((1,1,1))
for i in range(0, limite - 1):
    criba.append(1)

#Recorre lista
for index in range(2, cuadrado_limite): 
    for index2 in range(index,math.floor(len(criba)/index)):
        criba[index*index2] = 0
        
#Resultados
print('Fin: ',time.time())
print('Tiempo transcurrido: ',time.time() - inicio)

f = open(nombre_archivo, "w")
for i,x in enumerate(criba):
    if x ==1:
        f.write(str(i)+'\n')
f.close()

Generando los números primos hasta 1000 millones mi portatil con 16 Gigas de RAM y procesador Intel Core i7 de séptima generación (viejito) se demoró 40 minutos (2.397 segundos).

Aunque grabando el archivo se demoró otros 10 minutos. Generó un archivo de texto de 539.85 megabytes, que dejo a continuación, por que será útil para seguir jugando con primos en otras entradas. Está en formato texto con extensión htm comprimido en zip: MUCHOS NÚMEROS PRIMOS


Buscando patrones

]]>
https://monodelapila.com/python/jugando-con-python-y-numeros-primos/feed/ 0
My-Links https://monodelapila.com/wordpress/my-links/ https://monodelapila.com/wordpress/my-links/#respond Wed, 08 May 2019 01:21:11 +0000 https://monodelapila.com/?p=352 Leer más…]]>

It is a very simple but useful plugin for WordPress.
You can use this plugin to find all the links of your website to verify if they are “strange” or trustworthy.
If you do not trust the link, you can remove it.

Please help us test this plugin and let us know if something is not working as you think it should.

Download here

DONATION

If this plugin has been useful, consider supporting its improvement.





]]>
https://monodelapila.com/wordpress/my-links/feed/ 0
Árbol rascador para gatos utilizando Arduino https://monodelapila.com/arduino/arbol-rascador-para-gatos-utilizando-arduino/ https://monodelapila.com/arduino/arbol-rascador-para-gatos-utilizando-arduino/#respond Wed, 24 Jan 2018 01:09:37 +0000 http://monodelapila.com/?p=143 Leer más…]]> Cómo es esto posible?. Bueno se trata del típico árbol para que el gato afile sus uñas, sólo que con un pequeño añadido, un detector de movimiento para que en el momento en que rasguñe se active el sonido de un ave que lo incentive a seguir explorando el árbol.
Con un gatico nuevo en la casa se requiere proveerle un lugar donde pueda rascar y afilar sus uñas, de este modo no lo hará en el sofá.

Aquí el resultado final

Primero el diseño

La estructura se hace con tubo PVC de pulgada y media. Va del suelo al techo para que simule un árbol cuyo tronco puede ser escalado por el minino. Para ello se recubre el tubo con lazo de fique (Cabuya). Me han dicho que el lazo sintético no funciona igual, no lo he probado.

diseño-árbol-gato.pdf

Para bajar costos y ayudar al planeta podemos reciclar. Utilicé las tablas sobrantes de un piso laminado que había guardado con la esperanza de que fueran de utilidad en algún momento. Esta tablas resultaron ser buenísimas, son delgadas y duras, fáciles de recortar con una caladora. El lazo se consigue en ferreterías al igual que los herrajes, tuercas y tornillos utilizados. El diseño aquí mostrado fue el inicial,  cambió en el camino. Modifique su diseño de acuerdo a la altura techo-piso de que disponga.

Las tablas que lo anclan al piso y al techo son un poco mas gruesas. Utilicé aglomerado de 1 cm que conseguí en una miscelania (papelería). El sonido lo tome de la estupenda pagina: https://www.sonidosmp3gratis.com/pajaros

Algunas herramientas indispensables incluyen:

  • Taladro
  • Caladora
  • Nivel
  • Adaptador del taladro para hacer orificios

En cuanto a la electrónica, se requiere:

  • Fuente de corriente de un teléfono celular que ya no use.
  • Cable telefónico 4 metros
  • Pequeño parlante de 8Ω (ohmios) 1.5 watt.
  • Módulo sensor de vibración (SW-420)
  • Arduino nano V3
  • Modulo Lm2596 Convertidor Fuente Dc-dc Arduino
  • Módulo DFplayer mini

El circuito

Implementación del árbol rascador

Este blog no es sobre rascadores para gatos, que los hay y muy buenos. Sin embargo dedicaré algunas líneas para describir la construcción del árbol.

Corte los tubos de PVC de acuerdo a su diseño. En las terminales del sensor de vibración conecte cables suficientemente largos para que salgan del tubo. En mi caso fue de 1m.  Ubique el sensor de vibración (SW-420) en el interior del tubo en la parte alta del mismo. Adhieralo con cinta de papel al interior del tubo a unos 2 cm del borde superior como se aprecia en la imagen.

Corte las tablas con el diseño que desee. Es deseable que no tengan esquinas sino bordes redondeados. Con el adaptador del taladro realice los orificios que conecta las tablas con los tubos.
Para unir la tabla al tubo utilicé cuatro escuadras de 1.5cm. Es importante que el tubo y la tabla estén fuertemente unidos por cuanto soportarán el peso del gato. El parlante quedó ubicado en la parte baja de un tubo (cómo se aprecia en la foto), usé cable telefónico para llevar el sonido hasta el speaker.

Antes de cubrir los tubos y las tablas pase el cableado desde el parlante (un par) y desde el sensor (tres cables) hasta la base del árbol. Procure que el recorrido de los cables sea por el interior de los tubos y por la parte de abajo de las tablas. Aunque serán cubiertas por la tela y el lazo es mejor dejarlo lo más ocultos posibles.

Para cubrir los tubos con el lazo basta con realizar un orificio en ambos extremos del tubo y pasar el lazo por allí, realizar un nudo en el extremo del lazo y enrollar este en el exterior del tubo. Esta extraña descripción queda aclarada con la siguiente imagen

Con tela gruesa y pegante para madera (colbón) cubra las tablas. En mi caso intenté con un color verde oscuro de tela-fieltro en la parte de abajo y otra (verde más clara) cubriendo la parte superior de cada tabla.

El Programa

Usamos los pines digitales 9 y 10 para la transmisión y recepción de datos con el módulo DFPlayer. Para lo cual hacemos uso de las librerías: DFRobotDFPlayerMini.h que permite manejar la tarjeta de reproducción de audio y la, siempre muy útil, librería SoftwareSerial.h para manejar la comunicación con este dispositivo.  El pin 5 digital lo usamos para el detector de vibración como se vió en el diagrama.

El programa simplemente detecta si hay un 1 en el pin 5 y si es así reproduce una pista grabada en la tarjeta SD. Realmente el programa se explica por si mismo, pero si hay dudas, con gusto las aclaro.

#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h" 
SoftwareSerial mySoftwareSerial(9, 10); // RX, TX
DFRobotDFPlayerMini misSonidos;

void setup()
{
 Serial.begin(9600);
 mySoftwareSerial.begin(9600); //Establece la velocidad de transmisión entre Arduino y la tarjeta DFPlayer
 misSonidos.begin(mySoftwareSerial); //Inicializa la tarjeta DFPlayer
 misSonidos.volume(25); //Pone el valor de volume (0~30)
 pinMode(5,INPUT);
}
void loop()
{
 int sensor=digitalRead(5);
 if (sensor==1)
 {
 misSonidos.play(1); //Reproduce el canto
 delay(5000);
 misSonidos.stop();
 }
 sensor=digitalRead(5);
 if (sensor==1)
 {
    misSonidos.next(); //Reproduce el canto
    delay(3000);
    misSonidos.stop();
 }
 sensor=digitalRead(5);
 if (sensor==1)
 {
    misSonidos.next(); //Reproduce canto
    delay(3000);
    misSonidos.stop();
 }
 sensor=digitalRead(5);
 if (sensor==1)
 {
    misSonidos.next(); //Reproduce insecto
    delay(3000);
    misSonidos.stop();
    sensor=digitalRead(5);
    if (sensor==1)
    {
        misSonidos.next(); //Reproduce gallo
        delay(3000);
        misSonidos.stop();
    }
 } 
}

En la página sonidosmp3gratis.com se encuentran todo tipo de ruidos y sonidos útiles. Particularmente use el gallo, y otros de pájaros, a mi gata le interesa especialmente el que corresponde a pichones en un nido ¿por qué será?. Los archivos deben ser renombrados como 001.mp3, 002.mp3 etc.

]]>
https://monodelapila.com/arduino/arbol-rascador-para-gatos-utilizando-arduino/feed/ 0
Servidor Web usando LUA-Rtos https://monodelapila.com/programacion-lua/servidor-web-con-lua-rtos/ https://monodelapila.com/programacion-lua/servidor-web-con-lua-rtos/#respond Fri, 13 Oct 2017 17:44:14 +0000 http://monodelapila.com/?p=103 Leer más…]]> Los módulos incluidos en este interprete, LUA (Rtos), facilitan la realización de muchas tareas entre las cuales está la puesta en marcha de un servidor web.

Particularmente el módulo net tiene todo lo necesario como veremos a continuación

El proyecto consiste en dos archivos: system.lua, que el interprete busca y ejecuta (si existe) en el momento de hacer el boot. Y la página web de inicio que llamaremos index.html como es usual.

Comenzamos por conectarnos a nuestra tarjeta a través del popular y gratuito cliente Telnet: putty.

Configuración

Para conectarnos a la tarjeta de desarrollo: WeMos® WiFi + Bluetooth Battery ESP32, usamos la siguiente configuración:

Mi tarjeta es reconocida en el puerto serial COM11. En este  link se explica cómo detectar el puerto al cual está conectada su tarjeta.

Al conectar y encender la tarjeta, mi tarjeta tiene un pequeño interruptor para ponerla en funcionamiento, se obtiene la siguiente pantalla:

Mi tarjeta tiene un pequeño interruptor para encenderla

Es en la práctica un sencillo y útil sistema operativo muy parecido al linux. Podemos listar los archivos alojados usando el comando ls. También podemos crear o editar un archivo usando os.edit(“nombre del archivo“)

Conectarse a la red

Para conectarse a la red Wi-Fi basta con el uso de la instrucción: net.wf.setup. Con tres argumentos, el primero, el modo de la red. Para estación usamos el 1. El segundo el nombre de la red SSID (entre comillas), y el tercero el password para conectarse a su Wi-Fi, también entre comillas. Queda algo como esto:

net.wf.setup(1, "Miwifi", "miclave")

Para verificar la IP que le asignó su access point, usamos net.stat() así:

Aún debemos iniciar la red con net.wf.start().

Iniciar Servidor Web

Usamos ahora el editor para crear una página de ejemplo que será servida por nuestro WebServer.  Para ello basta con escribir:

os.edit("index.html")

Obtenemos un editor en el cual podemos escribir nuestra página Web. Aquí mi sencillo ejemplo:os.edit("index.html")

Grabamos con Ctrl-S. Con Ctrl-Y accedemos a la ayuda del editor:

Para salir del editor basta con la combinación de teclas Ctrl-Q

Sólo nos resta subir el servidor el cual buscará la página index.html y la mostrará a quien se conecte. Esto se hace con la instrucción:

net.service.http.start()

Podemos comprobarlo en nuestro navegador, accediendo a la IP que nos asignó el access point:

]]>
https://monodelapila.com/programacion-lua/servidor-web-con-lua-rtos/feed/ 0
Instalando LUA-RTOS en ESP-32 https://monodelapila.com/programacion-lua/instalando-lua-rtos-en-esp-32/ https://monodelapila.com/programacion-lua/instalando-lua-rtos-en-esp-32/#respond Wed, 04 Oct 2017 21:33:06 +0000 http://monodelapila.com/?p=36 Leer más…]]>

Objetivo

WeMos® WiFi + Bluetooth Battery ESP32 Development Tool (1164436)

Alistar la tarjeta de desarrollo basada en ESP32 para programar con LUA.

Lo haremos usando un equipo con Windows.

Firmaware

Para subir a la tarjeta el firmware es necesario generar el archivo bin. Esto se hace siguiendo lo señalado en http://esp-idf.readthedocs.io/en/latest/get-started/index.html#setup-toolchain.

Resumo los pasos:

  1. Instalar el toolchain MSYS2 en Windows.
  2. De este link se descargan las herramientas comprimidas en zip
  3. Se descomprime en una carpeta en C: llamada msys32
  4. Se ejecuta el programa C:\msys32\mingw32.exe se obtiene una ventana como la que se ve a continuación:
  5. Aquí se observa un inconveniente, la instalación automáticamente crea la carpeta /home/Pedro H. Ocampo// esos espacios en blanco serán un problema al momento de compilar. Dado que utilizó la variable de entorno del nombre de usuario (USERNAME) para dar nombre a la carpeta, no me complico y reingreso con otro usuario.

Mucho mejor sin espacios.

6. Por línea de comandos en la ventana de MSYS32 creo la carpeta esp usando el comando mkdir:

7. Cargar las librerías ESP32 (ESP-IDF). Para lo cual nos ubicamos en la carpeta que acabamos de crear y allí descargamos a través de git los archivos requeridos.

cd ~/esp
git clone --recursive https://github.com/espressif/esp-idf.git

Se creará la carpeta esp-idf. Cinco minutos de espera mientras trae los archivos a nuestro disco.

Se verá algo como esto:

Crear la variable de entorno IDF_PATH.  En la carpeta  C:/msys32/etc/profile.d/ creamos el archivo export_idf_path.sh y en el, sólo ponemos la línea:   export IDF_PATH=“C:/msys32/home/PedroH/esp/esp-idf” Por supuesto cambie “PedroH” por su nombre de usuario

8. Cierre la ventana del msys32 y vuelva a abrirla para que cargue la variable de entorno. Puede probar si la tomó, escribiendo:

echo $IDF_PATH

9. El tutorial propone que hagamos una prueba de que todo está bien, compilando el programa hello_world que viene como ejemplo. Para lo cual copiamos la carpeta respectiva en nuestro directorio esp:

cd ~/espcp -r $IDF_PATH/examples/get-started/hello_world .

El punto al final de la anterior instrucción es importante, no lo olvide

10. Conecte la tarjeta y préndala. En mi caso la reconoce en el puerto COM11. Este link explica cómo saber el puerto COM al cual está conectada la tarjeta.

11. Entre en la carpeta hello_world y corra el menuconfig

cd ~/esp/hello_world

make menuconfig

12. Debe observar una ventana como la siguiente:

13. Configure el puerto COM de la tarjeta.

Entre a la cuarta opción:   Serial flasher config

Y allí seleccione: Default serial port

En mi caso cambio lo que dice allí (/dev/ttyUSB0) por COM11. Luego Ok, Save y Exit.

14. Para construir el firmware y subirlo a la tarjeta damos:

make flash

Cuatro minutos de espera y obtenemos esto:

15. Aparentemente ya tenemos un programa hello_world en la tarjeta. Lo intento verificar conectándome con ESPlorer:

Con esto confirmamos que tenemos instalado en la tarjeta un programa en C corriendo. Si todo funciona bien ahora podremos instalar el interprete de LUA  para hacer nuestros propios desarrollos en este lenguaje y aprovechar las virtudes de esta tarjeta.

Instalar el firmware de LUA-RTOS

  1. Describiremos los pasos encontrados aquí. De nuevo usamos git para bajar ahora el LUA-RTOS. Vamos a la carpeta esp y desde allí ejecutamos:
git clone --recursive https://github.com/whitecatboard/Lua-RTOS-ESP32

  1. Vamos a la carpeta LUA_RTOS
cd Lua-RTOS-ESP32

Editamos el archivo env

Cambiamos las líneas

export IDF_PATH

por:

export IDF_PATH=/home/PedroH/esp/esp-idf

y la línea export OS=

por:

export OS=”Windows_NT”

  1. Ejecutamos:
source ./env

 

  1. Suponemos que nuestra tarjeta corresponde a Genérica y ejecutamos:
make SDKCONFIG_DEFAULTS=GENERIC defconfig

Obtenemos esta pantalla:

  1. Volvemos a menuconfig y verificamos que el Puerto COM sea el correcto
make menuconfig

Cambiamos  │/dev/tty.SLAB_USBtoUART   por COM11

Verificamos que la velocidad de transmission sea 115200

  1. Estando en la carpeta /home/PedroH/esp/Lua-RTOS-ESP32 (en lugar de PedroH estará su usuario) construimos el firmware y lo subimos a tarjeta con el comando:
make flash

Esta vez tuve que presionar el botón EN, en la tarjeta, por dos segundos, para entrar en el modo de carga.

Tenemos el ambiente listo para programar en LUA usando ESPlorer

También se podría usar putty dado que el firmware cargado permite el uso de un editor para programar directamente en la tarjeta.

 

]]>
https://monodelapila.com/programacion-lua/instalando-lua-rtos-en-esp-32/feed/ 0
Internet de las Cosas (IOT) https://monodelapila.com/publica/hello-world/ https://monodelapila.com/publica/hello-world/#respond Wed, 04 Oct 2017 01:32:17 +0000 http://monodelapila.com/?p=1 Leer más…]]> Si es aficionado a la electrónica o al “cacharreo” con tarjetas de desarrollo para el internet de las cosas (Esp8266, Arduino, Esp32, etc.) y quiere publicar su proyecto, dese de alta aquí y publique su proyecto. Por sencillo que sea puede ser la pieza clave para el desarrollo del proyecto de alguien más.

]]>
https://monodelapila.com/publica/hello-world/feed/ 0