Node: Vectors, Next: , Previous: Strings, Up: Standard Procedures



Vectors

Vectors are heterogenous structures whose elements are indexed by integers. A vector typically occupies less space than a list of the same length, and the average time required to access a randomly chosen element is typically less for the vector than for the list.

The length of a vector is the number of elements that it contains. This number is a non-negative integer that is fixed when the vector is created. The valid indexes of a vector are the exact non-negative integers less than the length of the vector. The first element in a vector is indexed by zero, and the last element is indexed by one less than the length of the vector.

Vectors are written using the notation #(obj ...). For example, a vector of length 3 containing the number zero in element 0, the list (2 2 2 2) in element 1, and the string "Anna" in element 2 can be written as following:

     #(0 (2 2 2 2) "Anna")
     

Note: In STKLOS, vectors constants don't need to be quoted.

vector? obj R5RS
Returns #t if obj is a vector, otherwise returns #f.

make-vector k R5RS
make-vector k fill R5RS
Returns a newly allocated vector of k elements. If a second argument is given, then each element is initialized to fill. Otherwise the initial contents of each element is unspecified.

vector obj ... R5RS
Returns a newly allocated vector whose elements contain the given arguments. Analogous to list.
          (vector 'a 'b 'c)               =>  #(a b c)
          

vector-length vector R5RS
Returns the number of elements in vector as an exact integer.

vector-ref vector k R5RS
k must be a valid index of vector. Vector-ref returns the contents of element k of vector.
          (vector-ref '#(1 1 2 3 5 8 13 21)
                      5)         =>  8
          (vector-ref '#(1 1 2 3 5 8 13 21)
                      (let ((i (round (* 2 (acos -1)))))
                        (if (inexact? i)
                            (inexact->exact i)
                            i))) => 13
          

vector-set! vector k obj R5RS
k must be a valid index of vector. Vector-set! stores obj in element k of vector. The value returned by vector-set! is void.
          (let ((vec (vector 0 '(2 2 2 2) "Anna")))
            (vector-set! vec 1 '("Sue" "Sue"))
            vec)      =>  #(0 ("Sue" "Sue") "Anna")
          
          (vector-set! '#(0 1 2) 1 "doe")  =>  error  ; constant vector
          

vector->list vector R5RS
list->vector list R5RS
Vector->list returns a newly allocated list of the objects contained in the elements of vector. List->vector returns a newly created vector initialized to the elements of the list list.
          (vector->list '#(dah dah didah))  =>  (dah dah didah)
          (list->vector '(dididit dah))     =>  #(dididit dah)
          

vector-fill! vector fill R5RS
Stores fill in every element of vector. The value returned by vector-fill! is void.

vector-copy v STKLOS Procedure
Return a copy of vectot v. Note that, if v is a constant vector, its copy is not constant.

vector-resize v size STKLOS Procedure
vector-resize v size fill STKLOS Procedure
Returns a copy of v of the given size. If size is greater than the vector size of v, the contents of the newly allocated vector cells is set to the value of fill. If fill is omitted the content of the new cells is void.

vector-mutable? obj STKLOS Procedure
Returns #t if obj is a mutable vector, otherwise returns #f.
          (vector-mutable? '#(1 2 a b))            => #f
          (vector-mutable? (vector-copy '#(1 2)))  => #t
          (vector-mutable? (vector 1 2 3))         => #t
          (vector-mutable? 12)                     => #f
          

sort obj predicate STKLOS Procedure
Obj must be a list or a vector. Sort returns a copy of obj sorted according to predicate. Predicate must be a procedure which takes two arguments and returns a true value if the first argument is strictly "before" the second.
          (sort '(1 2 -4 12 9 -1 2 3) <)
                         => (-4 -1 1 2 2 3 9 12)
          (sort '#("one" "two" "three" "four")
                (lambda (x y) (> (string-length x) (string-length y))))
                         => '#("three" "four" "one" "two")