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 (t–T), se lo conoce como «sistema con memoria finita»
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.
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.
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.
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.
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.
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.
En un sistema lineal cumple con el principio de superposición que se compone de la propiedad de aditividad y de la escalabilidad.
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.
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)
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:
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:
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.
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: Sympy – Fórmulas y funciones simbólicas
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 p103import 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)
# SALIDAprint('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()
Los sistemas se usan para procesar una señal con el objetivo de modificarla, por ejemplo sumar o restar información adicional.
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.
Otro 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)
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.
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:
para procesar el archivo, las instrucciones en Python son:
# Señales de Energía y Potenciaimport 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.
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)
# SALIDAprint(' 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]
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 Potenciaimport 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
# SALIDAprint('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
Para revisar los resultados, realizamos el cálculo de potencia haciendo x(t)=sin(t)
Comparado con la formula de Euler, se muestra que est es una generalización de ejω.
La función est tiene varias formas que pueden ser:
una constante k = est cuando s=0
una exponencial monótona eσt cuando ω=0 y s=σ
una sinusoide cos (ωt) cuando σ=0 y s=±jω
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 variasimport 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.
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- ejercicioimport 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-ejercicioimport 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.
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:
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 imparesimport 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 imparesimport 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)
El ejemplo más común es un sistema con un resistor:
