2.4 Sistemas con memoria o sin memoria

Referencia: Oppenheim 1.6.1 p44 pdf75 , Lathi 1.7-3 p103, Hsu 1.5.C p17

Si la salida de un sistema depende solo del valor aplicado en la entrada para un tiempo cualquiera, se dice que el sistema es sin memoria.

Resistor01El ejemplo más común es un sistema con un resistor:

y(t) = Rx(t)

Por otra parte, si el sistema depende de los valores anteriores de la entrada, se lo considera sistema con memoriacapacitor01

Tal es el caso de un capacitor, cuyo valor de salida depende de lo acumulado desde el tiempo -∞ hasta t.

y(t) =\frac{1}{C} \int_{-\infty}^{t} x(\tau) d\tau

Los sistemas sin memoria también se conocen como instantaneos, que son un caso particular de los sistemas dinámicos (con memoria).

Un sistema  cuya respuesta en t está determinada por los anteriores T segundos, es decir el intervalo (tT), se lo conoce como «sistema con memoria finita»

 

2.3 Sistemas Invariantes y Variantes en el tiempo con Sympy-Python

Referencia: Oppenheim 1.6.5 p50, Lathi 1.7-2 p102, Hsu 1.5.F p18

Si el comportamiento de un sistema y sus parámetros no cambian en el tiempo, se los denomina sistemas invariantes en el tiempo.

Por ejemplo, para un circuito RC, los valores de la resistencia y capacitor fijos no varian si se realiza un experimento o medición hoy o mañana.

Expresando lo mismo como:
Un sistema es invariante en el tiempo si, ante un desplazamiento de tiempo en la señal de entrada, se ocasiona el mismo desplazamiento en el tiempo en la señal de salida. El resultado se repite si el desplazamiento del tiempo se aplica a la salida del sistema en lugar de la entrada.

x(t) \rightarrow y(t) x(t-t_0) \rightarrow y(t-t_0)

Ejemplo 1. Sistema con comportamiento senoidal

Referencia: Oppenheim 1.14 p51

Para muestra de lo indicado, considere un sistema definido como:

y(t) = \sin[x(t)]

Para revisar si es invariante en el tiempo, se debe determinar si sus propiedades de mantienen para cualquier entrada ante cualquier desplazamiento t0.

y_1 (t) = \sin[x(t - t_0)] y_2(t) = y(t - t_0)

Suponga x1(t)= e(-t)u(t) la señal bajo prueba, siendo x2(t)= e(-(t-t0))u(t-t0) la entrada x1(t) desplazada en t0. Haciendo t0=1, se puede observar en la gráfica si al aplicar el retraso antes o después del sistema tienen resultados iguales.

y_1 (t) = y_2(t)

En éste caso se observa que la señal de salida se mantiene invariante en su forma y desplazada en sincronía con la señal de entrada. Por lo que el sistema es INVARIANTE en el tiempo.

La gráfica y el siguiente resultado se realizaron con el algoritmo desarrollado a partir del tema anterior sobre sistemas lineales. El algoritmo se adjunta al final.

        / -t             \
yf = sin\e  *Heaviside(t)/
        /                  -t                   \
yw = sin\2.71828182845905*e  *Heaviside(t - 1.0)/
              /                  -t                   \
yf(t-t0) = sin\2.71828182845905*e  *Heaviside(t - 1.0)/

Por otro lado, si la respuesta de la señal se modifica en el tiempo, el sistema será VARIANTE en el tiempo.


Ejemplo 2. Sistema comprime en tiempo

Referencia: Oppenheim 1.16 p52.Hsu ejercicio 1.39 p48

Considere el sistema que tiene escalamiento en el tiempo.:

y(t) = x(2t)

y(t) es una versión comprimida en tiempo de x(t) en un factor de 2.
Los desplazamientos en el tiempo de la señal de entrada  al pasar por el sistema también se «comprimen» por un factor de 2.

Haciendo f(t) = μ(t+2)-μ(t-2) una señal rectangular centrada en el origen con color azul en la gráfica.
Si la entrada w(t) = f(t-2)= μ(t)-μ(t-4) es una real rectangular desplazada en 2 (en color verde), su resultado en la salida se encuentra centrado en 1.

Al desplazar el resultado de la señal de entrada en su forma original en azul, por t0 se obtiene la señal de salida en color rojo. Claramente los resultados de aplicar un retraso antes o después del sistema son diferentes.

Por lo que, por ésta razón el sistema NO es invariante en el tiempo.

yf = -Heaviside(2*t - 2) + Heaviside(2*t + 2)
yw = Heaviside(2*t) - Heaviside(2*t - 4.0)
yft0 = -Heaviside(2*t - 6.0) + Heaviside(2*t - 2.0)

Siguiendo las indicaciones en el problema presentado, donde T se conoce como el «operador lineal«. El sistema tiene una relación de entrada-salida dada por:

y(t) = T{x(t)} = x(2t)

y t0 es un desplazamiento en el tiempo.

Sea y2(t) la respuesta a x2(t) = x(t-t0) entonces:

y2(t) = T{x2(t)} = x2(2t) = x(2t-t0)

Si se desplaza el resultado de la señal de salida sin desplazar se tiene:

y(t-t0) = x(2(t-t0)) = x(2t-2t0))

y(t-t0) ≠ y2(t)

por lo que el sistema no es invariante en el tiempo.
El sistema x(2t) se conoce como compresor, pues crea una secuencia de salida cada 2 valores de la secuencia de entrada.


Ejemplo 3. Sistema multiplica por tiempo

Referencia: Oppenheim 1.13 p49, Oppenheim 1.17 p54, Hsu ejercicio 1.38 p47

Considere el siguiente sistema, cuya salida depende del intervalo de tiempo evaluado. Los desplazamientos afectan a la señal de salida.

y(t) = t x(t)

Desarrollar semejante al ejercicio anterior, en forma analítica y usando Python, para la entrada:

x(t) = \sin (t)

yf = t*sin(t)
yw = t*sin(t - 2.0)
yf(t-t0) = (t - 2.0)*sin(t - 2.0)

Para el sistema dado, al depender su magnitud de la variable t, la salida tiende a crecer con el tiempo, por lo que se puede intuir que el sistema es inestable.

Observando los resultados y la gráfica se tiene que el sistema NO es invariante en el tiempo.

Ejemplo 4. Sistema deriva la entrada

Referencia: Lathi 1.11 p103

Determine la invariabilidad de tiempo del siguiente sistema

y(t) = \frac{d}{dt} x(t) ,

Suponga x1(t)= e(-t)u(t), semejante a lo usado en el ejercicio 1.

El desarrollo con el algoritmo muestra que el sistema resulta invariante en el tiempo.

      -t                  -t             
yf = e  *DiracDelta(t) - e  *Heaviside(t)
                       -t                                         -t               
yw  = 2.71828182845905*e  *DiracDelta(t - 1.0) - 2.71828182845905*e  *Heaviside(t - 1.0)
                             -t                                         -t               
yf(t-t0) = 2.71828182845905*e  *DiracDelta(t - 1.0) - 2.71828182845905*e  *Heaviside(t - 1.0)

En este caso, dado que la señal de entrada tiene una función escalón, sympy no presenta inconvenientes en realizar la derivada. Sin embargo, la operacion de conversión con Lambdify será necesario añadir la equivalencia de DiracDelta en numpy. Por lo que la instrucción de Lambdify se le añade el parámetro para considerar los modulos equivalentes.

equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                'numpy']

Instrucciones en Python

Desarrollado a partir del algoritmo usado para sistemas lineales y no lineales

Ejemplo 1. Sistema con comportamiento senoidal

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Oppenheim 1.14 p51 pdf82
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 1.0 
# señales de entrada
f = sym.exp(-t)*sym.Heaviside(t)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = sym.sin(x)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf)
ywt = sym.lambdify(t,yw)
yf0t = sym.lambdify(t,yf0)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'.',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 2. Sistema comprime en tiempo

Para aplicar cambios en la variable tiempo, en el algoritmo se sustituye en la expresión de la señal de entrada la variable t por 2t.

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Oppenheim 1.16 p52.Hsu ejercicio 1.39 p48
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 2.0
# señales de entrada
f = sym.Heaviside(t+2)-sym.Heaviside(t-2)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = sym.Subs(x,t,2*t,evaluate=False)

# intervalo de t[a,b] para graficar
a = -5
b = 5
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf)
ywt = sym.lambdify(t,yw)
yf0t = sym.lambdify(t,yf0)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'--',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 3. Sistema multiplica por tiempo

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Oppenheim 1.13 p49.Hsu ejercicio 1.38 p47
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 2.0
# señales de entrada
f = sym.sin(t)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = t*x

# intervalo de t[a,b] para graficar
a = 0
b = 3*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf)
ywt = sym.lambdify(t,yw)
yf0t = sym.lambdify(t,yf0)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'--',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 4. Sistema deriva la entrada

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Lathi 1.11 p103
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                'numpy']

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 1.0 
# señales de entrada
f = sym.exp(-t)*sym.Heaviside(t)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = sym.diff(x,t,evaluate=False)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf,modules=equivalentes)
ywt = sym.lambdify(t,yw,modules=equivalentes)
yf0t = sym.lambdify(t,yf0,modules=equivalentes)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'.',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

2.2 Sistemas Lineales y No Lineales con Sympy-Python

Referencia: Oppenheim 1.6.6 p53, Lathi 1.7-1 p97, Hsu 1.5.E p18

En un sistema lineal cumple con el principio de superposición que se compone de la propiedad de aditividad y de la escalabilidad.

sistema lineal ejemplo audio suma
La superposición puede ser un resultado deseado, por ejemplo en un sistema de audio que no añada «distorsiones» a lo que ingresa por un micrófono y se reproduce en los parlantes.

sistema lineal y propiedad de aditividad Un sistema lineal cumple la propiedad de aditividad, si la respuesta a una suma de señales en la entrada es igual a la suma de las salidas de las señales anteriores.

x_1(t) + x_2(t) \rightarrow y_1(t) + y_2(t)

sistema lineal y propiedad de escalabilidad La propiedad de escalabilidad u homogeneidad muestra una relación de «amplificación» o «atenuación» representada por una constante.
Para los ejemplos, las constantes a usar son α y β que podrían ser reales o complejas.

\alpha x_1(t) \rightarrow \alpha y_1(t)

La propiedad de escalabilidad implica que una amplificación o atenuación  puede ser aplicada antes o después del sistema, el resultado debería ser semejante.

La propiedad de superposición se plantea como una combinación de las propiedades anteriores:

en el tiempo contínuo:

\alpha x_1(t) + \beta x_2 (t) \rightarrow \alpha y_1(t) + \beta y_2(t)

sistema lineal y propiedad de superposición

en tiempo discreto:

\alpha x_1[n] + \beta x_2 [n] \rightarrow \alpha y_1[n] + \beta y_2[n]

Nota: De ser necesario, revisar los conceptos para Sympy en el curso de Métodos Numéricos: Fórmulas y funciones simbólicas con Python – Sympy


Ejemplo 1. Un micrófono inductivo, sistema que deriva x(t)

Referencia: Lathi 1.11 b p103.

Para el sistema dado, determine si cumple la propiedad de aditividad y escalabilidad para revisar si es un sistema lineal:

y(t) = \frac{\delta}{\delta t}x(t)

La salida del sistema es solo la derivada de la señal de entrada. Al sumar dos entradas diferentes antes del sistema, representada como w(t), se  produce el mismo resultado que la suma de las salidas del sistema para las señales de entrada individuales.

Suponiendo como entradas las señales f(t) = sin(t), graficada en azul, g(t) = cos(t) en color naranja, al aplicarse cada una al sistema, se obtienen las gráficas de salida usando los mismos colores para facilidad de comparación.

Para el análisis, se añade una entrada adicional w(t) = α f(t) + β g(t) que en la gráfica es de color verde para entrada y salida.
Se obtiene la expresión para el sistema α y[f(t)] + β y[g(t)]  (color rojo) y se observa si son iguales con y[w(t)], de ser iguales, el sistema es lineal.

El desarrollo analítico se encuentra en el libro guía en la referencia, por lo que se adjunta la parte algorítmica para la gráfica con Python, y se obtienen también las expresiones para los resultados correspondientes con Sympy:

yf = cos(t)
yg = -sin(t)
yw  = -3*sin(t) + 2*cos(t)
yfg = -3*sin(t) + 2*cos(t)

Un ejemplo de aplicación para un sistema que deriva una entrada es un micrófono dinámico o de bobina, usado como preferencia por sus propiedades en locución de radio.

Referencia: Micrófonos dinámicos de bobina móvil: la guía detallada. Micrófono Rocks. https://microfono.rocks/microfonos-dinamicos-de-bobina-movil-la-guia-detallada/

Diferencias entre un Micrófono Dinámico y de Condensador – StudioMusic.cl


Ejemplo 2. Sistema con salida (x(t))2

Referencia: Oppenheim 1.18 p54

Para un sistema cuya entrada x(t) y salida y(t) se encuentra relacionada por:

y(t) = x^2(t)

Desarrolle las expresiones para determinar si el sistema es lineal, semejante al ejemplo del texto guía.

Se adjunta el resultado realizado con el algoritmo en Python, modificando las expresiones para y = x**2 mostrando que el sistema es NO lineal.

        2   
yf = sin (t)
        2   
yg = cos (t)
                          2
yw = (2*sin(t) + 3*cos(t)) 

           2           2   
yfg = 2*sin (t) + 3*cos (t)


Ejemplo 3. Sistema t(x(t))

Referencia: Oppenheim 1.17 p54

Considere un sistema cuya entrada x(t) y salida y(t) se encuentra relacionada por:

y(t) = t x(t)

Para determinar si S es o no lineal, se consideran dos entradas arbitrarias iguales a las del ejercicio anterior, haciendo w(t) = α f(t) y β g(t)

Desarrolle las expresiones para determinar si el sistema es lineal

Se adjunta el resultado realizado con el algoritmo en Python, modificando las expresiones para y = t*x mostrando que el sistema es lineal.

yf = t*sin(t)
yg = t*cos(t)
yw = 2*t*sin(t) + 3*t*cos(t)
yfg =2*t*sin(t) + 3*t*cos(t)


Instrucciones con Sympy-Python

Sympy facilita generar las expresiones de las señales de entrada al pasar por el sistema. De ser necesario, revise los conceptos para Sympy en el curso de Métodos Numéricos: Fórmulas y funciones simbólicas con Python – Sympy

En Sympy se puede derivar una expresión usando sym.diff(). Sin embargo para un sistema que aplica derivadas, las expresiones de salida se generan sin aplicar la derivada pues primero se sustituye la variable x con la expresión de la entrada y luego se aplica sym.Derivative(x,t). Para que se ejecute la derivada se tiene la instrucción doit().

En caso que la señal de entrada sea una expresión mas compleja que la de los ejemplos, se recomienda usar la instrucción a la expresión .expand().
expand() genera términos más simples de la expresión que facilitan el análisis por algoritmos con Python.

# Sistema Lineal prueba
# Revisa propiedad de aditividad y escalabilidad
# Lathi ej1.11 p103
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

# señales de entrada
f = sym.sin(t)
g = sym.cos(t)
alpha = 1
beta  = 1

# sistema, aplica a entrada
#   expresión sin evaluar
y = sym.diff(x,t, evaluate=False)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 41

# PROCEDIMIENTO
# señales suma de entradas
w = alpha*f + beta*g

# Sistema sobre señal de entrada
#  se evalua la expresión con doit()
yf = y.subs(x,f).doit()
yg = y.subs(x,g).doit()
yw = y.subs(x,w).doit()
yfg = alpha*yf+ beta*yg

# Para gráfica
ti = np.linspace(a,b,muestras)

# señales de entrada
ft = sym.lambdify(t,f)
gt = sym.lambdify(t,g)
wt = sym.lambdify(t,w)
# señales de salida
yft = sym.lambdify(t,yf)
ygt = sym.lambdify(t,yg)
ywt = sym.lambdify(t,yw)
yfgt = sym.lambdify(t,yfg)

# evalua entradas ti
fi = ft(ti)
gi = gt(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ygi = ygt(ti)
ywi = ywt(ti)
yfgi = yfgt(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yg:')
sym.pprint(yg)
print('yw:')
sym.pprint(yw)
print('yfg:')
sym.pprint(yfg)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,gi,'--', label='g(t)')
plt.plot(ti,wi, label='w(t)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
untitulo = 'Sistemas Linealidad ' + str(y)
plt.title(untitulo)
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--', label='y(f(t))')
plt.plot(ti,ygi,'--', label='y(g(t))')
plt.plot(ti,ywi, label='y(w(t))')
etqLatex = r'$ \alpha y[f(t)]+\beta y[g(t)] $'
plt.plot(ti,yfgi,'.',
         label=etqLatex)

plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Referencia: Derivadas con Sympy. Expresión sin evaluar y evaluación de expresión con Derivative. https://docs.sympy.org
Conceptos para Sympy en el curso de Métodos Numéricos: Fórmulas y funciones simbólicas con Python – Sympy

2.1 Sistemas

Referencia: Lathi 1.6 p95, Oppenheim 1.5 p38 pdf 69, Hsu 1.5 p16

Los sistemas se usan para procesar una señal con el objetivo de modificarla, por ejemplo sumar o restar información adicional.

fiec05058Sistema01


Ejemplo

Un sistema amplificador de audio, tiene como señal de entrada el sonido captado por un micrófono y como salida el sonido amplificado en los parlantes.

cantante02Otro ejemplo de sistema se observa en los efectos que se aplican a una señal de audio de un piano, y por medio de un sistema se modifica la señal para que suene como guitarra.

Para otros ejemplos revisar videos sobre: wah pedals para efectos de guitarra, sintetizadores analógicos, etc.

Representación de sistemas

Un sistema para análisis y diseño es una representación de un proceso físico, que relaciona las señales de entrada x(t) y las señales de salida y(t) obtenidas como respuesta.

La representación puede ser de tipo matemática o en diagramas de bloques con flechas. El sentido de las flechas indican la entrada o salida.

y(t) = h(t) * x(t)
       h(t) = k
y(t) =  k x(t)

fiec05058Sistema01

Entradas y salidas de un sistema

Los sistemas pueden tener.

– Una entrada y una salida (SISO – Single Input, Single output)
– Varias entradas, varias salidas (MIMO – Multiple Input, Multiple output)

Durante el curso para simplificar el análisis, se usan las representaciones de una entrada y una salida (SISO), Ejemplo: audio monofónico o de un solo canal.

El bloque del sistemasistema por circuitos

Un sistema se puede realizar por:

– Componentes físicos (hardware: componentes electrónicos)

 

– Con su representación en diagrama de circuito:FIEC05058_RLC_solo

 

– Algoritmos (software: calculan la nueva señal a partir de la entrada)

arduinouno01arduinouno02

Un sistema puede estar compuesto de subsistemas interconectados, caracterizados por sus terminales de entrada y salida.

hometheater01

Dependiendo de las propiedades que tiene un sistema o las que se quieren utilizar, se realizan diferentes aplicaciones de los sistemas.

1.9 Señales de Energía y Potencia

… [ señal de energía ] [ señal de potencia ]


Señal de Energía

Referencia: Lathi 1.1-1 p65, Hsu 1.2.G p5

Una señal de energía tiene energía finita. En general toda señal en el sentido práctico tiene duración finita, por lo que la energía es finita.

La energía se define como:

E=\int_{-\infty}^{\infty} x^2(t) dt

o de una forma más general incluyendo señales de tipo compleja:

E=\int_{-\infty}^{\infty} |x(t)|^2 dt

No se considera solo como energía el área bajo la curva, o integral de la señal, debido a que puede contener áreas de signo negativo que pueden cancelar la media. El cuadrado de la señal será siempre positivo.

La señal tiene que ser de tipo finita para que la medida tenga significado. Una condición necesaria para que la señal sea finita es que su amplitud → 0 cuando |t|→ ∞. En cualquier otro caso la integral no converge.

Para una señal discreta:

E=\sum_{n=-\infty}^{\infty} | x[n] |^2

Ejemplo de señal de Energía

Un ejemplo de señal de Energía es un audio limitado en el tiempo, pues su amplitud tiende a 0 cuando |t|→ ∞.

Usando el mismo archivo de audio del ejercicio de señales analógicas y digitales:

Alarm01.wav

Recuerde que el archivo de audio.wav debe estar en el mismo directorio de trabajo que el archivo algoritmo.py.

señal de audio ejemplo

El audio mostrado es una señal limitada en el tiempo, por lo que es posible calcular su energía usando la formula descrita.

Referencia: Archivos de Audio.wav – Abrir, extraer una porción en CCPG1001 Fundamentos de programación

para procesar el archivo, las instrucciones en Python son:

# Señales de Energía y Potencia
import numpy as np
import matplotlib.pyplot as plt
import scipy.io.wavfile as waves

# INGRESO
# archivo = input('archivo de audio: ')
archivo = 'Alarm01.wav'

# PROCEDIMIENTO
muestreo, sonido = waves.read(archivo)
muestra = len(sonido)
dt = 1/muestreo
t = np.arange(0,muestra*dt,dt)
uncanal = sonido[:,0]

# SALIDA - Observación intermedia
plt.plot(t,uncanal)
plt.xlabel('t segundos')
plt.ylabel('sonido(t)')
plt.show()

Integración numérica de muestras

En el caso de las muestras disponibles de audio, las muestras están igualmente espaciadas, se puede integrar usando la regla de Simpson´s integrate.simps(valores,t) para obtener un estimado de alta precisión.

Para desarrollar el tema de integración numérica puede revisar el tema en Métodos numéricos en el siguiente enlace:  Unidad 05 Integración y Diferenciación Numérica

import scipy.integrate as integrate

# cuadrado de la señal para el integral de energía
cuadrado = uncanal**2

#integrando a partir de muestras de la señal
energia = integrate.simps(cuadrado,t)

# SALIDA
print(' La energía del audio es: ',energia)
print('\n revisando el canal y sus cuadrados')
print(uncanal[2500:2510])
print(cuadrado[2500:2510])
 La energía del audio es:  3827.5753288
 revisando el canal y sus cuadrados
[-16  -1   8  -3  -8   4  11  -1  -4  10]
[256   1  64   9  64  16 121   1  16 100]

[ señal de energía ] [ señal de potencia ]


Señal de Potencia

Si en x(t) la amplitud no tiende → 0 al mismo tiempo que |t|→ ∞, la energía de la señal será infinita.

Una mejor medida de la señal en este caso es promedio de energía en el un intervalo de tiempo T, si es periódica, existe T.

La señal de potencia se define como:

P_x =\lim_{T \to \infty}\frac{1}{T} \int_{-T/2}^{T/2} | x(t) |^2 dt

y para una señal discreta:

P =\lim_{N \to \infty}\frac{1}{2N+1} \sum_{n=-N}^{N} | x[n] |^2

Ejemplo: potencia de una señal

Considere una señal periódica conocida sin(), integrando dentro de un periodo podemos calcular la energía y luego la potencia.

# Señales de Energía y Potencia
import numpy as np
import matplotlib.pyplot as plt
import scipy.integrate as integrate

# INGRESO - Parámetros
w  = 1
fx = lambda t: np.sin(w*t)
a  = 0
b  = 2*np.pi # un periodo T
dte = 0.005

# PROCEDIMIENTO
T  = 2*np.pi/w
te = np.arange(a,b,dte)
xe = fx(te)

# energía en un periodo
cuadradoxe = xe**2
energiaxe  = integrate.simps(cuadradoxe,te)

# potencia en un periodo
potenciaxe = (1/T)*energiaxe

# SALIDA
print('la energia de xe es: ',energiaxe)
print('la potencia de xe es: ',potenciaxe)
# gráfica
plt.plot(te,xe,label='xe')
plt.fill_between(te,0,cuadradoxe,color='lightgreen')
plt.plot(te,cuadradoxe,'g--', label='xe^2')
plt.xlabel('t')
plt.legend()
plt.show()
la energia de xe es:  3.14159264282
la potencia de xe es:  0.499999998285

señal al cuadrado para energia y potencia

Para revisar los resultados, realizamos el cálculo de potencia haciendo x(t)=sin(t)

P_x =\lim_{T \to \infty}\frac{1}{T} \int_{-T/2}^{T/2} | x(t) |^2 dt

se tiene que:

=\frac{1}{2\pi} \int_{0}^{2\pi} | sin(t) |^2 dt = \frac{1}{2\pi} \int_{0}^{2\pi} \Big[ \frac{1}{2}-\frac{cos(2t)}{2}\Big] dt =\frac{1}{4\pi} \int_{0}^{2\pi} \Big[ 1-{cos(2t)}\Big] dt =\frac{1}{4\pi} \Big[\int_{0}^{2\pi} 1 dt - \int_{0}^{2\pi}{cos(2t)} \Big]dt =\frac{1}{4\pi} \Big[t \Big|_0^{2\pi} \ - \frac{sin(2x)}{2}\Big|_0^{2\pi} \ \Big] =\frac{1}{4\pi}\Big[(2\pi-0)- (sin(2\pi)-sin(0)) \Big] = \frac{1}{2}

que es el resultado de potencia obtenido usando Python.

Tarea

Realice el mismo cálculo para la energía de la señal del ejemplo anterior.

[ señal de energía ] [ señal de potencia ]

1.8 Señales con desplazamiento. escalamiento o inversión en tiempo

Referencia: Oppenheim 1.2.1 p8 pdf39, Lathi 1.2-1 p71

[ desplazamiento ] [ escalamiento ] [ inversión ] en el dominio tiempo

..


Desplazamiento en tiempo de señales

Una señal x(t) que se retrasa por k segundos se representa como una versión desplazada hacia la derecha el eje t.

Es decir:

\phi (t+k)= x(t)

o de otra forma:

\phi (t)= x(t-k)

se podrá observar entonces que el signo determina el desplazamiento hacia:

  • la derecha si se resta k
  • la izquierda si se suma k

Para mostrar las reglas, se tiene el siguiente ejemplo, usando como señal

x(t)=sen(t)

señal desplaza tiempo 01 animado

señal desplazada en tiempo

Instrucciones en Python

# Señales- Operaciones
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
w  = 1
fx = lambda t: np.sin(w*t)
k  = 1  # desplazamiento

# intervalo de tiempo [a,b)
a  = -8
b  = 8
dt = 0.1

# PROCEDIMIENTO
ti = np.arange(a,b,dt)

senal     = fx(ti)
derecha   = fx(ti-k)
izquierda = fx(ti+k)

# SALIDA
plt.figure(1)
plt.plot(ti,senal,label='x(t)')

plt.plot(ti,derecha,
         label='derecha : x(t-k)',
         linestyle='dashed')
plt.plot(ti,izquierda,
         label='izquierda: x(t+k)',
         linestyle='dashed')

plt.axvline(0, color='gray')
plt.axhline(0, color='gray')
plt.xlabel('t')
plt.legend(loc='lower left')
plt.grid()

plt.show()

[ desplazamiento ] [ escalamiento ] [ inversión ] en el dominio tiempo
..


Escalamiento en tiempo de señales

La compresión o expansión de la señal en el tiempo es conocida como escalamiento en el tiempo.

Considere la señal x(t) afectada en el tiempo por un factor de 2.
Se encuentra que:

\phi\Big(\frac{t}{2}\Big)=x(t) \phi(t)=x(2t)

siguiendo con la señal del ejercicio anterior

x(t) = sin(t)

señal escala t 01 animado

señal expande o comprime en tiempo

# Escalamiento en tiempo
factor = 2
expande  = fx(ti/factor)
comprime = fx(factor*ti)

# GRAFICA expande o comprime
plt.figure(2)
plt.plot(ti,senal,label='x(t)')
plt.plot(ti,expande,
         label='expande=x(t/factor)',
         linestyle='dashed')
plt.plot(ti,comprime,
         label='comprime=x(t*factor)',
         linestyle='dashed')
plt.axvline(0, color='gray')
plt.axhline(0, color='gray')
plt.xlabel('t')
plt.legend(loc='lower left')
plt.grid()

plt.show()

[ desplazamiento ] [ escalamiento ] [ inversión ] en el dominio tiempo

..


Inversión en tiempo de una señal

Si la función resultante es x(-t), la señal x(t) se invierte rotando sobre el eje de las ordenadas (vertical).

\phi (t)= x(-t)

inversión de tiempo 01 animado

Observe el resultado de la ecuación de ejemplo:

señal inversion en tiempo

# inversion en tiempo
espejo = fx(-ti)

# SALIDA
plt.figure(3)
plt.plot(ti,senal,label='x(t)')
plt.plot(ti,espejo,
         label='espejo=x(-t)',
         linestyle='dashed')
plt.axvline(0, color='gray')
plt.axhline(0, color='gray')
plt.xlabel('t')
plt.legend(loc='lower left')
plt.grid()

plt.show()

[ desplazamiento ] [ escalamiento ] [ inversión ] en el dominio tiempo


Modelo general de desplazamiento, escalamiento, e inversión

En resumen, el efecto de transformar la variable independiente de una señal x(t) para obtener la señal modificada es de la forma:

x(at+b)

Con la transformación, la variable independiente conserva la forma de x(t). La señal puede ser:

  • alargada linealmente cuando |a| < 1 ,
  • comprimida si |a| > 1,
  • invertida en el tiempo si a < 0, y
  • desplazada en el tiempo si b es diferente de cero.
    • siendo desplazada a la derecha si se resta el valor de |b|
    • siendo desplazada a la izquierda si se suma el valor de |b|

Ejemplo de desplazamiento en tiempo de una señal

Observe por un minuto el siguiente video sobre el desplazamiento en el tiempo (delay) en una guitarra.

[ desplazamiento ] [ escalamiento ] [ inversión ] en el dominio tiempo

1.7.1 Señales – Exponencial compleja

Referencia: Lathi 1.4-3 p89, Hsu 1.3.C p9, Oppenheim 1.3.1 p15 pdf46.

Exponencial est

Otra función importante en señales y sistemas es la señal est, donde s es en general de tipo compleja:

s = \sigma + j \omega

lo que convierte:

e^{st} =e^{( \sigma + j \omega)t} = e^{\sigma t} e^{j \omega t} e^{st} =e^{\sigma t} \Big( \cos (\omega t) + j \sin (\omega t)\Big)

dado que la conjugada s* = σ – jω

e^{s^* t} =e^{( \sigma - j \omega)t} = e^{\sigma t} e^{-j \omega t} e^{s^* t} =e^{\sigma t} \Big( \cos (\omega t) - j \sin (\omega t)\Big)

por lo que sumando las ecuaciones resultantes anteriores:

e^{\sigma t} cos(\omega t) = \frac{1}{2}\Big( e^{st} + e^{s^{*}t} \Big)

Comparado con la formula de Euler, se muestra que est es una generalización de e.

La función est tiene varias formas que pueden ser:

  1. una constante k = est cuando s=0
  2. una exponencial monótona eσt cuando ω=0 y s=σ
  3. una sinusoide cos (ωt) cuando σ=0 y s=±jω
  4. una sinusoide con amplitud exponenial  eσt cos (ωt) cuando s=σ ±jω

Desarrollamos la gráfica del primer caso en Python, a partir de la cual repetimos el proceso para analizas los demas casos.

# Señales modelo varias
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
senal = lambda s,t: np.exp(s*t)
sigma = 0  # s = 0 +0j
omega = 0

a  = -5 # intervalo de tiempo [a,b)
b  = 5
dt = 0.1

# PROCEDIMIENTO
ti = np.arange(a, b, dt)
s_i = complex(sigma,omega)
senal_i = senal(s_i,ti)

# SALIDA - gráfica
plt.figure(1)
plt.plot(ti,np.real(senal_i),label='real')
plt.plot(ti,np.imag(senal_i),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.grid()
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

A partir de aquí se continúa con la definición de t en el intervalo del ejercicio anterior, por lo que las instrucciones de Python se añaden a continuación de lo anterior.

Un exponencial simple σ>0 ω=0

Para éste caso se modifica en el bloque de ingreso los parámetros de σ=1 y ω=0, con lo que el algoritmo realiza la gráfica presentada.

# un exponencial simple sigma>0 omega=0 
sigma = 1
omega = 0

un exponencial simple σ<0 ω=0

Para éste caso se modifica en el bloque de ingreso los parámetros de σ=-1 y ω=0, con lo que el algoritmo realiza la gráfica presentada.

# un exponencial simple sigma<0 omega=0
sigma = -1
omega = 0

un sinusiode σ=0, ω>0

Para éste caso se modifica en el bloque de ingreso los parámetros de σ=0 y ω=1, con lo que el algoritmo realiza la gráfica presentada.

# un sinusiode sigma=0, omega>0
sigma = 0
omega = 1

un sinusiode σ=0, ω<0

Para éste caso se modifica en el bloque de ingreso los parámetros de σ=0 y ω=-1, con lo que el algoritmo realiza la gráfica presentada.

# un sinusiode sigma=0, omega<0
sigma = 0
omega = -1

un sinusoide con amplitud exponencial σ=0.25, ω>0

# un sinusoide con amplitud exponencial sigma=0.25, omega>0
sigma = 0.25
omega = 4

un sinusoide con amplitud exponencial σ=-0.25, ω>0

# un sinusoide con amplitud exponencial sigma=-0.25, omega>0
sigma = -0.25
omega = 4

1.7 Señales Compuestas

Referencia: Lathi Ejercicio 1.8 p86, Oppenheim ejemplo 1.1 p10, Hsu problema 1.22 p35

Una señal compuesta que se construye con varias señales mas simples, que entre ellas se encuentran desplazadas, con cambios de escala en tiempo, etc. Para realizar la gráfica de la señal compuesta con Python se las escribe como la suma de las partes. También es posible usar la forma por partes piecewise() o como un conjunto de instrucciones por bloques.

En Python es necesario seleccionar la forma más conveniente para definir cada señal:

  • en formato simplificado lambda
  • por bloques def-return

Por ejemplo Un escalón es mas sencillo definir en formato Lamba. Sin embargo, una señal con más partes se recomendaría realizarla por partes o bloques, definiendo su forma más básica para luego poder realizar cambios de escala o desplazamientos en el tiempo.

u = lambda t: np.heaviside(t,1)

Ejemplo 1. Señal compuesta

Referencia: Lathi Ejercicio 1.8 p86

Demuestre que la señal mostrada en la figura (en libro y al final) puede ser descrita como:

x(t) = (t-1)\mu(t-1) - (t-2)\mu(t-2) - \mu(t-4)

Instrucciones en Python

En el ejercicio se presenta que la señal se compone de la «suma» de sus partes. Se aprovecha la propiedad de linealidad para los sistemas para el caso presentado

# Señales modelo varias- ejercicio
import numpy as np
import matplotlib.pyplot as plt

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

# señal como suma de las partes
x1 = lambda t: (t-1)*u(t-1)
x2 = lambda t: -(t-2)*u(t-2)
x3 = lambda t: - u(t-4)

x = lambda t: x1(t) + x2(t) + x3(t)

# tiempo intervalo de observación
a = -2
b = 8
dt = 0.05

# PROCEDIMIENTO
ti = np.arange(a, b, dt)
xi = x(ti)

# evalua componentes para grafica
x1i = x1(ti)
x2i = x2(ti)
x3i = x3(ti)

# SALIDA - gráfico

plt.figure(1) # componentes
plt.plot(ti, x1i, '--', label='(t-1)u(t-1)')
plt.plot(ti, x2i, '--', label='- (t-2)u(t-2)' )
plt.plot(ti, x3i, '--', label='- u(t-4)')
plt.plot(ti, xi, label='x(t)')
plt.legend()
plt.ylabel('x(t) por partes')
plt.xlabel('t')
plt.grid()

plt.figure(2) # señal compuesta
plt.plot(ti, xi, label='x(t)')
plt.ylabel('x(t)')
plt.xlabel('t')
plt.grid()

plt.show()

Ejemplo 2. Señal compuesta

Referencia: Oppenheim ejemplo 1.1a p10

Dada la señal x(t) mostrada en la siguiente gráfica, realizar x(t+1), …

Procedemos como en el ejercicio anterior, continuando con el uso de la función escalón μ(t) .

# Señales modelo varias-ejercicio
import numpy as np
import matplotlib.pyplot as plt

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

# señal como suma de las partes
x1 = lambda t: -(t-1)*u(t-1)
x2 = lambda t: (t-2)*u(t-2)

x = lambda t: u(t) + x1(t) + x2(t)

# tiempo intervalo de observación
a = -2
b = 8
dt = 0.05

# PROCEDIMIENTO
ti = np.arange(a, b, dt)
xi = x(ti)

# evalua componentes para grafica
x0i = u(ti)
x1i = x1(ti)
x2i = x2(ti)

# SALIDA - gráfico

plt.figure(1) # componentes
plt.plot(ti,x0i, '--', label='u(t)')
plt.plot(ti,x1i, '--', label='-(t-1)*u(t-1)')
plt.plot(ti,x2i, '--', label='(t-2)*u(t-2)')
plt.plot(ti,xi, label='x(t)')
plt.legend()
plt.ylabel('x(t) por partes')
plt.xlabel('t')
plt.grid()

plt.figure(2) # señal compuesta
plt.plot(ti, xi, label='x(t)')
plt.ylabel('x(t)')
plt.xlabel('t')
plt.grid()

plt.show()

el resultado de la señal compuesta se observa en la gráfica


Ejercicio3. Señal con desplazamiento y escala

Referencia: Oppenheim ejemplo 1.1b p10

Semejante al ejercicio anterior, realizar la gráfica:

2x(t+1)

Para el ejercicio, se define el punto donde se desplaza la señal, y la escala para la amplitud. Para observar los cambios se grafica el desplazamiento y luego el cambio de escala en magnitud.

# INGRESO 
desplaza = -1
escala = 2

xd_i = x(ti-desplaza)
yi = escala*x(ti-desplaza)

# salida - gráfico
plt.figure(4)
plt.plot(ti, xi, '--' , label='x(t)')
plt.plot(ti, xd_i, '-.', label='x(t-desplaza)')
plt.plot(ti, yi, label='escala*x(t-desplaza)')
plt.xlabel('t')
plt.legend()
plt.grid()

plt.show()


Tarea

Referencia: Oppenheim ejemplo 1.1a p10

A partir de la seña x(t) del ejercicio anterior, realice el ejercicio para obtener las gráficas:

  • x(-t+1)
  • x(3t/2)
  • x(3t/2 +1)

Otros ejercicios

Referencia: Hsu problema 1.22 p35

1.6 Señales Escalón unitario μ(t) e Impulso unitario δ(t)

Referencia: Lathi 1.4.1 p83, Hsu 1.3 p6, Oppenheim 1.4 p30

[ escalón unitario ] [ impulso unitario ]

..


1. Escalón unitario μ(t)

Muchos de los temas de curso usan sistemas causales que inician en t=0. La función que describe éste comportamiento es escalón unitario μ(t) descrita como:

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

señal escalon unitario

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

Instrucciones en Python

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

# Señales modelo varias
import numpy as np
import matplotlib.pyplot as plt

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

a = -10
b = 10
dt = 0.1

# PROCEDIMIENTO
ti  = np.arange(a, b, dt)
u0_i = u(ti)

# SALIDA - GRAFICA
print('t:',ti)
print('t:',u0_i)

# grafica
plt.figure(1)
plt.plot(ti,u0_i)

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

Señal Causal con Escalón unitario

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 causal con escalón unitario

# señal a causal
x = lambda t: np.exp(-t)*u(t)
xi = x(ti)

# SALIDA - GRAFICA
plt.figure(2)
plt.plot(ti,xi)

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

La función escalón unitario también permite realizar descripciones matemáticas sobre diferentes segmentos del tiempo.

Señal Rectangular

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)

señal rectangular, gate o compuerta con escalón unitario

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

u2 = lambda t: u(t-2)
u4 = lambda t: u(t-4)
rectangular = lambda t:u2(t) - u4(t)
rect_i = rectangular(ti)

# SALIDA - GRAFICA
plt.figure(3)
plt.plot(ti,rect_i)

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

[ escalón unitario ] [ impulso unitario ]

..


2. Impulso unitario δ(t)

El impulso unitario δ(t), delta de Dirac,  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.

función impulso unitario

Siguiendo el concepto, se puede representar como:

Instrucciones en Python

# Señales impulso unitario
import numpy as np
import matplotlib.pyplot as plt

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

impulso = lambda t,dt: u(t)-u(t-dt)

# intervalo de observación
a = -10
b = 10

dt = 0.1  # tamaño de paso
t0 = 0    # punto de impulso

# PROCEDIMIENTO
ti  = np.arange(a, b, dt)
impulso_i = impulso(ti,dt)

# SALIDA - GRAFICA
# plt.plot(ti,impulso_i)
plt.stem(ti,impulso_i)
plt.xlabel('t')
plt.ylabel('impulso()')
plt.grid()
plt.show()

Otra forma de representar el impulso unitario es:

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

que como instrucción es,

impulso = lambda t,t0,tolera: 1*(np.abs(t-t0)<=tolera)
t0 = 0  # punto de impulso
tolera = 1e-10 # casicero

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

# SALIDA - GRAFICA
plt.figure(5)
plt.stem(ti,impulso_i)

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

señal impulso unitario

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 librería Scipy para ese caso.

[ escalón unitario ] [ impulso unitario ]

1.5 Señales Pares e Impares

Referencia: Lathi 1.5 p92, Oppenheim 1.2.3 p13 pdf44, Hsu 1.2.E p3

función o señal par e impar

Señales Pares

Una función o señal x(t) ó x[n] es par si se «refleja» en el eje vertical u ordenadas, es decir tienen simetría reflectiva a través del eje de las y.

x(t) = x(-t) x[n] = x[-n]

La señal tiene los mismos valores para el lado positivo o negativo de |t|. Es como si se aplicara el valor absoluto de t antes de aplicarlo en la ecuación.

Señales Impares

La gráfica de una función o señal impar es simétrica con respecto al origen. Una señal x(t) ó x[n] es impar si se cumple que:

x(t) = -x(-t) x[n] = -x[-n]

Una señal impar debe ser necesariamente 0 en t=0 o n=0.


Ejemplo de gráfica de función o señal par con Python

Un señal par conocida es cos(t). Para observar mejor, se marcará el área que genera la función dentro de un periodo centrado en el origen. Para ilustrar mejor el concepto se reutiliza los ejemplos anteriores de señales periódicas.

Se inicializa los parámetros para:

  • el periodo T de una señal
  • el número m de periodos que se observarán de la señal, donde m debe ser un número par.
  • El punto de inicio t0 para el eje horizontal se puede calcular a partir de T y m, dado que se extiende hacia cada lado del eje vertical, t0 al encontrarse a la izquierda del eje vertical tiene signo negativo.
  • El punto de final tn para tendrá el signo positivo de t0
  • los tramos por periodo de la señal a observar, deben ser un número 2k, donde k es un número entero.
# Señales pares e impares
import numpy as np
import matplotlib.pyplot as plt

# INGRESO parámetros
T  = 2*np.pi
f  = 1/T
w  = 2*np.pi*f
fx = lambda t: np.cos(w*t)

m  = 2        # incluir m periodos en grafica
t0 = -(m/2)*T # usa lado negativo de abscisas
tramos = 32   # tramos por periodo 2**k, siendo k entero

Para observar mejor la gráfica, se marcará el área que genera la señal dentro de un periodo centrado en el origen.

La cantidad de muestras depende de cuántos periodos m de la señal se quieran observar. Se necesitan tantas muestras como tramos de cada lado, incluyendo la muestra del origen (m*tramos+1).

# PROCEDIMIENTO
tn = -t0 # vector de tiempo
muestras = m*tramos+1
ti = np.linspace(t0,tn,muestras)
# dt = ti[1]-ti[0]
dt = (tn-t0)/(tramos*m)

senal = fx(ti)

# marcar un periodo en [desde, hasta]
desde = -T/2
hasta = desde + T + dt
tperiodo = np.arange(desde,hasta,dt)
periodo = fx(tperiodo)

Se marca un periodo comprendido en: [-T/2,T/2], sombreando alrededor de t=0. Para destacar el eje vertical se usa el color rojo.

# SALIDA
# Gráficas
plt.plot(ti,senal)
plt.xlabel('t')
plt.ylabel('señal x(t)')
plt.grid(True)

# marcar un periodo
plt.title('Señal PAR')
plt.fill_between(tperiodo,0,periodo,
                 color='lightgreen')
plt.axvline(x=0, color='red')
plt.show()

Ejemplo de gráfica de función o señal impar con Python

En el ejemplo se usará una señal par como el sin(). Se utiliza las instrucciones del algoritmo anterior, modificando la señal f(x) en el bloque de ingreso

fx = lambda t: np.sin(w*t)

y el título de la gráfica

plt.title('Señal IMPAR')

Las instrucciones en Python para señales pares e impares son:

# Señales pares e impares
import numpy as np
import matplotlib.pyplot as plt

# INGRESO parámetros
T  = 2*np.pi
f  = 1/T
w  = 2*np.pi*f
fx = lambda t: np.cos(w*t)

m  = 2        # incluir m periodos en grafica
t0 = -(m/2)*T # usa lado negativo de abscisas
tramos = 32    # tramos por periodo 2**k, siendo k entero

# PROCEDIMIENTO
tn = -t0  # vector de tiempo
muestras = m*tramos+1
ti = np.linspace(t0,tn,muestras)
# dt = ti[1]-ti[0]
dt = (tn-t0)/(tramos*m)

senal = fx(ti)

# marcar un periodo en [desde, hasta]
desde = -T/2
hasta = desde + T + dt
tperiodo = np.arange(desde,hasta,dt)
periodo  = fx(tperiodo)

# SALIDA
# Gráficas
plt.plot(ti,senal)
plt.xlabel('t')
plt.ylabel('señal x(t)')
plt.grid(True)

# marcar un periodo
plt.title('Señal PAR')
plt.fill_between(tperiodo,0,periodo,
                 color='lightgreen')
plt.axvline(x=0, color='red')
plt.show()

Tarea

probar con otras funciones tales como:

  • t
  • |t|
  • t2
  • t3
  • |- et|

nota: el valor absoluto en Python para t se escribe como abs(t), o usando numpy np.abs(t)