From Newsgroup: comp.lang.scheme

Steven E. Harris wrote:

(defun dot-product (u v)
(loop for elem-u across u
for elem-v across v
summing (* elem-u elem-v)))

(dot-product (vector 1 2 3)

(vector 4 5 6))
32

Gauche Scheme

(use gauche.sequence)

(define (dot-product u v)
(fold
(lambda (e-u e-v sum) (+ sum (* e-u e-v)))
0
u
v))

(dot-product #(1 2 3) #(4 5 6))
===>
32


Here's a version that handles any number of vectors.

(use scheme.vector)

(define (dot-product . vecs)
(apply vector-fold
(lambda (sum . elems) (+ sum (apply * elems)))
0
vecs))

(dot-product #(1 2 3) #(4 5 6) #(7 8 9))
===>
270



Shorter:

(define (dot-product u v)
(fold + 0 (map * u v)))


Shorter:

(define (dot-product u v)
(apply + (map * u v)))
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.scheme

B. Pym wrote:

Steven E. Harris wrote:

(defun dot-product (u v)
(loop for elem-u across u
for elem-v across v
summing (* elem-u elem-v)))

(dot-product (vector 1 2 3)

(vector 4 5 6))
32

Gauche Scheme

(define (dot-product U V)
(gmk u U)
(gmk v V)
(do ((s 0 (+ s (* (u) (v)))))
((unull?) s)))

(dot-product (vector 1 2 3) (vector 4 5 6))
===>
32

Given:

;; Make a generator.
(define (gmk* vec)
(let ((v vec)
(i 0))
(values
(lambda()
(if (= i (vector-length v)) #f (begin0 (~ v i) (inc! i))))
(lambda() (= i (vector-length v))))))

(define-macro gmk
(lambda (sym vec)
`(define-values
(,sym ,(symbol-append sym 'null?))
(gmk* ,vec))))
--
[T]he problem is that lispniks are as cultish as any other devout group and basically fall down frothing at the mouth if they see [heterodoxy].
--- Kenny Tilton
The good news is, it's not Lisp that sucks, but Common Lisp. --- Paul Graham --- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.scheme

B. Pym wrote:

B. Pym wrote:

Steven E. Harris wrote:

(defun dot-product (u v)
(loop for elem-u across u
for elem-v across v
summing (* elem-u elem-v)))

(dot-product (vector 1 2 3)

(vector 4 5 6))
32

Gauche Scheme

(define (dot-product U V)
(gmk u U)
(gmk v V)
(do ((s 0 (+ s (* (u) (v)))))
((unull?) s)))

(dot-product (vector 1 2 3) (vector 4 5 6))
===>
32

Given:

;; Make a generator.
(define (gmk* vec)
(let ((v vec)
(i 0))
(values
(lambda()
(if (= i (vector-length v)) #f (begin0 (~ v i) (inc! i))))
(lambda() (= i (vector-length v))))))

(define-macro gmk
(lambda (sym vec)
`(define-values
(,sym ,(symbol-append sym 'null?))
(gmk* ,vec))))

Shorter:

(define (dot-product U V)
(gmk u U v V)
(do ((s 0 (+ s (* (u) (v)))))
((unull?) s)))

(define-macro gmk
(lambda args
(define duos
(let go ()
(if (null? args) '() (cons (list (pop! args)(pop! args)) (go)))))
(define (def s v)
`(define-values
(,s ,(symbol-append s 'null?))
(gmk* ,v)))
`(begin ,@(map (lambda (xs) (apply def xs)) duos))))
--
[T]he problem is that lispniks are as cultish as any other devout group and basically fall down frothing at the mouth if they see [heterodoxy].
--- Kenny Tilton
The good news is, it's not Lisp that sucks, but Common Lisp. --- Paul Graham --- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.scheme

B. Pym wrote:

Steven E. Harris wrote:

(defun dot-product (u v)
(loop for elem-u across u
for elem-v across v
summing (* elem-u elem-v)))

(dot-product (vector 1 2 3)

(vector 4 5 6))
32

Gauche Scheme

(use gauche.sequence)

(define (dot-product u v)
(fold
(lambda (e-u e-v sum) (+ sum (* e-u e-v)))
0
u
v))

(dot-product #(1 2 3) #(4 5 6))
===>
32

Gauche Scheme

(use gauche.sequence) ;; So that "fold" can handle vectors.

(define (dot-product u v)
(% fold (+ (* A: B:) C:) 0 u v))

(dot-product (vector 1 2 3) (vector 4 5 6))
===>
32

Given:

;; Anaphoric macro to abreviate lambdas for higher-order functions.
;; Uses "_" for 1 argument;
;; uses "A:" and "B:" and so on for 2 or more arguments.
;; This version works under both Gauche Scheme
;; and Racket. Racket needs:
;; (require compatibility/defmacro)
;;
(define-macro %
(case-lambda
((func expr List) `(,func (lambda(_) ,expr) ,List))
((func expr . more)
(let* ((n 64)
(nums (map (lambda _ (set! n (+ 1 n)) n) more))
(vnames
(map (lambda(n)
(string->symbol (string (integer->char n) #\:)))
nums)))
`(,func (lambda ,vnames ,expr) ,@more)))))
--
[T]he problem is that lispniks are as cultish as any other devout group and basically fall down frothing at the mouth if they see [heterodoxy].
--- Kenny Tilton
The good news is, it's not Lisp that sucks, but Common Lisp. --- Paul Graham --- Synchronet 3.21a-Linux NewsLink 1.2