Changeset 39532 in project

Timestamp:

01/27/21 05:44:35 (5 weeks ago)

Author:

dieggsy

Message:

srfi-179 docs: add links to procedures

File:

• wiki/eggref/5/srfi-179 (modified) (51 diffs)

wiki/eggref/5/srfi-179

@@ -152 +152 @@
 ==== Procedures
 
+===== translation?
 <procedure>(translation? object)</procedure>
 
 Returns {{#t}} if {{object}} is a translation, and {{#f}} otherwise.
 
+===== permutation?
 <procedure>(permutation? object)</procedure>
 
@@ -168 +170 @@
 ==== Procedures
 
+===== make-interval
 <procedure>(make-interval arg1 #!optional arg2)</procedure>
 
@@ -179 +182 @@
 for $0\leq i<{}${{(vector-length lower-bounds)}}. It is an error if {{lower-bounds}} and {{upper-bounds}} do not satisfy these conditions.
 
+===== interval?
 <procedure>(interval? obj)</procedure>
 
 Returns {{#t}} if {{obj}} is an interval, and {{#f}} otherwise.
 
+===== interval-dimension
 <procedure>(interval-dimension interval)</procedure>
 
@@ -190 +195 @@
 then {{interval-dimension}} returns {{(vector-length lower-bounds)}}. It is an error to call {{interval-dimension}} if {{interval}} is not an interval.
 
+===== interval-lower-bound
 <procedure>(interval-lower-bound interval i)</procedure>
 
+===== interval-upper-bound
 <procedure>(interval-upper-bound interval i)</procedure>
 
@@ -204 +211 @@
 then {{interval-lower-bound}} returns {{(vector-ref lower-bounds i)}} and {{interval-upper-bound}} returns {{(vector-ref upper-bounds i)}}. It is an error to call {{interval-lower-bound}} or {{interval-upper-bound}} if {{interval}} and {{i}} do not satisfy these conditions.
 
+===== interval-lower-bounds->list
 <procedure>(interval-lower-bounds->list interval)</procedure>
 
+===== interval-upper-bounds->list
 <procedure>(interval-upper-bounds->list interval)</procedure>
 
@@ -214 +223 @@
 then {{interval-lower-bounds->list}} returns {{(vector->list lower-bounds)}} and {{interval-upper-bounds->list}} returns {{(vector->list upper-bounds)}}. It is an error to call {{interval-lower-bounds->list}} or {{interval-upper-bounds->list}} if {{interval}} does not satisfy these conditions.
 
+===== interval-lower-bounds->vector
 <procedure>(interval-lower-bounds->vector interval)</procedure>
 
+===== interval-upper-bounds->vector
 <procedure>(interval-upper-bounds->vector interval)</procedure>
 
@@ -223 +234 @@
 then {{interval-lower-bounds->vector}} returns a copy of {{lower-bounds}} and {{interval-upper-bounds->vector}} returns a copy of {{upper-bounds}}. It is an error to call {{interval-lower-bounds->vector}} or {{interval-upper-bounds->vector}} if {{interval}} does not satisfy these conditions.
 
+===== interval-volume
 <procedure>(interval-volume interval)</procedure>
 
@@ -233 +245 @@
 It is an error to call {{interval-volume}} if {{interval}} does not satisfy this condition.
 
+===== interval=
 <procedure>(interval= interval1 interval2)</procedure>
 
@@ -246 +259 @@
 It is an error to call {{interval=}} if {{interval1}} or {{interval2}} do not satisfy this condition.
 
+===== interval-subset?
 <procedure>(interval-subset? interval1 interval2)</procedure>
 
@@ -256 +270 @@
 for all $0\leq j<d$, otherwise it returns {{#f}}. It is an error if the arguments do not satisfy these conditions.
 
+===== interval-contains-multi-index?
 <procedure>(interval-contains-multi-index? interval index-0 index-1 ...)</procedure>
 
@@ -266 +281 @@
 It is an error to call {{interval-contains-multi-index?}} if {{interval}} and {{index-0}},..., do not satisfy this condition.
 
+===== interval-projections
 <procedure>(interval-projections interval right-dimension)</procedure>
 
@@ -303 +319 @@
 It is an error to call {{interval-projections}} if its arguments do not satisfy these conditions.
 
+===== interval-for-each
 <procedure>(interval-for-each f interval)</procedure>
 
@@ -309 +326 @@
 {{interval-for-each}} calls {{f}} with each multi-index of {{interval}} as arguments, all in lexicographical order.
 
+===== interval-dilate
 <procedure>(interval-dilate interval lower-diffs upper-diffs)</procedure>
 
@@ -330 +348 @@
  (make-interval '#(100 100))
  '#(0 0) '#(-500 -50)) => error</enscript>
+===== interval-intersect
 <procedure>(interval-intersect interval-1 interval-2 ...)</procedure>
 
@@ -336 +355 @@
 It is an error if the arguments are not all intervals with the same dimension.
 
+===== interval-translate
 <procedure>(interval-translate interval translation)</procedure>
 
@@ -342 +362 @@
 One could define {{(interval-translate interval translation)}} by {{(interval-dilate interval translation translation)}}.
 
+===== interval-permute
 <procedure>(interval-permute interval permutation)</procedure>
 
@@ -352 +373 @@
 For example, if the argument interval represents $[0,4)\times[0,8)\times[0,21)\times [0,16)$ and the permutation is {{#(3 0 1 2)}}, then the result of {{(interval-permute interval permutation)}} will be the representation of $[0,16)\times [0,4)\times[0,8)\times[0,21)$.
 
+===== interval-rotate
 <procedure>(interval-rotate interval dim)</procedure>
 
@@ -358 +380 @@
 More precisely, {{(interval-rotate interval dim)}} assumes that {{interval}} is an interval and {{dim}} is an exact integer between 0 (inclusive) and {{(interval-dimension interval)}} (exclusive). It computes the permutation {{(vector dim ... (- (interval-dimension interval) 1) 0 ... (- dim 1))}} (unless {{dim}} is zero, in which case it constructs the identity permutation) and returns {{(interval-permute interval permutation)}}. It is an error if the arguments do not satisfy these conditions.
 
+===== interval-scale
 <procedure>(interval-scale interval scales)</procedure>
 
@@ -364 +387 @@
 It is an error if {{interval}} and {{scales}} do not satisfy this condition.
 
+===== interval-cartesian-product
 <procedure>(interval-cartesian-product interval . intervals)</procedure>
 
@@ -378 +402 @@
 ==== Procedures
 
+===== make-storage-class
 <procedure>(make-storage-class getter setter checker maker copier length default)</procedure>
 
@@ -392 +417 @@
 Note that we assume that {{getter}} and {{setter}} generally take ''O''(1) time to execute.
 
+===== storage-class?
 <procedure>(storage-class? m)</procedure>
 
 Returns {{#t}} if {{m}} is a storage class, and {{#f}} otherwise.
 
+===== storage-class-getter
 <procedure>(storage-class-getter m)</procedure>
 
+===== storage-class-setter
 <procedure>(storage-class-setter m)</procedure>
 
+===== storage-class-checker
 <procedure>(storage-class-checker m)</procedure>
 
+===== storage-class-maker
 <procedure>(storage-class-maker m)</procedure>
 
+===== storage-class-copier
 <procedure>(storage-class-copier m)</procedure>
 
+===== storage-class-length
 <procedure>(storage-class-length m)</procedure>
 
+===== storage-class-default
 <procedure>(storage-class-default m)</procedure>
 
@@ -470 +503 @@
 ==== Procedures
 
+===== make-array
 <procedure>(make-array interval getter [ setter ])</procedure>
 
@@ -542 +576 @@
 (a_ 12345 6789)  => 0.
 (a_ 0 0) => 1.</enscript>
+===== array?
 <procedure>(array? obj)</procedure>
 
 Returns {{#t}} if {{obj}} is an array and {{#f}} otherwise.
 
+===== array-domain
 <procedure>(array-domain array)</procedure>
 
+===== array-getter
 <procedure>(array-getter array)</procedure>
 
@@ -567 +604 @@
 (a_ 2 3) => 0
 (a_ 11 0) => is an error</enscript>
+===== array-dimension
 <procedure>(array-dimension array)</procedure>
 
 Shorthand for {{(interval-dimension (array-domain array))}}. It is an error to call this function if {{array}} is not an array.
 
+===== mutable-array?
 <procedure>(mutable-array? obj)</procedure>
 
 Returns {{#t}} if {{obj}} is a mutable array and {{#f}} otherwise.
 
+===== array-setter
 <procedure>(array-setter array)</procedure>
 
@@ -594 +634 @@
 If {{bool}} is {{#t}} then the next call to {{specialized-array-default-mutable?}} will return {{#t}}; if {{bool}} is {{#f}} then the next call to {{specialized-array-default-mutable?}} will return {{#f}}; otherwise it is an error.
 
+===== make-specialized-array
 <procedure>(make-specialized-array interval [ storage-class generic-storage-class ] [ safe? (specialized-array-default-safe?) ])</procedure>
 
@@ -633 +674 @@
 and then simply call, e.g., {{(make-u16-array (make-interval '#(3 3)))}}.
 
+===== specialized-array?
 <procedure>(specialized-array? obj)</procedure>
 
 Returns {{#t}} if {{obj}} is a specialized-array, and {{#f}} otherwise. A specialized-array is an array.
 
+===== array-storage-class
 <procedure>(array-storage-class array)</procedure>
 
+===== array-indexer
 <procedure>(array-indexer array)</procedure>
 
+===== array-body
 <procedure>(array-body array)</procedure>
 
+===== array-safe?
 <procedure>(array-safe? array)</procedure>
 
@@ -655 +701 @@
 It is an error to call any of these routines if {{array}} is not a specialized array.
 
+===== array-elements-in-order?
 <procedure>(array-elements-in-order? A)</procedure>
 
@@ -661 +708 @@
 It is an error if {{A}} is not a specialized array.
 
+===== specialized-array-share
 <procedure>(specialized-array-share array new-domain new-domain->old-domain)</procedure>
 
@@ -710 +758 @@
 This "shearing" operation cannot be achieved by combining the procedures {{array-extract}}, {{array-translate}}, {{array-permute}}, {{array-translate}}, {{array-curry}}, {{array-reverse}}, and {{array-sample}}.
 
+===== array-copy
 <procedure>(array-copy array [ result-storage-class generic-storage-class ] [ new-domain #f ] [ mutable? (specialized-array-default-mutable?) ] [ safe? (specialized-array-default-safe?) ])</procedure>
 
@@ -727 +776 @@
 '''Note:''' If {{new-domain}} is not the same as {{(array-domain array)}}, one can think of the resulting array as a ''reshaped'' version of {{array}}.
 
+===== array-curry
 <procedure>(array-curry array inner-dimension)</procedure>
 
@@ -826 +876 @@
 ((array-getter (curried-a_ 3)) 4)
                     => (3 4)</enscript>
+===== array-extract
 <procedure>(array-extract array new-domain)</procedure>
 
@@ -850 +901 @@
 If {{array}} is a specialized array, the resulting array inherits its mutability and safety from {{array}}.
 
+===== array-tile
 <procedure>(array-tile A S)</procedure>
 
@@ -862 +914 @@
 '''Note:''' The routines {{array-tile}} and {{array-curry}} both decompose an array into subarrays, but in different ways. For example, if {{A}} is defined as {{(make-array (make-interval '#(10 10)) list)}}, then {{(array-tile A '#(1 10))}} returns an array with domain {{(make-interval '#(10 1))}}, each element of which is an array with domain {{(make-interval '#(1 10))}} (i.e., a two-dimensional array whose elements are two-dimensional arrays), while {{(array-curry A 1)}} returns an array with domain {{(make-interval '#(10))}}, each element of which has domain {{(make-interval '#(10))}} (i.e., a one-dimensional array whose elements are one-dimensional arrays).
 
+===== array-translate
 <procedure>(array-translate array translation)</procedure>
 
@@ -910 +963 @@
 It is an error if the arguments do not satisfy these conditions.
 
+===== array-permute
 <procedure>(array-permute array permutation)</procedure>
 
@@ -954 +1008 @@
 It is an error to call {{array-permute}} if its arguments do not satisfy these conditions.
 
+===== array-rotate
 <procedure>(array-rotate array dim)</procedure>
 
@@ -960 +1015 @@
 More precisely, {{(array-rotate array dim)}} assumes that {{array}} is an array and {{dim}} is an exact integer between 0 (inclusive) and {{(array-dimension array)}} (exclusive). It computes the permutation {{(vector dim ... (- (array-dimension array) 1) 0 ... (- dim 1))}} (unless {{dim}} is zero, in which case it constructs the identity permutation) and returns {{(array-permute array permutation)}}. It is an error if the arguments do not satisfy these conditions.
 
+===== array-reverse
 <procedure>(array-reverse array #!optional flip?)</procedure>
 
@@ -1042 +1098 @@
 (palindrome? "abca") => #f
 (palindrome? "abbc") => #f</enscript>
+===== array-sample
 <procedure>(array-sample array scales)</procedure>
 
@@ -1081 +1138 @@
 It is an error if {{array}} and {{scales}} don't satisfy these requirements.
 
+===== array-outer-product
 <procedure>(array-outer-product op array1 array2)</procedure>
 
@@ -1098 +1156 @@
 This implies that if {{(array-getter A)}} is expensive to compute (for example, if it's returning an array, as does {{array-curry}}) then the elements of {{A}} should be pre-computed if necessary and stored in a specialized array, typically using {{array-copy}}, before that specialized array is passed as an argument to {{array-outer-product}}. In the examples below, the code for Gaussian elimination applies {{array-outer-product}} to shared specialized arrays, which are of course themselves specialized arrays; the code for matrix multiplication and {{inner-product}} applies {{array-outer-product}} to curried arrays, so we apply {{array-copy}} to the arguments before passage to {{array-outer-product}}.
 
+===== array-map
 <procedure>(array-map f array . arrays)</procedure>
 
@@ -1133 +1192 @@
               (lambda (i)
                 (+ (a_ i) i))))</enscript>
+===== array-for-each
 <procedure>(array-for-each f array . arrays)</procedure>
 
@@ -1159 +1219 @@
 It is an error to call {{array-for-each}} if its arguments do not satisfy these conditions.
 
+===== array-fold
 <procedure>(array-fold kons knil array)</procedure>
 
@@ -1173 +1234 @@
 It is an error if {{array}} is not an array, or if {{kons}} is not a procedure.
 
+===== array-fold-right
 <procedure>(array-fold-right kons knil array)</procedure>
 
@@ -1186 +1248 @@
 It is an error if {{array}} is not an array, or if {{kons}} is not a procedure.
 
+===== array-reduce
 <procedure>(array-reduce op A)</procedure>
 
@@ -1225 +1288 @@
 Since $\pi^2/6\approx{}${{1.6449340668482264}}, we see using the first method that the difference $\pi^2/6-{}${{1.644934057834575}}${}\approx{}${{9.013651380840315e-9}} and with the second we have $\pi^2/6-{}${{1.6449340658482325}}${}\approx{}${{9.99993865491433e-10}}. The true difference should be between $\frac 1{1{,}000{,}000{,}001}\approx{}${{9.99999999e-10}} and $\frac 1{1{,}000{,}000{,}000}={}${{1e-9}}. The difference for the first method is about 10 times too big, and, in fact, will not change further because any further terms, when added to the partial sum, are too small to increase the sum after rounding-to-nearest in double-precision IEEE-754 floating-point arithmetic.
 
+===== array-any
 <procedure>(array-any pred array1 array2 ...)</procedure>
 
@@ -1241 +1305 @@
 It is an error if the arguments do not satisfy these assumptions.
 
+===== array-every
 <procedure>(array-every pred array1 array2 ...)</procedure>
 
@@ -1257 +1322 @@
 It is an error if the arguments do not satisfy these assumptions.
 
+===== array->list
 <procedure>(array->list array)</procedure>
 
@@ -1263 +1329 @@
 It is guaranteed that {{(array-getter array)}} is called precisely once for each multi-index in {{(array-domain array)}} in lexicographical order.
 
+===== list->array
 <procedure>(list->array l domain [ result-storage-class generic-storage-class ] [ mutable? (specialized-array-default-mutable?) ] [ safe? (specialized-array-default-safe?) ])</procedure>
 
@@ -1271 +1338 @@
 It is an error if the arguments do not satisfy these assumptions, or if any element of {{l}} cannot be stored in the body of {{result-storage-class}}, and this last error shall be detected and raised.
 
+===== array-assign!
 <procedure>(array-assign! destination source)</procedure>
 
@@ -1285 +1353 @@
 '''Note:''' If the domains of {{destination}} and {{source}} are not the same, one can think of {{destination}} as a ''reshaped'' copy of {{source}}.
 
+===== array-ref
 <procedure>(array-ref A i0 . i-tail)</procedure>
 
@@ -1293 +1362 @@
 It is an error if {{A}} is not an array, or if the number of arguments specified is not the correct number for {{(array-getter A)}}.
 
+===== array-set!
 <procedure>(array-set! A v i0 . i-tail)</procedure>
 
@@ -1305 +1375 @@
 '''Note:''' In the sample implementation, checking whether the multi-indices are exact integers and within the domain of the array, and checking whether the value is appropriate for storage into the array, is delegated to the underlying definition of the array argument. If the first argument is a safe specialized array, then these items are checked; if it is an unsafe specialized array, they are not. If it is a generalized array, it is up to the programmer whether to define the getter and setter of the array to check the correctness of the arguments.
 
+===== specialized-array-reshape
 <procedure>(specialized-array-reshape array new-domain [ copy-on-failure? #f ])</procedure>