{"id":1333,"date":"2011-04-25T14:12:12","date_gmt":"2011-04-25T14:12:12","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=1333"},"modified":"2011-04-28T07:12:50","modified_gmt":"2011-04-28T07:12:50","slug":"i1m2010-ejercicios-sobre-vectores-y-matrices-en-haskell-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2010-ejercicios-sobre-vectores-y-matrices-en-haskell-2\/","title":{"rendered":"I1M2010: Ejercicios sobre vectores y matrices en Haskell (2)"},"content":{"rendered":"<p>En la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-10\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos continuado comentando las soluciones a los ejercicios sobre vectores y matrices en Haskell de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2010\/index.php5\/Relaci%C3%B3n_28\">28\u00aa relaci\u00f3n<\/a> que iniciamos en la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2010-ejercicios-sobre-vectores-y-matrices-en-haskell\/\">clase del d\u00eda 7<\/a>.<\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<!--more--><\/p>\n<pre lang=\"haskell\">\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 (diagonalPral p)\r\n--    [5,2]\r\n-- ---------------------------------------------------------------------\r\n\r\ndiagonalSec :: Num a => Matriz a -> Vector a\r\ndiagonalSec p = array (1,n) [(i,p!(i,m+1-i)) | i <- [1..n]]\r\n    where n = min (numFilas p) (numColumnas p)\r\n          m = numFilas 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 = \r\n    array ((1,1), (m,n))\r\n          [((i,j), p! f i j) | i <- [1..m], j <- [1..n]]\r\n    where (m,n) = dimension p\r\n          f i j | i == k    = (l,j)\r\n                | i == l    = (k,j)\r\n                | otherwise = (i,j)\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 = \r\n    array ((1,1), (m,n))\r\n          [((i,j), p ! f i j) | i <- [1..m], j <- [1..n]]\r\n    where (m,n) = dimension p\r\n          f i j | j == k    = (i,l)\r\n                | j == l    = (i,k)\r\n                | otherwise = (i,j)\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 = \r\n    array ((1,1), (m,n))\r\n          [((i,j), f i j)  | i <- [1..m], j <- [1..n]]\r\n    where (m,n) = dimension p\r\n          f i j | i == k    = x*(p!(i,j))\r\n                | otherwise = p!(i,j)\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 = \r\n    array ((1,1), (m,n))\r\n          [((i,j), f i j) | i <- [1..m], j <- [1..n]]\r\n    where (m,n) = dimension p\r\n          f i j | i == k    = p!(i,j) + p!(l,j)\r\n                | otherwise = p!(i,j)        \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 = \r\n    array ((1,1), (m,n))\r\n          [((i,j), f i j) | i <- [1..m], j <- [1..n]]\r\n    where (m,n) = dimension p\r\n          f i j | i == k    = p!(i,j) + x*p!(l,j)\r\n                | otherwise = p!(i,j)\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 => 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 => Matriz a -> Int -> Int -> Maybe Int\r\nbuscaIndiceDesde p j i \r\n    | null xs   = Nothing\r\n    | otherwise = Just (head xs)\r\n    where xs = [k | ((k,j'),y) <- assocs p, j == j', y \/= 0, k>=i] \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 26. Definir la funci\u00f3n\r\n--    buscaPivoteDesde :: Num a => 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 => Matriz a -> Int -> Int -> Maybe a\r\nbuscaPivoteDesde p j i \r\n    | null xs   = Nothing\r\n    | otherwise = Just (head xs)\r\n    where xs = [y | ((k,j'),y) <- assocs p, j == j', y \/= 0, k>=i] \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 27. Definir la funci\u00f3n\r\n--    anuladaColumnaDesde :: Num a => 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 => Matriz a -> Int -> Int -> Bool\r\nanuladaColumnaDesde p j i = \r\n    buscaIndiceDesde p j (i+1) == Nothing\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 28. Definir la funci\u00f3n\r\n--    anulaEltoColumnaDesde :: Num a => 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 => Matriz a -> Int -> Int -> Matriz a\r\nanulaEltoColumnaDesde p j i = \r\n    sumaFilaPor l i (-(p!(l,j)\/a)) p\r\n    where Just l = buscaIndiceDesde p j (i+1)\r\n          a      = p!(i,j)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 29. Definir la funci\u00f3n\r\n--    anulaColumnaDesde :: Fractional a => 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 => Matriz a -> Int -> Int -> Matriz a\r\nanulaColumnaDesde p j i\r\n    | anuladaColumnaDesde p j i = p\r\n    | otherwise = anulaColumnaDesde (anulaEltoColumnaDesde p j i) j i \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 => 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 => Matriz a -> Int -> Int -> [a]\r\nelementosNoNulosColDesde p j i = \r\n    [x | ((k,j'),x) <- assocs p, x \/= 0, j' == j, k >= i]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 31. Definir la funci\u00f3n\r\n--    existeColNoNulaDesde :: Num a => 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 => Matriz a -> Int -> Int -> Bool\r\nexisteColNoNulaDesde p j i = \r\n    or [not (null (elementosNoNulosColDesde p l i)) | l <- [j..n]]\r\n    where n = numColumnas p\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 32. Definir la funci\u00f3n\r\n--    menorIndiceColNoNulaDesde \r\n--      :: Num a => 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) => Matriz a -> Int -> Int -> Maybe Int\r\nmenorIndiceColNoNulaDesde p j i \r\n    | null js   = Nothing\r\n    | otherwise = Just (head js)\r\n    where n  = numColumnas p\r\n          js = [j' | j' <- [j..n], \r\n                     not (null (elementosNoNulosColDesde p j' i))]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 33. Definir la funci\u00f3n\r\n--    gaussAux :: Fractional a => 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 => Matriz a -> Int -> Int -> Matriz a\r\ngaussAux p i j \r\n    | dimension p == (i,j)             = p                        -- 1\r\n    | not (existeColNoNulaDesde p j i) = p                        -- 2  \r\n    | otherwise                        = gaussAux p' (i+1) (j+1)  -- 3\r\n    where Just j' = menorIndiceColNoNulaDesde p j i               -- 3.1 \r\n          p1      = intercambiaColumnas j j' p                    -- 3.2\r\n          Just i' = buscaIndiceDesde p1 j i                       -- 3.3\r\n          p2      = intercambiaFilas i i' p1                      -- 3.4\r\n          p'      = anulaColumnaDesde p2 j i                      -- 3.5\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 34. Definir la funci\u00f3n\r\n--    gauss :: Fractional 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 => Matriz a -> Matriz a\r\ngauss p = gaussAux p 1 1\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 => 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 => Matriz a -> a\r\ndeterminante p = product (elems (diagonalPral (gauss p)))\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la clase de hoy de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos continuado comentando las soluciones a los ejercicios sobre vectores y matrices en Haskell de la 28\u00aa relaci\u00f3n que iniciamos en la clase del d\u00eda 7. Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","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":[133],"tags":[287],"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\/1333"}],"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=1333"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/1333\/revisions"}],"predecessor-version":[{"id":1334,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/1333\/revisions\/1334"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=1333"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=1333"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=1333"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}