Differences

This shows you the differences between two versions of the page.

--- pp:l09 [2020/04/25 19:06]
pdmatei
+++ pp:l09 [2020/04/25 19:31] (current)
pdmatei
@@ Line 14: / Line 14: @@
 . Write the stream of approximations of $math[e] [[https://en.wikipedia.org/wiki/E_(mathematical_constant) | details ]].
+. Write a function which takes a value $math[d], a sequence of approximations $math[(a_n)_{n\geq 0}] and returns that value $math[a_k] from the sequence which satisfies the condition $math[\mid a_k - a_{k+1}\mid \leq d]
+. Write a function which takes an $math[f], a value $math[a_0] and computes the sequence $math[a_0, f(a_0), f(f(a_0)), \ldots]
+. The sequence $math[(a_n)_{n\geq 0}] defined as $math[a_{k+1} = (a_k + \frac{n}{a_k})/2], will converge to $math[\sqrt{n}] as $math[k] approaches infinity. Use it to write a function which approximates $math[\sqrt{n}] within 3 decimals.
+. The diagram below illustrates the approximation of an integral of a continuous function $math[f] between two points $math[a] and $math[b]. The simplest approximation is the area of the rectangle defined by points $math[a] and $math[b] on the $math[Ox] axis, and points $math[f(a)] and $math[f(b)].
+To determine a better approximation, the interval $math[ [a,b] ] is broken in half and we add up the areas of the rectangles:
+  - $math[a,m,f(a),f(m)] and
+  - $math[m,b,f(m),f(b)]
+<code>
+Oy
+   ^
+f m|. . . . . . .  --------
+   |              / '      \
+   |             /  '       \  f
+f b|. . . . . . /. .'. . . . .-------
+   |       -----    '         '
+f a|. . . /         '         '
+   |     /          '         '
+   |    / '         '         '
+   |   /  '         '         '
+   ------------------------------>  Ox
+          a         m         b
+</code>
+The process can be repeated by recursively dividing up intervals. Write the a function ''integral'' which computes the sequence of approximations of $math[\int_a^b f(x)].
+<code haskell>
+integral :: (Float -> Float) -> Float -> Float -> [Float]
+</code>
+. It is likely that your implementation will recompute (unnecessarily) the values $math[f(a), m, f(m), f(b)] in recursive steps. Write an alternative implementation which avoids this.
+. Consider a representation of maps (with obstacles as follows):
+<code haskell>
+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)
+</code>
+Write the function ''at'' which returns the value of the position ''x'',''y'' in the map:
+<code haskell>
+at :: Map -> Int -> Int -> Maybe Char
+</code>
+. 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)]''.
+. Implement the type ''Tree a'' of trees with arbitrary number of children nodes.
+. Enrol ''Tree'' in class ''Functor'' (see classes), and define the function ''fmap''.
+. Write a function which takes a (possibly infinite) tree and returns the sub-tree where each branch is of length at most ''k'':
+<code haskell>
+take_t :: Integer -> Tree a -> Tree a
+</code>
+. Implement the infinite tree of valid positions, starting from an initial one. In this tree, paths represent trails exploring the map.
+<code haskell>
+make_st_tree :: Map -> State -> Tree State
+</code>
+. Implement the function ''toMap'' which //draws// a position on the map (using the character ''.'').
+<code haskell>
+toMap :: State -> Map -> Map
+</code>
+. Implement the tree of possible //trails// through the map:
+<code haskell>
+make_map_tree :: Map -> State -> Tree Map
+</code>