As if from nowhere, e appears, at it's own pace!

Inspired by this lovely blogpost I decided to write my own slow and arcane "e" maker. Please compile it before running, otherwise it has runtime complexity O(forever).

	import System.Random
	main = print e
	e :: Double
	e = (+1).average $ map (length . takeWhile (<1) . scanl1 (+) . randomReals) [1..1000000]
	where
	average :: [Int] -> Double
	average x = fromIntegral (sum x) / fromIntegral (length x) -- This is a rubbish (slow) way to average
	randomReals :: Int -> [Double]
	randomReals = randomRs (0.0,1) . mkStdGen more than 500000 takes a while
	-- This generates a random seed from each number and then makes a list of values in(0,1)

view raw slow slow e.hs hosted with ❤ by GitHub

Fast enough and fancy primes oneliner

primes = 2: filter(\x->not$any (\y->mod x y==0) (takeWhile (<(ceiling.sqrt$fromIntegral x+1)) primes)) [3..]

view raw niceprimes.hs hosted with ❤ by GitHub

A Couple of Haskell Quines

A simple little quine. A quaint quine.

main=let q x=putStr x>>print x in q"main=let q x=putStr x>>print x in q"

view raw basicquine.hs hosted with ❤ by GitHub

Fancier applicative version, because it's more hardcore.

import Control.Applicative;main=liftA2(>>)putStr print"import Control.Applicative;main=liftA2(>>)putStr print"

view raw fancyapplicativequine.hs hosted with ❤ by GitHub

Floating Point is Shit Part Two

Haskell is a great logical language and can be used for proofs and has Curry-Howard isomorphic-mathematical-glorious beauty. With that in mind I feel that when ghci says Peano's eighth postulate is false you best listen.

	> 1e16 + 1 == 1e16
	True

view raw lame.lhs hosted with ❤ by GitHub

Gorgeous Haskell Mandelbrot (and Burning Ship) in Haskell for your Enjoyment

As usual it's slow. It could be made much faster by using a parallel map. That's an exercise for the reader. Also PPM is terrible for anything but writing to, it must be converted immediately.

	import Complex
	main = writeFile "mandelthing.ppm" $ imageMB 1000 3
	type Colour = [Int]
	type Image = [Colour]
	createPPM :: Int -> Int -> Image -> String
	createPPM w h i =
	concat ["P3 ", show w, " ", show h, " 255\n",
	unlines.map (unwords.map show) $ i]
	--Calculates a fractal pixel from an initial condition 0+0i
	mandelbrotPixel x y = mb (x:+y) (0:+0) 0
	mb c x iter
	| magnitude x > 2 = iter
	| iter >= 255 = 255
	| otherwise = mb c (c+q^2) (iter+1)
	where
	q = x -- Mandelbrot
	-- q = (abs.realPart $ x) :+ (abs.imagPart $ x) --Burning Ship
	argandPlane x0 x1 y0 y1 width height =
	[(x,y)| y<-[y1,(y1-dy)..y0], --traverse from
	x<-[x0,(x0+dx)..x1]] --top-left to bottom-right
	where
	dx = (x1 - x0)/(width-1)
	dy = (y1 - y0)/(height-1)
	drawPlane :: (a->b->c)->(c->Colour)->[(a,b)]->Image
	drawPlane function = -- takes a function ,a colour function and a plane
	map . (.uncurry function)
	--'s' is size, 'a' is aspect as in a:1
	imageMB s a = createPPM (a*s) s $
	drawPlane mandelbrotPixel (\x->[x,x,x]) $
	argandPlane (-2) 1 0 1 (fromIntegral a *s') s'
	where s' = fromIntegral s

view raw Mandelthing.hs hosted with ❤ by GitHub

Why floating point is shit

take 50 $ zipWith id (map (\z->(^(2^z))) [1..]) (iterate (sqrt) 2)

view raw gistfile1.hsc hosted with ❤ by GitHub

Implicit Folds in Haskell (for those jealous of LISP)

Ever wish you could do things like (+ 3 4 5) from LISP, but in Haskell? Wish no more with the beautiful FoldyList datatype! An example instance for Show is given but feel free to write your own, otherwise the code is next to useless.

	module FoldyList where
	data FoldyList a =
	FoldyCons (FoldyHead a) (FoldyTail a)
	type FoldyHead a = (a -> a -> a)
	type FoldyTail a = [a]
	instance Show q => Show (FoldyList q) where
	show (FoldyCons x y) = show $ foldr1 x y
	flist :: FoldyList Int
	flist = FoldyCons (+) [3,4,5]
	main = print flist

view raw FoldyList.hs hosted with ❤ by GitHub