{"id":3311,"date":"2013-05-06T17:35:28","date_gmt":"2013-05-06T17:35:28","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3311"},"modified":"2013-05-06T17:35:28","modified_gmt":"2013-05-06T17:35:28","slug":"i1m2012-ejercicios-sobre-matrices-en-haskell-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2012-ejercicios-sobre-matrices-en-haskell-2\/","title":{"rendered":"I1M2012: Ejercicios sobre matrices en Haskell (2)"},"content":{"rendered":"<p>En la clase hoy  <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos continuando comentado las soluciones de los ejercicios sobre vectores y matrices en Haskell de la relaci\u00f3n 26. Concretamente, de los ejercicios para<\/p>\n<ul>\n<li> calcular la traspuesta de una matriz (ej. 14),\n<li> decidir si una matriz es cuadrada (ej. 15),\n<li> decidir si una matriz es sim\u00e9trica (ej. 16),\n<li> calcular la diagonal principal de una matriz (ej. 17),\n<li> calcular la diagonal secundaria de una matriz (ej. 18) y\n<li> calcular la submatriz obtenida suprimiendo una fila y una columna (ej. 19).\n<\/ul>\n<p>Los ejercicios de la relaci\u00f3n, junto con las soluciones de los 19 primeros, se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Introducci\u00f3n                                                       --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El objetivo de esta relaci\u00f3n es hacer ejercicios sobre vectores y\r\n-- matrices con el tipo de tablas de las tablas, definido en el m\u00f3dulo\r\n-- Data.Array y explicado en el tema 18 cuyas transparencias se\r\n-- encuentran en \r\n--    http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\/temas\/tema-18t.pdf\r\n-- Adem\u00e1s, en algunos ejemplos de usan matrices con n\u00fameros racionales.\r\n-- En Haskell, el n\u00famero racional x\/y se representa por x%y. El TAD de\r\n-- los n\u00fameros racionales est\u00e1 definido en el m\u00f3dulo Data.Ratio.\r\n \r\n-- ---------------------------------------------------------------------\r\n-- Importaci\u00f3n de librer\u00edas                                           --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Data.Array\r\nimport Data.Ratio\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Tipos de los vectores y de las matrices                            --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- Los vectores son tablas cuyos \u00edndices son n\u00fameros naturales.\r\ntype Vector a = Array Int a\r\n \r\n-- Las matrices son tablas cuyos \u00edndices son pares de n\u00fameros\r\n-- naturales. \r\ntype Matriz a = Array (Int,Int) a\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Operaciones b\u00e1sicas con matrices                                   --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1. Definir la funci\u00f3n\r\n--    listaVector :: Num a => [a] -> Vector a\r\n-- tal que (listaVector xs) es el vector correspondiente a la lista\r\n-- xs. Por ejemplo, \r\n--    ghci> listaVector [3,2,5]\r\n--    array (1,3) [(1,3),(2,2),(3,5)]\r\n-- ---------------------------------------------------------------------\r\n\r\nlistaVector :: Num a => [a] -> Vector a\r\nlistaVector xs = listArray (1,n) xs\r\n    where n = length xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2. Definir la funci\u00f3n\r\n--    listaMatriz :: Num a => [[a]] -> Matriz a\r\n-- tal que (listaMatriz xss) es la matriz cuyas filas son los elementos\r\n-- de xss. Por ejemplo,\r\n--    ghci> listaMatriz [[1,3,5],[2,4,7]]\r\n--    array ((1,1),(2,3)) [((1,1),1),((1,2),3),((1,3),5),\r\n--                         ((2,1),2),((2,2),4),((2,3),7)]\r\n-- ---------------------------------------------------------------------\r\n\r\nlistaMatriz :: Num a => [[a]] -> Matriz a\r\nlistaMatriz xss = listArray ((1,1),(m,n)) (concat xss)\r\n    where m = length xss\r\n          n = length (head xss)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3. Definir la funci\u00f3n\r\n--    numFilas :: Num a => Matriz a -> Int\r\n-- tal que (numFilas m) es el n\u00famero de filas de la matriz m. Por\r\n-- ejemplo,\r\n--    numFilas (listaMatriz [[1,3,5],[2,4,7]])  ==  2\r\n-- ---------------------------------------------------------------------\r\n\r\nnumFilas :: Num a => Matriz a -> Int\r\nnumFilas = fst . snd . bounds\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4. Definir la funci\u00f3n\r\n--    numColumnas :: Num a => Matriz a -> Int\r\n-- tal que (numColumnas m) es el n\u00famero de columnas de la matriz\r\n-- m. Por ejemplo,\r\n--    numColumnas (listaMatriz [[1,3,5],[2,4,7]])  ==  3\r\n-- ---------------------------------------------------------------------\r\n\r\nnumColumnas:: Num a => Matriz a -> Int\r\nnumColumnas = snd . snd . bounds\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5. Definir la funci\u00f3n\r\n--    dimension :: Num a => Matriz a -> (Int,Int)\r\n-- tal que (dimension m) es el n\u00famero de columnas de la matriz m. Por\r\n-- ejemplo, \r\n--    dimension (listaMatriz [[1,3,5],[2,4,7]])  ==  (2,3)\r\n-- ---------------------------------------------------------------------\r\n\r\ndimension :: Num a => Matriz a -> (Int,Int)\r\ndimension p = (numFilas p, numColumnas p)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6. Definir la funci\u00f3n\r\n--    separa :: Int -> [a] -> [[a]]\r\n-- tal que (separa n xs) es la lista obtenida separando los elementos de\r\n-- xs en grupos de n elementos (salvo el \u00faltimo que puede tener menos de\r\n-- n elementos). Por ejemplo, \r\n--    separa 3 [1..11]  ==  [[1,2,3],[4,5,6],[7,8,9],[10,11]]\r\n-- ---------------------------------------------------------------------\r\n\r\nsepara :: Int -> [a] -> [[a]]\r\nsepara _ [] = []\r\nsepara n xs = take n xs : separa n (drop n xs)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7. Definir la funci\u00f3n\r\n--    matrizLista :: Num a => Matriz a -> [[a]]\r\n-- tal que (matrizLista x) es la lista de las filas de la matriz x. Por\r\n-- ejemplo, \r\n--    ghci> let m = listaMatriz [[5,1,0],[3,2,6]]\r\n--    ghci> m\r\n--    array ((1,1),(2,3)) [((1,1),5),((1,2),1),((1,3),0),\r\n--                         ((2,1),3),((2,2),2),((2,3),6)]\r\n--    ghci> matrizLista m\r\n--    [[5,1,0],[3,2,6]]\r\n-- ---------------------------------------------------------------------\r\n\r\nmatrizLista :: Num a => Matriz a -> [[a]]\r\nmatrizLista p = separa (numColumnas p) (elems p)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8. Definir la funci\u00f3n\r\n--    vectorLista :: Num a => Vector a -> [a]\r\n-- tal que (vectorLista x) es la lista de los elementos del vector\r\n-- v. Por ejemplo, \r\n--    ghci> let v = listaVector [3,2,5]\r\n--    ghci> v\r\n--    array (1,3) [(1,3),(2,2),(3,5)]\r\n--    ghci> vectorLista v\r\n--    [3,2,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nvectorLista :: Num a => Vector a -> [a]\r\nvectorLista = elems \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Suma de matrices                                                   --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9. Definir la funci\u00f3n\r\n--    sumaMatrices:: Num a => Matriz a -> Matriz a -> Matriz a\r\n-- tal que (sumaMatrices x y) es la suma de las matrices x e y. Por\r\n-- ejemplo, \r\n--    ghci> let m1 = listaMatriz [[5,1,0],[3,2,6]]\r\n--    ghci> let m2 = listaMatriz [[4,6,3],[1,5,2]]\r\n--    ghci> matrizLista (sumaMatrices m1 m2)\r\n--    [[9,7,3],[4,7,8]]\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaMatrices:: Num a => Matriz a -> Matriz a -> Matriz a\r\nsumaMatrices p q = \r\n    array ((1,1),(m,n)) [((i,j),p!(i,j)+q!(i,j)) | \r\n                         i <- [1..m], j <- [1..n]]\r\n    where (m,n) = dimension p\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10. Definir la funci\u00f3n\r\n--    filaMat :: Num a => Int -> Matriz a -> Vector a\r\n-- tal que (filaMat i p) es el vector correspondiente a la fila i-\u00e9sima\r\n-- de la matriz p. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,5,7]]\r\n--    ghci> filaMat 2 p\r\n--    array (1,3) [(1,3),(2,2),(3,6)]\r\n--    ghci> vectorLista (filaMat 2 p)\r\n--    [3,2,6]\r\n-- ---------------------------------------------------------------------\r\n\r\nfilaMat :: Num a => Int -> Matriz a -> Vector a\r\nfilaMat i p = array (1,n) [(j,p!(i,j)) | j <- [1..n]]\r\n    where n = numColumnas p\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 11. Definir la funci\u00f3n\r\n--    columnaMat :: Num a => Int -> Matriz a -> Vector a\r\n-- tal que (columnaMat j p) es el vector correspondiente a la columna\r\n-- j-\u00e9sima de la matriz p. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,5,7]]\r\n--    ghci> columnaMat 2 p\r\n--    array (1,3) [(1,1),(2,2),(3,5)]\r\n--    ghci> vectorLista (columnaMat 2 p)\r\n--    [1,2,5]\r\n-- ---------------------------------------------------------------------\r\n\r\ncolumnaMat :: Num a => Int -> Matriz a -> Vector a\r\ncolumnaMat j p = array (1,m) [(i,p!(i,j)) | i <- [1..m]]\r\n    where m = numFilas p\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Producto de matrices                                               --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 12. Definir la funci\u00f3n\r\n--    prodEscalar :: Num a => Vector a -> Vector a -> a\r\n-- tal que (prodEscalar v1 v2) es el producto escalar de los vectores v1\r\n-- y v2. Por ejemplo,\r\n--    ghci> let v = listaVector [3,1,10]\r\n--    ghci> prodEscalar v v\r\n--    110\r\n-- ---------------------------------------------------------------------\r\n\r\nprodEscalar :: Num a => Vector a -> Vector a -> a\r\nprodEscalar v1 v2 = \r\n    sum [i*j | (i,j) <- zip (elems v1) (elems v2)]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 13. Definir la funci\u00f3n\r\n--    prodMatrices:: Num a => Matriz a -> Matriz a -> Matriz a\r\n-- tal que (prodMatrices p q) es el producto de las matrices p y q. Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[3,1],[2,4]]\r\n--    ghci> prodMatrices p p\r\n--    array ((1,1),(2,2)) [((1,1),11),((1,2),7),((2,1),14),((2,2),18)]\r\n--    ghci> matrizLista (prodMatrices p p)\r\n--    [[11,7],[14,18]]\r\n--    ghci> let q = listaMatriz [[7],[5]]\r\n--    ghci> prodMatrices p q\r\n--    array ((1,1),(2,1)) [((1,1),26),((2,1),34)]\r\n--    ghci> matrizLista (prodMatrices p q)\r\n--    [[26],[34]]\r\n-- ---------------------------------------------------------------------\r\n\r\nprodMatrices:: Num a => Matriz a -> Matriz a -> Matriz a\r\nprodMatrices p q = \r\n    array ((1,1),(m,n))\r\n          [((i,j), prodEscalar (filaMat i p) (columnaMat j q)) |\r\n           i <- [1..m], j <- [1..n]]\r\n    where m = numFilas p\r\n          n = numColumnas q\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Traspuestas y sim\u00e9tricas                                           --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 14. Definir la funci\u00f3n\r\n--    traspuesta :: Num a => Matriz a -> Matriz a\r\n-- tal que (traspuesta p) es la traspuesta de la matriz p. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\r\n--    ghci> traspuesta p\r\n--    array ((1,1),(3,2)) [((1,1),5),((1,2),3),\r\n--                         ((2,1),1),((2,2),2),\r\n--                         ((3,1),0),((3,2),6)]\r\n--    ghci> matrizLista (traspuesta p)\r\n--    [[5,3],[1,2],[0,6]]\r\n-- ---------------------------------------------------------------------\r\n\r\ntraspuesta :: Num a => Matriz a -> Matriz a\r\ntraspuesta p = \r\n    array ((1,1),(n,m))\r\n          [((i,j), p!(j,i)) | i <- [1..n], j <- [1..m]]\r\n    where (m,n) = dimension p\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 15. Definir la funci\u00f3n\r\n--    esCuadrada :: Num a => Matriz a -> Bool\r\n-- tal que (esCuadrada p) se verifica si la matriz p es cuadrada. Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\r\n--    ghci> esCuadrada p\r\n--    False\r\n--    ghci> let q = listaMatriz [[5,1],[3,2]]\r\n--    ghci> esCuadrada q\r\n--    True\r\n-- ---------------------------------------------------------------------\r\n\r\nesCuadrada :: Num a => Matriz a -> Bool\r\nesCuadrada x = numFilas x == numColumnas x\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16. Definir la funci\u00f3n\r\n--    esSimetrica :: (Num a, Eq a) => Matriz a -> Bool\r\n-- tal que (esSimetrica p) se verifica si la matriz p es sim\u00e9trica. Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[5,1,3],[1,4,7],[3,7,2]]\r\n--    ghci> esSimetrica p\r\n--    True\r\n--    ghci> let q = listaMatriz [[5,1,3],[1,4,7],[3,4,2]]\r\n--    ghci> esSimetrica q\r\n--    False\r\n-- ---------------------------------------------------------------------    \r\n\r\nesSimetrica :: (Num a, Eq a) => Matriz a -> Bool\r\nesSimetrica x = x == traspuesta x\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Diagonales de una matriz                                           --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 17. Definir la funci\u00f3n\r\n--    diagonalPral :: Num a => Matriz a -> Vector a\r\n-- tal que (diagonalPral p) es la diagonal principal de la matriz p. Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\r\n--    ghci> diagonalPral p\r\n--    array (1,2) [(1,5),(2,2)]\r\n--    ghci> vectorLista (diagonalPral p)\r\n--    [5,2]\r\n-- ---------------------------------------------------------------------\r\n\r\ndiagonalPral :: Num a => Matriz a -> Vector a\r\ndiagonalPral p = array (1,n) [(i,p!(i,i)) | i <- [1..n]]\r\n    where n = min (numFilas p) (numColumnas p)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 18. Definir la funci\u00f3n\r\n--    diagonalSec :: Num a => Matriz a -> Vector a\r\n-- tal que (diagonalSec p) es la diagonal secundaria de la matriz p. Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6]]\r\n--    ghci> diagonalSec p\r\n--    array (1,2) [(1,1),(2,3)]\r\n--    ghci> vectorLista (diagonalSec p)\r\n--    [1,3]\r\n--    ghci> let q = traspuesta p\r\n--    ghci> matrizLista q\r\n--    [[5,3],[1,2],[0,6]]\r\n--    ghci> vectorLista (diagonalSec q)\r\n--    [3,1]\r\n-- ---------------------------------------------------------------------\r\n\r\ndiagonalSec :: Num a => Matriz a -> Vector a\r\ndiagonalSec p = array (1,n) [(i,p!(i,n+1-i)) | i <- [1..n]]\r\n    where n = min (numFilas p) (numColumnas p)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Submatrices                                                        --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 19. Definir la funci\u00f3n\r\n--    submatriz :: Num a => Int -> Int -> Matriz a -> Matriz a\r\n-- tal que (submatriz i j p) es la matriz obtenida a partir de la p\r\n-- eliminando la fila i y la columna j. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> submatriz 2 3 p\r\n--    array ((1,1),(2,2)) [((1,1),5),((1,2),1),((2,1),4),((2,2),6)]\r\n--    ghci> matrizLista (submatriz 2 3 p)\r\n--    [[5,1],[4,6]]\r\n-- ---------------------------------------------------------------------\r\n\r\nsubmatriz :: Num a => Int -> Int -> Matriz a -> Matriz a\r\nsubmatriz i j p = \r\n    array ((1,1), (m-1,n -1))\r\n          [((k,l), p ! f k l) | k <- [1..m-1], l <- [1.. n-1]]\r\n    where (m,n) = dimension p\r\n          f k l | k < i  &#038;&#038; l < j  = (k,l)\r\n                | k >= i && l < j  = (k+1,l)\r\n                | k < i  &#038;&#038; l >= j = (k,l+1)\r\n                | otherwise        = (k+1,l+1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Transformaciones elementales                                       --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 20. Definir la funci\u00f3n\r\n--    intercambiaFilas :: Num a => Int -> Int -> Matriz a -> Matriz a\r\n-- tal que (intercambiaFilas k l p) es la matriz obtenida intercambiando\r\n-- las filas k y l de la matriz p. Por ejemplo, \r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> intercambiaFilas 1 3 p\r\n--    array ((1,1),(3,3)) [((1,1),4),((1,2),6),((1,3),9),\r\n--                         ((2,1),3),((2,2),2),((2,3),6),\r\n--                         ((3,1),5),((3,2),1),((3,3),0)]\r\n--    ghci> matrizLista (intercambiaFilas 1 3 p)\r\n--    [[4,6,9],[3,2,6],[5,1,0]]\r\n-- ---------------------------------------------------------------------\r\n\r\nintercambiaFilas :: Num a => Int -> Int -> Matriz a -> Matriz a\r\nintercambiaFilas k l p = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 21. Definir la funci\u00f3n\r\n--    intercambiaColumnas :: Num a => Int -> Int -> Matriz a -> Matriz a\r\n-- tal que (intercambiaColumnas k l p) es la matriz obtenida\r\n-- intercambiando las columnas k y l de la matriz p. Por ejemplo, \r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> matrizLista (intercambiaColumnas 1 3 p)\r\n--    [[0,1,5],[6,2,3],[9,6,4]]\r\n-- ---------------------------------------------------------------------\r\n\r\nintercambiaColumnas :: Num a => Int -> Int -> Matriz a -> Matriz a\r\nintercambiaColumnas k l p = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 22. Definir la funci\u00f3n\r\n--    multFilaPor :: Num a => Int -> a -> Matriz a -> Matriz a\r\n-- tal que (multFilaPor k x p) es a matriz obtenida multiplicando la\r\n-- fila k de la matriz p por el n\u00famero x. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> matrizLista (multFilaPor 2 3 p)\r\n--    [[5,1,0],[9,6,18],[4,6,9]]\r\n-- ---------------------------------------------------------------------\r\n\r\nmultFilaPor :: Num a => Int -> a -> Matriz a -> Matriz a\r\nmultFilaPor k x p = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 23. Definir la funci\u00f3n\r\n--    sumaFilaFila :: Num a => Int -> Int -> Matriz a -> Matriz a\r\n-- tal que (sumaFilaFila k l p) es la matriz obtenida sumando la fila l\r\n-- a la fila k d la matriz p. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> matrizLista (sumaFilaFila 2 3 p)\r\n--    [[5,1,0],[7,8,15],[4,6,9]]\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaFilaFila :: Num a => Int -> Int -> Matriz a -> Matriz a\r\nsumaFilaFila k l p = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 24. Definir la funci\u00f3n\r\n--    sumaFilaPor :: Num a => Int -> Int -> a -> Matriz a -> Matriz a\r\n-- tal que (sumaFilaPor k l x p) es la matriz obtenida sumando a la fila\r\n-- k de la matriz p la fila l multiplicada por x. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> matrizLista (sumaFilaPor 2 3 10 p)\r\n--    [[5,1,0],[43,62,96],[4,6,9]]\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaFilaPor :: Num a => Int -> Int -> a -> Matriz a -> Matriz a\r\nsumaFilaPor k l x p = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Triangularizaci\u00f3n de matrices                                      --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 25. Definir la funci\u00f3n\r\n--    buscaIndiceDesde :: (Num a, Eq a) => \r\n--                        Matriz a -> Int -> Int -> Maybe Int\r\n-- tal que (buscaIndiceDesde p j i) es el menor \u00edndice k, mayor o igual\r\n-- que i, tal que el elemento de la matriz p en la posici\u00f3n (k,j) es no\r\n-- nulo. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> buscaIndiceDesde p 3 2\r\n--    Just 2\r\n--    ghci> let q = listaMatriz [[5,1,1],[3,2,0],[4,6,0]]\r\n--    ghci> buscaIndiceDesde q 3 2\r\n--    Nothing\r\n-- ---------------------------------------------------------------------\r\n\r\nbuscaIndiceDesde :: (Num a, Eq a) => Matriz a -> Int -> Int -> Maybe Int\r\nbuscaIndiceDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 26. Definir la funci\u00f3n\r\n--    buscaPivoteDesde :: (Num a, Eq a) => \r\n--                        Matriz a -> Int -> Int -> Maybe a\r\n-- tal que (buscaPivoteDesde p j i) es el elemento de la matriz p en la\r\n-- posici\u00f3n (k,j) donde k es (buscaIndiceDesde p j i). Por ejemplo,\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> buscaPivoteDesde p 3 2\r\n--    Just 6\r\n--    ghci> let q = listaMatriz [[5,1,1],[3,2,0],[4,6,0]]\r\n--    ghci> buscaPivoteDesde q 3 2\r\n--    Nothing\r\n-- ---------------------------------------------------------------------\r\n\r\nbuscaPivoteDesde :: (Num a, Eq a) => Matriz a -> Int -> Int -> Maybe a\r\nbuscaPivoteDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 27. Definir la funci\u00f3n\r\n--    anuladaColumnaDesde :: (Num a, Eq a) => \r\n--                            Int -> Int -> Matriz a -> Bool\r\n-- tal que (anuladaColumnaDesde j i p) se verifica si todos los\r\n-- elementos de la columna j de la matriz p desde i+1 en adelante son\r\n-- nulos. Por ejemplo,\r\n--    ghci> let q = listaMatriz [[5,1,1],[3,2,0],[4,6,0]]\r\n--    ghci> anuladaColumnaDesde q 3 2\r\n--    True\r\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\r\n--    ghci> anuladaColumnaDesde p 3 2\r\n--    False\r\n-- ---------------------------------------------------------------------\r\n\r\nanuladaColumnaDesde :: (Num a, Eq a) => Matriz a -> Int -> Int -> Bool\r\nanuladaColumnaDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 28. Definir la funci\u00f3n\r\n--    anulaEltoColumnaDesde :: (Fractional a, Eq a) => \r\n--                             Matriz a -> Int -> Int -> Matriz a\r\n-- tal que (anulaEltoColumnaDesde p j i) es la matriz obtenida a partir\r\n-- de p anulando el primer elemento de la columna j por debajo de la\r\n-- fila i usando el elemento de la posici\u00f3n (i,j). Por ejemplo,\r\n--    ghci> let p = listaMatriz [[2,3,1],[5,0,5],[8,6,9]] :: Matriz Double\r\n--    ghci> matrizLista (anulaEltoColumnaDesde p 2 1)\r\n--    [[2.0,3.0,1.0],[5.0,0.0,5.0],[4.0,0.0,7.0]]\r\n-- ---------------------------------------------------------------------\r\n\r\nanulaEltoColumnaDesde :: (Fractional a, Eq a) => \r\n                         Matriz a -> Int -> Int -> Matriz a\r\nanulaEltoColumnaDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 29. Definir la funci\u00f3n\r\n--    anulaColumnaDesde :: (Fractional a, Eq a) => \r\n--                         Matriz a -> Int -> Int -> Matriz a\r\n-- tal que (anulaColumnaDesde p j i) es la matriz obtenida anulando\r\n-- todos los elementos de la columna j de la matriz p por debajo del la\r\n-- posici\u00f3n (i,j) (se supone que el elemnto p_(i,j) es no nulo). Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[2,2,1],[5,4,5],[10,8,9]] :: Matriz Double\r\n--    ghci> matrizLista (anulaColumnaDesde p 2 1)\r\n--    [[2.0,2.0,1.0],[1.0,0.0,3.0],[2.0,0.0,5.0]]\r\n--    ghci> let p = listaMatriz [[4,5],[2,7%2],[6,10]] \r\n--    ghci> matrizLista (anulaColumnaDesde p 1 1)\r\n--    [[4 % 1,5 % 1],[0 % 1,1 % 1],[0 % 1,5 % 2]]\r\n-- ---------------------------------------------------------------------\r\n\r\nanulaColumnaDesde :: (Fractional a, Eq a) => \r\n                     Matriz a -> Int -> Int -> Matriz a\r\nanulaColumnaDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Algoritmo de Gauss para triangularizar matrices                    --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 30. Definir la funci\u00f3n\r\n--    elementosNoNulosColDesde :: (Num a, Eq a) => \r\n--                                Matriz a -> Int -> Int -> [a]\r\n-- tal que (elementosNoNulosColDesde p j i) es la lista de los elementos\r\n-- no nulos de la columna j a partir de la fila i. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[3,2],[5,1],[0,4]]\r\n--    ghci> elementosNoNulosColDesde p 1 2\r\n--    [5]\r\n-- ---------------------------------------------------------------------\r\n\r\nelementosNoNulosColDesde :: (Num a, Eq a) => Matriz a -> Int -> Int -> [a]\r\nelementosNoNulosColDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 31. Definir la funci\u00f3n\r\n--    existeColNoNulaDesde :: (Num a, Eq a) => \r\n--                            Matriz a -> Int -> Int -> Bool\r\n-- tal que (existeColNoNulaDesde p j i) se verifica si la matriz p tiene\r\n-- una columna a partir de la j tal que tiene alg\u00fan elemento no nulo por\r\n-- debajo de la j; es decir, si la submatriz de p obtenida eliminando\r\n-- las i-1 primeras filas y las j-1 primeras columnas es no nula. Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[3,2,5],[5,0,0],[6,0,0]]\r\n--    ghci> existeColNoNulaDesde p 2 2\r\n--    False\r\n--    ghci> let q = listaMatriz [[3,2,5],[5,7,0],[6,0,0]]\r\n--    ghci> existeColNoNulaDesde q 2 2\r\n-- ---------------------------------------------------------------------\r\n  \r\nexisteColNoNulaDesde :: (Num a, Eq a) => Matriz a -> Int -> Int -> Bool\r\nexisteColNoNulaDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 32. Definir la funci\u00f3n\r\n--    menorIndiceColNoNulaDesde :: (Num a, Eq a) => \r\n--                                 Matriz a -> Int -> Int -> Maybe Int\r\n-- tal que (menorIndiceColNoNulaDesde p j i) es el \u00edndice de la primera\r\n-- columna, a partir de la j, en el que la matriz p tiene un elemento no\r\n-- nulo a partir de la fila i. Por ejemplo,\r\n--    ghci> let p = listaMatriz [[3,2,5],[5,7,0],[6,0,0]]\r\n--    ghci> menorIndiceColNoNulaDesde p 2 2\r\n--    Just 2\r\n--    ghci> let q = listaMatriz [[3,2,5],[5,0,0],[6,0,2]]\r\n--    ghci> menorIndiceColNoNulaDesde q 2 2\r\n--    Just 3\r\n--    ghci> let r = listaMatriz [[3,2,5],[5,0,0],[6,0,0]]\r\n--    ghci> menorIndiceColNoNulaDesde r 2 2\r\n--    Nothing\r\n-- ---------------------------------------------------------------------\r\n\r\nmenorIndiceColNoNulaDesde :: (Num a, Eq a) => \r\n                             Matriz a -> Int -> Int -> Maybe Int\r\nmenorIndiceColNoNulaDesde p j i = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 33. Definir la funci\u00f3n\r\n--    gaussAux :: (Fractional a, Eq a) => \r\n--                Matriz a -> Int -> Int -> Matriz a\r\n-- tal que (gauss p) es la matriz que en el que las i-1 primeras filas y\r\n-- las j-1 primeras columnas son las de p y las restantes est\u00e1n\r\n-- triangularizadas por el m\u00e9todo de Gauss; es decir,\r\n--    1. Si la dimensi\u00f3n de p es (i,j), entonces p.\r\n--    2. Si la submatriz de p sin las i-1 primeras filas y las j-1\r\n--       primeras columnas es nulas, entonces p.\r\n--    3. En caso contrario, (gaussAux p' (i+1) (j+1)) siendo\r\n--    3.1. j' la primera columna a partir de la j donde p tiene\r\n--         alg\u00fan elemento no nulo a partir de la fila i,\r\n--    3.2. p1 la matriz obtenida intercambiando las columnas j y j'\r\n--         de p,\r\n--    3.3. i' la primera fila a partir de la i donde la columna j de\r\n--         p1 tiene un elemento no nulo,\r\n--    3.4. p2 la matriz obtenida intercambiando las filas i e i' de\r\n--         la matriz p1 y\r\n--    3.5. p' la matriz obtenida anulando todos los elementos de la\r\n--         columna j de p2 por debajo de la fila i.\r\n-- Por ejemplo,\r\n--    ghci> let p = listaMatriz [[1.0,2,3],[1,2,4],[3,2,5]]\r\n--    ghci> matrizLista (gaussAux p 2 2)\r\n--    [[1.0,2.0,3.0],[1.0,2.0,4.0],[2.0,0.0,1.0]]\r\n-- ---------------------------------------------------------------------\r\n\r\ngaussAux :: (Fractional a, Eq a) => Matriz a -> Int -> Int -> Matriz a\r\ngaussAux p i j = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 34. Definir la funci\u00f3n\r\n--    gauss :: (Fractional a, Eq a) => Matriz a -> Matriz a\r\n-- tal que (gauss p) es la triangularizaci\u00f3n de la matriz p por el m\u00e9todo\r\n-- de Gauss. Por ejemplo, \r\n--    ghci> let p = listaMatriz [[1.0,2,3],[1,2,4],[1,2,5]]\r\n--    ghci> gauss p\r\n--    array ((1,1),(3,3)) [((1,1),1.0),((1,2),3.0),((1,3),2.0),\r\n--                         ((2,1),0.0),((2,2),1.0),((2,3),0.0),\r\n--                         ((3,1),0.0),((3,2),0.0),((3,3),0.0)]\r\n--    ghci> matrizLista (gauss p)\r\n--    [[1.0,3.0,2.0],[0.0,1.0,0.0],[0.0,0.0,0.0]]\r\n--    ghci> let p = listaMatriz [[3.0,2,3],[1,2,4],[1,2,5]]\r\n--    ghci> matrizLista (gauss p)\r\n--    [[3.0,2.0,3.0],[0.0,1.3333333333333335,3.0],[0.0,0.0,1.0]]\r\n--    ghci> let p = listaMatriz [[3%1,2,3],[1,2,4],[1,2,5]]\r\n--    ghci> matrizLista (gauss p)\r\n--    [[3 % 1,2 % 1,3 % 1],[0 % 1,4 % 3,3 % 1],[0 % 1,0 % 1,1 % 1]]\r\n--    ghci> let p = listaMatriz [[1.0,0,3],[1,0,4],[3,0,5]]\r\n--    ghci> matrizLista (gauss p)\r\n--    [[1.0,3.0,0.0],[0.0,1.0,0.0],[0.0,0.0,0.0]]\r\n-- ---------------------------------------------------------------------\r\n\r\ngauss :: (Fractional a, Eq a) => Matriz a -> Matriz a\r\ngauss p = undefined\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Determinante                                                       --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 35. Definir la funci\u00f3n\r\n--    determinante :: (Fractional a, Eq a) => Matriz a -> a\r\n-- tal que (determinante p) es el determinante de la matriz p. Por\r\n-- ejemplo, \r\n--    ghci> let p = listaMatriz [[1.0,2,3],[1,2,4],[1,2,5]]\r\n--    ghci> determinante p\r\n--    0.0\r\n--    ghci> let p = listaMatriz [[1.0,2,3],[1,3,4],[1,2,5]]\r\n--    ghci> determinante p\r\n--    2.0\r\n-- ---------------------------------------------------------------------\r\n\r\ndeterminante :: (Fractional a, Eq a) => Matriz a -> a\r\ndeterminante p = undefined\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la clase hoy Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos continuando comentado las soluciones de los ejercicios sobre vectores y matrices en Haskell de la relaci\u00f3n 26. Concretamente, de los ejercicios para calcular la traspuesta de una matriz (ej. 14), decidir si una matriz es cuadrada (ej. 15), decidir si una matriz es&#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":[1],"tags":[270,298],"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\/3311"}],"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=3311"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3311\/revisions"}],"predecessor-version":[{"id":3312,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3311\/revisions\/3312"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3311"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3311"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3311"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}