{"id":4688,"date":"2017-04-19T12:10:52","date_gmt":"2017-04-19T17:10:52","guid":{"rendered":"http:\/\/blog.espol.edu.ec\/telg1001\/?p=4688"},"modified":"2026-04-06T10:17:23","modified_gmt":"2026-04-06T15:17:23","slug":"simplifica-multiplicacion-impulso-o-escalon-unitario-sympy","status":"publish","type":"post","link":"https:\/\/blog.espol.edu.ec\/algoritmos101\/ss-u03\/simplifica-multiplicacion-impulso-o-escalon-unitario-sympy\/","title":{"rendered":"3.7 Simplifica multiplicaci\u00f3n entre impulso \u03b4(t) o escal\u00f3n unitario \u03bc(t) con Sympy"},"content":{"rendered":"\n

La multiplicaci\u00f3n entre impulso \u03b4(t) o escal\u00f3n unitario \u03bc(t) aparece al desarrollar en integral de convoluci\u00f3n cuando ambas se\u00f1ales son de tipo causal.<\/p>\n\n\n x(t) \\circledast h(t) = \\int_{-\\infty}^{+\\infty} x(\\tau)h(t-\\tau) \\delta \\tau <\/span>\n\n\n\n

Las expresiones resultantes pueden incluir algunas de \u00e9stas operaciones como se muestra en el ejemplo 3 de una convoluci\u00f3n entre se\u00f1ales tipo rectangular y rampa de car\u00e1cter causal.<\/p>\n\n\n x(t) = \\mu (t) - \\mu (t-1)<\/span>\n\n\n h(t) = t\\mu (t) - t\\mu (t-2)<\/span>\n\n\n\n

Con respuestas al usar el algoritmo con Sympy que integran varias multiplicaciones de escal\u00f3n unitario.<\/p>\n\n\n\n

Como Sympy '1,11,1' revisada en Enero del 2023, a\u00fan no incluye este tipo de operaciones, se realizan dos funciones:  simplifica_impulso() y simplifica_escalon(). Se desarrolla como un ejercicio de an\u00e1lisis de expresiones con Sympy.<\/p>\n\n\n\n

>>> sym.__version__\n'1.11.1'<\/code><\/pre>\n\n\n\n
Simplificar multiplicaci\u00f3n de impulso unitario \u03b4(t)<\/h2>\n\n\n\n
Las operaciones encontradas en los ejercicios del curso dan una idea b\u00e1sica de por d\u00f3nde empezar. Tambi\u00e9n se prob\u00f3 las instrucciones doit(), evalf() sin cambios.<\/p>\n\n\n\n
>>> sym.DiracDelta(t)*sym.DiracDelta(t-1)\nDiracDelta(t)*DiracDelta(t - 1)\n>>> sym.simplify(sym.DiracDelta(t)*sym.DiracDelta(t-1))\nDiracDelta(t)*DiracDelta(t - 1)\n>>> sym.DiracDelta(t)**2\nDiracDelta(t)**2\n>>> sym.simplify(sym.DiracDelta(t)**2)\nDiracDelta(t)**2\n>>><\/code><\/pre>\n\n\n\n
Como punto de partida de plantea encontrar todos los puntos de la expresi\u00f3n donde intervienen los impulsos. La funci\u00f3n busca_impulso() permite revisar si existiendo impulsos en diferentes tiempos, el resultado deber\u00e1 ser cero.<\/p>\n\n\n\n
x = d\nh = d.subs(t,t-1)\n\nxh = x*h<\/code><\/pre>\n\n\n\n
Para facilitar el an\u00e1lisis se realizan las gr\u00e1ficas de las dos funcines que se multiplican y la operaci\u00f3n resultante del algoritmo:<\/p>\n\n\n\n
\"simplifica<\/figure>\n\n\n\n
otro caso a considerar es:<\/p>\n\n\n\n
x = sym.sin(t)\nh = d.subs(t,t-2)\n\nxh = x*h<\/code><\/pre>\n\n\n\n
\"simplifica<\/figure>\n\n\n\n
Algoritmo en Python<\/p>\n\n\n\n
El algoritmo se desarrolla como funciones, para ser incorporadas a telg1001.py<\/p>\n\n\n
\n# Simplificar multiplicacion de impulso unitario d(t)*d(t-1)\n# https:\/\/blog.espol.edu.ec\/algoritmos101\/senales\/ss-unidades\/#unidad3\nimport numpy as np\nimport sympy as sym\nimport matplotlib.pyplot as plt\nimport telg1001 as ss\nequivalentes = [{'DiracDelta': lambda x: 1*(x==0)},\n                {'Heaviside': lambda x,y: np.heaviside(x, 1)},\n                'numpy',]\n\n# INGRESO\nt = sym.Symbol('t',real=True)\ntau = sym.Symbol('tau',real=True)\nu = sym.Heaviside(t)\nd = sym.DiracDelta(t)\n\n# entrada x(t), respuesta impulso h(t)\n# x = d\n# h = d.subs(t,t-1)\n# h = d # h= d**2\n\n# x = 2\n# h = d\n# h = sym.pi*d.subs(t,t-2)\n\nx = sym.sin(t)\nh = d.subs(t,t-2)\n# h = 5*d.subs(t,t-2)**2\n\n# x = d.subs(t,t-1)\n# h = u.subs(t,t-1)\n# h = d*u.subs(t,t-2)+ u*u.subs(t,t-2)\n# h = d*d.subs(t,t-1)*u.subs(t,t+2)+3\n\n# grafica intervalo [t_a,t_b] plano sim\u00e9trico\nt_b = 4 ; t_a = -t_b\nmuestras = 81\n\n# PROCEDIMIENTO\ndef simplifica_impulso(ft):\n    ''' simplifica d**2, d(t-1)*d\n    '''\n    def simplifica_d_d(ft):\n        '''un termino de suma  d**2, d(t+1)*d,\n        '''\n        respuesta = ft\n        if ft.has(sym.DiracDelta):# tiene impulsos\n            impulso_en = ss.busca_impulso(ft)\n            if len(impulso_en)==0: # anulado por d(t-a)*d(t-b)\n               respuesta = 0*t\n            elif len(impulso_en)>0: # tiene impulsos\n                respuesta = 1\n                factor_mul = sym.Mul.make_args(ft)\n                for factor_k in factor_mul:\n                    if not(factor_k.has(sym.DiracDelta)):\n                        if not(factor_k.has(sym.Heaviside)):\n                            termino = factor_k.subs(t,impulso_en[0])\n                        else: # tiene escal\u00f3n\n                            termino = factor_k.subs(t,impulso_en[0])\n                            if termino == 1\/2: #coinciden d,u\n                                termino = 1\n                        respuesta = respuesta*termino\n                    else:  # factor con impulso\n                        if factor_k.is_Pow: # tiene exponente\n                            respuesta = respuesta*factor_k.args[0]\n                        else: # termino sin exponente\n                            respuesta = respuesta*factor_k\n        return(respuesta)\n    \n    # revisa terminos suma\n    respuesta = 0*t\n    ft = sym.expand(ft,t)\n    term_suma = sym.Add.make_args(ft)\n    for term_k in term_suma:\n        respuesta = respuesta + simplifica_d_d(term_k)\n        \n    return(respuesta)\n\nxh = x*h\nft = simplifica_impulso(xh)\n\n# SALIDA\nprint('xh inicial:')\nsym.pprint(xh)\nprint('h simplificado:')\nsym.pprint(ft)\n\n# grafica\nfigura = ss.graficar_xh_y(x,h,ft,t_a,t_b,muestras,y_nombre='xh')\nplt.show()\n<\/pre><\/div>\n\n\n
\n\n\n\n
Simplificar multiplicaci\u00f3n de escal\u00f3n unitario \u03bc(t)<\/h2>\n\n\n\n
Las operaciones encontradas en los ejercicios del curso dan una idea b\u00e1sica de por d\u00f3nde empezar<\/p>\n\n\n\n
>>> sym.Heaviside(t)*sym.Heaviside(t-1)\nHeaviside(t)*Heaviside(t - 1)\n>>> sym.simplify(sym.Heaviside(t)*sym.Heaviside(t-1))\nHeaviside(t)*Heaviside(t - 1)\n>>> sym.simplify(sym.Heaviside(-t+1)*sym.Heaviside(t-1))\nHeaviside(1 - t)*Heaviside(t - 1)\n>>> sym.simplify(sym.Heaviside(t)**2)\nHeaviside(t)**2\n>>> sym.simplify(sym.DiracDelta(t-1)*sym.Heaviside(t))\nDiracDelta(t - 1)*Heaviside(t)\n>>><\/code><\/pre>\n\n\n\n
Como punto de partida de plantea encontrar todos los puntos de la expresi\u00f3n donde intervienen el escal\u00f3n unitario. La funci\u00f3n busca_escalon() permite revisar la ubicaci\u00f3n y el sentido de desarrollo de cada escal\u00f3n unitario, con estos datos se puede determinar si la funci\u00f3n se anula con la otra o la parte que permanece.<\/p>\n\n\n\n
x = u\nh = u.subs(t,t-1)\n\nxh = x*h<\/code><\/pre>\n\n\n\n
Con una gr\u00e1fica se puede comprobar el escal\u00f3n que se superpone en la multiplicaci\u00f3n de x(t)h(t).<\/p>\n\n\n\n
\"simplifica<\/figure>\n\n\n\n
otro ejercicio a considerar es cuando los escalones unitarios se pueden complementar o anular. En el siguiente ejemplo x(t) h(t) se anulan entre si.<\/p>\n\n\n\n
x = u.subs(t,t-1)\nh = u.subs(t,-t-1)\n\nxh = x*h<\/code><\/pre>\n\n\n\n
\"simplifica<\/figure>\n\n\n\n
mientras en en otro caso, las se\u00f1ales tienen una regi\u00f3n donde pueden coexistir<\/p>\n\n\n\n
x = u.subs(t,-t+1)\nh = u.subs(t,t-0)<\/code><\/pre>\n\n\n\n
\"simplifica<\/figure>\n\n\n\n
Algoritmo en Python<\/h3>\n\n\n
\n# Simplificar multiplicacion de escalon unitario u(t)*u(t-1)\n# https:\/\/blog.espol.edu.ec\/algoritmos101\/senales\/ss-unidades\/#unidad3\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sym\nequivalentes = [{'DiracDelta': lambda x: 1*(x==0)},\n                {'Heaviside': lambda x,y: np.heaviside(x, 1)},\n                'numpy',]\nimport telg1001 as ss\n\n# INGRESO\nt = sym.Symbol('t',real=True)\nu = sym.Heaviside(t)\nd = sym.DiracDelta(t)\n\n# entrada x(t), respuesta impulso h(t)\n# x = u\n# h = u.subs(t,t-1)\n\n# x = u.subs(t,t-1)\n# h = u.subs(t,-t-1)\n\nx = u.subs(t,-t+1)\nh = u.subs(t,t-0)\n\n#x = 3*u.subs(t,-t+2)\n#h = 2*u.subs(t,-t+3)\n\n# x = u.subs(t,t+1)*u.subs(t,-t+2)\n# h = 1\n# h = d.subs(t,-t+2)#*u.subs(t,t-3)\n\n\n# grafica intervalo [t_a,t_b] plano sim\u00e9trico\nt_b = 4 ; t_a = -t_b\nmuestras = 301\n\n# PROCEDIMIENTO\ndef simplifica_escalon(ft):\n    ''' simplifica multiplicaciones\n        Heaviside(t-a)*Heaviside(t-b) en f(t)\n    '''\n    def simplifica_u_u(ft):\n        '''solo dos pares de u(t-1)*u(t-2),\n           sin coeficientes\n        '''\n        donde_u = ss.busca_escalon(ft)\n        donde_u = np.array(donde_u)\n        # direccion donde_[:,1],\n        # lugar donde[:,0]\n        # analiza multiplicaci\u00f3n\n        resultado = ft   # todo igual\n        if donde_u[0,1]*donde_u[1,1] > 0: # direccion igual\n            k = 0\n            if donde_u[0,1]>0: # hacia derecha\n                k = np.argmax(donde_u[:,0])\n                k_signo = 1\n            else: # hacia izquierda\n                k = np.argmin(donde_u[:,0])\n                k_signo = -1\n            ubica = donde_u[k,1]*t-k_signo*donde_u[k][0]\n            resultado = sym.Heaviside(ubica)\n        else: # direccion diferente\n            if donde_u[0][1]>0 and (donde_u[0,0]>donde_u[1,0]):\n                    resultado = 0\n            if donde_u[0][1]<0 and (donde_u[0,0]<=donde_u[1,0]):\n                    resultado = 0\n        return(resultado)\n\n    def simplifica_u_term(ft):\n        ''' simplifica un termino de varios\n            factores que multiplican 2*pi*u*u(t-1)\n        '''\n        respuesta = ft\n        if ft.has(sym.Heaviside): # tiene escalon\n            escalon_en = ss.busca_escalon(ft)\n            revisa = 1 ; otros = 1 ; cuenta = 0\n            factor_mul = sym.Mul.make_args(ft)\n            for factor_k in factor_mul:\n                if factor_k.has(sym.Heaviside):\n                    if factor_k.is_Pow: # con exponente\n                        revisa = revisa*factor_k.args[0]\n                        cuenta = cuenta + 1\n                    else: # sin exponente\n                        revisa = revisa*factor_k\n                        cuenta = cuenta + 1\n                    if cuenta>1: # simplificar\n                        revisa = simplifica_u_u(revisa)\n                        cuenta = len(ss.busca_escalon(revisa))\n                else: # factor sin Heaviside\n                    otros = otros*factor_k\n            respuesta = otros*revisa\n        return(respuesta)\n\n    # revisa terminos suma\n    respuesta = 0*t\n    ft = sym.expand(ft,t)\n    if ft.has(sym.DiracDelta): # tiene impulsos\n        ft = ss.simplifica_impulso(ft)\n    term_suma = sym.Add.make_args(ft)\n    for term_k in term_suma:\n        respuesta = respuesta + simplifica_u_term(term_k)\n\n    return(respuesta)\n\nxh = x*h\nft = simplifica_escalon(xh)\n\n# SALIDA\nprint('busca_impulso(ft)', ss.busca_impulso(h))\nprint('busca_escalon(ft)', ss.busca_escalon(h))\nprint('x*h inicial:')\nsym.pprint(xh)\nprint('simplificado:')\nsym.pprint(ft)\n\n# grafica\nfigura = ss.graficar_xh_y(x,h,ft,t_a,t_b,y_nombre='xh')\nplt.show()\n<\/pre><\/div>\n\n\n
..<\/p>\n","protected":false},"excerpt":{"rendered":"
La multiplicaci\u00f3n entre impulso \u03b4(t) o escal\u00f3n unitario \u03bc(t) aparece al desarrollar en integral de convoluci\u00f3n cuando ambas se\u00f1ales son de tipo causal. Las expresiones resultantes pueden incluir algunas de \u00e9stas operaciones como se muestra en el ejemplo 3 de una convoluci\u00f3n entre se\u00f1ales tipo rectangular y rampa de car\u00e1cter causal. Con respuestas al usar […]<\/p>\n","protected":false},"author":8043,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"wp-custom-template-entrada-ss-unidades","format":"standard","meta":{"footnotes":""},"categories":[171],"tags":[],"class_list":["post-4688","post","type-post","status-publish","format-standard","hentry","category-ss-u03"],"_links":{"self":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/4688","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/users\/8043"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/comments?post=4688"}],"version-history":[{"count":4,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/4688\/revisions"}],"predecessor-version":[{"id":24087,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/4688\/revisions\/24087"}],"wp:attachment":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/media?parent=4688"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/categories?post=4688"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/tags?post=4688"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}