{"id":7934,"date":"2023-05-13T08:21:02","date_gmt":"2023-05-13T06:21:02","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7934"},"modified":"2023-05-13T08:21:02","modified_gmt":"2023-05-13T06:21:02","slug":"13-may-23","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/13-may-23\/","title":{"rendered":"La semana en Exercitium (13 de mayo de 2023)"},"content":{"rendered":"<p>Esta semana he publicado en <a href=\"http:\/\/bit.ly\/2sqPtGs\">Exercitium<\/a> las soluciones de los siguientes problemas sobre el <a href=\"https:\/\/bit.ly\/3KwqXYu\">tipo abstracto de datos de los polinomios<\/a><\/p>\n<ul>\n<li><a href=\"#ej1\">1. Integral definida de un polinomio<\/a><\/li>\n<li><a href=\"#ej2\">2. Multiplicaci\u00f3n de un polinomio por un n\u00famero<\/a><\/li>\n<li><a href=\"#ej3\">3. Divisi\u00f3n de polinomios<\/a><\/li>\n<li><a href=\"#ej4\">4. Divisibilidad de polinomios<\/a><\/li>\n<li><a href=\"#ej5\">5. M\u00e9todo de Horner del valor de un polinomio<\/a><\/li>\n<\/ul>\n<p>A continuaci\u00f3n se muestran las soluciones.<br \/>\n<!--more--><br \/>\n<a name=\"ej1\"><\/a><\/p>\n<h3>1. Integral definida de un polinomio<\/h3>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3KwqXYu\">tipo abstracto de datos de los polinomios<\/a> definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   integralDef :: (Fractional t, Eq t) => Polinomio t -> t -> t -> t\n<\/pre>\n<p>tal que <code>integralDef p a b<\/code> es la integral definida del polinomio <code>p<\/code> entre <code>a<\/code> y <code>b<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ejPol = consPol 7 2 (consPol 4 5 (consPol 2 5 polCero))\n   \u03bb> ejPol\n   2*x^7 + 5*x^4 + 5*x^2\n   \u03bb> integralDef ejPol 0 1\n   2.916666666666667\n   \u03bb> integralDef ejPol 0 1 :: Rational\n   35 % 12\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Polinomio (Polinomio, consPol, polCero)\nimport Pol_Valor_de_un_polinomio_en_un_punto (valor)\nimport Pol_Integral_de_un_polinomio (integral)\n\nintegralDef :: (Fractional t, Eq t) => Polinomio t -> t -> t -> t\nintegralDef p a b = valor q b - valor q a\n  where q = integral p\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom src.Pol_Integral_de_un_polinomio import integral\nfrom src.Pol_Valor_de_un_polinomio_en_un_punto import valor\nfrom src.TAD.Polinomio import Polinomio, consPol, polCero\n\n\ndef integralDef(p: Polinomio[float], a: float, b: float) -> float:\n    q = integral(p)\n    return valor(q, b) - valor(q, a)\n<\/pre>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. Multiplicaci\u00f3n de un polinomio por un n\u00famero<\/h3>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3KwqXYu\">tipo abstracto de los polinomios<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   multEscalar :: (Num a, Eq a) => a -> Polinomio a -> Polinomio a\n<\/pre>\n<p>tal que <code>multEscalar c p<\/code> es el polinomio obtenido multiplicando el n\u00famero <code>c<\/code> por el polinomio <code>p<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ejPol = consPol 1 2 (consPol 0 3 polCero)\n   \u03bb> ejPol\n   2*x + 3\n   \u03bb> multEscalar 4 ejPol\n   8*x + 12\n   \u03bb> multEscalar (1 % 4) ejPol\n   1 % 2*x + 3 % 4\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,\n                      coefLider, restoPol)\nimport Data.Ratio\n\nmultEscalar :: (Num a, Eq a) => a -> Polinomio a -> Polinomio a\nmultEscalar c p\n  | esPolCero p = polCero\n  | otherwise   = consPol n (c*b) (multEscalar c r)\n  where n = grado p\n        b = coefLider p\n        r = restoPol p\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom typing import TypeVar\n\nfrom src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,\n                               polCero, restoPol)\n\nA = TypeVar('A', int, float, complex)\n\ndef multEscalar(c: A, p: Polinomio[A]) -> Polinomio[A]:\n    if esPolCero(p):\n        return polCero()\n    n = grado(p)\n    b = coefLider(p)\n    r = restoPol(p)\n    return consPol(n, c * b, multEscalar(c, r))\n<\/pre>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. Divisi\u00f3n de polinomios<\/h3>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3KwqXYu\">tipo abstracto de los polinomios<\/a>, definir las funciones<\/p>\n<pre lang=\"text\">\n   cociente :: (Fractional a, Eq a) =>\n               Polinomio a -> Polinomio a -> Polinomio a\n   resto    :: (Fractional a, Eq a) =>\n               Polinomio a -> Polinomio a -> Polinomio a\n<\/pre>\n<p>tales que<\/p>\n<ul>\n<li><code>cociente p q<\/code> es el cociente de la divisi\u00f3n de <code>p<\/code> entre <code>q<\/code>. Por ejemplo,<\/li>\n<\/ul>\n<pre lang=\"text\">\n     \u03bb> pol1 = consPol 3 2 (consPol 2 9 (consPol 1 10 (consPol 0 4 polCero)))\n     \u03bb> pol1\n     2*x^3 + 9*x^2 + 10*x + 4\n     \u03bb> pol2 = consPol 2 1 (consPol 1 3 polCero)\n     \u03bb> pol2\n     x^2 + 3*x\n     \u03bb> cociente pol1 pol2\n     2.0*x + 3.0\n<\/pre>\n<ul>\n<li><code>resto p q<\/code> es el resto de la divisi\u00f3n de <code>p<\/code> entre <code>q<\/code>. Por ejemplo,<\/li>\n<\/ul>\n<pre lang=\"text\">\n     \u03bb> resto pol1 pol2\n     1.0*x + 4.0\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Polinomio (Polinomio, polCero, consPol, grado, coefLider)\nimport Pol_Crea_termino (creaTermino)\nimport Pol_Producto_polinomios (multPol, multPorTerm)\nimport Pol_Resta_de_polinomios (restaPol)\nimport Pol_Multiplicacion_de_un_polinomio_por_un_numero (multEscalar)\n\ncociente :: (Fractional a, Eq a) =>\n            Polinomio a -> Polinomio a -> Polinomio a\ncociente p q\n  | n2 == 0   = multEscalar (1\/a2) p\n  | n1 < n2   = polCero\n  | otherwise = consPol n3 a3 (cociente p3 q)\n  where n1 = grado p\n        a1 = coefLider p\n        n2 = grado q\n        a2 = coefLider q\n        n3 = n1-n2\n        a3 = a1\/a2\n        p3 = restaPol p (multPorTerm (creaTermino n3 a3) q)\n\nresto :: (Fractional a, Eq a) =>\n         Polinomio a -> Polinomio a -> Polinomio a\nresto p q = restaPol p (multPol (cociente p q) q)\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom src.Pol_Crea_termino import creaTermino\nfrom src.Pol_Multiplicacion_de_un_polinomio_por_un_numero import multEscalar\nfrom src.Pol_Producto_polinomios import multPol, multPorTerm\nfrom src.Pol_Resta_de_polinomios import restaPol\nfrom src.TAD.Polinomio import Polinomio, coefLider, consPol, grado, polCero\n\n\ndef cociente(p: Polinomio[float], q: Polinomio[float]) -> Polinomio[float]:\n    n1 = grado(p)\n    a1 = coefLider(p)\n    n2 = grado(q)\n    a2 = coefLider(q)\n    n3 = n1 - n2\n    a3 = a1 \/ a2\n    p3 = restaPol(p, multPorTerm(creaTermino(n3, a3), q))\n    if n2 == 0:\n        return multEscalar(1 \/ a2, p)\n    if n1 < n2:\n        return polCero()\n    return consPol(n3, a3, cociente(p3, q))\n\ndef resto(p: Polinomio[float], q: Polinomio[float]) -> Polinomio[float]:\n    return restaPol(p, multPol(cociente(p, q), q))\n<\/pre>\n<p><a name=\"ej4\"><\/a><\/p>\n<h3>4. Divisibilidad de polinomios<\/h3>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3KwqXYu\">tipo abstracto de los polinomios<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   divisiblePol :: (Fractional a, Eq a) =>\n                   Polinomio a -> Polinomio a -> Bool\n<\/pre>\n<p>tal que <code>divisiblePol p q<\/code> se verifica si el polinomio <code>p<\/code> es divisible por el polinomio <code>q<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> pol1 = consPol 2 8 (consPol 1 14 (consPol 0 3 polCero))\n   \u03bb> pol1\n   8*x^2 + 14*x + 3\n   \u03bb> pol2 = consPol 1 2 (consPol 0 3 polCero)\n   \u03bb> pol2\n   2*x + 3\n   \u03bb> pol3 = consPol 2 6 (consPol 1 2 polCero)\n   \u03bb> pol3\n   6*x^2 + 2*x\n   \u03bb> divisiblePol pol1 pol2\n   True\n   \u03bb> divisiblePol pol1 pol3\n   False\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Polinomio (Polinomio, polCero, consPol, esPolCero)\nimport Pol_Division_de_polinomios (resto)\n\ndivisiblePol :: (Fractional a, Eq a) =>\n                Polinomio a -> Polinomio a -> Bool\ndivisiblePol p q = esPolCero (resto p q)\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom src.Pol_Division_de_polinomios import resto\nfrom src.TAD.Polinomio import Polinomio, consPol, esPolCero, polCero\n\n\ndef divisiblePol(p: Polinomio[float], q: Polinomio[float]) -> bool:\n    return esPolCero(resto(p, q))\n<\/pre>\n<p><a name=\"ej5\"><\/a><\/p>\n<h3>5. M\u00e9todo de Horner del valor de un polinomio<\/h3>\n<p>El m\u00e9todo de Horner para calcular el valor de un  polinomio se basa en representarlo de una forma forma alernativa. Por ejemplo, para calcular el valor de<\/p>\n<pre lang=\"text\">\n   a*x^5 + b*x^4 + c*x^3 + d*x^2 + e*x + f\n<\/pre>\n<p>se representa como<\/p>\n<pre lang=\"text\">\n  (((((0 * x + a) * x + b) * x + c) * x + d) * x + e) * x + f\n<\/pre>\n<p>y se eval\u00faa de dentro hacia afuera; es decir,<\/p>\n<pre lang=\"text\">\n  v(0) = 0\n  v(1) = v(0)*x+a = 0*x+a = a\n  v(2) = v(1)*x+b = a*x+b\n  v(3) = v(2)*x+c = (a*x+b)*x+c = a*x^2+b*x+c\n  v(4) = v(3)*x+d = (a*x^2+b*x+c)*x+d = a*x^3+b*x^2+c*x+d\n  v(5) = v(4)*x+e = (a*x^3+b*x^2+c*x+d)*x+e = a*x^4+b*x^3+c*x^2+d*x+e\n  v(6) = v(5)*x+f = (a*x^4+b*x^3+c*x^2+d*x+e)*x+f = a*x^5+b*x^4+c*x^3+d*x^2+e*x+f\n<\/pre>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3KwqXYu\">tipo abstracto de los polinomios<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   horner :: (Num a, Eq a) => Polinomio a -> a -> a\n<\/pre>\n<p>tal que <code>horner p x<\/code> es el valor del polinomio <code>p<\/code> al sustituir su variable por el n\u00famero <code>x<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> pol1 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))\n   \u03bb> pol1\n   x^5 + 5*x^2 + 4*x\n   \u03bb> horner pol1 0\n   0\n   \u03bb> horner pol1 1\n   10\n   \u03bb> horner pol1 1.5\n   24.84375\n   \u03bb> import Data.Ratio\n   \u03bb> horner pol1 (3%2)\n   795 % 32\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Polinomio (Polinomio, polCero, consPol)\nimport Pol_Transformaciones_polinomios_densas (polinomioAdensa)\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nhorner :: (Num a, Eq a) => Polinomio a -> a -> a\nhorner p x = hornerAux (polinomioAdensa p) 0\n  where hornerAux [] v     = v\n        hornerAux (a:as) v = hornerAux as (v*x+a)\n\n-- El c\u00e1lculo de (horner pol1 2) es el siguiente\n--    horner pol1 2\n--    = hornerAux [1,0,0,5,4,0] 0\n--    = hornerAux   [0,0,5,4,0] ( 0*2+1) = hornerAux   [0,0,5,4,0] 1\n--    = hornerAux     [0,5,4,0] ( 1*2+0) = hornerAux     [0,5,4,0] 2\n--    = hornerAux       [5,4,0] ( 2*2+0) = hornerAux       [5,4,0] 4\n--    = hornerAux         [4,0] ( 4*2+5) = hornerAux         [4,0] 13\n--    = hornerAux           [0] (13*2+4) = hornerAux           [0] 30\n--    = hornerAux            [] (30*2+0) = hornerAux            [] 60\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nhorner2 :: (Num a, Eq a) => Polinomio a -> a -> a\nhorner2 p x = foldl (\\a b -> a*x + b) 0 (polinomioAdensa p)\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom functools import reduce\n\nfrom src.Pol_Transformaciones_polinomios_densas import polinomioAdensa\nfrom src.TAD.Polinomio import Polinomio, consPol, polCero\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef horner(p: Polinomio[float], x: float) -> float:\n    def hornerAux(ys: list[float], v: float) -> float:\n        if not ys:\n            return v\n        return hornerAux(ys[1:], v * x + ys[0])\n\n    return hornerAux(polinomioAdensa(p), 0)\n\n# El c\u00e1lculo de horner(pol1, 2) es el siguiente\n#    horner pol1 2\n#    = hornerAux [1,0,0,5,4,0] 0\n#    = hornerAux   [0,0,5,4,0] ( 0*2+1) = hornerAux   [0,0,5,4,0] 1\n#    = hornerAux     [0,5,4,0] ( 1*2+0) = hornerAux     [0,5,4,0] 2\n#    = hornerAux       [5,4,0] ( 2*2+0) = hornerAux       [5,4,0] 4\n#    = hornerAux         [4,0] ( 4*2+5) = hornerAux         [4,0] 13\n#    = hornerAux           [0] (13*2+4) = hornerAux           [0] 30\n#    = hornerAux            [] (30*2+0) = hornerAux            [] 60\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef horner2(p: Polinomio[float], x: float) -> float:\n    return reduce(lambda a, b: a * x + b, polinomioAdensa(p) , 0.0)\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas sobre el tipo abstracto de datos de los polinomios 1. Integral definida de un polinomio 2. Multiplicaci\u00f3n de un polinomio por un n\u00famero 3. Divisi\u00f3n de polinomios 4. Divisibilidad de polinomios 5. M\u00e9todo de Horner del valor de un polinomio A continuaci\u00f3n se&#8230;<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false},"categories":[337],"tags":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_likes_enabled":false,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7934"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/comments?post=7934"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7934\/revisions"}],"predecessor-version":[{"id":7935,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7934\/revisions\/7935"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7934"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7934"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7934"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}