Dougal Stanton wrote:

To create an infinite list where each f(u) depends on the previous u, with a single seed value, use 'iterate':

main = mapM_ (uncurry (printf "%d %f\n")) (zip [1..50] (iterate f 3))

How about main = sequence_ $ zipWith (printf "%d %f\n") [1..50] (iterate f 3) Regards, apfelmus

Thanks to all of you. The suggestions work like a charm. Very nice. I still need to digest the advices, but have already one further question: How would I compute the new value based on the 2 (or even more) last values instead of only the last one? [ 2, 3 , f 3 2, f((f 3 2) 3), f ( f((f 3 2) 3) f 3 2)), ...] (background: I am doing explicit time stepping for some physical problem, where higher order time integration schemes are interesting. You advance in time by extrapolating based on the old time step values.) I guess I just wrote the definition and define iterate2 as iterate2 history = case history of [] -> error "no start values" x1:x2:xs -> iterate2 ([f x1 x2] ++ xs) or iterate2 :: [Double] -> [Double] iterate2 history = case history of [] -> error "two start values needed" x1:[] -> error "one more start values" x1:x2:xs -> iterate2 (history ++ ([f a b])) where [a,b] = take 2 $ reverse history however,I don't get it this to work. Is it possible to see the definition of the iterate function? The online help just shows it's usage... Again thanks a lot for your ideas and the links. I knew there was a one-liner for my problem, but I couldn't find it for days. Axel Dougal Stanton wrote:

On 06/09/07, Axel Gerstenberger wrote:

...

module Main where

import System.IO import Text.Printf

main :: IO () main = do let all_results1 = take 20000 $ step [1] --print $ length all_results1 -- BTW: if not commented out, -- all values of all_results -- are already -- calculated here loop [1..50] $ \i -> do let x = all_results1!!i putStrLn $ show i ++ " " ++ show x

-- create an infinite list with values u_{n+1} ++ [u_n,u_{n-1},...,u_1] -- where u_{n+1} = f (u_n) step history = case history of [] -> error "no start values" xs -> xs ++ (step [ f (head $ reverse (xs) )])

To create an infinite list where each f(u) depends on the previous u, with a single seed value, use 'iterate':

Prelude> let us = iterate f 3

That produces your infinite list of values, starting with [f 3, f(f3), f(f(f 3)), ...]. Pretty neat.

Then all you really need is

main = mapM_ (uncurry (printf "%d %f\n")) (zip [1..50] (iterate f 3))

You can probably shorten this a bit more with arrows but I've got a cold at the moment and not really thinking straight.

Cheers,

D.

On 06/09/07, Axel Gerstenberger wrote:

Thanks to all of you. The suggestions work like a charm. Very nice.

I still need to digest the advices, but have already one further question: How would I compute the new value based on the 2 (or even more) last values instead of only the last one?

[ 2, 3 , f 3 2, f((f 3 2) 3), f ( f((f 3 2) 3) f 3 2)), ...]

foo = 2 : 3 : zipWith f (drop 1 foo) foo There's also zipWith3 etc. for functions with more arguments. -- Sebastian Sylvan +44(0)7857-300802 UIN: 44640862

On 9/6/07, Dougal Stanton wrote:

On 06/09/07, Sebastian Sylvan wrote: [2,3,4,9,16,29,54,99,182,335] -- what's this?

Two times this: http://www.research.att.com/~njas/sequences/A000213 plus this: http://www.research.att.com/~njas/sequences/A001590 plus two times this: http://www.research.att.com/~njas/sequences/A000073 All of which are a form of Tribonacci numbers. -- Dan

When you get to more than two arguments, it will probably be nicer to do something like this: fibs = map (\(a,b) -> a) $ iterate (\(a,b) -> (b, a+b)) (0,1) or fibs = unfoldr (\(a,b) -> Just (a, (b, a+b))) (0,1) -- this uses unfoldr to get rid of the map This is essentially a translation of the imperative algorithm - the state is stored in the tuple, which is repeatedly transformed by the function \(a,b) -> (b, a+b), and then you extract the values to be yielded from the state with \(a,b) -> a. On 06/09/07, Axel Gerstenberger wrote:

Thanks to all of you. The suggestions work like a charm. Very nice.

I still need to digest the advices, but have already one further question: How would I compute the new value based on the 2 (or even more) last values instead of only the last one?

[ 2, 3 , f 3 2, f((f 3 2) 3), f ( f((f 3 2) 3) f 3 2)), ...]

(background: I am doing explicit time stepping for some physical problem, where higher order time integration schemes are interesting. You advance in time by extrapolating based on the old time step values.)

I guess I just wrote the definition and define iterate2 as

iterate2 history = case history of [] -> error "no start values" x1:x2:xs -> iterate2 ([f x1 x2] ++ xs) or

iterate2 :: [Double] -> [Double] iterate2 history = case history of [] -> error "two start values needed" x1:[] -> error "one more start values" x1:x2:xs -> iterate2 (history ++ ([f a b])) where [a,b] = take 2 $ reverse history

however,I don't get it this to work. Is it possible to see the definition of the iterate function? The online help just shows it's usage...

Again thanks a lot for your ideas and the links. I knew there was a one-liner for my problem, but I couldn't find it for days.

Axel

Dougal Stanton wrote:

...

On 06/09/07, Axel Gerstenberger wrote:

...

module Main where

import System.IO import Text.Printf

main :: IO () main = do let all_results1 = take 20000 $ step [1] --print $ length all_results1 -- BTW: if not commented out, -- all values of all_results -- are already -- calculated here loop [1..50] $ \i -> do let x = all_results1!!i putStrLn $ show i ++ " " ++ show x

-- create an infinite list with values u_{n+1} ++ [u_n,u_{n-1},...,u_1] -- where u_{n+1} = f (u_n) step history = case history of [] -> error "no start values" xs -> xs ++ (step [ f (head $ reverse (xs) )])

To create an infinite list where each f(u) depends on the previous u, with a single seed value, use 'iterate':

Prelude> let us = iterate f 3

That produces your infinite list of values, starting with [f 3, f(f3), f(f(f 3)), ...]. Pretty neat.

Then all you really need is

main = mapM_ (uncurry (printf "%d %f\n")) (zip [1..50] (iterate f 3))

You can probably shorten this a bit more with arrows but I've got a cold at the moment and not really thinking straight.

Cheers,

D.

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

Hi all, thanks again for all the responses on the "imperative loop" question. Here is another questions: I am used to work with map, zip and zipWith, when working with lists, however, I could not find such functions for Arrays. For example, in my Finite Element prototype, I have a function

type Dof = Double type TimeInc = Double

predictU :: Double -> TimeInc -> Dof -> Dof -> Dof -> Dof predictU beta dt u u_t u_tt = u + dt*u_t + ((dt**2.0)/2.0)*(1.0 - 2.0*beta ) * u_tt

Given 3 equal sized lists un, vn and an of double values [Dof], I apply it with

u_est = zipWith3 (predictU beta dt) un vn an

I like it's conciseness, but is that efficient? The lists can be very long and correspond to a plain C++ vectors in corresponding C++ codes. my own "map" for a vector I defined based on the Array documention (Data.Array) as

mapVec f vec = vec//[ (i, f(vec!i)) |i<-[a..b]] where (a,b) = bounds vec

I guess, I could implement zip and zipWith in a similar manner, but using list comprehension seems weird and inefficient here. I wonder if these standard functions are already defined somewhere. I only found "amap" for IArrays http://cvs.haskell.org/Hugs/pages/libraries/base/Data-Array-IArray.html but no zip, zipWith or even zipWith3. The whole point of using (unboxed) Arrays instead of lists is memory performce and speead of random access. Any hints on how to do zipWith on arrays is highly appreciated. Best, Axel Gerstenberger Henning Thielemann schrieb:

On Thu, 6 Sep 2007, Axel Gerstenberger wrote:

...

Thanks to all of you. The suggestions work like a charm. Very nice.

I still need to digest the advices, but have already one further question: How would I compute the new value based on the 2 (or even more) last values instead of only the last one?

[ 2, 3 , f 3 2, f((f 3 2) 3), f ( f((f 3 2) 3) f 3 2)), ...]

(background: I am doing explicit time stepping for some physical problem, where higher order time integration schemes are interesting. You advance in time by extrapolating based on the old time step values.)

You might be interested in some ideas on how to solve differential equations numerically in an elegant way: http://darcs.haskell.org/htam/src/Numerics/ODEEuler.lhs

On 9 Sep 2007, at 10:05 pm, Axel Gerstenberger wrote:

I am used to work with map, zip and zipWith, when working with lists, however, I could not find such functions for Arrays.

They aren't there for at least two reasons. (1) They are easy to implement on top of the operations that are provided. (EASY is not the same as EFFICIENT, of course.) (2) In some cases it isn't obvious what the operations should be. I note as a counter-argument that Clean provides, in addition to list comprehension and list generators, array comprehension and array generators, so maps and zips of any arity are directly and transparently available in a very Haskell-like language. I note as a counter-counter-argument that Clean is free of Haskell's "Ix" baggage, which takes us back to (2). zip being a special case of zipWith, let's consider just map and zipWith. amap :: Ix i => (a -> b) -> Array i a -> Array i b amap f arr = listArray (bounds arr) (map f (elems arr)) A more general version of this is available, under that name, in Data.Array.IArray, and Data.Array.MArray gives you mapArray. aZipWith :: Ix i => (a -> b -> c) -> Array i a -> Array i b -> Array i c aZipWith f a1 a2 = if bounds a1 == bounds a2 then listArray (bounds a1) (zipWith f (elems a1) (elems a2)) else error "aZipWith: array bounds do not agree" But do you really want aMap's result to have the same bounds as its argument? If not, what bounds do you want it to have? Do you want aZipWith to fail if the arrays haven't exactly the same bounds, or do you want to work with the intersection of their bounds, or what? A worse problem these days is that in the dotted libraries there are so *many* variants of arrays. We need to start writing stuff like aZipWith :: (Ix i, IArray a1 e1, IArray a2 e2, IArray a3 e3) => (e1 -> e2 -> e3) -> a1 i a1 -> a2 i e2 -> a3 i e3 and this is deeper waters than I am comfortable swimming in. (What's the best thing to read to explain functional dependencies for multi-parameter type classes?)

ok wrote:

On 9 Sep 2007, at 10:05 pm, Axel Gerstenberger wrote:

...

I am used to work with map, zip and zipWith, when working with lists, however, I could not find such functions for Arrays.

They aren't there for at least two reasons. (1) They are easy to implement on top of the operations that are provided. (EASY is not the same as EFFICIENT, of course.) (2) In some cases it isn't obvious what the operations should be.

I note as a counter-argument that Clean provides, in addition to list comprehension and list generators, array comprehension and array generators, so maps and zips of any arity are directly and transparently available in a very Haskell-like language.

I note as a counter-counter-argument that Clean is free of Haskell's "Ix" baggage, which takes us back to (2).

LOL! Now there's a convuloted argument... Personally, I always use 0-origin arrays. I often forget that it's *possible* to use something else. (The obvious example being tuple indexes...)

zip being a special case of zipWith, let's consider just map and zipWith.

I also find it puzzling that the mutable arrays do not provide an analogue of map with works in-place. (Surely this is the entire *point* of mutable arrays?) I mean, it's not difficult to implement it manually yourself, but we all know that home-grown implementations aren't ideal.

But do you really want aMap's result to have the same bounds as its argument? If not, what bounds do you want it to have? Do you want aZipWith to fail if the arrays haven't exactly the same bounds, or do you want to work with the intersection of their bounds, or what?

How about you specify what bounds you want in the zip call? And it then iterates the two arrays from beginning to end like the normal list-zip does. (Of course, then it has a different arity in addition to a different type signature...)

A worse problem these days is that in the dotted libraries there are so *many* variants of arrays. We need to start writing stuff like

aZipWith :: (Ix i, IArray a1 e1, IArray a2 e2, IArray a3 e3) => (e1 -> e2 -> e3) -> a1 i a1 -> a2 i e2 -> a3 i e3

and this is deeper waters than I am comfortable swimming in.

Yeah, I get the impression that the entire thing wants redesigning. It's too complicated and ad-hoc at the moment. (OTOH, who is going to undertake this?)

(What's the best thing to read to explain functional dependencies for multi-parameter type classes?)

Good question...