{"id":5258,"date":"2017-08-17T17:17:52","date_gmt":"2017-08-17T22:17:52","guid":{"rendered":"http:\/\/blog.espol.edu.ec\/telg1001\/?p=5258"},"modified":"2026-04-06T10:06:58","modified_gmt":"2026-04-06T15:06:58","slug":"transformada-z-propiedades-sympy","status":"publish","type":"post","link":"https:\/\/blog.espol.edu.ec\/algoritmos101\/ss-u07\/transformada-z-propiedades-sympy\/","title":{"rendered":"7.1.2 Transformada z \u2013 Propiedades con Sympy"},"content":{"rendered":"\n
\n\n\n\n
\n

propiedades<\/a><\/p>\n\n\n\n

multiplica por n<\/a><\/p>\n\n\n\n

inversa multiplica por n<\/a><\/p>\n<\/div>\n\n\n\n

\n\n\n\n

1. Transformada z Propiedades<\/h2>\n\n\n\n

Luego de intentar obtener la Transformada z<\/strong> con la Tabla de Pares<\/a> f[n]<\/code> y F[z]<\/code>, si del resultado sigue siendo None<\/code> se busca aplicar las reglas descritas en la tabla de propiedades<\/strong> de la Transformada z<\/a>.<\/p>\n\n\n\n

Referencia<\/strong><\/em>: Schaum Hsu Tabla 4-2 p173. Lathi Tabla 5.2 p509. Oppenheim Tabla 10.3 p793<\/p>\n\n\n\n

\n\n\n\n
\n

propiedades<\/a><\/p>\n\n\n\n

multiplica por n<\/a><\/p>\n\n\n\n

inversa multiplica por n<\/a><\/p>\n<\/div>\n\n\n\n

\n\n\n\n

2. Propiedad de multiplicaci\u00f3n por n de la transformada z<\/h2>\n\n\n\n

Presentada en la tabla de propiedades y tambi\u00e9n conocida como Diferenciaci\u00f3n en z, se presenta como:<\/p>\n\n\n\n

n x[n] u[n]<\/td>-z \\frac{\\delta}{\\delta z}X(z) <\/span><\/td>R' = R<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Se aplica sobre la se\u00f1al x[n]=1<\/p>\n\n\n x[n] = n \\mu[n] <\/span>\n\n\n\n

A partir de la tabla de transformadas se tiene que la expresi\u00f3n para \u03bc[n] es<\/p>\n\n\n F[z] = \\frac{z}{z-1} = (z)\\frac{1}{z-1}<\/span>\n\n\n \\frac{\\delta}{\\delta z}F[z] = \\frac{1}{z-1}-\\frac{z}{(z-1)^2} <\/span>\n\n\n\n

por lo que para X[z] de obtiene como:<\/p>\n\n\n X[z] = -z \\frac{\\delta}{\\delta z} F[z] <\/span>\n\n\n = -z \\Big[ \\frac{1}{z-1}-\\frac{z}{(z-1)^2}\\Big]<\/span>\n\n\n = -z \\Big[ -\\frac{1}{(z-1)^2}\\Big]<\/span>\n\n\n X[z] = \\frac{z}{(z-1)^2}<\/span>\n\n\n\n

\n\n\n\n
\n

propiedades<\/a><\/p>\n\n\n\n

multiplica por n<\/a><\/p>\n\n\n\n

inversa multiplica por n<\/a><\/p>\n<\/div>\n\n\n\n

\n\n\n\n

3. Algoritmo en Python<\/h2>\n\n\n\n

El desarrollo del algoritmo es posterior a la b\u00fasqueda en la tabla de pares de transformadas z, por lo que se importa el proceso desde telg1001.py<\/a>. En la tabla, para comprobar el funcionamiento de la propiedad con los resultados del texto, se usa una tabla b\u00e1sica, que luego puede ser ampliada.<\/p>\n\n\n\n

El algoritmo se desarrolla para una expresi\u00f3n b\u00e1sica como la de la tabla. Luego los procedimientos se integran en una sola instrucci\u00f3n tal como z_transform(f,n,z)<\/code> que usa primero la tabla, luego revisa las propiedades y f\u00f3rmula de la transformada para mostrar un resultado.<\/p>\n\n\n\n

u = sym.Heaviside(n)\n\n#f = u\nf = n*u<\/code><\/pre>\n\n\n\n
Resultados con el algoritmo:<\/p>\n\n\n\n
 k ; func: 1  ;  n*Heaviside(n)\nno hubo expresi\u00f3n similar en tabla de transformadas\nbuscando aplicar una propiedad n*f[n]\n  f_powna ; n**a: n  ;  {a_: 1}\n\n _z_propiedad n*f[n] -------------\n  n**a ; func\/n, : n  ;  Heaviside(n)\n  _z_propiedad n*f[n] <--> -z*diff(Fz):\n   (z\/(z - 1)**2, Abs(z) > 1, True)\n>>> <\/code><\/pre>\n\n\n\n
Instrucciones en Python<\/h3>\n\n\n\n
El coeficiente constante k<\/code> se separa de la expresi\u00f3n para simplificar el an\u00e1lisis de la expresi\u00f3n en func<\/code>. La constante se reincorpora al resultado al final.<\/p>\n\n\n\n
El procedimiento con la tabla de pares de transformadas \u00a0z_pairs_properties<\/code> se obtiene desde telg1001.py\u00a0<\/a>, se usa con el par\u00e1metro apply_properties=False<\/code> para mostrar el funcionamiento del algoritmo para el ejercicio. La instrucci\u00f3n z_pairs_properties<\/code> hace el llamado a una funci\u00f3n que analiza la expresi\u00f3n con las propiedades ya implementadas y se omite su escritura en condiciones normales.<\/p>\n\n\n\n
Las expresiones pueden tener dos factores con exponentes: an<\/sup>, na<\/sup>, que corresponden a dos propiedades diferentes. El factor  de inter\u00e9s para el ejercicio es na<\/sup>.  La b\u00fasqueda de \u00e9stos factores se realiza con las instrucciones sym.pow(n,a)<\/code> y sym.pow(a,n)<\/code>, en la variable f_powna<\/code> que se inicializan con sym.S.One<\/code>.<\/p>\n\n\n\n
Cuando se encuentra la expresi\u00f3n con f_powna<\/code> se modifica expresi\u00f3n func_n =func\/n, con la que se vuelve a buscar el resultado en la tabla. El proceso para analizar la expresi\u00f3n puede realizarse de forma recursiva hasta obtener una expresi\u00f3n simple como \u03bc[n] y regresar al estado anterior para completar las operaciones. La forma recursiva requiere implementar el procedimiento con def z_propiedades()<\/code>.<\/p>\n\n\n\n
La aplicaci\u00f3n de la propiedad de multiplicaci\u00f3n para n(x[n]) prepara la expresi\u00f3n para aplicar:<\/p>\n\n\n n x[n] \\longleftrightarrow -z \\frac{\\delta}{\\delta z}X(z) <\/span>\n\n\n\n
Fz = (k*(-z)*sym.factor(sym.diff(Fz[0],z,1)),\n                  Fz[1], Fz[2])<\/code><\/pre>\n\n\n\n
que contiene las partes de la transformada como el plano de convergencia y condiciones de aplicaci\u00f3n que tambi\u00e9n deben tomarse en cuenta durante el proceso. Aunque para expresiones se sumas, no se toman en cuenta para el resultado final como en los ejercicios de los textos de referencia.<\/p>\n\n\n\n
Esta secci\u00f3n expone c\u00f3mo se implementa la propiedad de transformada z, el resultado final se encuentra en el archivo.py.<\/p>\n\n\n
\n# transformada z propiedades con Sympy\n# aplicar luego de buscar en tabla de pares\nimport sympy as sym\nfrom telg1001 import z_pairs_properties\n\n# INGRESO\nn = sym.Symbol('n', real=True)\nz = sym.Symbol('z')\nu = sym.Heaviside(n)\n\n#f = u\nf = n*u\n#f = sym.cos(2*n)\n#f = sym.sin(2*n)\n\n# PROCEDIMIENTO\nf = sym.expand(sym.powsimp(f))\na = sym.Wild('a', exclude=[n])\nb = sym.Wild('b', exclude=[n])\ny = sym.Wild('y')\ng = sym.WildFunction('g', nargs=1)\n\n# separa constantes del t\u00e9rmino\nk, func = f.as_independent(n, as_Add=False)\nprint(' k ; func:',k,' ; ',func)\nFz = z_pairs_properties(func, n, z, apply_properties=False)\nif not(Fz==None):\n    Fz = k*Fz\n    print(' usando tabla de pares: \\n ',Fz)\n\nif Fz==None: # no encontrada en tabla\n    print('no hubo expresi\u00f3n similar en tabla de transformadas')\n    print('buscando aplicar una propiedad n*f[n]')\n    # crear una funci\u00f3n para aplicar varias veces las propiedades\n    # en las expresiones, en forma recursiva.\n    \n    # busca factores pow(n,a) or pow(a,n)\n    f_powna = sym.S.One ; f_powan = sym.S.One\n    factor_Mul = sym.Mul.make_args(func)\n    for factor_k in factor_Mul:\n        ma_powna = factor_k.match(sym.Pow(n,a))\n        ma_powan = factor_k.match(sym.Pow(a,n))\n        if ma_powna and not(ma_powna[a]==sym.S.Zero) and ma_powna[a].is_integer:\n            f_powna = f_powna*factor_k\n            print('  f_powna ; n**a:',factor_k,' ; ',ma_powna)\n        if ma_powan:\n            f_powan = f_powan*factor_k\n            print('  f_powan ; a**n:',factor_k,' ; ',ma_powan)\n\n    # otras formas de expresi\u00f3n a revisar\n    ma_un = func.match(sym.Heaviside(y))\n    ma_gn = func.match(g)\n    ma_gu = func.match(g*sym.Heaviside(y))\n\n    # z_propiedad de multipliaci\u00f3n n*f[n] <--> -z*dF(z)\/dz --------\n    if not(f_powna==sym.S.One): # n**a factor encontrado\n        ma_powna = f_powna.match(sym.Pow(n,a))\n        func_n = func\/n # aplicar luego de forma recursiva\n        print('\\n _z_propiedad n*f[n] -------------')\n        print('  n**a ; func\/n, :',n,' ; ',func_n)\n        Fz = z_pairs_properties(func_n,n,z,\n                                apply_properties=False)\n        if not(Fz==None):\n            Fz = (k*(-z)*sym.factor(sym.diff(Fz[0],z,1)),\n                  Fz[1], Fz[2])\n            print('  _z_propiedad n*f[n] <--> -z*diff(Fz):\\n  ',Fz)\n\nif Fz==None: # no encontrada en tabla, tampoco con la propiedad\n    print('propiedad implementada no es suficiente')\n    print('implementar otras propiedades.')\n<\/pre><\/div>\n\n\n
Un procedimiento semejante se implementa para la transformada z inversa.<\/p>\n\n\n\n
\n\n\n\n
\n
propiedades<\/a><\/p>\n\n\n\n
multiplica por n<\/a><\/p>\n\n\n\n
inversa multiplica por n<\/a><\/p>\n<\/div>\n\n\n\n
\n\n\n\n
4. Propiedad de multiplicaci\u00f3n por n de la transformada z inversa<\/h2>\n\n\n\n
Se aplica a partir de F(z), donde la expresi\u00f3n ser\u00e1 tipo polinomio, por lo que se prepara la expresi\u00f3n para conocer el grado del numerador y denominador, separar su signo, constante de multiplicaci\u00f3n, coeficientes, etc.<\/p>\n\n\n\n
Para el resultado del ejercicio anterior f(n) = n\u03bc(n) se obtuvo la expresi\u00f3n:<\/p>\n\n\n F[z] = \\frac{z}{(z-1)^2}<\/span>\n\n\n\n
n x[n] u[n]<\/td>-z \\frac{\\delta}{\\delta z}X(z) <\/span><\/td>R' = R<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
el sentido inverso de la propiedad, se aplica con un integral sobre la expresi\u00f3n con denominador Q=(z-a)b<\/sup>. y a partir de la respuesta F[z] con al menos el grado del numerador P de 1.<\/p>\n\n\n\n
El integral se desarrolla con la expresi\u00f3n despejada de la derivada y con un valor F(0)=0 para determinar la constante del integral.<\/p>\n\n\n X[z] = \\int{\\Big[\\frac{z}{(z-1)^2}\\Big]\\Big[\\frac{-1}{z}\\Big]} + C <\/span>\n\n\n X[z] = \\frac{1}{(z-1)} + C <\/span>\n\n\n\n
usando el valor de para la constante F(0)=0<\/p>\n\n\n 0 = \\frac{1}{(0-1)} + C <\/span>\n\n\n C = 1 <\/span>\n\n\n X[z] = \\frac{1}{(z-1)} +1 = \\frac{1+(z-1)}{(z-1)}<\/span>\n\n\n X[z] = \\frac{z}{(z-1)}<\/span>\n\n\n\n
de la tabla la transformada z inversa es \u03bc(n), y al aplicar al resultado la propiedad se tiene:<\/p>\n\n\n x[n] = n \\mu [n]<\/span>\n\n\n\n
resultados con el algoritmo:<\/p>\n\n\n\n
 Parametros de P\/Q -------------\n P: z\n Q: (z - 1)**2\n P_signo ;k :  1  ;  1\n P_grado, P_ceros: 1  ;  {0: 1}\n Q_grado, Q_polos (real):  2  ;  [1, 1]\n ma_P1 (a*z+ b) :  {a_: 1, b_: 0}\n ma_Q1 (z-a)**b :  {a_: 1, b_: 2}\n ma_Q2 a*z**2+ b*z + r**2:  None\n Fz :  z\/(z - 1)**2\n\n _z_propiedad multiplicaci\u00f3n nf[n] <--> -z*diff(F[z])-- \n Func = integrate(factor(Fz)\/z,z):\n  z\/(z - 1)\n  _z_propiedad multiplicaci\u00f3n nf[n]:\n  (n*Heaviside(n), Abs(z) > 1, True)\n>>> <\/code><\/pre>\n\n\n\n
\n\n\n\n
\n
propiedades<\/a><\/p>\n\n\n\n
multiplica por n<\/a><\/p>\n\n\n\n
inversa multiplica por n<\/a><\/p>\n<\/div>\n\n\n\n
\n\n\n\n
Algoritmo en Python<\/h3>\n\n\n
\n# transformada z propiedades con Sympy\n# aplicar luego de buscar en tabla de pares\nimport sympy as sym\nfrom telg1001 import z_pairs_prop_inverse\n\n# INGRESO\nn = sym.Symbol('n', real=True)\nz = sym.Symbol('z')\nu = sym.Heaviside(n)\n\n# multiplicaci\u00f3n nf[n] <--> -z*diff(F[z])\n#F = z\/(z - 1) #f = u\nF = z\/(z - 1)**2 #f = n*u\n#F = z*(z + 1)\/(z - 1)**3 # (n**2)*u\n\n# PROCEDIMIENTO\n# separa constantes del t\u00e9rmino\nfn = z_pairs_prop_inverse(F, z, n, apply_properties=False)\nif not(fn==None):\n    print(' usando tabla de pares: \\n ',fn)\n\nif fn==None: # no encontrada en tabla\n    Fz = sym.simplify(F) #sym.simplify(F)\n    a = sym.Wild('a', exclude=[n,z])\n    b = sym.Wild('b', exclude=[n,z])\n    r = sym.Wild('r', exclude=[n,z])\n    y = sym.Wild('y')\n    g = sym.WildFunction('g', nargs=1)\n    # analiza como polinomio F[z]:\n    # P_signo, constante, F[z] pares\n    [P,Q] = F.as_numer_denom()\n    # P\n    P = sym.Poly(P,z)\n    ma_P1 = P.match(a*z+ b)\n    P_zeros  = sym.roots(P)\n    P_degree = sym.degree(P,z)\n    P_leadcoef = sym.LC(P)\n    k = sym.Abs(P_leadcoef)\n    P_sign = P_leadcoef\/k\n    P = P\/P_leadcoef\n    # Q\n    Q = sym.factor(Q)\n    ma_Q1 = Q.match((z-a)**b)\n    ma_Q2 = Q.match(a*z**2+ b*z + r**2)\n    Q_poles = sym.real_roots(Q)\n    Q_degree = sym.degree(Q,z)\n    # separa constante\n    Fz = sym.factor(Fz*P_sign\/k)\n    print('\\n Parametros de P\/Q -------------')\n    print(' P:',P)\n    print(' Q:',Q)\n    print(' P_signo ;k : ',P_sign,' ; ',k)\n    print(' P_grado, P_ceros:',P_degree,' ; ', P_zeros)\n    print(' Q_grado, Q_polos (real): ',Q_degree,' ; ',Q_poles)\n    print(' ma_P1 (a*z+ b) : ',ma_P1)\n    print(' ma_Q1 (z-a)**b : ',ma_Q1)\n    print(' ma_Q2 a*z**2+ b*z + r**2: ',ma_Q2)\n    print(' Fz : ',Fz)\n    \n    # _z_property nf[n] <--> -z*diff(F[z])\n    if ma_Q1 and ma_Q1[a]==1 and P_degree>0:\n        FuncI = sym.factor(Fz\/(-z),z)\n        Func = sym.integrate(FuncI,z)\n        F0 = 0 # para Constante de integral\n        C = -Func.subs(z,0)+F0 \n        FunC = sym.factor(Func+C)\n        print('\\n _z_propiedad multiplicaci\u00f3n nf[n] <--> -z*diff(F[z])-- ')\n        print(' Func = integrate(factor(Fz)\/z,z):\\n ',FunC)\n        fn = z_pairs_prop_inverse(FunC, z, n, apply_properties=True)\n        if not(fn==None):\n            fn = (P_sign*k*n*fn[0],fn[1],fn[2])\n            print('  _z_propiedad multiplicaci\u00f3n nf[n]:\\n ',fn)\n\nif fn==None: # no encontrada en tabla, tampoco con la propiedad\n    print('propiedad implementada no es suficiente')\n    print('implementar otras propiedades.')\n<\/pre><\/div>\n\n\n
Si la propiedad debe aplicarse m\u00e1s de una vez, ser\u00e1 necesario convertir el bloque a una funci\u00f3n para hacer llamadas recursivas a si misma, como es el caso de n2<\/sup>*u<\/p>\n\n\n\n
F = z*(z + 1)\/(z - 1)**3 # (n**2)*u<\/span><\/code><\/pre>\n\n\n\n
o al final de la secci\u00f3n de la propiedad, usar apply_properties=True<\/code>, para usar el algoritmo implementado en telg1001.py<\/a><\/p>\n\n\n\n
\n\n\n\n
\n
propiedades<\/a><\/p>\n\n\n\n
multiplica por n<\/a><\/p>\n\n\n\n
inversa multiplica por n<\/a><\/p>\n<\/div>\n\n\n\n
\n","protected":false},"excerpt":{"rendered":"
propiedades multiplica por n inversa multiplica por n 1. Transformada z Propiedades Luego de intentar obtener la Transformada z con la Tabla de Pares f[n] y F[z], si del resultado sigue siendo None se busca aplicar las reglas descritas en la tabla de propiedades de la Transformada z. Referencia: Schaum Hsu Tabla 4-2 p173. Lathi […]<\/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":[177],"tags":[],"class_list":["post-5258","post","type-post","status-publish","format-standard","hentry","category-ss-u07"],"_links":{"self":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/5258","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=5258"}],"version-history":[{"count":10,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/5258\/revisions"}],"predecessor-version":[{"id":24078,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/5258\/revisions\/24078"}],"wp:attachment":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/media?parent=5258"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/categories?post=5258"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/tags?post=5258"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}