{"id":11661,"date":"2023-10-08T05:36:31","date_gmt":"2023-10-08T10:36:31","guid":{"rendered":"http:\/\/blog.espol.edu.ec\/analisisnumerico\/?p=11661"},"modified":"2026-03-15T07:17:39","modified_gmt":"2026-03-15T12:17:39","slug":"edp-elipticas-analitico-implicito-sympy","status":"publish","type":"post","link":"https:\/\/blog.espol.edu.ec\/algoritmos101\/mn-u07\/edp-elipticas-analitico-implicito-sympy\/","title":{"rendered":"7.2.4 EDP El\u00edpticas - anal\u00edtico impl\u00edcito con Sympy-Python"},"content":{"rendered":"\n<hr class=\"wp-block-separator has-alpha-channel-opacity\" \/>\n\n\n\n<div class=\"wp-block-group is-nowrap is-layout-flex wp-container-core-group-is-layout-6c531013 wp-block-group-is-layout-flex\">\n<p>EDP El\u00edpticas<\/p>\n\n\n\n<p><a href=\"https:\/\/blog.espol.edu.ec\/algoritmos101\/mn-unidades\/mn-u07\/edp-elipticas-analitico-iterativo-sympy\/#edpdiscreta\">cont\u00ednua a discreta<\/a><\/p>\n\n\n\n<p><a href=\"#algoritmoimplicito\">algoritmo impl\u00edcito<\/a><\/p>\n<\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">6. EDP El\u00edpticas - M\u00e9todo Impl\u00edcito con Sympy-Python<\/h2>\n\n\n\n<p>Desarrollo anal\u00edtico del <strong>m\u00e9todo implicito<\/strong> para una ecuaci\u00f3n diferencial parcial <strong>el\u00edptica<\/strong> usando <strong>Sympy<\/strong>. El algoritmo reutiliza el algoritmo para la <a href=\"https:\/\/blog.espol.edu.ec\/algoritmos101\/mn-unidades\/mn-u07\/edp-elipticas-analitico-iterativo-sympy\/#edpdiscreta\">EDP El\u00edptica de cont\u00ednua a discreta<\/a>, la creaci\u00f3n de la matriz de valores u_xy, y la funci\u00f3n<br><code>edp_sustituyeValorU()<\/code> para buscar los valores conocidos de la u(x,y).<\/p>\n\n\n\n<p>El algoritmo usa la ecuaci\u00f3n discreta para en cada iteraci\u00f3n i,j reemplazar los valores de U conocidos. Los valores de U se escriben en una matriz u_xy, para diferenciar si el valor existe se usa la matriz de estados u_mask.<\/p>\n\n\n\n<p>Con las ecuaciones de cada iteraci\u00f3n se llena la matriz A de coeficientes y el vector B de las constantes. Al resolver el sistema de ecuaciones se obtienen todos los valores de la matriz U, completando el ejercicio. Se desarrolla la soluci\u00f3n al sistema de ecuaciones usando Sympy como alternativa a usar Numpy con <code>np.linalg.solve(A.B)<\/code> que se encuentra como comentario entre las instrucciones.<\/p>\n\n\n\n<pre class=\"wp-block-code alignwide\"><code> discreta :\n-4\u22c5U(i, j) + U(i, j - 1) + U(i, j + 1) + U(i - 1, j) + U(i + 1, j) = 0\n\nM\u00e9todo Impl\u00edcito - EDP El\u00edptica\nj: 1 ; i: 1 ; ecuacion: 0\nU(0, 1) + U(1, 0) - 4\u22c5U(1, 1) + U(1, 2) + U(2, 1) = 0\n-4\u22c5U(1, 1) + U(1, 2) + U(2, 1) = -110.0\nj: 1 ; i: 2 ; ecuacion: 1\nU(1, 1) + U(2, 0) - 4\u22c5U(2, 1) + U(2, 2) + U(3, 1) = 0\nU(1, 1) - 4\u22c5U(2, 1) + U(2, 2) + U(3, 1) = -50.0\nj: 1 ; i: 3 ; ecuacion: 2\nU(2, 1) + U(3, 0) - 4\u22c5U(3, 1) + U(3, 2) + U(4, 1) = 0\nU(2, 1) - 4\u22c5U(3, 1) + U(3, 2) + U(4, 1) = -50.0\nj: 1 ; i: 4 ; ecuacion: 3\nU(3, 1) + U(4, 0) - 4\u22c5U(4, 1) + U(4, 2) + U(5, 1) = 0\nU(3, 1) - 4\u22c5U(4, 1) + U(4, 2) + U(5, 1) = -50.0\nj: 1 ; i: 5 ; ecuacion: 4\nU(4, 1) + U(5, 0) - 4\u22c5U(5, 1) + U(5, 2) + U(6, 1) = 0\nU(4, 1) - 4\u22c5U(5, 1) + U(5, 2) + U(6, 1) = -50.0\nj: 1 ; i: 6 ; ecuacion: 5\nU(5, 1) + U(6, 0) - 4\u22c5U(6, 1) + U(6, 2) + U(7, 1) = 0\nU(5, 1) - 4\u22c5U(6, 1) + U(6, 2) + U(7, 1) = -50.0\nj: 1 ; i: 7 ; ecuacion: 6\nU(6, 1) + U(7, 0) - 4\u22c5U(7, 1) + U(7, 2) + U(8, 1) = 0\nU(6, 1) - 4\u22c5U(7, 1) + U(7, 2) = -75.0\nj: 2 ; i: 1 ; ecuacion: 7\nU(0, 2) + U(1, 1) - 4\u22c5U(1, 2) + U(1, 3) + U(2, 2) = 0\nU(1, 1) - 4\u22c5U(1, 2) + U(1, 3) + U(2, 2) = -60.0\nj: 2 ; i: 2 ; ecuacion: 8\nU(1, 2) + U(2, 1) - 4\u22c5U(2, 2) + U(2, 3) + U(3, 2) = 0\nj: 2 ; i: 3 ; ecuacion: 9\nU(2, 2) + U(3, 1) - 4\u22c5U(3, 2) + U(3, 3) + U(4, 2) = 0\nj: 2 ; i: 4 ; ecuacion: 10\nU(3, 2) + U(4, 1) - 4\u22c5U(4, 2) + U(4, 3) + U(5, 2) = 0\nj: 2 ; i: 5 ; ecuacion: 11\nU(4, 2) + U(5, 1) - 4\u22c5U(5, 2) + U(5, 3) + U(6, 2) = 0\nj: 2 ; i: 6 ; ecuacion: 12\nU(5, 2) + U(6, 1) - 4\u22c5U(6, 2) + U(6, 3) + U(7, 2) = 0\nj: 2 ; i: 7 ; ecuacion: 13\nU(6, 2) + U(7, 1) - 4\u22c5U(7, 2) + U(7, 3) + U(8, 2) = 0\nU(6, 2) + U(7, 1) - 4\u22c5U(7, 2) + U(7, 3) = -25.0\nj: 3 ; i: 1 ; ecuacion: 14\nU(0, 3) + U(1, 2) - 4\u22c5U(1, 3) + U(1, 4) + U(2, 3) = 0\nU(1, 2) - 4\u22c5U(1, 3) + U(1, 4) + U(2, 3) = -60.0\nj: 3 ; i: 2 ; ecuacion: 15\nU(1, 3) + U(2, 2) - 4\u22c5U(2, 3) + U(2, 4) + U(3, 3) = 0\nj: 3 ; i: 3 ; ecuacion: 16\nU(2, 3) + U(3, 2) - 4\u22c5U(3, 3) + U(3, 4) + U(4, 3) = 0\nj: 3 ; i: 4 ; ecuacion: 17\nU(3, 3) + U(4, 2) - 4\u22c5U(4, 3) + U(4, 4) + U(5, 3) = 0\nj: 3 ; i: 5 ; ecuacion: 18\nU(4, 3) + U(5, 2) - 4\u22c5U(5, 3) + U(5, 4) + U(6, 3) = 0\nj: 3 ; i: 6 ; ecuacion: 19\nU(5, 3) + U(6, 2) - 4\u22c5U(6, 3) + U(6, 4) + U(7, 3) = 0\nj: 3 ; i: 7 ; ecuacion: 20\nU(6, 3) + U(7, 2) - 4\u22c5U(7, 3) + U(7, 4) + U(8, 3) = 0\nU(6, 3) + U(7, 2) - 4\u22c5U(7, 3) + U(7, 4) = -25.0\nj: 4 ; i: 1 ; ecuacion: 21\nU(0, 4) + U(1, 3) - 4\u22c5U(1, 4) + U(1, 5) + U(2, 4) = 0\nU(1, 3) - 4\u22c5U(1, 4) + U(1, 5) + U(2, 4) = -60.0\nj: 4 ; i: 2 ; ecuacion: 22\nU(1, 4) + U(2, 3) - 4\u22c5U(2, 4) + U(2, 5) + U(3, 4) = 0\nj: 4 ; i: 3 ; ecuacion: 23\nU(2, 4) + U(3, 3) - 4\u22c5U(3, 4) + U(3, 5) + U(4, 4) = 0\nj: 4 ; i: 4 ; ecuacion: 24\nU(3, 4) + U(4, 3) - 4\u22c5U(4, 4) + U(4, 5) + U(5, 4) = 0\nj: 4 ; i: 5 ; ecuacion: 25\nU(4, 4) + U(5, 3) - 4\u22c5U(5, 4) + U(5, 5) + U(6, 4) = 0\nj: 4 ; i: 6 ; ecuacion: 26\nU(5, 4) + U(6, 3) - 4\u22c5U(6, 4) + U(6, 5) + U(7, 4) = 0\nj: 4 ; i: 7 ; ecuacion: 27\nU(6, 4) + U(7, 3) - 4\u22c5U(7, 4) + U(7, 5) + U(8, 4) = 0\nU(6, 4) + U(7, 3) - 4\u22c5U(7, 4) + U(7, 5) = -25.0\nj: 5 ; i: 1 ; ecuacion: 28\nU(0, 5) + U(1, 4) - 4\u22c5U(1, 5) + U(1, 6) + U(2, 5) = 0\nU(1, 4) - 4\u22c5U(1, 5) + U(2, 5) = -130.0\nj: 5 ; i: 2 ; ecuacion: 29\nU(1, 5) + U(2, 4) - 4\u22c5U(2, 5) + U(2, 6) + U(3, 5) = 0\nU(1, 5) + U(2, 4) - 4\u22c5U(2, 5) + U(3, 5) = -70.0\nj: 5 ; i: 3 ; ecuacion: 30\nU(2, 5) + U(3, 4) - 4\u22c5U(3, 5) + U(3, 6) + U(4, 5) = 0\nU(2, 5) + U(3, 4) - 4\u22c5U(3, 5) + U(4, 5) = -70.0\nj: 5 ; i: 4 ; ecuacion: 31\nU(3, 5) + U(4, 4) - 4\u22c5U(4, 5) + U(4, 6) + U(5, 5) = 0\nU(3, 5) + U(4, 4) - 4\u22c5U(4, 5) + U(5, 5) = -70.0\nj: 5 ; i: 5 ; ecuacion: 32\nU(4, 5) + U(5, 4) - 4\u22c5U(5, 5) + U(5, 6) + U(6, 5) = 0\nU(4, 5) + U(5, 4) - 4\u22c5U(5, 5) + U(6, 5) = -70.0\nj: 5 ; i: 6 ; ecuacion: 33\nU(5, 5) + U(6, 4) - 4\u22c5U(6, 5) + U(6, 6) + U(7, 5) = 0\nU(5, 5) + U(6, 4) - 4\u22c5U(6, 5) + U(7, 5) = -70.0\nj: 5 ; i: 7 ; ecuacion: 34\nU(6, 5) + U(7, 4) - 4\u22c5U(7, 5) + U(7, 6) + U(8, 5) = 0\nU(6, 5) + U(7, 4) - 4\u22c5U(7, 5) = -95.0\n\n A : \n &#091;&#091;-4.  1.  0. ...  0.  0.  0.]\n &#091; 1. -4.  1. ...  0.  0.  0.]\n &#091; 0.  1. -4. ...  0.  0.  0.]\n ...\n &#091; 0.  0.  0. ... -4.  1.  0.]\n &#091; 0.  0.  0. ...  1. -4.  1.]\n &#091; 0.  0.  0. ...  0.  1. -4.]]\n\n B : \n &#091;-110.  -50.  -50.  -50.  -50.  -50.  -75.  -60.    0.    0.    0.    0.\n    0.  -25.  -60.    0.    0.    0.    0.    0.  -25.  -60.    0.    0.\n    0.    0.    0.  -25. -130.  -70.  -70.  -70.  -70.  -70.  -95.]\nResultados para U(x,y)\nxi: &#091;0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]\nyj: &#091;0.   0.25 0.5  0.75 1.   1.25 1.5 ]\n j, U&#091;i,j]\n6 &#091;70. 70. 70. 70. 70. 70. 70. 70. 70.]\n5 &#091;60.   64.02 64.97 64.71 63.62 61.44 57.16 47.96 25.  ]\n4 &#091;60.   61.1  61.14 60.25 58.35 54.98 49.23 39.67 25.  ]\n3 &#091;60.   59.23 58.25 56.81 54.53 50.89 45.13 36.48 25.  ]\n2 &#091;60.   57.56 55.82 54.19 52.09 48.92 43.91 36.14 25.  ]\n1 &#091;60.   55.21 53.27 52.05 50.73 48.78 45.46 39.15 25.  ]\n0 &#091;50. 50. 50. 50. 50. 50. 50. 50. 50.]\n<\/code><\/pre>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\" \/>\n\n\n\n<div class=\"wp-block-group is-nowrap is-layout-flex wp-container-core-group-is-layout-6c531013 wp-block-group-is-layout-flex\">\n<p>EDP El\u00edpticas<\/p>\n\n\n\n<p><a href=\"https:\/\/blog.espol.edu.ec\/algoritmos101\/mn-unidades\/mn-u07\/edp-elipticas-analitico-iterativo-sympy\/#edpdiscreta\">cont\u00ednua a discreta<\/a><\/p>\n\n\n\n<p><a href=\"#algoritmoimplicito\">algoritmo impl\u00edcito<\/a><\/p>\n<\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\" \/>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"algoritmoimplicito\">7. Algoritmo en Python<\/h2>\n\n\n\n<p>Las instrucciones completas con Sympy-Python son:<\/p>\n\n\n<div class=\"wp-block-syntaxhighlighter-code alignwide\"><pre class=\"brush: python; title: ; notranslate\" title=\"\">\n# Ecuaciones Diferenciales Parciales Elipticas\n# EDP El\u00edpticas cont\u00ednua a discreta con Sympy\nimport numpy as np\nimport sympy as sym\n\n# u(x,y) funciones continuas y variables simb\u00f3licas usadas\nx = sym.Symbol('x',real=True)\ny = sym.Symbol('y',real=True)\nu = sym.Function('u')(x,y) # funcion\nf = sym.Function('f')(x,y) # funcion complemento\n# U&#x5B;i,j] funciones discretas y variables simb\u00f3licas usadas\ni  = sym.Symbol('i',integer=True,positive=True)\nj  = sym.Symbol('j',integer=True,positive=True)\nDx = sym.Symbol('Dx',real=True,positive=True)\nDy = sym.Symbol('Dy',real=True,positive=True)\nL  = sym.Symbol('L',real=True)\nU  = sym.Function('U')(i,j)\n\n# INGRESO\nfxy = 0*x+0*y  # f(x,y) = 0 , ecuacion de Poisson\n# ecuacion edp : LHS=RHS\nLHS = sym.diff(u,x,2) + sym.diff(u,y,2)\nRHS = fxy\nedp = sym.Eq(LHS-RHS,0)\n\n# centrada, centrada, atras\ndif_dividida ={sym.diff(u,x,2): (U.subs(i,i-1)-2*U+U.subs(i,i+1))\/(Dx**2),\n               sym.diff(u,y,2): (U.subs(j,j-1)-2*U+U.subs(j,j+1))\/(Dy**2),\n               sym.diff(u,y,1): (U - U.subs(j,j-1))\/Dy}\n\n# Condiciones iniciales en los bordes\nfya = lambda y: 60 +0*y  # izquierda\nfyb = lambda y: 25 +0*y  # derecha\nfxc = lambda x: 50 +0*x  # inferior \nfxd = lambda x: 70 +0*x  # superior \n\n# dimensiones de la placa\nx0 = 0    # longitud en x\nxn = 2\ny0 = 0    # longitud en y\nyn = 1.5\n# muestreo en ejes, discreto, supone dx=dy\ndx = 0.25  # Tama\u00f1o de paso\ndy = dx # supone dx=dy\niteramax = 100 # revisa convergencia\ntolera = 0.0001\n\nverdigitos = 2      # para mostrar en tabla de resultados\ncasicero = 1e-15    # para redondeo de t\u00e9rminos en ecuacion\n\n# PROCEDIMIENTO\ndef edp_discreta(edp,dif_dividida,x,y,u):\n    ''' EDP cont\u00ednua a discreta, usa diferencias divididas\n        proporcionadas en par\u00e1metros, indica las variables x,y\n        con funci\u00f3n u de (x,y)\n    '''\n    resultado={}\n    # expresi\u00f3n todo a la izquierda LHS (Left Hand side)\n    LHS = edp.lhs\n    RHS = edp.rhs\n    if not(edp.rhs==0):\n        LHS = LHS-RHS\n        RHS = 0\n        edp = sym.Eq(LHS,RHS)\n    # orden de derivada por x, y\n    edp_x = edp.subs(x,0)\n    edp_y = edp.subs(y,0)\n    ordenDx = sym.ode_order(edp_x,u)\n    ordenDy = sym.ode_order(edp_y,u)\n    resultado&#x5B;'ordenDx'] = ordenDx  # guarda en resultados\n    resultado&#x5B;'ordenDy'] = ordenDy\n    # coeficiente derivada orden mayor a 1 (d2u\/dx2)\n    coeff_x = edp_coef_Dx(edp,x,ordenDx)\n    if not(coeff_x==1):\n        LHS = LHS\/coeff_x\n        RHS = RHS\/coeff_x\n    edp = sym.Eq(LHS,RHS)\n    K_ = edp_coef_Dx(edp,y,ordenDy)\n    if abs(K_)%1&lt;casicero: # si es entero\n        K_ = int(K_)\n    resultado&#x5B;'edp=0']  = edp\n    resultado&#x5B;'K_']  = K_\n    \n    discreta = edp.lhs  # EDP discreta\n    for derivada in dif_dividida: # reemplaza diferencia dividida\n        discreta = discreta.subs(derivada,dif_dividida&#x5B;derivada])\n    resultado&#x5B;'discreta=0'] = discreta\n    return (resultado)\n\ndef edp_coef_Dx(edp,x,ordenx):\n    ''' Extrae el coeficiente de la derivada Dx de ordenx\n    edp es la ecuaci\u00f3n como lhs=rhs\n    '''\n    coeff_x = 1.0 # valor inicial\n    # separa cada t\u00e9rmino de suma\n    term_suma = sym.Add.make_args(edp.lhs)\n    for term_k in term_suma:\n        if term_k.is_Mul: # mas de un factor\n            factor_Mul = sym.Mul.make_args(term_k)\n            coeff_temp = 1; coeff_usar=False\n            # separa cada factor de t\u00e9rmino \n            for factor_k in factor_Mul:\n                if not(factor_k.is_Derivative):\n                    coeff_temp = coeff_temp*factor_k\n                else: # factor con derivada de ordenx\n                    partes = factor_k.args\n                    if partes&#x5B;1]==(x,ordenx):\n                        coeff_usar = 1\n            if coeff_usar==True:\n                coeff_x = coeff_x*coeff_temp\n    return(coeff_x)\n\ndef redondea_coef(ecuacion, precision=6,casicero = 1e-15):\n    ''' redondea coeficientes de t\u00e9rminos suma de una ecuacion\n    ecuaci\u00f3n como lhs=rhs\n    '''\n    tipo = type(ecuacion)\n    tipo_eq = False\n    if tipo == sym.core.relational.Equality:\n        RHS = ecuacion.rhs\n        ecuacion = ecuacion.lhs\n        tipo = type(ecuacion)\n        tipo_eq = True\n\n    if tipo == sym.core.add.Add: # t\u00e9rminos suma de ecuacion\n        term_sum = sym.Add.make_args(ecuacion)\n        ecuacion = sym.S.Zero # vacia\n        for term_k in term_sum:\n            # factor multiplicativo de termino suma\n            term_mul = sym.Mul.make_args(term_k)\n            producto = sym.S.One\n            for factor in term_mul:\n                if not(factor.has(sym.Symbol)): # es numerico\n                    factor = np.around(float(factor),precision)\n                    if (abs(factor)%1)&lt;casicero: # si es entero\n                        factor = int(factor)\n                producto = producto*factor\n            ecuacion = ecuacion + producto\n    \n    if tipo == sym.core.mul.Mul: # termino \u00fanico, busca factores\n        term_mul = sym.Mul.make_args(ecuacion)\n        producto = sym.S.One\n        for factor in term_mul:\n            if not(factor.has(sym.Symbol)): # es numerico\n                factor = np.around(float(factor),precision)\n                if (abs(factor)%1)&lt;casicero: # si es entero\n                    factor = int(factor)\n            producto = producto*factor\n        ecuacion = producto\n    \n    if tipo == float: # # solo un numero\n        if (abs(ecuacion)%1)&lt;casicero: \n            ecuacion = int(ecuacion)\n    if tipo_eq==True: # era igualdad, integra lhs=rhs\n        ecuacion = sym.Eq(ecuacion,RHS)\n    \n    return(ecuacion)\n\ndef edp_simplificaLamba(resultado,dx,dy):\n    '''simplifica ecuacion con valores de lambda, dx y dy\n    entregando la edp discreta simplificada\n    '''\n    discreta = resultado&#x5B;'discreta=0']\n    ordenDy = resultado&#x5B;'ordenDy']\n    ordenDx = resultado&#x5B;'ordenDx']\n    K_ = resultado&#x5B;'K_']\n    lamb = (Dy**ordenDy)\/(Dx**ordenDx)\n    if ordenDy==1 and ordenDx==2:\n        lamb = lamb\/K_\n    resultado&#x5B;'Lambda_L'] = lamb\n    # valor de Lambda en ecuacion edp\n    L_k = lamb.subs(&#x5B;(Dx,dx),(Dy,dy)])\n    if abs(L_k)%1&lt;casicero: # si es entero\n        L_k = int(L_k)\n    resultado&#x5B;'Lambda L_k'] = L_k\n    # simplifica con lambda L\n    discreta_L = sym.expand(discreta*(Dy**ordenDy),mul=True)\n    resultado&#x5B;'(discreta=0)*Dy**ordeny'] = discreta_L\n    discreta_L = edp_sustituye_L(resultado)\n    discreta_L = discreta_L.subs(lamb,L)\n    discreta_L = sym.collect(discreta_L,U)\n    discreta_L = sym.Eq(discreta_L,0)\n    resultado&#x5B;'discreta_L = 0'] = discreta_L\n    # sustituye constantes en ecuaci\u00f3n a iterar\n    discreta_L = discreta_L.subs(&#x5B;(Dx,dx),(Dy,dy),(L,L_k)])\n    discreta_L = redondea_coef(discreta_L)\n    resultado&#x5B;'discreta'] = discreta_L\n    return(resultado)\n\ndef edp_sustituye_L(resultado):\n    ''' sustituye lambda con Dy**ordeny\/Dx**x\/K_\n    por L, al simplificar Lambda\n    '''\n    discreta = resultado&#x5B;'(discreta=0)*Dy**ordeny']\n    ordenDy = resultado&#x5B;'ordenDy']\n    ordenDx = resultado&#x5B;'ordenDx']\n    discreta_L = 0\n    # separa cada t\u00e9rmino de suma\n    term_suma = sym.Add.make_args(discreta)\n    for term_k in term_suma:\n        # busca partes de L y cambia por valor L\n        cambiar = 0 # por orden de derivada\n        if term_k.has(Dx) and term_k.has(Dy):\n            partes = term_k.args\n            ordeny=1\n            ordenx=1\n            for unaparte in partes:    \n                if unaparte.has(Dy):\n                    if unaparte.is_Pow:\n                        partey = unaparte.args\n                        ordeny = partey&#x5B;1]\n                if unaparte.has(Dx):\n                    if unaparte.is_Pow:\n                        partey = unaparte.args\n                        ordenx = partey&#x5B;1]\n            if (ordeny&lt;=ordenDy and ordenx&lt;=-ordenDx):\n                cambiar=1\n        if cambiar:\n            term_k = term_k*L\/resultado&#x5B;'Lambda_L']\n        discreta_L = discreta_L + term_k\n        # simplifica unos con decimal a entero \n        discreta_L = discreta_L.subs(1.0,1)\n    return(discreta_L)\n\ndef edp_sustituyeValorU(discreta,xi,yj,u_xy,u_mask):\n    '''Sustituye en edp discreta los valores conocidos de U&#x5B;i,j]\n    tomados desde u_xy, marcados con u_mask\n    u_mask indica si el valor se ha calculado con edp.\n    '''\n    LHS = discreta.lhs # lado izquierdo de ecuacion\n    RHS = discreta.rhs # lado derecho\n    # sustituye U&#x5B;i,j] con valores conocidos\n    A_diagonal = &#x5B;] # lista de i,j para matriz de coeficientes A\n    # Separa t\u00e9rminos suma\n    term_suma = sym.Add.make_args(LHS)\n    for term_k in term_suma:\n        # busca U&#x5B;i,j] y cambia por valor uxt&#x5B;i,j]\n        cambiar = 0 ; cambiar_valor = 0 ; cambiar_factor = 0\n        # separa cada factor de t\u00e9rmino\n        factor_Mul = sym.Mul.make_args(term_k)\n        for factor_k in factor_Mul:\n            # busca U&#x5B;i,j] en matriz uxt&#x5B;i,j]\n            if factor_k.is_Function:\n                &#x5B;i_k,j_k] = factor_k.args\n                if not(np.isnan(u_xy&#x5B;i_k,j_k])):\n                    cambiar = u_mask&#x5B;i_k,j_k]\n                    cambiar_factor = factor_k\n                    cambiar_valor = u_xy&#x5B;i_k,j_k]\n                else:\n                    A_diagonal.append(&#x5B;i_k,j_k,term_k\/factor_k])\n        # encontr\u00f3 valor U&#x5B;i,j],term_k va a la derecha de ecuaci\u00f3n\n        if cambiar:\n            LHS = LHS - term_k\n            term_ki = term_k.subs(cambiar_factor,cambiar_valor)\n            RHS = RHS - term_ki\n    discreta = sym.Eq(LHS,RHS)\n    B_diagonal = RHS\n    resultado = &#x5B;discreta,A_diagonal,B_diagonal]\n    return (resultado)\n\n# PROCEDIMIENTO\n# transforma edp continua a discreta\nresultado = edp_discreta(edp,dif_dividida,x,y,u)\nresultado = edp_simplificaLamba(resultado,dx,dy)\ndiscreta = resultado&#x5B;'discreta']\n\n# SALIDA\nnp.set_printoptions(precision=verdigitos)\nalgun_numero = &#x5B;int,float,str,'Lambda L_k']\nprint('EDP El\u00edptica cont\u00ednua a discreta')\nfor entrada in resultado:\n    tipo = type(resultado&#x5B;entrada])\n    if tipo in algun_numero or entrada in algun_numero:\n        print('',entrada,':',resultado&#x5B;entrada])\n    else:\n        print('\\n',entrada,':')\n        sym.pprint(resultado&#x5B;entrada])\n\n# ITERAR para cada i,j dentro de U ------------\n# x&#x5B;i] , y&#x5B;j]  valor en posici\u00f3n en cada eje\nxi = np.arange(x0,xn+dx\/2,dx)\nyj = np.arange(y0,yn+dy\/2,dy)\nn = len(xi)\nm = len(yj)\n\n# Matriz U\nu_xy = np.zeros(shape=(n,m),dtype = float)\nu_xy = u_xy*np.nan # valor inicial dentro de u\n# llena u con valores en fronteras\nu_xy&#x5B;0,:]   = fya(yj)  # izquierda Ta\nu_xy&#x5B;n-1,:] = fyb(yj)  # derecha   Tb\nu_xy&#x5B;:,0]   = fxc(xi)  # inferior  Tc\nu_xy&#x5B;:,m-1] = fxd(xi)  # superior  Td\nu0 = np.copy(u_xy)     # matriz u inicial\n\n# u_mask&#x5B;i,j] con valores iniciales o calculados:True\nu_mask = np.zeros(shape=(n,m),dtype=bool)\nu_mask&#x5B;0,:]  = True # izquierda\nu_mask&#x5B;-1,:] = True # derecha\nu_mask&#x5B;:,0]  = True # inferior\nu_mask&#x5B;:,-1] = True # superior\n\n# M\u00e9todo impl\u00edcito para EDP El\u00edptica\n# ITERAR para plantear las ecuaciones en &#x5B;i,j]\nresultado = {}\neq_itera = &#x5B;] ; tamano = (n-2)*(m-2)\nA = np.zeros(shape=(tamano,tamano),dtype=float)\nB = np.zeros(tamano,dtype=float)\nfor j_k in range(1,m-1,1): # no usar valores en bordes\n    for i_k in range(1,n-1,1): \n        eq_conteo = (j_k - 1)*(n-2)+(i_k-1)\n        discreta_ij = discreta.subs({i:i_k,j:j_k,\n                                     x:xi&#x5B;i_k],y:yj&#x5B;j_k]})\n        resultado&#x5B;eq_conteo]= {'j':j_k, 'i':i_k,\n                                 'discreta_ij': discreta_ij}\n        # usa valores de frontera segun u_mask con True\n        discreta_k = edp_sustituyeValorU(discreta_ij,\n                                        xi,yj,u_xy,u_mask)\n        discreta_ij = discreta_k&#x5B;0]\n        A_diagonal  = discreta_k&#x5B;1] # lista de (i,j,coeficiente) \n        B_diagonal  = discreta_k&#x5B;2]\n        resultado&#x5B;eq_conteo]&#x5B;'discreta_k'] = discreta_k&#x5B;0]\n        # a\u00f1ade ecuacion a resolver\n        eq_itera.append(discreta_ij)\n        # Aplica coeficientes de ecuacion en A y B:\n        # A_diagonal tiene lista de (i,j,coeficiente) \n        for uncoeff in A_diagonal:\n            columna = (uncoeff&#x5B;1]-1)*(n-2)+(uncoeff&#x5B;0]-1)\n            fila = (j_k - 1)*(n-2)+(i_k-1)\n            A&#x5B;fila,columna] = uncoeff&#x5B;2]\n        B&#x5B;eq_conteo] = float(B_diagonal) # discreta_ij.rhs\nresultado&#x5B;'A'] = np.copy(A)\nresultado&#x5B;'B'] = np.copy(B)\n\n# resuelve el sistema de ecuaciones en eq_itera en Sympy\nX_k = sym.solve(eq_itera)&#x5B;0]\n# actualiza uxt&#x5B;i,j] , u_mask segun X_k en Sympy\nfor nodo_Uij in X_k: \n    &#x5B;i_k,j_k] = nodo_Uij.args\n    u_xy&#x5B;i_k,j_k] = X_k&#x5B;nodo_Uij]\n    u_mask&#x5B;i_k,j_k] = True\n# resuelve el sistema A.X=B en Numpy\n#X = np.linalg.solve(A,B)\n# tarea: llevar valores X a u_xy\n\n# SALIDA\nnp.set_printoptions(precision=verdigitos)\nalgun_numero = &#x5B;int,float,str,'Lambda L_k']\nprint('\\nM\u00e9todo Impl\u00edcito - EDP El\u00edptica')\nfor entrada in resultado:\n    tipo = type(resultado&#x5B;entrada])\n    if tipo in algun_numero or entrada in algun_numero:\n        print('',entrada,':',resultado&#x5B;entrada])\n    elif (tipo==dict):\n        print('j:',resultado&#x5B;entrada]&#x5B;'j'],'; '\n              'i:',resultado&#x5B;entrada]&#x5B;'i'],'; '\n              'ecuacion:',entrada)\n        sym.pprint(resultado&#x5B;entrada]&#x5B;'discreta_ij'])\n        if resultado&#x5B;entrada]&#x5B;'discreta_k'].rhs!=0:\n            sym.pprint(resultado&#x5B;entrada]&#x5B;'discreta_k'])\n    else:\n        print('\\n',entrada,': \\n',resultado&#x5B;entrada])\nprint('Resultados para U(x,y)')\nprint('xi:',xi)\nprint('yj:',yj)\nprint(' j, U&#x5B;i,j]')\nfor j_k in range(m-1,-1,-1):\n    print(j_k, (u_xy&#x5B;:,j_k]))\n<\/pre><\/div>\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\" \/>\n\n\n\n<div class=\"wp-block-group is-nowrap is-layout-flex wp-container-core-group-is-layout-6c531013 wp-block-group-is-layout-flex\">\n<p>EDP El\u00edpticas<\/p>\n\n\n\n<p><a href=\"https:\/\/blog.espol.edu.ec\/algoritmos101\/mn-unidades\/mn-u07\/edp-elipticas-analitico-iterativo-sympy\/#edpdiscreta\">cont\u00ednua a discreta<\/a><\/p>\n\n\n\n<p><a href=\"#algoritmoimplicito\">algoritmo impl\u00edcito<\/a><\/p>\n<\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\" \/>\n","protected":false},"excerpt":{"rendered":"<p>EDP El\u00edpticas cont\u00ednua a discreta algoritmo impl\u00edcito 6. EDP El\u00edpticas - M\u00e9todo Impl\u00edcito con Sympy-Python Desarrollo anal\u00edtico del m\u00e9todo implicito para una ecuaci\u00f3n diferencial parcial el\u00edptica usando Sympy. El algoritmo reutiliza el algoritmo para la EDP El\u00edptica de cont\u00ednua a discreta, la creaci\u00f3n de la matriz de valores u_xy, y la funci\u00f3nedp_sustituyeValorU() para buscar los [&hellip;]<\/p>\n","protected":false},"author":8043,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"wp-custom-template-entrada-mn-unidades","format":"standard","meta":{"footnotes":""},"categories":[41],"tags":[],"class_list":["post-11661","post","type-post","status-publish","format-standard","hentry","category-mn-u07"],"_links":{"self":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/11661","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=11661"}],"version-history":[{"count":4,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/11661\/revisions"}],"predecessor-version":[{"id":22990,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/posts\/11661\/revisions\/22990"}],"wp:attachment":[{"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/media?parent=11661"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/categories?post=11661"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.espol.edu.ec\/algoritmos101\/wp-json\/wp\/v2\/tags?post=11661"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}