csci2041/public-class-repo/Homework/Hwk_05.md

Homework 5: Lazy Evaluation

CSci 2041: Advanced Programming Principles, Spring 2017

Due: 5pm Wednesday, April 5

Part 1: Expression evaluation by-hand

In class, and demonstrated in the document "Expression Evaluation Examples" on Moodle, we have evaluated expressions by hand, step by step, to understand the different ways in which call by value semantics, call by name semantics, and lazy evaluation work.

Question 1

Consider the following definitions:

sum [] = 0
sum x::xs -> x + sum xs

take 0 lst = [ ]
take n [ ] = [ ]
take n (x::xs) = x::take (n-1) xs

some_squares_from 0 v = [ ]
some_squares_from n v = v*v :: some_squares_from (n-1) (v+1)

Evaluate

sum (take 3 (some_squares_from 5 1))

using call by value semantics, call by name semantics, and lazy evaluation.

Each of these three evaluations must be clearly labeled with the form of evaluation used.

Furthermore, all must be produced electronically. No handwritten work will be accepted. You may use a text editor and turn in a text file. These are relatively simple so there is no need to use MarkDown or generate a PDF file.

Your name and University Internet ID must appear in the upper left of the document.

Name this file question_1.txt and place it in a directory named Hwk_05 in your GitHub repository.

Question 2

Recall our definitions for foldl and foldr as well as the functions for folding and over a list of boolean values. (Note that we removed the underscores from the names as they appeared on the slides.)

foldr f [] v = v
foldr f (x::xs) v = f x (foldr f xs v)

foldl f v [] = v
foldl f v (x::xs) = foldl f (f v x) xs

and b1 b2 = if b1 then b2 else false

andl l = foldl and true l
andr l = foldr and l true

You are asked to evaluate the expressions

andl (t::f::t::t::[])

and

andr (t::f::t::t::[])

using both call by value and call by name semantics.

A few things to note:

• Since anytime a function uses an argument more than once (this only happens with f in the two fold functions) it is given a value and not an unevaluated expression, there is no benefit from the optimization we get with lazy evaluation. So we don't need to consider it here.

• To save space we are not spelling out the full name of the values true and false but are instead abbreviating them here as t and f. Do not consider these to be variables! They are the boolean literals for true and false. You may do the same in your homework.

• Lists are written in their basic form using the cons (::) and nil ([]) operators instead of the syntactic sugar form using semicolons to separate lists values between square brackets.

Clearly label each evaluation with the kind of semantics used for it.

After you have completed all four of them, explain which one is the most efficient and why.

Each of these three evaluations must be clearly labeled with the form of evaluation used.

Furthermore, all must be produced electronically. No handwritten work will be accepted. As before, you may use a text editor and turn in a text file.

Your name and University Internet ID must appear in the upper left of the document.

Name this file question_2.txt and place it in the Hwk_05 directory your created for question 1.

Part 2: Efficiently computing the conjunction of a list of boolean values in OCaml

Write an OCaml function named ands with the type bool list -> bool that computes the same result as the andl and andr functions described in the problem above.

Your OCaml function should be written so that it does not examine or traverse the entire list if it does not need to. We saw this behavior in one of the by-hand evaluations above. If a false value is encountered then it the computation can terminate and return false.

This function should, following the pattern of past assignments, be placed in a file named hwk_05.ml. This file must be placed in a directory named Hwk_05 in your GitHub repository.

Part 3: Implementing Streams in OCaml

In class, and demonstrated in the file streams.ml in the code-examples directory of the public repositories, we developed a type constructor stream that can be used to create lazy streams and make use of lazy evaluation techniques in a strict/eager language.

Below you are asked to define a collection of stream values and functions over streams.

To start this part of the assignment, first copy the streams.ml file into your Hwk_05 directory. Add the following functions to the end of that file. But you should clearly mark the parts of this file that you did not write and attribute them to their author (your instructor) and then indicate where your work starts in the file by adding you name and a comment to this effect.

cubes_from

Define a function cubes_from with the type int -> int stream that creates a stream of the cubes of numbers starting with the input value. For example, cubes_from 5 should return a stream that contains the values 125, 216, 343, ...

Demonstrate to yourself that this work by using take to generate a finite number of cubes.

drop

Write a function named drop with the type int -> 'a stream -> 'a stream. This function is the stream version of the drop function that you've written for lists. Note the difference of the type for drop for that of take over lists. Since take will remove a finite number of elements from a stream we have decided to store them in a list instead.

drop_until

Write a function named drop_until with the type ('a -> bool) -> 'a stream -> 'a stream that returns the "tail" of a stream after dropping all of the initial values for which the first argument function returns false.

That is, this function keeps dropping elements of the input stream until it finds one for which the function returns true. This element, and all those that follow it, form the stream that is returned.

For example, using head and squares from our original streams.ml file

head (drop_until (fun v -> v > 35) squares)

should evaluate to 36

map

In streams.ml we defined the functions filter and zip to work over lists. You are now asked to define a map function over steams with the type ('a -> 'b) -> 'a stream -> 'b stream. This is the analog to map over lists.

squares, again.

In the class examples we defined the stream of squares of natural numbers using zip so that squares = zip ( * ) nats nats.

We could also define squares as squares_from 1 using the function defined above.

Define squares_again to be equal to squares but define it using the map function written above.

square roots

You've previously seen a recursive function and an imperative loop to compute the square root of a floating point number to some specified degree of accuracy.

We now make use of lazy evaluation to pull apart two aspects of this algorithm

1. the part the generates a sequence of approximations to the square root of a number, and
2. the part that determines when the approximations generated so far are close enough that we can stop generating them

The first task is to define the function sqrt_approximations with the type float -> float stream that takes a floating point number and generates the stream of approximations to its square root. This sequence corresponds to the sequence of values that the local variable guess took in a previous implementation of this algorithm.

For example, take 10 (sqrt_approximations 49.0) evaluates to

[25.; 13.; 7.; 10.; 8.5; 7.75; 7.375; 7.1875; 7.09375; 7.046875]

(Recall that floating point values are approximations or real numbers and thus there may be small round off errors that cause your results to be slightly different from these.)

The second task is to write a function whose purpose is similar to the accuracy value used in the previous implementations, that is, to determine when to stop generating approximations.

This function should be named epsilon_diff with the type float -> float stream -> float. The first argument is a floating point value, perhaps named epsilon. This function pulls values out of the stream until the difference between two successive values in the stream is less than epsilon. It then returns the second of those two values.

An example below uses a stream named diminishing which begins at 16.0 and each following value is half of its preceding on. For example, in utop:

# take 10 diminishing ;;
- : float list = [16.; 8.; 4.; 2.; 1.; 0.5; 0.25; 0.125; 0.0625; 0.03125]

Define diminishing in your file.

We can use epsilon_diff to as follows:

# epsilon_diff 0.3 diminishing ;;
- : float = 0.25

Since the difference between 0.5 and 0.25 is the first one that is less than 0.3, the second of them is returned.

As a third task, include the following declarations to compute the square root of 50.0 to different degrees of accuracy:

let rough_guess = epsilon_diff 1.0 (sqrt_approximations 50.0) 

let precise_calculation = epsilon_diff 0.00001 (sqrt_approximations 50.0) 

another square root

The function epsilon_diff looked at two successive values to determine when to stop traversing a stream.

We now want to write a square root approximation function that picks the first element out of sqrt_approximations that is within some threshold. This one looks at the elements of sqrt_approximations separately instead of comparing two of them in determining what value to return.

This function, named sqrt_threshold, has the type float -> float -> float. The first floating point value is the one we would like to take the square root of, call it v. The second is a threshold value, call it t. We want return the first element, say s, of sqrt_approximations for which the absolute value of (s *. s) -. v is less than t.

For full credit this function should make appropriate use of the functions you've already written and those in the streams.ml file we developed in class.

This function, at first glance, seems to return more accurate answers than our value of epsilon might suggest. For example,

sqrt_threshold 50.0 3.0

evaluates to 7.125.

Write a comment in your OCaml file just above the definition of sqrt_threshold that explains why this is.