Autor: Edison Del Rosario

Ejercicio: 1Eva2016TII_T2 LTI CT bloques en paralelo-serie con Laplace ,  1Eva2012TII_T4 LTI CT bloques en paralelo-serie con Laplace, 1Eva2011TII_T3 LTI CT H(s) desde expresión con operadores D

Ejercicio resuelto: [ transformada de Laplace ] [integral convolución]

..

---

literal a. Funcion H(s) global

en el diagrama se muestran dos sistemas LTIC de primer orden, ambos sistemas se encuentran multiplicados por una constante y en paralelo.

La función de transferencia de un sistema LTIC de primer orden es
H(s) = 1/(s-a)

Con lo que el sistema se puede reescribir como:

H(s) = 3\frac{1}{s+7} + 12 \frac{1}{s-4}

Ceros y polos de H(s)

H(s) = \frac{3(s-4)+12(s+7)}{(s+7)(s-4)} = \frac{3s-12+12s+84}{(s+7)(s-4)} = \frac{15s+72}{(s+7)(s-4)}

los ceros se toman del numerador:

15s+72 = 0 s=\frac{-72}{15} = -\frac{24}{5}

los polos se toman del denominador:

(s+7)(s-4) = 0 s=-7 ; s= 4

literal b. La respuesta impulso h(t)

Los polos tienen signo diferente, lo que indica que el intervalo donde se encuentran incluyen al eje imaginario en el intervalo, por lo que el sistema es BIBO inestable. Por tener un polo a derecha del plano es asintoticamente inestable, su respuesta tiene componentes que crecen en el tiempo.

Como la región de convergencia ROC no se encuentra a la derecha de todos los polos, se tiene concluye que el sistema NO es causal.

h(t) = \mathscr{L}^{-1} [H(s)] = \mathscr{L}^{-1} \Big[ 3\frac{1}{s+7} + 12 \frac{1}{s-4}\Big] = \mathscr{L}^{-1} \Big[ 3\frac{1}{s+7} \Big] + \mathscr{L}^{-1} \Big[ 12 \frac{1}{s-4}\Big]

usando la tabla de transformadas o Sympy de Python

h(t) = 3e^{-7t} \mu (t) + 12 e^{4t} \mu (t)

literal c. Salida ante entrada x(t)

x(t) = e^{-5t} \mu (t)

X(s) = \frac{1}{s+5} Y(s) = X(s) H(s) =\frac{1}{s+5} \Bigg[\frac{15s+72}{(s+7)(s-4)}\Bigg] =\frac{15s+72}{(s+5)(s+7)(s-4)}

se usa fracciones parciales

=-\frac{3}{2(s+7)} + \frac{1}{6(s+5)}+\frac{4}{3(s-4)} y(t) = \mathscr{L}^{-1} [Y(s)] y(t) = \mathscr{L}^{-1} \Bigg[-\frac{3}{2(s+7)} + \frac{1}{6(s+5)}+\frac{4}{3(s-4)} \Bigg]

usando la tabla de transformadas de Laplace :

y(t) = -\frac{3}{2} e^{-7t} \mu (t) + \frac{1}{6}e^{-5t} \mu (t) +\frac{4}{3}e^{4t} \mu (-t)

---

Algoritmo en Python

realizado a partir de LTIC Laplace – Algoritmo Python para analizar estabilidad H(s), Y(s) con entrada cero, estado cero, condiciones iniciales

 H(s) = P(s)/Q(s):
  3       12 
----- + -----
s + 7   s - 4
 H(s) en factores:
  3*(5*s + 24) 
---------------
(s - 4)*(s + 7)

 h(t) :
/    4*t      -7*t\             
\12*e    + 3*e    /*Heaviside(t)

polosceros:
Q_polos : {4: 1, -7: 1}
P_ceros : {-24/5: 1}

Estabilidad de H(s):
 n_polos_real : 2
 n_polos_imag : 0
 enRHP : 1
 unicos : 0
 repetidos : 0
 asintota : inestable

 X(s): 
  1  
-----
s + 5

Respuesta entrada cero ZIR H(s) y condiciones iniciales
term_cero : 0
ZIR :
0
yt_ZIR :
0

 ZSR respuesta estado cero:
ZSR :
      3           1           4    
- --------- + --------- + ---------
  2*(s + 7)   6*(s + 5)   3*(s - 4)
yt_ZSR :
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /             

 Y(s)_total = ZIR + ZSR:
      3           1           4    
- --------- + --------- + ---------
  2*(s + 7)   6*(s + 5)   3*(s - 4)

 y(t)_total = ZIR + ZSR:
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /  

Instrucciones en Python

Usando los bloques desarrollados en la Unidad 4 Sistemas LTI – Laplace  y las funciones resumidas como telg1001.py que pueden ser usados en cada pregunta:

# Y(s) Respuesta total con entada cero y estado cero
# Qs Y(s) = Ps X(s) ; H(s)=Ps/Qs
# http://blog.espol.edu.ec/telg1001/
import sympy as sym
import matplotlib.pyplot as plt
import telg1001 as fcnm

# INGRESO
s = sym.Symbol('s')
t = sym.Symbol('t', real=True)
d = sym.DiracDelta(t)
u = sym.Heaviside(t)

# H(s) y estabilidad
Hs = 3/(s+7) + 12/(s-4)
#Hs = 1+0*s cuando es constante

# X(s) Señal de entrada
xt = sym.exp(-5*t)*u

# condiciones iniciales, [y'(0),y(0)] orden descendente
t0 = 0
cond_inicio = [0, 0] # estado cero no se usan

# Grafica, intervalo tiempo [t_a,t_b]
t_a = -0.2 ; t_b = 0.5
muestras = 101  # 51 resolucion grafica

# PROCEDIMIENTO
Hs = fcnm.apart_s(Hs) # fracciones parciales
Hs_fc = fcnm.factor_exp(Hs) # en factores
Hs_Qs2 = fcnm.Q_cuad_s_parametros(Hs_fc)

polosceros = fcnm.busca_polosceros(Hs)
Q_polos = polosceros['Q_polos']
P_ceros = polosceros['P_ceros']

estable = fcnm.estabilidad_asintotica_s(Q_polos)

# H(t) respuesta al impulso
ht = 0*s
term_suma = sym.Add.make_args(Hs)
for term_k in term_suma:
    ht_k = sym.inverse_laplace_transform(term_k,s,t)
    # simplifica log(exp()) ej: e**(-2s)/(s**2)
    if ht_k.has(sym.log):
        ht_k = sym.simplify(ht_k,inverse=True)
    ht  = ht + ht_k
lista_escalon = ht.atoms(sym.Heaviside)
ht = sym.expand(ht,t) # terminos suma
ht = sym.collect(ht,lista_escalon)

# PROCEDIMIENTO Respuesta ZIR, ZSR
Xs = fcnm.laplace_transform_suma(xt)

# ZIR_s respuesta entrada cero de s
sol_ZIR = fcnm.respuesta_ZIR_s(Hs,cond_inicio)
ZIR = sol_ZIR['ZIR']
yt_ZIR = sol_ZIR['yt_ZIR']

# ZSR respuesta estado cero, Y(s) a entrada X(s)
sol_ZSR = fcnm.respuesta_ZSR_s(Hs,Xs)
ZSR = sol_ZSR['ZSR']
yt_ZSR = sol_ZSR['yt_ZSR']

# Respuesta total Y(s) y y(t)
Ys = ZIR + ZSR
Ys = fcnm.apart_s(Ys)
yt = yt_ZIR + yt_ZSR
lista_escalon = yt.atoms(sym.Heaviside)
yt = sym.collect(yt,lista_escalon)

# SALIDA
print(' H(s) = P(s)/Q(s):')
sym.pprint(Hs)
print(' H(s) en factores:')
sym.pprint(Hs_fc)
if len(Hs_Qs2)>0:
    print('\nH(s) parámetros cuadraticos:')
    fcnm.print_resultado_dict(Hs_Qs2)

print('\n h(t) :')
sym.pprint(ht)

print('\npolosceros:')
fcnm.print_resultado_dict(polosceros)

print('\nEstabilidad de H(s):')
for k in estable:
    print('',k,':',estable[k])

print('\n X(s): ')
sym.pprint(Xs)
print('\nRespuesta entrada cero ZIR H(s) y condiciones iniciales')

if not(sol_ZIR == sym.nan): # existe resultado
    fcnm.print_resultado_dict(sol_ZIR)
else:
    print(' insuficientes condiciones iniciales')
    print(' revisar los valores de cond_inicio[]')

print('\n ZSR respuesta estado cero:')
fcnm.print_resultado_dict(sol_ZSR)

print('\n Y(s)_total = ZIR + ZSR:')
sym.pprint(Ys)
print('\n y(t)_total = ZIR + ZSR:')
sym.pprint(yt)

# Graficas polos, H(s), con polos h(t) --------
muestras_H = 201
figura_s  = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,f_nombre='H',solopolos=True)
figura_Hs = fcnm.graficar_Fs(Hs_fc,Q_polos,P_ceros,muestras=muestras_H,f_nombre='H')
figura_ht = fcnm.graficar_ft(ht,t_a,t_b,muestras,f_nombre='h')
# GRAFICAS y(t),x(t),h(t) ---------------------
figura_ft = fcnm.graficar_xh_y(xt,ht,yt,t_a,t_b,muestras)
plt.show()

Ejercicio resuelto: [ transformada de Laplace ] [integral convolución]
..

---

Ejercicio resuelto con integral de convolución, unidad 3

Algoritmo desarrollado con LTI CT Respuesta del Sistema Y(s)=ZIR+ZSR con Sympy-Python

 ZIR(t):
0

 h(t):
/    4*t      -7*t\             
\12*e    + 3*e    /*Heaviside(t)

 ZSR(t):
xh :
    4*t  -9*tau                                     
12*e   *e      *Heaviside(tau)*Heaviside(t - tau) + 

     -7*t  2*tau            
+ 3*e    *e     *Heaviside(tau)*Heaviside(t - tau)
xcausal : True
hcausal : True
[tau_a,tau_b] : [0, t]
intercambia : False
cond_graf : True
ZSR :
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /             

 y(t) = ZIR(t)+ZSR(t):
/   4*t    -5*t      -7*t\             
|4*e      e       3*e    |             
|------ + ----- - -------|*Heaviside(t)
\  3        6        2   /    

Las gráficas resultan iguales a las mostradas

Instrucciones con Python

# Respuesta total del sistema
# y(t) = ZIR(t) + ZSR(t)
# http://blog.espol.edu.ec/telg1001/lti-ct-yszirzsr-respuesta-del-sistema-con-sympy-python/
# Revisar causalidad de x(t) y h(t)
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                {'Heaviside': lambda x,y: np.heaviside(x, 1)},
                'numpy',]
import telg1001 as fcnm

# INGRESO
t = sym.Symbol('t',real=True)
tau = sym.Symbol('tau',real=True)
y = sym.Function('y')
x = sym.Function('x')
h = sym.Function('h')
u = sym.Heaviside(t)

# ecuacion: lado izquierdo = lado derecho
#           Left Hand Side = Right Hand Side
LHS = sym.diff(y(t),t,2) + 3*sym.diff(y(t),t,1) - 28*y(t)
RHS = 15*sym.diff(x(t),t,1,evaluate=False) + 72*x(t)
ecuacion = sym.Eq(LHS,RHS)

# condiciones iniciales [y'(t0),y(t0)]
t0 = 0
cond_inicio = [0,0]

# entrada x(t)
x = sym.exp(-5*t)*u

# grafica intervalo [t_a,t_b]
t_a = 0; t_b = .5
muestras = 201

# PROCEDIMIENTO
# Respuesta entrada cero ZIR
sol_ZIR = fcnm.respuesta_ZIR(ecuacion,cond_inicio,t0)
ZIR = sol_ZIR['ZIR']

# Respuesta al impulso h(t)
sol_h = fcnm.respuesta_impulso_h(ecuacion)
h = sol_h['h']

# respuesta a estado cero ZSR
sol_ZSR = fcnm.respuesta_ZSR(x,h)
ZSR = sol_ZSR['ZSR']
xh  = sol_ZSR['xh']

# respuesta a y(t) = ZIR(t)+ZSR(t)
y_total = ZIR+ZSR

# revisa si grafica ZSR
if not(sol_ZSR['cond_graf']):
    print('revisar acortar x(t) o h(t) para BIBO')
    
# SALIDA
print('\n ZIR(t):')
sym.pprint(ZIR)

print('\n h(t):')
sym.pprint(h)

print('\n ZSR(t):')
fcnm.print_resultado_dict(sol_ZSR)
if sol_ZSR['hcausal']==False:
    print('revisar causalidad de h(t)')
if sol_ZSR['xcausal']==False:
    print('revisar causalidad de x(t)')
if sol_ZSR['intercambia']:
    print('considere intercambiar h(t)con x(t)')
if not(sol_ZSR['cond_graf']):
    print('revisar acortar x(t) o h(t) para BIBO')

print('\n y(t) = ZIR(t)+ZSR(t):')
sym.pprint(y_total)

# GRAFICA
figura_ZIR = fcnm.graficar_ft(ZIR,t_a,t_b,
                              muestras,'ZIR')
figura_h   = fcnm.graficar_ft(h,t_a,t_b,
                              muestras,'h')
# grafica animada de convolución
n_archivo = '' # sin crear archivo gif animado 
#n_archivo = '1Eva2016TII_T2_ZSR' # requiere 'imagemagick'
if sol_ZSR['cond_graf']:
    fig_ZSR = fcnm.graficar_xh_y(x,h,ZSR,t_a,t_b,
                                 muestras,y_nombre='ZSR')
    fig_ytotal = fcnm.graficar_xhy(ZIR,ZSR,y_total,t_a,t_b,
                                   muestras,x_nombre='ZIR',
                                   h_nombre='ZSR',y_nombre='y')
    figura_animada = fcnm.graf_animada_xh_y(x,h,ZSR,-t_b,t_b,
                      muestras, reprod_x = 4,y_nombre='ZSR',
                      archivo_nombre = n_archivo)
plt.show()

Ejercicio: 1Eva2016TII_T1 LTI CT Sistema en paralelo-serie

a. respuestas impulso de los subsistemas SS1, SS2 y SS3

realizadas a partir de las respuestas de paso, x(t) = μ(t), entrada escalón unitario:

s_1(t) = r(t+1) - r(t-1) s_2(t) = s_3(t) = r(t-1) - r(t-2)

---

h_1 (t) = \frac{\delta}{\delta t} s_1(t) h_1 (t) = \frac{\delta}{\delta t} [ r(t+1) - r(t-1)] = \frac{\delta}{\delta t}[(t+1)\mu (t+1) - (t-1)\mu (t-1)] = (1) \mu (t+1) +(t+1) \delta(t+1) -[ (1)\mu (t-1) + (t-1)\delta(t-1)] = \mu (t+1) +0 -[ (1)\mu (t-1) + 0] = \mu (t+1) - \mu (t-1)

---

h_2 (t) = \frac{\delta}{\delta t} s_2(t) h_2 (t) = \frac{\delta}{\delta t} [(t-1) \mu (t-1) - (t-2) \mu (t-2)

siguiendo el desarrollo para h₁(t)

h_2 (t) = \mu (t-1) - \mu (t-2)

por lo que también:

h_3 (t) = h_2 (t) =\mu (t-1) - \mu (t-2)

respuesta con el algoritmo:

 literal a: Respuestas de paso
s1:  -(t - 1)*Heaviside(t - 1) + (t + 1)*Heaviside(t + 1)
s2:  -(t - 2)*Heaviside(t - 2) + (t - 1)*Heaviside(t - 1)
s3:  -(t - 2)*Heaviside(t - 2) + (t - 1)*Heaviside(t - 1)
 literal a: Respuestas impulso
h1:  -(t - 1)*DiracDelta(t - 1) + (t + 1)*DiracDelta(t + 1)
     - Heaviside(t - 1) + Heaviside(t + 1)
h2:  -(t - 2)*DiracDelta(t - 2) + (t - 1)*DiracDelta(t - 1)
     - Heaviside(t - 2) + Heaviside(t - 1)
h3:  -(t - 2)*DiracDelta(t - 2) + (t - 1)*DiracDelta(t - 1)
     - Heaviside(t - 2) + Heaviside(t - 1)

Instrucciones en Python

# 1Eva2016TII_T1 Sistema LTIC en paralelo-serie
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                {'Heaviside': lambda x,y: np.heaviside(x, 1)},
                'numpy',]
# INGRESO
t = sym.Symbol('t', real=True)
u = sym.Heaviside(t) 
r = t*u

# literal a, repuesta de paso
s1 = r.subs(t,t+1) - r.subs(t,t-1)
s2 = r.subs(t,t-1) - r.subs(t,t-2)
s3 = r.subs(t,t-1) - r.subs(t,t-2)

t_a = -2 ; t_b = 3

# PROCEDIMIENTO
muestras = (t_b-t_a)*(20+1)
ti = np.linspace(t_a,t_b,muestras)
s1n = sym.lambdify(t,s1, modules=equivalentes)
s2n = sym.lambdify(t,s2, modules=equivalentes)
s1i = s1n(ti)
s2i = s2n(ti)

# literal a, respuesta impulso
h1 = sym.diff(s1,t,1)
h2 = sym.diff(s2,t,1)
h3 = sym.diff(s3,t,1)

h1n = sym.lambdify(t,h1, modules=equivalentes)
h2n = sym.lambdify(t,h2, modules=equivalentes)
h3n = sym.lambdify(t,h3, modules=equivalentes)
h1i = h1n(ti)
h2i = h2n(ti)
h3i = h3n(ti)

# SALIDA
print(' literal a: Respuestas de paso')
print('s1: ',s1)
print('s2: ',s2)
print('s3: ',s3)
print(' literal a: Respuestas impulso')
print('h1: ',h1)
print('h2: ',h2)
print('h3: ',h3)

# Gráfica
plt.subplot(211)
plt.plot(ti,s1i,label ='s1(t)')
plt.plot(ti,s2i,label ='s2(t), s3(t)')
plt.axvline(0, linestyle='dashed',color='grey')
plt.legend()
plt.grid()

plt.subplot(212)
plt.plot(ti,h1i,label ='h1(t)')
plt.plot(ti,h2i,label ='h2(t), h3(t)')
plt.axvline(0, linestyle='dashed',color='grey')
plt.ylabel('Respuesta impulso')
plt.xlabel('t')
plt.legend()
plt.grid()
plt.show()

---

b. respuestas impulso h₁₂(t) y respuesta de paso (escalón unitario) s₁₂(t)

los sistemas SS1 y SS2 se encuentran con un operador suma en paralelo ,restando SS2, por lo que las respuestas al impulso son:

h_{12} (t) = h_1 (t) - h_2 (t) = [\mu (t+1) - \mu (t-1)] - [\mu (t-1) - \mu (t-2)] = \mu (t+1) - 2 \mu (t-1) + \mu (t-2)

la «respuesta de paso» se encuentran como:

s_{12} (t) = \int_{-\infty}^{\infty} h_{12}(t) \delta t = h_{12} (t) \circledast \mu (t) s_{12} (t) = [\mu (t+1) - 2 \mu (t-1) - \mu (t-2)] \circledast \mu (t)

Usando la tabla de integrales de convolución, fila 3:

s_{12} (t) = r(t+1) -2 r(t-1) + r(t-2)

---

c. respuesta impulso del sistema global  h₁₂₃(t)

A partir de h₁₂(t) y h₃(t), que se encuentran en serie (cascada), se tiene que:

h_{123} (t) = h_{12} (t) \circledast h_3 (t) \frac{\delta}{\delta t}h_{123} (t) = \frac{\delta}{\delta t}[h_{12} (t) \circledast h_3 (t)] = \frac{\delta}{\delta t}h_{12} (t) \circledast h_3 (t) = h_{12} (t) \circledast \frac{\delta}{\delta t}h_3 (t)

usando la primera expresión equivalente de la convolución:

\frac{\delta}{\delta t}h_{12} (t) = \frac{\delta}{\delta t}[\mu (t+1) - 2 \mu (t-1) + \mu (t-2)] = \delta (t+1) - 2 \delta (t-1) + \delta (t-2)

por lo que

\frac{\delta}{\delta t}h_{123} (t) = [\delta (t+1) - 2 \delta (t-1) + \delta (t-2)] \circledast h_3 (t) = \delta (t+1) \circledast h_3 (t) - 2 \delta (t-1) \circledast h_3 (t) + \delta (t-2) \circledast h_3 (t)

Usando la tabla de integrales de convolución, fila 1:

= h_3 (t+1) - 2 h_3 (t-1) + h_3 (t-2)

y sustituyendo las expresiones con los deplazamientos en t,

= [\mu ((t+1)-1) - \mu ((t+1)-2)] -2[\mu ((t-1)-1) - \mu ((t-1)-2)] + [\mu ((t-2)-1) - \mu ((t-2)-2)]

realizado las operaciones en los paréntesis,

= \mu (t) - \mu (t-1) - 2\mu (t-2) + 2\mu (t-3) + \mu (t-3) - \mu (t-4)

uniendo términos iguales, se simplifica,

\frac{\delta}{\delta t} h_{123} (t) = \mu (t) - \mu (t-1)- 2\mu (t-2) + 3\mu (t-3) - \mu (t-4)

ahora se puede calcular h₁₂₃(t) como

h_{123} (t) =\frac{\delta}{\delta t} h_{123} (t) \circledast \mu (t) = [\mu (t) - \mu (t-1)- 2\mu (t-2) + 3\mu (t-3) - \mu (t-4)] \circledast \mu (t) = \mu (t)\circledast \mu (t) - \mu (t-1)\circledast \mu (t) -2\mu (t-2)\circledast \mu (t)+ + 3\mu (t-3)\circledast \mu (t) - \mu (t-4) \circledast \mu (t)

Usando la tabla de integral de convolución, fila 3:

h_{123} (t) = r(t) - r(t-1) -2 r(t-2)+ 3 r(t-3) - r(t-4)

también se puede escribir en función de μ(t)

h_{123} (t) = t \mu(t) - (t-1) \mu (t-1) -2 (t-2) \mu(t-2)+ +3 (t-3) \mu(t-3) - (t-4)\mu(t-4)

Con lo que se que se obtiene la gráfica de las funciones requeridas en el literal b.

el resultado del algoritmo es:

literal b. h123(t)
h12:  (t - 2)*DiracDelta(t - 2) - 2*(t - 1)*DiracDelta(t - 1)
    + (t + 1)*DiracDelta(t + 1) + Heaviside(t - 2)
    - 2*Heaviside(t - 1) + Heaviside(t + 1)
h123:  t*Heaviside(t) - (t - 4)*Heaviside(t - 4) 
     + 3*(t - 3)*Heaviside(t - 3) -2*(t - 2)*Heaviside(t - 2)
     - (t - 1)*Heaviside(t - 1)

las instrucciones adicionales en Python son:

t_a = -2 ; t_b = 5
# PROCEDIMIENTO
muestras = (t_b-t_a)*(20+1)
ti = np.linspace(t_a,t_b,muestras)

# b. respuesta impulso y paso del sistema 12 en paralelo
h12  = h1 - h2
h12n = sym.lambdify(t,h12, modules=equivalentes)
h12i = h12n(ti)

# respuesta impulso global sistema 123
h123  = r-r.subs(t,t-1)-2*r.subs(t,t-2)
h123  = h123 + 3*r.subs(t,t-3)-r.subs(t,t-4)
h123n = sym.lambdify(t,h123, modules=equivalentes)
h123i = h123n(ti)

# SALIDA
print('\nliteral b. h123(t)')
print('h12: ', h12)
print('h123: ',h123)

# Grafica
plt.plot(ti,h12i,label ='h12(t)')
plt.axvline(0, linestyle='dashed'
            ,color='grey')
plt.plot(ti,h123i,label ='h123(t)')
plt.ylabel('Respuesta impulso')
plt.xlabel('t')
plt.legend()
plt.grid()

plt.show()

---

litera b. Tabla de respuestas

Subsistema LTIC SS1

• h₁(t) no tiene la forma kδ(T), por lo que SSI es con memoria.
• h₁(t) ≠ 0, t<0, el sistema no es causal.
• La respuesta al impulso es absolutamente integrable, por lo que es BIBO estable

Subsistema LTIC SS2 y SS3

• h₂(t) y h₂(t) no tienen la forma kδ(T), por lo que SS2 y SS3 tienen memoria.
• h₂(t) = h₃(t) = 0, t<0, los sistemas SS2 y SS3 son causales.
• La respuesta al impulso es absolutamente integrable, por lo que SS2 y SS3 son BIBO estables

Subsistema LTIC en paralelo SS1-SS2

• h₁₂(t) no tiene la forma kδ(T), por lo que SS1-SS2 en paralelo es con memoria.
• h₁₂(t) ≠ 0 t<0, el sistema en paralelo SS1-SS2 no es causal.
• La respuesta al impulso es absolutamente integrable, por lo que el sistema en paralelo SS1-SS2 es BIBO estable

Subsistema LTIC global SS1-SS2-SS3

• h₁₂₃(t) no tiene la forma kδ(T), por lo que el sistema global es con memoria.
• h₁₂(t) = 0 t<0, el sistema global es causal.
• La respuesta al impulso es absolutamente integrable, por lo que el sistema global es BIBO estable
  

  ---

  literal d. salida w(t)

La combinación en paralelo del sistema SS1 y SS2 a partir de la entrada x(t) dada es:

w(t) = x(t) \circledast h_{12} (t) = h_{12} (t) \circledast x(t) w(t) = h_{12} (t) \circledast \sum_{k=-\infty}^{\infty} \delta (t-4k) = \sum_{k=-\infty}^{\infty} [h_{12} (t) \circledast\delta (t-4k)] = \sum_{k=-\infty}^{\infty} h_{12} (t-4k)

que es una función periódica con T_k = 4.

Por ser una señal periódica, la potencia y energía se determinan en un periodo:

E_{w(t)} = \int_{-1}^{3} |w(t)|^2 \delta t = \int_{-1}^{1} |1|^2 \delta t + \int_{1}^{2} |-1|^2 \delta t + \int_{2}^{3} |0|^2 \delta t = \int_{-1}^{1} (1) \delta t + \int_{1}^{2} (1) \delta t = t \bigg|_{-1}^{1} + t \bigg|_{1}^{2} =2+1 =3 E_{w(t)} = 3 P_{w(t)} = \frac{E_{w(t)}}{T_0} = \frac{3}{4}

---

literal e. salida y(t) sistema global

y(t) = x(t) \circledast h_{123} (t) = h_{123} (t) \circledast x(t) = h_{123} (t) \circledast \sum_{k=-\infty}^{\infty} \delta (t-4k) = \sum_{k=-\infty}^{\infty} [h_{123} (t) \circledast \delta (t-4k)] y(t) = \sum_{k=-\infty}^{\infty} h_{123}(t-4k)

siendo una respuesta de tipo periódica con T₀ = 4, por lo que la potencia y energía se determinan en un periodo,

E_{y(t)} = \int_{0}^{4} |y(t)|^2 \delta t = \int_{0}^{1} |t|^2 \delta t + \int_{1}^{2} |1|^2 \delta t +\int_{2}^{3} |5-2t|^2 \delta t + \int_{3}^{4} |t-4|^2 \delta t = \frac{t^3}{3} \Big|_0^1 + t\Big|_1^2 + \int_{2}^{3}(25-20t+4t^2) \delta t+ \int_{3}^{4} |t^2-8t+16| \delta t = (0+\frac{1}{3}) + (2-1) + [25t-10t^2+\frac{4}{3}t^3] \Big|_2^3 + [\frac{t^3}{3}-4[t^2]+16t] \Big|_3^4 = \frac{1}{3} + 1 + \Big[\big(25(3)-10(3)^2+\frac{4}{3}(3)^3\big) -\big(25(2)-10(2)^2+\frac{4}{3}(2)^3\big)\Big] + + \Big[\big(\frac{4^3}{3}-4[4^2]+16(4)\big) - \big(\frac{3^3}{3}-4[3^2]+16(3) \big)\Big] = \frac{4}{3} + \Big[\big(75-90+36\big) -\big(50-40+\frac{32}{3}\big)\Big] + + \Big[\big(\frac{64}{3}-64 +64\big) - \big(9-36+48 \big)\Big] = \frac{4}{3} + \frac{2}{3} = \frac{6}{3} = 2 E_{y(t)} = 2 P_{y(t)} =\frac{E_{y(t)}}{T_0} = \frac{2}{4} = \frac{1}{2}