Usando Python, calcule los valore de E∞ y P∞ de las siguientes funciones o señales:
x1(t) = exp(−2t)u(t)
import numpy as np
import [Link] as spi
import [Link] as plt
# Definición de la señal
def x(t):
return [Link](-2 * t) * (t >= 0) # x(t) = e^(-2t) * u(t)
# Calcular E_infinito (energía total)
E_infinito, _ = [Link](lambda t: [Link](x(t))**2, 0, [Link])
print(f"E_infinito (energía total) = {E_infinito}")
# Calcular P_infinito (potencia promedio)
T = 1000 # Valor grande para T, aproximando el límite cuando T tiende a infinito
P_infinito = (1 / (2 * T)) * [Link](lambda t: [Link](x(t))**2, 0, T)[0]
print(f"P_infinito (potencia promedio) = {P_infinito}")
# Graficar la señal
t = [Link](0, 5, 500) # Rango de tiempo de 0 a 5 segundos
[Link](figsize=(10, 6))
[Link](t, x(t), label='$x(t) = e^{-2t} u(t)$', color='blue')
[Link]('Grafico de la señal $x(t) = e^{-2t} u(t)$')
[Link]('Tiempo (t)')
[Link]('$x(t)$')
[Link](0, 5)
[Link](0, 1)
[Link]()
[Link]()
[Link]()
ejemplo 2
con todos los problemas
import numpy as np
import [Link] as plt
# Definición de la señal original x[n]
def x(n):
if n in [2, 3, 4]:
return 1
else:
return 0
# Función para graficar la señal discreta
def plot_signal(n_values, signal_values, title):
[Link](n_values, signal_values) # Eliminado use_line_collection
[Link](title)
[Link]('n')
[Link]('x[n]')
[Link](n_values) # Mostrar solo los valores de n en el eje x
[Link]()
[Link]()
# Definir el rango de n
n = [Link](-10, 10)
# a. x[n - 3]
signal_a = [x(n_i - 3) for n_i in n]
plot_signal(n, signal_a, 'Señal x[n - 3]')
# b. x[n + 4]
signal_b = [x(n_i + 4) for n_i in n]
plot_signal(n, signal_b, 'Señal x[n + 4]')
# c. x[-n]
signal_c = [x(-n_i) for n_i in n]
plot_signal(n, signal_c, 'Señal x[-n]')
# d. x[-n + 2]
signal_d = [x(-n_i + 2) for n_i in n]
plot_signal(n, signal_d, 'Señal x[-n + 2]')
# e. x[-n - 1]
signal_e = [x(-n_i - 1) for n_i in n]
plot_signal(n, signal_e, 'Señal x[-n - 1]')
Otra toma
import numpy as np
import [Link] as plt
# Definición de la señal original x[n]
def x(n):
if n in [2, 3, 4]:
return 1
else:
return 0
# Función para graficar la señal discreta
def plot_signal(n_values, signal_values, title):
[Link](n_values, signal_values) # Eliminado use_line_collection
[Link](title)
[Link]('n')
[Link]('x[n]')
[Link](n_values) # Mostrar solo los valores de n en el eje x
[Link]()
[Link]()
# Definir el rango de n
n = [Link](-10, 10)
# Graficar la señal original x[n]
signal_original = [x(n_i) for n_i in n]
plot_signal(n, signal_original, 'Señal x[n]')
# a. x[n - 3]
signal_a = [x(n_i - 3) for n_i in n]
plot_signal(n, signal_a, 'Señal x[n - 3]')
ejemplo 3
import numpy as np
import [Link] as plt
# Definir la función x(t) tal que x(t) = 0 para t < 3
def x(t):
return [Link](t >= 3, 1, 0)
# Definir el rango de t
t = [Link](0, 10, 500) # Valores de t de 0 a 10
# Señales a evaluar:
# a. x(1 - t)
x_a = x(1 - t)
# b. x(1 - t) + x(2 - t)
x_b = x(1 - t) + x(2 - t)
# c. x(1 - t) * x(2 - t)
x_c = x(1 - t) * x(2 - t)
# d. x(3t)
x_d = x(3 * t)
# e. x(t/3)
x_e = x(t / 3)
# Crear la figura para las gráficas
[Link](figsize=(10, 8))
# Graficar cada señal
[Link](3, 2, 1)
[Link](t, x_a, label='x(1 - t)')
[Link]('a. x(1 - t)')
[Link](True)
[Link](3, 2, 2)
[Link](t, x_b, label='x(1 - t) + x(2 - t)')
[Link]('b. x(1 - t) + x(2 - t)')
[Link](True)
[Link](3, 2, 3)
[Link](t, x_c, label='x(1 - t) * x(2 - t)')
[Link]('c. x(1 - t) * x(2 - t)')
[Link](True)
[Link](3, 2, 4)
[Link](t, x_d, label='x(3t)')
[Link]('d. x(3t)')
[Link](True)
[Link](3, 2, 5)
[Link](t, x_e, label='x(t / 3)')
[Link]('e. x(t / 3)')
[Link](True)
# Ajustar el layout y mostrar las gráficas
plt.tight_layout()
[Link]()
ejemplo 4
import numpy as np
import [Link] as plt
# Definir la función escalón unitario
def u(n):
return [Link](n >= 0, 1, 0)
# Definir la señal x[n]
def x(n):
return u(n + 1) - u(n - 5)
# Definir el rango de n
n = [Link](-10, 10)
# Calcular x[n]
signal_x = x(n)
# Calcular x[-n]
signal_neg_x = x(-n)
# Calcular las componentes par e impar
xe = 0.5 * (signal_x + signal_neg_x)
xo = 0.5 * (signal_x - signal_neg_x)
# Verificar que x[n] = xe[n] + xo[n]
reconstructed_x = xe + xo
# Función para graficar señales
def plot_signal(n_values, signal_values, title):
[Link](n_values, signal_values) # Eliminado use_line_collection
[Link](title)
[Link]('n')
[Link]('Amplitude')
[Link]()
[Link](0, color='black', lw=0.5, ls='--') # Línea en y=0
[Link](0, color='black', lw=0.5, ls='--') # Línea en x=0
[Link](-0.1, 1.1) # Limitar el eje y para que se vea mejor
[Link]()
# Graficar las señales
plot_signal(n, signal_x, 'Señal x[n]')
plot_signal(n, xe, 'Componente Par xe[n]')
plot_signal(n, xo, 'Componente Impar xo[n]')
plot_signal(n, reconstructed_x, 'Reconstrucción: xe[n] + xo[n]')
# Verificar si la señal original es igual a la reconstruida
if np.array_equal(signal_x, reconstructed_x):
print("La reconstrucción es correcta: x[n] = xe[n] + xo[n]")
else:
print("La reconstrucción no coincide con la señal original.")
ejmplo 5
import numpy as np
import [Link] as plt
# Definir los parámetros de la señal
A_values = [Link](1, -1, 5) # Amplitud de 1 a -1
omega_values = [Link](0, 60 * [Link], 5) # Frecuencia de 0 a 60π
phi_values = [Link](0, 2 * [Link], 5) # Fase de 0 a 2π
# Crear un rango de tiempo t
t = [Link](0, 1, 500) # Tiempo de 0 a 1 segundo
# Graficar la señal para diferentes valores de A, ω0 y φ
[Link](figsize=(12, 10))
for A in A_values:
for omega in omega_values:
for phi in phi_values:
# Calcular la señal x(t)
x_t = A * [Link](omega * t + phi)
[Link](t, x_t, label=f'A={A:.1f}, ω₀={omega/[Link]:.1f}π, φ={phi/[Link]:.1f}π')
[Link]('Señal Coseno x(t) = A cos(ω₀t + φ)')
[Link]('Tiempo (t)')
[Link]('x(t)')
[Link](0, color='black', lw=0.5, ls='--') # Línea en y=0
[Link](0, color='black', lw=0.5, ls='--') # Línea en x=0
ejemplo 6
import numpy as np
import [Link] as plt
# Definir la función exponencial
def x(t, C, a):
return C * [Link](a * t)
# Rango de tiempo t
t1 = [Link](-1, 1, 500) # Para las primeras cuatro gráficas
t2 = [Link](0, 1, 500) # Para comparar x1(t) y x2(t)
# Parámetros para las gráficas
params = [
(2, 2), # C = 2, a = 2
(2, -2), # C = 2, a = -2
(-2, 2), # C = -2, a = 2
(-2, -2) # C = -2, a = -2
# Crear las gráficas de las funciones exponenciales
[Link](figsize=(12, 10))
for C, a in params:
[Link](t1, x(t1, C, a), label=f'C={C}, a={a}')
[Link]('Funciones Exponenciales x(t) = C * e^(at)')
[Link]('Tiempo (t)')
[Link]('x(t)')
[Link](0, color='black', lw=0.5, ls='--') # Línea en y=0
[Link](0, color='black', lw=0.5, ls='--') # Línea en x=0
[Link]()
[Link]()
[Link](-5, 5) # Limitar el eje y para una mejor visualización
[Link]()
# Comparación de las dos señales x1(t) y x2(t)
x1 = [Link](-10 * t2)
x2 = [Link](-2 * t2)
[Link](figsize=(12, 6))
[Link](t2, x1, label='x1(t) = e^{-10t}')
[Link](t2, x2, label='x2(t) = e^{-2t}')
[Link]('Comparación de Decaimiento Exponencial')
[Link]('Tiempo (t)')
[Link]('x(t)')
[Link](0, color='black', lw=0.5, ls='--') # Línea en y=0
[Link](0, color='black', lw=0.5, ls='--') # Línea en x=0
[Link]()
[Link]()
[Link]()
ejemplo 7
import numpy as np
import [Link] as plt
# Definir el rango de tiempo
t = [Link](0, 1, 1000) # De 0 a 1 segundo
# Definir las señales
x1 = [Link](5 * t) * [Link](2 * [Link] * 10 * t) # e^(5t) * cos(2π10t)
x2 = [Link](-5 * t) * [Link](2 * [Link] * 10 * t) # e^(-5t) * cos(2π10t)
# Graficar las señales
[Link](figsize=(12, 6))
# Graficar x1(t)
[Link](2, 1, 1)
[Link](t, x1, label='x1(t) = e^(5t) * cos(2π10t)', color='blue')
[Link]('Señal Amortiguada Creciente')
[Link]('Tiempo (t)')
[Link]('x1(t)')
[Link](0, color='black', lw=0.5, ls='--') # Línea en y=0
[Link](0, color='black', lw=0.5, ls='--') # Línea en x=0
[Link]()
[Link]()
# Graficar x2(t)
[Link](2, 1, 2)
[Link](t, x2, label='x2(t) = e^(-5t) * cos(2π10t)', color='red')
[Link]('Señal Amortiguada Decrescente')
[Link]('Tiempo (t)')
[Link]('x2(t)')
ejercio 8
import numpy as np
import [Link] as plt
# Definir el rango de n
n = [Link](-10, 10) # n de -10 a 9
# Definir las constantes C y los valores de alpha
C=1
alpha_values = [2.0, 0.5, -0.5, -2.0] # Asegúrate de que sean float
# Crear la figura
[Link](figsize=(12, 8))
# Graficar las señales exponenciales
for alpha in alpha_values:
x_n = C * (alpha ** n) # x[n] = C * α^n
[Link](n, x_n, label=f'α={alpha}') # Sin use_line_collection
# Configuración de la gráfica
[Link]('Exponenciales Discretas x[n] = C * α^n')
[Link]('n')
[Link]('x[n]')
[Link](0, color='black', lw=0.5, ls='--') # Línea en y=0
[Link](0, color='black', lw=0.5, ls='--') # Línea en
ejrcicio 9
import numpy as np
import [Link] as plt
# Definir el rango de n
n = [Link](0, 50) # n de 0 a 49
# Valores de omega0
omega0_values = [0, [Link]/2, [Link], 3*[Link]/2, 2*[Link]]
# Crear la figura con subgráficas
[Link](figsize=(15, 10))
# Graficar las exponenciales complejas en subgráficas
for i, omega0 in enumerate(omega0_values):
[Link](len(omega0_values), 1, i + 1) # Crear una subgráfica
x_n = [Link](1j * omega0 * n) # e^(j * ω₀ * n)
[Link](n, x_n.real, label='Parte Real') # Parte real
[Link](n, x_n.imag, '--', label='Parte Imaginaria')
ejercicio 10 solo primero
import numpy as np
import [Link] as plt
# Definir el rango de n
n = [Link](-5, 6) # n de -5 a 5
# Definir el impulso unitario δ[n]
delta_n = np.zeros_like(n) # Inicializa un arreglo de ceros
delta_n[n == 0] = 1 # Establece el impulso en n = 0
# Graficar la señal del impulso unitario
[Link](n, delta_n, basefmt=" ") # Sin use_line_collection
[Link]('Impulso Unitario δ[n]')
[Link]('n')
[Link]
Todas las variabñe del 10
import numpy as np
import [Link] as plt
# Definir el rango de n
n = [Link](-5, 6) # n de -5 a 5
# Definir el impulso unitario δ[n]
delta_n = np.zeros_like(n) # Inicializar el arreglo de ceros
delta_n[n == 0] = 1 # Establecer el impulso unitario en n = 0
# Definir el escalón unitario u[n]
u_n = [Link](n, 1) # Escalón unitario, 1 para n >= 0
# Señales a graficar
signals = {
'δ[n]': delta_n,
'δ[n - 2]': [Link](delta_n, 2), # Desplazar el impulso a la derecha
'δ[n + 2]': [Link](delta_n, -2), # Desplazar el impulso a la izquierda
'2δ[n + 1] + δ[n] - 2δ[n - 1]': 2 * [Link](delta_n, -1) + delta_n - 2 * [Link](delta_n, 1),
'u[n] - u[n - 1]': u_n - [Link](n - 1, 1), # Impulso unitario
'u[n] - u[n - 5]': u_n - [Link](n - 5, 1) # Escalón que dura 5 unidades
# Crear la figura
[Link](figsize=(15, 12))
# Graficar cada señal
for i, (title, signal) in enumerate([Link]()):
[Link](len(signals), 1, i + 1) # Crear subgráficas
[Link](n, signal, basefmt=" ") # Graficar la señal
[Link](title)
[Link]('n')
[Link]('x[n]')
[Link](0, color='black', lw=0.5, ls='--') # Línea en y=0
[Link](0, color='black', lw=0.5, ls='--') # Línea en x=0
[Link](-2, 3) # Limitar el eje y para mejor visualización
[Link]()
plt.tight_layout() # Ajustar el layout para evitar solapamientos
[Link]()
Python moneda
import random
import [Link] as plt
# Simula lanzamientos de una moneda
lanzamientos = []
ncara = 0
nsello = 0
# Listas para almacenar frecuencias relativas
frecuencia_cara = []
frecuencia_sello = []
for i in range(100):
n = [Link](0, 1)
[Link](n)
if n == 1:
ncara += 1
else:
nsello += 1
# Calcular frecuencia relativa instantánea
frecuencia_cara.append(ncara / (i + 1))
frecuencia_sello.append(nsello / (i + 1))
print(lanzamientos[i], end="-")
print() # Para cambiar de línea
print("Cara: " + str(ncara) + " - Sello: " + str(nsello))
# Graficar la frecuencia relativa
[Link](range(1, 101), frecuencia_cara, label='Frecuencia Relativa Cara', color='blue')
[Link](range(1, 101), frecuencia_sello, label='Frecuencia Relativa Sello', color='orange')
[Link](y=0.5, color='gray', linestyle='--', label='Teórica 50%')
[Link]('Frecuencia Relativa Instantánea de Lanzamientos de una Moneda')
[Link]('Número de Lanzamientos')
[Link]('Frecuencia Relativa')
[Link]()
[Link]()
[Link](0, 1) # Limitar el eje y entre 0 y 1
[Link](1, 100) # Limitar el eje x entre 1 y 100
# Mostrar la gráfica
[Link]()
