https://jorgechac.blogspot.com: matplotlib

Mostrando las entradas con la etiqueta matplotlib. Mostrar todas las entradas

jueves, 6 de marzo de 2025

Generación de Formas de Onda en Python utilizando la libreria Matplotlib y Numpy

Bienvenido a mi blog, hoy hablaremos un poco de la generación de formas de onda, la cual es la producción de patrones de señales analógicas o digitales, periódicas o no periódicas. Esta acción, se realiza físicamente mediante dispositivos electrónicos llamados generadores de formas de onda. Un generador de forma de onda, produce formas de onda precisas, incluyendo sinusoidales, cuadradas, triangulares y de rampa, así como formas de onda arbitrarias definidas por el usuario utilizando secuencias de datos o transmitiendo continuamente desde un host o instrumento "peer-to-peer" dentro de sistemas de pruebas de señal mixta.

La generación de formas de onda por software se puede realizar con programas especializados que permiten crear, editar y administrar dichas formas de onda, el día de hoy veremos la generación básica de algunas formas de onda en Python, para ello haremos uso de Matplotlib, la cuál es una librería completa para crear visualizaciones estáticas, animadas e interactivas en Python, y de igual forma también usaremos la librería NumPy, que nos trae el poder computacional de lenguajes como C y Fortran a Python, un lenguaje mucho más fácil de aprender y usar. Vamos a ello directamente y veamos el código en Python con sus respectivos comentarios explicativos:

# -------------------------------------------------------------------------
# (| " FormasdeOnda.py                                                  "|)
# (| "                                                                  "|)
# (| " Script que genera las formas de onda más conocidas para mostrar, "|)
# (| " a modo de ejemplo, cómo se realiza el procedimiento.             "|)
# (| "                                                                  "|)
# (| " Este código de ejemplo es de dominio público.                    "|)
# (| "                                                                  "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB     "|)
# (| " Visita  https://jorgechac.blogspot.com                           "|)
# (| "                                                                  "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   	        "|)
# (| " Whatsapp y Ventas NEQUI +573177295861                            "|)
# (| " Bucaramanga - Colombia                                           "|)
# -------------------------------------------------------------------------
import numpy as np # Importamos la biblioteca NumPy para proporciona un
                   # objeto de matriz N-dimensional y funciones
                   # matemáticas de alto rendimiento para operar en esas
                   # matrices.
import matplotlib.pyplot as plt  # Importamos Matplotlib para graficar
                                 # y visualizar

# Definición de parámetros
T = 1  # Duración de la señal en segundos
fs = 1000  # Frecuencia de muestreo en Hz (muestras por segundo)
t = np.linspace(0, T, int(T * fs), endpoint=False)  # Vector de tiempo

# Onda Senoidal
f_sine = 5  # Frecuencia de la onda senoidal en Hz
sine_wave = np.sin(2 * np.pi * f_sine * t) # Generación de la señal senoidal

# Onda Cuadrada
f_square = 2  # Frecuencia de la onda cuadrada en Hz
duty_cycle = 0.01  # Ciclo de trabajo (porcentaje del período en alto)
square_wave = np.where(np.mod(np.floor(2 * duty_cycle * fs * t), 2) == 0, 1, -1)
# Generación de la señal cuadrada

# Onda Triangular
f_triangle = 1  # Frecuencia de la onda triangular en Hz
triangle_wave = 2 * np.abs((10 * f_triangle * t) % 2 - 1) - 1
# Generación de la señal triangular

# Onda Diente de Sierra
f_sawtooth = 10  # Frecuencia de la onda diente de sierra en Hz
sawtooth_wave = 2 * (f_sawtooth * t - np.floor(f_sawtooth * t + 0.5))
# Generación de la señal diente de sierra

# Gráfica de las ondas
fig, axs = plt.subplots(4, 1, sharex=True, figsize=(8, 8))
# Crea una figura con 4 subgráficos

axs[0].plot(t, sine_wave)  # Grafica la onda senoidal
axs[0].set_title('Onda Senoidal')  # Título del primer gráfico

axs[1].plot(t, square_wave)  # Grafica la onda cuadrada
axs[1].set_title('Onda Cuadrada')  # Título del segundo gráfico

axs[2].plot(t, triangle_wave)  # Grafica la onda triangular
axs[2].set_title('Onda Triangular')  # Título del tercer gráfico

axs[3].plot(t, sawtooth_wave)  # Grafica la onda diente de sierra
axs[3].set_title('Onda Diente de Sierra')  # Título del cuarto gráfico

plt.xlabel('Tiempo (seg)')  # Etiqueta del eje X para todas las gráficas
plt.show()  # Muestra la gráfica

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar la grafica en Python con matplotlib, así:

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

Recuerda que en https://jorgechac.blogspot.com nos dedicamos a construir una electrónica mejor! y apoyamos el proyecto CTC GO! (Creative Technologies in the Classroom) que es un programa de educación steam personalizable.

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

También te puede interesar:

Dibujo de un arbol de navidad utilizando el módulo Python Turtle

ARBOL DE NAVIDAD EN PYTHON

Dibujando en Python utilizando la libreria Matplotlib y Numpy

Dibujando en Python utilizando el módulo Python Turtle

Dibujo del logotipo de Python utilizando el módulo Python Turtle

viernes, 17 de febrero de 2023

Dibujando en Python utilizando la libreria Matplotlib y Numpy

Bienvenido a mi blog, hoy hablaremos un poco de el conjunto de Mandelbrot, que es el más estudiado de los fractales. Se conoce así en honor al matemático Benoît Mandelbrot (1924-2010), que investigó sobre él en los años setenta. Este conjunto se define en el plano complejo fijando un número complejo C cualquiera, a partir de C, se construye una sucesión por recursión. Fractal (del latín fractus, "irregular", "fragmentado") es una palabra que acuñó el propio Mandelbrot para describir la repetición "infinita" de patrones geométricos a diferentes escalas, que muestran versiones cada vez más pequeñas de sí mismos. Las partes pequeñas de un fractal, explicaba Mandelbrot, son semejantes al todo, al conjunto completo. Lo más interesante es que el matemático demostró que la mayoría de las formas de la naturaleza son fractales. Los fractales se han utilizado para explicar fenómenos atmosféricos, para analizar las redes vasculares y las redes neuronales del cuerpo humano, para calcular la longitud de las costas, para explicar el crecimiento de los cerebros de los mamíferos, para estudiar los seísmos... Incluso en telecomunicaciones se han diseñado antenas fractales como las que utilizan los teléfonos celulares actuales.

En el contexto de los fractales, la iteración se refiere a la aplicación repetida de una regla o un procedimiento para generar la forma o estructura compleja del fractal. En la creación del fractal de Mandelbrot, una fórmula matemática se aplica repetidamente a cada punto en un plano complejo, produciendo un patrón auténtico. La cantidad de veces que se aplica la fórmula es conocida como el nivel de iteración. La Autosimilitud es una característica de los fractales que se refiere a su capacidad para mantener un patrón o forma similar a sí mismos a diferentes escalas. En otras palabras, una porción de un fractal se parece a la forma completa del fractal, sin importar la escala a la que se observe. Esta propiedad se conoce como "simetría fractal". Por ejemplo, un árbol fractal tendrá ramas que se parezcan a las ramas más grandes y a la forma general del árbol. La autosimilitud es una de las características que hacen que los fractales sean tan interesantes y únicos en el mundo de las matemáticas.

Para ello haremos uso de Matplotlib, la cuál es una librería completa para crear visualizaciones estáticas, animadas e interactivas en Python, de igual forma también usaremos la librería NumPy, que nos trae el poder computacional de lenguajes como C y Fortran a Python, un lenguaje mucho más fácil de aprender y usar.

Este será un post corto, vamos primero a tratar de explicar el script linea por linea, después veremos el código final limpio y acabaremos generando la grafica respectiva.

import numpy # importamos la librería NumPy

# NumPy es una biblioteca en Python que proporciona un objeto de matriz N-dimensional

# y funciones matemáticas de alto rendimiento para operar en esas matrices.

import matplotlib.pyplot # importamos la librería Matplotlib que se utiliza para la creación de gráficos y visualizaciones

# comenzamos la definición de una función que calcula el Conjunto de Mandelbrot

def mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon=2.0):

X = numpy.linspace(xmin, xmax, xn, dtype=numpy.float32) # Aquí se está generando un arreglo de números que representan los valores en el eje x. La función linspace de NumPy genera un número especificado de puntos equidistantes entre dos valores dados

Y = numpy.linspace(ymin, ymax, yn, dtype=numpy.float32) # Aquí se está generando un arreglo de números que representan los valores en el eje y

C = X + Y[:, None]*1j # generamos una matriz de números complejos que representan todos los puntos en el plano complejo. La notación 1j es una forma de representar la unidad imaginaria en Python

N = numpy.zeros_like(C, dtype=int) # Se crea un array N con la misma forma que C y se inicializa en cero

Z = numpy.zeros_like(C) # Se crea un array Z con la misma forma que C e inicializa en cero

for n in range(maxiter): # se itera sobre un rango de maxiter elementos

I = numpy.less(abs(Z), horizon) # se crea una matriz booleana I que es verdadera en las posiciones donde la magnitud de Z es menor que horizon

N[I] = n # asignamos el valor actual de la variable "n" a las posiciones en el array "N" donde la condición "I" es verdadera

Z[I] = Z[I]**2 + C[I] # es la fórmula iterativa para calcular el conjunto de Mandelbrot. Esta línea está asignando el resultado de esta fórmula a aquellos elementos en el array "Z" donde la condición "I" es verdadera

N[N == maxiter-1] = 0 # asignamos el valor 0 a aquellos elementos en el array "N" que tienen un valor igual a "maxiter-1"

return Z, N # la función "mandelbrot_set" devuelve los arrays "Z" y "N" como resultados

# Si se está ejecutando este archivo, define los parámetros y ejecuta la función mandelbrot_set

if __name__ == '__main__':

# Se definen los límites para que el gráfico incluya la región rectangular con esquinas opuestas (-2, -1.5) y (1, 1.5)

xmin, xmax, ymin, ymax = numpy.array([-2, 1, -1.5, 1.5], dtype=numpy.float32)

# Se definen las dimensiones de la matriz que se va a utilizar para almacenar los valores de iteración para cada punto del conjunto de Mandelbrot

# Se usarán matrices de 3000x2500 para almacenar los valores de iteración

xn, yn = numpy.array([3000, 2500], dtype=int)

# La variable "maxiter" define el número máximo de iteraciones que se realizarán en el cálculo del conjunto de Mandelbrot.

# En este caso, se han establecido en 200

maxiter = 200

# La variable "horizon" se usa para definir el umbral que determina si un punto está dentro del conjunto de Mandelbrot. En este caso, se ha definido

# como 2 elevado a la 40, lo que significa que se realizarán un máximo de 2 elevado a la 40 iteraciones para determinar si un punto está dentro del conjunto

horizon = 2.0 ** 40

log_horizon = numpy.log2(numpy.log(horizon))/2

# Llamamos a la función "mandelbrot_set" definida previamente para calcular los valores de iteración y la matriz compleja para el conjunto de Mandelbrot

Z, N = mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon)

# Se ignora la advertencia de que algunos valores resultantes de las operaciones sean inválidos

with numpy.errstate(invalid='ignore'):

# Calculamos los valores de M utilizando los valores de N y Z

M = numpy.nan_to_num(N + 1 - numpy.log(numpy.log(abs(Z)))/numpy.log(2) + log_horizon)

# Graficamos los valores de M con los parámetros especificados

matplotlib.pyplot.imshow(M, extent=[xmin, xmax, ymin, ymax], cmap='hot', aspect='equal') # se muestra el conjunto de Mandelbrot como una imagen en una ventana emergente

matplotlib.pyplot.xlabel("Re(c)") # Se agrega un label o etiqueta para las coordenadas x e y y se establece un título

matplotlib.pyplot.ylabel("Im(c)")

matplotlib.pyplot.title("Mandelbrot Set by JorgeChac")

matplotlib.pyplot.show() # Abrimos una ventana de visualización y mostramos el gráfico generado por el código.

Acá tenemos el código final limpio en Python:

# -----------------------------------------------------------------------
# (| " mandelbrot.py                                                  "|)
# (| "                                                                "|)
# (| " Script que genera el conjunto de Mandelbrot y lo visualiza     "|)
# (| " como una imagen utilizando las librerías NumPy y Matplotlib    "|)
# (| " de Python.                                                     "|)
# (| "                                                                "|)
# (| " El conjunto de Mandelbrot es un conjunto de puntos en el plano "|)
# (| " complejo que se define mediante una regla matemática iterativa."|)
# (| " El programa calcula los valores de los puntos en una cuadrícula"|)
# (| " de coordenadas en el plano complejo utilizando la función      "|)
# (| " mandelbrot_set() que implementa la regla iterativa. Luego, el  "|)
# (| " programa utiliza la librería Matplotlib para representar los   "|)
# (| " resultados como una imagen en una ventana de visualización.    "|)
# (| "                                                                "|)
# (| " Este código de ejemplo es de dominio público.                  "|)
# (| "                                                                "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB   "|)
# (| " Visita  https://jorgechac.blogspot.com                         "|)
# (| "                                                                "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   	      "|)
# (| " Whatsapp y Ventas NEQUI +573177295861                          "|)
# (| " Bucaramanga - Colombia                                         "|)
# -----------------------------------------------------------------------
import numpy
import matplotlib.pyplot

def mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon=2.0):
    
    X = numpy.linspace(xmin, xmax, xn, dtype=numpy.float32)
    Y = numpy.linspace(ymin, ymax, yn, dtype=numpy.float32)

    C = X + Y[:, None]*1j

    N = numpy.zeros_like(C, dtype=int)
    Z = numpy.zeros_like(C)

    for n in range(maxiter):

        I = numpy.less(abs(Z), horizon)
        N[I] = n

        Z[I] = Z[I]**2 + C[I]

    N[N == maxiter-1] = 0
    return Z, N

if __name__ == '__main__':

    xmin, xmax, ymin, ymax = numpy.array([-2, 1, -1.5, 1.5], dtype=numpy.float32)

    xn, yn = numpy.array([3000, 2500], dtype=int)

    maxiter = 200

    horizon = 2.0 ** 40

    log_horizon = numpy.log2(numpy.log(horizon))/2

    Z, N = mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon)

    with numpy.errstate(invalid='ignore'):
        
        M = numpy.nan_to_num(N + 1 - numpy.log(numpy.log(abs(Z)))/numpy.log(2) + log_horizon)

    matplotlib.pyplot.imshow(M, extent=[xmin, xmax, ymin, ymax], cmap='hot', aspect='equal')
    matplotlib.pyplot.xlabel("Re(c)")
    matplotlib.pyplot.ylabel("Im(c)")
    matplotlib.pyplot.title("Mandelbrot Set by JorgeChac")
    matplotlib.pyplot.show()

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar la grafica en Python con matplotlib, así: