Menu Close

Representación ampliada de matrices dispersas

En el ejercicio anterior se explicó una representación reducida de las matrices dispersas. A partir del número de columnas y la representación reducida se puede construir la matriz.

Definir la función

   ampliada :: Num a => Int -> [[(Int,a)]] -> Matrix a

tal que (ampliada n xss) es la matriz con n columnas cuya representación reducida es xss. Por ejemplo,

   λ> ampliada 3 [[(3,4)],[(2,5)],[]]
   ( 0 0 4 )
   ( 0 5 0 )
   ( 0 0 0 )
 
   λ> ampliada 3 [[],[]]
   ( 0 0 0 )
   ( 0 0 0 )
 
   λ> ampliada 2 [[],[],[]]
   ( 0 0 )
   ( 0 0 )
   ( 0 0 )

Soluciones

import Data.Matrix (Matrix, fromLists)
import Data.List   (lookup)
 
ampliada :: Num a => Int -> [[(Int,a)]] -> Matrix a
ampliada n xss =
  fromLists [filaAmpliada n xs | xs <- xss]
 
-- Se puede redefinir con un argumento
ampliada2 :: Num a => Int -> [[(Int,a)]] -> Matrix a
ampliada2 n = fromLists . map (filaAmpliada n)
 
-- Se puede redefinir sin argumentos usando las siguientes reducciones
--      fromLists . map (filaAmpliada n)
--    = fromLists . ((map . filaAmpliada) n)
--    = ((fromLists .) . (map . filaAmpliada)) n
--    = ((fromLists .) . map . filaAmpliada) n
ampliada3 :: Num a => Int -> [[(Int,a)]] -> Matrix a
ampliada3 = (fromLists .) . map . filaAmpliada
 
-- (filaAmpliada n xs) es la fila ampliada de la representación reducida
-- xs de una matriz con n columnas. Por ejemplo, 
--    filaAmpliada 3 [(2,5)]        ==  [0,5,0]
--    filaAmpliada 7 [(2,5),(1,3)]  ==  [3,5,0,0,0,0,0]
filaAmpliada :: Num a => Int -> [(Int,a)] -> [a]
filaAmpliada n xs =
  [f (lookup i xs) | i <- [1..n]]
  where f Nothing  = 0
        f (Just x) = x

5 soluciones de “Representación ampliada de matrices dispersas

  1. angruicam1
    import Data.Matrix (Matrix, fromLists)
     
    ampliada :: Num a => Int -> [[(Int,a)]] -> Matrix a
    ampliada n xss = fromLists (map (aux n) xss)
      where aux n []         = replicate n 0
            aux n ((x,y):xs) = replicate (x-1) 0 ++ y : aux (n-x) xs
    • angruicam1

      Creo que no es correcta para cuando haya más de un elemento distinto de 0 en una fila, corregida creo que es así:

      import Data.Matrix (Matrix, fromLists)
       
      ampliada :: Num a => Int -> [[(Int,a)]] -> Matrix a
      ampliada n xss = fromLists (map (aux 0 n) xss)
        where aux m n []         = replicate (n-m) 0
              aux m n ((x,y):xs) = replicate (x-m-1) 0 ++ y : aux x n xs
  2. albcarcas1
    Está definida de forma un poco complicada pero funciona
     
    import Data.Matrix
     
    ampliada :: Num a => Int -> [[(Int,a)]] -> Matrix a
    ampliada n xss = aux cs
       where aux [] = zero (length xss) n
             aux [c] = c
             aux (c:d:cs) = (c + d) + aux cs 
             cs = sustituye xss (zero (length xss) n)
     
    sustituye :: [[(Int,a)]] -> Matrix a -> [Matrix a]
    sustituye xss p = [setElem x (i,j) p | (i,[(j,x)]) <- zip [1..] xss]
  3. carbremor
    import Data.Matrix
     
    ampliada :: Num a => Int -> [[(Int,a)]] -> Matrix a
    ampliada n = fromLists . map (filaAmpliada n 1)
     
    filaAmpliada :: Num a => Int -> Int -> [(Int,a)] -> [a]
    filaAmpliada n i [] = replicate (n-i+1) 0
    filaAmpliada n i pss@((k,a):ps) =
        if i==k
        then a : filaAmpliada n (i+1) ps
        else 0 : filaAmpliada n (i+1) pss
  4. Chema Cortés
    ampliada :: Num a => Int -> [[(Int,a)]] -> Matrix a
    ampliada n = fromLists . map aux
      where
        zeros = replicate n 0
        aux = foldl setValue zeros
     
    setValue :: [a] -> (Int, a) -> [a]
    setValue xs (n,x) = ys ++ x:tail zs
      where
        (ys,zs) = splitAt (n-1) xs

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.