{"id":6486,"date":"2019-02-15T13:21:08","date_gmt":"2019-02-15T12:21:08","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=6486"},"modified":"2019-02-15T13:21:08","modified_gmt":"2019-02-15T12:21:08","slug":"i1m2018-ejercicios-sobre-vectores-y-matrices-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2018-ejercicios-sobre-vectores-y-matrices-en-haskell\/","title":{"rendered":"I1M2018: Ejercicios sobre vectores y matrices en Haskell"},"content":{"rendered":"<p>En la primera parte de la clase hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-18\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentado las soluciones de los ejercicios sobre vectores y matrices en Haskell de la relaci\u00f3n 15.<\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Introducci\u00f3n                                                       --\n-- ---------------------------------------------------------------------\n\n-- El objetivo de esta relaci\u00f3n es hacer ejercicios sobre vectores y\n-- matrices con el tipo de las tablas, definido en el m\u00f3dulo\n-- Data.Array y explicado en el tema 18 que se encuentra en\n--    http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-18\/temas\/tema-18.html\n \n-- ---------------------------------------------------------------------\n-- Importaci\u00f3n de librer\u00edas                                           --\n-- ---------------------------------------------------------------------\n\nimport Data.Array\n\n-- ---------------------------------------------------------------------\n-- Tipos de los vectores y de las matrices                            --\n-- ---------------------------------------------------------------------\n\n-- Los vectores son tablas cuyos \u00edndices son n\u00fameros naturales.\ntype Vector a = Array Int a\n \n-- Las matrices son tablas cuyos \u00edndices son pares de n\u00fameros\n-- naturales. \ntype Matriz a = Array (Int,Int) a\n\n-- ---------------------------------------------------------------------\n-- Operaciones b\u00e1sicas con matrices                                   --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 1. Definir la funci\u00f3n\n--    listaVector :: Num a => [a] -> Vector a\n-- tal que (listaVector xs) es el vector correspondiente a la lista\n-- xs. Por ejemplo, \n--    ghci> listaVector [3,2,5]\n--    array (1,3) [(1,3),(2,2),(3,5)]\n-- ---------------------------------------------------------------------\n\nlistaVector :: Num a => [a] -> Vector a\nlistaVector xs = listArray (1,n) xs\n  where n = length xs\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2. Definir la funci\u00f3n\n--    listaMatriz :: Num a => [[a]] -> Matriz a\n-- tal que (listaMatriz xss) es la matriz cuyas filas son los elementos\n-- de xss. Por ejemplo,\n--    ghci> listaMatriz [[1,3,5],[2,4,7]]\n--    array ((1,1),(2,3)) [((1,1),1),((1,2),3),((1,3),5),\n--                         ((2,1),2),((2,2),4),((2,3),7)]\n-- ---------------------------------------------------------------------\n\nlistaMatriz :: Num a => [[a]] -> Matriz a\nlistaMatriz xss = listArray ((1,1),(m,n)) (concat xss)\n  where m = length xss\n        n = length (head xss)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3. Definir la funci\u00f3n\n--    numFilas :: Num a => Matriz a -> Int\n-- tal que (numFilas m) es el n\u00famero de filas de la matriz m. Por\n-- ejemplo,\n--    numFilas (listaMatriz [[1,3,5],[2,4,7]])  ==  2\n-- ---------------------------------------------------------------------\n\nnumFilas :: Num a => Matriz a -> Int\nnumFilas = fst . snd . bounds\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4. Definir la funci\u00f3n\n--    numColumnas :: Num a => Matriz a -> Int\n-- tal que (numColumnas m) es el n\u00famero de columnas de la matriz\n-- m. Por ejemplo,\n--    numColumnas (listaMatriz [[1,3,5],[2,4,7]])  ==  3\n-- ---------------------------------------------------------------------\n\nnumColumnas :: Num a => Matriz a -> Int\nnumColumnas = snd . snd . bounds\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5. Definir la funci\u00f3n\n--    dimension :: Num a => Matriz a -> (Int,Int)\n-- tal que (dimension m) es la dimensi\u00f3n de la matriz m. Por ejemplo, \n--    dimension (listaMatriz [[1,3,5],[2,4,7]])  ==  (2,3)\n-- ---------------------------------------------------------------------\n\ndimension :: Num a => Matriz a -> (Int,Int)\ndimension = snd . bounds\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6. Definir la funci\u00f3n\n--    separa :: Int -> [a] -> [[a]]\n-- tal que (separa n xs) es la lista obtenida separando los elementos de\n-- xs en grupos de n elementos (salvo el \u00faltimo que puede tener menos de\n-- n elementos). Por ejemplo, \n--    separa 3 [1..11]  ==  [[1,2,3],[4,5,6],[7,8,9],[10,11]]\n-- ---------------------------------------------------------------------\n\nsepara :: Int -> [a] -> [[a]]\nsepara _ [] = []\nsepara n xs = take n xs : separa n (drop n xs)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 7. Definir la funci\u00f3n\n--    matrizLista :: Num a => Matriz a -> [[a]]\n-- tal que (matrizLista x) es la lista de las filas de la matriz x. Por\n-- ejemplo, \n--    ghci> let m = listaMatriz [[5,1,0],[3,2,6]]\n--    ghci> m\n--    array ((1,1),(2,3)) [((1,1),5),((1,2),1),((1,3),0),\n--                         ((2,1),3),((2,2),2),((2,3),6)]\n--    ghci> matrizLista m\n--    [[5,1,0],[3,2,6]]\n-- ---------------------------------------------------------------------\n\nmatrizLista :: Num a => Matriz a -> [[a]]\nmatrizLista p = separa (numColumnas p) (elems p)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 8. Definir la funci\u00f3n\n--    vectorLista :: Num a => Vector a -> [a]\n-- tal que (vectorLista x) es la lista de los elementos del vector\n-- v. Por ejemplo, \n--    ghci> let v = listaVector [3,2,5]\n--    ghci> v\n--    array (1,3) [(1,3),(2,2),(3,5)]\n--    ghci> vectorLista v\n--    [3,2,5]\n-- ---------------------------------------------------------------------\n\nvectorLista :: Num a => Vector a -> [a]\nvectorLista = elems \n\n-- ---------------------------------------------------------------------\n-- Suma de matrices                                                   --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 9. Definir la funci\u00f3n\n--    sumaMatrices:: Num a => Matriz a -> Matriz a -> Matriz a\n-- tal que (sumaMatrices x y) es la suma de las matrices x e y. Por\n-- ejemplo, \n--    ghci> let m1 = listaMatriz [[5,1,0],[3,2,6]]\n--    ghci> let m2 = listaMatriz [[4,6,3],[1,5,2]]\n--    ghci> matrizLista (sumaMatrices m1 m2)\n--    [[9,7,3],[4,7,8]]\n-- ---------------------------------------------------------------------\n\n-- 1\u00aa definici\u00f3n\nsumaMatrices :: Num a => Matriz a -> Matriz a -> Matriz a\nsumaMatrices p q = \n  array ((1,1),(m,n)) [((i,j),p!(i,j)+q!(i,j))  \n                      | i <- [1..m], j <- [1..n]]\n  where (m,n) = dimension p\n\n-- 2\u00aa definici\u00f3n\nsumaMatrices2 :: Num a => Matriz a -> Matriz a -> Matriz a\nsumaMatrices2 p q = \n  listArray (bounds p) (zipWith (+) (elems p) (elems q))\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 10. Definir la funci\u00f3n\n--    filaMat :: Num a => Int -> Matriz a -> Vector a\n-- tal que (filaMat i p) es el vector correspondiente a la fila i-\u00e9sima\n-- de la matriz p. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,5,7]]\n--    ghci> filaMat 2 p\n--    array (1,3) [(1,3),(2,2),(3,6)]\n--    ghci> vectorLista (filaMat 2 p)\n--    [3,2,6]\n-- ---------------------------------------------------------------------\n\nfilaMat :: Num a => Int -> Matriz a -> Vector a\nfilaMat i p = array (1,n) [(j,p!(i,j)) | j <- [1..n]]\n  where n = numColumnas p\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 11. Definir la funci\u00f3n\n--    columnaMat :: Num a => Int -> Matriz a -> Vector a\n-- tal que (columnaMat j p) es el vector correspondiente a la columna\n-- j-\u00e9sima de la matriz p. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,5,7]]\n--    ghci> columnaMat 2 p\n--    array (1,3) [(1,1),(2,2),(3,5)]\n--    ghci> vectorLista (columnaMat 2 p)\n--    [1,2,5]\n-- ---------------------------------------------------------------------\n\ncolumnaMat :: Num a => Int -> Matriz a -> Vector a\ncolumnaMat j p = array (1,m) [(i,p!(i,j)) | i <- [1..m]]\n  where m = numFilas p\n\n-- ---------------------------------------------------------------------\n-- Producto de matrices                                               --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 12. Definir la funci\u00f3n\n--    prodEscalar :: Num a => Vector a -> Vector a -> a\n-- tal que (prodEscalar v1 v2) es el producto escalar de los vectores v1\n-- y v2. Por ejemplo,\n--    ghci> let v = listaVector [3,1,10]\n--    ghci> prodEscalar v v\n--    110\n-- ---------------------------------------------------------------------\n\n-- 1\u00aa soluci\u00f3n\nprodEscalar :: Num a => Vector a -> Vector a -> a\nprodEscalar v1 v2 = \n  sum [i*j | (i,j) <- zip (elems v1) (elems v2)]\n\n-- 2\u00aa soluci\u00f3n\nprodEscalar2 :: Num a => Vector a -> Vector a -> a\nprodEscalar2 v1 v2 = \n  sum (zipWith (*) (elems v1) (elems v2))\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 13. Definir la funci\u00f3n\n--    prodMatrices:: Num a => Matriz a -> Matriz a -> Matriz a\n-- tal que (prodMatrices p q) es el producto de las matrices p y q. Por\n-- ejemplo, \n--    ghci> let p = listaMatriz [[3,1],[2,4]]\n--    ghci> prodMatrices p p\n--    array ((1,1),(2,2)) [((1,1),11),((1,2),7),((2,1),14),((2,2),18)]\n--    ghci> matrizLista (prodMatrices p p)\n--    [[11,7],[14,18]]\n--    ghci> let q = listaMatriz [[7],[5]]\n--    ghci> prodMatrices p q\n--    array ((1,1),(2,1)) [((1,1),26),((2,1),34)]\n--    ghci> matrizLista (prodMatrices p q)\n--    [[26],[34]]\n-- ---------------------------------------------------------------------\n\nprodMatrices :: Num a => Matriz a -> Matriz a -> Matriz a\nprodMatrices p q = \n  array ((1,1),(m,n))\n        [((i,j), prodEscalar (filaMat i p) (columnaMat j q))\n        | i <- [1..m], j <- [1..n]]\n  where m = numFilas p\n        n = numColumnas q\n\n-- ---------------------------------------------------------------------\n-- Matriz identidad                                                   --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 14. Definir la funci\u00f3n\n--    identidad :: Num a => Int -> Matriz a\n-- tal que (identidad n) es la matriz identidad de orden n. Por ejemplo, \n--    ghci> identidad 3\n--    array ((1,1),(3,3)) [((1,1),1),((1,2),0),((1,3),0),\n--                         ((2,1),0),((2,2),1),((2,3),0),\n--                         ((3,1),0),((3,2),0),((3,3),1)]\n-- ---------------------------------------------------------------------\n\nidentidad :: Num a => Int -> Matriz a\nidentidad n =     \n  array ((1,1),(n,n))\n        [((i,j),f i j) | i <- [1..n], j <- [1..n]]\n  where f i j | i == j    = 1\n              | otherwise = 0\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 15. Definir la funci\u00f3n\n--    potencia :: Num a => Matriz a -> Int -> Matriz a\n-- tal que (potencia p n) es la potencia n-\u00e9sima de la matriz cuadrada\n-- p. Por ejemplo, si q es la matriz definida por\n--    q1 :: Matriz Int\n--    q1 = listArray ((1,1),(2,2)) [1,1,1,0] \n-- entonces\n--    ghci> potencia q1 2\n--    array ((1,1),(2,2)) [((1,1),2),((1,2),1),((2,1),1),((2,2),1)]\n--    ghci> potencia q1 3\n--    array ((1,1),(2,2)) [((1,1),3),((1,2),2),((2,1),2),((2,2),1)]\n--    ghci> potencia q1 4\n--    array ((1,1),(2,2)) [((1,1),5),((1,2),3),((2,1),3),((2,2),2)]\n-- \u00bfQu\u00e9 relaci\u00f3n hay entre las potencias de la matriz q y la sucesi\u00f3n de\n-- Fibonacci? \n-- ---------------------------------------------------------------------\n\nq1 :: Matriz Int\nq1 = listArray ((1,1),(2,2)) [1,1,1,0] \n\npotencia :: Num a => Matriz a -> Int -> Matriz a\npotencia p 0 = identidad n\n  where (_,(n,_)) = bounds p\npotencia p n = prodMatrices p (potencia p (n-1))\n\n-- ---------------------------------------------------------------------\n-- Traspuestas                                                        --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 16. Definir la funci\u00f3n\n--    traspuesta :: Num a => Matriz a -> Matriz a\n-- tal que (traspuesta p) es la traspuesta de la matriz p. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\n--    ghci> traspuesta p\n--    array ((1,1),(3,2)) [((1,1),5),((1,2),3),\n--                         ((2,1),1),((2,2),2),\n--                         ((3,1),0),((3,2),6)]\n--    ghci> matrizLista (traspuesta p)\n--    [[5,3],[1,2],[0,6]]\n-- ---------------------------------------------------------------------\n\ntraspuesta :: Num a => Matriz a -> Matriz a\ntraspuesta p = \n  array ((1,1),(n,m))\n        [((i,j), p!(j,i)) | i <- [1..n], j <- [1..m]]\n  where (m,n) = dimension p\n\n-- ---------------------------------------------------------------------\n-- Submatriz                                                          --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Tipos de matrices                                                  --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 17. Definir la funci\u00f3n\n--    esCuadrada :: Num a => Matriz a -> Bool\n-- tal que (esCuadrada p) se verifica si la matriz p es cuadrada. Por\n-- ejemplo, \n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\n--    ghci> esCuadrada p\n--    False\n--    ghci> let q = listaMatriz [[5,1],[3,2]]\n--    ghci> esCuadrada q\n--    True\n-- ---------------------------------------------------------------------\n\nesCuadrada :: Num a => Matriz a -> Bool\nesCuadrada x = numFilas x == numColumnas x\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 18. Definir la funci\u00f3n\n--    esSimetrica :: (Num a, Eq a) => Matriz a -> Bool\n-- tal que (esSimetrica p) se verifica si la matriz p es sim\u00e9trica. Por\n-- ejemplo, \n--    ghci> let p = listaMatriz [[5,1,3],[1,4,7],[3,7,2]]\n--    ghci> esSimetrica p\n--    True\n--    ghci> let q = listaMatriz [[5,1,3],[1,4,7],[3,4,2]]\n--    ghci> esSimetrica q\n--    False\n-- ---------------------------------------------------------------------    \n\nesSimetrica :: (Num a, Eq a) => Matriz a -> Bool\nesSimetrica x = x == traspuesta x\n\n-- ---------------------------------------------------------------------\n-- Diagonales de una matriz                                           --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 19. Definir la funci\u00f3n\n--    diagonalPral :: Num a => Matriz a -> Vector a\n-- tal que (diagonalPral p) es la diagonal principal de la matriz p. Por\n-- ejemplo, \n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\n--    ghci> diagonalPral p\n--    array (1,2) [(1,5),(2,2)]\n--    ghci> vectorLista (diagonalPral p)\n--    [5,2]\n-- ---------------------------------------------------------------------\n\ndiagonalPral :: Num a => Matriz a -> Vector a\ndiagonalPral p = array (1,n) [(i,p!(i,i)) | i <- [1..n]]\n  where n = min (numFilas p) (numColumnas p)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 20. Definir la funci\u00f3n\n--    diagonalSec :: Num a => Matriz a -> Vector a\n-- tal que (diagonalSec p) es la diagonal secundaria de la matriz p. Por\n-- ejemplo, \n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\n--    ghci> diagonalSec p\n--    array (1,2) [(1,1),(2,3)]\n--    ghci> vectorLista (diagonalSec p)\n--    [1,3]\n--    ghci> let q = traspuesta p\n--    ghci> matrizLista q\n--    [[5,3],[1,2],[0,6]]\n--    ghci> vectorLista (diagonalSec q)\n--    [3,1]\n-- ---------------------------------------------------------------------\n\ndiagonalSec :: Num a => Matriz a -> Vector a\ndiagonalSec p = array (1,n) [(i,p!(i,n+1-i)) | i <- [1..n]]\n  where n = min (numFilas p) (numColumnas p)\n\n-- ---------------------------------------------------------------------\n-- Submatrices                                                        --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 21. Definir la funci\u00f3n\n--    submatriz :: Num a => Int -> Int -> Matriz a -> Matriz a\n-- tal que (submatriz i j p) es la matriz obtenida a partir de la p\n-- eliminando la fila i y la columna j. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> submatriz 2 3 p\n--    array ((1,1),(2,2)) [((1,1),5),((1,2),1),((2,1),4),((2,2),6)]\n--    ghci> matrizLista (submatriz 2 3 p)\n--    [[5,1],[4,6]]\n-- ---------------------------------------------------------------------\n\nsubmatriz :: Num a => Int -> Int -> Matriz a -> Matriz a\nsubmatriz i j p = \n  array ((1,1), (m-1,n -1))\n        [((k,l), p ! f k l) | k <- [1..m-1], l <- [1.. n-1]]\n  where (m,n) = dimension p\n        f k l | k < i  &#038;&#038; l < j  = (k,l)\n              | k >= i && l < j  = (k+1,l)\n              | k < i  &#038;&#038; l >= j = (k,l+1)\n              | otherwise        = (k+1,l+1)\n\n-- ---------------------------------------------------------------------\n-- Determinante                                                       --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 22. Definir la funci\u00f3n\n--    determinante:: Matriz Double -> Double\n-- tal que (determinante p) es el determinante de la matriz p. Por\n-- ejemplo, \n--    ghci> determinante (listArray ((1,1),(3,3)) [2,0,0,0,3,0,0,0,1])\n--    6.0\n--    ghci> determinante (listArray ((1,1),(3,3)) [1..9])\n--    0.0\n--    ghci> determinante (listArray ((1,1),(3,3)) [2,1,5,1,2,3,5,4,2])\n--    -33.0\n-- ---------------------------------------------------------------------\n\ndeterminante :: Matriz Double -> Double\ndeterminante p \n  | (m,n) == (1,1) = p!(1,1)\n  | otherwise = \n      sum [((-1)^(i+1))*(p!(i,1))*determinante (submatriz i 1 p)\n          | i <- [1..m]]\n  where (_,(m,n)) = bounds p\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la primera parte de la clase hoy de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos comentado las soluciones de los ejercicios sobre vectores y matrices en Haskell de la relaci\u00f3n 15. Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<\/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":[320],"tags":[270,321],"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\/6486"}],"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=6486"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/6486\/revisions"}],"predecessor-version":[{"id":6487,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/6486\/revisions\/6487"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=6486"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=6486"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=6486"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}