{"id":5707,"date":"2017-02-17T12:34:30","date_gmt":"2017-02-17T11:34:30","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=5707"},"modified":"2017-02-23T12:35:47","modified_gmt":"2017-02-23T11:35:47","slug":"i1m2016-ejercicios-sobre-vectores-y-matrices-con-las-librerias","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2016-ejercicios-sobre-vectores-y-matrices-con-las-librerias\/","title":{"rendered":"I1M2016: Ejercicios sobre vectores y matrices con las librer\u00edas"},"content":{"rendered":"<p>En la primera parte de la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-16\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentado las soluciones de los ejercicios de la relaci\u00f3n 17 sobre vectores y matrices en Haskell usando las librer\u00edas Data.Vector y Data.Matrix.<\/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 adaptar los ejercicios de las\n-- relaciones 15 y 16 (sobre vectores y matrices) usando las librer\u00edas\n-- Data.Vector y Data.Matrix. \n--\n-- El manual, con ejemplos, de la librer\u00eda de vectores de encuentra en\n-- http:\/\/bit.ly\/1PNZ6Br y el de matrices en http:\/\/bit.ly\/1PNZ9ND\n--\n-- Para instalar las librer\u00edas basta escribir en la consola\n--    cabal update\n--    cabal install vector matrix\n \n-- ---------------------------------------------------------------------\n-- Importaci\u00f3n de librer\u00edas                                           --\n-- ---------------------------------------------------------------------\n\nimport qualified Data.Vector as V \nimport Data.Matrix \nimport Data.Ratio\nimport Data.Maybe\n\n-- ---------------------------------------------------------------------\n-- Tipos de los vectores y de las matrices                            --\n-- ---------------------------------------------------------------------\n\n-- Los vectores (con elementos de tipo a son del tipo (V.Vector a).\n-- Los matrices (con elementos de tipo a son del tipo (Matrix a).\n\n-- ---------------------------------------------------------------------\n-- Operaciones b\u00e1sicas con matrices                                   --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 1. Definir la funci\u00f3n\n--    listaVector :: Num a => [a] -> V.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--    fromList [3,2,5]\n-- ---------------------------------------------------------------------\n\nlistaVector :: Num a => [a] -> V.Vector a\nlistaVector = V.fromList \n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2. Definir la funci\u00f3n\n--    listaMatriz :: Num a => [[a]] -> Matrix 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--    ( 1 3 5 )\n--    ( 2 4 7 )\n-- ---------------------------------------------------------------------\n\nlistaMatriz :: Num a => [[a]] -> Matrix a\nlistaMatriz = fromLists\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3. Definir la funci\u00f3n\n--    numFilas :: Num a => Matrix 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 => Matrix a -> Int\nnumFilas = nrows\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4. Definir la funci\u00f3n\n--    numColumnas :: Num a => Matrix 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 => Matrix a -> Int\nnumColumnas = ncols\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5. Definir la funci\u00f3n\n--    dimension :: Num a => Matrix 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 => Matrix a -> (Int,Int)\ndimension p = (nrows p, ncols p)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 7. Definir la funci\u00f3n\n--    matrizLista :: Num a => Matrix 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--    ( 5 1 0 )\n--    ( 3 2 6 )\n--    ghci> matrizLista m\n--    [[5,1,0],[3,2,6]]\n-- ---------------------------------------------------------------------\n\nmatrizLista :: Num a => Matrix a -> [[a]]\nmatrizLista = toLists\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 8. Definir la funci\u00f3n\n--    vectorLista :: Num a => V.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--    fromList [3,2,5]\n--    ghci> vectorLista v\n--    [3,2,5]\n-- ---------------------------------------------------------------------\n\nvectorLista :: Num a => V.Vector a -> [a]\nvectorLista = V.toList\n\n-- ---------------------------------------------------------------------\n-- Suma de matrices                                                   --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 9. Definir la funci\u00f3n\n--    sumaMatrices:: Num a => Matrix a -> Matrix a -> Matrix 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> sumaMatrices m1 m2\n--    ( 9 7 3 )\n--    ( 4 7 8 )\n-- ---------------------------------------------------------------------\n\nsumaMatrices:: Num a => Matrix a -> Matrix a -> Matrix a\nsumaMatrices = (+)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 10. Definir la funci\u00f3n\n--    filaMat :: Num a => Int -> Matrix a -> V.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--    fromList [3,2,6]\n--    ghci> vectorLista (filaMat 2 p)\n--    [3,2,6]\n-- ---------------------------------------------------------------------\n\nfilaMat :: Num a => Int -> Matrix a -> V.Vector a\nfilaMat = getRow\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 11. Definir la funci\u00f3n\n--    columnaMat :: Num a => Int -> Matrix a -> V.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--    fromList [1,2,5]\n--    ghci> vectorLista (columnaMat 2 p)\n--    [1,2,5]\n-- ---------------------------------------------------------------------\n\ncolumnaMat :: Num a => Int -> Matrix a -> V.Vector a\ncolumnaMat = getCol\n\n-- ---------------------------------------------------------------------\n-- Producto de matrices                                               --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 12. Definir la funci\u00f3n\n--    prodEscalar :: Num a => V.Vector a -> V.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\nprodEscalar :: Num a => V.Vector a -> V.Vector a -> a\nprodEscalar v1 v2 = V.sum (V.zipWith (*) v1 v2) \n\n-- ---------------------------------------------------------------------\n-- Ejercicio 13. Definir la funci\u00f3n\n--    prodMatrices:: Num a => Matrix a -> Matrix a -> Matrix 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--    ( 11  7 )\n--    ( 14 18 )\n--    ghci> let q = listaMatriz [[7],[5]]\n--    ghci> prodMatrices p q\n--    ( 26 )\n--    ( 34 )\n-- ---------------------------------------------------------------------\n\nprodMatrices:: Num a => Matrix a -> Matrix a -> Matrix a\nprodMatrices = (*)\n\n-- ---------------------------------------------------------------------\n-- Traspuestas y sim\u00e9tricas                                           --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 14. Definir la funci\u00f3n\n--    traspuesta :: Num a => Matrix a -> Matrix 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--    ( 5 3 )\n--    ( 1 2 )\n--    ( 0 6 )\n-- ---------------------------------------------------------------------\n\ntraspuesta :: Num a => Matrix a -> Matrix a\ntraspuesta = transpose\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 15. Definir la funci\u00f3n\n--    esCuadrada :: Num a => Matrix 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 => Matrix a -> Bool\nesCuadrada p = nrows p == ncols p\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 16. Definir la funci\u00f3n\n--    esSimetrica :: (Num a, Eq a) => Matrix 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) => Matrix a -> Bool\nesSimetrica x = x == transpose x\n\n-- ---------------------------------------------------------------------\n-- Diagonales de una matriz                                           --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 17. Definir la funci\u00f3n\n--    diagonalPral :: Num a => Matrix a -> V.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--    fromList [5,2]\n-- ---------------------------------------------------------------------\n\ndiagonalPral :: Num a => Matrix a -> V.Vector a\ndiagonalPral = getDiag\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 18. Definir la funci\u00f3n\n--    diagonalSec :: Num a => Matrix a -> V.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--    fromList [1,3]\n--    ghci> let q = traspuesta p\n--    ghci> matrizLista q\n--    [[5,3],[1,2],[0,6]]\n--    ghci> diagonalSec q\n--    fromList [1,2]\n-- ---------------------------------------------------------------------\n\ndiagonalSec :: Num a => Matrix a -> V.Vector a\ndiagonalSec p = V.fromList [p!(i,n+1-i) | i <- [1..n]]\n    where n = min (nrows p) (ncols p)\n\n-- ---------------------------------------------------------------------\n-- Submatrices                                                        --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 19. Definir la funci\u00f3n\n--    submatriz :: Num a => Int -> Int -> Matrix a -> Matrix 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--    ( 5 1 )\n--    ( 4 6 )\n-- ---------------------------------------------------------------------\n\nsubmatriz :: Num a => Int -> Int -> Matrix a -> Matrix a\nsubmatriz = minorMatrix\n\n-- ---------------------------------------------------------------------\n-- Transformaciones elementales                                       --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 20. Definir la funci\u00f3n\n--    intercambiaFilas :: Num a => Int -> Int -> Matrix a -> Matrix a\n-- tal que (intercambiaFilas k l p) es la matriz obtenida intercambiando\n-- las filas k y l de la matriz p. Por ejemplo, \n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> intercambiaFilas 1 3 p\n--    ( 4 6 9 )\n--    ( 3 2 6 )\n--    ( 5 1 0 )\n-- ---------------------------------------------------------------------\n\nintercambiaFilas :: Num a => Int -> Int -> Matrix a -> Matrix a\nintercambiaFilas = switchRows\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 21. Definir la funci\u00f3n\n--    intercambiaColumnas :: Num a => Int -> Int -> Matrix a -> Matrix a\n-- tal que (intercambiaColumnas k l p) es la matriz obtenida\n-- intercambiando las columnas k y l de la matriz p. Por ejemplo, \n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> intercambiaColumnas 1 3 p\n--    ( 0 1 5 )\n--    ( 6 2 3 )\n--    ( 9 6 4 )\n-- ---------------------------------------------------------------------\n\nintercambiaColumnas :: Num a => Int -> Int -> Matrix a -> Matrix a\nintercambiaColumnas = switchCols\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 22. Definir la funci\u00f3n\n--    multFilaPor :: Num a => Int -> a -> Matrix a -> Matrix a\n-- tal que (multFilaPor k x p) es la matriz obtenida multiplicando la\n-- fila k de la matriz p por el n\u00famero x. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> multFilaPor 2 3 p\n--    (  5  1  0 )\n--    (  9  6 18 )\n--    (  4  6  9 )\n-- ---------------------------------------------------------------------\n\nmultFilaPor :: Num a => Int -> a -> Matrix a -> Matrix a\nmultFilaPor k x p = scaleRow x k p\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 23. Definir la funci\u00f3n\n--    sumaFilaFila :: Num a => Int -> Int -> Matrix a -> Matrix a\n-- tal que (sumaFilaFila k l p) es la matriz obtenida sumando la fila l\n-- a la fila k de la matriz p. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> sumaFilaFila 2 3 p\n--    (  5  1  0 )\n--    (  7  8 15 )\n--    (  4  6  9 )\n-- ---------------------------------------------------------------------\n\nsumaFilaFila :: Num a => Int -> Int -> Matrix a -> Matrix a\nsumaFilaFila k l p = combineRows k 1 l p\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 24. Definir la funci\u00f3n\n--    sumaFilaPor :: Num a => Int -> Int -> a -> Matrix a -> Matrix a\n-- tal que (sumaFilaPor k l x p) es la matriz obtenida sumando a la fila\n-- k de la matriz p la fila l multiplicada por x. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> sumaFilaPor 2 3 10 p\n--    (  5  1  0 )\n--    ( 43 62 96 )\n--    (  4  6  9 )\n-- ---------------------------------------------------------------------\n\nsumaFilaPor :: Num a => Int -> Int -> a -> Matrix a -> Matrix a\nsumaFilaPor k l x p = combineRows k x l p\n\n-- ---------------------------------------------------------------------\n-- Triangularizaci\u00f3n de matrices                                      --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 25. Definir la funci\u00f3n\n--    buscaIndiceDesde :: (Num a, Eq a) => \n--                        Matrix a -> Int -> Int -> Maybe Int\n-- tal que (buscaIndiceDesde p j i) es el menor \u00edndice k, mayor o igual\n-- que i, tal que el elemento de la matriz p en la posici\u00f3n (k,j) es no\n-- nulo. Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> buscaIndiceDesde p 3 2\n--    Just 2\n--    ghci> let q = listaMatriz [[5,1,1],[3,2,0],[4,6,0]]\n--    ghci> buscaIndiceDesde q 3 2\n--    Nothing\n-- ---------------------------------------------------------------------\n\n-- 1\u00aa definici\u00f3n\nbuscaIndiceDesde :: (Num a, Eq a) => Matrix a -> Int -> Int -> Maybe Int\nbuscaIndiceDesde p j i \n    | null xs   = Nothing\n    | otherwise = Just (head xs)\n    where xs = [k | k <- [i..nrows p], p!(k,j) \/= 0]\n\n-- 2\u00aa definici\u00f3n (con listToMaybe http:\/\/bit.ly\/212iSgl)\nbuscaIndiceDesde2 :: (Num a, Eq a) => Matrix a -> Int -> Int -> Maybe Int\nbuscaIndiceDesde2 p j i =\n    listToMaybe [k | k <- [i..nrows p], p!(k,j) \/= 0]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 26. Definir la funci\u00f3n\n--    buscaPivoteDesde :: (Num a, Eq a) => \n--                        Matrix a -> Int -> Int -> Maybe a\n-- tal que (buscaPivoteDesde p j i) es el elemento de la matriz p en la\n-- posici\u00f3n (k,j) donde k es (buscaIndiceDesde p j i). Por ejemplo,\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> buscaPivoteDesde p 3 2\n--    Just 6\n--    ghci> let q = listaMatriz [[5,1,1],[3,2,0],[4,6,0]]\n--    ghci> buscaPivoteDesde q 3 2\n--    Nothing\n-- ---------------------------------------------------------------------\n\n-- 1\u00aa definici\u00f3n\nbuscaPivoteDesde :: (Num a, Eq a) => Matrix a -> Int -> Int -> Maybe a\nbuscaPivoteDesde p j i \n    | null xs   = Nothing\n    | otherwise = Just (head xs)\n    where xs = [y | k <- [i..nrows p], let y = p!(k,j), y \/= 0]\n\n-- 2\u00aa definici\u00f3n (con listToMaybe http:\/\/bit.ly\/212iSgl)\nbuscaPivoteDesde2 :: (Num a, Eq a) => Matrix a -> Int -> Int -> Maybe a\nbuscaPivoteDesde2 p j i = \n    listToMaybe [y | k <- [i..nrows p], let y = p!(k,j), y \/= 0]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 27. Definir la funci\u00f3n\n--    anuladaColumnaDesde :: (Num a, Eq a) => \n--                           Int -> Int -> Matrix a -> Bool\n-- tal que (anuladaColumnaDesde j i p) se verifica si todos los\n-- elementos de la columna j de la matriz p desde i+1 en adelante son\n-- nulos. Por ejemplo,\n--    ghci> let q = listaMatriz [[5,1,1],[3,2,0],[4,6,0]]\n--    ghci> anuladaColumnaDesde q 3 2\n--    True\n--    ghci> let p = listaMatriz [[5,1,0],[3,2,6],[4,6,9]]\n--    ghci> anuladaColumnaDesde p 3 2\n--    False\n-- ---------------------------------------------------------------------\n\nanuladaColumnaDesde :: (Num a, Eq a) => Matrix a -> Int -> Int -> Bool\nanuladaColumnaDesde p j i = \n    buscaIndiceDesde p j (i+1) == Nothing\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 28. Definir la funci\u00f3n\n--    anulaEltoColumnaDesde :: (Fractional a, Eq a) => \n--                             Matrix a -> Int -> Int -> Matrix a\n-- tal que (anulaEltoColumnaDesde p j i) es la matriz obtenida a partir\n-- de p anulando el primer elemento de la columna j por debajo de la\n-- fila i usando el elemento de la posici\u00f3n (i,j). Por ejemplo,\n--    ghci> let p = listaMatriz [[2,3,1],[5,0,5],[8,6,9]] :: Matrix Double\n--    ghci> matrizLista (anulaEltoColumnaDesde p 2 1)\n--    [[2.0,3.0,1.0],[5.0,0.0,5.0],[4.0,0.0,7.0]]\n-- ---------------------------------------------------------------------\n\nanulaEltoColumnaDesde :: (Fractional a, Eq a) => \n                         Matrix a -> Int -> Int -> Matrix a\nanulaEltoColumnaDesde p j i = \n    sumaFilaPor l i (-(p!(l,j)\/a)) p\n    where Just l = buscaIndiceDesde p j (i+1)\n          a      = p!(i,j)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 29. Definir la funci\u00f3n\n--    anulaColumnaDesde :: (Fractional a, Eq a) => \n--                         Matrix a -> Int -> Int -> Matrix a\n-- tal que (anulaColumnaDesde p j i) es la matriz obtenida anulando\n-- todos los elementos de la columna j de la matriz p por debajo del la\n-- posici\u00f3n (i,j) (se supone que el elemnto p_(i,j) es no nulo). Por\n-- ejemplo, \n--    ghci> let p = listaMatriz [[2,2,1],[5,4,5],[10,8,9]] :: Matrix Double\n--    ghci> matrizLista (anulaColumnaDesde p 2 1)\n--    [[2.0,2.0,1.0],[1.0,0.0,3.0],[2.0,0.0,5.0]]\n--    ghci> let p = listaMatriz [[4,5],[2,7%2],[6,10]] \n--    ghci> matrizLista (anulaColumnaDesde p 1 1)\n--    [[4 % 1,5 % 1],[0 % 1,1 % 1],[0 % 1,5 % 2]]\n-- ---------------------------------------------------------------------\n\nanulaColumnaDesde :: (Fractional a, Eq a) => \n                     Matrix a -> Int -> Int -> Matrix a\nanulaColumnaDesde p j i\n    | anuladaColumnaDesde p j i = p\n    | otherwise = anulaColumnaDesde (anulaEltoColumnaDesde p j i) j i \n\n-- ---------------------------------------------------------------------\n-- Algoritmo de Gauss para triangularizar matrices                    --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 30. Definir la funci\u00f3n\n--    elementosNoNulosColDesde :: (Num a, Eq a) => \n--                                Matrix a -> Int -> Int -> [a]\n-- tal que (elementosNoNulosColDesde p j i) es la lista de los elementos\n-- no nulos de la columna j a partir de la fila i. Por ejemplo,\n--    ghci> let p = listaMatriz [[3,2],[5,1],[0,4]]\n--    ghci> elementosNoNulosColDesde p 1 2\n--    [5]\n-- ---------------------------------------------------------------------\n\nelementosNoNulosColDesde :: (Num a, Eq a) => Matrix a -> Int -> Int -> [a]\nelementosNoNulosColDesde p j i = \n    [y | k <- [i..nrows p], let y = p!(k,j), y \/= 0]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 31. Definir la funci\u00f3n\n--    existeColNoNulaDesde :: (Num a, Eq a) => \n--                            Matrix a -> Int -> Int -> Bool\n-- tal que (existeColNoNulaDesde p j i) se verifica si la matriz p tiene\n-- una columna a partir de la j tal que tiene alg\u00fan elemento no nulo por\n-- debajo de la j; es decir, si la submatriz de p obtenida eliminando\n-- las i-1 primeras filas y las j-1 primeras columnas es no nula. Por\n-- ejemplo, \n--    ghci> let p = listaMatriz [[3,2,5],[5,0,0],[6,0,0]]\n--    ghci> existeColNoNulaDesde p 2 2\n--    False\n--    ghci> let q = listaMatriz [[3,2,5],[5,7,0],[6,0,0]]\n--    ghci> existeColNoNulaDesde q 2 2\n--    True\n-- ---------------------------------------------------------------------\n  \nexisteColNoNulaDesde :: (Num a, Eq a) => Matrix a -> Int -> Int -> Bool\nexisteColNoNulaDesde p j i = \n    or [not (null (elementosNoNulosColDesde p l i)) | l <- [j..n]]\n    where n = numColumnas p\n\n-- 2\u00aa soluci\u00f3n\nexisteColNoNulaDesde2 :: (Num a, Eq a) => Matrix a -> Int -> Int -> Bool\nexisteColNoNulaDesde2 p j i = \n    submatrix i m j n p \/= zero (m-i+1) (n-j+1)\n    where (m,n) = dimension p\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 32. Definir la funci\u00f3n\n--    menorIndiceColNoNulaDesde :: (Num a, Eq a) => \n--                                 Matrix a -> Int -> Int -> Maybe Int\n-- tal que (menorIndiceColNoNulaDesde p j i) es el \u00edndice de la primera\n-- columna, a partir de la j, en el que la matriz p tiene un elemento no\n-- nulo a partir de la fila i. Por ejemplo,\n--    ghci> let p = listaMatriz [[3,2,5],[5,7,0],[6,0,0]]\n--    ghci> menorIndiceColNoNulaDesde p 2 2\n--    Just 2\n--    ghci> let q = listaMatriz [[3,2,5],[5,0,0],[6,0,2]]\n--    ghci> menorIndiceColNoNulaDesde q 2 2\n--    Just 3\n--    ghci> let r = listaMatriz [[3,2,5],[5,0,0],[6,0,0]]\n--    ghci> menorIndiceColNoNulaDesde r 2 2\n--    Nothing\n-- ---------------------------------------------------------------------\n\n-- 1\u00aa definici\u00f3n\nmenorIndiceColNoNulaDesde :: (Num a, Eq a) => \n                             Matrix a -> Int -> Int -> Maybe Int\nmenorIndiceColNoNulaDesde p j i \n    | null js   = Nothing\n    | otherwise = Just (head js)\n    where n  = numColumnas p\n          js = [j' | j' <- [j..n], \n                     not (null (elementosNoNulosColDesde p j' i))]\n\n-- 2\u00aa definici\u00f3n (con listToMaybe http:\/\/bit.ly\/212iSgl)\nmenorIndiceColNoNulaDesde2 :: (Num a, Eq a) => \n                              Matrix a -> Int -> Int -> Maybe Int\nmenorIndiceColNoNulaDesde2 p j i =\n    listToMaybe [j' | j' <- [j..n], \n                      not (null (elementosNoNulosColDesde p j' i))]\n    where n  = numColumnas p\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 33. Definir la funci\u00f3n\n--    gaussAux :: (Fractional a, Eq a) => \n--                Matrix a -> Int -> Int -> Matrix a\n-- tal que (gaussAux p i j) es la matriz que en el que las i-1 primeras\n-- filas y las j-1 primeras columnas son las de p y las restantes est\u00e1n\n-- triangularizadas por el m\u00e9todo de Gauss; es decir,\n--    1. Si la dimensi\u00f3n de p es (i,j), entonces p.\n--    2. Si la submatriz de p sin las i-1 primeras filas y las j-1\n--       primeras columnas es nulas, entonces p.\n--    3. En caso contrario, (gaussAux p' (i+1) (j+1)) siendo\n--    3.1. j' la primera columna a partir de la j donde p tiene\n--         alg\u00fan elemento no nulo a partir de la fila i,\n--    3.2. p1 la matriz obtenida intercambiando las columnas j y j'\n--         de p,\n--    3.3. i' la primera fila a partir de la i donde la columna j de\n--         p1 tiene un elemento no nulo,\n--    3.4. p2 la matriz obtenida intercambiando las filas i e i' de\n--         la matriz p1 y\n--    3.5. p' la matriz obtenida anulando todos los elementos de la\n--         columna j de p2 por debajo de la fila i.\n-- Por ejemplo,\n--    ghci> let p = listaMatriz [[1.0,2,3],[1,2,4],[3,2,5]]\n--    ghci> gaussAux p 2 2\n--    ( 1.0 2.0 3.0 )\n--    ( 1.0 2.0 4.0 )\n--    ( 2.0 0.0 1.0 )\n-- ---------------------------------------------------------------------\n\ngaussAux :: (Fractional a, Eq a) => Matrix a -> Int -> Int -> Matrix a\ngaussAux p i j \n    | dimension p == (i,j)             = p                        -- 1\n    | not (existeColNoNulaDesde p j i) = p                        -- 2  \n    | otherwise                        = gaussAux p' (i+1) (j+1)  -- 3\n    where Just j' = menorIndiceColNoNulaDesde p j i               -- 3.1 \n          p1      = intercambiaColumnas j j' p                    -- 3.2\n          Just i' = buscaIndiceDesde p1 j i                       -- 3.3\n          p2      = intercambiaFilas i i' p1                      -- 3.4\n          p'      = anulaColumnaDesde p2 j i                      -- 3.5\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 34. Definir la funci\u00f3n\n--    gauss :: (Fractional a, Eq a) => Matrix a -> Matrix a\n-- tal que (gauss p) es la triangularizaci\u00f3n de la matriz p por el m\u00e9todo\n-- de Gauss. Por ejemplo, \n--    ghci> let p = listaMatriz [[1.0,2,3],[1,2,4],[1,2,5]]\n--    ghci> gauss p\n--    ( 1.0 3.0 2.0 )\n--    ( 0.0 1.0 0.0 )\n--    ( 0.0 0.0 0.0 )\n--    ghci> let p = listaMatriz [[3%1,2,3],[1,2,4],[1,2,5]]\n--    ghci> gauss p\n--    ( 3 % 1 2 % 1 3 % 1 )\n--    ( 0 % 1 4 % 3 3 % 1 )\n--    ( 0 % 1 0 % 1 1 % 1 )\n--    ghci> let p = listaMatriz [[1.0,0,3],[1,0,4],[3,0,5]]\n--    ghci> gauss p\n--    ( 1.0 3.0 0.0 )\n--    ( 0.0 1.0 0.0 )\n--    ( 0.0 0.0 0.0 )\n-- ---------------------------------------------------------------------\n\ngauss :: (Fractional a, Eq a) => Matrix a -> Matrix a\ngauss p = gaussAux p 1 1\n\n-- ---------------------------------------------------------------------\n-- Determinante                                                       --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 35. Definir la funci\u00f3n\n--    gaussCAux :: (Fractional a, Eq a) => \n--                 Matriz a -> Int -> Int -> Int -> Matriz a\n-- tal que (gaussCAux p i j c) es el par (n,q) donde q es la matriz que\n-- en el que las i-1 primeras filas y las j-1 primeras columnas son las\n-- de p y las restantes est\u00e1n triangularizadas por el m\u00e9todo de Gauss;\n-- es decir, \n--    1. Si la dimensi\u00f3n de p es (i,j), entonces p.\n--    2. Si la submatriz de p sin las i-1 primeras filas y las j-1\n--       primeras columnas es nulas, entonces p.\n--    3. En caso contrario, (gaussAux p' (i+1) (j+1)) siendo\n--    3.1. j' la primera columna a partir de la j donde p tiene\n--         alg\u00fan elemento no nulo a partir de la fila i,\n--    3.2. p1 la matriz obtenida intercambiando las columnas j y j'\n--         de p,\n--    3.3. i' la primera fila a partir de la i donde la columna j de\n--         p1 tiene un elemento no nulo,\n--    3.4. p2 la matriz obtenida intercambiando las filas i e i' de\n--         la matriz p1 y\n--    3.5. p' la matriz obtenida anulando todos los elementos de la\n--         columna j de p2 por debajo de la fila i.\n-- y n es c m\u00e1s el n\u00famero de intercambios de columnas y filas que se han \n-- producido durante el c\u00e1lculo. Por ejemplo,\n--    ghci> gaussCAux (fromLists [[1.0,2,3],[1,2,4],[1,2,5]]) 1 1 0\n--    (1,( 1.0 3.0 2.0 )\n--       ( 0.0 1.0 0.0 )\n--       ( 0.0 0.0 0.0 ))\n-- ---------------------------------------------------------------------\n\ngaussCAux :: (Fractional a, Eq a) => \n             Matrix a -> Int -> Int -> Int -> (Int,Matrix a)\ngaussCAux p i j c \n    | dimension p == (i,j)             = (c,p)                        -- 1\n    | not (existeColNoNulaDesde p j i) = (c,p)                        -- 2  \n    | otherwise                        = gaussCAux p' (i+1) (j+1) c'  -- 3\n    where Just j' = menorIndiceColNoNulaDesde p j i                   -- 3.1 \n          p1      = switchCols j j' p                                 -- 3.2\n          Just i' = buscaIndiceDesde p1 j i                           -- 3.3\n          p2      = switchRows i i' p1                                -- 3.4\n          p'      = anulaColumnaDesde p2 j i                          -- 3.5\n          c'      = c + signum (abs (j-j')) + signum (abs (i-i'))\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 36. Definir la funci\u00f3n\n--    gaussC :: (Fractional a, Eq a) => Matriz a -> Matriz a\n-- tal que (gaussC p) es el par (n,q), donde q es la triangularizaci\u00f3n\n-- de la matriz p por el m\u00e9todo de Gauss y n es el n\u00famero de\n-- intercambios de columnas y filas que se han producido durante el\n-- c\u00e1lculo. Por ejemplo,  \n--    ghci> gaussC (fromLists [[1.0,2,3],[1,2,4],[1,2,5]])\n--    (1, ( 1.0 3.0 2.0 )\n--        ( 0.0 1.0 0.0 )\n--        ( 0.0 0.0 0.0 )\n-- ---------------------------------------------------------------------\n\ngaussC :: (Fractional a, Eq a) => Matrix a -> (Int,Matrix a)\ngaussC p = gaussCAux p 1 1 0\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 37. Definir la funci\u00f3n\n--    determinante :: (Fractional a, Eq a) => Matriz a -> a\n-- tal que (determinante p) es el determinante de la matriz p. Por\n-- ejemplo, \n--    ghci> determinante (fromLists [[1.0,2,3],[1,3,4],[1,2,5]])\n--    2.0\n-- ---------------------------------------------------------------------\n\ndeterminante :: (Fractional a, Eq a) => Matrix a -> a\ndeterminante p = (-1)^c * V.product (getDiag p')\n    where (c,p') = gaussC p\n<\/pre>\n<p>El c\u00f3digo anterior se encuentra tambi\u00e9n en <a href=\"https:\/\/github.com\/jaalonso\/I1M-Ejercicios\/blob\/master\/Ejercicios\/Rel_17_sol.hs\">GitHub<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>En la primera parte de la clase de hoy de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos comentado las soluciones de los ejercicios de la relaci\u00f3n 17 sobre vectores y matrices en Haskell usando las librer\u00edas Data.Vector y Data.Matrix. 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":[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\/5707"}],"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=5707"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5707\/revisions"}],"predecessor-version":[{"id":5708,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5707\/revisions\/5708"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=5707"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=5707"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=5707"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}