modifica di array a Haskell e ricordando indici

ho bisogno di fare le trasformazioni a un sottoarray, e potrebbe essere necessario effettuare trasformazioni su un sottoarray di sottoarray, e così via.modifica di array a Haskell e ricordando indici

C'è modo intuitivo di fare questo in Haskell, come ad esempio la definizione di un sottoarray o qualcosa del genere? Ho letto la sezione su matrici in "un'introduzione graduale alla Haskell", e non affronta, e ho una difficoltà a trovare un modo per farlo.

E 'per un'implementazione dell'algoritmo ungherese come descritto here su wikipedia.

Così finora ho fatto quanto segue:

import Array 

step1 :: (Ord a , Num a) => Array (Int,Int) a -> Array (Int,Int) a 
step1 a  = a // [ ((i,j), f (i,j)) | (i,j) <- range (bounds a) ] where 
    f (i,j) = a!(i,j) - minRow i 
    minRow i = minimum [ a!(i,j) | j <- [1..(snd . snd . bounds) a] ] 

step2 :: (Ord a , Num a) => Array (Int,Int) a -> Array (Int,Int) a 
step2 a  = a // [ ((i,j), f (i,j)) | (i,j) <- range (bounds a) ] where 
    f (i,j) = a!(i,j) - minCol j 
    minCol j = minimum [ a!(i,j) | i <- [1..(fst . snd . bounds) a] ]

Il problema è che non so come implementare punti 3 e 4, che continua la procedura a un sottomatrice, nel caso in cui una soluzione è non facilmente disponibile.

fonte

2012-03-21 Undreren

C'è un codice di esempio su Hackage che potrebbe dare una mano, vedere http://hackage.haskell.org/packages/archive/Munkres/0.1/doc/html/src/Data-Algorithm-Munkres.html#hungarianMethodInt –

C'è un sacco di codice qui che non capisco davvero. Ad esempio, come viene definito l'operatore '@'? È usato in circa ogni seconda riga, in espressioni come 'xxs @ (x: xs)'. – Undreren

L'operatore '@' è usato per dare un nome ai componenti che corrispondono a un modello. Significa che 'xxs' può essere usato per riferirsi all'espressione che corrisponde a' (x: xs) ' –

ho trovato un modo per aggirare, allthough è un po 'di hack. E funziona solo su array 2D, cioè array di tipo Array (Int,Int) Int. Ecco quello che ho fatto:

import Data.Array 
import Control.Applicative 

updateSubArr :: [Int] -> [Int] -> (Array (Int,Int) Int -> Array (Int,Int) Int) 
         -> Array (Int,Int) Int -> Array (Int,Int) Int 
updateSubArr rows cols f arr = arr // (zip [(i,j) | i <- rows, j <- cols ] 
           [ fSubArr!i | i <- range $ bounds subArr ]) where 
fSubArr = f subArr 
subArr = subArray cols rows arr 

subArray rows cols arr = subArr where 
    js  = length cols 
    is  = length rows 
    subArr  = array subBounds $ zip (range subBounds) 
          [ arr!(i,j) | i <- rows, j <- cols ] 
    subRange = range subBounds 
    subBounds = ((1,1),(is,js))

questo potrebbe essere fatto per lavorare per un generale Array a b?

fonte

2012-03-23 12:17:00 Undreren

modifica di array a Haskell e ricordando indici

risposta

Problemi correlati