{"id":7929,"date":"2023-04-29T08:42:20","date_gmt":"2023-04-29T06:42:20","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7929"},"modified":"2023-04-29T08:45:53","modified_gmt":"2023-04-29T06:45:53","slug":"29-abr-23","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/29-abr-23\/","title":{"rendered":"La semana en Exercitium (29 de abril 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 TAD (tipo abstracto de datos) de los polinomios.<\/p>\n<ul>\n<li><a href=\"#ej1\">1. Construcci\u00f3n de t\u00e9rminos<\/a><\/li>\n<li><a href=\"#ej2\">2. T\u00e9rmino l\u00edder de un polinomio<\/a><\/li>\n<li><a href=\"#ej3\">3. Suma de polinomios<\/a><\/li>\n<li><a href=\"#ej4\">4. Producto de polinomios<\/a><\/li>\n<li><a href=\"#ej5\">5. Valor de un polinomio en un punto<\/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. Construcci\u00f3n de t\u00e9rminos<\/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   creaTermino :: (Num a, Eq a) => Int -> a -> Polinomio a\n<\/pre>\n<p>tal que <code>creaTermino n a<\/code> es el t\u00e9rmino <code>a\u00b7x^n<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   creaTermino 2 5  ==  5*x^2\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)\n\ncreaTermino :: (Num a, Eq a) => Int -> a -> Polinomio a\ncreaTermino n a = consPol n a polCero\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 hypothesis import given\nfrom hypothesis import strategies as st\n\nfrom src.TAD.Polinomio import (Polinomio, consPol, polCero)\n\nA = TypeVar('A', int, float, complex)\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef creaTermino(n: int, a: A) -> Polinomio[A]:\n    return consPol(n, a, polCero())\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef creaTermino2(n: int, a: A) -> Polinomio[A]:\n    r: Polinomio[A] = polCero()\n    return r.consPol(n, a)\n\n# Equivalencia de las definiciones\n# ================================\n\n# La propiedad es\n@given(st.integers(min_value=0, max_value=9),\n       st.integers(min_value=-9, max_value=9))\ndef test_creaTermino(n: int, a: int) -> None:\n    assert creaTermino(n, a) == creaTermino2(n, a)\n\n# La comprobaci\u00f3n es\n#    > poetry run pytest -q Pol_Crea_termino.py\n#    1 passed in 0.21s\n<\/pre>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. T\u00e9rmino l\u00edder de un polinomio<\/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   termLider :: (Num a, Eq a) => Polinomio a -> Polinomio a\n<\/pre>\n<p>tal que <code>termLider p<\/code> es el t\u00e9rmino l\u00edder del polinomio <code>p<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ejPol = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))\n   \u03bb> ejPol\n   x^5 + 5*x^2 + 4*x\n   \u03bb> termLider ejPol\n   x^5\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, coefLider, grado, polCero, consPol)\nimport Pol_Crea_termino (creaTermino)\n\ntermLider :: (Num a, Eq a) => Polinomio a -> Polinomio a\ntermLider p = creaTermino (grado p) (coefLider p)\n\n-- La funci\u00f3n creaTermino est\u00e1 definida en el ejercicio\n-- \"Construcci\u00f3n de t\u00e9rminos\" que se encuentra en\n-- https:\/\/bit.ly\/3GXteuH\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 hypothesis import given\n\nfrom src.Pol_Crea_termino import creaTermino\nfrom src.TAD.Polinomio import (Polinomio, coefLider, consPol, grado, polCero,\n                               polinomioAleatorio)\n\nA = TypeVar('A', int, float, complex)\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef termLider(p: Polinomio[A]) -> Polinomio[A]:\n    return creaTermino(grado(p), coefLider(p))\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef termLider2(p: Polinomio[A]) -> Polinomio[A]:\n    return creaTermino(p.grado(), p.coefLider())\n\n# La funci\u00f3n creaTermino est\u00e1 definida en el ejercicio\n# \"Construcci\u00f3n de t\u00e9rminos\" que se encuentra en\n# https:\/\/bit.ly\/3GXteuH\n\n# Equivalencia de las definiciones\n# ================================\n\n# La propiedad es\n@given(p=polinomioAleatorio())\ndef test_termLider(p: Polinomio[int]) -> None:\n    assert termLider(p) == termLider2(p)\n\n# La comprobaci\u00f3n es\n#    > poetry run pytest -q Pol_Termino_lider.py\n#    1 passed in 0.21s\n<\/pre>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. Suma 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   sumaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a\n<\/pre>\n<p>tal que (sumaPol p q) es la suma de los polinomios p y q. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))\n   \u03bb> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))\n   \u03bb> ejPol1\n   3*x^4 + -5*x^2 + 3\n   \u03bb> ejPol2\n   x^5 + 5*x^2 + 4*x\n   \u03bb> sumaPol ejPol1 ejPol2\n   x^5 + 3*x^4 + 4*x + 3\n<\/pre>\n<p>Comprobar con QuickCheck las siguientes propiedades:<\/p>\n<ul>\n<li><code>polCero<\/code> es el elemento neutro de la suma.<\/li>\n<li>la suma es conmutativa.<\/li>\n<\/ul>\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 Test.QuickCheck\n\nsumaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a\nsumaPol p q\n  | esPolCero p = q\n  | esPolCero q = p\n  | n1 > n2      = consPol n1 a1 (sumaPol r1 q)\n  | n1 < n2      = consPol n2 a2 (sumaPol p r2)\n  | otherwise    = consPol n1 (a1+a2) (sumaPol r1 r2)\n  where (n1, a1, r1) = (grado p, coefLider p, restoPol p)\n        (n2, a2, r2) = (grado q, coefLider q, restoPol q)\n\n-- Propiedad. El polinomio cero es el elemento neutro de la suma.\nprop_neutroSumaPol :: Polinomio Int -> Bool\nprop_neutroSumaPol p =\n  sumaPol polCero p == p\n\n-- Comprobaci\u00f3n con QuickCheck.\n--    \u03bb> quickCheck prop_neutroSumaPol\n--    OK, passed 100 tests.\n\n-- Propiedad. La suma es conmutativa.\nprop_conmutativaSuma :: Polinomio Int -> Polinomio Int -> Bool\nprop_conmutativaSuma p q =\n  sumaPol p q == sumaPol q p\n\n-- Comprobaci\u00f3n:\n--    \u03bb> quickCheck prop_conmutativaSuma\n--    OK, passed 100 tests.\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 hypothesis import given\n\nfrom src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,\n                               polCero, polinomioAleatorio, restoPol)\n\nA = TypeVar('A', int, float, complex)\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef sumaPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:\n    if esPolCero(p):\n        return q\n    if esPolCero(q):\n        return p\n    n1, a1, r1 = grado(p), coefLider(p), restoPol(p)\n    n2, a2, r2 = grado(q), coefLider(q), restoPol(q)\n    if n1 > n2:\n        return consPol(n1, a1, sumaPol(r1, q))\n    if n1 < n2:\n        return consPol(n2, a2, sumaPol(p, r2))\n    return consPol(n1, a1 + a2, sumaPol(r1, r2))\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef sumaPol2(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:\n    if p.esPolCero():\n        return q\n    if q.esPolCero():\n        return p\n    n1, a1, r1 = p.grado(), p.coefLider(), p.restoPol()\n    n2, a2, r2 = q.grado(), q.coefLider(), q.restoPol()\n    if n1 > n2:\n        return sumaPol(r1, q).consPol(n1, a1)\n    if n1 < n2:\n        return sumaPol(p, r2).consPol(n2, a2)\n    return sumaPol(r1, r2).consPol(n1, a1 + a2)\n\n# Equivalencia de las definiciones\n# ================================\n\n# La propiedad es\n@given(p=polinomioAleatorio(), q=polinomioAleatorio())\ndef test_sumaPol(p: Polinomio[int], q: Polinomio[int]) -> None:\n    assert sumaPol(p, q) == sumaPol2(p,q)\n\n# Propiedad. El polinomio cero es el elemento neutro de la suma.\n@given(p=polinomioAleatorio())\ndef test_neutroSumaPol(p: Polinomio[int]) -> None:\n    assert sumaPol(polCero(), p) == p\n    assert sumaPol(p, polCero()) == p\n\n# -- Propiedad. La suma es conmutativa.\n@given(p=polinomioAleatorio(), q=polinomioAleatorio())\ndef test_conmutativaSuma(p: Polinomio[int], q: Polinomio[int]) -> None:\n    assert sumaPol(p, q) == sumaPol(q, p)\n\n# La comprobaci\u00f3n es\n#    > poetry run pytest -v Pol_Suma_de_polinomios.py\n#    test_sumaPol PASSED\n#    test_neutroSumaPol PASSED\n#    test_conmutativaSuma PASSED\n<\/pre>\n<p><a name=\"ej4\"><\/a><\/p>\n<h3>4. Producto 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   multPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a\n<\/pre>\n<p>tal que <code>multPol p q<\/code> es el producto de los polinomios <code>p<\/code> y <code>q<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))\n   \u03bb> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))\n   \u03bb> ejPol1\n   3*x^4 + -5*x^2 + 3\n   \u03bb> ejPol2\n   x^5 + 5*x^2 + 4*x\n   \u03bb> multPol ejPol1 ejPol2\n   3*x^9 + -5*x^7 + 15*x^6 + 15*x^5 + -25*x^4 + -20*x^3 + 15*x^2 + 12*x\n<\/pre>\n<p>Comprobar con QuickCheck las siguientes propiedades<\/p>\n<ul>\n<li>El producto de polinomios es conmutativo.<\/li>\n<li>El producto es distributivo respecto de la suma.<\/li>\n<\/ul>\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 Pol_Termino_lider (termLider)\nimport Pol_Suma_de_polinomios (sumaPol)\nimport Test.QuickCheck\n\nmultPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a\nmultPol p q\n  | esPolCero p = polCero\n  | otherwise    = sumaPol (multPorTerm (termLider p) q)\n                           (multPol (restoPol p) q)\n\n-- (multPorTerm t p) es el producto del t\u00e9rmino t por el polinomio\n-- p. Por ejemplo,\n--    ejTerm                     ==  4*x\n--    ejPol2                     ==  x^5 + 5*x^2 + 4*x\n--    multPorTerm ejTerm ejPol2  ==  4*x^6 + 20*x^3 + 16*x^2\nmultPorTerm :: (Num t, Eq t) => Polinomio t -> Polinomio t -> Polinomio t\nmultPorTerm term pol\n  | esPolCero pol = polCero\n  | otherwise     = consPol (n+m) (a*b) (multPorTerm term r)\n  where n = grado term\n        a = coefLider term\n        m = grado pol\n        b = coefLider pol\n        r = restoPol pol\n\n-- El producto de polinomios es conmutativo.\nprop_conmutativaProducto :: Polinomio Int -> Polinomio Int -> Bool\nprop_conmutativaProducto p q =\n  multPol p q == multPol q p\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_conmutativaProducto\n--    OK, passed 100 tests.\n\n-- El producto es distributivo respecto de la suma.\nprop_distributivaProductoSuma :: Polinomio Int -> Polinomio Int\n                                 -> Polinomio Int -> Bool\nprop_distributivaProductoSuma p q r =\n  multPol p (sumaPol q r) == sumaPol (multPol p q) (multPol p r)\n\n-- Comprobaci\u00f3n:\n--    \u03bb> quickCheck prop_distributivaProductoSuma\n--    OK, passed 100 tests.\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 hypothesis import given\n\nfrom src.Pol_Suma_de_polinomios import sumaPol\nfrom src.Pol_Termino_lider import termLider\nfrom src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,\n                               polCero, polinomioAleatorio, restoPol)\n\nA = TypeVar('A', int, float, complex)\n\n# multPorTerm(t, p) es el producto del t\u00e9rmino t por el polinomio\n# p. Por ejemplo,\n#    ejTerm                     ==  4*x\n#    ejPol2                     ==  x^5 + 5*x^2 + 4*x\n#    multPorTerm ejTerm ejPol2  ==  4*x^6 + 20*x^3 + 16*x^2\ndef multPorTerm(term: Polinomio[A], pol: Polinomio[A]) -> Polinomio[A]:\n    n = grado(term)\n    a = coefLider(term)\n    m = grado(pol)\n    b = coefLider(pol)\n    r = restoPol(pol)\n    if esPolCero(pol):\n        return polCero()\n    return consPol(n + m, a * b, multPorTerm(term, r))\n\ndef multPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:\n    if esPolCero(p):\n        return polCero()\n    return sumaPol(multPorTerm(termLider(p), q),\n                   multPol(restoPol(p), q))\n\n# El producto de polinomios es conmutativo.\n@given(p=polinomioAleatorio(),\n       q=polinomioAleatorio())\ndef test_conmutativaProducto(p: Polinomio[int], q: Polinomio[int]) -> None:\n    assert multPol(p, q) == multPol(q, p)\n\n# El producto es distributivo respecto de la suma.\n@given(p=polinomioAleatorio(),\n       q=polinomioAleatorio(),\n       r=polinomioAleatorio())\ndef test_distributivaProductoSuma(p: Polinomio[int],\n                                  q: Polinomio[int],\n                                  r: Polinomio[int]) -> None:\n    assert multPol(p, sumaPol(q, r)) == sumaPol(multPol(p, q), multPol(p, r))\n\n# La comprobaci\u00f3n es\n#    > poetry run pytest -v Pol_Producto_polinomios.py\n#    test_conmutativaProducto PASSED\n#    test_distributivaProductoSuma PASSED\n<\/pre>\n<p><a name=\"ej5\"><\/a><\/p>\n<h3>5. Valor de un polinomio en un punto<\/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   valor :: (Num a, Eq a) => Polinomio a -> a -> a\n<\/pre>\n<p>tal que <code>valor p c<\/code> es el valor del polinomio <code>p<\/code> al sustituir su variable por <code>c<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ejPol = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))\n   \u03bb> ejPol\n   3*x^4 + -5*x^2 + 3\n   \u03bb> valor ejPol 0\n   3\n   \u03bb> valor ejPol 1\n   1\n   \u03bb> valor ejPol (-2)\n   31\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)\n\nvalor :: (Num a, Eq a) => Polinomio a -> a -> a\nvalor p c\n  | esPolCero p = 0\n  | otherwise   =  b*c^n + valor r c\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 valor(p: Polinomio[A], c: A) -> A:\n    if esPolCero(p):\n        return 0\n    n = grado(p)\n    b = coefLider(p)\n    r = restoPol(p)\n    return b*c**n + valor(r, c)\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas sobre el TAD (tipo abstracto de datos) de los polinomios. 1. Construcci\u00f3n de t\u00e9rminos 2. T\u00e9rmino l\u00edder de un polinomio 3. Suma de polinomios 4. Producto de polinomios 5. Valor de un polinomio en un punto A continuaci\u00f3n se muestran las soluciones.<\/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":[1],"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\/7929"}],"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=7929"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7929\/revisions"}],"predecessor-version":[{"id":7931,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7929\/revisions\/7931"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7929"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7929"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7929"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}