Parallel processing is the idea that, generally, if a command can be applied to one or more individual arguments, then it can also be extended to be applied to one or more sets of arguments.
As a rule-of-thumb, a given command can use parallel list processing if all the following are true:
DUP
, SWAP
, ROT
, and so forth, do not use parallel list processing.→LIST
) do not use parallel list processing.IF
, FOR
, CASE
, NEXT
, and so forth).The remainder of this chapter describes how the many and various commands available on the calculator are grouped with respect to parallel processing.
A command must take arguments before it can parallel process, since a zero-argument command (such as DEPTH
, VARS
, or RAND
) has no arguments with which to form a group.
This group of commands cannot use parallel processing directly, but can be “coerced” into it using the DOLIST
command (see Using DOLIST for parallel processing later in this chapter). This group consists of several subgroups:
DROP
) that take level 1 arguments will not accept level 1 list arguments.→STR
converts the entire list object to a string rather than converting each individual element, and the ==
command tests the level 1 object against the level 2 object regardless of the objects’ types.DOLIST
command. For example, 3: { { 1 2 3 } { 4 5 6 } } 2: 1 1: « ΠLIST » …………………………………………………………………………………… DOLIST
returns { 6 120 }
.
DOLIST
.1: { 3 4 } …………………………………………………………………………………… RANM
will generate a random integer matrix having 3 rows and 4 columns. Since these commands can normally use lists as arguments, they cannot perform parallel processing, except by using DOLIST
.
DOLIST
. For example, 3: { 1 2 3 4 5 6 } 2: 1 1: « IF DUP 3 ≤ THEN DROP END » …………………………………………………………………………………… DOLIST
returns { 4 5 6 }
.
Commands that store values in system-specific locations so as to control certain modes and machine states can generally be used to parallel process data. The problem is that each successive parameter in the list cancels the setting established by the previous parameter. For example,
1: { 16 32 48 } …………………………………………………………………………………… SETPREC
is effectively the same as
1: 48 …………………………………………………………………………………… SETPREC
These commands are the easiest to use with parallel processing. Simply provide the command with a list of arguments instead of the expected single argument. Some examples:
1: { 1 -2 3 -4 } …………………………………………………………………………………… ABS
returns { 1 2 3 4 }
.
1: { 0 30 60 90 } …………………………………………………………………………………… SIN
returns { 0 .5. .866025403784. 1 }
(assuming DEG
mode).
1: { 1 'A' 'SIN(Z)'} …………………………………………………………………………………… INV
returns { 1 'INV(A)' 'INV(SIN(Z))' }
.
Two-argument commands can operate in parallel in any of three different ways:
In the first form, parallel elements are combined by the command:
2: { 1 2 3 } 1: { 4 5 6 } …………………………………………………………………………………… %
returns { .04 .1 .18 }
.
In the second form, the level 1 object is combined with each element in the level 2 list in succession:
2: { 1 2 3 } 1: 30 …………………………………………………………………………………… %CH
returns { 2900 1400 900 }
.
In the third form, the level 2 object is combined with each element of the level 1 list in succession:
2: 50 1: { 1 2 3 } …………………………………………………………………………………… %T
returns { 2 4 6 }
.
Commands that take multiple (3, 4, or 5) arguments can perform parallel processing only if all arguments are lists. For example, { 'SIN(X)' 'COS(X)' 'TAN(X)' } { X X X } { 0 0 0 } ROOT
returns { 0 90 0 }
. Notice that lists must be used even though the level 1 and level 2 lists each contain multiples of the same element.
Any command that allows parallel processing, but produces multiple results from its input data, will return its results as a single list. For example,
2: { 1 2 3 } 1: { 4 5 6 } …………………………………………………………………………………… R→C
produces, as expected { (1, 4) (2, 5) (3, 6) }
, but
1: { (1, 4) (2, 5) (3, 6) } …………………………………………………………………………………… C→R
produces { 1 4 2 5 3 6 }
rather than the more expected { 1 2 3 } { 4 5 6 }
.
The following UNMIX
program will unmix the data given the number of expected result lists:
« OVER SIZE → l n s « 1 n FOR 'j' j s FOR 'i' l i GET n STEP s n / →LIST NEXT » »
Taking { 1 4 2 5 3 6 }
from above as the result of C→R
(a command which should return two results),
2: { 1 4 2 5 3 6 } 1: 2 …………………………………………………………………………………… UNMIX
gives { 1 2 3 } { 4 5 6 }
.
A few commands behave uniquely with respect to parallel processing:
DELALARM
. This command can take a list of arguments. Note, however, that deletions from early in the alarm list will change the alarm indices of the later alarm entries. Thus, if there are only three alarms, 1: { 1 3 } …………………………………………………………………………………… DELALARM
will cause an error, whereas
1: { 3 1 } …………………………………………………………………………………… DELALARM
will not.
DOERR
. This command forces an error state that causes all running programs and commands to halt. Thus even though providing the command with a list argument will cause the command to perform parallel processing, the first error state will cause the command to abort and none of the rest of the list arguments will be used.USBRESTORE
. This command performs a system warmstart after installing the backup object into memory. All functions are terminated at that time. Thus, only the first backup object in a list will be restored.
Almost any command or user program can be made to work in parallel over a list or lists of data by using the DOLIST
command. Use DOLIST
as follows.
As an example, the following program takes three objects from the stack, tags them with the names a
, b
, and c
, and displays them one after the other in line 1 of the display.
« → a b c « { a b c } DUP « EVAL » DOLIST SWAP « →TAG » DOLIST CLLCD 1 « 1 DISP 1 WAIT » DOLIST » »