Verlet integration in Haskell

Verlet integration algorithm written in 3 minutes

-- Verlet integration

projOneTwo ( a, b, c , d ,e ) = ( a, b)

nextStepInt (_ ,_ , 0 ,_ ,_ ) = []

nextStepInt ( xt ,vt , n , acc , h ) =

let

atph = acc . ( xt + ) $ h

vtph = vt + atph * h * 0.5

xtph = xt + h * vt + 0.5 * acc xt * h^2

in

( xtph, vtph , n-1 , acc , h ) : nextStepInt ( xtph, vtph , n-1 , acc , h )

timeInt ( xt ,vt , n , acc , h ) = map ( projOneTwo ) $ nextStepInt ( xt ,vt , n , acc , h )

example ( spring ) :

timeInt (0 , 1 , 10000 , (\x -> 0.1 * ( - x ) ) , 0.2 )

Cairo-Chaos Haskell

Haskell chaos and lib-cairo.

Is only a fixed-point iteration over this function:

lgs x r = r * x * exp(- x )

Dollar $ operator in Haskell

Do you know what is $ operator in Haskell?
$ means simply , 'apply the left function at the right value'.

f $ x := f x

it seems really trivial, isn't it ?
But, for example in this kind of situation, is really usefull:

zipWith ( $ ) ( cycle [ \x -> div (x + 1) 2 , \x -> div x 2 ] ) [1..]

here you have a infinite list of function:

a = cycle [ \x -> div (x + 1) 2 , \x -> div x 2 ]
( ie: [\x -> div (x + 1) 2 , \x -> div x 2 , \x -> div (x + 1) 2 , \x -> div x 2, ... ] )

and you want to apply every element of the list at the element
at the same index in the second list:

b = [1..]

zipWith, for every index i takes the element a(i) of the left list
and b(i) of the right list and execute what is requested inside the parentheses.
In this situation is specified $ so:

a(i) $ b(i ) := a(i) ( b(i) )

the result must be the following:

[ 1 ,1 , 2, 2 , 3 ,3 ... and so on.

Prime Numbers in haskell

well, do you want to know how to find 'prime numbers' in a quick and dirty
way using Haskell ?
try this!

import Data.List
nubBy ( \x y -> mod y x == 0 ) [2..]

Haskell is so easy and charming...

( ps: if you want to speed up a little bit:
nubBy ( \x y -> ( x*x-1 <= y ) && ( mod y x == 0 ) ) [2..]
)

re: Mandelbrot Set in Haskell

import Data.Complex

conv p=(\n->".,:;|!([$O0*%#@?"!!(n-1))(ceiling (p*8)::Int)

gr=map(\y->[(x:+y)|x<-[-2,-1.97..0.7]])[-1.2,-1.13..1.2]

--px w=magnitude(foldl1(\z c ->z^2 +c)(replicate 10 w))

px w=(magnitude.last.take 10.takeWhile(\r->(magnitude r )<6).iterate(\z->z^2+w))w

image=map((map(\el->case(px el<2)of{true->conv(px el);_->' '})))gr

main=mapM_ putStrLn image

better...

Mandelbrot set in Haskell

import Data.Complex
gr = map(\y-> [( x:+y )|x<-[-3,-2.95..1]])[-2,-1.9..2]

px (a:+b) = magnitude(foldl (\z c ->z^2+c) 0 (take 10([((a*x):+b)|x<-[1,1..]])))

image = map((map(\el->case(px el<2)of{true->'*';_ ->'-'})))gr
main = mapM_ putStrLn ( (map(\el->show el) )image )

A first interpretation ( a little bit unsatisfactory ) of the Mandelbrot set in Haskell

Numbers in Haskell

The core of numbers post in Haskell:

idens p q x = case ( rem ( x ^ 2 ) p ) of { 1 -> 1 ; _ -> 0 }
numList p x = map ( idens p x ) ( map ( x * ) [ 1..( p-1 ) ] )
matIde p = map ( numList p ) [ 1..(p-1) ]