Paste: PI3-1

-- Approximate the square root of $x to at least the accuracy of $eps
-- collecting the steps in a list.
squareRoot :: Double -> Double -> [Double]
squareRoot x eps | x   < 0.0 = error "Non real answer."
                 | eps < 0.0 = error "Accuracy can't be more than perfect."
		 | otherwise = loop [((1 + x) / 2)] where
	loop :: [Double] -> [Double]
	loop (y:t) | abs((y * y) - x) <= eps = y : t
	           | otherwise               = loop ((0.5*(y+(x/y))):y:t)


-- Just the head of this list.
-- I wonder if the compiler is capeable to optimize the list away ...
wurzel :: Double -> Double -> Double
wurzel x eps = head (squareRoot x eps)


-- How many approximations does it take to reach $eps accuracy
count :: Double -> Double -> Int
count x eps = length (squareRoot x eps)


sq :: Double -> Double
sq x = x * x

-- Trivial isn't it?
data Point = P Double Double deriving Show


add :: Point -> Point -> Point
add (P x1 y1) (P x2 y2) = P (x1+x2) (y1+y2)


distance :: Point -> Point -> Double
distance (P x1 y1) (P x2 y2) = sqrt ((sq (x1 - x2)) + (sq (y1 - y2)))


-- A shape has an area an can be moved.
class Shape a where 
	move :: a -> Point -> a
	area :: a -> Double


-- Circles are shapes.
data Circle = C Point Double deriving Show
instance Shape Circle where
	move (C middle radius) delta = C (add middle delta) radius
	area (C middle radius)       = pi * (sq radius)


-- As are Triangles.
data Triangle = T Point Point Point deriving Show
instance Shape Triangle where
	move (T point1 point2 point3) delta =
		T (add point1 delta) (add point2 delta) (add point3 delta)
	area (T point1 point2 point3) =
		sqrt (s * (s - a) * (s - b) * (s - c)) where
			s = (a + b + c) / 2
			a = distance point1 point2
			b = distance point2 point3
			c = distance point3 point1


-- and Rectangles.
data Rectangle = R Point Point deriving Show
instance Shape Rectangle where
	move (R p1 p2) d =
		R (add p1 d) (add p2 d)
	area (R (P x1 y1) (P x2 y2)) =
		abs((x1 - x2) * (x1 - y2))


-- Bits are Zero or One.
data Bit = Zero | One deriving (Eq, Show)


-- Encode an Int as a Bit.
enc1 :: Int -> Bit
enc1 x | x == 0 = Zero
       | x /= 0 = One


-- Decode a Bit to an Int.
dec1 :: Bit -> Int
dec1 x | x == Zero = 0
       | x == One  = 1

-- Convert from one datatype to an other by replaceing
-- occurances of x with occurances y.
replace :: (Eq a) => [(a,b)] -> a -> b
replace [ ] _                       = error "Undefined replacement"
replace ((a, b) : xs) x | a == x    = b
		        | otherwise = replace xs x


-- Pretty selfexplaining isn't it?
encode :: Int -> [Bit]
encode n | n <  0    = error "Can't convert negative numbers."
         | otherwise = convert n [] where
	convert :: Int -> [Bit] -> [Bit]
	convert 0 l = l
	convert n l = convert (floor (fromIntegral n / 2))
	                      ((enc1 (mod n 2)):l)

decode :: [Bit] -> Int
decode l = foldl (\sum bit -> 2 * sum + (dec1 bit)) 0 l

display :: [Bit] -> String
display = map (replace [(Zero, '0'), (One, '1')])