Tema 8 Vectores - Dpto. Ciencias de la Computación e Inteligencia

Vectores
Tema 8
Contenido:
Vectores
•
•
•
•
José A. Alonso
Listas, vectores y cadenas.
El tipo de dato vector.
El procedimiento vector-set! .
Procedimientos con vectores.
M. José Hidalgo
Álvaro Romero
Dpto. Ciencias de la Computación e Inteligencia Artificial
U NIVERSIDAD
DE
S EVILLA
Informática
Vectores
8.1
Comparación de listas, vectores y cadenas
Informática
8.2
Comparación de listas, vectores y cadenas
Listas:
• Ventaja: son extensibles.
• Inconveniente: el acceso a los elementos es secuencial.
Reconocedores
Selectores
Vectores:
• Ventaja: el acceso a los elementos es directo.
• Inconveniente: el tamaño es fijo.
Constructores
Mutadores
Cadenas:
• Ventajas: son extensibles y el acceso a los elementos es directo.
• Inconvenientes: sólo pueden tener caracteres como elementos.
Informática
Vectores
Vectores
8.3
Informática
Listas
Vectores
Cadenas
list?
null?
list-ref
length
car
cdr
vector?
string?
vector-ref
vector-length
string-ref
string-length
list
cons
append
vector
substring
string
make-vector
vector-set!
string-append
make-string
string-set!
Vectores
8.4
El tipo de dato vector
Procedimientos con vectores: suma-elementos-vector
• Representación:
#(1 2 3), #((a) (a b)), #(1 #(2)
#(#(3))), . . .
• Reconocedor: vector?
(vector? #(1 2 3)) => #t
(vector? ’(1 2 3)) => #f
(suma-elementos-vector #(1 2 3 4))
(suma-elementos-vector #(1 3 5))
=>
=>
10
9
(define suma-elementos-vector
(lambda (v )
(let ((res 0)
(n (vector-length v )))
(do ((i 0 (+ i 1)))
((= i n) res)
(set! res (+ res (vector-ref v i )))))))
• Selectores: vector-length, vector-ref
(vector-length #(1 2 3)) => 3
(vector-ref #(1 2 3) 0)
=> 1
(vector-ref #(1 2 3) 3)
=> vector-ref: index 3 out of range
• Constructores: make-vector , vector
(make-vector 3)
=> #(0 0 0)
(make-vector 5 ’a) => #(a a a a a)
(vector 1 2 3)
=> #(1 2 3)
Informática
Vectores
8.5
Procedimientos con vectores: lista-simbolos-vector
(lista-simbolos-vector #(1 a #f hola (ola)))
(lista-simbolos-vector #(#f #t #f #t #f))
=>
=>
Informática
8.6
Vectores
8.8
El procedimiento vector-set!
• Sintaxis:
(a hola)
()
(vector-set! vector índice elemento)
• Ejemplos:
(define lista-simbolos-vector
(lambda (v )
(let ((res ())
(n (vector-length v )))
(do ((i 0 (+ i 1)))
((= i n) res)
(if (symbol? (vector-ref v i ))
(set! res (append res (list (vector-ref v i )))))))))
(define v #(1 2 3))
(define w1 #(1 #(2) #(#(3))))
(define w2 #(1 #(2) #(#(3))))
(vector-set! v 1 (list ’a))
v
=>
#( 1 ( a) 3)
w1
=>
#( 1 #( 2) 3)
w2
=>
#(1 #(2) #(3))
(vector-set! w1 2 3)
(vector-set! (vector-ref w2 2) 0 3)
Informática
Vectores
Vectores
8.7
Informática
Procedimientos con vectores: suma-vectores
(suma-vectores #(1 2 3) #(3 2 1))
(suma-vectores #(1 3 5 7 9) #(0 2 4 6 8))
=>
=>
Procedimientos con vectores: vector-simbolos
#( 4 4 4)
#(1 5 9 13 17)
(vector-simbolos #(1 a #f hola (ola)))
(vector-simbolos #(#f #t #f #t #f))
(define suma-vectores
(lambda (v1 v2 )
(let∗ ((n (vector-length v1))
(w (make-vector n)))
(do ((i 0 (+ i 1)))
((= i n) w )
(vector-set! w i (+ (vector-ref v1 i )
(vector-ref v2 i )))))))
Informática
#(a hola)
#()
(define cuenta-simbolos
(lambda (w )
(let ((res 0)
(n (vector-length w )))
(do ((i 0 (+ i 1)))
((= i n) res)
(if (symbol? (vector-ref w i ))
(set! res (+ res 1)))))))
Vectores
8.9
Procedimientos con vectores: vector-simbolos
Informática
Vectores
8.10
Vectores
8.12
Procedimientos con vectores: suma-todos
(suma-todos #(#(1 2 3) #(1 3) #(1 4 7 10)))
(suma-todos #(#() #(0 0 0)))
(define vector-simbolos
(lambda (v )
(let∗ ((n (cuenta-simbolos v ))
(w (make-vector n)))
(do ((i 0 (+ i 1))
(j 0 (if (symbol? (vector-ref v i ))
(+ j 1) j )))
((= j n) w )
(if (symbol? (vector-ref v i ))
(vector-set! w j (vector-ref v i )))))))
Informática
=>
=>
=>
=>
32
0
(define suma-todos
(lambda (v )
(let ((res 0)
(m (vector-length v )))
(do ((i 0 (+ i 1)))
((= i m) res)
(let∗ ((w (vector-ref v i ))
(n (vector-length w )))
(do ((j 0 (+ j 1)))
((= j n))
(set! res (+ res (vector-ref w j )))))))))
Vectores
8.11
Informática
Procedimientos con vectores: matriz-i+j
Otros procedimientos relativos a vectores
• Los procedimientos vector->list y list->vector :
(matriz-i+j 3)
(matriz-i+j 4)
=>
=>
#(#(0 1 2) #(1 2 3) #(2 3 4))
#(#(0 1 2 3) #(1 2 3 4) #(2 3 4 5) #(3 4 5 6))
(define matriz-i+j
(lambda (n)
(let ((v (make-vector n)))
(do ((i 0 (+ i 1)))
((= i n) v )
(let ((w (make-vector n)))
(do ((j 0 (+ j 1)))
((= j n) (vector-set! v i w ))
(vector-set! w j (+ i j ))))))))
Informática
=>
=>
(1 2 3)
(1 #(2) #((3)))
(list->vector ’(1 2 3))
(list->vector ’(1 (2) ((3))))
(list->vector (map list->vector ’((1) (2) (3))))
=>
=>
=>
#( 1 2 3)
#(1 (2) ((3)))
#(#(1) #(2) #(3))
• El procedimiento vector-fill! :
(vector-fill! #(1 2 3) ’a)
(define v #(1 2 3))
(define w (vector-fill! #(0 0) v ))
w
(vector-set! v 1 ’a)
w
Vectores
8.13
Vectores
8.15
Bibliografía
[Springer-94]
Cap. 9: ”Using vectors"
Informática
(vector->list #(1 2 3))
(vector->list #(1 #(2) #((3))))
Informática
=>
#( a a a)
=>
#(#(1 2 3) #(1 2 3))
=>
#(#(1 a 3) #(1 a 3))
Vectores
8.14