Comments on: SICP section 2.2.3

By: gorilych

gorilych — Fri, 03 Oct 2008 01:59:04 +0000

On ex. 2.38

for any init, el1, el2, .. eln , op should have such properties that:

(el1 op (el2 op ( .. (eln op init)))) == ((.. (init op el1) op el2) op … ) op eln

consider the case when n = 2:

(el1 op (el2 op init)) == ((init op el1) op el2)

We need both associative and communicative properties for op to have this:

By: eliben

eliben — Thu, 07 Aug 2008 16:56:20 +0000

Arturo,
Yes, you’re right. Associative and not commutative.
I’ve fixed the post, thanks.

By: Arturo Pina

Arturo Pina — Tue, 05 Aug 2008 13:26:21 +0000

By the way my previous comment was for exercise 2.38

By: Arturo Pina

Arturo Pina — Mon, 04 Aug 2008 10:48:20 +0000

Hi,

I think the requirement is that the op is associative rather than commutative. As a counterexample please consider 2/(x+y) which is commutative and produces different results depending on if you use fold-left or fold-right

What led me to think in associativity was that intuitively the functions go building the results two ops at a time but starting from the left or from the right… A formal demonstration might be produced but that’s off limits for me

By: Wang Shengyi

Wang Shengyi — Fri, 01 Aug 2008 14:16:12 +0000

Exercise 2.41
In my opinion, the requirement “ordered triple” is a mathematical terminology such as “ordered pair”. It emphasizes the order of coordinate, not the order of the numbers. You can see this concept in wikipedia: http://en.wikipedia.org/wiki/Ordered_pair. This article contains generalities as “ordered n-tuples”. I give my solution here (of course it’s not the optimal):
(define (triple n s)
(filter (lambda (trp)
(and
(eqv? s (accumulate + 0 trp))
(not (eqv? (car trp) (cadr trp)))
(not (eqv? (car trp) (caddr trp)))
(not (eqv? (cadr trp) (caddr trp)))))
(flatmap
(lambda (i)
(flatmap
(lambda (j)
(map (lambda (k) (list i j k))
(enumerate-interval 1 n)))
(enumerate-interval 1 n)))
(enumerate-interval 1 n))))

By: eliben

eliben — Sun, 25 May 2008 16:24:11 +0000

prahlad,

When you multiply a matrix by a vector (matrix at the left, which is different from vector by matrix, where the matrix is at the right), the vector must be a column vector and the multiplication is indeed the dot product of the vector and each row.

By: prahlad

prahlad — Sat, 24 May 2008 08:58:03 +0000

As far as i am able to understand this procdure
(defun matrix-*-vector (m v)
(mapcar
(lambda (row)
(dot-product row v))
m))
it gives the dot product of vector and each row of matrix. while the matrix*-vector should provide the dot product of given vector and each column of matrix.

By: ElPicasso

ElPicasso — Sun, 30 Dec 2007 14:24:47 +0000

thoughts about ex 2.41
unique-triples can be rewritten using unique-pairs:

unique triples is flatmap of the first element with unique-pair of (1+ n) till end

for instance:
(unique-triples 4)
; ((1 2 3) (1 2 4) (1 3 4) (2 3 4))

first element is 1, unique-pair from 2 till 4 is: (2 3) (2 4) (3 4), so becomes (1 2 3) (1 2 4) (1 3 4)
snd element is 2, unique-pair from 3 till 4 is: (3 4), so (2 3 4)

(define (unique-pairs-interval from till) (flatmap (lambda (i) (map (lambda (j) (list i j)) (enumerate-interval (+ 1 i) till))) (enumerate-interval from till)))


(define (unique-triples n)

  (flatmap

   (lambda (i)

     (map (lambda (j) (append (list i) j))

	  (unique-pairs-interval (+ 1 i) n)))

   (enumerate-interval 1 n)))

even more general you can say that the unique-nth is the flatmap of the first element with the unique-(nth -1) of (+1 n) till

(define (unique-nths from till nths) (if (= nths 0) (list ()) (flatmap (lambda (i) (map (lambda (j) (append (list i) j)) (unique-nths (+ 1 i) till (- nths 1)))) (enumerate-interval from till))))


(define (unique-pair n)

  (unique-nths 1 n 2))

(define (unique-triples n) (unique-nths 1 n 3))

By: rinat

rinat — Sat, 13 Oct 2007 07:55:18 +0000

ex 2.35
(define (count-leaves-acc t) (accumulate + 0 (map (lambda (x) (+ 0 1)) (enumerate-tree t))))