{"id":5688,"date":"2017-02-08T16:35:00","date_gmt":"2017-02-08T15:35:00","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=5688"},"modified":"2017-02-08T16:35:00","modified_gmt":"2017-02-08T15:35:00","slug":"i1m2016-matrices-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2016-matrices-en-haskell\/","title":{"rendered":"I1M2016: Matrices en Haskell"},"content":{"rendered":"<p>En la clase de hoy del curso de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-16\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> se ha estudiado c\u00f3mo trabajar con tablas en Haskell usando el m\u00f3dulo Data.Array.<\/p>\n<p>En la primera parte se ha explicado <a href=\"https:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-16\/temas\/tema-18.html#el-tipo-predefinido-de-las-tablas-arrays\">El tipo predefinido de las tablas (&#8220;arrays&#8221;)<\/a> se han estudiado las funciones sobre \u00edndices (range, index, inRange, rangeSize) y sobre tablas (array, (!), bounds, indices, elems, assocs, (\/\/), listArray y accumArray). Tambi\u00e9n se han estudiado ejemplos de definiciones con dichas funciones.<\/p>\n<p>En la segunda parte se han comentado las soluciones de los siguientes ejercicios de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2016G4\/images\/b\/b9\/Rel_15.hs\">Relaci\u00f3n 15<\/a>:<\/p>\n<p><!--more--><\/p>\n<pre lang=\"haskell\">\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 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<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la clase de hoy del curso de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas se ha estudiado c\u00f3mo trabajar con tablas en Haskell usando el m\u00f3dulo Data.Array. En la primera parte se ha explicado El tipo predefinido de las tablas (&#8220;arrays&#8221;) se han estudiado las funciones sobre \u00edndices (range, index, inRange, rangeSize) y sobre&#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":[260],"tags":[270,313],"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\/5688"}],"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=5688"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5688\/revisions"}],"predecessor-version":[{"id":5689,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5688\/revisions\/5689"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=5688"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=5688"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=5688"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}