![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Description2 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / B / doc|
Return to Description2 CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / B / doc |
1.1 root 1: .\" Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984.
2: .St 6 "EXPRESSIONS, TARGETS AND TESTS"
3: .Se 3 6.1 EXPRESSIONS
4: .Xx scratch-pad copy
5: .Xx compound
6: .Tx
7: In \*B, the evaluation of an expression cannot alter the values of targets
8: that currently exist, nor can it create new targets that survive the expression.
9: If an expression appears to alter a target, it effectively modifies
10: a local ``scratch-pad''
11: \fIcopy\fP of that target, and the change is invisible outside the expression.
12: .Sy 3
13: .Pr expression 4
14: .Al
15: single-expression
16: .Al
17: multiple-expression
18: .Pr single-expression 3
19: .Al
20: basic-expression
21: .Al
22: \*(<:(\*(:> expression \*(<:)\*(:>
23: .Pr basic-expression 3
24: .Al
25: simple-expression
26: .Al
27: formula
28: .Pr simple-expression 7
29: .Al
30: constant
31: .Al
32: target-content
33: .Al
34: trimmed-text
35: .Al
36: table-selection
37: .Al
38: display
39: .Al
40: refined-expression
41: .Pr tight-expression 3
42: .Al
43: simple-expression
44: .Al
45: zeroadic-formula
46: .Al
47: \*(<:(\*(:> expression \*(<:)\*(:>
48: .Pr right-expression 3
49: .Al
50: tight-expression
51: .Al
52: monadic-formula
53: .Eo 6 basic-:\0\0\k2simple-:\0\k3tight-:\0\0\0\0\k4right-expressions:
54: \h'|\n1u'\*(<:a\*(:> \h'|\n2u'\*(<:a\*(:> \h'|\n3u'\*(<:a\*(:> \h'|\n4u'\*(<:a\*(:>
55: \h'|\n1u'\*(<:-a\*(:> \h'|\n4u'\*(<:-a\*(:>
56: \h'|\n1u'\*(<:a+b\*(:>
57: \h'|\n3u'\*(<:(a+b)\*(:> \h'|\n4u'\*(<:(a+b)\*(:>
58: .Xe
59: .Tx
60: The various kinds of expressions that are distinguished here
61: serve to define the syntax
62: in such a way that no parentheses are needed where the meaning is
63: sufficiently clear.
64: .Pr multiple-expression 1
65: .Al
66: single-expression\*(<:,\*(:> single-expression
67: .Al
68: single-expression\*(<:,\*(:> multiple-expression
69: .Ex 3
70: \k1multiple-expressions:
71: \h'|\n1u'\*(<:1, 'abc'\*(:>
72: \h'|\n1u'\*(<:(1, 0), (0, 1), (-1, 0), (0, -1)\*(:>
73: .Xe
74: .Tx
75: The value of a multiple-expression composed of single-expressions
76: separated by commas
77: is the compound whose fields are the values of the
78: successive single-expressions.
79: .Se 3 6.1.1 NUMERIC-CONSTANTS
80: .Sy 3
81: .Pr numeric-constant 3
82: .Al
83: exact-constant
84: .Al
85: approximate-constant
86: .Pr exact-constant 3
87: .Al
88: integral-part\0optional-fractional-part
89: .Al
90: integral-part \*(<:.\*(:>
91: .Al
92: fractional-part
93: .Pr integral-part 3
94: .Al
95: digit
96: .Al
97: integral-part\0digit
98: .Pr digit 2
99: .Al
100: \*(<:0\*(:>
101: .Al
102: \*(<:1\*(:>
103: .Al
104: \*(<:2\*(:>
105: .Al
106: \*(<:3\*(:>
107: .Al
108: \*(<:4\*(:>
109: .Al
110: \*(<:5\*(:>
111: .Al
112: \*(<:6\*(:>
113: .Al
114: \*(<:7\*(:>
115: .Al
116: \*(<:8\*(:>
117: .Al
118: \*(<:9\*(:>
119: .Pr fractional-part 3
120: .Al
121: \&\*(<:.\*(:> digit
122: .Al
123: fractional-part\0digit
124: .Pr approximate-constant 2
125: .Sl
126: exact-constant\0exponent-part
127: .Pr exponent-part 2
128: .Sl
129: \*(<:E\*(:> optional-plusminus\0integral-part
130: .Pr plusminus 2
131: .Al
132: \*(<:+\*(:>
133: .Al
134: \*(<:-\*(:>
135: .Eo 5 exact-constants:\0\0\0\0\0\0\k2approximate-constants:
136: \h'|\n1u'\*(<:666\*(:> \h'|\n2u'\*(<:2.99793E8\*(:>
137: \h'|\n1u'\*(<:666.\*(:> \h'|\n2u'\*(<:2.99793E+8\*(:>
138: \h'|\n1u'\*(<:3.14\*(:> \h'|\n2u'\*(<:1E-9\*(:>
139: .Xe
140: .Tx
141: The value of an exact-constant is an exact number.
142: For example, \*(<:1.25\*(:> stands for the exact number \*(<:5/4\*(:>.
143: The value of an approximate-constant is an approximate number.
144: The exponent-part gives the power of ten in floating-point notation.
145: For example, \*(<:1.2345E2\*(:> and \*(<:~123.45\*(:> are (approximately) the same,
146: because \*(<:123.45 = 1.2345*10**2\*(:>.
147: .Se 2 6.1.2 TARGET-CONTENTS
148: .Sy 2
149: .Pr target-content 2
150: .Sl
151: tag
152: .Tx
153: The value of a target-content is the value last put in the target whose
154: name is the given tag.
155: .Se 2 6.1.3 TRIMMED-TEXTS
156: .Xx integer
157: .Sy 2
158: .Pr trimmed-text 2
159: .Al
160: tight-expression \*(<:@\*(:> right-expression
161: .Al
162: tight-expression \*(<:|\*(:> right-expression
163: .Ps
164: .Ex 6
165: \k1trimmed-texts:
166: \h'|\n1u'\*(<:t@p\*(:>
167: \h'|\n1u'\*(<:t|1\*(:>
168: \h'|\n1u'\*(<:t|q@p\*(:>
169: \h'|\n1u'\*(<:t@p|(q-p+1)\*(:>
170: .Xe
171: .Tx
172: The value of the tight-expression must be a text T, and that
173: of the right-expression must be an integer N.
174: .br
175: If the sign between the expressions is \*(<:@\*(:>, then the value of
176: the trimmed-text is that of T after removing the first N\(mi1 characters.
177: For example, \*(<:'lamplight'@4 = 'plight'\*(:>.
178: N must be at least 1 and at most one more than the length of T.
179: .br
180: If the sign between the expressions is \*(<:|\*(:>, then the value of
181: the trimmed-text is the text consisting of the first N characters of T.
182: For example, \*(<:'scarface'|5 = 'scarf'\*(:>.
183: N must be at least 0 and at most equal to the length of T.
184: .br
185: Note that the tight-expression itself may be a trimmed-text
186: again.
187: For example, \*(<:'department'|6@3 = 'depart'@3 = 'part'\*(:>.
188: .Se 3 6.1.4 TABLE-SELECTIONS
189: .Xx key
190: .Xx associate
191: .Xx table entry
192: .Sy 3
193: .Pr table-selection 3
194: .Sl
195: tight-expression \*(<:[\*(:> expression \*(<:]\*(:>
196: .Sx 2 table-selection:
197: \*(<:t[i, j]\*(:>
198: .Xe
199: .Tx
200: The value of the tight-expression must be a table T, and
201: the value of the expression between the square brackets must
202: be a key K of T.
203: The value of the table-selection is then the associate of
204: the table entry in T whose key is K.
205: .Se 3 6.1.5 DISPLAYS
206: .Xx integer
207: .Xx character
208: .Xx quote
209: .Xx convert to a text
210: .Xx ambiguity
211: .Xx empty list
212: .Xx empty table
213: .Xx key
214: .Xx associate
215: .Sy 3
216: .Pr display 4
217: .Al
218: text-display
219: .Al
220: list-display
221: .Al
222: table-display
223: .Pr text-display 3
224: .Al
225: \&\*(<:'\*(:> optional-text-body \*(<:'\*(:>
226: .Al
227: \*(<:"\*(:> optional-text-body \*(<:"\*(:>
228: .Ps
229: The text-displays \*(<:''\*(:> and \*(<:""\*(:> stand for the empty text.
230: A text-body may be any sequence of printable characters
231: (see section 1 under `Texts')
232: and conversions
233: (see below).
234: However, in a text-display in the \*(<:'\*(:>\^...\^\*(<:'\*(:> style,
235: any single quote \*(<:'\*(:> in the text must be written twice to give \*(<:''\*(:>.
236: Otherwise, it will signal the end of the text-display.
237: Similarly, in a text-display in the \*(<:"\*(:>\^...\^\*(<:"\*(:> style,
238: any double quote \*(<:"\*(:> in the text must be written twice to give \*(<:""\*(:>.
239: Finally, the back-quote \*(<:`\*(:> must be written twice too, giving \*(<:``\*(:>.
240: Otherwise, it signals a conversion.
241: .Pr conversion 2
242: .Sl
243: \*(<:`\*(:> expression \*(<:`\*(:>
244: .Ps
245: The requirement that some signs be written twice does not hold
246: \fIinside\fP a conversion.
247: For example, \*(<:'`t['a']`'\*(:> is proper, whereas \*(<:'`t[''a'']`'\*(:> is not.
248: .Eo 6 text-displays:
249: \h'|\n1u'\*(<:''\*(:>
250: \h'|\n1u'\*(<:'He said: "Don''t!"'\*(:>
251: \h'|\n1u'\*(<:"He said: ""Don't!"""\*(:>
252: \h'|\n1u'\*(<:'altitude is `a/1E3` km'\*(:>
253: .Xe
254: .Tx
255: The value of a text-display is the text composed of the
256: characters given between the enclosing text quotes.
257: If the text-display contains conversions, the expressions of
258: these conversions are evaluated first and converted to a
259: text in the same way as for a write-command.
260: For example,
261: since
262: .Di 1
263: \*(<:WRITE 239*4649\*(:>
264: .Ed
265: causes the text \*(<:1111111\*(:> to be written,
266: the text-display
267: .Di 1
268: \&\*(<:'239 times 4649 gives `239*4649`'\*(:>
269: .Ed
270: is equivalent to
271: .Di 1
272: \&\*(<:'239 times 4649 gives 1111111'\*(:>.
273: .Ed
274: The quotes and conversion-signs that had to be written twice
275: according to the above rules correspond to one character of
276: the resulting text.
277: For example, the number of characters in \*(<:'x''y""z'\*(:> is 6,
278: because it consists of one \*(<:x\*(:>, \fIone\fP \*(<:'\*(:> character,
279: one \*(<:y\*(:>, \fItwo\fP \*(<:"\*(:> characters, and finally one \*(<:z\*(:>.
280: Another way to specify the same text is \*(<:"x'y""""z"\*(:>.
281: .Pr list-display 2
282: .Sl
283: \*(<:{\*(:> optional-list-body \*(<:}\*(:>
284: .Pr list-body 5
285: .Al
286: list-filler-series
287: .Al
288: single-expression \*(<:..\*(:> single-expression
289: .Ps
290: The ambiguity in, e.g., \*(<:{1...9}\*(:>, is resolved by parsing it
291: as \*(<:{1. .. 9}\*(:>.
292: .Pr list-filler-series 2
293: .Al
294: list-filler
295: .Al
296: list-filler\*(<:;\*(:> list-filler-series
297: .Pr list-filler 2
298: .Sl
299: single-expression
300: .Eo 6 list-displays:
301: \h'|\n1u'\*(<:{}\*(:>
302: \h'|\n1u'\*(<:{x1; x2; x3}\*(:>
303: \h'|\n1u'\*(<:{1..n-1}\*(:>
304: \h'|\n1u'\*(<:{'a'..'z'}\*(:>
305: .Xe
306: .Tx
307: The value of \*(<:{}\*(:> is an empty list.
308: (It may also be an empty table; see below.)
309: .br
310: The value of a list-display containing list-fillers is the
311: list whose entries are the values of those list-fillers.
312: If values occur multiply, they give rise to multiple entries
313: in the list.
314: .br
315: For a list-display of the form \*(<:{\*(:>p\*(<:..\*(:>q\*(<:}\*(:>, p and q must both be
316: integers, or both be characters (texts of length one).
317: The resulting value is then the list of all integers
318: or characters x such that p\ \(<= x\ \(<=\ q.
319: For example, \*(<:{1..4} = {1; 2; 3; 4}\*(:> and \*(<:{'a'..'c'} = {'a'; 'b'; 'c'}\*(:>.
320: .br
321: If p\ >\ q, the list is empty, but this is only allowed if p
322: and q are adjacent.
323: If there is an intervening integer or character x (such that
324: p\ >\ x\ >\ q), an error is reported.
325: .Pr table-display 2
326: .Sl
327: \*(<:{\*(:> optional-table-filler-series \*(<:}\*(:>
328: .Pr table-filler-series 2
329: .Al
330: table-filler
331: .Al
332: table-filler\*(<:;\*(:> table-filler-series
333: .Pr table-filler 2
334: .Sl
335: \*(<:[\*(:> expression \*(<:] :\*(:> single-expression
336: .Eo 6 table-displays:
337: \h'|\n1u'\*(<:{}\*(:>
338: \h'|\n1u'\*(<:{[i, j]: 0}\*(:>
339: \h'|\n1u'\*(<:{[0]: {}; [1]: {0}}\*(:>
340: \h'|\n1u'\*(<:{[name]: (month, day, year)}\*(:>
341: .Xe
342: .Tx
343: The table-display \*(<:{}\*(:> stands for an empty table.
344: Otherwise, each table-filler gives a table entry with key K
345: and associate A, where K is the value of the expression
346: between square brackets, and A is the value of the
347: single-expression following the colon.
348: The result is then the table containing these table
349: entries.
350: .br
351: If there are \fIdifferent\fP table entries with the same
352: key, an error is reported.
353: Multiple occurrences of the \fIsame\fP table entry, however,
354: are allowed.
355: The extra occurrences are then simply discarded.
356: .Se 2 6.1.6 FORMULAS
357: .Xx formula
358: .Xx function
359: .Xx ambiguity
360: .Xx parentheses
361: .Xx brackets
362: .Xx priority
363: .Xx user-defined-function
364: .Xx yield-unit
365: .Xx target
366: .Xx scratch-pad copy
367: .Xx local
368: .Xx return-command
369: .Xx predefined functions
370: .Xx number
371: .Xx denominator
372: .Xx numerator
373: .Xx text
374: .Xx convert to a text
375: .Xx text, list and table
376: .Xx key
377: .Xx character
378: .Xx associate
379: .Xx list entry
380: .Xx integer
381: .Sy 2
382: .Pr zeroadic-formula 2
383: .Sl
384: zeroadic-function
385: .Pr monadic-formula 2
386: .Sl
387: monadic-function\0actual-operand
388: .Pr dyadic-formula 2
389: .Al
390: actual-operand\0dyadic-function\0actual-operand
391: .Ps
392: The parsing ambiguities introduced by these rules
393: are resolved by priority rules, as follows:
394: .in +\w'2.\ 'u
395: .ti -\w'2.\ 'u
396: 1.\ If there is no parsing ambiguity (as in \*(<:1 + sin x\*(:>),
397: no parentheses are needed.
398: .ti -\w'2.\ 'u
399: 2.\ If the order makes no difference (as in \*(<:a*b*c\*(:>, \*(<:a*b/c\*(:> or
400: \*(<:a^b^c\*(:>), no parentheses are needed.
401: .ti -\w'2.\ 'u
402: 3.\ The five arithmetic functions
403: \*(<:**\*(:>, \*(<:*\*(:>, \*(<:/\*(:>, \*(<:+\*(:> and \*(<:-\*(:>
404: have their traditional priority rules:
405: .in +4
406: \*(<:**\*(:> comes before \*(<:*\*(:>, \*(<:/\*(:>, \*(<:+\*(:> and \*(<:-\*(:>;
407: .br
408: \*(<:*\*(:> and \*(<:/\*(:> come before \*(<:+\*(:> and \*(<:-\*(:>;
409: .br
410: combinations of \*(<:+\*(:> and \*(<:-\*(:> are computed from left to right.
411: .in -4
412: Note, however, that \*(<:a**b**c\*(:>, \*(<:a/b*c\*(:> and \*(<:a/b/c\*(:> are wrong.
413: .ti -\w'2.\ 'u
414: 4.\ The function \*(<:#\*(:> has a high priority, higher than the
415: five arithmetic functions, and the function \*(<:~\*(:> has a
416: higher priority than all other functions.
417: .ti -\w'2.\ 'u
418: 5.\ All other functions,
419: in particular \*(<:^\*(:>, \*(<:^^\*(:>, \*(<:<<\*(:>, \*(<:><\*(:>, \*(<:>>\*(:>
420: and all tags (like \*(<:sin\*(:> or \*(<:floor\*(:>) have no established priority and
421: may be used
422: .in +4
423: .ti -\w'\(em\ 'u
424: \(em\ having formulas as operands only if these operands
425: are parenthesized (except as in, e.g., \*(<:exp -x\*(:>, because of
426: point 1 above, or as in \*(<:~1>>20\*(:> because of point 4);
427: .ti -\w'\(em\ 'u
428: \(em\ in operands of other formulas only if these operands are
429: parenthesized (except as above).
430: .in -4
431: .in -\w'2.\ 'u
432: .Bl 3
433: None of
434: \*(<:a/b/c\*(:>, \*(<:a/b*c\*(:> and \*(<:sin x+y\*(:>
435: is a correct formula.
436: Each of these can be made correct by inserting parentheses,
437: depending on the intention:
438: either \*(<:(a/b)/c\*(:> or \*(<:a/(b/c)\*(:>,
439: either \*(<:(a/b)*c\*(:> or \*(<:a/(b*c)\*(:>,
440: and either \*(<:(sin x) + y\*(:> or \*(<:sin(x+y)\*(:>.
441: Note that because of point 5 above
442: \*(<:sin(x)+1\*(:> is just as wrong as \*(<:sin x + 1\*(:>,
443: in spite of what other programming languages might lead you to expect.
444: .br
445: The function \*(<:#\*(:> has been given
446: a high priority since expressions like \*(<:#t+1\*(:> are so common,
447: that it would be a nuisance to have to parenthesize these,
448: and more so since \*(<:#(t+1)\*(:> is meaningless anyway.
449: The reason for the high priority of the function \*(<:~\*(:> is
450: to make
451: \*(<:~0\*(:>, for example, for all practical purposes behave as a constant.
452: .Pr zeroadic-function 2
453: .Sl
454: tag
455: .Pr monadic-function 6
456: .Al
457: \*(<:~\*(:>
458: .Al
459: \*(<:+\*(:>
460: .Al
461: \*(<:-\*(:>
462: .Al
463: \*(<:*/\*(:>
464: .Al
465: \*(<:/*\*(:>
466: .Al
467: \*(<:#\*(:>
468: .Al
469: tag
470: .Pr dyadic-function 3
471: .Al
472: \*(<:+\*(:>
473: .Al
474: \*(<:-\*(:>
475: .Al
476: \*(<:*\*(:>
477: .Al
478: \*(<:/\*(:>
479: .Al
480: \*(<:**\*(:>
481: .Al
482: \*(<:^\*(:>
483: .Al
484: \*(<:^^\*(:>
485: .Al
486: \*(<:<<\*(:>
487: .Al
488: \*(<:><\*(:>
489: .Al
490: \*(<:>>\*(:>
491: .Al
492: \*(<:#\*(:>
493: .Al
494: tag
495: .Pr actual-operand 3
496: .Sl
497: single-expression
498: .Eo 3 zeroadic-formula:\0\0\0\k2monadic-formula:\0\0\0\k3dyadic-formula:
499: \h'|\n1u'\*(<:pi\*(:> \h'|\n2u'\*(<:atan(y/x)\*(:> \h'|\n3u'\*(<:x atan y\*(:>
500: .Xe
501: .Us 7 Formulas with user-defined functions
502: A formula whose function is defined by a yield-unit, is
503: evaluated in the following steps:
504: .in \w'2.\ 'u
505: .ti 0
506: 1.\ A copy is made of the current environment (the value of
507: all targets), and all computations during the evaluation of
508: the formula will take place in this ``scratch-pad copy''.
509: .ti 0
510: 2.\ Any local tags in the yield-unit that might clash with tags currently
511: in use are systematically replaced by other tags that do not cause conflict.
512: .ti 0
513: 3.\ Each actual-operand is evaluated and put in the
514: corresponding formal-operand, used as a (new)
515: target.
516: .ti 0
517: 4.\ The command-suite of the unit, thus modified, is executed.
518: .in 0
519: The evaluation of the formula is complete when the execution
520: of this command-suite terminates because of the execution of a return-command;
521: the value of the formula is the value returned.
522: .Us 7 Formulas with predefined functions
523: .de Qr
524: .sp 1
525: .in 0
526: .ne 3
527: ..
528: .de Qe
529: .br
530: .sp -1
531: .in 7m
532: ..
533: .Us 0 A. Functions on numbers
534: .Qr
535: \*(<:~x\*(:>
536: .Qe
537: returns an approximate number, as close as possible
538: in arithmetic magnitude to \*(<:x\*(:>.
539: .Qr
540: \*(<:x+y\*(:>
541: .Qe
542: returns the sum of \*(<:x\*(:> and \*(<:y\*(:>.
543: The result is exact if both operands are exact.
544: .Qr
545: \*(<:+x\*(:>
546: .Qe
547: returns the value of \*(<:x\*(:>.
548: .Qr
549: \*(<:x-y\*(:>
550: .Qe
551: returns the difference of \*(<:x\*(:> and \*(<:y\*(:>.
552: The result is exact if both operands are exact.
553: .Qr
554: \*(<:-x\*(:>
555: .Qe
556: returns minus the value of \*(<:x\*(:>.
557: The result is exact if the operand is exact.
558: .Qr
559: \*(<:x*y\*(:>
560: .Qe
561: returns the product of \*(<:x\*(:> and \*(<:y\*(:>.
562: The result is exact if both operands are exact.
563: .Qr
564: \*(<:x/y\*(:>
565: .Qe
566: returns the quotient of \*(<:x\*(:> and \*(<:y\*(:>.
567: The value of \*(<:y\*(:> must not be zero.
568: The result is exact if both operands are exact.
569: .Qr
570: \*(<:x**y\*(:>
571: .Qe
572: returns \*(<:x\*(:> to the power \*(<:y\*(:>.
573: The result is exact if \*(<:x\*(:> is exact and \*(<:y\*(:> is an integer.
574: If \*(<:x\*(:> is negative,
575: \*(<:y\*(:> must be an integer or an exact number with an odd denominator.
576: If \*(<:x\*(:> is zero,
577: \*(<:y\*(:> must not be negative.
578: If \*(<:y\*(:> is zero, the result is one (exact or approximate).
579: .Qr
580: \*(<:n root x\*(:>
581: .Qe
582: returns the same as \*(<:x**(1/n)\*(:>.
583: .Qr
584: \*(<:root x\*(:>
585: .Qe
586: returns the same as \*(<:2 root x\*(:>, the square root of \*(<:x\*(:>.
587: .Qr
588: \*(<:abs x\*(:>
589: .Qe
590: returns the absolute value of \*(<:x\*(:>.
591: The result is exact if the operand is exact.
592: .Qr
593: \*(<:sign x\*(:>
594: .Qe
595: returns \(mi1 if \*(<:x\*(:> is negative, 0 if \*(<:x\*(:> is zero, and 1 otherwise.
596: .Qr
597: \*(<:floor x\*(:>
598: .Qe
599: returns the largest integer not exceeding \*(<:x\*(:> in arithmetic
600: magnitude.
601: .Qr
602: \*(<:ceiling x\*(:>
603: .Qe
604: returns the same as \*(<:- floor -x\*(:>.
605: .Qr
606: \*(<:n round x\*(:>
607: .Qe
608: returns the same as \*(<:(10**-n)*floor(x*10**n+.5)\*(:>.
609: For example, \*(<:4 round pi = 3.1416\*(:>.
610: The value of \*(<:n\*(:> must be an integer.
611: It may be negative: \*(<:(-2) round 666 = 700\*(:>.
612: .Qr
613: \*(<:round x\*(:>
614: .Qe
615: returns the same as \*(<:0 round x\*(:>.
616: .Qr
617: \*(<:a mod n\*(:>
618: .Qe
619: returns the same as \*(<:a-n*floor(a/n)\*(:>,
620: that is, the remainder after dividing \*(<:a\*(:> by \*(<:n\*(:>.
621: (Both operands may be approximate, and \*(<:n\*(:> may be negative, but not zero.)
622: .Qr
623: \*(<:/*x\*(:>
624: .Qe
625: returns the ``denominator'' of \*(<:x\*(:>,
626: that is, regarding \*(<:x\*(:> as the fraction \*(<:p/q\*(:>,
627: the smallest positive integer \*(<:q\*(:> such that \*(<:q*x\*(:> is an integer.
628: The value of \*(<:x\*(:> must be an exact number.
629: .Qr
630: \*(<:*/x\*(:>
631: .Qe
632: returns the corresponding ``numerator'' with the same sign as \*(<:x\*(:>,
633: the same integer as \*(<:(/*x)*x\*(:>.
634: So, if \*(<:x\*(:> is exact, \*(<:x = (*/x)/(/*x)\*(:>.
635: .Qr
636: \*(<:pi\*(:>
637: .Qe
638: returns approximately \*(<:3.1415926535\*(:>...
639: .Qr
640: \*(<:sin x\*(:>
641: .Qe
642: returns an approximate number by applying the sine function to \*(<:x\*(:>,
643: with \*(<:x\*(:> in radians.
644: .Qr
645: \*(<:cos x\*(:>
646: .Qe
647: returns an approximate number by applying the cosine function to \*(<:x\*(:>,
648: with \*(<:x\*(:> in radians.
649: .Qr
650: \*(<:tan x\*(:>
651: .Qe
652: returns the same as \*(<:(sin x) / (cos x)\*(:>.
653: .Qr
654: \*(<:x atan y\*(:>
655: .Qe
656: returns an approximate number \*(<:phi\*(:>, in the range from (about)
657: \*(<:-pi\*(:> to \*(<:+pi\*(:>, such that
658: \*(<:x\*(:> is approximated by \*(<:r * cos phi\*(:>
659: and \*(<:y\*(:> by \*(<:r * sin phi\*(:>, where \*(<:r = root(x*x+y*y)\*(:>.
660: The operands must not both be zero.
661: .Qr
662: \*(<:atan x\*(:>
663: .Qe
664: returns the same as \*(<:1 atan x\*(:>.
665: .Qr
666: \*(<:e\*(:>
667: .Qe
668: returns approximately \*(<:2.7182818284\*(:>...
669: .Qr
670: \*(<:exp x\*(:>
671: .Qe
672: returns approximately the same as \*(<:e**x\*(:>.
673: .Qr
674: \*(<:log x\*(:>
675: .Qe
676: returns an approximate number by applying the natural logarithm function
677: (with base \*(<:e\*(:>)
678: to \*(<:x\*(:>.
679: The value of \*(<:x\*(:> must be positive.
680: .Qr
681: \*(<:b log x\*(:>
682: .Qe
683: returns the same as \*(<:(log x) / (log b)\*(:>,
684: that is, the logarithm with base \*(<:b\*(:> of \*(<:x\*(:>.
685: .Us 7 B. Functions on texts
686: .Qr
687: \*(<:t^u\*(:>
688: .Qe
689: returns the text consisting of \*(<:t\*(:> and \*(<:u\*(:> joined.
690: For example, \*(<:'now'^'here' = 'nowhere'\*(:>.
691: .Qr
692: \*(<:t^^n\*(:>
693: .Qe
694: returns the text consisting of \*(<:n\*(:> copies of \*(<:t\*(:> joined together.
695: For \pexample, \*(<:'Fi! '^^3 = 'Fi! Fi! Fi! '\*(:>.
696: The value of \*(<:n\*(:> must be an integer and not negative.
697: .Qr
698: \*(<:x<<n\*(:>
699: .Qe
700: converts \*(<:x\*(:> to a text and adds space characters to
701: the right until the length is \*(<:n\*(:>.
702: For example, \*(<:123<<6 = '123 '\*(:>.
703: In no case is the text truncated; if \*(<:n\*(:> is too small,
704: the resulting text is as long as necessary.
705: The value of \*(<:n\*(:> must be an integer, but \*(<:x\*(:> may be of any type.
706: See write-commands, section 5.1.2, for details about converting values to
707: texts.
708: .Qr
709: \*(<:x><n\*(:>
710: .Qe
711: converts \*(<:x\*(:> to a text and adds space characters to
712: the right and to the left, in turn, until the length is \*(<:n\*(:>.
713: For example, \*(<:123><6 = ' 123 '\*(:>.
714: In no case is the text truncated.
715: The value of \*(<:n\*(:> must be an integer, but \*(<:x\*(:> may be of any type.
716: .Qr
717: \*(<:x>>n\*(:>
718: .Qe
719: converts \*(<:x\*(:> to a text and adds space characters to
720: the left until the length is \*(<:n\*(:>.
721: For example, \*(<:123>>6 = ' 123'\*(:>.
722: In no case is the text truncated.
723: The value of \*(<:n\*(:> must be an integer, but \*(<:x\*(:> may be of any type.
724: .Bl 7
725: .Us 7 C. Functions on texts, lists and tables
726: .Qr
727: \*(<:keys t\*(:>
728: .Qe
729: requires a table as operand, and returns a list of all keys
730: in the table.
731: For example, \*(<:keys {[1]: 1; [4]: 2; [9]: 3} = {1; 4; 9}\*(:>.
732: .Qr
733: \*(<:#t\*(:>
734: .Qe
735: accepts texts, lists and tables.
736: For a text operand, its length is returned, and
737: for a list or table operand, the number of
738: entries is returned (where duplicates in lists are counted).
739: .Qr
740: \*(<:e#t\*(:>
741: .Qe
742: accepts texts, lists and tables for the right operand.
743: .br
744: For a text operand, the first operand must
745: be a character, and the number of times the character
746: occurs in the text is returned.
747: For example, \*(<:'i'#'mississippi' = 4\*(:>.
748: .br
749: For a list operand, the number of entries is returned
750: that are equal to the first operand
751: (which must be of the same type as the list entries.)
752: .br
753: For example, \*(<:3#{1; 3; 3; 4} = 2\*(:>.
754: .br
755: .??
756: For a table operand, the number of \fIassociates\fP is returned
757: that are equal to the first operand
758: (which must be of the same type as the associates in the table.)
759: For example, \*(<:3#{[1]: 3; [2]: 4; [3]: 3} = 2\*(:>.
760: .Qr
761: \*(<:min t\*(:>
762: .Qe
763: accepts texts, lists and tables.
764: For a text operand, its smallest (in the ASCII order) character is returned,
765: for a list operand, its smallest
766: entry is returned, and
767: for a table operand, its smallest
768: \fIassociate\fP
769: .??
770: is returned.
771: For example, \*(<:min 'uscule' = 'c'\*(:>,
772: \*(<:min{1; 3; 3; 4} = 1\*(:>, and
773: \*(<:min{[1]: 3; [2]: 4; [3]: 3} = 3\*(:>.
774: The text, list or table must not be empty.
775: .br
776: To get the smallest \fIkey\fP of a table \*(<:t\*(:>,
777: use \*(<:min keys t\*(:>.
778: .Qr
779: \*(<:e min t\*(:>
780: .Qe
781: accepts texts, lists and tables for the right operand.
782: .br
783: For a text operand,
784: the first operand
785: must
786: be a character, and the smallest character in the text
787: \fIexceeding\fP
788: that character is returned.
789: For example, \*(<:'i' min 'mississippi' = 'm'\*(:>.
790: .br
791: For a list operand, the smallest
792: entry is returned exceeding the first operand
793: (which must be of the same type as the list entries.)
794: For example, \*(<:3 min {1; 3; 3; 4} = 4\*(:>.
795: .br
796: For a table operand, the smallest associate
797: is returned exceeding the first operand
798: (which must be of the same type as the associates in the table.)
799: For example, \*(<:3 min {[1]: 3; [2]: 4; [3]: 3} = 4\*(:>.
800: .br
801: There must be a character, list entry or table associate exceeding
802: the first operand.
803: .Qr
804: \*(<:max t\*(:> and
805: .br
806: \*(<:e max t\*(:>
807: .Qe
808: .Qe
809: are like \*(<:min\*(:>, except that they return the largest
810: element, and in the dyadic case the largest element
811: that is less than the first operand.
812: For example, \*(<:'m' max 'mississippi' = 'i'\*(:>.
813: .Qr
814: \*(<:n th'of t\*(:>
815: .Qe
816: requires an integer in \*(<:{1..#t}\*(:> for the left operand, and
817: accepts texts, lists and tables for the right operand.
818: It returns the \*(<:n\*(:>'th character, list entry or associate.
819: .br
820: In fact, \*(<:n th'of t\*(:>, for a text \*(<:t\*(:>, is written as easily
821: \*(<:t@n|1\*(:>.
822: For a table, it is the same as \*(<:t[n th'of (keys t)]\*(:>,
823: which is something different from \*(<:t[n]\*(:>, unless,
824: of course, \*(<:keys t = {1..#t}\*(:>.
825: For a list,
826: \*(<:1 th'of t\*(:> is \*(<:min t\*(:>.
827: .Se 2 6.1.7 REFINED-EXPRESSIONS
828: .Xx expression-refinement
829: .Xx scratch-pad copy
830: .Xx return-command
831: .Sy 2
832: .Pr refined-expression 2
833: .Sl
834: tag
835: .Ps
836: The tag of a refined-expression must occur as
837: the tag of one
838: expression-refinement in the unit
839: in which it occurs.
840: .Sx 3 \k1refined-expression:
841: \*(<:stack'pointer\*(:>
842: .Xe
843: .Tx
844: A refined-expression is
845: evaluated in the following steps:
846: .in \w'2.\ 'u
847: .ti 0
848: 1.\ A copy is made of the current environment (the value of
849: all targets), and all computations during the evaluation of
850: the expression will take place in this ``scratch-pad copy''.
851: .ti 0
852: 2.\ The command-suite of the corresponding
853: expression-refinement is executed.
854: .in 0
855: The evaluation of the refined-expression is complete when the execution
856: of this command-suite terminates because of the execution of a return-command;
857: the value of the refined-expression is the value returned.
858: .Sa
859: expression-refinements (4.4).
860: .Se 4 6.2 TARGETS
861: .Xx compound
862: .Sy 4
863: .Pr target 4
864: .Al
865: single-target
866: .Al
867: multiple-target
868: .Pr single-target 3
869: .Al
870: basic-target
871: .Al
872: \*(<:(\*(:> target \*(<:)\*(:>
873: .Pr basic-target 4
874: .Al
875: tag
876: .Al
877: trimmed-text-target
878: .Al
879: table-selection-target
880: .Tx
881: For the use of a tag as target, see below under IDENTIFIERS.
882: For other kinds of targets, see below under the appropriate heading.
883: .Pr multiple-target 1
884: .Al
885: single-target\*(<:,\*(:> single-target
886: .Al
887: single-target\*(<:,\*(:> multiple-target
888: .Ex 3
889: \k1multiple-targets:
890: \h'|\n1u'\*(<:nn, t2\*(:>
891: \h'|\n1u'\*(<:(x0, y0), (x1, y1), (x2, y2), (x3, y3)\*(:>
892: .Xe
893: .Tx
894: If a value is put in a multiple-target, the value must be
895: a compound with as many fields as there are single-targets
896: separated by commas in the multiple-target.
897: The successive fields are then put in the
898: successive single-targets.
899: If it makes a difference in what order the fields are put in
900: the single-targets (as in \*(<:PUT 1, 2 IN x, x\*(:>
901: where the final value of \*(<:x\*(:> might be either \*(<:1\*(:> or \*(<:2\*(:>),
902: an error is reported {{but this is currently not checked}}.
903: .br
904: Note that the meaning of \*(<:PUT a, b IN b, a\*(:>
905: is well defined (provided that \*(<:a\*(:> and \*(<:b\*(:> are defined and have
906: values of the same type):
907: first the value of the expression \*(<:a, b\*(:> is determined,
908: and that value is next put in \*(<:b, a\*(:>.
909: Note also that the meaning of \*(<:PUT t[i], t[j] IN t[j], t[i]\*(:>
910: is well defined, even if \*(<:i\*(:> and \*(<:j\*(:> have the same value.
911: For although in this case a value is put twice in the same
912: target, that value is the same each time, so the order does not matter.
913: .Se 2 6.2.1 IDENTIFIERS
914: .Xx tag
915: .Xx target
916: .Xx location
917: .Xx local
918: .Sy 2
919: .Pr identifier 4
920: .Al
921: single-identifier
922: .Al
923: multiple-identifier
924: .Pr single-identifier 3
925: .Al
926: tag
927: .Al
928: \*(<:(\*(:> identifier \*(<:)\*(:>
929: .Pr multiple-identifier 1
930: .Al
931: single-identifier\*(<:,\*(:> single-identifier
932: .Al
933: single-identifier\*(<:,\*(:> multiple-identifier
934: .Eo 6 identifiers:\0\0\0\0\0\0\0\0\0\0\0\k2single-identifiers:
935: \h'|\n1u'\*(<:a\*(:>\h'|\n2u'\*(<:a\*(:>
936: \h'|\n1u'\*(<:(a)\*(:>\h'|\n2u'\*(<:(a)\*(:>
937: \h'|\n1u'\*(<:(a, b, (c, d))\*(:>\h'|\n2u'\*(<:(a, b, (c, d))\*(:>
938: \h'|\n1u'\*(<:a, b, (c, d)\*(:>
939: .Xe
940: .Tx
941: All identifiers can be used as targets, but the converse is
942: not true.
943: For example,
944: .Di 1
945: \*(<:FOR a[1] IN {1..3}: WRITE a\*(:>
946: .Ed
947: is wrong, because \*(<:a[1]\*(:>, although a target, is not an identifier.
948: If something is put in a target that is a tag, and no
949: location for that tag exists already, it is created first.
950: If the location is created locally (the tag did not occur in
951: an immediate command and was not listed in a share-heading),
952: the location will cease to exist when the current unit is exited.
953: For putting in multiple-identifiers, see multiple-targets in section 6.2.
954: .Se 2 6.2.2 TRIMMED-TEXT-TARGETS
955: .Sy 2
956: .Pr trimmed-text-target 3
957: .Al
958: target \*(<:@\*(:> right-expression
959: .Al
960: target \*(<:|\*(:> right-expression
961: .Ps\"(The \*(<:|\*(:> in the last line is not the BNF choice indicator, but should be takenliterally.)
962: .Ex 6
963: \k1trimmed-text-targets:
964: \h'|\n1u'\*(<:t@p\*(:>
965: \h'|\n1u'\*(<:t|1\*(:>
966: \h'|\n1u'\*(<:t|q@p\*(:>
967: \h'|\n1u'\*(<:t@p|(q-p+1)\*(:>
968: .Xe
969: .Tx
970: The target must hold a text T, and the value
971: of the right-expression must be an integer N.
972: .br
973: If the sign used is \*(<:@\*(:>, then the
974: trimmed-text-target indicates a location consisting of the
975: positions of T starting with the N'th position.
976: N must be at least 1 and at most one more than the length of T.
977: For example, after
978: .Di 2
979: \*(<:PUT 'computer' IN tt
980: PUT 'ass' IN tt@5\*(:>
981: .Ed
982: \*(<:tt\*(:> will contain the text \*(<:'compass'\*(:>.
983: .br
984: If the sign used is \*(<:|\*(:>, then the
985: trimmed-text-target indicates a location
986: consisting of the first N characters of T.
987: N must be at least 0 and at most equal to the length of T.
988: For example, after
989: .Di 2
990: \*(<:PUT 'computer' IN tt
991: PUT 'ne' IN tt|4\*(:>
992: .Ed
993: \*(<:tt\*(:> will contain the text \*(<:'neuter'\*(:>.
994: .Bl 1
995: Note that the target itself may be a trimmed-text-target
996: again.
997: For example, after
998: .Di 2
999: \*(<:PUT 'computer' IN tt
1000: PUT 'm' IN tt@4|1\*(:>
1001: .Ed
1002: \*(<:tt\*(:> will contain the text \*(<:'commuter'\*(:>.
1003: .br
1004: Some useful special cases: \*(<:PUT '' IN t|1\*(:>
1005: removes the first character of the text in \*(<:t\*(:>;
1006: .br
1007: \*(<:PUT '.' IN t@(#t+1)\*(:>
1008: appends a period to the text in \*(<:t\*(:>.
1009: .Se 2 6.2.3 TABLE-SELECTION-TARGETS
1010: .Xx key
1011: .Xx associate
1012: .Xx table entry
1013: .Xx location
1014: .Xx type
1015: .Sy 2
1016: .Pr table-selection-target 2
1017: .Sl
1018: target \*(<:[\*(:> expression \*(<:]\*(:>
1019: .Sx 3 \k1table-selection-target:
1020: \*(<:t[i, j]\*(:>
1021: .Xe
1022: .Tx
1023: The target must contain a table.
1024: The value of the expression is a key K, to be used as selector.
1025: For each key in the table, there is a location for the
1026: corresponding associate.
1027: If K is an existing key of the table, the location for the
1028: table-selection-target is that of the associate corresponding to K.
1029: If a value A is then put in the table-selection-target,
1030: the original associate held in that location is superseded by A.
1031: If K is not an existing key and a value A is to be put in the
1032: table-selection-target, a new location is created, and the
1033: (original) table is made to contain a new table entry
1034: consisting of K and A.
1035: K must be of the same type as the other keys of the
1036: table, and A of the same type as the other associates.
1037: .Se 5 6.3 TESTS
1038: .Xx bound tags
1039: .Xx scratch-pad copy
1040: .Tx
1041: Tests do not return a value, but succeed or fail when
1042: tested.
1043: In \*B, the testing of a test cannot alter the values of targets
1044: that currently exist, nor can it create new targets that survive the test,
1045: with the exception of the temporary survival of bound tags
1046: as described under QUANTIFICATIONS (section 6.3.7) and
1047: REFINED-TESTS (section 6.3.3).
1048: .br
1049: If a test appears to alter an existing target, it effectively modifies
1050: a local, ``scratch-pad''
1051: \fIcopy\fP of that target, and the change is invisible outside the test.
1052: .Sy 6
1053: .Pr test 6
1054: .Al
1055: tight-test
1056: .Al
1057: conjunction
1058: .Al
1059: disjunction
1060: .Al
1061: negation
1062: .Al
1063: quantification
1064: .Pr tight-test 6
1065: .Al
1066: \*(<:(\*(:> test \*(<:)\*(:>
1067: .Al
1068: order-test
1069: .Al
1070: proposition
1071: .Al
1072: refined-test
1073: .Pr right-test 4
1074: .Al
1075: tight-test
1076: .Al
1077: negation
1078: .Al
1079: quantification
1080: .Tx
1081: The various kinds of tests that are distinguished here
1082: serve to define the syntax
1083: in such a way that no parentheses are needed where the meaning is
1084: sufficiently clear.
1085: .Se 7 6.3.1 ORDER-TESTS
1086: .Xx order
1087: .Xx approximate
1088: .Xx exact
1089: .Xx equal
1090: .Xx number
1091: .Sy 7
1092: .Pr order-test 3
1093: .Al
1094: single-expression\0order-sign\0single-expression
1095: .Al
1096: order-test\0order-sign\0single-expression
1097: .Pr order-sign 7
1098: .Al
1099: \*(<:<\*(:>
1100: .Al
1101: \*(<:<=\*(:>
1102: .Al
1103: \*(<:=\*(:>
1104: .Al
1105: \*(<:<>\*(:>
1106: .Al
1107: \*(<:>=\*(:>
1108: .Al
1109: \*(<:>\*(:>
1110: .Ps
1111: (The order-sign \*(<:<>\*(:> stands for ``not equals''.)
1112: .Ex 5
1113: \k1order-tests:
1114: \h'|\n1u'\*(<:(i', j') > (i, j)\*(:>
1115: \&\h'|\n1u'\*(<:'0' <= d <= '9'\*(:>
1116: \h'|\n1u'\*(<:fa <= f(x) >= fb\*(:>
1117: .Xe
1118: The single-expressions are evaluated one by one, from left to right,
1119: and each adjacent pair is compared.
1120: As soon as a comparison does not comply with the given order-sign,
1121: the whole order-test fails and no further single-expressions are evaluated.
1122: The order-test succeeds if all comparisons comply with the
1123: specified order-signs.
1124: .br
1125: Note carefully that an approximate number is \fInever\fP equal to an exact
1126: number, so, for instance, if you want to compare an approximate number \*(<:a\*(:>
1127: for equality with an exact number \*(<:e\*(:>, you should write
1128: .Di 1
1129: \*(<:IF a = ~e:\*(:>\ ...
1130: .Ed
1131: .br
1132: This also allows you to test if a number is exact or not:
1133: .Di 3
1134: \*(<:SELECT:
1135: x = ~x: WRITE 'Approximate'
1136: ELSE: WRITE 'Exact'\*(:>
1137: .Ed
1138: .Se 2 6.3.2 PROPOSITIONS
1139: .Xx proposition
1140: .Xx user-defined predicate
1141: .Xx scratch-pad copy
1142: .Xx test-unit
1143: .Xx report-command
1144: .Xx succeed-command
1145: .Xx fail-command
1146: .Xx text, list or table
1147: .Sy 2
1148: .Pr zeroadic-proposition 2
1149: .Sl
1150: zeroadic-predicate
1151: .Pr monadic-proposition 2
1152: .Sl
1153: monadic-predicate\0actual-operand
1154: .Pr dyadic-proposition 2
1155: .Al
1156: actual-operand\0dyadic-predicate\0actual-operand
1157: .Pr zeroadic-predicate 2
1158: .Sl
1159: tag
1160: .Pr monadic-predicate 2
1161: .Sl
1162: tag
1163: .Pr dyadic-predicate 2
1164: .Sl
1165: tag
1166: .Us 7 Propositions with user-defined predicates
1167: A proposition whose predicate is defined by a test-unit, is
1168: tested in the following steps:
1169: .in \w'2.\ 'u
1170: .ti 0
1171: 1.\ A copy is made of the current environment (the value of
1172: all targets), and all computations during the testing of
1173: the proposition will take place in this ``scratch-pad copy''.
1174: .ti 0
1175: 2.\ Any local tags in the test-unit that might clash with tags currently
1176: in use are systematically replaced by other tags that do not cause conflict.
1177: .ti 0
1178: 3.\ Each actual-operand is evaluated and put in the
1179: corresponding formal-operand, used as a (new)
1180: target.
1181: .ti 0
1182: 4.\ The command-suite of the unit, thus modified, is executed.
1183: .in 0
1184: The testing of the proposition is complete when the execution
1185: of this command-suite terminates because of the execution
1186: of a report-, succeed- or fail-command;
1187: the proposition succeeds or fails accordingly.
1188: .Us 7 Propositions with predefined predicates
1189: .Qr
1190: \*(<:e in t\*(:>
1191: .Qe
1192: accepts texts, lists and tables for the right operand.
1193: It succeeds if \*(<:e#t > 0\*(:> succeeds,
1194: in other words, if the value \*(<:e\*(:> occurs in \*(<:t\*(:>.
1195: .Qr
1196: \*(<:e not'in t\*(:>
1197: .Qe
1198: is the same as \*(<:(NOT e in t)\*(:>.
1199: .Se 2 6.3.3 REFINED-TESTS
1200: .Xx scratch-pad copy
1201: .Xx report-command
1202: .Xx succeed-command
1203: .Xx fail-command
1204: .Xx bound tags
1205: .Sy 2
1206: .Pr refined-test 2
1207: .Sl
1208: tag
1209: .Sx 3 \k1refined-test:
1210: \*(<:special'case\*(:>
1211: .Xe
1212: .Tx
1213: A refined-test is
1214: tested in the following steps:
1215: .in \w'2.\ 'u
1216: .ti 0
1217: 1.\ A copy is made of the current environment (the value of all targets),
1218: and all computations during the testing of
1219: the test will take place in this ``scratch-pad copy''.
1220: .ti 0
1221: 2.\ The command-suite of the corresponding
1222: test-refinement is executed.
1223: .in 0
1224: The testing of the refined-test is complete when the execution
1225: of this command-suite terminates because of the execution
1226: of a report-, succeed- or fail-command, and the refined-test
1227: succeeds or fails accordingly.
1228: .ne 3
1229: .br
1230: Any bound tags set by a for-command or
1231: a quantification (see 6.3.7) at that time will temporarily survive
1232: for those parts that are reachable only by virtue of the outcome of the test.
1233: This is so that you can turn any test into a refined-test with the same effect.
1234: .br
1235: For example, in
1236: .Di 3
1237: \*(<: IF divisible AND n > d**2: WRITE d
1238: \*(:>...\*(<:
1239: divisible: REPORT SOME d IN {2..n-1} HAS n mod d = 0\*(:>,
1240: .Ed
1241: the bound tag \*(<:d\*(:> is set to a divisor of \*(<:n\*(:> if the
1242: refined-test succeeds, and since the part \*(<:n > d**2\*(:>
1243: is only reached after success, \*(<:d\*(:> may be used there.
1244: The same is true for the write-command using \*(<:d\*(:>.
1245: The line after (indicated with three dots), however, can be
1246: reached if the divisibility test fails.
1247: So there \*(<:d\*(:> has ceased to exist.
1248: .Sa
1249: test-refinements (4.4).
1250: .Se 2 6.3.4 CONJUNCTIONS
1251: .Sy 2
1252: .Pr conjunction 3
1253: .Al
1254: tight-test \*(<:AND\*(:> right-test
1255: .Al
1256: tight-test \*(<:AND\*(:> conjunction
1257: .Ex 4
1258: \k1conjunctions:
1259: \h'|\n1u'\*(<:a > 0 AND b > 0\*(:>
1260: \h'|\n1u'\*(<:i in keys t AND t[i] in keys u AND u[t[i]] <> 'dummy'\*(:>
1261: .Xe
1262: .Tx
1263: The tests of the conjunction, separated by \*(<:AND\*(:>, are tested
1264: one by one, from left to right.
1265: As soon as one of these tests fails,
1266: the whole conjunction fails and no further parts
1267: are tested.
1268: The conjunction succeeds if all its tests succeed.
1269: .Se 2 6.3.5 DISJUNCTIONS
1270: .Sy 2
1271: .Pr disjunction 3
1272: .Al
1273: tight-test \*(<:OR\*(:> right-test
1274: .Al
1275: tight-test \*(<:OR\*(:> disjunction
1276: .Ex 4
1277: \k1disjunctions:
1278: \h'|\n1u'\*(<:a <= 0 OR b <= 0\*(:>
1279: \h'|\n1u'\*(<:n = 0 OR s[1] = s[n] OR t[1] = t[n]\*(:>
1280: .Xe
1281: .Tx
1282: The tests of the disjunction, separated by \*(<:OR\*(:>, are tested
1283: one by one, from left to right.
1284: As soon as one of these tests succeeds,
1285: the whole disjunction succeeds and no further parts
1286: are tested.
1287: The disjunction fails if all its tests fail.
1288: .Se 2 6.3.6 NEGATIONS
1289: .Sy 2
1290: .Pr negation 2
1291: .Sl
1292: \*(<:NOT\*(:> right-test
1293: .Sx 3 \k1negation:
1294: \*(<:NOT a subset b\*(:>
1295: .Xe
1296: .Tx
1297: A negation succeeds if its right-test fails, and fails if
1298: that test succeeds.
1299: .Se 3 6.3.7 QUANTIFICATIONS
1300: .Xx bound tags
1301: .Xx text, list or table
1302: .Xx character
1303: .Xx list entry
1304: .Xx associate
1305: .Sy 3
1306: .Pr quantification 2
1307: .Sl
1308: quantifier\0ranger \*(<:HAS\*(:> right-test
1309: .Pr quantifier 4
1310: .Al
1311: \*(<:SOME\*(:>
1312: .Al
1313: \*(<:EACH\*(:>
1314: .Al
1315: \*(<:NO\*(:>
1316: .Pr ranger 3
1317: .Al
1318: in-ranger
1319: .Al
1320: parsing-ranger
1321: .Pr parsing-ranger 3
1322: .Sl
1323: multiple-identifier \*(<:PARSING\*(:> expression
1324: .Ps
1325: Note that the identifier of a parsing-ranger must be a multiple-identifier
1326: (like \*(<:p, q, r\*(:>):
1327: it may not be a single-identifier (like \*(<:pqr\*(:>).
1328: Moreover, each of the single-identifiers (like \*(<:p\*(:>) must be
1329: plain tags.
1330: The reason is that this determines the number of parts
1331: which the value of the expression must be split into (see below).
1332: .Bl 1
1333: (For in-rangers, see for-commands, section 5.2.4.)
1334: .Ex 5
1335: \k1quantifications:
1336: \h'|\n1u'\*(<:SOME p, q, r PARSING line HAS q in {'. '; '? '; '! '}\*(:>
1337: \h'|\n1u'\*(<:EACH i, j IN keys t HAS t[i, j] = t[j, i]\*(:>
1338: \h'|\n1u'\*(<:NO d IN {2..n-1} HAS n mod d = 0\*(:>
1339: .Xe
1340: .Tx
1341: The tags of the identifier of a quantifier may not be used as targets
1342: or target-contents
1343: outside such a quantifier.
1344: They are ``bound tags'', and lose their meaning outside the
1345: quantifier, except as described below.
1346: .Bl 2
1347: The meaning of quantifications will first be described for
1348: the case of \*(<:SOME\*(:>\ ...\ \*(<:IN\*(:>\ ...
1349: .br
1350: The value of the expression must be a text, list or table.
1351: The items (characters, list entries or associates) of that value are
1352: assigned one by one to the identifier, and the right-test is
1353: tested each time.
1354: The quantification succeeds as soon as
1355: the right-test succeeds once.
1356: It fails only if the text, list or table is exhausted and the
1357: right-test has failed each time.
1358: .br
1359: If the quantification succeeds,
1360: the bound tags set at that moment
1361: will temporarily survive and may be used
1362: in those parts that are reachable only by virtue of the
1363: outcome of the test.
1364: .br
1365: For example, in
1366: .Di 3
1367: \*(<: IF (SOME d IN {2..n-1} HAS n mod d = 0) AND n > d**2: WRITE d
1368: \*(:>\ ...
1369: .Ed
1370: the bound tag \*(<:d\*(:> is set to a divisor of \*(<:n\*(:> if the
1371: quantification succeeds, and since the part \*(<:n > d**2\*(:>
1372: is only reached after success, \*(<:d\*(:> may be used there.
1373: The same is true for the write-command using \*(<:d\*(:>.
1374: So, if \*(<:n\*(:> has the value \*(<:77\*(:>, \*(<:7\*(:> will be written, since
1375: the test \*(<:n mod d = 0\*(:> succeeds the first time when
1376: \*(<:d\*(:> is set to \*(<:7\*(:> (and \*(<:77 > 7**2\*(:>).
1377: The line after (indicated with three dots), however, can be
1378: reached if the divisibility test fails.
1379: So there \*(<:d\*(:> has ceased to exist and may not be used.
1380: .sp
1381: The meaning of a quantification \*(<:SOME id IN tlt HAS prop\*(:>
1382: can also be described as the meaning of the refined-test
1383: \*(<:test'if'some\*(:>, given
1384: a test-refinement
1385: .Di 4
1386: \*(<:test'if'some:
1387: FOR id IN tlt:
1388: IF prop: SUCCEED
1389: FAIL\*(:>
1390: .Ed
1391: .Bl 3
1392: The meaning of \*(<:EACH id IN tlt HAS prop\*(:>
1393: is the same as that of \*(<:NOT SOME id IN tlt HAS NOT prop\*(:>.
1394: In other words, an \*(<:EACH\*(:> quantification succeeds only if its
1395: right-test succeeds each time.
1396: .br
1397: The meaning of \*(<:NO id IN tlt HAS prop\*(:>
1398: is the same as that of \*(<:NOT SOME id IN tlt HAS prop\*(:>.
1399: In other words, a \*(<:NO\*(:> quantification succeeds only if its
1400: right-test fails each time.
1401: .br
1402: The rules for temporary survival are the same as for \*(<:SOME\*(:>.
1403: So an \*(<:EACH\*(:> or \*(<:NO\*(:> quantification will only have set its
1404: bound tags on failure.
1405: Thus, in the following, the bound tag \*(<:d\*(:> survives into the \*(<:ELSE\*(:>:
1406: .Di 4
1407: \*(<:SELECT:
1408: NO d IN {2..n-1} HAS n mod d = 0:
1409: WRITE 'prime'
1410: ELSE: WRITE 'divisible by `d`'\*(:>
1411: .Ed
1412: .Bl 3
1413: If \*(<:PARSING\*(:> is specified,
1414: all \fIparsings\fP of the value of the given expression are
1415: tried, instead of its items.
1416: The value of the expression must be a text.
1417: A ``parsing'' of a text is a way of splitting it in parts.
1418: The text is split in all possible ways in as many parts as
1419: there are tags in the multiple-identifier, and each split
1420: is put in that identifier, whereupon the right-test is tested.
1421: For example,
1422: .Di 1
1423: \*(<:SOME p, q, r PARSING 'abracadabra' HAS (p = r AND #p > 3)\*(:>
1424: .Ed
1425: will succeed with \*(<:p\*(:> and \*(<:r\*(:> set to \*(<:'abra'\*(:> and \*(<:q\*(:> set to \*(<:'cad'\*(:>.
1426: If the test \*(<:#p > 3\*(:> is omitted, the quantification will
1427: succeed with the uninteresting result that \*(<:p\*(:> and \*(<:r\*(:> are set
1428: to \*(<:''\*(:> and \*(<:q\*(:> to \*(<:'abracadabra'\*(:>.
1429: .br
1430: To give another example,
1431: .Di 3
1432: \*(<: PUT 'a man, a plan, a canal: panama!' IN palindrome
1433: WHILE SOME hd, x, tl PARSING palindrome HAS x'non'letter:
1434: PUT hd^tl IN palindrome
1435: WRITE palindrome /
1436: x'non'letter: REPORT #x = 1 AND x not'in {'a'..'z'}\*(:>
1437: .Ed
1438: will successively find and remove all non-letters from the
1439: text in \*(<:palindrome\*(:> finally leaving the text \*(<:'amanaplanacanalpanama'\*(:>.
1440: (This is not a recommended way, because it will be very slow.
1441: There are equally simple and much faster ways to achieve the same effect.
1442: The example is only chosen to illustrate the possibilities of \*(<:PARSING\*(:>.)
1443: Note that the test \*(<:#x = 1\*(:> here is essential.
1444: If it is omitted, the program will go
1445: into an endless loop ``removing'' empty texts \*(<:x\*(:> from \*(<:palindrome\*(:>.
1446: .br
1447: The meaning of \*(<:SOME p, q,\*(:>\ ...\ \*(<:PARSING whole HAS prop\*(:>
1448: may more precisely be described as follows.
1449: Let \*(<:parsings\*(:> stand for a list, containing
1450: \fIall\fP compounds with the same number of fields as the
1451: multiple-identifier \*(<:p, q,\*(:>\ ..., such that those fields
1452: (which are texts) joined together give the text \*(<:whole\*(:>.
1453: For example, in
1454: .Di 1
1455: \*(<:SOME p, q, r PARSING 'abracadabra' HAS (p = r AND #p > 3)\*(:>
1456: .Ed
1457: the list \*(<:parsings\*(:> will begin with
1458: .Di 1
1459: \*(<:{('', '', 'abracadabra'); ('', 'a', 'bracadabra');\*(:>\ ...\ ,
1460: .Ed
1461: contain somewhere in the middle
1462: .Di 1
1463: \&...\ \*(<:; ('abra', 'cad', 'abra');\*(:>\ ...\ ,
1464: .Ed
1465: and end with
1466: .Di 1
1467: \&...\ \*(<:; ('abracadabr', 'a', ''); ('abracadabra', '', '')}\*(:>.
1468: .Ed
1469: The effect of the quantification is then the same as that
1470: of
1471: .Di 1
1472: \*(<:SOME p, q,\*(:>\ ...\ \*(<:IN parsings HAS prop\*(:>.
1473: .Ed
1474: The meaning of \*(<:EACH\*(:> or \*(<:NO\*(:> is accordingly defined.
1475: .Sa
1476: for-commands (5.2.4).
1477: .ps 10
1478: .vs 12
1479: .de PH\"Page Header
1480: .ie \\n+(cl<3 \{\
1481: .po +\\n(TWu/3u
1482: .rt
1483: .ns \}
1484: .el \{\
1485: .po \\n(POu
1486: .nr f1 \\n(.f\" current font
1487: .ft
1488: .nr f2 \\n(.f\" previous font
1489: .ft R
1490: .nr sp \\n(.s\"current point size
1491: .ps \\n(ms-1
1492: 'bp
1493: .CM \" Cut Mark
1494: 'ie o 'tl ''\\*(TL'\\*(Sn'
1495: 'el 'tl '\\*(Sn'\\*(TL''
1496: .ft \\n(f2\" restore previous font
1497: .ft \\n(f1\" restore current font
1498: .ps \\n(sp\"restore point size
1499: 'sp 2
1500: .mk
1501: 'ns
1502: 'EH\"Extra Header
1503: 'nr cl 0 1 \}
1504: 'na
1505: ..
1506: .ch PH
1507: .wh -(\n(HFu-1v) PH
1508: .de Fo\" Page footer
1509: .nr f1 \\n(.f\" current font
1510: .ft
1511: .nr f2 \\n(.f\" previous font
1512: .ft R
1513: .nr sp \\n(.s\"current point size
1514: .ps \\n(ms-1
1515: .po \\n(POu
1516: .if \\n%>2 .tl ''%''
1517: .po
1518: .ft \\n(f2\" restore previous font
1519: .ft \\n(f1\" restore current font
1520: .ps \\n(sp\"restore point size
1521: ..
1522: .de XX
1523: .br
1524: .ti 0
1525: ..
1526: .ds Sn Index
1527: .nr cl 4 1
1528: .ll \n(TWu/3u-2n
1529: .na
1530: .bp
1531: .Us 3 INDEX
1532: .mk
1533: .in 2n
1534: .XX
1535: actual-operand 6.1.6
1536: .XX
1537: actual-parameter 5.1.16
1538: .XX
1539: alternative-sequence 5.2.2
1540: .XX
1541: alternative-suite 5.2.2
1542: .XX
1543: ambiguity 6.1.5, 6.1.6
1544: .XX
1545: approximate 6.3.1
1546: .XX
1547: approximate-constant 6.1.1
1548: .XX
1549: approximate number 1
1550: .XX
1551: associate 1, 5.1.6, 5.2.4, 6.1.4, 6.1.5, 6.1.6, 6.2.3, 6.3.7
1552: .XX
1553: basic-expression 6.1
1554: .XX
1555: basic-target 6.2
1556: .XX
1557: bound tags 5.1.13, 5.1.14, 5.1.15, 5.2.4, 6.3, 6.3.3, 6.3.7
1558: .XX
1559: brackets 6.1.6
1560: .XX
1561: character 1, 5.1.6, 5.2.4, 6.1.5, 6.1.6, 6.3.7
1562: .XX
1563: check-command 5.1.1
1564: .XX
1565: choose-command 5.1.6
1566: .XX
1567: command 5
1568: .XX
1569: command-refinement 4.4, 5.1.11, 5.1.17
1570: .XX
1571: command-sequence 4.5
1572: .XX
1573: command-suite 4.5
1574: .XX
1575: comment 3
1576: .XX
1577: compound 1, 6.1, 6.2
1578: .XX
1579: conjunction 6.3.4
1580: .XX
1581: control-command 5.2
1582: .XX
1583: conversion 6.1.5
1584: .XX
1585: convert to a text 5.1.2, 6.1.5, 6.1.6
1586: .XX
1587: decrease-indentation 3
1588: .XX
1589: delete-command 5.1.10
1590: .XX
1591: denominator 6.1.6
1592: .XX
1593: digit 6.1.1
1594: .XX
1595: disjunction 6.3.5
1596: .XX
1597: display 6.1.5
1598: .XX
1599: draw-command 5.1.5
1600: .XX
1601: dyadic 4.2, 4.3
1602: .XX
1603: dyadic-formula 6.1.6
1604: .XX
1605: dyadic-function 6.1.6
1606: .XX
1607: dyadic-predicate 6.3.2
1608: .XX
1609: dyadic-proposition 6.3.2
1610: .XX
1611: else-alternative 5.2.2
1612: .XX
1613: empty 2
1614: .XX
1615: empty list 6.1.5
1616: .XX
1617: empty table 6.1.5
1618: .XX
1619: entry 1
1620: .XX
1621: equal 6.3.1
1622: .XX
1623: exact 6.3.1
1624: .XX
1625: exact-constant 6.1.1
1626: .XX
1627: exact number 1
1628: .XX
1629: exponent-part 6.1.1
1630: .XX
1631: expression 6.1
1632: .XX
1633: expression-refinement 4.4, 4.5, 5.1.12, 6.1.7
1634: .XX
1635: fail-command 4.5, 5.1.15, 6.3.2, 6.3.3
1636: .XX
1637: field 1
1638: .XX
1639: for-command 5.2.4
1640: .XX
1641: formal-dyadic-formula 4.2
1642: .XX
1643: formal-dyadic-proposition 4.3
1644: .XX
1645: formal-formula 4.2
1646: .XX
1647: formal-monadic-formula 4.2
1648: .XX
1649: formal-monadic-proposition 4.3
1650: .XX
1651: formal-operand 4.2
1652: .XX
1653: formal-parameter 4.1
1654: .XX
1655: formal-proposition 4.3
1656: .XX
1657: formal-tail 4.1
1658: .XX
1659: formal-trailer 4.1
1660: .XX
1661: formal-user-defined-command 4.1
1662: .XX
1663: formal-zeroadic-formula 4.2
1664: .XX
1665: formal-zeroadic-proposition 4.3
1666: .XX
1667: formula 4.2, 4.3, 6.1.6
1668: .XX
1669: fractional-part 6.1.1
1670: .XX
1671: function 4.2, 4.3, 6.1.6
1672: .XX
1673: further-comment 3
1674: .XX
1675: global 4.5, 5
1676: .XX
1677: how-to-unit 4.1, 5.1.11, 5.1.16
1678: .XX
1679: identifier 6.2.1
1680: .XX
1681: if-command 5.2.1
1682: .XX
1683: immediate command 5, 5.1.11
1684: .XX
1685: in-ranger 5.2.4
1686: .XX
1687: increase-indentation 3
1688: .XX
1689: indentation 3
1690: .XX
1691: insert-command 5.1.9
1692: .XX
1693: integer 6.1.3, 6.1.5, 6.1.6
1694: .XX
1695: integral-part 6.1.1
1696: .XX
1697: interrupt key 5, 5.1.2
1698: .XX
1699: key 1, 6.1.4, 6.1.5, 6.1.6, 6.2.3
1700: .XX
1701: keyword 3, 4.1, 4.4, 5.1.16, 5.1.17
1702: .XX
1703: list 1
1704: .XX
1705: list-body 6.1.5
1706: .XX
1707: list-display 6.1.5
1708: .XX
1709: list entry 1, 5.1.6, 5.1.8, 5.1.9, 5.2.4, 6.1.6, 6.3.7
1710: .XX
1711: list-filler 6.1.5
1712: .XX
1713: list-filler-series 6.1.5
1714: .XX
1715: local 4.5, 6.1.6, 6.2.1
1716: .XX
1717: location 5.1.4, 5.1.10, 6.2.1, 6.2.3
1718: .XX
1719: monadic 4.2, 4.3
1720: .XX
1721: monadic-formula 6.1.6
1722: .XX
1723: monadic-function 6.1.6
1724: .XX
1725: monadic-predicate 6.3.2
1726: .XX
1727: monadic-proposition 6.3.2
1728: .XX
1729: multiple-expression 6.1
1730: .XX
1731: multiple-identifier 6.2.1
1732: .XX
1733: multiple-target 6.2
1734: .XX
1735: negation 6.3.6
1736: .XX
1737: new-line 3
1738: .XX
1739: new-line-proper 3
1740: .XX
1741: new-liners 5.1.2
1742: .XX
1743: number 1, 5.1.5, 6.1.6, 6.3.1
1744: .XX
1745: numerator 6.1.6
1746: .XX
1747: numeric-constant 6.1.1
1748: .XX
1749: optional-ANYTHING 2
1750: .XX
1751: order 1, 6.3.1
1752: .XX
1753: order-sign 6.3.1
1754: .XX
1755: order-test 6.3.1
1756: .XX
1757: overloading of functions and predicates 4.2, 4.3
1758: .XX
1759: parentheses 6.1.6
1760: .XX
1761: parsing-ranger 6.3.7
1762: .XX
1763: permanent environment 4.5, 5.1.2, 5.1.11
1764: .XX
1765: plusminus 6.1.1
1766: .XX
1767: predefined functions 6.1.6
1768: .XX
1769: predefined predicates 6.3.2
1770: .XX
1771: predicate 4.2, 4.3
1772: .XX
1773: priority 6.1.6
1774: .XX
1775: proposition 4.3, 6.3.2
1776: .XX
1777: put-command 5.1.4
1778: .XX
1779: quantification 6.3.7
1780: .XX
1781: quantifier 6.3.7
1782: .XX
1783: quit-command 5.1.11, 5.1.16, 5.1.17
1784: .XX
1785: quote 6.1.5
1786: .XX
1787: random 5.1.5, 5.1.6, 5.1.7
1788: .XX
1789: ranger 6.3.7
1790: .XX
1791: read-command 5.1.3
1792: .XX
1793: refined-command 5.1.17
1794: .XX
1795: refined-expression 5.1.12, 6.1.7
1796: .XX
1797: refined-test 5.1.13, 5.1.14, 5.1.15, 6.3.3
1798: .XX
1799: refinement 4.4
1800: .XX
1801: refinement-suite 4
1802: .XX
1803: remove-command 5.1.8
1804: .XX
1805: report-command 4.5, 5.1.13, 6.3.2, 6.3.3
1806: .XX
1807: return-command 4.5, 5.1.12, 6.1.6, 6.1.7
1808: .XX
1809: right-expression 6.1
1810: .XX
1811: right-test 6.3
1812: .XX
1813: scratch-pad copy 6.1, 6.1.6, 6.1.7, 6.3, 6.3.2, 6.3.3
1814: .XX
1815: select-command 5.2.2
1816: .XX
1817: set-random-command 5.1.7
1818: .XX
1819: share-heading 4.5
1820: .XX
1821: simple-command 5.1
1822: .XX
1823: simple-expression 6.1
1824: .XX
1825: single-alternative 5.2.2
1826: .XX
1827: single-expression 6.1
1828: .XX
1829: single-identifier 6.2.1
1830: .XX
1831: single-target 6.2
1832: .XX
1833: spaces 3
1834: .XX
1835: succeed-command 4.5, 5.1.14, 6.3.2, 6.3.3
1836: .XX
1837: table 1
1838: .XX
1839: table-display 6.1.5
1840: .XX
1841: table entry 1, 5.1.10, 6.1.4, 6.2.3
1842: .XX
1843: table-filler 6.1.5
1844: .XX
1845: table-filler-series 6.1.5
1846: .XX
1847: table-selection 6.1.4
1848: .XX
1849: table-selection-target 5.1.10, 6.2.3
1850: .XX
1851: tag 3, 6.2.1
1852: .XX
1853: target 4.5, 5.1.4, 5.2.4, 6.1.6, 6.2, 6.2.1
1854: .XX
1855: target-content 6.1.2
1856: .XX
1857: terminating-command 5.1, 5.2.3
1858: .XX
1859: test 4.3, 6.3
1860: .XX
1861: test-refinement 4.4, 4.5, 5.1.13, 5.1.14, 5.1.15
1862: .XX
1863: test-unit 4.3, 4.5, 5.1.13, 5.1.14, 5.1.15, 6.3.2
1864: .XX
1865: text 1, 6.1.6
1866: .XX
1867: text, list and table 5.1.6, 5.2.4, 6.1.6, 6.3.2, 6.3.7
1868: .XX
1869: text-display 6.1.5
1870: .XX
1871: tight-expression 6.1
1872: .XX
1873: tight-test 6.3
1874: .XX
1875: trailer 5.1.16
1876: .XX
1877: trimmed-text 6.1.3
1878: .XX
1879: trimmed-text-target 6.2.2
1880: .XX
1881: type 5.1.4, 6.2.3
1882: .XX
1883: unit 4
1884: .XX
1885: user-defined-command 4.1, 5.1.16
1886: .XX
1887: user-defined-function 4.2, 5.1.12, 6.1.6
1888: .XX
1889: user-defined-predicate 4.3, 5.1.13, 5.1.14, 5.1.15, 6.3.2
1890: .XX
1891: while-command 5.2.3
1892: .XX
1893: work-space 4, 4.5
1894: .XX
1895: write-command 5.1.2
1896: .XX
1897: yield-unit 4.2, 4.5, 5.1.12, 6.1.6
1898: .XX
1899: zeroadic 4.2, 4.3
1900: .XX
1901: zeroadic-formula 6.1.6
1902: .XX
1903: zeroadic-function 6.1.6
1904: .XX
1905: zeroadic-predicate 6.3.2
1906: .XX
1907: zeroadic-proposition 6.3.2
1908: .rm PH
1909: .wh -0 CM
1910: .bp
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.