Señales μ(t) y δ(t)

Señales escalón e impulso

Referencia: Lathi 1.4.1 pdf/p.63 – 68, Schaum 1.3 pdf/p.17-22 Oppenheim 1.4 pdf/p.61

Escalón unitario μ(t)

En muchos de los temas de curso se usan sistemas causales que inician en t=0. La función que describe éste comporamiento es μ(t) descrita como:

\mu(t)= \begin{cases} 1, & t\geq 0 \\ 0, & t<0\end{cases}

Algunas señales pueden convenientemente ser descritas usando términos de una función μ(t) como se muestra el los siguientes ejemplos

Algoritmo Python

La función μ(t) se puede describir con la np.piecewise()

# Señales modelo varias
# propuesta: edelros@espol.edu.ec
import numpy as np

# INGRESO
u = lambda t: np.piecewise(t,t>=0,[1,0])

a = -10
b = 10
dt = 0.1

# PROCEDIMIENTO
t = np.arange(a, b, dt)
u0 = u(t-0)

# SALIDA - GRAFICA
import matplotlib.pyplot as plt
plt.figure(1)
plt.plot(t,u0)

plt.xlabel('t')
plt.ylabel('escalon u(t)')
plt.margins(dt)
plt.grid()
plt.show()

Para convertir una señal cualquiera a causal, que inicie en t=0, se multiplica la señal por μ(t).

Por ejemplo, x(t)=e-αt se puede convertir a una señal causal si se escribe como:

x(t) = e^{-\alpha t} \mu(t)

Para mostrar lo indicado y considerando α=1 tenemos que:

# señal a causal
x = np.exp(-t)*u0

# SALIDA - GRAFICA
plt.figure(2)
plt.plot(t,x)

plt.xlabel('t')
plt.ylabel('x(t)u(t)')
plt.margins(dt)
plt.grid()
plt.show()


La función escalón tambien realizar descripciones matematicas sobre diferentes segmentos del tiempo.

Por ejemplo, una señal rectangular se puede representar como la suma de dos señales μ(t) desplazadas:

x(t) = \mu (t-2) - \mu (t-4)
# Rectangular como u(t-2)-u(t-4)
# u2 = np.piecewise(t,t>=2,[1,0])
# u4 = np.piecewise(t,t>=4,[1,0])

u2 = u(t-2) 
u4 = u(t-4) 
rectangular = u2 - u4

# SALIDA - GRAFICA
plt.figure(3)
plt.plot(t,rectangular)

plt.xlabel('t')
plt.ylabel('rectangular()')
plt.margins(dt)
plt.grid()
plt.show()

Impulso unitario δ(t)

El impulso unitario δ(t) es una función definida primero por Paul Dirac de la forma:

\delta(t)=0,t\neq 0 \int_{-\infty}^{\infty} \delta(t) dt = 1

Se puede ver al impulso como un pulso rectangular muy pequeño de área unitaria. El ancho del pulso rectangular es muy pequeño.

Siguiendo el concepto, se puede representar como:

# impulso unitario
# u0 = np.piecewise(t,t>=0,[1,0])
# udt = np.piecewise(t,t>=(0+dt),[1,0])

u0 = u(t)
udt = u(t-dt)
impulso = u0 - udt

# SALIDA - GRAFICA
plt.figure(4)
plt.plot(t,impulso)

plt.margins(dt)
plt.xlabel('t')
plt.ylabel('impulso()')
plt.grid()
plt.show()


Aunque la forma mas simple de representarlo es como:

\delta(t)= \begin{cases} 1, & t = 0 \\ 0, & t \neq 0\end{cases}

En el algoritmo consiste en poner todos los valores en cero y buscar donde ocurre el cambio de signo del tiempo, para aproximar el valor más cercano a cero.

Para la gráfica también se usa stem(x,y):

def unimpulso(t):
    n = len(t)
    y = np.zeros(n)
    donde = 0
    for i in range(1,len(t)):
        if np.sign(t[i])!=np.sign(t[i-1]):
            donde=i
    y[donde]=1
    return(y)

# Calcula el impulso en t=0
elimpulso = unimpulso(t)

# SALIDA - GRAFICA
plt.figure(5)
plt.stem(t,elimpulso)

plt.margins(dt)
plt.xlabel('t')
plt.ylabel('impulso(t)')
plt.grid()
plt.show()

También se puede usar la librería scipy para tener un impulso más general:

https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.unit_impulse.html

hay que importar la libreria scipy para ese caso.

Publicado por

Edison Del Rosario

edelros@espol.edu.ec / Profesor del FIEC/FCNM-ESPOL