最可怕的事情是我的价值观塌陷了，起码在两周之前我还在想着怎么变强，怎么让自己能在这个陌生的地方有个立足之地，怎么让我心爱的人因为我过上更好的生活。但是她说，“这些都不是我想要的”。我说，“我都走出了最难的一步了，后面还有什么呢？”。可能对她而言，往后就是无尽的等待吧。她不喜欢离开家，不喜欢压力大的生活，她还像小孩子一样把生活看着简单，她也不会懂大人的道理。如果你的压力小，总有人会替你承担压力大的部分。

也许是我错了，我都错了。公司告诉录用我的时候我也没有多开心，但是她说不再等我的时候我心却碎了。我对她是什么呢？OPT完了有H1B，H1B完了有绿卡。这些事情就是一颗颗定时炸弹，永远不可能让我们安心的生活。

我们异地一年多了，我觉得我变了好多，起码变得可以给她我认为好的“未来”。但是她需要的就是温暖，就是“小”日子，是日常的生活。我无法想象她在冷冷的出租屋里，孤单的时候，会不会哭，会不会笑，会不会想我，会不会怨着我。

我有时候也恨美国，这个地方给了我许多，却让我失去了最重要的东西。这些事情对于她可能难以理解吧。

不过我也决定了，我会尽快去找她。因为我知道，

我已不会再对谁 满怀期待

总听说人生苦短，依我看人生前五十年是领略“苦”，后面就是“短”。我也体会到了为什么说人是要享受忧郁的。因为这样，我才想着下一步做什么，才想着在这写点东西。可能几年前我就该想明白，我还是没有走到那一层，每次都是落后半拍。总想着那个时候要是能想明白就好了，这也说明我现在也还没有想通几年后我才明白的道理。

周一飞去面两家公司，我想还是学习的态度去吧。比我强的人太多了，我只有这样才能不被你们淘汰。

Binary Search

二分查找，是非常简单的算法。但是这种算法应用非常灵活，首先想一次性写对二分查找并不是一件容易的事情。这里我想简单总结一下二分查找的使用背景。众所周知，最最常见应用二分查找的地方就是对于一个已经排好序的数组中，找到一个我们已知的值的位置。这个问题背后隐藏着什么呢？记得我在初次学习二分查找的时候，看到有人总结说二分查找的应用条件就是这个问题是否可以证明是“单调的”。对于数组查找中，我们可以简化问题为一个函数f，f(index)就是对于查找index的值是否大于等于目标值，这样我们就发现函数f在定义域[0, n)是满足单调性质的，因为必然有个界限让小于的f为false，大于等于的时候是true（当然这个界限也有可能不存在，就是我们没有找到这个值的时候）。再举个例子，我们想找到实数取决一个满足f(x)=y的值，也可以对整个实数区域进行二分，然后求解x，就像解方程一样。

说完了背景，再说说写法。首先是整数的写法：

因为整数的二分会自动去掉小数部分，这就会遇到一个头疼的问题，如果当low = k, high = k + 1 这时候我们做二分，中间值永远是k。如果我们写的代码是while (low < high) {if (f(mid)) { low = mid; } else { high = mid - 1; }} 且这个时候f(mid)为true，那么我们永远也无法跳出这个循环。解决这个问题有两种思路：1. 因为我们停止的条件是low == high所以不妨把循环条件设置为 while (low + 1 < high) 但是这又会引起一个问题，我们需要在最后再double check一下low和high我们需要的答案是什么。 2. 也可以把二分的结果向上取整 mid = (low + high + 1) / 2 这样在遇到这种情况是我们总会选择high。所以在写完二分解法后最好想一下，两个答案的时候程序能不能成功运行出结果。第二个是值域分布的问题，有可能我们的判断函数f(x)永远都是false，这样的结果是我们最后的二分结果也是错的。

下面是实数二分的写法：

这里就不会遇到那个头疼问题，我们只要保证精度就可以了 while (left < high && Math.abs(left - high) < 1e-5) 但是我不喜欢这么写，会因为精度的问题陷入死循环。我们单纯循环100次就可以把精度控制在小数点后30位。

K-th with Binary Search

这里说一下为什么K-th问题都可以借用二分查找解决。因为K-th问题必然是单调性的，因为我们有函数f(x)=k表示x在数据集中的排序为k，那么比x大的数字，f(x)就会变大，反之亦然，单调性很容易证明。所以我们只要在合理的时间计算出x的排序，就可以二分查找出排序为k的数值。下面我们来看几道题：

Find K-th Smallest Pair Distance 给了一个数组，让找出两两pair中相差值为k-th小的值。我们可以对数组排序，然后二分这个相差值。然后根据这个值找出有多少个pair比这个值小。这里注意并不是如果比这个值小的元素有k-1个就证明了就是答案，因为我们不知道这个相差值是否真的存在。所以我们要找到答案为k-1且这个值最小的那个。因为这个值是处于一个分界点，比这个值小排序的序号就减少1，就说明了这个差值是存在的。这里我们用sliding window来找到多少个差值比target要小。

public int smallestDistancePair(int[] nums, int k) {
	Arrays.sort(nums);
	int low = 0, high = Integer.MAX_VALUE;
	while (low < high) {
		int mid = (low + high) / 2;
		int begin = 0, end = 0, cnt = 0;
		for (; end < nums.length; ++ end) {
			while (begin < nums.length && nums[end] - nums[begin] > mid) {
				begin++;
			}
			cnt += (end - begin);
		}
		if (cnt >= k) {
			high = mid;
		} else {
			low = mid + 1;
		}
	}
	return low;
}

K-th Smallest Prime Fraction 给一个排序好的素数数组，对于 p < q find p / q 找出所有值中第k小的。同样，这里我们对实数值域进行二分，找到多少个分数比当前值小，同样找到这些满足条件中的最小值。我们也可以通过比较巧妙的线性方法的找出所有满足小于查找值的分数个数。

public int[] kthSmallestPrimeFraction(int[] A, int K) {
	int n = A.length;
	double low = (double)A[0]/A[n - 1];
	double high = (double)A[n - 1]/A[0];
	Set<Integer> set = new HashSet<>();
	for (int a : A) set.add(a);
	for (int itr = 0; itr < 100; ++itr) {
		double mid = (low + high) * 0.5;
		int i = 0, j = 0, cnt = 0;
		for (; i < n; ++ i) {
			for (; j < n; ++ j) {
				if (i < j && A[i] < mid * A[j]) {
					cnt += (n - j);
					break;
				}
			}
		}
		if (cnt < K) {
			low = mid;
		} else {
			high = mid;
		}
	}
	for (int a : A) {
		double p = Math.round(low * (double)a);
		if (Math.abs(p - low * (double)a) < 1e-5 && set.contains((int)p)) {
			return new int[]{(int)p, a};
		}
	}
	return null;
}

Kth Smallest Element in a Sorted Matrix 给一个行和列都排序的矩阵，找到其中第k小的。我们二分来查找这个值，然后通过每行进行二分查找来统计多少个值比这个数要小。

public int kthSmallest(int[][] matrix, int k) {
	int n = matrix.length;
	int low = matrix[0][0], high = matrix[n - 1][n - 1];
	while (low < high) {
		int mid = (low + high) / 2;
		int count = 0;
		for (int i = 0; i < n; ++ i) {
			int l = 0, h = n - 1;
			while (l < h) {
				int m = (l + h + 1) / 2;
				if (matrix[i][m] <= mid) {
					l = m;
				} else {
					h = m - 1;
				}
			}
			if (matrix[i][l] <= mid) {
				count += l + 1;
			}
		}
		if (count < k) {
			low = mid + 1;
		} else {
			high = mid;
		}
	}
	return low;
}

Kth Smallest Number in Multiplication Table 和上道题类似，每行换成了等比数列。免去了进行二分查找统计，直接算除法就可以统计数量。

public int findKthNumber(int m, int n, int k) {
	int low = 1, high = m * n;
	while (low < high) {
		int mid = (low + high) >>> 1;
		int count = 0;
		for (int i = 1; i <= m; ++ i) {
			count += Math.min(n, mid / i);
		}
		if (count < k) {
			low = mid + 1;
		} else {
			high = mid;
		}
	}
	return low;
}

递归与递推

众所周知，BST是天生具有递归特性的，因为的BST的任一子树都是BST。所以很多题目都是利用这一性质。比如将BST有序打印出来就可以使用inorder遍历：

public void recursive(TreeNode root) {
    if (root == null) return;
    recursive(root.left);
        /*
        Do something...
        */
    recursive(root.right);
}

当然也可以通过栈来改写为递推，这里是将未处理的结点存入栈中。这里需要介绍一种pushAll操作。就是将该结点的所有左结点全部压入栈。然后每次取出结点后对右结点进行pushAll操作。Binary Tree Inorder Traversal：

public List<Integer> inorderTraversal(TreeNode root) {
	List<Integer> ans = new ArrayList<>();
	Stack<TreeNode> stack = new Stack<>();
	while(root != null) {
		stack.push(root);
		root = root.left;
	}
	while (!stack.isEmpty()) {
		TreeNode cur = stack.pop();
		ans.add(cur.val);
		cur = cur.right;
		while (cur != null) {
			stack.push(cur);
			cur = cur.left;
		}
	}
	return ans;
}

了解到这个特性后，我们就可以将BST改写成Iterator - next()取出下一个最小值，hasNext()是否存在结点。Binary Search Tree Iterator：

public class BSTIterator {
    private Deque<TreeNode> stack;

    public BSTIterator(TreeNode root) {
        stack = new ArrayDeque<>();
        pushAll(root);
    }

    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        return !stack.isEmpty();
    }

    /** @return the next smallest number */
    public int next() {
        TreeNode cur = stack.pop();
        pushAll(cur.right);
        return cur.val;
    }

    private void pushAll(TreeNode root) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
    }
}

在Java的Iterator是也可以支持remove()操作 - 删除上一个访问的结点。BST删除结点的操作也可以用递归算法来解决（当然也可用平衡二叉树删除结点进行分类的解法，但是递归的解法更加巧妙）。首先我们找到被删除的结点，然后把它替换成其右子树的最小值m（目的是为了保证删除后的右子树满足比当前结点大）。然后我们再递归删除右子树的m结点。Delete Node in a BST：

public TreeNode deleteNode(TreeNode root, int key) {
	if (root == null) {
		return null;
	}
	if (key < root.val) {
		root.left = deleteNode(root.left, key);
	}  else if (key > root.val) {
		root.right = deleteNode(root.right, key);
	} else {
		if (root.left == null) {
			return root.right;
		} else if (root.right == null) {
			return root.left;
		} else {
			TreeNode min = findMin(root.right);
			// copy
			root.val = min.val;
			root.right = deleteNode(root.right, min.val);
		}
	}
	return root;
}

private TreeNode findMin(TreeNode root) {
	TreeNode cur = root;
	while (cur.left != null) {
		cur = cur.left;
	}
	return cur;
}

查找

上文中我们知道BST是可以有序输出的，所以很多针对有序数据的算法都可以套在BST上。比如，二分查找，第k大问题，等等。

如果查找的结点存在于BST上，我们很容易可以将它找出。但是如果需要查找的结点不存在与树上，我们希望返回最接近的结点，这种问题该如何解决呢？首先我们要想一个问题，对于一个在BST上的结点，比它大的值可能存在于哪里？应该是存在于这个结点的右子树或父结点（如果存在）的右子树。但是这么思考的问题是我们需要跟踪父结点的情况，这个如果不借助其他数据结构存储很难实现。我们不如换一种思路：当访问到结点时，如果值大于target就找保存左子树的最接近target的值，然后取这两个值最接近target的一个；反之就从右子树来找。同样借助递归的特性我们可以解决这个问题。Closest Binary Search Tree Value

public int closestValue(TreeNode root, double target) {
	if (root == null) {
		return -1;
	}
	if (Math.abs((double)root.val - target) < 1e-6) {
		return root.val;
	}
	if ((double)root.val < target && root.right != null) {
		int r = closestValue(root.right, target);
		if (Math.abs(target - (double)r) < Math.abs(target - (double)root.val)) {
			return r;
		}
		return root.val;
	} else if ((double)root.val > target && root.left != null) {
		int r = closestValue(root.left, target);
		if (Math.abs(target - (double)r) < Math.abs(target - (double)root.val)) {
			return r;
		}
		return root.val;
	}
	return root.val;
}

借用这种想法，我们还可以解决类似的问题。比如将BST分成两个BST，一个所有的值小于等于target，另一个大于target。对于当前结点如果小于等于target，其左边子树都是小于等于target，所以将右子树分成的结果的第一部分连接到当前结点的右边；如果大于target，说明右子树都是大于target，需要将左子树的结果的第二部分连入左边。Split BST：

public TreeNode[] splitBST(TreeNode root, int V) {
	if (root == null) {
		return new TreeNode[]{null, null};
	}
	TreeNode[] res;
	if (root.val <= V) {
		res = splitBST(root.right, V);
		root.right = res[0];
		res[0] = root;
	} else {
		res = splitBST(root.left, V);
		root.left = res[1];
		res[1] = root;
	}
	return res;
}

对于第k大的问题，可以通过inorder遍历来解决。Kth Smallest Element in a BST：

int count = 0;
public int kthSmallest(TreeNode root, int k) {
	return solve(root, k);
}

private int solve(TreeNode root, int k) {
	if (root == null) {
		return -1;
	}
	int r = solve(root.left, k);
	if (r != -1) return r;
	count++;
	if (count == k) {
		return root.val;
	}
	r = solve(root.right, k);
	return r;
}

另一种变形是，在BST找到接近target的k个数。这个可以通过inorder来找到，但是这里介绍一种高效的方法借助额外的数据结构来解决。通过栈来存储比target小的结点，另一个栈存储大于等于target的结点。然后用类似two pointer的方法找到接近target的k个数。Closest Binary Search Tree Value II：

public List<Integer> closestKValues(TreeNode root, double target, int k) {
	Deque<TreeNode> greater = new ArrayDeque<>(), less = new ArrayDeque<>();
	TreeNode cur = root;
	while (cur != null) {
		if (cur.val < target) {
			less.push(cur);
			cur = cur.right;
		} else {
			greater.push(cur);
			cur = cur.left;
		}
	}
	List<Integer> list = new ArrayList<>();
	while (k > 0) {
		if (greater.isEmpty() && less.isEmpty()) {
			break;
		} else if (greater.isEmpty()) {
			list.add(lessNext(less));
		} else if (less.isEmpty()) {
			list.add(greaterNext(greater));
		} else if (Math.abs(less.peek().val - target) < Math.abs(greater.peek().val - target)) {
			list.add(lessNext(less));
		} else {
			list.add(greaterNext(greater));
		}
		k--;
	}
	return list;
}

private int lessNext(Deque<TreeNode> stack) {
	TreeNode top = stack.pop();
	int r = top.val;
	top = top.left;
	while (top != null) {
		stack.push(top);
		top = top.right;
	}
	return r;
}

private int greaterNext(Deque<TreeNode> stack) {
	TreeNode top = stack.pop();
	int r = top.val;
	top = top.right;
	while (top != null) {
		stack.push(top);
		top = top.left;
	}
	return r;
}

这几天又重新拾起来以前经常做的算法竞赛，发现自己越来越水。原来是自己很水却不自知，现在是知道了也没法改变，不过倒是觉得心态挺好，完全是学习的感觉，排名随意了。我理解算法竞赛快成了程序员的基本功，肉眼debug与编程的准确性，这些都很重要不是吗？希望能多涨涨rank，虽然连刷题网站我都没法稳定前200，上周出了两个图论题就崩了。现在对于我本科时代狗屁没学懂的结论简直是不能再认同了。

前几天一直有个想法，想把一个公开课的项目用js实现出来。类似与一个Google Map和地铁信息网站的结合吧，希望这段时间能做出来。至于后面的面试，我越来越看开了，爱怎么样就怎么样，要就要不要拉倒。觉得天天跪舔这些公司烦得很，尤其这些social的事情，我又做不好。因为我这样的性格，很难融于这样的环境。可能我也是羡慕也是嫉妒吧，要改变自己很难，要做成超出自己能力的事情更难。

以及，我前几天过了24岁生日。我走到了人生苦短与及时行乐的过渡区域。

Exercises in this section of SCIP.

Exercise 2.17. Define a procedure last-pair that returns the list that contains only the last element of a given (nonempty) list:

(last-pair (list 23 72 149 34))
(34)

Answer 2.17.

(define (last-pair items)
    (if (null? (cdr items))
        items
        (last-pair (cdr items))
    )
)

Exercise 2.18. Define a procedure reverse that takes a list as argument and returns a list of the same elements in reverse order:

(reverse (list 1 4 9 16 25))
(25 16 9 4 1)

Answer 2.18.

(define (reverse items)
    (if (null? (cdr items))
        items
        (append (reverse (cdr items)) (cons (car items) ()))
    )
)

Exercise 2.19. Consider the change-counting program of section 1.2.2. It would be nice to be able to easily change the currency used by the program, so that we could compute the number of ways to change a British pound, for example. As the program is written, the knowledge of the currency is distributed partly into the procedure first-denomination and partly into the procedure count-change (which knows that there are five kinds of U.S. coins). It would be nicer to be able to supply a list of coins to be used for making change.

We want to rewrite the procedure cc so that its second argument is a list of the values of the coins to use rather than an integer specifying which coins to use. We could then have lists that defined each kind of currency:

(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))

We could then call cc as follows:

(cc 100 us-coins)
292

To do this will require changing the program cc somewhat. It will still have the same form, but it will access its second argument differently, as follows:

(define (cc amount coin-values)
  (cond ((= amount 0) 1)
        ((or (< amount 0) (no-more? coin-values)) 0)
        (else
         (+ (cc amount
                (except-first-denomination coin-values))
            (cc (- amount
                   (first-denomination coin-values))
                coin-values)))))

Define the procedures first-denomination, except-first-denomination, and no-more? in terms of primitive operations on list structures. Does the order of the list coin-values affect the answer produced by cc? Why or why not?

Answer 2.19.

(define (cc amount coin-values)
  (cond ((= amount 0) 1)
        ((or (< amount 0) (no-more? coin-values)) 0)
        (else
         (+ (cc amount
                (except-first-denomination coin-values))
            (cc (- amount
                   (first-denomination coin-values))
                coin-values)))))

(define (no-more? coin-values)
    (null? coin-values)
)

(define (except-first-denomination coin-values)
    (cdr coin-values)
)

(define (first-denomination coin-values)
    (car coin-values)
)

(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))

(cc 100 us-coins)

Exercise 2.20. The procedures +, *, and list take arbitrary numbers of arguments. One way to define such procedures is to use define with dotted-tail notation. In a procedure definition, a parameter list that has a dot before the last parameter name indicates that, when the procedure is called, the initial parameters (if any) will have as values the initial arguments, as usual, but the final parameter’s value will be a list of any remaining arguments. For instance, given the definition

(define (f x y . z) <body>)

the procedure f can be called with two or more arguments. If we evaluate

(f 1 2 3 4 5 6)

then in the body of f, x will be $1$, y will be $2$, and z will be the list (3 4 5 6). Given the definition

(define (g . w) <body>)

the procedure g can be called with zero or more arguments. If we evaluate

(g 1 2 3 4 5 6)

then in the body of g, w will be the list (1 2 3 4 5 6).

Use this notation to write a procedure same-parity that takes one or more integers and returns a list of all the arguments that have the same even-odd parity as the first argument. For example,

(same-parity 1 2 3 4 5 6 7)
(1 3 5 7)

(same-parity 2 3 4 5 6 7)
(2 4 6)

Answer 2.20.

(define (same-parity first . rest)
    (define (filter x)
        (if (even? x)
            even?
            odd?
        )
    )

    (define (parity f l)
        (cond ((null? l) ())
              ((f (car l)) (cons (car l) (parity f (cdr l))))
              (else (parity f (cdr l)))
        )
    )
    (parity (filter first) rest)
)

Exercise 2.21. The procedure square-list takes a list of numbers as argument and returns a list of the squares of those numbers.

(square-list (list 1 2 3 4))
(1 4 9 16)

Here are two different definitions of square-list. Complete both of them by filling in the missing expressions:

(define (square-list items)
  (if (null? items)
      nil
      (cons <??> <??>)))
(define (square-list items)
  (map <??> <??>))

Answer 2.21.

(define (square-list items)
    (if (null? items)
        `()
        (cons (square (car items)) (square-list (cdr items)))
    )
)

(define (square x) (* x x))

(define (square-list-map items)
    (map square items)
)

Exercise 2.22. Louis Reasoner tries to rewrite the first square-list procedure of exercise 2.21 so that it evolves an iterative process:

(define (square-list items)
  (define (iter things answer)
    (if (null? things)
        answer
        (iter (cdr things) 
              (cons (square (car things))
                    answer))))
  (iter items nil))

Unfortunately, defining square-list this way produces the answer list in the reverse order of the one desired. Why?

Louis then tries to fix his bug by interchanging the arguments to cons:

(define (square-list items)
  (define (iter things answer)
    (if (null? things)
        answer
        (iter (cdr things)
              (cons answer
                    (square (car things))))))
  (iter items nil))

This doesn’t work either. Explain.

Answer 2.22. The first procedure doesn’t work because it constructs the last item from the front of the list to the answer. The second procedure seems right at first glance, but result is:

(square-list (list 1 2 3 4)) ((((() 1) 4) 9) 16)

Let’s look the definition of list:

(list <a_1> <a_2> ... <a_n>)
(cons <a_1> (cons <a_2> ... (cons <a_n> nil) ... ))

And the substitution of the procedure:

(square-list (list 1 2 3 4))

(iter (list 1 2 3 4) '())

(iter (list 2 3 4) (cons '() (square 1)))

(iter (list 3 4) (cons (cons '() 1)
                       (square 2)))

(iter (list 4)  (cons (cons (cons '() 1) 4)
                      (square 3)))

(iter '() (cons (cons (cons (cons '() 1) 4) 9)
                (square 4)))

(iter '() (cons (cons (cons (cons '() 1) 4) 9) 16))

(cons (cons (cons (cons '() 1) 4) 9) 16)

Therefore, the structure of answer is wrong.

Exercise 2.23. The procedure for-each is similar to map. It takes as arguments a procedure and a list of elements. However, rather than forming a list of the results, for-each just applies the procedure to each of the elements in turn, from left to right. The values returned by applying the procedure to the elements are not used at all – for-each is used with procedures that perform an action, such as printing. For example,

(for-each (lambda (x) (newline) (display x))
          (list 57 321 88))
57
321
88

The value returned by the call to for-each (not illustrated above) can be something arbitrary, such as true. Give an implementation of for-each.

Answer 2.23. I find a feature between cond and if in Lisp. If we want to use if instead of cond, one things should be concerned. Here are definitions:

(cond (<predicate> <expression> ...)
	  ...
	  (else <expression> ..)
)

(if <predicate>
	<consequent>
	<alternative>
)

In cond, one clause has one predicate and several expressions, meanwhile consequent and alternative of if only have one expression for each. Thus, in this exercise we should use cond because (newline) and (display x) are two expressions.

(define (for-each f l)
    (cond ((null? l) '()) 
          (else (f (car l))
                (for-each f (cdr l)))
    )
)

Exercise 2.24. Suppose we evaluate the expression (list 1 (list 2 (list 3 4))). Give the result printed by the interpreter, the corresponding box-and-pointer structure, and the interpretation of this as a tree (as in figure 2.6).

Exercises in this section of SCIP.

Exercise 2.1. Define a better version of make-rat that handles both positive and negative arguments. Make-rat should normalize the sign so that if the rational number is positive, both the numerator and denominator are positive, and if the rational number is negative, only the numerator is negative.

Answer 2.1.

(define (numer x) (car x))

(define (denom x) (cdr x))

(define (print-rat x)
    (newline)
    (display (numer x))
    (display "/")
    (display (denom x))
)

(define (make-rat n d)
    (let ((g ((if (< d 0) - +) (abs (gcd n d)))))
        (cons (/ n g) (/ d g))
    )
)

Exercise 2.2. Consider the problem of representing line segments in a plane. Each segment is represented as a pair of points: a starting point and an ending point. Define a constructor make-segment and selectors start-segment and end-segment that define the representation of segments in terms of points. Furthermore, a point can be represented as a pair of numbers: the $x$ coordinate and the $y$ coordinate. Accordingly, specify a constructor make-point and selectors x-point and y-point that define this representation. Finally, using your selectors and constructors, define a procedure midpoint-segment that takes a line segment as argument and returns its midpoint (the point whose coordinates are the average of the coordinates of the endpoints). To try your procedures, you’ll need a way to print points:

(define (print-point p)
  (newline)
  (display "(")
  (display (x-point p))
  (display ",")
  (display (y-point p))
  (display ")"))

Answer 2.2.

(define (x-point x) (car x))

(define (y-point x) (cdr x))

(define (print-point p)
    (newline)
    (display "(")
    (display (x-point p))
    (display ",")
    (display (y-point p))
    (display ")")
)

(define (make-point x y)
    (cons x y)
)

(define (start-segment x) (car x))

(define (end-segment x) (cdr x))

(define (make-segment x y)
    (cons x y)
)

(define (midpoint-segment s)
    (define (average a b) (/ (+ a b) 2.0))
    (let (
            (a (start-segment s))
            (b (end-segment s))
         )
         (make-point (average (x-point a) (x-point b)) (average (y-point a) (y-point b)))
    )
)

Exercise 2.3. Implement a representation for rectangles in a plane. (Hint: You may want to make use of exercise 2.2.) In terms of your constructors and selectors, create procedures that compute the perimeter and the area of a given rectangle. Now implement a different representation for rectangles. Can you design your system with suitable abstraction barriers, so that the same perimeter and area procedures will work using either representation?

Answer 2.3. Here, it talks about axis-aligned rectangles.

(define (x-point x) (car x))

(define (y-point x) (cdr x))

(define (print-point p)
    (newline)
    (display "(")
    (display (x-point p))
    (display ",")
    (display (y-point p))
    (display ")")
)

(define (make-point x y)
    (cons x y)
)

(define (make-rect p1 p2)
    (let (
            (x1 (x-point p1))
            (x2 (x-point p2))
            (y1 (y-point p1))
            (y2 (y-point p2))
         )
         (cond 
            ((and (< x1 x2) (< y1 y2)) (cons p1 p2))
            ((and (> x1 x2) (> y1 y2)) (cons p2 p1))
            ((and (< x1 x2) (> y1 y2)) (cons (make-point (x1 y2)) (make-point (x2 y1))))
            (else (cons (make-point (x2 y1)) (make-point (x1 y2))))
         )
    )
)

(define (bottom-left r) (car r))

(define (top-right r) (cdr r))

(define (print-rect r)
    (print-point (bottom-left r))
    (print-point (top-right r))
)

(define (perimeter r)
    (let (
            (p1 (bottom-left r))
            (p2 (top-right r))
         )
         (let (
                (x1 (x-point p1))
                (x2 (x-point p2))
                (y1 (y-point p1))
                (y2 (y-point p2))
              )
              (* 2 (+ (- x2 x1) (- y2 y1)))
         )
    )    
)

(define (area r)
     (let (
            (p1 (bottom-left r))
            (p2 (top-right r))
         )
         (let (
                (x1 (x-point p1))
                (x2 (x-point p2))
                (y1 (y-point p1))
                (y2 (y-point p2))
              )
              (* (- x2 x1) (- y2 y1))
         )
    )    
)

(define r (make-rect (make-point 1 1)
                     (make-point 4 5)))

Exercise 2.4. Here is an alternative procedural representation of pairs. For this representation, verify that (car (cons x y)) yields $x$ for any objects $x$ and $y$.

(define (cons x y)
  (lambda (m) (m x y)))

(define (car z)
  (z (lambda (p q) p)))

What is the corresponding definition of cdr? (Hint: To verify that this works, make use of the substitution model of section 1.1.5.)

Answer 2.4.

(define (cdr z)
	(z (lambda (p q) q))
)

Substitution model:

=> (cdr z)
=> (z (lambda (p q) p))
=> ((lambda (m) (m x y) (lambda (p q) q)))
=> ((lambda (p q) q) x y)
=> y

Exercise 2.5. Show that we can represent pairs of nonnegative integers using only numbers and arithmetic operations if we represent the pair $a$ and $b$ as the integer that is the product $2^a 3^b$. Give the corresponding definitions of the procedures cons, car, and cdr.

Answer 2.5.

(define (cons a b)
    (* (expt 2 a) (expt 3 b))
)

(define (logb b n) (floor (/ (log n) (log b))))

(define (car x)
    (logb 2 (/ x (gcd x (expt 3 (logb 3 x)))))
)

(define (cdr x)
    (logb 3 (/ x (gcd x (expt 2 (logb 2 x)))))
)

Exercise 2.6. In case representing pairs as procedures wasn’t mind-boggling enough, consider that, in a language that can manipulate procedures, we can get by without numbers (at least insofar as nonnegative integers are concerned) by implementing $0$ and the operation of adding $1$ as

(define zero (lambda (f) (lambda (x) x)))

(define (add-1 n)
  (lambda (f) (lambda (x) (f ((n f) x)))))

This representation is known as Church numerals, after its inventor, Alonzo Church, the logician who invented the $\lambda$ calculus.

Define one and two directly (not in terms of zero and add-1). (Hint: Use substitution to evaluate (add-1 zero)). Give a direct definition of the addition procedure + (not in terms of repeated application of add-1).

Answer 2.6.

=> (one)
=> (add-1 zero)
=> (lambda (f) (lambda (x) (f ((zero f) x))))

zero is a function of one argument, that returns a function of one argument that returns the argument.

=> ((zero f) x)
=> ((lambda(x) x) x)
=> x

So, one and two are:

=> (one)
=> (lambda (f) (lambda (x) (f x)))

=> (two)
=> (add-1 two)
=> (lambda (f) (lambda (x) (f (f x))))

Thus,

(define one (lambda (f) (lambda (x) (f x))))

(define two (lambda (f) (lambda (x) (f (f x)))))

And add using the same approach in add-1:

(define (add a b)
	(lambda (f)
		(lambda (x) (a f) ((b f) x))
	)
)

Exercise 2.7. Alyssa’s program is incomplete because she has not specified the implementation of the interval abstraction. Here is a definition of the interval constructor:

(define (make-interval a b) (cons a b))

Define selectors upper-bound and lower-bound to complete the implementation.

Answer 2.7.

(define (upper-bound interval)
	(max (car interval) (cdr interval))
)

(define (lower-bound interval)
	(min (car interval) (cdr interval))
)

Exercise 2.8. Using reasoning analogous to Alyssa’s, describe how the difference of two intervals may be computed. Define a corresponding subtraction procedure, called sub-interval.

Answer 2.8.

(define (sub-interval x y)
	(make-interval (- (lower-bound x) (upper-bound y))
				   (- (upper-bound x) (lower-bound y)))
)

Exercise 2.9. The width of an interval is half of the difference between its upper and lower bounds. The width is a measure of the uncertainty of the number specified by the interval. For some arithmetic operations the width of the result of combining two intervals is a function only of the widths of the argument intervals, whereas for others the width of the combination is not a function of the widths of the argument intervals. Show that the width of the sum (or difference) of two intervals is a function only of the widths of the intervals being added (or subtracted). Give examples to show that this is not true for multiplication or division.

Answer 2.9. For multiplication and division, the story is different. If the width of the result was a function of the widths of the inputs, then multiplying different intervals with the same widths should give the same answer. For example, multiplying a width 5 interval with a width 1 interval.

Exercise 2.10. Ben Bitdiddle, an expert systems programmer, looks over Alyssa’s shoulder and comments that it is not clear what it means to divide by an interval that spans zero. Modify Alyssa’s code to check for this condition and to signal an error if it occurs.

Answer 2.10. We should guarantee:

$$ R_p = \frac{1}{1/R_1+1/R_2} = \frac{R_1+R_2}{R_1 R_2}, \text{where } R_1 R_2 \neq 0. $$

(define (div-interval x y)
	(if (>= 0 (* (lower-bound y) (upper-bound y)))
		(error "Divison 0 error")
		(mul-interval x (make-interval (/ 1 (upper-bound y))
							(/ 1 (lower-bound y))
						))
	)
)

Exercise 2.11. In passing, Ben also cryptically comments: “By testing the signs of the endpoints of the intervals, it is possible to break mul-interval into nine cases, only one of which requires more than two multiplications.” Rewrite this procedure using Ben’s suggestion.

After debugging her program, Alyssa shows it to a potential user, who complains that her program solves the wrong problem. He wants a program that can deal with numbers represented as a center value and an additive tolerance; for example, he wants to work with intervals such as $3.5 \pm 0.15$ rather than $[3.35, 3.65]$. Alyssa returns to her desk and fixes this problem by supplying an alternate constructor and alternate selectors:

(define (make-center-width c w)
  (make-interval (- c w) (+ c w)))
(define (center i)
  (/ (+ (lower-bound i) (upper-bound i)) 2))
(define (width i)
  (/ (- (upper-bound i) (lower-bound i)) 2))

Unfortunately, most of Alyssa’s users are engineers. Real engineering situations usually involve measurements with only a small uncertainty, measured as the ratio of the width of the interval to the midpoint of the interval. Engineers usually specify percentage tolerances on the parameters of devices, as in the resistor specifications given earlier.

Exercises in this section of SCIP, and Merry Xmas.

Exercise 1.29. Simpson’s Rule is a more accurate method of numerical integration than the method illustrated above. Using Simpson’s Rule, the integral of a function $f$ between $a$ and $b$ is approximated as

$$ \frac{h}{3}[y_0+4y_1+2y_2+4y_3+…+2y_{n-2}+4y_{n-1}+y_n] $$

where $h = (b - a)/n$, for some even integer $n$, and $y_k = f(a + kh)$. (Increasing $n$ increases the accuracy of the approximation.) Define a procedure that takes as arguments $f$, $a$, $b$, and $n$ and returns the value of the integral, computed using Simpson’s Rule. Use your procedure to integrate cube between $0$ and $1$ (with $n = 100$ and $n = 1000$), and compare the results to those of the integral procedure shown above.

Answer 1.29. The Simpson’s Rule can also be written as follow:

$$ \frac{h}{3}[y_0+4y_1+2y_2+4y_3+…+2y_{n-2}+4y_{n-1}+y_n] = \frac{h}{3}\sum_{j=2,4…}^{n}[y_{j-2} + 4y_{j-1} + y_{j}] $$

(define (sum term a next b)
    (if (> a b)
        0
        (+ (term a)
           (sum term (next a) next b)
        )
    )
)

(define (simpson-rule f a b n)
    (define (simpson-next x)
        (+ x 2)
    )
    
    (define h (/ (- b a) n))
    
    (define (y k)
        (f (+ a (* k h)))
    )

    (define (simpson-term x)
        (+
            (y x)
            (* 4 (y (+ x 1)))
            (y (+ x 2))
        )
    )

    (* (sum simpson-term 0 simpson-next n ) (/ h 3))
)

(define (cub x)
    (* x x x)
)

(exact->inexact(simpson-rule cub 0 1 100))
(exact->inexact(simpson-rule cub 0 1 1000))

Exercise 1.30. The sum procedure above generates a linear recursion. The procedure can be rewritten so that the sum is performed iteratively. Show how to do this by filling in the missing expressions in the following definition:

(define (sum term a next b)
  (define (iter a result)
      (if <??>
	      <??>
		  (iter <??> <??>))
  (iter <??> <??>)

Answer 1.30.

(define (sum term a next b)
	(define (iter a result)
		(if (> a b)
			result
			(iter (next a) (+ result (term a)))
		)
	)
	(iter a 0)
)

Exercise 1.31.

a. The sum procedure is only the simplest of a vast number of similar abstractions that can be captured as higher-order procedures. Write an analogous procedure called product that returns the product of the values of a function at points over a given range. Show how to define factorial in terms of product. Also use product to compute approximations to $\pi$ using the formula

$$ \frac{\pi}{4}=\frac{2 \cdot 4 \cdot 4 \cdot 6 \cdot 6 \cdot 8 …}{3 \cdot 3 \cdot 5 \cdot 5 \cdot 7 \cdot 7 …} $$

b. If your product procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

Answer 1.31.

$$ \frac{\pi}{4}=\frac{2 \cdot 4 \cdot 4 \cdot 6 \cdot 6 \cdot 8 …}{3 \cdot 3 \cdot 5 \cdot 5 \cdot 7 \cdot 7 …} = \frac{1}{n+1}\prod_{i=1}^{n}[(\frac{2(i+1)}{2i})^2] $$

(define (product term a next b)
    (if (> a b)
        1
        (* (term a) (product term (next a) next b))
    )
)

(define (factorial n)
    (define (identity x)
        x
    )
    (define (next x)
        (+ x 1)
    )
    (product identity 1 next n)
)

(define (product term a next b)
    (define (iter a result)
        (if (> a b)
            result
            (iter (next a) (* result (term a)))
        )
    )
    (iter a 1)
)

(define (square x)
    (* x x)
)

(define (pi-product a b)
    (define (pi-term x)
       (square (/ (* 2 (+ x 1)) (+ (* 2 x) 1)))
    )
    (define (pi-next x)
        (+ x 1)
    )
    (* 4 (/ (product-iter pi-term a pi-next b) (+ b 1)))
)

(exact->inexact(pi-product 1 10000))

Exercise 1.32.

a. Show that sum and product (exercise 1.31) are both special cases of a still more general notion called accumulate that combines a collection of terms, using some general accumulation function:

(accumulate combiner null-value term a next b)

Accumulate takes as arguments the same term and range specifications as sum and product, together with a combiner procedure (of two arguments) that specifies how the current term is to be combined with the accumulation of the preceding terms and a null-value that specifies what base value to use when the terms run out. Write accumulate and show how sum and product can both be defined as simple calls to accumulate.

b. If your accumulate procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

Answer 1.32.

(define (accumulate combiner null-value term a next b)
    (if (> a b)
        null-value
        (combiner (term a) (accumulate combiner null-value term (next a) next b))
    )
)

(define (accumlate-iter combiner null-value term a next b)
    (define (iter a result)
        (if (> a b) res
            (iter (next a) (combiner res (term a)))
        )
    )
    (iter a null-value)
)

(define (sum term a next b)
    (accumulate + 0 term a next b)
)

(define (product term a next b)
    (accumlate * 1 term a next b)
)

Exercise 1.33. You can obtain an even more general version of accumulate (exercise 1.32) by introducing the notion of a filter on the terms to be combined. That is, combine only those terms derived from values in the range that satisfy a specified condition. The resulting filtered-accumulate abstraction takes the same arguments as accumulate, together with an additional predicate of one argument that specifies the filter. Write filtered-accumulate as a procedure. Show how to express the following using filtered-accumulate:

a. the sum of the squares of the prime numbers in the interval $a$ to $b$ (assuming that you have a prime? predicate already written)

b. the product of all the positive integers less than $n$ that are relatively prime to $n$ (i.e., all positive integers $i < n$ such that $GCD(i,n) = 1)$.

Answer 1.33.

(define (filtered-accumulate combiner null-value term a next b filter)
    (if (> a b)
        null-value
        (if (filter a)
            (combiner (term a) (filtered-accumulate combiner null-value (next a) next b filter))
            (combiner null-value (filtered-accumulate combiner null-value (next a) next b filter))
        )
    )
)

Exercise 1.34. Suppose we define the procedure

(define (f g)
  (g 2))

Then we have

(f square)
4

(f (lambda (z) (* z (+ z 1))))
6

What happens if we (perversely) ask the interpreter to evaluate the combination (f f)? Explain.

Answer 1.34.

=> (f f)
=> (f 2)
=> (2 2)

The third invocation will attempt to apply its argument, 2, to 2, resulting in error.

Exercise 1.35. Show that the golden ratio $\phi$ (section 1.2.2) is a fixed point of the transformation $x \mapsto 1 + 1/x$, and use this fact to compute $\phi$ by means of the fixed-point procedure.

Answer 1.35.

(define tolerance 0.00001)

(define (fixed-point f first-guess)
    (define (close-enough? v1 v2)
        (< (abs (- v1 v2)) tolerance)
    )

    (define (try guess)
        (let ((next (f guess)))
            (if (close-enough? guess next)
                next
                (try next)
            )
        )
    )

    (try first-guess)
)

(fixed-point (lambda (x) (+ 1 (/ 1 x))) 1.0)

Exercise 1.36. Modify fixed-point so that it prints the sequence of approximations it generates, using the newline and display primitives shown in exercise 1.22. Then find a solution to $x^x = 1000$ by finding a fixed point of $x \mapsto \log(1000)/\log(x)$. (Use Scheme’s primitive log procedure, which computes natural logarithms.) Compare the number of steps this takes with and without average damping. (Note that you cannot start fixed-point with a guess of $1$, as this would cause division by $\log(1) = 0$.)

Answer 1.36.

(define tolerance 0.00001)

(define (fixed-point f first-guess)
    (define (close-enough? v1 v2)
        (< (abs (- v1 v2)) tolerance)
    )

    (define (try guess)
        (display guess)
        (newline)
        (let ((next (f guess)))
            (if (close-enough? guess next)
                next
                (try next)
            )
        )
    )

    (try first-guess)
)

(fixed-point (lambda(x) (/ (log 1000.0) (log x))) 2.0)

Exercise 1.37.

a. An infinite continued fraction is an expression of the form

$$ f=\frac{N_1}{D_1+\frac{N_2}{D_2+\frac{N_3}{D_3+…}}} $$

As an example, one can show that the infinite continued fraction expansion with the $N_i$ and the $D_i$ all equal to $1$ produces $1/\phi$, where $\phi$ is the golden ratio (described in section 1.2.2). One way to approximate an infinite continued fraction is to truncate the expansion after a given number of terms. Such a truncation – a so-called $k$-term finite continued fraction – has the form

$$ \frac{N_1}{D_1+\frac{N_2}{…+\frac{N_k}{D_k}}} $$

Suppose that n and d are procedures of one argument (the term index $i$) that return the $N_i$ and $D_i$ of the terms of the continued fraction. Define a procedure cont-frac such that evaluating (cont-frac n d k) computes the value of the $k$-term finite continued fraction. Check your procedure by approximating $1/\phi$ using

(cont-frac (lambda (i) 1.0)
           (lambda (i) 1.0)
           k)

for successive values of k. How large must you make k in order to get an approximation that is accurate to $4$ decimal places?

b. If your cont-frac procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

Answer 1.37.

(define (con-frac n d k)
    (define (frac i)
        (if (< i k)
            (/ (n i) (+ (d i) (frac (+ i 1))))
            (/ (n i) (d i))
        )
    )
    (frac 1)
)

(define (con-frac-iter n d k)
    (define (frac-iter i result)
        (if (= i 0)
            result
            (frac-iter (- i 1) (/ (n i) (+ (d i) result)))
        )
        (frac-iter (- k 1) (/ (n k) (d k)))
    )
)

(con-frac (lambda(i) 1.0) (lambda(i) 1.0) 10)

Exercise 1.38. In 1737, the Swiss mathematician Leonhard Euler published a memoir De Fractionibus Continuis, which included a continued fraction expansion for $e - 2$, where $e$ is the base of the natural logarithms. In this fraction, the $E_i$ are all $1$, and the $D_i$ are successively $1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, …$. Write a program that uses your cont-frac procedure from exercise 1.37 to approximate $e$, based on Euler’s expansion.

Answer 1.38.

$$ D_i= \begin{cases} 2(i+1)/3, & \text{if } i\bmod 3 = 2;
1, & \text{if } i\bmod 3 \neq 2. \end{cases} $$

(define (con-frac n d k)
    (define (frac i)
        (if (< i k)
            (/ (n i) (+ (d i) (frac (+ i 1))))
            (/ (n i) (d i))
        )
    )
    (frac 1)
)

(define (eular k)
    (+ 2.0 (con-frac 
        (lambda(i) 1)
        (lambda(i)
            (if (= (remainder i 3) 2)
                (/ (+ i 1) 1.5)
                1
            )
        )
        k
    ))
)

(eular 100)

Exercise 1.39. A continued fraction representation of the tangent function was published in 1770 by the German mathematician J.H. Lambert:

$$ \tan x = \frac{x}{1-\frac{x^2}{3-\frac{x^2}{5-…}}} $$

where $x$ is in radians. Define a procedure (tan-cf x k) that computes an approximation to the tangent function based on Lambert’s formula. K specifies the number of terms to compute, as in exercise 1.37.

Answer 1.39.

(define (con-frac n d k)
    (define (frac i)
        (if (< i k)
            (/ (n i) (- (d i) (frac (+ i 1))))
            (/ (n i) (d i))
        )
    )
    (frac 1)
)

(define (tan-cf x k)
    (con-frac 
        (lambda (i) (
            if (= i 1)
                x
                (* x x)
        ))
        (lambda (i) (
            - (* 2 i) 1
        ))
        k
    )
)

Exercise 1.40. Define a procedure cubic that can be used together with the newtons-method procedure in expressions of the form

(newtons-method (cubic a b c) 1)

to approximate zeros of the cubic $x^3 + ax^2 + bx + c$.

Answer 1.40.

(define (cubic a b c)
    (lambda(x)
        (+
            (cube x)
            (* a (square x))
            (* b x)
            c
        )
    )
)

(define (cube x)
    (* x x x)
)

(define (square x)
    (* x x)
)

Exercise 1.41. Define a procedure double that takes a procedure of one argument as argument and returns a procedure that applies the original procedure twice. For example, if inc is a procedure that adds $1$ to its argument, then (double inc) should be a procedure that adds $2$. What value is returned by

(((double (double double)) inc) 5)

Answer 1.41.

We guess the procedure double is:

(define (double f)
	(lambda (x) (f (f x)))
)

Then:

=> (((double (double double)) inc) 5) 
=> (((double (lambda (x) (double (double x)))) inc) 5) 
=> ((double (double (double (double inc)))) 5)

Since there are 4 double procedures, call procedure is invoked $2^4 = 16$ times. Thus, result is $5 + 16 = 21$

Exercise 1.42. Let $f$ and $g$ be two one-argument functions. The composition $f$ after $g$ is defined to be the function $x \mapsto f(g(x))$. Define a procedure compose that implements composition. For example, if inc is a procedure that adds $1$ to its argument,

((compose square inc) 6)
49

Answer 1.42.

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

Exercise 1.43. If $f$ is a numerical function and $n$ is a positive integer, then we can form the $n$th repeated application of $f$, which is defined to be the function whose value at $x$ is $f(f(…(f(x))…))$. For example, if $f$ is the function $x \mapsto x + 1$, then the $n$th repeated application of $f$ is the function $x \mapsto x + n$. If $f$ is the operation of squaring a number, then the $n$th repeated application of $f$ is the function that raises its argument to the $2^n$th power. Write a procedure that takes as inputs a procedure that computes $f$ and a positive integer $n$ and returns the procedure that computes the $n$th repeated application of $f$. Your procedure should be able to be used as follows:

((repeated square 2) 5)
625

Hint: You may find it convenient to use compose from exercise 1.42.

Answer 1.43.

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

(define (repeated f n)
   (if (< n 1)
        (lambda(x) x)
        (compose f (repeated f (- n 1)))
   ) 
)

Exercise 1.44. The idea of smoothing a function is an important concept in signal processing. If $f$ is a function and $dx$ is some small number, then the smoothed version of $f$ is the function whose value at a point $x$ is the average of $f(x - dx)$, $f(x)$, and $f(x + dx)$. Write a procedure smooth that takes as input a procedure that computes $f$ and returns a procedure that computes the smoothed $f$. It is sometimes valuable to repeatedly smooth a function (that is, smooth the smoothed function, and so on) to obtained the $n$-fold smoothed function. Show how to generate the $n$-fold smoothed function of any given function using $smooth$ and $repeated$ from exercise 1.43.

Answer 1.44.

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

(define (repeated f n)
   (if (< n 1)
        (lambda(x) x)
        (compose f (repeated f (- n 1)))
   ) 
)

(define (smooth f)
    (lambda (x)
        (/ (+
                (f (- x dx))
                (f x)
                (f (+ x dx))
           )
           3 
        )
    )
)

(define (n-fold-smooth f n)
    ((repeated smooth n) f)
)

Exercise 1.45. We saw in section 1.3.3 that attempting to compute square roots by naively finding a fixed point of $y \mapsto x/y$ does not converge, and that this can be fixed by average damping. The same method works for finding cube roots as fixed points of the average-damped $y \mapsto x/y^2$. Unfortunately, the process does not work for fourth roots – a single average damp is not enough to make a fixed-point search for $y \mapsto x/y^3$ converge. On the other hand, if we average damp twice (i.e., use the average damp of the average damp of $y \mapsto x/y^3$) the fixed-point search does converge. Do some experiments to determine how many average damps are required to compute $n$th roots as a fixed-point search based upon repeated average damping of $y \mapsto x/y^{n-1}$. Use this to implement a simple procedure for computing nth roots using fixed-point, average-damp, and the repeated procedure of exercise 1.43. Assume that any arithmetic operations you need are available as primitives.

Answer 1.45. Here reference SICP 1.45: Computing nth roots

To fix the problem, we need to increase the number of times invoking average-damp. And we find out the number of average damps, $a$, we can say:

$$ n_{\text{max}} = 2^{a+1} - 1 \ a = \lfloor \log _2{n} \rfloor $$

(define (nth-root x n)
    (fixed-point
        ((repeated average-damp (floor (/ (log x) (log 2))))
            (lambda (y) (/ x (expt y (- n 1))))
        )
        1.0
    )
)

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

(define (repeated f n)
   (if (< n 1)
        (lambda(x) x)
        (compose f (repeated f (- n 1)))
   ) 
)

(define tolerance 0.00001)

(define (fixed-point f first-guess)
    (define (close-enough? v1 v2)
        (< (abs (- v1 v2)) tolerance)
    )

    (define (try guess)
        (let ((next (f guess)))
            (if (close-enough? guess next)
                next
                (try next)
            )
        )
    )

    (try first-guess)
)

(define (average-damp f)
    (define (average x y)
        (/ (+ x y) 2)
    )
    (lambda (x) (average x (f x)))
)

(define (expt b n)
    (define (even? n) (= (remainder n 2) 0))
    (define (square x) (* x x))
    (cond 
        ((= n 0) 1)
        ((even? n) (square (expt b (/ n 2))))
        (else (* b (expt b (- n 1))))
    )
)

Exercise 1.46. Several of the numerical methods described in this chapter are instances of an extremely general computational strategy known as iterative improvement. Iterative improvement says that, to compute something, we start with an initial guess for the answer, test if the guess is good enough, and otherwise improve the guess and continue the process using the improved guess as the new guess. Write a procedure iterative-improve that takes two procedures as arguments: a method for telling whether a guess is good enough and a method for improving a guess. Iterative-improve should return as its value a procedure that takes a guess as argument and keeps improving the guess until it is good enough. Rewrite the sqrt procedure of section 1.1.7 and the fixed-point procedure of section 1.3.3 in terms of iterative-improve.

(define (close-enough? v1 v2) 
   (define tolerance 1.e-6) 
   (< (/ (abs (- v1 v2)) v2)  tolerance)) 
  
(define (iterative-improve improve close-enough?) 
   (lambda (x) 
     (let ((xim (improve x))) 
       (if (close-enough? x xim) 
           xim 
         ((iterative-improve improve close-enough?) xim)) 
       ))) 
  
(define (sqrt x) 
   ((iterative-improve   
     (lambda (y) 
       (/ (+ (/ x y) y) 2)) 
     close-enough?) 1.0))

Exercises in this section of SCIP.

Exercise 1.20. The process that a procedure generates is of course dependent on the rules used by the interpreter. As an example, consider the iterative gcd procedure given above. Suppose we were to interpret this procedure using normal-order evaluation, as discussed in section 1.1.5. (The normal-order-evaluation rule for if is described in exercise 1.5.) Using the substitution method (for normal order), illustrate the process generated in evaluating (gcd 206 40) and indicate the remainder operations that are actually performed. How many remainder operations are actually performed in the normal-order evaluation of (gcd 206 40)? In the applicative-order evaluation?

Answer 1.20.

Normal-order evaluation: fully expand and then reduce. 18 total remainder.

Applicative-order evaluation: evaluate arguments and then apply operands. 4 total remainder.

Exercise 1.21. Use the smallest-divisor procedure to find the smallest divisor of each of the following numbers: $199$, $1999$, $19999$.

Answer 1.21.

(define (smallest-divisor n)
    (find-divisor n 2)
)

(define (find-divisor n test-divisor)
    (cond ((> (square test-divisor) n) n)
          ((divides? test-divisor n) test-divisor)
          (else (find-divisor n (+ test-divisor 1)))
    )
)

(define (divides? a b)
    (= (remainder b a) 0)
)

(smallest-divisor 199) => 199
(smallest-divisor 1999) => 1999
(smallest-divisor 19999) => 7

Exercise 1.22. Most Lisp implementations include a primitive called runtime that returns an integer that specifies the amount of time the system has been running (measured, for example, in microseconds). The following timed-prime-test procedure, when called with an integer $n$, prints $n$ and checks to see if $n$ is prime. If $n$ is prime, the procedure prints three asterisks followed by the amount of time used in performing the test.

(define (timed-prime-test n)
  (newline)
  (display n)
  (start-prime-test n (runtime)))
(define (start-prime-test n start-time)
  (if (prime? n)
      (report-prime (- (runtime) start-time))))
(define (report-prime elapsed-time)
  (display " *** ")
  (display elapsed-time))

Using this procedure, write a procedure search-for-primes that checks the primality of consecutive odd integers in a specified range. Use your procedure to find the three smallest primes larger than $1000$; larger than $10,000$; larger than $100,000$; larger than $1,000,000$. Note the time needed to test each prime. Since the testing algorithm has order of growth of $\theta(\sqrt n)$, you should expect that testing for primes around $10,000$ should take about $\sqrt{10}$ times as long as testing for primes around $1000$. Do your timing data bear this out? How well do the data for $100,000$ and $1,000,000$ support the $\sqrt n$ prediction? Is your result compatible with the notion that programs on your machine run in time proportional to the number of steps required for the computation?

Answer 1.22.

(define runtime real-time-clock)

(define (timed-prime-test n)
  (newline)
  (display n)
  (start-prime-test n (runtime)))

(define (start-prime-test n start-time)
  (if (prime? n)
      (report-prime (- (runtime) start-time))))

(define (report-prime elapsed-time)
  (display " *** ")
  (display elapsed-time))

(define (find-divisor n test-divisor)
	(cond 
		((> (square test-divisor) n) n)
		((divides? test-divisor n) test-divisor)
		(else (find-divisor n (+ test-divisor 1)))
	)
)

(define (square x)
	(* x x)
)

(define (divides? a b)
	(= (remainder b a) 0)
)

(define (smallest-divisor n)
	(find-divisor n 2)
)

(define (prime? n)
	(= n (smallest-divisor n))
)

(define (search-for-primes start end)
	(if (even? start)
		(search-for-primes (+ start 1) end)
		(cond 
			((< start end) (timed-prime-test start)
			(search-for-primes (+ start 2) end))
		)
	)
)

(search-for-primes 1000000 1000100)

Exercise 1.23. The smallest-divisor procedure shown at the start of this section does lots of needless testing: After it checks to see if the number is divisible by $2$ there is no point in checking to see if it is divisible by any larger even numbers. This suggests that the values used for test-divisor should not be $2, 3, 4, 5, 6, …$, but rather $2, 3, 5, 7, 9, …$. To implement this change, define a procedure next that returns $3$ if its input is equal to $2$ and otherwise returns its input plus $2$. Modify the smallest-divisor procedure to use (next test-divisor) instead of (+ test-divisor 1). With timed-prime-test incorporating this modified version of smallest-divisor, run the test for each of the $12$ primes found in exercise 1.22. Since this modification halves the number of test steps, you should expect it to run about twice as fast. Is this expectation confirmed? If not, what is the observed ratio of the speeds of the two algorithms, and how do you explain the fact that it is different from $2$?

Answer 1.23.

(define (find-divisor n test-divisor)
    (cond
        ((> (square test-divisor) n) n)
        ((divides? test-divisor n) test-divisor)
        (else (find-divisor n (next test-divisor)))
    )
)

(define (next test-divisor)
    (if (= test-divisor 2) (+ test-divisor 1)
                           (+ test-divisor 2)
    )
)

(define (square x)
    (* x x)
)

(define (divides? a b)
    (= (remainder b a) 0)
)

(define (smallest-divisor n)
    (find-divisor n 2)
)

(define (prime? n)
    (= (smallest-divisor n) n)
)

Exercise 1.24. Modify the timed-prime-test procedure of exercise 1.22 to use fast-prime? (the Fermat method), and test each of the $12$ primes you found in that exercise. Since the Fermat test has $\theta (\log n)$ growth, how would you expect the time to test primes near $1,000,000$ to compare with the time needed to test primes near 1000? Do your data bear this out? Can you explain any discrepancy you find?

Answer 1.24.

(define (expmod base exp m)
    (cond 
        ((= exp 0) 1)
        ((even? exp) (remainder (square (expmod base (/ exp 2) m)) m))
        (else (remainder (* base (expmod base (- exp 1) m)) m))
    )
)

(define (fermat-test n)
    (define (try-it a)
        (= (expmod a n n) a)
    )
    (try-it (+ 1 (random (- n 1))))
)

(define (fast-prime? n times)
    (cond
        ((= times 0) true)
        ((fermat-test n) (fast-prime? n (- times 1)))
        (else false)
    )
)

(define (prime? n)
    (fast-prime? n 100 )
)

Exercise 1.25. Alyssa P. Hacker complains that we went to a lot of extra work in writing expmod. After all, she says, since we already know how to compute exponentials, we could have simply written

(define (expmod base exp m)
  (remainder (fast-expt base exp) m))

Is she correct? Would this procedure serve as well for our fast prime tester? Explain.

Answer 1.25. Scheme is able to handle arbitrary-precision arithmetic, but arithmetic with arbitrarily long numbers is computationally expensive. This means that we get the correct results, but it takes considerably longer.

Exercise 1.26. Louis Reasoner is having great difficulty doing exercise 1.24. His fast-prime? test seems to run more slowly than his prime? test. Louis calls his friend Eva Lu Ator over to help. When they examine Louis’s code, they find that he has rewritten the expmod procedure to use an explicit multiplication, rather than calling square:

(define (expmod base exp m)
  (cond ((= exp 0) 1)
        ((even? exp)
         (remainder (* (expmod base (/ exp 2) m)
                       (expmod base (/ exp 2) m))
                    m))
        (else
         (remainder (* base (expmod base (- exp 1) m))
                    m))))

“I don’t see what difference that could make,” says Louis. “I do.” says Eva. “By writing the procedure like that, you have transformed the $\theta (\log n)$ process into a $\theta (n)$ process.’’ Explain.

Answer 1.26. Let $n$ is exponent which can generate a complete binary tree recursion. The depth of the tree is $\log n + 1$, the total number of nodes is $2^{\log n + 1} - 1$, is $2n -1 = \theta (n)$.

Exercise 1.27. Demonstrate that the Carmichael numbers listed in footnote 47 really do fool the Fermat test. That is, write a procedure that takes an integer $n$ and tests whether $a^n$ is congruent to $a$ modulo $n$ for every $a < n$, and try your procedure on the given Carmichael numbers.

Answer 1.27. Carmichael numbers fools Fermat test.

(define (expmod base exp m)
    (cond 
        ((= exp 0) 1)
        ((even? exp) (remainder (square (expmod base (/ exp 2) m)) m))
        (else (remainder (* base (expmod base (- exp 1) m)) m))
    )
)

(define (fermat-test n test-value)
    (define (try-it a)
        (= (expmod a n n) a)
    )
    (try-it test-value)
)

(define (fast-prime? n times)
    (cond
        ((= times 0) true)
        ((fermat-test n times) (fast-prime? n (- times 1)))
        (else false)
    )
)

(define (prime? n)
    (fast-prime? n (- n 1))
)

(prime? 561)
(prime? 1105)
(prime? 1729)
(prime? 2465)

Exercise 1.28. One variant of the Fermat test that cannot be fooled is called the Miller-Rabin test (Miller 1976; Rabin 1980). This starts from an alternate form of Fermat’s Little Theorem, which states that if $n$ is a prime number and $a$ is any positive integer less than $n$, then $a$ raised to the $(n - 1)$st power is congruent to $1$ modulo $n$. To test the primality of a number $n$ by the Miller-Rabin test, we pick a random number $a<n$ and raise $a$ to the $(n - 1)$st power modulo $n$ using the expmod procedure. However, whenever we perform the squaring step in expmod, we check to see if we have discovered a “nontrivial square root of $1$ modulo $n$,” that is, a number not equal to $1$ or $n - 1$ whose square is equal to $1$ modulo $n$. It is possible to prove that if such a nontrivial square root of $1$ exists, then $n$ is not prime. It is also possible to prove that if $n$ is an odd number that is not prime, then, for at least half the numbers $a<n$, computing $a^{n-1}$ in this way will reveal a nontrivial square root of $1$ modulo $n$. (This is why the Miller-Rabin test cannot be fooled.) Modify the expmod procedure to signal if it discovers a nontrivial square root of $1$, and use this to implement the Miller-Rabin test with a procedure analogous to fermat-test. Check your procedure by testing various known primes and non-primes. Hint: One convenient way to make expmod signal is to have it return $0$.

Answer 1.28. I got stuck in the exercise for hours. After reading other resources about Miller-Rabin test, I find out we don’t worry about the proof that “if such a nontrivial square root of $1$ exists, then $n$ is not prime”. Just know about the condition apply to the procedure.

(define (expmod base exp m)
    (cond
        ((= exp 0) 1)
        ((even? exp)
            (let ((x (expmod base (/ exp 2) m)))
                (if (non-trivial-sqrt? x m) 0 (remainder (square x) m))
            )
        )
        (else (remainder (* base (expmod base (- exp 1) m)) m))
    )
)

(define (non-trivial-sqrt? n m)
    (cond
        ((= n 1) false)
        ((= n (- m 1)) false)
        (else (= (remainder (square n) m) 1))
    )
)

(define (square x)
    (* x x)
)

(define (miller-rabin-test a n)
    (cond
        ((= a 0) true)
        ((= (expmod a (- n 1) n ) 1) (miller-rabin-test (- a 1) n))
        (else false)
    )
)

(define (prime? n)
    (miller-rabin-test (- n 1) n)
)

(prime? 561)
(prime? 1105)
(prime? 1729)
(prime? 2465)

Exercises in this section of SCIP.

Exercise 1.9. Each of the following two procedures defines a method for adding two positive integers in terms of the procedures inc, which increments its argument by 1, and dec, which decrements its argument by 1.

(define (+ a b)
  (if (= a 0)
      b
      (inc (+ (dec a) b))))

(define (+ a b)
  (if (= a 0)
      b
      (+ (dec a) (inc b))))

Using the substitution model, illustrate the process generated by each procedure in evaluating (+ 4 5). Are these processes iterative or recursive?

Answer 1.9.

For the first process, it is recursive:

=> (+ 4 5)
=> (+ 1 ( + 3 5))
=> (+ 1 (+ 1 (+ 2 5)))
=> ...
=> (+ 1 (+ 1 (+ 1 (+ 1 (5)))))
=> (+ 1 (+ 1 (+ 1 (6))))
=> (+ 1 (+ 1 (7)))
=> ...
=> 9

For the second process, it is iterative:

=> (+ 4 5)
=> (+ 3 6)
=> (+ 2 7)
=> ...
=> (+ 0 8)
=> 8

Exercise 1.10. The following procedure computes a mathematical function called Ackermann’s function.

(define (A x y)
  (cond ((= y 0) 0)
        ((= x 0) (* 2 y))
        ((= y 1) 2)
        (else (A (- x 1)
                 (A x (- y 1))))))

What are the values of the following expressions?

(A 1 10)

(A 2 4)

(A 3 3)

Consider the following procedures, where A is the procedure defined above:

(define (f n) (A 0 n))

(define (g n) (A 1 n))

(define (h n) (A 2 n))

Give concise mathematical definitions for the functions computed by the procedures f, g, and h for positive integer values of n.

Answer 1.10.

(A 1 10) = 2^10 = 1024
(A 2 4) = 65536
(A 3 3) = 65536

$$ A(0,n)=f(n)=2n $$

$$ A(1,n)=g(n)=2^n $$

$$ A(2,n)=h(n) = \overbrace{(2^{(2^{(2^{…})})})}^{n ~times} $$

Exercise 1.11. A function f is defined by the rule that f(n) = n if n<3 and f(n) = f(n-1) + 2f(n-2) + 3f(n-3) if n>3. Write a procedure that computes f by means of a recursive process. Write a procedure that computes f by means of an iterative process.

Answer 1.11.

(define (fun-recursive n)
  (if (< n 3)
  n
  (+ (fun-recursive (- n 1))
     (* 2 (fun-recursive (- n 2)))
     (* 3 (fun-recursive (- n 3)))
     )) 
  )

(define (fun-iter n a b cnt)
     (if (= cnt 0)
            n
            (fun-iter (+ n (* 2 a) (* 3 b)) n a (- cnt 1))
     )
)

(define (fun-iterative n)
    (fun-iter 2 1 0 (- n 2))
)

Exercise 1.12. The following pattern of numbers is called Pascal’s triangle.

				1
			1		1
		1		2		1
	1		3		3		1
1		4		6		4		1
			   ...

The numbers at the edge of the triangle are all 1, and each number inside the triangle is the sum of the two numbers above it. Write a procedure that computes elements of Pascal’s triangle by means of a recursive process.

Answer 1.12.

(define (pascal-triangle m n)
    (if (or (= n 1) (= n m))
        1
        (+ (pascal-triangle (- m 1) (- n 1)) 
           (pascal-triangle (- m 1) n))
    )
)

Exercise 1.13. Prove that Fib(n) is the closest integer to $\frac{\phi^{n}}{\sqrt{5}}$, where $\phi=\frac{1 + \sqrt{5}}{2}$.

Answer 1.13.

Theorem 1

$$ Fib(n)=\frac{\phi^n-\psi^n}{\sqrt{5}},\phi=\frac{1+\sqrt{5}}{2}, \psi=\frac{1-\sqrt{5}}{2} $$

Base Case

$$ Fib(0)=0, Fib(1)=1 $$

Induction Step

\begin{align} Fib(n-1)+Fib(n-2)&=\frac{(\phi^{n-1}-\psi^{n-1})+(\phi^{n-2}-\psi^{n-2})}{\sqrt{5}}\ &=\frac{(\phi^{n-1}+\phi^{n-2})-(\psi^{n-1}+\psi^{n-2})}{\sqrt{5}}\end{align}

Meanwhile,

\begin{align} \phi+1=\frac{3+\sqrt{5}}{2}=\frac{6+2\sqrt{5}}{4}=(\frac{1+\sqrt{5}}{2})^2=\phi^2\ \psi+1=\frac{3-\sqrt{5}}{2}=\frac{6-2\sqrt{5}}{4}=(\frac{1-\sqrt{5}}{2})^2=\psi^2 \end{align}

Thus,

\begin{align} Fib(n-1)+Fib(n-2)&=\frac{\phi^{n-2}(\phi+1)-\psi^{n-2}(\psi+1)}{\sqrt{5}}\ &=\frac{\phi^n-\psi^n}{\sqrt{5}}=Fib(n) \end{align}

Theorem 2

\begin{align} \frac{\psi^n}{\sqrt{5}} < \frac{1}{2} \end{align}

Proof

\begin{align} \frac{\psi^0}{\sqrt{5}}&\sim0.4472, \frac{\psi^1}{\sqrt{5}}\sim0.2764,…\ \frac{\psi^n}{\sqrt{5}}&<\frac{1}{2} \end{align}

Therefore,

\begin{align} Fib(n) &= \frac{\phi^n-\psi^n}{\sqrt{5}} = \left[\frac{\phi^n-\psi^n}{\sqrt{5}}\right]\ &=\left[\frac{\phi^n}{\sqrt{5}}\right] \end{align}

Q.E.D.

Exercise 1.14. Draw the tree illustrating the process generated by the count-change procedure of section 1.2.2 in making change for 11 cents. What are the orders of growth of the space and number of steps used by this process as the amount to be changed increases?

Answer 1.14.

Let the number of kinds of coins: $k$; Amount of money: $n$; Denominations: $d_1, d_2, …, d_k$.

Orders of growth of the space

The space required is proportional to the maximum depth of the tree. Clearly, this means the maximum height is going to be linear in the amount $n$, or $\theta(n)$.

Number of steps

Basic case

Let see the recursive tree of (cc n 1), which number of steps is defined as $T(n,1)$. Clearly, we can calculate that $T(n,1)=2n+1=\theta(n)$.

Induction step

Next, we look at the recursive tree of (cc n k). We have:

$$ T(n,k)=\lfloor \frac{n}{d_k} \rfloor (T(n,k-1)+1)+2 $$

We can expand it further:

\begin{align} T(n,k)&=\lfloor \frac{n}{d_k} \rfloor (T(n,k-1)+1)+2 \ &=\lfloor \frac{n}{d_k} \rfloor ((\lfloor \frac{n}{d_k} \rfloor T(n,k-2)+1)+2+1)+2 \ &= \lfloor \frac{n}{d_k} \rfloor (… (\lfloor \frac{n}{d_k} \rfloor T(n,1)+1)+2 … +1)+2 \ &= \theta(n^k) \end{align}

Thus, we have $T(n,5) = \theta(n^5)$.

Exercise 1.15. The sine of an angle (specified in radians) can be computed by making use of the approximation $sin x \approx x$ if $x$ is sufficiently small, and the trigonometric identity

$$ \sin x = 3 \sin \frac{x}{3} - 4 \sin^3 \frac{x}{3} $$

to reduce the size of the argument of sin. (For purposes of this exercise an angle is considered “sufficiently small” if its magnitude is not greater than 0.1 radians.) These ideas are incorporated in the following procedures:

(define (cube x) (* x x x))
(define (p x) (- (* 3 x) (* 4 (cube x))))
(define (sine angle)
   (if (not (> (abs angle) 0.1))
       angle
       (p (sine (/ angle 3.0)))))

a. How many times is the procedure p applied when (sine 12.15) is evaluated?

b. What is the order of growth in space and number of steps (as a function of $a$) used by the process generated by the sine procedure when (sine a) is evaluated?

Answer 1.15.

a. $\lceil \log_3 \frac{12.15}{0.1} \rceil = 5$.

b. The order of growth in space and number of steps are $\theta(\log n)$.

Exercise 1.16. Design a procedure that evolves an iterative exponentiation process that uses successive squaring and uses a logarithmic number of steps, as does fast-expt. (Hint: Using the observation that $(b^{n/2})^2 = (b^2)^{n/2}$, keep, along with the exponent $n$ and the base $b$, an additional state variable $a$, and define the state transformation in such a way that the product $ab^n$ is unchanged from state to state. At the beginning of the process $a$ is taken to be $1$, and the answer is given by the value of $a$ at the end of the process. In general, the technique of defining an invariant quantity that remains unchanged from state to state is a powerful way to think about the design of iterative algorithms.)

Answer 1.16.

(define (square x)
    (* x x)
)

(define (expt-iter b n a)
    (cond
        ((= n 0) a)
        ((even? n) (expt-iter (square b) (/ n 2) a))
        (else (expt-iter b (- n 1) (* a b)))
    )
)

(define (fast-expt a n)
    (expt-iter a n 1)
)

Exercise 1.17. The exponentiation algorithms in this section are based on performing exponentiation by means of repeated multiplication. In a similar way, one can perform integer multiplication by means of repeated addition. The following multiplication procedure (in which it is assumed that our language can only add, not multiply) is analogous to the expt procedure:

(define (* a b)
  (if (= b 0)
      0
      (+ a (* a (- b 1)))))

This algorithm takes a number of steps that is linear in b. Now suppose we include, together with addition, operations double, which doubles an integer, and halve, which divides an (even) integer by $2$. Using these, design a multiplication procedure analogous to fast-expt that uses a logarithmic number of steps.

(define (double x)
    (+ x x)
)

(define (halve x)
    (/ x 2)
)

(define (mult-iter a b )
    (cond
        ((= b 0) 0)
        ((even? b) (mult-iter (double a) (halve b)))
        (else (+ a (mult-iter a (- b 1) )))
    )
)

(define (fast-mult a b)
    (mult-iter a b)
)

Exercise 1.18. Using the results of exercises 1.16 and 1.17, devise a procedure that generates an iterative process for multiplying two integers in terms of adding, doubling, and halving and uses a logarithmic number of steps.

Answer 1.18.

(define (double x)
    (+ x x)
)

(define (halve x)
    (/ x 2)
)

(define (fast-mult a b)
    (define (mult-iter a b acc)
        (cond
            ((= b 0) acc)
            ((even? b) (mult-iter (double a) (halve b) acc))
            (else (mult-iter a (- b 1) (+ acc a)))
        )
    )
    (mult-iter a b 0)
)

Exercise 1.19. There is a clever algorithm for computing the Fibonacci numbers in a logarithmic number of steps. Recall the transformation of the state variables $a$ and $b$ in the fib-iter process of section 1.2.2: $a \rightarrow a + b$ and $b \rightarrow a$. Call this transformation $T$, and observe that applying $T$ over and over again $n$ times, starting with $1$ and $0$, produces the pair $Fib(n + 1)$ and $Fib(n)$. In other words, the Fibonacci numbers are produced by applying $T^n$, the $n$th power of the transformation $T$, starting with the pair $(1,0)$. Now consider $T$ to be the special case of $p = 0$ and $q = 1$ in a family of transformations $T_{pq}$, where $T_{pq}$ transforms the pair $(a,b)$ according to $a \leftarrow bq + aq + ap$ and $b \leftarrow bp + aq$. Show that if we apply such a transformation $T_{pq}$ twice, the effect is the same as using a single transformation $T_{p’q’}$ of the same form, and compute $p’$ and $q’$ in terms of $p$ and $q$. This gives us an explicit way to square these transformations, and thus we can compute $T^n$ using successive squaring, as in the fast-expt procedure. Put this all together to complete the following procedure, which runs in a logarithmic number of steps:

(define (fib n)
  (fib-iter 1 0 0 1 n))
(define (fib-iter a b p q count)
  (cond ((= count 0) b)
        ((even? count)
         (fib-iter a
                   b
                   <??>      ; compute p'
                   <??>      ; compute q'
                   (/ count 2)))
        (else (fib-iter (+ (* b q) (* a q) (* a p))
                        (+ (* b p) (* a q))
                        p
                        q
                        (- count 1)))))

Answer 1.19.

Define $a’$ and $b’$ by the definition of the transformation $T_{pq}$:

\begin{align} a’ &= qb + qa + pa = (p + q)a + qb \ b’ &= qa + pb \end{align}

Then, let $a’’$ and $b’’$ be the results of the transformation to $a’$ and $b’$ by applying the transformation once:

\begin{align} a’’ &= (p + q)a’ + qb’ = (p^2 + 2pq + 2q^2)a + (2pq + q^2)b \ b’’ &= qa’ + pb’ = (2pq + q^2)a + (p^2 + q^2)b \end{align}

Thus, we get the transformation to $p$ and $q$:

\begin{align} p’ &= p^2 + q^2 \ q’ &= 2pq + q^2 \end{align}

Exercises in this section of SICP.

Exercise 1.1. Below is a sequence of expressions. What is the result printed by the interpreter in response to each expression? Assume that the sequence is to be evaluated in the order in which it is presented.

10
(+ 5 3 4)
(- 9 1)
(/ 6 2)
(+ (* 2 4) (- 4 6))
(define a 3)
(define b (+ a 1))
(+ a b (* a b))
(= a b)
(if (and (> b a) (< b (* a b)))
    b
    a)
(cond ((= a 4) 6)
      ((= b 4) (+ 6 7 a))
      (else 25))
(+ 2 (if (> b a) b a))
(* (cond ((> a b) a)
         ((< a b) b)
         (else -1))
   (+ a 1))

Answer 1.1.

10
12
8
3
6
a
b
19
#f
4
16
6
16

Exercise 1.2. Translate the following expression into prefix form

$$ \frac{5+4+(2-(3-6 + \frac{4}{5}))}{3(6-2)(2-7)} $$

Answer 1.2.

(/ (+ 5 4 (- 2 (- 3 (+ 6 (/ 4 3))))) (* 3 (- 6 2) (- 2 7)))

Exercise 1.3. Define a procedure that takes three numbers as arguments and returns the sum of the squares of the two larger numbers.

Answer 1.3.

(DEFINE (SOS x y) (+ (* x x) (* y y)))
(DEFINE (F x y z)
	(COND ((AND (<= x y) (<= x z)) (SOS y z))
	      ((AND (<= y x) (<= y z)) (SOS x z))
	      ((AND (<= z x) (<= z y)) (SOS x y))
	)	
)

Exercise 1.4. Observe that our model of evaluation allows for combinations whose operators are compound expressions. Use this observation to describe the behavior of the following procedure:

(define (a-plus-abs-b a b)
  ((if (> b 0) + -) a b))

Answer 1.4.

$$ a+|b| $$

a plus the absolute value of b.

Exercise 1.5. Ben Bitdiddle has invented a test to determine whether the interpreter he is faced with is using applicative-order evaluation or normal-order evaluation. He defines the following two procedures:

(define (p) (p))

(define (test x y)
  (if (= x 0)
      0
      y))

Then he evaluates the expression:

(test 0 (p))

What behavior will Ben observe with an interpreter that uses applicative-order evaluation? What behavior will he observe with an interpreter that uses normal-order evaluation? Explain your answer. (Assume that the evaluation rule for the special form if is the same whether the interpreter is using normal or applicative order: The predicate expression is evaluated first, and the result determines whether to evaluate the consequent or the alternative expression.)

Answer 1.5.

The applicative-order evaluation:

=> (test 0 (p))
=> (test 0 ((p)))
=> (test 0 (((p))))

As we see, the evaluation of (test 0 (p)) is infinitive.

The normal-order evaluation:

=> (test 0 (p))
=> (if (= 0 0) 0 (p))
=> (if #t 0 (p))
=> 0

The expression evaluates to 0.

Exercise 1.6. Alyssa P. Hacker doesn’t see why if needs to be provided as a special form. “Why can’t I just define it as an ordinary procedure in terms of cond?” she asks. Alyssa’s friend Eva Lu Ator claims this can indeed be done, and she defines a new version of if:

(define (new-if predicate then-clause else-clause)
  (cond (predicate then-clause)
        (else else-clause)))

Eva demonstrates the program for Alyssa:

(new-if (= 2 3) 0 5)
5

(new-if (= 1 1) 0 5)
0

Delighted, Alyssa uses new-if to rewrite the square-root program:

(define (sqrt-iter guess x)
  (new-if (good-enough? guess x)
          guess
          (sqrt-iter (improve guess x)
                     x)))

What happens when Alyssa attempts to use this to compute square roots? Explain.

Answer 1.6. I believe this program is incorrect, because new-if uses applicative-order evaluation. Thus, it always expands the else-clause and causes an infinite recursion. In contrast, if uses normal-order evaluation.

Exercise 1.7. The good-enough? test used in computing square roots will not be very effective for finding the square roots of very small numbers. Also, in real computers, arithmetic operations are almost always performed with limited precision. This makes our test inadequate for very large numbers. Explain these statements, with examples showing how the test fails for small and large numbers. An alternative strategy for implementing good-enough? is to watch how guess changes from one iteration to the next and to stop when the change is a very small fraction of the guess. Design a square-root procedure that uses this kind of end test. Does this work better for small and large numbers?

Answer 1.7. The results are very inaccurate when calculating sqrt(0.0001) and sqrt(100000000). We can modify good-enough using current guess and previous guess below:

$$ \frac{|G-G_{pre}|}{G}<0.001 $$

(define (good-enough? guess prev-guess)
  (< (/ (abs (- guess prev-guess))
        guess)
     0.001))

(define (sqrt-iter guess prev-guess x)
  (if (good-enough? guess prev-guess)
    guess
    (sqrt-iter (improve guess x)
               guess
               x)))

(define (sqrt x) 
   (sqrt-iter 1.0 0 x))

Exercise 1.8. Newton’s method for cube roots is based on the fact that if y is an approximation to the cube root of x, then a better approximation is given by the value

$$ \frac{x/y^2+2y}{3} $$

Use this formula to implement a cube-root procedure analogous to the square-root procedure.

Answer 1.8.

(define (cub-iter guess prev-guess x)
  (if (good-enough? guess prev-guess)
    guess
    (cub-iter (improve guess x) guess x)
    )
  )

(define (good-enough? guess prev-guess)
  (< (/ (abs (- guess prev-guess)) guess) 0.001)
  )

(define (improve guess x)
  (/ (+ (/ x (square guess)) (* 2 guess)) 3)
  )

(define (square x)
  (* x x)
  )

(define (cubroot x) 
  ((if (< x 0) - +) (cub-iter (improve 1.0 (abs x)) 1 (abs x)))
  )

Nowadays, NAND flash memory has been widely used as storage medium for embedded systems because of its small size, lightweight, shock resistance, power economic and high reliability. As its capacity increases and its price decreases, flash-memory-based SSDs (abbreviated Solid-state Driver) has also become an alternative of magnetic disk in enterprise computing environment. In addition, flash memory has the characteristics of not-in-place update and asymmetric I/O costs among read, write, and erase operations, in which the cost of write/erase operations is much higher than that of read operation. Hence, the buffer replacement algorithms in flash-based systems should take the asymmetric I/O costs into account. There are several solutions to this issue, such as LRU, CFLRU, APRA and AML. As we LRU policy is a basic cache replacement algorithm and page replacement algorithm. Thus we try to introduce the different variants algorithm of LRU used especially in flash memory.

Instruction

Toshiba company developed flash memory EEPROM (abbreviated electronically erasable programmable read-only memory). There are two types of flash memory, NOR and NAND. The names are two logic gates used in each flash memory because the two types of memory exhibits similar characteristics of the corresponding logic gates. Besides the different design of two type of flash memories, the most important difference between the NOR and NAND flash memory is the bus interface. NOR flash memory is connected to Address/Data bus like cache memory device as SRAM. NAND flash memory uses a multiplexed I/O interface with additional control inputs. NOR flash memory is a random access device appropriate for code storage application, while NAND flash is a sequential access device appropriate for mass storage application. NOR flash memory can be used to store code and execute code, but NAND flash memory can’t store code because code can’t be executed there. It must be loaded into DRAM and executed there. Table 1 describes the main differences between NOR and NAND flash memory.

Table 1. The characteristics of flash memory [1]

In addition, the characteristics of flash memory are significantly different from disks. First, the seek time of disk is very high because of numerous I/O activities. Second, flash memory has asymmetric read and write operation because the performance and energy consumption. Third, flash memory does not support in-place update because the write operation to the same page can’t be finished before the page is erased. Therefore, as the number of write operations is increasing so is the number of erase operations. When we consider the erase operations with write operations, the performance of a flash writing operation costs more than 8 times higher than flash read operation [2].

The operating system of embedded storage of most mobile devices has much more chances to optimize I/O subsystem to use particular features based on the characteristics of flash memory. The operating system can reduce the number of write and erase operations using the kernel-level information, and finally increase the performance. Most operating systems are customized for disk-based system and their replacement algorithms only concern the number of cache hits. But the operating system used for flash memory should consider different read and write cost when they replace pages. In this paper, we propose different replacement algorithms of flash memory, CFLRU, etc., and intend to compare the performance of these different replacement algorithms. LRU Replacement Algorithm

LRU (abbreviated least recently used) has been frequently used for memory replacement algorithm, but this is not to say all the page lists are strictly maintained in LRU order when it used in operating system. In this section we intend to introduce the page replacement policy based on LRU replacement algorithm in Linux kernel. First, Virtual memory uses page cache to back up the data frequently referenced in the disk. When the page cache is full (see Fig. 1), the cache space is shrunk by selecting some less active pages and swapping them out the cache called page reclaiming. Thus we will focus on how the cache decides which pages to reclaim and how to maintain the least recently used pages swapping out of the cache space first.

Figure 1. Virtual Memory and Page Cache List example.

When a page in virtual address is accessed but not exists in physical memory the page faults are triggered. The page faults instruct the Linux kernel to read the missing data from the swap area. After writing back the data to the physical memory, the swap policy determines which pages can be swapped out of the physical memory without hitting the operating system performance. First, The LRU in Linux kernel contains two LRU lists called the active_list and inactive_list in Figure 1. The former list includes the pages that have been accessed recently, while the latter includes the pages that have not been accessed for some time. Apparently, future pages should be store from the inactive list. Second, there are two methods in Linux kernel to help maintain a balance between the active and inactive lists, shrink_active_list() and shrink_inactive_list(). The former is essentially responsible for deciding which page swapped out and which are not, while the latter is responsible for removing inactive pages from the inactive_list and transferring them to shrink_page_list, which then reclaims the selected pages by issuing requests to backing stores to write data back in order to free space physical memory.

In addition, the pages in the LRU lists may be cold or hot regardless either they are in active_list or inactive_list. If a page is hot, it means the page has been recently referenced. The pages in the inactive_list should be moved to the active_list because they are recently used. The pages in the inactive_list thus are always the least recently used pages. The kernel designed two flags to mark the hot/cold state of pages, PG_active and PG_referenced [3]. If the former is set, the page is in active_list, and in inactive_list vice versa. If the latter is set, the page is hot, and cold otherwise. As we known, the page cache is a data structures which contain pages that are backed up. Fault pages or anonymous pages may be cached in this structures. The principle for this cache is to eliminate unnecessary disk reads. Pages read from disk are stored in a page hash table which hashed the address in order to always search the table before the disk is accessed. When caches have been shrunk, pages are moved from active_list to inactive_list. Pages are move from the end of the active_list. If the PG_referenced flag is set, it means the page is still hot and put back at the top of the active_list. This is sometimes called rotating the list in (see Fig. 2). If the PG_referenced flag is cleared, it is moved to inactive_list and set the PG_referenced flag in order to move back to active_list if necessary. After moving pages to inactive_list, the kernel can reclaim the pages in this list. We don’t discuss the page reclaiming in this section because the paper mainly focuses on the page replacement algorithm.

Figure 2. Page Cache LRU Lists in Linux kernel. [4]

This LRU replacement algorithm implements is used in Linux kernel and works smoothly in a large number of machines. But it has some differences with machines using flash memory.

CFLRU Replacement Algorithm

As we mentioned before, flash memory cost more time on write operation than read operation. Thus when operating system reclaims pages we should minimize the number of write operations. There are two types of pages in page cache, dirty page and clean page. A dirty page contains different data from the data in flash memory thus its data must be written back to the memory before dropped. While A clean page contains the same copy of the original data in flash memory thus it can be just dropped from the page cache when it is evicted by the replacement algorithm. For this purpose, Park, Jung, Kang, Kim, & Lee (2006) propose a new replacement algorithm called CFLRU (abbreviated Clean-First LRU) [2]. CFLRU divides the LRU inactive_list into two regions as shown (see Fig. 3). The working region contains the of hot pages recently used, while the clean-first region contains pages which are candidates for reclaiming.

Figure 3. Example of CFLRU Replacement Algorithm.

CFLRU first selects a clean page to reclaim in the clean-first region to reduce the cost of flash write operation. If there is no clean page in this region, a dirty page at the end of the inactive_list is reclaimed. For example, under the LRU replacement algorithm the last page in the inactive_list is reclaimed first. Therefore, the order for victim pages is P8, P7, P6, and P5, in Figure 3. However, under the CFLRU replacement algorithm, it is P7, P5, P8, and P6. The size of the clean-first region is called widow size, w. The cache hit rate may fall dramatically because the window size is too large and the pages can be referenced future only in a small size of working region. If the window size reduces to one, CFLRU replacement algorithm will degenerates to a simple LRU replacement algorithm. Thus, Park et al. devise two methods to deal with this problem, static-CFLRU and dynamic-CFLRU. Under static method, they investigate the proper window size of the clean-first region with static parameters by obtaining an average well-performed value from repetitive experiments. The dynamic method can properly adjust the window size based on the information collected from currently flash memory reading and writing. If the ration of write operation is more than the ratio of read operation, the method can enlarge the window size, and narrow vice versa. With the experiments, the dynamic-CFLRU performs well in contrast to static-CFLRU.

The implement of CFLRU is not difficult based on Linux kernel. As we mentioned before, the original Linux kernel selects the victim page in the inactive_list and swaps out it, but under CFLRU dirty pages are simply skipped and find next victim which is a clean page. If pages in the inactive_list are all dirty, the kernel just swapped out the last pages of the list. For the window size of the clean-first region in CFLRU, we can simply change the priority value of pages in the inactive_list. To adjust the widow size properly, the priority values of pages can be changed dynamically. Park et al. devise a kernel deamon periodically checks the read and write cost and compare with last replacement cost to decide whether to increase or reduce the priority values. The difference between the current cost and last cost must exceed a predefined threshold in order to avoid oscillation of the priority values.

Adaptive Page Replacement Algorithm

Shen, Jin, Song, & Lee (2006) propose the APRA (abbreviated Adaptive Page Replacement Algorithm), because Shen et al. find that the read hit ratio of CFLRU is extremely low under certain workloads involving mainly read requests and its predefined window size contributes to the performance only for certain applications [5]. To deal with these shortcomings, the APRA maintains two cache lists of length L, LRU list and ghost list (see Fig. 4). The first list maintains a window to search clean pages just like CFLRU. However, the size of window can vary from W_min to W_max while static-CFLRU has fixed window size. Different from dynamic-CFLRU, the size of window in APRA can indicate the extent to which the clean pages are evicted from the buffer. The second list is called ghost list because it doesn’t contain the content of pages and just have the metadata of the pages which have been swapped out of the LRU list. In another word, the ghost list consists of the referenced history of pages which have been existed in LRU list. Although dirty pages evicted from LRU list have been already written back to the flash memory, we still mark these pages as dirty pages in ghost list to indicate the write operations.

Figure 4. Example of APRA page replacement.

APRA can always modify the size of window w based on the information of the current workload since an appropriate value of w will dramatically increase the hit ratio. The algorithm indents to increase or decrease the window size in LRU list depending on whether the state of pages in ghost list is dirty or clean, because the hit information can be observed in ghost list. Therefore, if a hit happened on a dirty page in ghost list, we enlarger w, and a hit happened on a clean page in ghost list, we narrow w. The extent of w changing is also very important. Hence Shen et al. devise two parameters p and q to control the changing extent of revision, where p = L/w and q = 1/(1-w/L) control the revision rates depending on w. Thus, the smaller the w is, the larger the increment p will be. Similarly, the larger the w is, the larger the decrement q will be. Suppose a large of number requests mainly involving write operations from file system, APRA will increase the size of window to evict more clean pages in the LRU list. Likewise, when a large of number request mainly involving read operations, APRA will decrease the size of widow to achieve a high read hit performance.

AML Replacement Algorithm

Zhu, Dai, & Yang (2010) propose an improved LRU replacement algorithm called AML (abbreviated Adaptively Mixed List) algorithm, because Zhu et al. investigate that the evicting method of cold clean pages is inefficient. According to the page replacement policy, pages have to be evicted in the order of cold clean pages, hot clean pages, cold dirty pages, and hot dirty pages. Thus, AML replacement algorithm prefers to evict cold clean pages first and never chooses hot dirty pages as victims. In CFLRU algorithm, the clean pages are evicted regardless of cold or hot. However, the hot pages will be more likely to be referenced in the future than the cold pages. The cold pages thus must be evicted first to improve the hit ratio of page replacement in flash memory. To achieve the ideal results, AML maintains three LRU lists (see Fig. 5). The first list, LRU list, is just like CFLRU and APRA list with variable-size window. Cold clean list organizes all cold clean pages in the order of LRU list, and ghost list saves the metadata of swapped pages just like the ghost list in APRA, where it also doesn’t include any content of pages.

Figure 5. AML replacement algorithm example.

The AML algorithm improves CFLRU and APRA by maintaining a clean cold list, which can achieve the result that the clean cold pages can be first evicted. Zhu et al. devise a procedure to maintain the clean cold list which called cold-detection (see Fig. 6). In cold-detection, COOLMAX is an integer which is used to show the pages are the coldest. When the cold flag of a page reduces to zero, it shows that the page is hottest. For example, when COOLMAX is equal to 7, hot and cold can be divided into many levels from the coldest to the hottest (first hottest is 0, second hottest is 1, …, second coldest is 6, first coldest is 7). In addition, we can define which level is the boundary between cold and hot. When a page in AML lists is referenced, the procedure can move the cold clean pages to the clean cold list. If the referenced page is in the ghost list and it is a cold page (like P12 in fig. 5), moving it to the clean cold list and setting its cold flag as COOLMAX; If the referenced page is in the ghost list and it is a hot page (like P13 in fig. 5), moving it to the LRU list and its cold flag will be cleared to zero showing that it is a hot page; If the referenced page is in the cold clean list (like P9 in fig. 6), moving it to the LRU list and clearing its cold flag.

Figure 6. Cold-detection example.

The eviction of AML algorithm is just like CFLRU algorithm but AML first concerns the pages in cold clean list. If the list is not empty, evicting the pages in the list. If the list is empty, evicting the pages in LRU list just like LRU list in CFLRU. When pages in LRU list are evicted, the ghost list adds pages contains the metadata of them, such as information of hot/cold and clean/dirty. Besides, the variable size of window in LRU list is just like APRA replacement algorithm, which changes the size that depends on the information in ghost list also maintained by AML algorithm.

Performance Evaluation

Zhu et al. perform a complete experiment includes LRU, CFLRU, APRA, AML and LRUWSR (which is a simple improve version of CFLRU). In the experiment, they use six kinds of workloads contain all the access pattern in Table 2. The total references are 1,000,000. The locality expression 80/20 means 80% of the total number of accesses operation are performed in 20% of the flash memory area. The write/read ration of 90/10 means that the write and read operations are 90% and 10% respectively.

Table. 2 The types of traces.

Figure 7 shows the hit ratios of the five replacement algorithms. The hit ratio of AML is almost equal to LRU. It is higher than other algorithms in most cases (see Fig. 6). Because AML prefers to evict the cold clean page first, and it delays eviction of hot page to keep high hit ratio. When the locality of data access is 50/50, the hit ratio of AML is pretty same as other three replacement algorithms. When locality is good and I/O access is write-dominant as 90/10, the hit ratio of AML is pretty same as that of APRA. On this condition, the major evicted pages are dirty pages, and clean pages are very few. Thus, the faster cold dirty pages are evicted, the higher is hit ratio.

Figure 7. Hit ratio of different traces

Figure 8 shows the number of pages written into flash memory. They got these results by counting the number of physical flush operations, and adding the number of dirty pages remaining in the buffer. They have known that a good algorithm not only keeps high hit ratio but also decreases the write counts effectively to reduce the replacement cost. AML is basically done both for various traces. When write/read ratio is smaller, the write count of AML is much less than other algorithms including APRA. It reduces the write count on average by 15% compared to APRA and by 10% compared to CFLRU. For write-most access pattern, the write count of AML is smaller than that of other algorithms. However, it is nearly equal to that of APRA.

Figure 8. Write counts of various traces

Figure 9 shows the overall runtime of various replacement algorithms. Except LRU list AML maintain an additional ghost list. The space overhead of keeping ghost list is very small as the paper mentioned before. They only focus on the time overhead of these algorithm. Runtime is estimated as the sum of read, write latency and the time of erase operations. Runtime therefore reflects overall performance. The runtime is determined by hit ratio and write count. It is the standard to judge whether this algorithm is effective enough. The runtime of AML is reduced at most by 18% compared to APRA. Even if CFLRU has a good performance in the read-most applications, AML reduces the runtime on average by 14% compared to CFLRU.

Figure 9. Runtime for various traces.

Conclusion

In the LRU-based replacement algorithms of flash memory, we introduce the main LRU algorithm which is widely used in Linux kernel and many other operating systems. Then we mainly investigate three algorithm aiming to improve the traditional LRU replacement algorithm as we called LRU-based replacement algorithms. The first algorithm is CFLRU replacement algorithm. It changes the order of evicting pages in LRU within selecting clean pages first. The method can reduce the cost of write operations. The second algorithm is APRA, which adds ghost list to dynamically change the size of window in CFLRU algorithm. Because the performance of CFLRU may decrease dramatically when the I/O access is read-dominant. The last algorithm is AML replacement algorithm which adds a cold clean list to APRA. The cold clean pages can be evicted first within the cold-detection method, and this algorithm performs better than three other algorithms in different condition in flash memory.

Reference

[1] Memory Technology Device (MTD) Subsystem for Linux, http://www.linux-mtd.infradead.org/doc/nand.html/.

[2] Park, S. Y., Jung, D., Kang, J. U., Kim, J. S., & Lee, J. (2006, October). CFLRU: a replacement algorithm for flash memory. In Proceedings of the 2006 international conference on Compilers, architecture and synthesis for embedded systems (pp. 234-241). ACM.

[3] Bovet, D. P., & Cesati, M. (2005). Page Frame Reclaiming, Understanding the Linux Kernel, Third Edition (pp. 676-737). O’Reilly Media, Inc.

[4] Page Frame Reclamation, https://www.kernel.org/doc/gorman/html/understand/understand013.html.

[5] Shen, B., Jin, X., Song, Y. H., & Lee, S. S. (2009). APRA: adaptive page replacement algorithm for NAND flash memory storages. In Computer Science-Technology and Applications, 2009. IFCSTA’09. International Forum on (Vol. 1, pp. 11-14). IEEE.

[6] Zhu, H., Dai, H., & Yan, Y. (2010, December). AML: a novel page replacement algorithm for Solid State Disks. In Computational Intelligence and Software Engineering (CiSE), 2010 International Conference on (pp. 1-6). IEEE.

Last time we find that in the DefaultListableBeanFactory it provides map to save bean definitions. But when getting bean instance, we need to step into DefaultSingletonBeanRegistry. First let’s see the document:

Generic registry for shared bean instances, implementing the SingletonBeanRegistry. Allows for registering singleton instances that should be shared for all callers of the registry, to be obtained via bean name.

Also supports registration of DisposableBean instances, (which might or might not correspond to registered singletons), to be destroyed on shutdown of the registry. Dependencies between beans can be registered to enforce an appropriate shutdown order.

This class mainly serves as base class for BeanFactory implementations, factoring out the common management of singleton bean instances. Note that the ConfigurableBeanFactory interface extends the SingletonBeanRegistry interface.

Note that this class assumes neither a bean definition concept nor a specific creation process for bean instances, in contrast to AbstractBeanFactory and DefaultListableBeanFactory (which inherit from it). Can alternatively also be used as a nested helper to delegate to.

In the class, it has private variable to cache the bean instance:

/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

AbstractBeanFactory

Again AbstractBeanFactory is very important BeanFactory implementation to get beans, and it is also a SingletonBeanRegistry interface implementation to save beans.

protected <T> T doGetBean(String name,
                          Class<T> requiredType,
                          Object[] args,
                          boolean typeCheckOnly)

When ApplicationContext calls doGetBean(...), it will call getSingleton(...) which is declared in SingletonBeanRegistry interface and implements in DefaultSingletonBeanRegistry.

Return the (raw) singleton object registered under the given name. Only checks already instantiated singletons; does not return an Object for singleton bean definitions which have not been instantiated yet.

The main purpose of this method is to access manually registered singletons (see registerSingleton(java.lang.String, java.lang.Object)). Can also be used to access a singleton defined by a bean definition that already been created, in a raw fashion.

NOTE: This lookup method is not aware of FactoryBean prefixes or aliases. You need to resolve the canonical bean name first before obtaining the singleton instance.

In this method, if the bean exists in concurrent map singletonObjects<String, Object> of DefaultSingletonBeanRegistry, it will call getSingleton(...) and return the bean object; Else the bean isn’t defined, the method will also call getSingleton(...), if the singleton bean is null then it will generate the object of bean.

Create Object of Bean

How does spring create object from bean definition file? In AbstractBeanFactory, it provide an abstract bean creation method:

protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
			throws BeanCreationException;

Also see the document:

Create a bean instance for the given merged bean definition (and arguments). The bean definition will already have been merged with the parent definition in case of a child definition.

All bean retrieval methods delegate to this method for actual bean creation.

This method is implemented in AbstractAutowireCapableBeanFactory:

Abstract bean factory superclass that implements default bean creation, with the full capabilities specified by the RootBeanDefinition class. Implements the AutowireCapableBeanFactory interface in addition to AbstractBeanFactory’s createBean(java.lang.Class<T>) method.

Provides bean creation (with constructor resolution), property population, wiring (including autowiring), and initialization. Handles runtime bean references, resolves managed collections, calls initialization methods, etc. Supports autowiring constructors, properties by name, and properties by type.

The main template method to be implemented by subclasses is AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor, String, Set, TypeConverter), used for autowiring by type. In case of a factory which is capable of searching its bean definitions, matching beans will typically be implemented through such a search. For other factory styles, simplified matching algorithms can be implemented.

Note that this class does not assume or implement bean definition registry capabilities. See DefaultListableBeanFactory for an implementation of the ListableBeanFactory and BeanDefinitionRegistry interfaces, which represent the API and SPI view of such a factory, respectively.

Now we just move to createBean(...) method and its main method is doCreateBean(...):

Actually create the specified bean. Pre-creation processing has already happened at this point, e.g. checking postProcessBeforeInstantiation callbacks.

Differentiates between default bean instantiation, use of a factory method, and autowiring a constructor.

So we can know from the document that the method just create the specified bean which means it should get class reference in the definition file.

In this method, we find BeanWrapper class which is the central interface of Spring’s low-level JavaBeans infrastructure. The wrapper is initialized with createBeanInstance(...) method which can create a new instance for the specified bean, using an appropriate instantiation strategy: factory method, constructor autowiring, or simple instantiation. Then it call the core instantiation method instantiateBean(...) and it will step into InstantiationStrategy interface.

InstantiationStrategy

Interface responsible for creating instances corresponding to a root bean definition.

This is pulled out into a strategy as various approaches are possible, including using CGLIB to create subclasses on the fly to support Method Injection.

Here we just talk about its SimpleInstantiationStrategy implement class. it has instantiate(...) which can return an instance of the bean with the given name in this factory. First it get the Class<?> clazz of the bean, and call clazz.getDeclaredConstructor(...) to get the Constructor<?> of the bean, then step into BeanUtils class and call instantiateClass(...) method which can call constructor.newInstance(args) and return a new object created by calling the constructor this object represents.

Finally, the object will be saved in the singletonObjects<String, Object> for getBean(...) method to get the object.

What’s Next?

After reading the source code of Spring’s IoC, I find some TODO list.

• ThreadLocal<?>, ConcurrentMap<K, V> and volatile are often appeared in the source, so I need to deal with something about Java Threads;
• Spring Reference is very useful document to read thus I need to focus more with it.

When using Spring framework, we must use Apache Common Logging to print log in console or binary files. As we known, Spring log configuration can change in the web.xml when it works on server. But in these series of articles, we try to analyze the Spring core techniques without works on server. So there should have another way to configure log without web.xml because we want to see the debug informations.

Spring gives Log4jConfigurer.initLogging() method (has been deprecated in Spring 4.2.1) to initialize log4j from the given file location. Note that we always use Maven to build project, but maven might mash src and resources folders to one. Thus we should use classpath: ,without slash, to represent resources folder in the project.

Now Apache Commons Logging (JCL) provides thin-wrapper Log implementations for other logging tools, including Log4J. But Log4jConfigurer.initLogging() calls methods from log4j 1.x. It means that we should add log4j 1.x dependency to make sure that our log configuration file works smoothly.

Here is the configure file log4j.properties, and just opening debug function in org.springframework.beans because we want to know the IOC process:

log4j.rootCategory=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c:%L - %m%n

log4j.category.org.springframework.beans=DEBUG

As last article, we run the same code but add our log configuration before:

Log4jConfigurer.initLogging("classpath:log4j.properties");
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml");
PetStoreServiceImpl petStoreService = context.getBean("petStore", PetStoreServiceImpl.class);

Now we can follow the log information to know the IOC clearly.

ClassPathXmlApplicationContext

17:23:15,265  INFO main ClassPathXmlApplicationContext org.springframework.context.support.AbstractApplicationContext.prepareRefresh:581 - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@42dafa95: startup date [Fri Oct 21 17:23:15 EDT 2016]; root of context hierarchy

First we step into ClassPathXmlApplicationContext constructor and it calls refresh(). This method is declared in the interface ConfigurableApplicationContext, implements in AbstractApplicationContext, finally called in ClassPathXmlApplicationContext which is a subclass of AbstractApplicationContext.

This method can load or refresh the persistent representation of the configuration, which might an XML file, properties file, or relational database schema. As this is a startup method, it should destroy already created singletons if it fails, to avoid dangling resources. In other words, after invocation of that method, either all or no singletons at all should be instantiated.

As we see in the document, refresh() is used to load and refresh persistent representation configuration. It should be done first of all.

XmlBeanDefinitionReader

17:23:15,555  INFO main XmlBeanDefinitionReader org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions:317 - Loading XML bean definitions from class path resource [services.xml]

The refresh() method calls obtainFreshBeanFactory() in which can tell the subclass to refresh the internal bean factory. So how to let a class to call the method (in this case it is refreshBeanFactory()) in its subclass? It is a very classical design pattern.

First, the AbstractApplicationContext declares:

protected abstract void refreshBeanFactory()

This method is implemented in AbstractRefreshableApplicationContext which is a subclass of AbstractApplicationContext:

@Override
protected final void refreshBeanFactory()

Therefore the father class can call the method which implemented in its subclass.

Here is XmlBeanDefinitionReader:

Bean definition reader for XML bean definitions. Delegates the actual XML document reading to an implementation of the BeanDefinitionDocumentReader interface. Typically applied to a DefaultListableBeanFactory or a GenericApplicationContext.

This class loads a DOM document and applies the BeanDefinitionDocumentReader to it.

The document reader will register each bean definition with the given bean factory, talking to the latter’s implementation of the BeanDefinitionRegistry interface.

loadBeanDefinition() method is used to load bean definitions from the specified XML file.

DefaultDocumentLoader

XmlBeanDefinitionReader calls doLoadDocument() and it has local variable DocumentLoader documentLoader which calls loadDocument().

19:38:23,603 DEBUG main DefaultDocumentLoader org.springframework.beans.factory.xml.DefaultDocumentLoader.loadDocument:73 - Using JAXP provider [com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl]

Here is DefaultDocumentLoader:

Spring’s default {@link DocumentLoader} implementation. Simply loads Document documents using the standard JAXP-configured XML parser. If you want to change the DocumentBuilder that is used to load documents, then one strategy is to define a corresponding Java system property when starting your JVM. For example, to use the Oracle DocumentBuilder, might start your application like as follows:

java -Djavax.xml.parsers.DocumentBuilderFactory=oracle.xml.jaxp.JXDocumentBuilderFactory MyMainClass

DefaultBeanDefinitionDocumentReader

Here is DefaultBeanDefinitionDocumentReader which is used to read bean definitions:

Default implementation of the BeanDefinitionDocumentReader interface that reads bean definitions according to the “spring-beans” DTD and XSD format (Spring’s default XML bean definition format).

The structure, elements, and attribute names of the required XML document are hard-coded in this class. (Of course a transform could be run if necessary to produce this format). <beans> does not need to be the root element of the XML document: this class will parse all bean definition elements in the XML file, regardless of the actual root element.

And registerBeanDefinitions(doc, readerContext):

Read bean definitions from the given DOM document and register them with the registry in the given reader context.

doc the DOM document readerContext the current context of the reader (includes the target registry and the resource being parsed)

DefaultListableBeanFactory

Default implementation of the ListableBeanFactory and BeanDefinitionRegistry interfaces: a full-fledged bean factory based on bean definition objects. Typical usage is registering all bean definitions first (possibly read from a bean definition file), before accessing beans. Bean definition lookup is therefore an inexpensive operation in a local bean definition table, operating on pre-built bean definition metadata objects.

Can be used as a standalone bean factory, or as a superclass for custom bean factories. Note that readers for specific bean definition formats are typically implemented separately rather than as bean factory subclasses: see for example PropertiesBeanDefinitionReader and XmlBeanDefinitionReader.

For an alternative implementation of the ListableBeanFactory interface, have a look at StaticListableBeanFactory, which manages existing bean instances rather than creating new ones based on bean definitions.

It implements the bean register method registerBeanDefinition() which is declared in interface BeanDefinitionRegistry.

Register a new bean definition with this registry. Must support RootBeanDefinition and ChildBeanDefinition.

Now we look at DefaultListableBeanFactory and find that it has some private variables.

/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);

/** List of bean definition names, in registration order */
private volatile List<String> beanDefinitionNames = new ArrayList<String>(256);

Note that beanDefinitionMap is a java.util.concurrent.ConcurrentHashMap and beanDefinitionNames is a volatile variable.

this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);

TODO: java.util.concurrent.ConcurrentHashMap and volatile variable.