(index ("array?" 0) ("array-rank" 426) ("array-dimensions" 602) ("make-array" 784) ("make-shared-array" 1513) ("list->array" 2318) ("array->list" 2920) ("vector->array" 3311) ("array->vector" 3869) ("array-in-bounds?" 4170) ("array-ref" 4344) ("array-set!" 4467) ("A:floC128b" 4684) ("A:floC128b" 4684) ("A:floC64b" 4857) ("A:floC64b" 4857) ("A:floC32b" 5025) ("A:floC32b" 5025) ("A:floC16b" 5193) ("A:floC16b" 5193) ("A:floR128b" 5361) ("A:floR128b" 5361) ("A:floR64b" 5531) ("A:floR64b" 5531) ("A:floR32b" 5696) ("A:floR32b" 5696) ("A:floR16b" 5861) ("A:floR16b" 5861) ("A:fixZ64b" 6026) ("A:fixZ64b" 6026) ("A:fixZ32b" 6219) ("A:fixZ32b" 6219) ("A:fixZ16b" 6412) ("A:fixZ16b" 6412) ("A:fixZ8b" 6605) ("A:fixZ8b" 6605) ("A:fixN64b" 6793) ("A:fixN64b" 6793) ("A:fixN32b" 6999) ("A:fixN32b" 6999) ("A:fixN16b" 7205) ("A:fixN16b" 7205) ("A:fixN8b" 7411) ("A:fixN8b" 7411) ("A:bool" 7612) ("A:bool" 7612))
(def (sig (procedure "(array? obj)" (id array?))) (p "Returns " (tt "#t") " if the " (tt "obj") " is an array, and " (tt "#f") " if not.") (p (b "Note") ": Arrays are not disjoint from other Scheme types. Vectors and strings also satisfy " (tt "array?") ". A disjoint array predicate can be written as follows:") (highlight scheme "(define (strict-array? obj)\n  (and (array? obj) (not (string? obj)) (not (vector? obj))))"))
(def (sig (procedure "(array-rank obj)" (id array-rank))) (p "Returns the number of dimensions of " (tt "obj") ". If " (tt "obj") " is not an array, 0 is returned.") (pre ""))
(def (sig (procedure "(array-dimensions obj)" (id array-dimensions))) (p "Returns a list of dimensions.") (highlight scheme "(array-dimensions (make-array '#() 3 5))\n   => (3 5)"))
(def (sig (procedure "(make-array prototype k1 ...)" (id make-array))) (p "Creates and returns an array of type " (tt "prototype") " with dimensions " (tt "k1") ", ... and filled with elements from " (tt "prototype") ". " (tt "prototype") " must be an array, vector, or string. The implementation-dependent type of the returned array will be the same as the type of " (tt "prototype") "; except if that would be a vector or string with rank not equal to one, in which case some variety of array will be returned.") (p "If " (tt "prototype") " has no elements, then the initial contents of the returned array are unspecified. Otherwise, the returned array will be filled with the element at the origin of " (tt "prototype") "."))
(def (sig (procedure "(make-shared-array array mapper k1 ...)" (id make-shared-array))) (p (tt "make-shared-array") " can be used to create shared subarrays of other arrays. The " (tt "mapper") " is a function that translates coordinates in the new array into coordinates in the old array. A " (tt "mapper") " must be linear, and its range must stay within the bounds of the old array, but it can be otherwise arbitrary. A simple example:") (highlight scheme "(define fred (make-array '#(#f) 8 8))\n(define freds-diagonal\n  (make-shared-array fred (lambda (i) (list i i)) 8))\n(array-set! freds-diagonal 'foo 3)\n(array-ref fred 3 3)\n   => FOO\n(define freds-center\n  (make-shared-array fred (lambda (i j) (list (+ 3 i) (+ 3 j)))\n                     2 2))\n(array-ref freds-center 0 0)\n   => FOO"))
(def (sig (procedure "(list->array rank proto list)" (id list->array))) (p (tt "list") " must be a rank-nested list consisting of all the elements, in row-major order, of the array to be created.") (p (tt "list->array") " returns an array of rank " (tt "rank") " and type " (tt "proto") " consisting of all the elements, in row-major order, of " (tt "list") ". When " (tt "rank") " is 0, " (tt "list") " is the lone array element; not necessarily a list.") (highlight scheme "(list->array 2 '#() '((1 2) (3 4)))\n                => #2A((1 2) (3 4))\n(list->array 0 '#() 3)\n                => #0A 3"))
(def (sig (procedure "(array->list array)" (id array->list))) (p "Returns a rank-nested list consisting of all the elements, in row-major order, of " (tt "array") ". In the case of a rank-0 array, array->list returns the single element.") (highlight scheme "(array->list #2A((ho ho ho) (ho oh oh)))\n                => ((ho ho ho) (ho oh oh))\n(array->list #0A ho)\n                => ho"))
(def (sig (procedure "(vector->array vect proto dim1 ...)" (id vector->array))) (p (tt "vect") " must be a vector of length equal to the product of exact nonnegative integers " (tt "dim1") ", ....") (p (tt "vector->array") " returns an array of type " (tt "proto") " consisting of all the elements, in row-major order, of " (tt "vect") ". In the case of a rank-0 array, " (tt "vect") " has a single element.") (highlight scheme "(vector->array #(1 2 3 4) #() 2 2)\n                => #2A((1 2) (3 4))\n(vector->array '#(3) '#())\n                => #0A 3"))
(def (sig (procedure "(array->vector array)" (id array->vector))) (p "Returns a new vector consisting of all the elements of " (tt "array") " in row-major order.") (highlight scheme "(array->vector #2A ((1 2)( 3 4)))\n                => #(1 2 3 4)\n(array->vector #0A ho)\n                => #(ho)"))
(def (sig (procedure "(array-in-bounds? array index1 ...)" (id array-in-bounds?))) (p "Returns " (tt "#t") " if its arguments would be acceptable to " (tt "array-ref") "."))
(def (sig (procedure "(array-ref array k1 ...)" (id array-ref))) (p "Returns the " (tt "(k1, ...)") " element of array."))
(def (sig (procedure "(array-set! array obj k1 ...)" (id array-set!))) (p "Stores " (tt "obj") " in the " (tt "(k1, ...)") " element of " (tt "array") ". The value returned by " (tt "array-set!") " is unspecified."))
(def (sig (procedure "(A:floC128b)" (id A:floC128b)) (procedure "(A:floC128b z)" (id A:floC128b))) (p "Returns an inexact 128-bit flonum complex uniform-array prototype."))
(def (sig (procedure "(A:floC64b)" (id A:floC64b)) (procedure "(A:floC64b z)" (id A:floC64b))) (p "Returns an inexact 64-bit flonum complex uniform-array prototype."))
(def (sig (procedure "(A:floC32b)" (id A:floC32b)) (procedure "(A:floC32b z)" (id A:floC32b))) (p "Returns an inexact 32-bit flonum complex uniform-array prototype."))
(def (sig (procedure "(A:floC16b)" (id A:floC16b)) (procedure "(A:floC16b z)" (id A:floC16b))) (p "Returns an inexact 16-bit flonum complex uniform-array prototype."))
(def (sig (procedure "(A:floR128b)" (id A:floR128b)) (procedure "(A:floR128b x)" (id A:floR128b))) (p "Returns an inexact 128-bit flonum real uniform-array prototype."))
(def (sig (procedure "(A:floR64b)" (id A:floR64b)) (procedure "(A:floR64b x)" (id A:floR64b))) (p "Returns an inexact 64-bit flonum real uniform-array prototype."))
(def (sig (procedure "(A:floR32b)" (id A:floR32b)) (procedure "(A:floR32b x)" (id A:floR32b))) (p "Returns an inexact 32-bit flonum real uniform-array prototype."))
(def (sig (procedure "(A:floR16b)" (id A:floR16b)) (procedure "(A:floR16b x)" (id A:floR16b))) (p "Returns an inexact 16-bit flonum real uniform-array prototype."))
(def (sig (procedure "(A:fixZ64b)" (id A:fixZ64b)) (procedure "(A:fixZ64b n)" (id A:fixZ64b))) (p "Returns an exact binary fixnum uniform-array prototype with at least 64 bits of precision."))
(def (sig (procedure "(A:fixZ32b)" (id A:fixZ32b)) (procedure "(A:fixZ32b n)" (id A:fixZ32b))) (p "Returns an exact binary fixnum uniform-array prototype with at least 32 bits of precision."))
(def (sig (procedure "(A:fixZ16b)" (id A:fixZ16b)) (procedure "(A:fixZ16b n)" (id A:fixZ16b))) (p "Returns an exact binary fixnum uniform-array prototype with at least 16 bits of precision."))
(def (sig (procedure "(A:fixZ8b)" (id A:fixZ8b)) (procedure "(A:fixZ8b n)" (id A:fixZ8b))) (p "Returns an exact binary fixnum uniform-array prototype with at least 8 bits of precision."))
(def (sig (procedure "(A:fixN64b)" (id A:fixN64b)) (procedure "(A:fixN64b k)" (id A:fixN64b))) (p "Returns an exact non-negative binary fixnum uniform-array prototype with at least 64 bits of precision."))
(def (sig (procedure "(A:fixN32b)" (id A:fixN32b)) (procedure "(A:fixN32b k)" (id A:fixN32b))) (p "Returns an exact non-negative binary fixnum uniform-array prototype with at least 32 bits of precision."))
(def (sig (procedure "(A:fixN16b)" (id A:fixN16b)) (procedure "(A:fixN16b k)" (id A:fixN16b))) (p "Returns an exact non-negative binary fixnum uniform-array prototype with at least 16 bits of precision."))
(def (sig (procedure "(A:fixN8b)" (id A:fixN8b)) (procedure "(A:fixN8b k)" (id A:fixN8b))) (p "Returns an exact non-negative binary fixnum uniform-array prototype with at least 8 bits of precision."))
(def (sig (procedure "(A:bool)" (id A:bool)) (procedure "(A:bool boolean)" (id A:bool))) (p "Returns a boolean uniform-array prototype."))
