<table cellspacing="0" cellpadding="0" border="0" ><tr><td valign="top" style="font: inherit;">Brian wrote:<br>> Really, arrays in Haskell are the most @#!$! confusing thing in the world.<br><br>Hi, Brian. <br>I am having a great difficulty with arrays in Haskell. In the university where I study, functional programming is taught in Clean or in Haskell, depending on the professor who is teaching the subject in a given year. One year ago, when I took functional programming, the professor used Clean in his classes. I had no difficulty in learning how arrays and input/output work in Clean. In the case of arrays, the idea is very simple: One can update arrays, provided that s/he does not try to access the old array. Therefore, one needs to make a copy of any value of the old array that s/he will use before performing the update; the operation that makes copies also provides a new name for the array, that obliterates the old name. In order
to get a better feeling of the thing, here is the `solvitī function, in Clean and Haskell (you can consider the # as a kind of do):<br><br>// Clean<br>leftSide acc i j n arr | j >= n= (acc, arr);<br> # (v, arr)= arr![j, n];<br> (a, arr)= arr![i, j];<br> = leftSide (acc-v*a) i (j+1) n arr;<br><br>solvit i n arr | i < 0 = arr<br> # (a, arr)= arr![i, i];<br> (acc, arr)= arr![i, n];<br> (v, arr)= leftSide acc i (i+1) n arr;<br> = solvit (i-1) n {arr&[i, n]= v/a};<br><br>-- HASKELL<br>leftSide acc i j n arr | j>n= return acc<br>leftSide acc i j n arr = do<br> v <- readArray arr (j, n+1)<br> a <- readArray arr (i, j)<br> leftSide (acc-v*a) i (j+1) n arr<br><br>solvit i n arr | i<1= return ()<br>solvit i n arr= do<br> a <- readArray arr (i, i)<br> acc <- readArray arr (i,
n+1)<br> v <- leftSide acc i (i+1) n arr<br> writeArray arr (i, n+1) $! (v/a)<br> solvit (i-1) n arr<br><br>And here comes the reason for writing this article. In the previous version of the Gauss elimination algorithm, I have imported Data.Array.IO. I also wrote a version of the program that imports Data.Array.ST. The problem is that I don't know how to read an STUArray from a file, process it, and write it back to a file. Is it possible to transform it into an IOUArray pro tempore, read it, make it into an STUArray again in order to process it, and bring it back to IOUArray in order to print it? Below, you will find the Gauss elimination program in STUArray (by the way, it is slower than IOUArray). Could you modify the main function so it can read array `arrī from a file, and write the result to a file? Here is the Gauss Elimination for STUArray (the main function is the first one; modify it to
read the array from a file, and write it back to a file):<br><br>import Control.Monad<br>import Control.Monad.ST<br>import Data.Array.ST<br>import Data.Array.IO <br>import System.IO<br>import System.Random<br>import System (getArgs)<br><br><br>main = do<br> xs <- rnList (1.0,1000.0)<br> args <- getArgs<br> let (n, m)= dims args<br> xx <- stToIO $ do<br> arr <- newArray_ ((1,1),(n,m+1)) :: <br> ST s (STUArray s (Int, Int) Double)<br> fillArray xs 0.0 (1,n) (1,m)
arr<br> sLU arr n<br> solvit n n arr<br> x1 <- readArray arr (1, n+1)<br> x2 <- readArray arr (1, n+1)<br> return [x1, x2]<br> print xx<br><br><br>{- -- Other option:<br>main = do<br> xs <- rnList (1.0,1000.0)<br> args <- getArgs<br> let (n, m)= dims args<br> print $ runST $
do<br> arr <- newArray_ ((1,1),(n,m+1)) :: <br> ST s (STUArray s (Int, Int) Double)<br> fillArray xs 0.0 (1,n) (1,m) arr<br> sLU arr n<br> solvit n n arr<br> x1 <- readArray arr (1, n+1)<br> x2 <- readArray arr (1,
n+1)<br> return [x1, x2]<br>-} <br><br>fillArray xs s (i, n) (j, m) arr | i > n= return ()<br>fillArray xs s (i,n) (j, m) arr | i==n && j>m= do<br> writeArray arr (i, j) $! s<br> return ()<br>fillArray xs s (i, n) (j, m) arr | j > m = do<br> writeArray arr (i, j) $! s<br> fillArray xs 0.0 (i+1, n) (1, m) arr<br>fillArray (val:xs) s (i, n) (j, m) arr= do<br> writeArray arr (i, j) $! val<br> fillArray xs (s+val) (i, n) (j+1, m) arr<br><br>sLU arr n= sIJ 2 1 2 n arr<br><br>sIJ i j k n arr | i > n = return ()<br>sIJ i j k n arr | k > n = sIJ (i+1) i (i+1) n arr<br>sIJ i j k n arr = do<br> {- im <- pmax (j+1) j<br> swap j im 1 -}<br> a <- readArray arr (k, j)<br> forM_ [j..n+1] $ \l -> do<br>
ajj <- readArray arr (j, j)<br> ajl <- readArray arr (j, l)<br> akl <- readArray arr (k, l) <br> writeArray arr (k, l) $! (akl-a*(ajl/ajj))<br> sIJ i j (k+1) n arr where<br> pmax line imax | line > n = return imax<br> pmax line imax = do<br> alj <- readArray arr (line, j)<br> aij <- readArray arr (imax, j)<br> if (abs alj)> (abs aij) <br> then pmax (line+1) line<br> else pmax (line+1) imax<br> swap r s q | q>n+1 = return ()<br> swap r s q | r==s = return ()<br> swap r s q =
do<br> arq <- readArray arr (r,q)<br> asq <- readArray arr (s,q)<br> writeArray arr (s,q) $! arq<br> writeArray arr (r,q) $! asq<br> swap r s (q+1)<br> <br> <br>leftSide acc i j n arr | j>n= return acc<br>leftSide acc i j n arr = do<br> v <- readArray arr (j, n+1)<br> a <- readArray arr (i, j)<br> leftSide (acc-v*a) i (j+1) n arr<br><br>solvit i n arr | i<1= return ()<br>solvit i n arr= do<br> a <- readArray arr (i, i)<br> acc <- readArray arr (i, n+1)<br> v <- leftSide acc i (i+1) n arr<br> writeArray arr (i, n+1) $! (v/a)<br> solvit (i-1) n arr<br><br>rnList :: (Double, Double) -> IO
[Double]<br>rnList r=getStdGen>>=(\x->return(randomRs r x))<br><br>dims [input] = (read input, read input)<br>dims _ = (1000, 1000)<br><br><br><br><br><br>--- On <b>Tue, 11/3/09, brian <i><briand@aracnet.com></i></b> wrote:<br><blockquote style="border-left: 2px solid rgb(16, 16, 255); margin-left: 5px; padding-left: 5px;"><br>From: brian <briand@aracnet.com><br>Subject: Re: [Haskell-cafe] What's the deal with Clean?<br>To: "David Leimbach" <leimy2k@gmail.com><br>Cc: haskell-cafe@haskell.org<br>Received: Tuesday, November 3, 2009, 7:12 PM<br><br><div class="plainMail">Really, arrays in Haskell are the most @#!$! confusing thing in the world.<br><br>There's a bunch of different array structures.<br><br>I can't tell which one works best, and all I want to do is x[i] = value.<br><br>I thought uvector was the answer, you know, fast unboxed ARRAYs. Imagine my surprise when I saw this<br><br> indexU :: UA e => UArr e
-> Int -> e<br><br> O(n). indexU extracts an element out of an immutable unboxed array.<br><br>An array implementation with an order N lookup. huh ?? That's not an array, that's a list. I was looking for an array.<br><br>However, I then found in the same hackage:<br><br> readMU :: MUArr e s -> Int -> ST s e<br><br> O(1). readMU reads the element at the specified index of a mutable unboxed array.<br><br>So O(1) for mutable, but O(n) for immutable ? See, confusing... I'm sure there's a really good, lofty type safety, something<br>or other reason for that, that I'm sure I don't care about ;-)<br><br>There's also ST. So why is there a uvector, when there's ST ??<br><br>etc, etc, etc...<br><br>and then there's monads...<br><br>other than that, having fun with haskell :-)<br><br>Brian<br><br><br>On Nov 3, 2009, at 3:42 PM, David Leimbach wrote:<br><br>> <br>> <br>> On Tue, Nov 3, 2009 at
2:16 PM, Tracy Wadleigh <<a ymailto="mailto:tracy.wadleigh@gmail.com" href="/mc/compose?to=tracy.wadleigh@gmail.com">tracy.wadleigh@gmail.com</a>> wrote:<br>> <br>> I had to implement a ring buffer, and I wanted the code using it to be written in Haskell. I ended up implementing the buffer in C, and wrapping it in FFI from Haskell because implementing a destructive array in Haskell is kind of unwieldy to someone of my experience level. In Clean, it looks like the uniqueness typing allows for destructive updates in a very controlled manner.<br>> <br>> The ST monad provides this functionality. The never-instantiated-in-a-visible-way state parameter of the ST monad provides the "uniqueness" required for doing destructive updates in a pure way.<br>> <br>> Someone suggested that to me on IRC once I'd already cranked out a C implementation with FFI bindings. It's just too easy to use the FFI in Haskell :-)<br>>
<br>> If we raise the barrier of FFI, more people will use ST!<br>> <br>> Dave<br>> <br>> <br>> <br>> _______________________________________________<br>> Haskell-Cafe mailing list<br>> <a ymailto="mailto:Haskell-Cafe@haskell.org" href="/mc/compose?to=Haskell-Cafe@haskell.org">Haskell-Cafe@haskell.org</a><br>> <a href="http://www.haskell.org/mailman/listinfo/haskell-cafe" target="_blank">http://www.haskell.org/mailman/listinfo/haskell-cafe</a><br>> <br>> <br>> _______________________________________________<br>> Haskell-Cafe mailing list<br>> <a ymailto="mailto:Haskell-Cafe@haskell.org" href="/mc/compose?to=Haskell-Cafe@haskell.org">Haskell-Cafe@haskell.org</a><br>> <a href="http://www.haskell.org/mailman/listinfo/haskell-cafe" target="_blank">http://www.haskell.org/mailman/listinfo/haskell-cafe</a><br><br>_______________________________________________<br>Haskell-Cafe mailing list<br><a
ymailto="mailto:Haskell-Cafe@haskell.org" href="/mc/compose?to=Haskell-Cafe@haskell.org">Haskell-Cafe@haskell.org</a><br><a href="http://www.haskell.org/mailman/listinfo/haskell-cafe" target="_blank">http://www.haskell.org/mailman/listinfo/haskell-cafe</a><br></div></blockquote></td></tr></table><br>
<hr size=1><a href="http://ca.promos.yahoo.com/newmail/overview2/"><b>All new Yahoo! Mail - </b></a>Get a sneak peak at messages with a handy reading pane.