Categoría: Unidades

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)

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 y₀[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 γ₁=-0.2 y γ₂=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 c₁ y c₂ 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: c₁ = 0.2 c₂ = 0.8

con lo que la solución tiene la expresión basado en la sumatoria de c_i ϒⁿ, 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 y₀[-1]=2 y y₀[-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 y₀[-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 y₀[-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]

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] = n² ,para n≥0.

El algoritmo tiene el siguiente resultado:

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]$

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()