manual:chapter5:listproc

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
manual:chapter5:listproc [2019/10/04 14:49]
jojo1973 Removed Group 4 since ADD and + swapped behavior
manual:chapter5:listproc [2019/11/03 06:36]
jojo1973 [Group 9: Quirky commands]
Line 24: Line 24:
   * **Commands that operate on a list as a whole.** Certain commands accept lists as arguments but treat them no differently than any other data object. They perform their function on the object as a whole without respect to its elements. For example, ''→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.   * **Commands that operate on a list as a whole.** Certain commands accept lists as arguments but treat them no differently than any other data object. They perform their function on the object as a whole without respect to its elements. For example, ''→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.
   * **List manipulation commands.** List manipulation commands will not parallel process since they operate on list arguments as lists rather than as sets of parallel data. However, a list manipulation command can be forced to parallel process lists of lists by using the ''DOLIST'' command. For example, <code>   * **List manipulation commands.** List manipulation commands will not parallel process since they operate on list arguments as lists rather than as sets of parallel data. However, a list manipulation command can be forced to parallel process lists of lists by using the ''DOLIST'' command. For example, <code>
-{ { 1 2 3 } { 4 5 6 } } +3:       { { 1 2 3 } { 4 5 6 } } 
-+2:                             
-« ΠLIST »+1:                     « ΠLIST » 
 +……………………………………………………………………………………
 DOLIST DOLIST
 </code> returns ''{ 6 120 }''. </code> returns ''{ 6 120 }''.
   * **Other commands that have list arguments.** Because a list can hold any number of objects of any type, it is commonly used to hold a variable number of parameters of various types. Some commands accept such lists, and because of this are insensitive to parallel processing, except by using ''DOLIST''.   * **Other commands that have list arguments.** Because a list can hold any number of objects of any type, it is commonly used to hold a variable number of parameters of various types. Some commands accept such lists, and because of this are insensitive to parallel processing, except by using ''DOLIST''.
   * **Index-oriented commands.** Many array commands either establish the size of an array in rows and columns or manipulate individual elements by their row and column indices. These commands expect these row and column indices to be real number pairs collected in lists. For example, <code>   * **Index-oriented commands.** Many array commands either establish the size of an array in rows and columns or manipulate individual elements by their row and column indices. These commands expect these row and column indices to be real number pairs collected in lists. For example, <code>
-{ 3 4 }+1:                       { 3 4 } 
 +……………………………………………………………………………………
 RANM RANM
 </code> 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''. </code> 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''.
   * **Program control commands.** Program control structures and commands do no perform parallel processing and cannot be forced to do so. However, programs containing these structures can be made to parallel process by using ''DOLIST''. For example, <code>   * **Program control commands.** Program control structures and commands do no perform parallel processing and cannot be forced to do so. However, programs containing these structures can be made to parallel process by using ''DOLIST''. For example, <code>
-{ 1 2 3 4 5 6 } +3:               { 1 2 3 4 5 6 } 
-+2:                             
-« IF  +1:                   « IF        
-    DUP 3 ≤ +                         DUP 3 ≤ 
-  THEN +                       THEN      
-    DROP +                         DROP    
-  END +                       END       
-»+                     »           
 +……………………………………………………………………………………
 DOLIST DOLIST
 </code> returns ''{ 4 5 6 }''. </code> returns ''{ 4 5 6 }''.
Line 51: Line 54:
 ==== Group 4: Commands that set modes / states ==== ==== Group 4: Commands that set modes / states ====
 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, <code> 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, <code>
-{ 16 32 48 }+1:                  { 16 32 48 } 
 +……………………………………………………………………………………
 SETPREC</code> is effectively the same as <code> SETPREC</code> is effectively the same as <code>
-48+1:                            48 
 +……………………………………………………………………………………
 SETPREC SETPREC
 </code> </code>
Line 60: Line 65:
 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: 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:
  
-  * <code>{ 1 -2 3 -4 }+  * <code> 
 +1:                 { 1 -2 3 -4 } 
 +……………………………………………………………………………………
 ABS ABS
 </code> returns ''{ 1 2 3 4 }''. </code> returns ''{ 1 2 3 4 }''.
   * <code>   * <code>
-DEG +1:                { 0 30 60 90 } 
-{ 0 30 60 90 }+……………………………………………………………………………………
 SIN SIN
-</code> returns ''{ 0 .5. .866025403784. 1 }''.+</code> returns ''{ 0 .5. .866025403784. 1 }'' (assuming ''DEG'' mode).
   * <code>   * <code>
-{ 1 A 'SIN(Z)'}+1:             { 1 'A'SIN(Z)'} 
 +……………………………………………………………………………………
 INV INV
 </code> returns ''{ 1 'INV(A)' 'INV(SIN(Z))' }''. </code> returns ''{ 1 'INV(A)' 'INV(SIN(Z))' }''.
Line 81: Line 89:
  
 In the first form, parallel elements are combined by the command: <code> In the first form, parallel elements are combined by the command: <code>
-{ 1 2 3 } +2:                     { 1 2 3 } 
-{ 4 5 6 }+1:                     { 4 5 6 } 
 +……………………………………………………………………………………
 % %
 </code> returns ''{ .04 .1 .18 }''. </code> returns ''{ .04 .1 .18 }''.
  
 In the second form, the level 1 object is combined with each element in the level 2 list in succession: <code> In the second form, the level 1 object is combined with each element in the level 2 list in succession: <code>
-{ 1 2 3 } +2:                     { 1 2 3 } 
-30+1:                            30 
 +……………………………………………………………………………………
 %CH %CH
 </code> returns ''{ 2900 1400 900 }''. </code> returns ''{ 2900 1400 900 }''.
  
 In the third form, the level 2 object is combined with each element of the level 1 list in succession: <code> In the third form, the level 2 object is combined with each element of the level 1 list in succession: <code>
-50 +2:                            50 
-{ 1 2 3 }+1:                     { 1 2 3 } 
 +……………………………………………………………………………………
 %T %T
 </code> returns ''{ 2 4 6 }''. </code> returns ''{ 2 4 6 }''.
Line 103: Line 114:
 ==== Group 8: Multiple-result commands ==== ==== Group 8: Multiple-result commands ====
 Any command that allows parallel processing, but produces multiple results from its input data, will return its results as a single list. For example,<code> Any command that allows parallel processing, but produces multiple results from its input data, will return its results as a single list. For example,<code>
-{ 1 2 3 } +2:                     { 1 2 3 } 
-{ 4 5 6 }+1:                     { 4 5 6 } 
 +……………………………………………………………………………………
 R→C R→C
 +</code> produces, as expected ''{ (1, 4) (2, 5) (3, 6) }'', but<code>
 +1:      { (1, 4) (2, 5) (3, 6) }
 +……………………………………………………………………………………
 C→R C→R
 </code> produces ''{ 1 4 2 5 3 6 }'' rather than the more expected ''{ 1 2 3 } { 4 5 6 }''. </code> produces ''{ 1 4 2 5 3 6 }'' rather than the more expected ''{ 1 2 3 } { 4 5 6 }''.
Line 121: Line 136:
 » »
 </code> </code>
 +
 Taking ''{ 1 4 2 5 3 6 }'' from above as the result of ''C→R'' (a command which should return two results),<code> Taking ''{ 1 4 2 5 3 6 }'' from above as the result of ''C→R'' (a command which should return two results),<code>
-2+2:               { 1 4 2 5 3 6 } 
 +1:                             2 
 +……………………………………………………………………………………
 UNMIX UNMIX
 </code> gives ''{ 1 2 3 } { 4 5 6 }''. </code> gives ''{ 1 2 3 } { 4 5 6 }''.
Line 130: Line 148:
  
   * ''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, <code>   * ''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, <code>
-{ 1 3 }+1:                       { 1 3 } 
 +……………………………………………………………………………………
 DELALARM DELALARM
 </code> will cause an error, whereas <code> </code> will cause an error, whereas <code>
-{ 3 1 }+1:                       { 3 1 } 
 +……………………………………………………………………………………
 DELALARM DELALARM
 </code>will not. </code>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.   * ''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.
-  * ''RESTORE''. 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. FIXME+  * ''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. FIXME
  
 ==== Using DOLIST for parallel processing ==== ==== Using DOLIST for parallel processing ====
Line 143: Line 163:
  
   * Level 1 must contain a command, a program object, or the name of a variable that contains a command or program object.   * Level 1 must contain a command, a program object, or the name of a variable that contains a command or program object.
-  * Level 2 must contain an argument count unless the level 1 object is a command that accepts parallel processing, or a user-defined functionIn these special cases, level 2 contains the first of the list arguments. FIXME +  * Level 2 must contain an argument count. 
-  * If level 2 was the argument count, then level is the first of the argument lists. Otherwise, levels 2 through are the argument lists. FIXME+  * Level and on are the argument lists.
  
 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.<code> 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.<code>
  • manual/chapter5/listproc.txt
  • Last modified: 2019/11/03 06:36
  • by jojo1973