1. Consider the following recurrence scheme described informally below. Use it to build the sequence $ 1, 2, \ldots, n!, \ldots$
4 4*5 4*5*6 ... 3 3 3 3 ---------------------- 3 3*4 3*4*5 3*4*5*6 ...
2. Define the sequence $ 1, \frac{1}{2}, \ldots, \frac{1}{k!}, \ldots $
3. Write a function which takes a sequence $ (a_n)_{n\geq 0}$ and computes the sequence $ (s_n)_{n\geq 0}$ where $ s_k = \sum_{k\geq 0} a_k$ . Use a strategy similar to that from exercise 1.
4. Write the stream of approximations of $ e$ details .
5. Write a function which takes a value $ d$ , a sequence of approximations $ (a_n)_{n\geq 0}$ and returns that value $ a_k$ from the sequence which satisfies the condition $ \mid a_k - a_{k+1}\mid \leq d$
6. Write a function which takes an $ f$ , a value $ a_0$ and computes the sequence $ a_0, f(a_0), f(f(a_0)), \ldots$
7. The sequence $ (a_n)_{n\geq 0}$ defined as $ a_{k+1} = (a_k + \frac{n}{a_k})/2$ , will converge to $ \sqrt{n}$ as $ k$ approaches infinity. Use it to write a function which approximates $ \sqrt{n}$ within 3 decimals.
8. The diagram below illustrates the approximation of an integral of a continuous function $ f$ between two points $ a$ and $ b$ . The simplest approximation is the area of the rectangle defined by points $ a$ and $ b$ on the $ Ox$ axis, and points $ f(a)$ and $ f(b)$ .
To determine a better approximation, the interval $ $ [ [a,b] ] is broken in half and we add up the areas of the rectangles:
Oy
^
f m|. . . . . . . --------
| / ' \
| / ' \ f
f b|. . . . . . /. .'. . . . .-------
| ----- ' '
f a|. . . / ' '
| / ' '
| / ' ' '
| / ' ' '
------------------------------> Ox
a m b
The process can be repeated by recursively dividing up intervals. Write the a function integral which computes the sequence of approximations of $ \int_a^b f(x)$ .
integral :: (Float -> Float) -> Float -> Float -> [Float]
9. It is likely that your implementation will recompute (unnecessarily) the values $ f(a), m, f(m), f(b)$ in recursive steps. Write an alternative implementation which avoids this.
10. Consider a representation of maps (with obstacles as follows):
l1=" # " l2=" # # # " l3=" # ### # " l4=" # # " l5=" ####### " l6=" " data Map = Map [String] instance Show Map where show (Map m) = "\n" ++ foldr (\x acc->x++"\n"++acc) [] m m = Map [l1,l2,l3,l4,l5,l6] type State = (Int,Int)
Write the function at which returns the value of the position x,y in the map:
at :: Map -> Int -> Int -> Maybe Char
11. Define a function which computes, for a given position, the list of valid next positions (a valid position is one that is on the map, and it is not a wall, i.e. a #). Hint, use the list [(x-1,y-1),(x-1,y),(x-1,y+1),(x,y-1),(x,y+1),(x+1,y-1),(x+1,y),(x+1,y+1)].
12. Implement the type Tree a of trees with arbitrary number of children nodes.
13. Enrol Tree in class Functor (see classes), and define the function fmap.
14. Write a function which takes a (possibly infinite) tree and returns the sub-tree where each branch is of length at most k:
take_t :: Integer -> Tree a -> Tree a
15. Implement the infinite tree of valid positions, starting from an initial one. In this tree, paths represent trails exploring the map.
make_st_tree :: Map -> State -> Tree State
16. Implement the function toMap which draws a position on the map (using the character .).
toMap :: State -> Map -> Map
17. Implement the tree of possible trails through the map:
make_map_tree :: Map -> State -> Tree Map