6.3 LTI DT – Respuesta impulso – Concepto

Referencia: Lathi 3.7 p277

Partiendo de

Q(E) y[n] = P(E) x[n]

la entrada x[n] es del tipo δ[n] con todas las condiciones iniciales cero.

Q(E) h[n] = P(E) \delta[n]

sujeta a h[-1] = h[-2] = … = h[-N] = 0

Solución de forma cerrada

Con entrada un impulso, solo los modos característicos se mantienen en el sistema, por lo que h[n] se compone de los modos característicos para n>0.

Con n=0, pueden tener valores no cero A0, por lo que la forma general de h[n] se puede expresar como:

h[n] = A_0 \delta[n] +y_c[n] \mu [n]

donde yc[n] es una combinación de los modos característicos, se debe encontrar Q[E] yc[n] u[n] = 0, con lo que se tiene,

A_0 Q[E] \delta [n] = P[E] \delta [n]

haciendo n=0 y usando el hecho que δ[m] = 0  para todo m ≠ 0 y δ[0] = 1, (pues  se ha asumido que es un sistema invariante en el tiempo LTI y la respuesta a δ[n-m] se puede expresar como h[n-m]), se tiene,

A_0 a_N = b_N A_0 = \frac{b_N}{a_N}

quedando la ecuación de respuesta a impulso como,

h[n] = \frac{b_N}{a_N} \delta[n] +y_c[n] \mu [n]

Los N coeficientes desconocidos en yc[n], del lado derecho de la ecuación se pueden determinar conociendo los N valores h[n]

6.2.2 LTI DT – Respuesta entrada cero – Resumen algoritmo Python

El algoritmo integra los casos presentados en los ejercicios anteriores para:

1. raíces reales diferentes
2. raíces con números complejos
3. raíces reales repetidas


Instrucciones en Python

EL detalle de los pasos se encuentra en los ejercicios con Python que se han integrado por caso.

# Sistema LTID. Respuesta entrada cero
# QE con raices Reales NO repetidas Lathi ejemplo 3.13 pdf271
# QE con raices Reales Repetidas Lathi ejemplo 3.15 p274
# QE con raices Complejas Lathi ejemplo 3.16 p275
# blog.espol.edu.ec/telg1001
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
# coeficientes E con grado descendente
QE = [1.0, -1.56, 0.81]
PE = [0., 1., 3.]
# condiciones iniciales ascendente ...,y[-2],y[-1]
inicial = [1.,2.]

tolera = 1e-6  # casi_cero

# PROCEDIMIENTO
# Respuesta a ENTRADA CERO
# raices, revisa numeros complejos
gamma = np.roots(QE)
revisaImag = np.iscomplex(gamma)
escomplejo = np.sum(revisaImag)

# coeficientes de ecuacion
m_q = len(QE)-1
Ac = np.zeros(shape=(m_q,m_q),dtype=float)

# revisa si parte compleja <tolera o casi_cero 
if escomplejo>0:
    for i in range(0,m_q,1):
        valorimag = np.imag(gamma[i])
        if np.abs(valorimag)<tolera:
            gamma[i] = float(np.real(gamma[i]))
    sumaj = np.sum(np.abs(np.imag(gamma)))
    if sumaj <tolera:
        print(sumaj)
        gamma = np.real(gamma)
        escomplejo = 0

# revisa repetidos
unicoscuenta = np.unique(gamma,return_counts=True)
repetidas = np.sum(unicoscuenta[1]-1)

# Determina coeficientes ci de Y[n]
# raices Reales no repetidas
if escomplejo == 0 and repetidas==0:
    for i in range(0,m_q,1):
        for j in range(0,m_q,1):
            Ac[i,j] = gamma[j]**(-m_q+i)
    ci = np.linalg.solve(Ac,inicial)
    
# raices Reales repetidas
if escomplejo == 0 and repetidas > 0:
    for i in range(0,m_q,1):
        for j in range(0,m_q,1):
            Ac[i,j] = ((-m_q+i)**j)*gamma[j]**(-m_q+i)
    ci = np.linalg.solve(Ac,inicial)

# raices Complejas
if escomplejo > 0:
    g_magnitud = np.absolute(gamma)
    g_angulo = np.angle(gamma)

    for i in range(0,m_q,1):
        k = -(m_q-i)
        a = np.cos(np.abs(g_angulo[i])*(k))*(g_magnitud[i]**(k))
        b = -np.sin(np.abs(g_angulo[i])*(k))*(g_magnitud[i]**(k))
        Ac[i] = [a,b]
    Ac = np.array(Ac)
    cj = np.linalg.solve(Ac,inicial)

    theta = np.arctan(cj[1]/cj[0])
    ci = cj[0]/np.cos(theta)

# ecuacion y0 entrada cero
n = sym.Symbol('n')
y0 = 0*n

if escomplejo == 0 and repetidas==0:
    for i in range(0,m_q,1):
        y0 = y0 + ci[i]*(gamma[i]**n)
        
if escomplejo == 0 and repetidas > 0:
    for i in range(0,m_q,1):
        y0 = y0 + ci[i]*(n**i)*(gamma[i]**n)
    y0 = y0.simplify()

if escomplejo > 0:
    y0 = ci*(g_magnitud[0]**n)*sym.cos(np.abs(g_angulo[i])*n - theta)
    
# SALIDA
print('respuesta entrada cero: ')
print('raices: ', gamma)
if escomplejo == 0:
    if repetidas>0:
        print('Raices repetidas: ', repetidas)
    print('Matriz: ')
    print(Ac)
    print('Ci:     ', ci)
    print('y0:')
    sym.pprint(y0)
if escomplejo > 0:
    print('raices complejas: ', escomplejo)
    print('magnitud:',g_magnitud)
    print('theta:',g_angulo)
    print('Matriz: ')
    print(Ac)
    print('Cj: ', cj)
    print('Ci: ',ci)
    print('y0: ')
    sym.pprint(y0)

6.2.1 LTI DT – Respuesta entrada cero. Ejercicios con Python

Los siguientes ejercicios de LTI Discretos muestran los desarrollos  cuando el denominador de la función de transferencia tiene:

1. raíces reales diferentes (No repetidas)
2. raíces reales repetidas
3. raíces con números complejos


Ejercicio 1. Raíces reales diferentes

Referencia: Lathi Ejemplo 3.13 p271

Para un sistema LTID descrito por la ecuación de diferencias mostrada,

y[n+2] - 0.6 y[n+1] - 0.16 y[n] = 5x[n+2]

encuentre la respuesta a entrada cero y0[n] del sistema dadas las condiciones iniciales y[-1]=0, y[-2] =25/4, ante una entrada

x[n]= 4^{-n} \mu [n]

(El componente de estado cero se calcula en la sección correspondiente)


Para realizar el diagrama, se desplaza la ecuación en dos unidades

y[n] - 0.6 y[n-1] - 0.16 y[n-2] = 5x[n] y[n] = 0.6 y[n-1] + 0.16 y[n-2] + 5x[n]

Para respuesta a entrada cero se usa x[n] = 0

1.1 Desarrollo analítico

y[n+2] - 0.6 y[n+1] - 0.16 y[n] = 5x[n+2]

La ecuación del sistema en notación de operador E es:

E^2 y[n] - 0.6 E y[n] - 0.16 y[n] = 5 E^2 x[n] (E^2 - 0.6 E - 0.16) y[n] = 5 E^2 x[n]

que para entrada cero tiene x[n]=0,

(E^2 - 0.6 E - 0.16) y[n] = 0

tiene el polinomio característico,

\gamma^2 - 0.6 \gamma - 0.16 = 0 (\gamma+0.2) (\gamma - 0.8) = 0

con raíces características γ1=-0.2 y γ2=0.8, obtenidas con  instrucciones con Python:

raices:
[ 0.8 -0.2]
coeficientes:
[0.8 0.2] 

la repuesta a entrada cero tiene la forma

y_0[n] = c_1 (-0.2)^n + c_2 (0.8)^n

se usan las condiciones iniciales para determinar las constantes c1 y c2 aplicadas como:

y_0[-1] = c_1 (-0.2)^{-1} + c_2 (0.8)^{-1} 0 = -5 c_1 + 1.25 c_2 y_0[-2] = c_1 (-0.2)^{-2} + c_2 (0.8)^{-2} \frac{25}{4} = 25 c_1 + 1.5625 c_2

se tiene el sistema de ecuaciones

0 = -5 c_1 + 1.25 c_2 \frac{25}{4} = 25 c_1 + 1.5625 c_2

resolviendo se encuentra que: c1 = 0.2 c2 = 0.8

con lo que la solución tiene la expresión basado en la sumatoria de ci ϒn, para n≥0

y_0 [n] = \frac{1}{5} (-0.2)^n + \frac{4}{5} (0.8)^n

Instrucciones en Python

import numpy as np

coeficientes = [1.,-0.6,-0.16]
raiz = np.roots(coeficientes)
print('raices:')
print(raiz)

A = np.array([[raiz[0]**(-1) , raiz[1]**(-1)],
     [raiz[0]**(-2) , raiz[1]**(-2)]])
B = np.array([0., 25/4])
ci = np.linalg.solve(A,B)
print('coeficientes:')
print(ci)

1.2 Desarrollo con Python

El algoritmo requiere los coeficientes de la ecuación de diferencias Q(E) y P(E) junto a las condiciones iniciales.

QE = [1., -0.6, -0.16]
PE = [5., 0., 0.]
inicial = [25/4, 0.] 

que da como resultado:

respuesta entrada cero: 
raices:  [ 0.8 -0.2]
Matriz: 
[[ 1.5625 25.    ]
 [ 1.25   -5.    ]]
Ci:      [0.8 0.2]
y0:
        n          n
0.2*-0.2  + 0.8*0.8 

Instrucciones en Python

# Sistema LTID. Respuesta entrada cero
# resultado con raices Reales
# ejercicio Lathi ejemplo 3.13 p271
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
# coeficientes E con grado descendente
QE = [1., -0.6, -0.16]
PE = [5., 0., 0.]
# condiciones iniciales ascendente ...,y[-2],y[-1]
inicial = [25/4, 0.] 

# PROCEDIMIENTO
# Respuesta a ENTRADA CERO
# raices, revisa numeros complejos
gamma = np.roots(QE)
revisaImag = np.iscomplex(gamma)
escomplejo = np.sum(revisaImag)

# coeficientes de ecuacion
m_q = len(QE)-1
Ac = np.zeros(shape=(m_q,m_q),dtype=float)

if escomplejo == 0:
    for i in range(0,m_q,1):
        for j in range(0,m_q,1):
            Ac[i,j] = gamma[j]**(-m_q+i)
    ci = np.linalg.solve(Ac,inicial)

# ecuacion y0
n = sym.Symbol('n')
y0 = 0
if escomplejo == 0:
    for i in range(0,m_q,1):
        y0 = y0 + ci[i]*(gamma[i]**n)
    
# SALIDA
print('respuesta entrada cero: ')
print('raices: ', gamma)
if escomplejo == 0:
    print('Matriz: ')
    print(Ac)
    print('Ci:     ', ci)
    print('y0:')
    sym.pprint(y0)
else:
    print(' existen raices con números complejos.')
    print(' usar algoritmo de la sección correspondiente.')

Raíces: [reales No repetidas] [reales repetidas] [números complejos]


2. Raíces repetidas

Referencia: Lathi Ejemplo 3.15 p274

y[n+2] +6 y[n+1] + 9 y[n] = 2 x[n+2] + 6 x[n+1]

con las condiciones iniciales y0[-1] = -1/3 y y0[-2] = -2/9

Para realizar el diagrama de bloques, se desplaza ambos lados de la ecuación en 2 unidades. Luego se despeja y[n]

y[n] +6 y[n-1] + 9 y[n-2] = 2 x[n] + 6 x[n-1] y[n] = -6 y[n-1] - 9 y[n-2] + 2 x[n] + 6 x[n-1]

2.1 Desarrollo analítico

siguiendo los mismos pasos que en los ejercicios anteriores

E^2 y[n] +6 E y[n] + 9 y[n] = 2 E^2 x[n] + 6 E x[n] (E^2 +6 E + 9) y[n] = (2 E^2 + 6 E) x[n]

Para entrada cero se tiene x[n] = 0

(E^2 +6 E + 9) y[n] = (2 E^2 + 6 E) (0) \gamma^2 +6 \gamma + 9 = 0 (\gamma + 3)( \gamma + 3) = 0

de donde se muestra una raiz repetida γ=3, donde los modos característicos hacen que la expresión sea:

y_0[n] = (c_1 + c_2 n) (\gamma)^n

siguiendo el procedimiento realizado para raíces reales se puede determinar los valores de c1=4 y c2=3, con lo que se obtiene la solución:

y_0[n] = (4 + 3n) (-3)^n

los resultados obtenidos con el algoritmo en Python son

respuesta entrada cero: 
raices:  [-3. -3.]
Raices repetidas:  1
Matriz: 
[[ 0.11111111 -0.22222222]
 [-0.33333333  0.33333333]]
Ci:      [4. 3.]
y0:
    n              
-3.0 *(3.0*n + 4.0)
>>>

2.2 Instrucciones en Python, integrando raices reales únicas y repetidas

# Sistema LTID. Respuesta entrada cero
# QE con raices Reales NO repetidas Lathi ejemplo 3.13 pdf271
# QE con raices Reales Repetidas Lathi ejemplo 3.15 p274
# blog.espol.edu.ec/telg1001
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
# coeficientes E con grado descendente
QE = [1., 6., 9.]
PE = [2., 6., 0.]
# condiciones iniciales ascendente ...,y[-2],y[-1]
 inicial = [-2/9, -1/3]

tolera = 1e-6  # casi_cero

# PROCEDIMIENTO
# Respuesta a ENTRADA CERO
# raices, revisa numeros complejos
gamma = np.roots(QE)
revisaImag = np.iscomplex(gamma)
escomplejo = np.sum(revisaImag)

# coeficientes de ecuacion
m_q = len(QE)-1
Ac = np.zeros(shape=(m_q,m_q),dtype=float)

# revisa si parte compleja <tolera o casi_cero 
if escomplejo>0:
    for i in range(0,m_q,1):
        if np.imag(gamma[i]) < tolera:
            gamma[i] = float(np.real(gamma[i]))
    sumaj = np.sum(np.imag(gamma))
    if sumaj <tolera:
        gamma = np.real(gamma)
        escomplejo = 0

# revisa repetidos
unicoscuenta = np.unique(gamma,return_counts=True)
repetidas = np.sum(unicoscuenta[1]-1)

# raices Reales no repetidas
if escomplejo == 0 and repetidas==0:
    for i in range(0,m_q,1):
        for j in range(0,m_q,1):
            Ac[i,j] = gamma[j]**(-m_q+i)
    ci = np.linalg.solve(Ac,inicial)
    
# raices Reales repetidas
if escomplejo == 0 and repetidas > 0:
    for i in range(0,m_q,1):
        for j in range(0,m_q,1):
            Ac[i,j] = ((-m_q+i)**j)*gamma[j]**(-m_q+i)
    ci = np.linalg.solve(Ac,inicial)

# ecuacion y0 entrada cero
n = sym.Symbol('n')
y0 = 0*n

if escomplejo == 0 and repetidas==0:
    for i in range(0,m_q,1):
        y0 = y0 + ci[i]*(gamma[i]**n)
        
if escomplejo == 0 and repetidas > 0:
    for i in range(0,m_q,1):
        y0 = y0 + ci[i]*(n**i)*(gamma[i]**n)
    y0 = y0.simplify()
    
# SALIDA
print('respuesta entrada cero: ')
print('raices: ', gamma)
if escomplejo == 0:
    if repetidas>0:
        print('Raices repetidas: ', repetidas)
    print('Matriz: ')
    print(Ac)
    print('Ci:     ', ci)
    print('y0:')
    sym.pprint(y0)
else:
    print(' existen raices con números complejos.')
    print(' usar algoritmo de la sección correspondiente.')

Raíces: [reales No repetidas] [reales repetidas] [números complejos]


Ejercicio 3. Raices con números complejos

Referencia: Lathi Ejemplo 3.16 p275

Para el caso de tener raíces con números complejos se muestra el siguiente ejemplo:

y[n+2] - 1.56 y[n+1] + 0.81 y[n] = x[n+1] + 3x[n]

con condiciones iniciales y0[-1]=2 y y0[-2]=1

Para realizar el diagrama de bloques, se desplaza ambos lados de la ecuación en 2 unidades. Luego se despeja y[n]

y[n] - 1.56 y[n-1] + 0.81 y[n-2] = x[n-1] + 3x[n-2] y[n] = 1.56 y[n-1] - 0.81 y[n-2] + x[n-1] + 3x[n-2]

3.1 Desarrollo analítico

y[n+2] - 1.56 y[n+1] + 0.81 y[n] = x[n+1] + 3x[n]

La expresión usando operador E:

E^2 y[n] - 1.56 E y[n] + 0.81 y[n] = E x[n] + 3x[n] (E^2 - 1.56 E + 0.81) y[n] = (E+ 3)x[n]

para entrada cero se hace x[n] = 0

(E^2 - 1.56 E + 0.81) y[n] = (E+ 3)(0)

por lo que, el polinomio característico es,}

(\gamma^2 - 1.56 \gamma + 0.81) = 0

con raíces de números complejos

(\gamma - (0.78 + j 0.45))(\gamma - (0.78-j 0.45)) = 0

la raíz también se puede escribir como:

\gamma = 0.9 e^{\pm j\frac{\pi}{6}}

obtenida mediante:

raices:
[0.78+0.44899889j 0.78-0.44899889j]
magnitud:  [0.9 0.9]
angulo:  [ 0.52231482 -0.52231482]
>>>  

Se puede escribir la solución como:

y_0[n] = c(0.9)n e^{j\frac{\pi}{6} } + c^{*} (0.9)n e^{-j\frac{\pi}{6}}

Luego aplicando oas condiciones iniciales  se encuentra que

c = 2.34 e^{-j0.17} c^{*} = 2.34 e^{j0.17}

Otra manera de desarrollo permite encontrar la solución usando la forma real de la solución, conociendo que la solución esta dada por la expresión:

y_0[n] = c(0.9)^n \cos \Big( \frac{\pi}{6}n + \theta \Big)

con lo que se puede crear el sistema de ecuaciones aplicando las condiciones iniciales, ademas de considerar que:

\cos(a \pm b) = \cos(a) \cos(b) \mp \sin(a) \sin(b)

Para y0[-2] = 1

1 = c(0.9)^{-2} \cos \Big( \frac{\pi}{6}(-2) + \theta \Big) 1 = c\frac{1}{(0.9)^2} \Big[ \cos \big(-2\frac{\pi}{6} \big) \cos ( \theta ) - \sin \big(-2\frac{\pi}{6}\big) \sin (\theta) \Big] 1 = c\frac{1}{0.81} \Big[ \frac{1}{2} \cos ( \theta ) - \frac{-\sqrt{3}}{2} \sin (\theta) \Big] 1 = c \Big[ \frac{1}{1.62} \cos ( \theta ) + \frac{\sqrt{3}}{1.62} \sin (\theta) \Big]

Para y0[-1] = 2

2 = c(0.9)^{-1} \cos \Big( \frac{\pi}{6}(-1) + \theta \Big) 2 = c\frac{1}{0.9} \Big[ \cos \big(-\frac{\pi}{6} \big) \cos ( \theta ) - \sin \big(-\frac{\pi}{6}\big) \sin (\theta) \Big] 2 = c\frac{1}{0.9} \Big[ \frac{\sqrt{3}}{2} \cos ( \theta ) - \frac{-1}{2} \sin (\theta) \Big] 2 = c\Big[ \frac{\sqrt{3}}{1.8} \cos ( \theta ) + \frac{1}{1.8} \sin (\theta) \Big]

con lo que se puede determinar los valores para [c cos(θ)] y [c sin(θ)]

usando una matriz A y vector B a partir de las ecuaciones

c \cos ( \theta ) = 2.31 c \sin ( \theta ) = -0.4049

al dividir  [c sin(θ)]/[c cos(θ)] = tan (θ), con lo que se obtiene el ángulo en radianes.

\frac{ c \sin ( \theta )} {c \cos ( \theta )} = \frac{-0.4049}{2.31} = -0.17528 \theta = \tan ^{-1} (-0.17528) = -0.1735

al sustituir el valor en c cos(θ) = 2.31 se tiene,

c = \frac{2.31}{ \cos (-0.1735)} = 2.3452

con lo que la solución se puede escribir mediante:

y_0[n] = 2.3452 (0.9)^n \cos \Big( \frac{\pi}{6}n - 0.1735 \Big)

para n≥0

Instrucciones de cálculo

import numpy as np

coeficientes = [1.,-1.56,0.81]
raiz = np.roots(coeficientes)
print('raices:')
print(raiz)

g_magnitud = np.absolute(raiz)
g_angulo = np.angle(raiz)

print('magnitud: ',g_magnitud)
print('angulo: ',g_angulo)

3.2 Algoritmo en Python, integrando raices reales y complejas

usando el algoritmo se obtienen los siguientes resultados:

Respuesta entrada cero: 
raices :  [0.78+0.44899889j 0.78-0.44899889j]
raices complejas:  2
magnitud: [0.9 0.9]
theta: [ 0.52231482 -0.52231482]
Matriz: 
[[0.62002743 1.06757851]
 [0.96296296 0.55431961]]
Cj:      [ 2.31       -0.40490078] 
Ci:  2.345217397781524
y0: 
                    n                                             
2.34521739778152*0.9 *cos(0.522314821806049*n + 0.173519005551295)
>>> 

Para el caso de raíces complejas, se añade al algoritmo anterior las instrucciones en Python:

# Sistema LTID. Respuesta entrada cero
# QE con raices Reales NO repetidas Lathi ejemplo 3.13 pdf271
# QE con raices Reales Repetidas Lathi ejemplo 3.15 p274
# QE con raices Complejas Lathi ejemplo 3.16 p275
# blog.espol.edu.ec/telg1001
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
# coeficientes E con grado descendente
QE = [1.0, -1.56, 0.81]
PE = [0., 1., 3.]
# condiciones iniciales ascendente ...,y[-2],y[-1]
inicial = [1.,2.]

tolera = 1e-6  # casi_cero
muestras = 10  # para grafica

# PROCEDIMIENTO
# Respuesta a ENTRADA CERO
# raices, revisa numeros complejos
gamma = np.roots(QE)
revisaImag = np.iscomplex(gamma)
escomplejo = np.sum(revisaImag)

# coeficientes de ecuacion
m_q = len(QE)-1
Ac = np.zeros(shape=(m_q,m_q),dtype=float)

# revisa si parte compleja <tolera o casi_cero 
if escomplejo>0:
    for i in range(0,m_q,1):
        valorimag = np.imag(gamma[i])
        if np.abs(valorimag)<tolera:
            gamma[i] = float(np.real(gamma[i]))
    sumaj = np.sum(np.abs(np.imag(gamma)))
    if sumaj <tolera:
        print(sumaj)
        gamma = np.real(gamma)
        escomplejo = 0

# revisa repetidos
unicoscuenta = np.unique(gamma,return_counts=True)
repetidas = np.sum(unicoscuenta[1]-1)

# Determina coeficientes ci de Y[n]
# raices Reales no repetidas
if escomplejo == 0 and repetidas==0:
    for i in range(0,m_q,1):
        for j in range(0,m_q,1):
            Ac[i,j] = gamma[j]**(-m_q+i)
    ci = np.linalg.solve(Ac,inicial)
    
# raices Reales repetidas
if escomplejo == 0 and repetidas > 0:
    for i in range(0,m_q,1):
        for j in range(0,m_q,1):
            Ac[i,j] = ((-m_q+i)**j)*gamma[j]**(-m_q+i)
    ci = np.linalg.solve(Ac,inicial)

# raices Complejas
if escomplejo > 0:
    g_magnitud = np.absolute(gamma)
    g_angulo = np.angle(gamma)

    for i in range(0,m_q,1):
        k = -(m_q-i)
        a = np.cos(np.abs(g_angulo[i])*(k))*(g_magnitud[i]**(k))
        b = -np.sin(np.abs(g_angulo[i])*(k))*(g_magnitud[i]**(k))
        Ac[i] = [a,b]
    Ac = np.array(Ac)
    cj = np.linalg.solve(Ac,inicial)

    theta = np.arctan(cj[1]/cj[0])
    ci = cj[0]/np.cos(theta)

# ecuacion y0 entrada cero
n = sym.Symbol('n')
y0 = 0*n

if escomplejo == 0 and repetidas==0:
    for i in range(0,m_q,1):
        y0 = y0 + ci[i]*(gamma[i]**n)
        
if escomplejo == 0 and repetidas > 0:
    for i in range(0,m_q,1):
        y0 = y0 + ci[i]*(n**i)*(gamma[i]**n)
    y0 = y0.simplify()

if escomplejo > 0:
    y0 = ci*(g_magnitud[0]**n)*sym.cos(np.abs(g_angulo[i])*n - theta)
    
# SALIDA
print('respuesta entrada cero: ')
print('raices: ', gamma)
if escomplejo == 0:
    if repetidas>0:
        print('Raices repetidas: ', repetidas)
    print('Matriz: ')
    print(Ac)
    print('Ci:     ', ci)
    print('y0:')
    sym.pprint(y0)
if escomplejo > 0:
    print('raices complejas: ', escomplejo)
    print('magnitud:',g_magnitud)
    print('theta:',g_angulo)
    print('Matriz: ')
    print(Ac)
    print('Cj: ', cj)
    print('Ci: ',ci)
    print('y0: ')
    sym.pprint(y0)

# grafica datos
ki = np.arange(-m_q,muestras,1)
y0i = np.zeros(muestras+m_q)
# valores iniciales
y0i[0:m_q] = inicial[0:m_q]
# evaluación de y0[n]
y0n = sym.lambdify(n,y0)
y0i[m_q:] = y0n(ki[m_q:])

# grafica y[n] ante x[n]=0
plt.stem(ki,y0i)
plt.xlabel('ki')
plt.ylabel('y0[n]')
plt.title('y0[n]='+str(y0))
plt.grid()
plt.show()

Raíces: [reales No repetidas] [reales repetidas] [números complejos]

6.2 LTI DT – Respuesta entrada cero – concepto

Referencia: Lathi 3.6 p270

En el sistema LTID de la forma,

Q(E) y[n] = P(E) x[n]

la entrada cero implica x[n] =0, lo que cambia la expresión anterior a,

Q(E) y_0 [n] = 0

que lleva a resolver:

y_0[n+N] + a_1 y_0[n+N-1] + \text{...} + a_{N-1} y_0[n+1] + a_N y_0[n] = 0 (E^N + a_1 E^{N-1} + \text{...} + a_{N-1}E{n+1} + a_N) y_0[n] = 0

La ecuacion muestra que es una combinación lineal de y0[n] y un avance de y0[n] también es cero, siempre y cuando ambas expresiones tengan la misma forma. La función exponencial γn es la que tiene ésta propiedad,

E^k {\gamma ^n} = \gamma^{k+n} = \gamma^k \gamma^n

Raices reales no repetidas

Indica que γn avanzado por k unidades es varias veces una constante (γk). Por lo que la solución es de la forma y0[n] = cγn, de donde se deben encontrar los valores para c y γ.

Se reescribe la ecuación de diferencias con operadores E como y se busca una solución:

c(\gamma^N + a_1 \gamma^{N-1} + \text{...} + a_{N-1}\gamma{n+1} + a_N) \gamma^n = 0 \gamma^N + a_1 \gamma^{N-1} + \text{...} + a_{N-1}\gamma{n+1} + a_N = 0 (\gamma -\gamma_1)(\gamma -\gamma_2) \text{...}(\gamma -\gamma_N) = 0 y_0[n] = c_1 \gamma_1^n + c_2 \gamma_2^{n} + \text{...} + c_n \gamma_N^{n}

que se resuelve con las condiciones iniciales del problema, teniendo asi la ecuación característica, con valores característicos.

Raíces reales repetidas

Si no todas las raíces son diferentes, es decir algunas se repiten, la forma de los modos característicos se modifican. Por sustitución directa, siendo r el número de raíces repetidas, se tiene:

Q[\gamma] =(\gamma -\gamma_1)^r (\gamma -\gamma_{r+1}) (\gamma -\gamma_{r+2}) \text{...}(\gamma -\gamma_N) y_0[n] = (c_1+c_2 n +c_3 n^2 + \text{...} +c_r n^{r-1}) \gamma_1^n + c_{r+1} \gamma_{r+1}^{n} + + c_{r+2} \gamma_{r+2}^{n} + \text{...} + c_n \gamma_N^{n}

Raices complejas

Pueden darse el caso en forma de pares de conjugadas, si los coeficientes en la ecuación del sistema con números reales.

Una alternativa es usar la forma real de la solución, tal como se hace en sistemas contínuos.

Se expresan las raíces conjugadas complejas en su forma polar. Si la magnitud es |γ| y el ángulo es β, se tiene,

\gamma = |\gamma | e^{j \beta} \gamma^* = |\gamma | e^{-j \beta} y_0[n] = c_1 \gamma ^{n} + c_2 (\gamma^*)^n =c_1 |\gamma| ^{n} e^{j \beta n} + c_2 | \gamma |^n e^{-j \beta n} c_1 = \frac{c}{2} e^{j \theta} c_2 = \frac{c}{2} e^{-j \theta} y_0[n] = \frac{c}{2} |\gamma| ^{n} \Big[ e^{j (\beta n + \theta)}+ e^{-j (\beta n + \theta)} \Big] y_0[n] = c |\gamma| ^{n} \cos (\beta n + \theta)

donde c y θ son constantes determinadas con las condiciones iniciales. Esta solución es numérica real, evitando trabajar con números complejos

6.1.4 Sistema LTI DT – Solución iterativa con simulador Xcos

El ejercicio planteado en Sistema Discreto – Solución iterativa, se desarrolla con el simulador XCOS de Scilab.


Ejercicio 1

Referencia: Lathi ejemplo 3.11 p266

Un sistema LTID tiene la siguiente expresión:

y[n] - 0.5 y[n-1] = x[n]

con condiciones iniciales y[-1]=16 y entrada causal x[n] = n2 ,para n>=0.


El simulador requiere establecer una señal de tiempo para coordinar lo que sucede en cada bloque que depende del tiempo para generar una salida.

El contador requiere una señal de reloj para actualizar el valor de salida. El bloque de gráfica también se sincroniza con el reloj y el bloque de atraso también usa el reloj para determinar si usa los valores iniciales.

Las operaciones matemáticas como ganancia, suma y base a un exponente no usan reloj.

El parámetro de condicion inicial se configura en el bloque de retraso (1/z)

La señal de entrada requiere dos bloques: el contador y el bloque de base elevado a potencia.

El bloque del contador se configura considerando los tiempos de observación:

El bloque de potencia se configura el exponente,

Control de muestreo se realiza en el reloj, con periodo 1 e inicio en cero

El intervalo de muestreo se establece en las propiedades del osciloscopio de salida,

La gráfica de salida se obtiene con el botón de «PLAY» y se ajusta en el menu de «Edit/Axes properties» para presentar muestras con puntos de tamaño 6 y color rojo, sin lineas, con estilo de barra.

los datos de la gráfica se pueden observar en la viñeta «data»,

Se presenta el procedimiento en pasos básicos, luego se pueden añadir mas detalles.

 

6.1.3 Sistema LTI DT – Solución iterativa con Python

El ejercicio planteado en Sistema Discreto – Solución iterativa, se desarrolla con un algoritmo en Python.


Ejercicio 1

Referencia: Lathi ejemplo 3.11 p266

Un sistema LTID tiene la siguiente expresión:

y[n] - 0.5 y[n-1] = x[n]

con condiciones iniciales y[-1]=16 y entrada causal x[n] = n2 ,para n≥0.


El algoritmo tiene el siguiente resultado:

LTI DT Solución iterativaEj01

muestras:  10
[[  n,  xi,  yi]]
[[ -1.     0.    16.  ]
 [  0.     0.     8.  ]
 [  1.     1.     5.  ]
 [  2.     4.     6.5 ]
 [  3.     9.    12.25]
 [  4.    16.    22.12]
 [  5.    25.    36.06]
 [  6.    36.    54.03]
 [  7.    49.    76.02]
 [  8.    64.   102.01]
 [  9.    81.   132.  ]]
>>> 

Algoritmo en Python

Las condiciones iniciales se ingresan como un vector con valores de posición ascendente. También es necesario indicar el número de muestras a observar. esto permite construir el vector de salida yi.

Las fórmulas de entrada y salida se muestran en la sección «calcula los siguientes valores»

# Sistema LTID. Solución iterativa
# Ejercicio Lathi ejemplo 3.11 p266
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
muestras = 10
# condiciones iniciales ascendente ...,y[-2],y[-1]
y0  = [16.]

# PROCEDIMIENTO
m0 = len(y0)
m  = muestras + m0
# vectores
n  = np.arange(-m0,muestras,1)
xi = np.zeros(m, dtype=float)
yi = np.zeros(m, dtype=float)

# añade condiciones iniciales
xi[0:m0] = 0
yi[0:m0] = y0

# calcula los siguientes valores
for k in range(m0,m,1):
    xi[k] = n[k]**2
    yi[k] = 0.5*yi[k-1]+xi[k]

# tabla de valores
tabla = np.concatenate([[n],[xi],[yi]], axis=0)
tabla = np.transpose(tabla)
# SALIDA
np.set_printoptions(precision=2)
print('muestras: ', muestras)
print('[[  n,  xi,  yi]]')
print(tabla)

# Gráfica
plt.subplot(211)
plt.stem(n,xi,label='x[n]=n**2')
plt.xlabel('n')
plt.ylabel('x[n]')
plt.axvline(0,color='gray')
plt.legend()
plt.grid()

plt.subplot(212)
plt.stem(n,yi,label='y[n]=0.5y[n-1]+x[n]',
         markerfmt='go',
         linefmt='green')
plt.xlabel('n')
plt.ylabel('y[n]')
plt.axvline(0,color='gray')
plt.legend()
plt.grid()
plt.show()

Ejercicio 2

Se aplica el mismo algoritmo a otro ejercicio para comparar resultados con lo realizado en forma analítica.

Referencia: Lathi ejemplo 3.12 p267

Resolver de forma iterativa,

y[n+2] - y[n+1] +0.24y[n] = x[n+2] - 2x[n+1]

con las condiciones iniciales de y[-1] = 2, y[-2] =1 y entrada causal x[n]=n que inicia en n=0

Para usar la ecuación en el algoritmo, se desplaza dos posiciones en ambos lados de la ecuacion para despejar y[n]

y[n] - y[n-1] +0.24y[n-2] = x[n0] - 2x[n-1] y[n] = y[n-1] -0.24y[n-2] + x[n0] - 2x[n-1]

LTI DT Sol iterativa Ej02

muestras:  10
[[  n,  xi,  yi]]
[[ -2.     0.     1.  ]
 [ -1.     0.     2.  ]
 [  0.     0.     1.76]
 [  1.     1.     2.28]
 [  2.     2.     1.86]
 [  3.     3.     0.31]
 [  4.     4.    -2.14]
 [  5.     5.    -5.21]
 [  6.     6.    -8.7 ]
 [  7.     7.   -12.45]
 [  8.     8.   -16.36]
 [  9.     9.   -20.37]]
>>> 

Algoritmo en Python

# Sistema LTID. Solución iterativa
# Ejercicio Lathi ejemplo 3.12 p267
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
muestras = 10
# condiciones iniciales ascendente ...,y[-2],y[-1]
y0  = [1,2]

# PROCEDIMIENTO
m0 = len(y0)
m  = muestras + m0
# vectores
n  = np.arange(-m0,muestras,1)
xi = np.zeros(m, dtype=float)
yi = np.zeros(m, dtype=float)

# añade condiciones iniciales
xi[0:m0] = 0
yi[0:m0] = y0

# calcula los siguientes valores
for k in range(m0,m,1):
    xi[k] = n[k]
    yi[k] = yi[k-1]-0.24*yi[k-2]+xi[k]-2*xi[k-1]

# tabla de valores
tabla = np.concatenate([[n],[xi],[yi]], axis=0)
tabla = np.transpose(tabla)
# SALIDA
np.set_printoptions(precision=2)
print('muestras: ', muestras)
print('[[  n,  xi,  yi]]')
print(tabla)

# Gráfica
plt.subplot(211)
plt.stem(n,xi,label='x[n]=n')
plt.xlabel('n')
plt.ylabel('x[n]')
plt.axvline(0,color='gray')
plt.legend()
plt.grid()

plt.subplot(212)
plt.stem(n,yi,label='y[n]=yi[k-1]-0.24*yi[k-2]+xi[k]-2*xi[k-1]',
         markerfmt='go',
         linefmt='green')
plt.xlabel('n')
plt.ylabel('y[n]')
plt.axvline(0,color='gray')
plt.legend()
plt.grid()
plt.show()

6.1.2 Sistema LTI DT – Solución iterativa

Ejercicio 1

Referencia: Lathi ejemplo 3.11 p266

Un sistema LTID tiene la siguiente expresión:

y[n] - 0.5 y[n-1] = x[n]

con condiciones iniciales y[-1]=16 y entrada causal x[n] = n2 μ[n] ,para n>=0.

Desarrollo analítico

La expresión se reordena,

y[n] = 0.5 y[n-1] + x[n]

Para n=0, y la condición y[-1]=16

y[0] = 0.5 y[0-1] + x[0] = 0.5 y[-1] + 0^2 = 0.5(16) + 0 = 8

Para n=1,

y[1] = 0.5 y[1-1] + x[1] = 0.5 y[0] + 1^2 = 0.5(8) + 1 = 5

Para n=2,

y[2] = 0.5 y[2-1] + x[2] = 0.5 y[1] +2^2 = 6.5

Para n=3,

y[3] = 0.5 y[3-1] + x[3] = 0.5 y[2] + 3^2 = 0.5 (6.5) + 9 = 12.25

y así sucesivamente.

El algoritmo en Python presenta el resultado en forma gráfica y en forma de valores.

LTI DT Solución iterativaEj01

los resultados numéricos son:

muestras:  10
[[  n,  xi,  yi]]
[[ -1.     0.    16.  ]
 [  0.     0.     8.  ]
 [  1.     1.     5.  ]
 [  2.     4.     6.5 ]
 [  3.     9.    12.25]
 [  4.    16.    22.12]
 [  5.    25.    36.06]
 [  6.    36.    54.03]
 [  7.    49.    76.02]
 [  8.    64.   102.01]
 [  9.    81.   132.  ]]
>>>

El diagrama realizado para la ecuación tiene dos partes, el generador de señal en azul y la parte del sistema en color gris para el retrazo y naranja para el coeficiente de retrazo:


Ejercicio 2

Referencia: Lathi ejemplo 3.12 p267

Resolver de forma iterativa,

y[n+2] - y[n+1] +0.24y[n] = x[n+2] - 2x[n+1]

con las condiciones iniciales de y[-1] = 2, y[-2] =1 y entrada causal x[n]=n que inicia en n=0

Desarrollo

Se deja como tarea realizar la solución analítica con lapiz y papel, se continua con el uso del algoritmo para la solución.

Si la ecuación se reescribe de la forma:

y[n+2] = y[n+1] - 0.24y[n] + x[n+2] - 2x[n+1]

y se desplaza en el tiempo con retrasos, para adaptarla al algoritmo presentado en el ejemplo anterior.

y[n] = y[n-1] - 0.24y[n-2] + x[n] - 2x[n-1]

Las condiciones iniciales ordenadas son inicial= [1,2]

se emplea el mismo algoritmo, adaptando la fórmula par x[n] y y[n],teniendo los resultados siguientes:

muestras:  10
[[  n,  xi,  yi]]
[[ -2.     0.     1.  ]
 [ -1.     0.     2.  ]
 [  0.     0.     1.76]
 [  1.     1.     2.28]
 [  2.     2.     1.86]
 [  3.     3.     0.31]
 [  4.     4.    -2.14]
 [  5.     5.    -5.21]
 [  6.     6.    -8.7 ]
 [  7.     7.   -12.45]
 [  8.     8.   -16.36]
 [  9.     9.   -20.37]]
>>>

la gráfica correspondiente es:

LTI DT Sol iterativa Ej02

6.1.1 Sistemas LTI Discretos – Ecuaciones de diferencias y Operadores

Referencia: Lathi 3.5 p265, Lathi 3.5 p269

Los sistemas discretos LTID (linear time-invariant, discrete time systems) se analizan de forma semejante a los de tipo continuo, con algunas variantes.

Ecuaciones de Diferencias

Las ecuaciones de diferencia se pueden escribir de dos formas:

  • La primera usa términos con atrasos como y[n-1], y[n-2], x[n-1]…
  • La segunda con terminos de avance como son  y[n+1], y[n+2], x[n+1]…

La forma con atrasos es mas natural, mientras que ser prefieren las forma de avances por motivos de uniformidad con las operaciones de ecuaciones de diferencias.

Una ecuación de diferencias con operador de avances tiene la forma:

y[n+N] + a_1 y[n+N-1] + \text{...} + a_{N-1} y[n+1] + a_N y[n] = = b_{n-M} x[n+M] + b_{N-M+1} x[n+M-1] + \text{...} + + b_{N-1} x[n+1] + b_N x[n]

que es una ecuación de diferencias con orden de magnitud max(N,M). Se asume que el coeficiente de y[n+N] es 1, es decir a0=1, sin perder la generalidad, caso contrario se normaliza.

Notación de operadores E

Para simplificar la escritura en sistemas discretos, las ecuaciones de diferencias usan la notación E  para mostrar una operación de avance de una unidad. La notación de operadores es semejante a la usada en ecuaciones diferenciales que era D.

E x[n] = x[n+1] E^2 x[n] = x[n+2] E^N x[n] = x[n+N]

por lo que una ecuación de diferencias de primer orden se puede escribir como:

y[n+1] - a y[n] = x[n+1] E y[n] - a y[n] = E x[n] (E-a) y[n] = E x[n]

lo que refleja lo antes usado para el manejo de operadores:

Q(E) y[n] = P(E) x[n]

6.1 Sistemas LTI Discretos – Ejemplos y Diagramas de Bloques

Ejemplo 1 – Cuenta de ahorros

Referencia: Lathi ejemplo 3.6 p253, Oppenheim ejemplo 1.10 p40. Acumuladores en Fundamentos de programación

Una persona ahorradora realiza depósitos regularmente en el banco a un intervalo T mensual.  El banco paga intereses registrados en el estado de cuenta en el periodo T y lo envía al depositante.
Siendo:

x[n] depósito realizado en el instante n-ésimo
y[n] saldo de la cuenta al n-ésimo instante inmediato luego de recibir el n-ésimo depósito x[n]
r tasa de interés del periodo T

El saldo y[n] es la suma [i] del saldo anterior y[n-1], los intereses r sobre y[n-1] durante el periodo T y el depósito x[n]. El evento se puede registrar mediante la ecuación:

y[n] = y[n-1] + r y[n-1] + x[n]

reordenando la ecuación:

y[n] = (1+ r) y[n-1] + x[n] y[n] - (1+ r) y[n-1] = x[n]

por facilidad se simplifica, a = 1+r

la ecuación general se escribe como:

y[n] - a y[n-1] = x[n]

Para el caso presentado, la expresión podría escribirse también para manejar retiros de la cuenta si se cambia de signo al valor de x[n]. También debe considerar condiciones iniciales, por ejemplo al abrir la cuenta y[0] = M si es un depósito, o en otro caso Y[0] = -M por si lo que representa es un préstamo.

El índice de tiempo n es una variable arbitraria, se puede sustituir en la referencia por n+1

y[n+1] - a y[n] = x[n+1]

La expresión con n-1 usa un operación de retardo o retraso, mientras que n+1 usa una operación de avance o adelanto.

El operador de retraso n-1 es más natural, pues la operación es causal, realizable en el tiempo. La operación de adelanto n+1 es no causal, no realizable en tiempo. Por facilidad de operación matemática se usa el operador de adelanto.

Diagrama de bloques

Referencia: Oppenheim 2.4.3 p124.

Semejante a lo presentado en sistemas contínuos se tiene,

y[n] = a y[n-1] + x[n]

Aunque los primeros ejemplos dados son de claramente señales discretas en tiempo, las señales contínuas en tiempo pueden también ser procesadas por sistemas discretos usando muestreo. Los diagramas de bloques se elaboran usando Xcos de Scilab que es software abierto.


Ejemplo 2 – Estimación de ventas

Referencia: Lathi ejercicio 3.7 p255, Hsu 2.39 p100

Un vendedor de una editora de libros en un n-ésimo semestre con x[n] estudiantes registrados en un curso vende y[n] copias de un libro.

En promedio, la cuarta parte de los estudiantes al final del semestre revende el libro usado, el libro se mantiene en buenas condiciones por tres semestres.

Escriba la ecuación que relaciona los libros vendidos por la editora y[n], considerando el número de estudiantes registrados x[n] en el n-ésimo semestre, bajo el supuesto que todos los estudiantes compran el libro.

Durante el n-ésimo semestre, los x[n] estudiantes tienen libros compuestos por libros nuevos vendidos y[n] mas los libros de segunda mano de los dos semestres anteriores.

  • Del semestre inmediato anterior, la cuarta parte de los libros nuevos se revendieron, (1/4) y[n-1].
  • Lo mismo sucedió hace dos semestres (1/4) y[n-2] que se vendieron en el semestre anterior (n-1).
  • También 1/4 de los revendidos el semestre anterior, se vuelven a vender, llegando al ciclo final de vida del libro, es decir (1/4)(1/4 y[n-2]) = (1/16) y[n-2].

Siendo así, los x[n] estudiantes tienen libros provenientes de los libros nuevos y revendidos, expresados mediante:

y[n] + \frac{1}{4} y[n-1] + \frac{1}{16} y[n-2] = x[n]

por facilidad de operaciones matemáticas, se desplaza los índices a positivos,

y[n+2] + \frac{1}{4} y[n+1] + \frac{1}{16} y[n] = x[n+2] .

Para diagramar el sistema, se reordena la ecuación original como entrada-salida:

y[n]= -\frac{1}{4} y[n-1] -\frac{1}{16} y[n-2] + x[n]

Transformadas de Fourier – Tabla de Propiedades

Referencia: Schaum Hsu Tabla 5-1 p222. Lathi Tabla 7.2 p717, Oppenheim Tabla 4.1p328 pdf356

Transformada Fourier – Tabla

Series de Fourier de señales periódicas con Python

Operación x(t) X(ω)
x(t)
x1(t)
x2(t)
X(ω)
X1(ω)
X2(ω)
Multiplicación por escalar k x(t) k X(ω)
Aditiva x1(t) +x2(t) X1(ω) + X2(ω)
Linealidad a1 x1(t) + a2 x2(t) a1 X1(ω) + a2 X2(ω)
Conjugada x*(t) X*(-ω)
Inversión en tiempo x(-t) X(-ω)
Dualidad X(t) 2π x(-ω)
Escalamiento
(a Real)
x(at) \frac{1}{|a|} X \Big(\frac{\omega}{a} \Big)
Desplazamiento en tiempo (t Real) x(t-t0) X(ω) e-jωt0
Deplazamiento en frecuencia (ω0 Real) x(t)e0t X(ω-ω0)
Convolución en tiempo x_1(t) \circledast x_2 (t) X1(ω)X2(ω)
Convolución en frecuencia x1(t)x2(t) \frac{1}{2 \pi}X_1(\omega) \circledast X_2 (\omega)
Derivada en tiempo \frac{\delta^n}{\delta t^n}x(t) (jω)n X(ω)
Derivada en frecuencia (-jt)x(t) \frac{\delta}{\delta \omega}X(\omega)
Integral en tiempo \int_{- \infty}^{t}x(u) \delta u \frac{X(\omega)}{j \omega} + \pi X(0) \delta (\omega)
Señal Real x(t) = x_e(t) + x_o(t) X(\omega) = A(\omega)+jB(\omega)
componente par
componente impar
x_e(t)
x_o(t)
Re[X(\omega)] = A(\omega)
j Im[X(\omega)] = j B(\omega)

Relación de Parseval

\int_{-\infty}^{\infty} x_1 (\lambda) X_2 (\lambda) \delta \lambda = \int_{-\infty}^{\infty} X_1 (\lambda) x_2 (\lambda) \delta \lambda \int_{-\infty}^{\infty} x_1 (t) x_2 (t) \delta t = \frac{1}{2 \pi}\int_{-\infty}^{\infty} X_1 (\omega) X_2 (-\omega) \delta \omega \int_{-\infty}^{\infty} |x (t)|^2 \delta t = \frac{1}{2 \pi} \int_{-\infty}^{\infty} |X (\omega) |^2 \delta \omega

Transformada Fourier – Tabla

Series de Fourier de señales periódicas con Python