Sistemas

Referencia: Lathi 1.6 pdf/p.72, Oppenheim 1.5 pdf/.66, Schaum/Hsu 1.5 pdf/p.27

Los sistemas se usan para procesar una señal con el objetivo de modificarla, por ejemplo sumar o restar informacion 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 sistema

Un sistema se puede realizar por:
– Componentes físicos (hardware: componentes electrónicos)

FIEC05058_RLC_board

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.

scipy Resumen

la librería de funciones scipy (scientific python), dispone de funciones para el tratamiento de señales, estadíasticas, audio, entre otras.

El orden de las instrucciones es el que aparece en los post del blog.

instrucciones
import scipy.io.wavfile as waves librerias de audio en formato wac para lectura y escritura de archivos.
fsonido, sonido = waves.read(archivo) lectura de datos de un archivo de audio en formato wav. Se obtiene la frecuencia de muestreo en fsonido y los datos en sonido
import scipy.integrate as integrate importar metodos de integración de scipy
integrate.simps(valrores, ejex) integral de muestras de señal usando el método de Simpson.
. .
. .

numpy Resumen

la librería de funciones numpy facilitan el cálculo numérico, con datos de vectores y matrices en forma de «arrays».

El orden de las instrucciones es el que aparece en los post del blog.

instrucciones
import numpy as np Importar librerias de funciones Numpy, python numérico, usando un álias de dos letras «np»:
vector=np.arange(a,b,dt) crea un vector con valores en el rango [a,b) y espaciados dt.

t=np.arange(0,10,2)>>> t
array([0, 2, 4, 6, 8])
np.pi constante con valor π

>>> np.pi
3.141592653589793
np.sin(t)
np.cos(t)
función trigonométrica en radianes. La variable t puede ser un escalar o un arreglo.

>>> t=0.65
>>> np.sin(0.65)
0.60518640573603955
>>> t=[0, 0.3, 0.6]
>>> np.sin(t)
array([ 0. , 0.29552021, 0.56464247])
np.abs() obtiene el valor absoluto de un número. En el caso de un número complejo obtiene la parte real.
np.real(complejo)
np.imag(complejo)
obtiene la parte real de los números complejos en un vector. Se aplica lo mismo para la parte imaginaria del número complejo.
complex(a,b) crea el número complejo a partir de los valores de a y b.
a=2
b=3
el resultado es: 2+3j
np.piecewise(t, t>=donde, [1,0]) función que crea a partir de t, los valores de la condicion t>=donde, ubicando los valores de 1, para otro caso es 0. Usada en la funcion escalón.
np.roots([a,b,c]) obtiene las raíces del polinomio:
ax2+bx+c

siendo:

x2 + 3 x + 2 = (x+1)(x+2)
>>> np.roots([1,3,2])
array([-2., -1.])
np.linalg.solve(A,B) Resuelve el sistema de ecuaciones dado por una matriz A y un vector B. siendo, por ejemplo:

 0 =  c1 +  c2
-5 = -c1 - 2c2

c1 = -5 
c2 = 5
>>> A = [[ 1, 1],
	 [-1,-2]]
>>> B = [0,-5]
>>> np.linalg.solve(A,B)
array([-5.,  5.])
>>>

matplotlib Resumen

La librería de funciones matplotlib permite realizar las gráficas de datos. En los ejercicios se usan como datos los vectores y matrices «arrays».

El orden de las instrucciones es el que aparece en las entradas del blog.

instrucciones
%matplotlib inline intrucción de IPython para que las gráficas se incluyan en la página.
De no usarla, las gráficas aparecen en ventanas aparte.
import matplotlib.pyplot as plt Importar librerias de funciones matplotlib.pyplot, usando un álias de tres letras «plt»:
plt.plot(x,y) genera un gráfico de línea con los valores de x,y
plt.show() muestra el gráfico creado con las intrucciones.
Es la última instrucción a usar luego de crear el gráfico.
plt.xlabel(‘textoejex’)

plt.ylabel(‘textoejey’)

Asigna nombres a los ejes de abscisas y ordenas. El nombre se escribe entre ‘apóstrofes’ o «comillas».
plt.stem(x,y) gráfico de líneas verticales y un punto. Usado para mostrar señales discretas en los libros de texto de la bibliografía.
plt.figure(k) permite generar varias gráficas, numeradas cada una por el valor de k. En Python simple se muestran en ventanas separadas.
plt.title(‘texto’) escribe el título del gráfico, definido por ‘texto’
plt.fill_between(rangox, 0, valores, color=’green’ dibuja en el rango un área entre 0 y los valores, al color descrito: ‘green’, ‘ligthgreen’, ‘red’, ‘magenta’, ‘blue’, ‘yellow’, etc
plt.axvline(x=0, color=’red’)
plt.axhline(0, color=’red’)
ubica una linea vertical en el valor dado en x. ejemplo x=0.
El otro caso se refiere a una línea horizontal
plt.grid(True)
plt.grid(False)
dibuja líneas de división en la gráfica.
plt.legend() incluye una leyenda para cada curva a graficar. Trabaja en conjunto con
plt.plot(x,y, label=’nombre curva’)
plt.margins(0.1) crea un margen en la gráfica de valor 0.1 expandiendo los bordes sobre los máximos y mínimos. Se usa para ver claramente las variaciones en los extremos o cuando los valores máximos son constantes en un periodo.
. .
. .

Descargas

Winpython

WinPythonInstalador de Python para windows con librerias integradas: Numpy, Matplotlib, Scipy, IPython, entre otros… .

Las instrucciones se encuentran en:

http://blog.espol.edu.ec/ccpg1001/descargas/winpython-portable/


Pydroid

Si usará una tablet o celular para los ejercicios en python, se recomendaría usar Pydroid 3, que perimte instalar numpy, pandas, matplotlib para realizar los ejercicios.

Se obtiene de la tienda de google (google play):

https://play.google.com/store/apps/details?id=ru.iiec.pydroid3&hl=es_EC

En el menú principal dispone de la instruccion PIP para instalar las librerias adicionales que necesite.

http://blog.espol.edu.ec/ccpg1001/android-pydroid-3/


Scilab /Xcos

Software gráfico para modelar y simular señales discretas y contínuas en el dominio del tiempo.

https://www.scilab.org/download/

 

Señal compuesta

Señal compuesta

Una señal que se compone de varias señales mas simples se puede manejar como un conjunto de instrucciones por bloques.

Para ello, en Python es necesario seleccionar la forma más apropiada para definir cada señal:

  • por bloques def-return
  • en formato de linea lambda

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

Ejemplo 1

Referencia: Lathi Ejercicio 1.8 pdf/.65

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)

Algoritmo en python

En el ejercicio se presenta una solución por partes, mostrando que la señal se compone de la «suma» de sus partes. Se utiliza la propiedad de la linealidad para los sistemas.

# Señales modelo varias- ejercicio
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
# Función escalón
u = lambda t: np.piecewise(t, t>=0, [1,0])

# INGRESO - tiempos de observaciÓn
a = -2
b = 8
dt = 0.05

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

# componentes de la señal
# escalones desplazados
u0 = u(t)
u1 = u(t-1)
u2 = u(t-2)
u4 = u(t-4)
# las partes
x1 =  (t-1)*u1
x2 = -(t-2)*u2

# señal como suma de las partes
x = x1 + x2 - u4
# SALIDA - gráfico
plt.figure(1)

plt.subplot(121)
plt.plot(t, x1, '--', label='(t-1)u(t-1)')
plt.plot(t, x2, '--', label='- (t-2)u(t-2)' )
plt.plot(t, -u4, '--', label='- u(t-4)')
plt.plot(t, x, label='x(t)')
# plt.legend(loc="upper right")
plt.ylabel('x(t) por partes')
plt.xlabel('t')
plt.margins(0.1)

plt.subplot(122)
plt.plot(t, x, label='x(t)')
plt.ylabel('x(t)')
plt.xlabel('t')
plt.margins(0.1)
plt.show()

Ejemplo 2

Referencia: Oppenheim ejemplo 1.1 pdf/p.38

Dada la señal mostrada x(t) (en el libro y 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), las partes ahora conforman un bloque def-return.

# continuando en el intervalo de tiempo del ejercicio anterior
def senal(t):
    # componentes de la señal
    u0 = u(t)
    u1 = u(t-1)
    u2 = u(t-2)
    
    x1 = -(t-1)*u1
    x2 =  (t-2)*u2
    
    z = u0 + x1 + x2
    
    return(z)

# INGRESO - tiempos de observaciÓn
a = -2
b = 8
dt = 0.05

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

#señal
x = senal(t)
# SALIDA - gráfico
plt.figure(2)
plt.plot(t, u0, '--', label='u(t)')
plt.plot(t, x1, '--', label='- (t-1)u(t-1)' )
plt.plot(t, x2, '--', label='(t-2)u(t-2)')
plt.plot(t, x, label='x(t)')
plt.legend(loc=0)
plt.xlabel('t')
plt.show()

o de gráfica simplificada, solo con el resultado

# SALIDA - gráfico
plt.figure(3)
plt.plot(t, x, label='x(t)')
plt.xlabel('t')
plt.margins(0.1)
plt.show()

Ejercicio

Continuando con el ejercicio anterior, realizar la gráfica:

2x(t+1)

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

# INGRESO 
inicia = -1
escala = 2

xd = senal(t-inicia)
y = escala*senal(t-inicia)

# salida - gráfico
plt.figure(4)
plt.plot(t, x, '--' , label='x(t)')
plt.plot(t, xd, '-.', label='x(t-inicia)')
plt.plot(t, y, label='escala*x(t-inicia)')
plt.xlabel('t')
plt.legend()
plt.margins(0.1)
plt.show()


Tarea

Realice el ejercicio para obtener las gráficas:

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

Para mejor comprensión del proceso, se recomienda iniciar con un bloque que incluya todas las partes de forma independiente, y asi pueda modificar las instrucciones sin depender de los ejercicios anteriores.

Se adjunta lo recomendado:

# Sección para tarea, 
# se inicia con el último ejemplo

% matplotlib inline
# Señales modelo varias- ejercicio
# propuesta: edelros@espol.edu.ec
# librerias
import numpy as np
import matplotlib.pyplot as plt

# INGRESO - tiempos de observaciÓn
a = -2
b = 3
dt = 0.05

# PROCEDIMIENTO
t = np.arange(a, b, dt)
tescala = 3/2
inicio = 0
yescala = 1

# componentes de la señal
u0 = np.piecewise(t, (t-inicio)>=0, [1,0])
u1 = np.piecewise(t, (t-inicio)>=1, [1,0])
u2 = np.piecewise(t, (t-inicio)>=2, [1,0])

x1 = -((t-inicio)-1)*u1
x2 =  ((t-inicio)-2)*u2

#señal
x = yescala*(u0 + x1 + x2)

# SALIDA - gráfico
plt.figure(5)
plt.plot(t, x, label='x(t)')
plt.xlabel('t')
plt.legend(loc='upper left')
plt.margins(0.1)
plt.show()

Otros ejercicios

Schaum problema 1.22 pdf/p.35

Referencia: Lathi Ejercicio 1.8 pdf/.65, Oppenheim ejemplo 1.1 pdf/p.38, Schaum-Hsu problema 1.22 pdf/p.35

Señal Exponencial compleja

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 = σ + jω

lo que convierte:

est = e(σ + jω) 
    = eσ e 
    = eσt ( cos(ωt) + j sin(ωt) )

dado que la conjugada s* = σ – jω

es*t = e(σ - jω) 
    = eσ e-jω 
    = eσt ( cos(ωt) - j sin(ωt) )

por lo que sumando las ecuaciones anteriores:

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

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

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

# INGRESO
a = -5 # rango de tiempo
b = 5
dt = 0.1
sigma = 0  # s = 0 +0j
omega = 0

# PROCEDIMIENTO
t = np.arange(a, b, dt)
s = complex(sigma,omega)
senal = np.exp(s*t)

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

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

s = complex(sigma,omega)
senal = np.exp(s*t)

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

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

s = complex(sigma,omega)
senal = np.exp(s*t)

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

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

s = complex(sigma,omega)
senal = np.exp(s*t)

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

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

s = complex(sigma,omega)
senal = np.exp(s*t)

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

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

s = complex(sigma,omega)
senal = np.exp(s*t)

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

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

s = complex(sigma,omega)
senal = np.exp(s*t)

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

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

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.

Señales operaciones en tiempo

Referencia: Oppenheim 1.2.1 pdf/p.36, Lathi 1.2 pdf/p.55

Desplazamiento en tiempo

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:

# Señales- Operaciones
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt

# INGRESO - tiempo [a,b)
a = -8
b = 8
dt = 0.1
k = 1  # desplazamiento

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

senal = np.sin(t)
derecha = np.sin(t-k)
izquierda = np.sin(t+k)


# SALIDA
plt.figure(1)
plt.plot(t,senal,label='x(t)')
plt.plot(t,derecha,label='derecha=x(t-k)')
plt.plot(t,izquierda,label='izquierda=x(t+k)')
plt.axvline(0)
plt.xlabel('t')
plt.legend(loc='lower left')
plt.show()

Escalamiento en tiempo

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)

# Escalamiento en tiempo
factor = 2

expande = np.sin((1/factor)*t)
comprime = np.sin(factor*t)

#salida
plt.figure(2)
plt.plot(t,senal,label='x(t)')
plt.plot(t,expande,label='expande=x(t/factor)')
plt.plot(t,comprime,label='comprime=x(t*factor)')
plt.axvline(0)
plt.xlabel('t')
plt.legend(loc='lower left')
plt.show()

Inversión en tiempo

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

Observe el resultado de la ecuacion de ejemplo:

# inversion en tiempo
espejo = np.sin(-t)

#salida
plt.figure(3)
plt.plot(t,senal,label='x(t)')
plt.plot(t,espejo,label='espejo=x(-t)')
plt.axvline(0)
plt.xlabel('t')
plt.legend(loc='lower left')
plt.show()

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|

Desplazamiento en tiempo

solo de un click y observe por un minuto el siguiente video sobre el desplazamiento en el tiempo (delay) en una guitarra.