(guile.info.gz) Uniform Arrays

 
 22.6.3 Uniform Arrays
 ---------------------
 
 "Uniform arrays" have elements all of the same type and occupy less
 storage than conventional arrays.  Uniform arrays with a single
 zero-based dimension are also known as "uniform vectors".  The
 procedures in this section can also be used on conventional arrays,
 vectors, bit-vectors and strings.
 
 When creating a uniform array, the type of data to be stored is
 indicated with a PROTOTYPE argument.  The following table lists the
 types available and example prototypes:
 
      prototype           type                       printing character
 
      #t             boolean (bit-vector)                    b
      #\a            char (string)                           a
      #\nul          byte (integer)                          y
      's             short (integer)                         h
      1              unsigned long (integer)                 u
      -1             signed long (integer)                   e
      'l             signed long long (integer)              l
      1.0            float (single precision)                s
      1/3            double (double precision float)         i
      0+i            complex (double precision)              c
      ()             conventional vector
 
 Unshared uniform arrays of characters with a single zero-based dimension
 are identical to strings:
 
      (make-uniform-array #\a 3) =>
      "aaa"
 
 Unshared uniform arrays of booleans with a single zero-based dimension
 are identical to  bit-vectors Bit Vectors.
 
      (make-uniform-array #t 3) =>
      #*111
 
 Other uniform vectors are written in a form similar to that of vectors,
 except that a single character from the above table is put between `#'
 and `('.  For example, a uniform vector of signed long integers is
 displayed in the form `'#e(3 5 9)'.
 
  -- Scheme Procedure: array? v [prot]
      Return `#t' if the OBJ is an array, and `#f' if not.
 
      The PROTOTYPE argument is used with uniform arrays and is described
      elsewhere.
 
  -- Scheme Procedure: make-uniform-array prototype bound1 bound2 ...
      Create and return a uniform array of type corresponding to
      PROTOTYPE that has as many dimensions as there are BOUNDs and fill
      it with PROTOTYPE.
 
  -- Scheme Procedure: array-prototype ra
  -- C Function: scm_array_prototype (ra)
      Return an object that would produce an array of the same type as
      ARRAY, if used as the PROTOTYPE for `make-uniform-array'.
 
  -- Scheme Procedure: list->uniform-array ndim prot lst
  -- Scheme Procedure: list->uniform-vector prot lst
  -- C Function: scm_list_to_uniform_array (ndim, prot, lst)
      Return a uniform array of the type indicated by prototype PROT
      with elements the same as those of LST.  Elements must be of the
      appropriate type, no coercions are done.
 
  -- Scheme Procedure: uniform-vector-fill! uve fill
      Store FILL in every element of UVE.  The value returned is
      unspecified.
 
  -- Scheme Procedure: uniform-vector-length v
  -- C Function: scm_uniform_vector_length (v)
      Return the number of elements in UVE.
 
  -- Scheme Procedure: dimensions->uniform-array dims prot [fill]
  -- Scheme Procedure: make-uniform-vector length prototype [fill]
  -- C Function: scm_dimensions_to_uniform_array (dims, prot, fill)
      Create and return a uniform array or vector of type corresponding
      to PROTOTYPE with dimensions DIMS or length LENGTH.  If FILL is
      supplied, it's used to fill the array, otherwise PROTOTYPE is used.
 
  -- Scheme Procedure: uniform-array-read! ra [port_or_fd [start [end]]]
  -- Scheme Procedure: uniform-vector-read! uve [port-or-fdes] [start]
           [end]
  -- C Function: scm_uniform_array_read_x (ra, port_or_fd, start, end)
      Attempt to read all elements of URA, in lexicographic order, as
      binary objects from PORT-OR-FDES.  If an end of file is
      encountered, the objects up to that point are put into URA
      (starting at the beginning) and the remainder of the array is
      unchanged.
 
      The optional arguments START and END allow a specified region of a
      vector (or linearized array) to be read, leaving the remainder of
      the vector unchanged.
 
      `uniform-array-read!' returns the number of objects read.
      PORT-OR-FDES may be omitted, in which case it defaults to the value
      returned by `(current-input-port)'.
 
  -- Scheme Procedure: uniform-array-write v [port_or_fd [start [end]]]
  -- Scheme Procedure: uniform-vector-write uve [port-or-fdes] [start]
           [end]
  -- C Function: scm_uniform_array_write (v, port_or_fd, start, end)
      Writes all elements of URA as binary objects to PORT-OR-FDES.
 
      The optional arguments START and END allow a specified region of a
      vector (or linearized array) to be written.
 
      The number of objects actually written is returned.  PORT-OR-FDES
      may be omitted, in which case it defaults to the value returned by
      `(current-output-port)'.
Info Catalog
(guile.info.gz) Array Mapping
(guile.info.gz) Arrays
(guile.info.gz) Bit Vectors
automatically generated byinfo2html