The following is the example of C:

int main(void){
    int hoge[] = {0,1,2,3};
    printf("%d", hoge[3]); // output: 3
    printf("%d", hoge[4]); // get a warning
    return 0;
}

We can implement this kind of exception in Scheme by using the procedure length which is introduced in SICP 2.2.1.

The code will be as follows:

; returns the length of a list
(define (length li)
  (define (length-iter n iter-li)
    (if (null? iter-li)
      n
      (length-iter (+ n 1) (cdr iter-li))))
  (length-iter 0 li))

; check if the value passed to the list is valid
(define (cdr-chk-err li n)
  (cond ((or (> n (length li)) (= n (length li)))
    (error "Invalid value passed to the list. "))))

(define (list-ref n)
  (lambda (x)
    (cdr-chk-err x n)
    (if (= n 0)
      (car x)
      ((list-ref (- n 1)) (cdr x)))))

This works correctly.

(define l1 (list 1 2 3 4))
((list-ref 3) l1) ; returns 4
((list-ref 4) l1) ; error!

The post [Scheme] Checking The Validity of The Number Passed to The List appeared first on Nisei Kimura's Blog.

To examine this, let’s define a function calculating some complex value.

 

(define (g n)
  (define (g-iter result i)
    (if (= i n)
      result
      (g-iter (+ (/ (/ (/ 312423 125531) (/ 2052712 7231400)) (/ 13222 113131)) result) (+ i 1)
  )))
  (g-iter 1 1)
)

The result of the operation is returned as a fraction:
(19358134129159 * 750189) * 5180721713949/19358134129159

Each term is absolutely determined value.
For getting the decimal number from this fraction value, we just need to multiply this by 1.0.

(* 1.0 (g 10000)) ; 750189.2676250552

If we use the decimal number in the calculation, the different result will show up:

(define (g n)
  (define (g-iter result i)
    (if (= i n)
      result
      (g-iter (+ (/ (/ (/ 312423.0 125531) (/ 2052712 7231400)) (/ 13222 113131)) result) (+ i 1)
  )))
  (g-iter 0 0)
)

(g 10000) ; 750189.2676250958

Then which number is more near the actual value?
Let’s calculate ((((312423 / 125531) / (2052712 / 7231400)) / (13222 / 113131)) * 10000) in the Wolframalpha.
Calc result

750189.2676250551516388667249372079289168657014682584005287499...

It seems that the former one is more accurate.

However, the fraction-version calculation will lose its speed when the number of calculation grows up. If we try to execute function g 10000000 times, the response of the fraction-version one is cruel in contrast to the decimal-version one which outputs the result within 0.5s.

The post [SICP 2.1.4] Some Observation about Exercise 2.16 appeared first on Nisei Kimura's Blog.

The default mul-interval executes 4 multiplications on every case of operations, because the process calculates p1 to p4 regardless of the signs of the endpoints.
So, the objective of this problem is to minimize the number of operations.

(define (mul-interval x y)
  (let
    ((mi make-interval)
     (lx (lower-bound x))
     (ux (upper-bound x))
     (ly (lower-bound y))
     (uy (upper-bound y)))
  (cond
    ((and (neg-int? x) (neg-int? y))
      (mi (* lx ly) (* ux uy)))
    ((and (neg-int? x) (zero-span? y))
      (mi (* lx uy) (* lx ly)))
    ((and (neg-int? x) (pos-int? y))
      (mi (* ux uy) (* lx ly)))
    ((and (zero-span? x) (neg-int? y))
      (mi (* ux uy) (* lx uy)))
    ((and (zero-span? x) (pos-int? y))
      (mi (* lx uy) (* ux uy)))
    ((and (pos-int? x) (neg-int? y))
      (mi (* ux uy) (* lx ly)))
    ((and (pos-int? x) (zero-span? y))
      (mi (* ux ly) (* ux uy)))
    ((and (pos-int? x) (pos-int? y))
      (mi (* lx ly) (* ux uy)))
    ((and (zero-span? x) (zero-span? y))
      (mi (min (* lx uy) (* ux ly)) (max (* lx ly) (* ux uy)))))))

(define i1 (make-interval -5 3))
(define i2 (make-interval -2 110))
(mul-interval i1 i2) ; (-550, 330)

Note that there will be no point to rewrite the procedure if you write the multiplication as the variable defined in the `let`, because variables we define in `let` are all executed whether or not we use them. In this case, if you write as follows, 4 multiplications are executed in mul-interval every time:

(define (mul-interval x y)
  (let
    ((mi make-interval)
     (lxly (* (lower-bound x) (lower-bound y)))
     (lxuy (* (lower-bound x) (upper-bound y)))
     (uxly (* (upper-bound x) (lower-bound y)))
     (uxuy (* (upper-bound x) (upper-bound y))))
  :
  :
  :

If you want to confirm this kind of behavior of `let`, try defining (zero-div (/ 1 0)) as an variable of `let`, and you’ll soon get zero-division error even if you aren’t using variable zero-div in the process.

The post [SICP 2.1.4] Exercise 2.11 Memo appeared first on Nisei Kimura's Blog.

There were many blog posts which talks about Exercise 2.10, and I’ve found that there were 2 ways of understanding of the problem on the internet.

• The problem literally tells us to implement an error that occurs when we pass two arguments that spans zero (like -5 and 3).
• The problem tells us to implement errors by zero division.

So, which one is correct? After a straightforward survey, I’ve found that the answer seems to be the former one.

Then why people feel confused to understand the meaning of the problem?

At a first glance, not a few people might have thought that “OK, this is an problem that related to the procedure div-interval, right?”, then tried to pass arguments for div-interval like this:

(define i1 (make-interval 5 5))
(define i2 (make-interval -5 5))
(div-interval i1 i2) ; (-1.0 . 1.0)

The output seems to work correct ( in fact it does, because the procedure mul-interval properly extracts the result from p1 ~ p4, using the procedures min & mul ). Now we don’t know what the actual problem is.

The answer is simple. What we really had to check was not the procedure div-interval but the following process:

(make-interval (/ 1.0 (upper-bound x)) (/ 1.0 (lower-bound x)))

Let’s check the behavior of this process.

(define i (make-interval -5 5))
  (make-interval (/ 1.0 (upper-bound i)) (/ 1.0 (lower-bound i))) ; (0.2, -0.2)

The output is (0.2, -0.2), and now we know what we have to do is:

(define (reciprocal-interval x)
(if (< (* (upper-bound x) (lower-bound x)) 0) (error "The arguments spans 0") (make-interval (/ 1.0 (upper-bound x)) (/ 1.0 (lower-bound x))))) [/shell] I think this is the true understanding of the exercise 2.10. As long as we use the reciprocal-value for only the procedure div-interval, it works well, so we don't need to implement the error function. However, say we want to implement another procedure using the reciprocal interval --- the tragedy occurs. So we have to test the black-box thoroughly even if one of abstract procedures that using the black-box seems to work fine. They can sometimes hide the flaw of the implementation and make problem difficult, like this exercise.

The post [SICP 2.1.4] Some Observation about Exercise 2.10 appeared first on Nisei Kimura's Blog.

So far, we’ve seen an implementation of these procedures using lambda expression. By the way, it seems that we can implement them with only numbers and some arithmetic operations according to the problem, so let’s create that version of the procedures.

First of all, We need a procedure that tells us the power of 2 and 3 from a value.

(define (find-times-of-n n x)
  (define (iter dev-x result)
    (let ((r (remainder dev-x n)))
      (if (= r 0) (iter (/ dev-x n) (+ result 1))
                  result)))
  (iter x 0))

What we have to do for getting the power of n( in this case, 2 or 3 would be passed ) from value x is only devide n from x until the remainder of the value / n is non-zero.

Next, we’ll create procedure cons. This is easy because we only need to create a procedure that takes two arguments ( a and b ), and returns 2^a3^b. The procedure will be as follows:

(define (pow x n)
  (define (iter i result)
    (if (= i n) result (iter (+ i 1) (* result x))))
  (iter 0 1))

(define (cons x y) (* (pow 2 x) (pow 3 y)))

Finally, we’ll create procedure car and cdr. Let’s use the procedure find-times-of-n:

(define (car cons) (find-times-of-n 2 cons))
(define (cdr cons) (find-times-of-n 3 cons))

If we want to get the output, you can implement the procedure like this:

(define (print-cons cons)
  (newline)
  (display "(")
  (display (car cons))
  (display ",")
  (display (cdr cons))
  (display ")"))

(define hoge (cons 61 22))
(print-cons hoge) ; (61, 22)

The post [SICP 2.1.3] Exercise 2.5 Memo appeared first on Nisei Kimura's Blog.

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

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

(newtons-method (cubic 3 2 5) 1) ; -2.9041608591349113

You can see answer of x^3+2x^2+5x+1 = 0 in the following link.
http://www.wolframalpha.com/input/?i=x%5E3%2B3x%5E2%2B2x%2B5%3D0&dataset=

Excercise 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)

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

((double square) 5) ; 625

Notice that the answer is 625, not 125 because we apply square for the square of 5(= 25).

Exercise 1.42. Let f and g be two one-argument functions. The composition f after g is defined to be the function x 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

(define (composition f g)
(lambda (x) (f (g x))))

((compose square inc) 6) ; 49

Excercise 1.43 – If f is a numerical function and n is a positive integer, then we can form the nth 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 x + 1, then the nth repeated application of f is the function x x + n. If f is the operation of squaring a number, then the nth repeated application of f is the function that raises its argument to the 2nth 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 nth repeated application of f. Your procedure should be able to be used as follows:
((repeated square 2) 5) ;625

We pass the default value of iteration and procedure itself in repeated-iter.
The result will be executed at last.

(define (repeated f n)
(define (repeated-iter i result)
(if (= i n)
(lambda (x) (result x))
(repeated-iter (+ i 1) (double result))))
(repeated-iter 1 f))

((repeated square 2) 5) ; 625

Excercise 1.44 – 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.

Notice that in exercise 1.43, we passed the number 5 to the square procedure as an argument, but this time we’re passing a procedure to it. At the first time, we feel confused for the diversity of the expression. however you can get the picture of this by imagining that we’re passing an “argument” for the procedure.

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

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

((n-fold-smooth 5 cube) 3) ; apply smooth procedure 5 times

Excercise 1.45 – Do some experiments to determine how many average damps are required to compute nth roots as a fixed-point search based upon repeated average damping of y |-> x / y^n-1.

First we create a procedure so that we can do the experiment with some small values.

(define (n-times-average-damp n)
(repeated average-damp n))

(define (n-sqrt x)
(fixed-point-of-transform (lambda (y) (/ x (* y y ... )))
(n-times-average-damp ... ))
1.0))

You see the factorial of y in the function. This means “n-1″ in the expression.
That is, You can get x^n when the (n-1)th power is excecuted.

Finally we get following result of the experiment.

(power) (required number of average-damp execution)
y^1 = 1 time
y^2 = 1 time
y^3 = 2 times
:
:
y^8 = 3 times
:
:
y^16 = 4 times

So the number of required execution of average-damp will be log_2(n).

Use this to implement a simple procedure for computing nth roots using fixed-point, average-damp, and the repeated procedure of exercie 1.43. Assume that any arithmetic operations you need are available as primitives.

Because the number should be an integer, we’re using a primitive procedure floor.

(define (log_2 x) (/ (log x) (log 2)))

(define (n-sqrt x n)
(fixed-point-of-transform
(lambda (y) (/ x ((repeated (lambda (x) (* x y)) (- n 1)) 1)))
(n-times-average-damp (floor (log_2 n)))
1.0))

Excercise 1.46 – 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.

(define (iterative-improve enough? improve)
(lambda (guess)
(define (iter guess)
(let ((next (improve guess)))
(if (enough? next guess)
next
(iter next))))
(iter guess)))

Rewrite the sqrt procedure of section 1.1.7 and the fixed-point procedure of section 1.3.3 in terms of iterative-improve.

The sqrt procedure will be as follows:

(define (sqrt x)
(define (close-enough? v1 v2)
(< (abs (- v1 v2)) 0.0000001))
(iterative-improve
close-enough?
(lambda (y) (average y (/ x y)))))

((sqrt 3) 1.0); 1.7320508075688772

And the fixed-point procedure will be as follows:

(define (fixed-point-improved f)
(define (close-enough? v1 v2)
(< (abs (- v1 v2)) 0.0000001))
(iterative-improve
close-enough?
(lambda (x) (average x (f x)))))

If you think that you want to use fixed-point-improved procedure in the sqrt procedure, the code will be like this:

(define (sqrt x)
(fixed-point-improved (lambda (y) (/ x y))))

((sqrt 3) 1.0) ; 1.7320508075688772

“1.0″ is the number for first guess. Although you can create this in the procedure, it would be efficient sometimes, like when you need to guess numbers with some logarithm ( in this time, we might pass 2.0 instead of 1.0 because log(1) = 0 ).

The post [SICP 1.3.4] Exercise 1.40-1.46 Memo appeared first on Nisei Kimura's Blog.

Linear recursive version:

(define (cont-frac n d k)
  (define (cont-frac-iter i)
    (if (= i k)
      (/ (n i) (d i))
      (/ (n i) (+ (d i) (cont-frac-iter (+ i 1.0)))))
  )
  (cont-frac-iter 1)
)

Then how can we check if the number of k is enough for the calculation in the accuracy of 0.0001? We may be able to check it manually, but creating a checking function seems to be better for me.

(define (check-accuracy)
  (define (iter k)
    (if (< (abs (- (calc-ratio k) (/ 1 1.6180339887)) ) 0.0001)
      k
      (iter (+ k 1))
    )
  )
  (iter 1)
)

And we get 10 iterations to get the accuracy in 0.0001.

In this case, the function passes calc-ratio method without using arguments. You can build an abstraction for checking arbitrary accuracy of arbitrary function if you prefer.

(define (check-accuracy accuracy f target)
  (define (iter k)
    (if (< (abs (- (f k) target) ) accuracy)
      k
      (iter (+ k 1))
    )
  )
  (iter 1)
)

Exercise 1.37(b) Write linear-iterative version of cont-frac function ( if you’ve created the linear-iterative one in the Exercise 1.37(a), then create linear-recursive version )

The linear-recursive version processes the calculation from 1 to n, but we need to change this process from n to 1 for creating the linear-iterative one, because if we try to start from 1 and make it increment the number, the requirement of the result of (i + 1)th process occurs to determine the result of i-th process. Then the function will be as follows:

(define (cont-frac-linear-iterative n d k)
  (define (cont-frac-iter numerator i)
    (cond ((= i 1) numerator)
      ((= i k) (cont-frac-iter (/ (n (- i 1.0)) (+ (/ (n i) (d i)) (d (- i 1.0)))) (- i 1.0)))
      (else (cont-frac-iter (/ (n (- i 1.0)) (+ numerator (d (- i 1.0)))) (- i 1.0)))
    )
  )
  (cont-frac-iter 0 k)
)

Let’s check two versions of cont-frac function.

(define (calc-ratio k) (cont-frac (lambda (x) 1.0) (lambda (x) 1.0) k))
(define (calc-ratio2 k) (cont-frac-linear-iterative (lambda (x) 1.0) (lambda (x) 1.0) k))

(calc-ratio 100) ; 0.6180339887498948
(calc-ratio2 100) ; 0.6180339887498948

(calc-ratio 10000000) ; used up the memory
(calc-ratio2 10000000) ; 0.6180339887498948

Exercise 1.38 – define the natual logarithm e.

We finally get the expression of the 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, … as follows:

(define (e)
  (+ 2 (cont-frac-linear-iterative
    (lambda (a) 1.0)
    (lambda (a) (if (< (remainder a 3) 2) 1.0 (* (/ 2.0 3.0) (+ a 1))))
    1000
  ))
)

The output is:

(e) ; 2.7182818284590455

(if (< (remainder a 3) 2) 1.0 [calculation] ) means that the element that (= (remainder a 3) 0) or (= (remainder a 3) 1) will be 1.0.

To get the meaning of [calculation] ( that is, (* (/ 2.0 3.0) (+ a 1)) ), we need some conversion of numbers.

—

n = 2, 5, 8, 11, 14

m = 1, 2, 3, 4, 5

a(m) = 2, 4, 6, 8, 10 = (* 2 m)

—

then m = (* (/ 1 3 ) ( n + 1 ))

so a(n) = (* 2 m) = (* 2 (* (/ 1 3 ) ( n + 1 ))) = (* (/ 2 3 ) ( n + 1 ))

Exercise 1.39 - Define a procedure (tan-cf x k) that computes an approximation to the tangent
function based on Lambert’s formula.

Note that the operand of the calculation in numerators is minus.

(define (tan-cf x k)
  (cont-frac-linear-iterative
    (lambda (a) (if (= a 1) x (- (* x x))))
    (lambda (a) (- (* 2 a) 1))
    k
  )
)

The output is:

(tan-cf 1.0 1000) ; 1.557407724654902

The post [SICP 1.3.3] Exercise 1.37-1.39 Memo appeared first on Nisei Kimura's Blog.

The following code works correctly.

(define (golden-ratio) (fixed-point (lambda (y) (avg y (+ 1 (/ 1 y)))) 1.0))

(golden-ratio) ; 1.6180311591702674

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.

To show each output with the newline and  display primitives, we only need to change the fixed-point method as follows:

(define (fixed-point f first-guess)
(define (close-enough? v1 v2) (< (abs (- v1 v2)) tolerance))
(define (try guess)
(let ((next (f guess)))
; add two methods below to the existing code.
(display guess)
(newline)
:
:

Let’s try if the newly implemented feature works:

(golden-ratio)

And we’ll get the following output:

1.0
1.5
1.5833333333333333
1.6074561403508771
1.6147785476652068
1.61702925556443
1.617723628348796
1.6179380934832117
1.6180043565683029
1.6180248320058461
1.6180311591702674

Exercise 1.36( sequel ) Find a solution to x^x = 1000 by finding a fixed point of x |-> log(1000) / log(x).

 The following code will work. In this case, we need to change the initial number to 2.0 because the base of logarithm is 2.

(define (xexp) (fixed-point (lambda (x) (/ (log 1000) (log x))) 2.0))

Then we get the following output:

2.0
5.9828921423310435
4.922168721308343
4.628224318195455
4.568346513136242
4.5577305909237005
4.555909809045131
4.555599411610624
4.5555465521473675
4.555537551999825

Finally we get 4.555537551999825, and we can confirm if we’ve got a correct one by means of google search.

Exercise 1.36( sequel ) Compare the number of steps this takes with and without average damping.

In the previous solution, we’ve got 46 outputs, and we still have room for improvement using average damping. Then let’s change the code( Just adding a little bit of  arithmetics will do ).

(define (xexp) (fixed-point (lambda (x) (avg x (/ (log 1000) (log x)))) 2.0))

Then the output is:

2.0
5.9828921423310435
4.922168721308343
4.628224318195455
4.568346513136242
4.5577305909237005
4.555909809045131
4.555599411610624
4.5555465521473675
4.555537551999825

The number of the output is only 10, so it looks like the correction worked.

The post [SICP 1.3.3] Exercise 1.35-1.36 Memo appeared first on Nisei Kimura's Blog.

(define (sympson f a b n)
(define (term-num x)
(if (even? x) 2 4)
)
(define (y k) ( f (+ a (* k h))))
(define h (/ (- b a) n))
(define (next x) (+ x 1))

(define (term x)
(* (term-num x) ( y x ))
)

(* (/ h 3.0) (+ (y 0) (sum term 1 next (- n 1)) (y n)))
)
[shell]
Then let's compare this method to the one which isn't using Simpson's Rule. First we write the code as follows:
[shell]
(integral cube 0 1 0.001)
(sympson cube 0 1 10)
(sympson cube 0 1 100)

And we’ll get the following output.

0.24999987500000073
0.25
0.25

It looks like the new one outperforms the previous one.

SICP Exercise 1.30 – Rewrite sum method as a linear iterative process.
You can easily solve this by using what we’ve learned so far.

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

SICP Exercise 1.31(a) – 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 approximationas to PI using the formula: PI/4 = (2*4*4*6*6*8*…) / (3*3*5*5*7*7*…)

We can get the definition of product by changing sum method we’ve created just before.

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

Then the definition of factorial is:

(define (factorial n)
(product (lambda (x) x) 1 (lambda (x) (+ x 1)) n)
)

And the definition of the quarter of PI is:

(define (qrt-pi)
(define (term x)
(if (even? x) (/ (+ x 2.0) (+ x 1)) (/ (+ x 1.0) (+ x 2)))
)
(define (next x) (+ x 1) )
(product term 1 next 30000)
)

To confirm these codes, we write as follows:

; Factorial
(factorial 7) ; 5040
; PI
(* 4.0 (qrt-pi)) ; 3.14.....

It looks like this works well.

SICP Exercise 1.32(a) – Show that sum and product 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)

So let’s create this by using linear iterative process. We can easily get the abstraction by watching two functions( sum, product ) and extracting the common points.

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

Then two functions will be as follows:

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

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

Now let’s check their behavior.

(define (total term from to)
(sum term from (lambda (x) (+ x 1)) to)
)

(define (factorial n)
(product (lambda (x) x) 1 (lambda (x) (+ x 1)) n)
)

(total (lambda (x) x) 1 10) ; 55
(total (lambda (x) (* x x)) 1 5) ; 55
(factorial 7) ; 5040

Voila.

The post [SICP 1.3.1] Exercise 1.29-1.32 Memo appeared first on Nisei Kimura's Blog.

In the exercise, the multiplication is implemented as follows:

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

This requires the order of b. The question here is that we want to implement the same function that requires the order proportional to some logarithm.

(define (double x) (+ x x)) 
(define (halve x) (/ x 2))
(define (mul-2 a b)
  (cond ((= b 0) 0)
        ((even? b) (mul-2 (double a) (halve b)))
        (else (+ a (mul-2 a (- b 1)))))
)

This only requires the order of log_2(b).

As a result, we get the following output:

(mul-1 100 5000000) ; memory shortage
(mul-2 100 5000000) ; 500000000
(mul-2 10000 50000000000000) ; 500000000000000000

The post [SICP 1.2.4] Exercise 1.17 Memo appeared first on Nisei Kimura's Blog.