manual:chapter5:basics

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:basics [2019/09/11 07:36]
claudioadmin [Variables] 		manual:chapter5:basics [2021/09/15 10:32]
claudio
Line 8: Line 8:
 A typical sequence of a program is to place some objects on the stack, do one or more operations and leave the result in the stack. For example: A typical sequence of a program is to place some objects on the stack, do one or more operations and leave the result in the stack. For example:
  
-<code>« 1 2 + »</code>+<code> 
 +« 
 +  1 2 + 
 +»</code>
  
 Let's analyze the program above: Let's analyze the program above:
Line 18: Line 21:
 And that's the most basic RPL program. Operators and functions always take some values from the stack and leave some results on it. A program may include multiple operations: And that's the most basic RPL program. Operators and functions always take some values from the stack and leave some results on it. A program may include multiple operations:
  
-<code>« 1 2 + 2 / »</code>+<code>« 
 +  1 2 + 
 +  2 / 
 +»</code>
  
 The program above starts identical to the previous example, and after the + operator is executed, the resulting number 3 is left on the stack. As the program continues, the number 2 is put on level 1, relegating the number 3 to level 2. The division operator takes 2 numbers and performs the division of the number in level 2 divided by the number in level 1. In this case, level 2 had a 3 and level 1 had a 2, therefore the number 1.5 will be left on the stack as a result. The program above starts identical to the previous example, and after the + operator is executed, the resulting number 3 is left on the stack. As the program continues, the number 2 is put on level 1, relegating the number 3 to level 2. The division operator takes 2 numbers and performs the division of the number in level 2 divided by the number in level 1. In this case, level 2 had a 3 and level 1 had a 2, therefore the number 1.5 will be left on the stack as a result.
Line 24: Line 30:
 ---- ----
  
-==== Operators and Commands ====+==== Operators, Functions and Commands ==== 
 + 
 +In the examples above we showed how + and / would take some objects from the stack, operate on them and place the result in the stack. This is the basic operation of all operators and commands in RPL. All commands, functions and operators take some (or none) arguments from the stack, and leave some (or none) results in it. There are hundreds of RPL keywords, all based on the same principle of taking and leaving objects on the stack. Future chapters will describe each keyword in depth, for now only a few ones will be introduced that define the basic core of the RPL language.  
 + 
 +Fundamentally all the keywords can be divided into 4 classes: commands, operators, functions and analytic functions. Difference between classes isn't in the effect they have on the stack (as said above, almost any keyword manipulates the stack) rather in behavior and scope. 
 + 
 +=== Commands === 
 + 
 +Commands perform actions. They are used to control program flow (''IF'', ''WHILE'', ''FOR''), manipulate objects (''PUT'', ''HEAD'') or variables (''STO+'', ''QUOTEID'') and setting the system (''SETLOCALE'', ''ASNKEYS''). 
 + 
 +=== Operators === 
 + 
 +Operators manipulate objects, returning results. Usually these objects are [[manual:chapter3:reals|real numbers]], but they can also be [[manual:chapter3:angles|angles]], [[manual:chapter3:matrix|matrices]] or [[manual:chapter3:symbolic|symbolic expressions]]. 
 + 
 +Most operators are //binary// i.e. they need two arguments and when used within symbolic expressions are distinguished by the fact that they adopt the //infix// notation. There also are a few //unary// operators adopting the //prefix// notation in symbolics (unary ''+'' and ''-'') and also one operator adopting //postfix// notation (''!'', the factorial operator). 
 + 
 +The basic arithmetic operators work as expected (''+'' and ''/'' were already introduced), taking objects from the stack and leaving the result of the operation. Test operators (''>'', ''<'', ''≤'', ''≥'', ''=='' ) take two objects from the stack, perform a comparison and leave a 1 on the stack if the test was true, and a 0 if the test failed. The true condition is always represented with the number 1, while the false condition is always represented with the number 0. 
 + 
 +=== Functions === 
 + 
 +Functions, like operators, manipulate objects and return results. They can be inserted into symbolic expressions, adopting a //functional// notation (i.e. their name is followed by a list of parameters enclosed by parentheses) but differ from analytic functions by the fact that they cannot be differentiated or integrated, either because they returns non numerical objects (''PHERMITE'', ''PMUL'') or because they are not continuous and/or differentiable (''ISPRIME?'', ''RAND'', ''MIN'').
  
-In the examples above we showed how + and / would take some objects from the stack, operate on them and place the result in the stack. This is the basic operation of all operators and commands in RPL. All commands and operators take some (or none) arguments from the stack, and leave some (or none) results in it. There are hundreds of RPL commands, all based on the same principle of taking and leaving objects on the stack. Future chapters will describe each command in depth, for now only a few commands will be introduced that define the basic core of the RPL language. The basic arithmetic operators work as expected (+ and / were already introduced), taking objects from the stack and leaving the result of the operation. Test operators (>, <, ≤, ≥, == ) take two objects from the stack, perform a comparison and leave a 1 on the stack if the test was true, and a 0 if the test failed. The true condition is always represented with the number 1, while the false condition is always represented with the number 0.+=== Analytic Functions ===
  
 +Analytic functions are a subset of the functions that conform to the layman's concept of mathematical function: they take one or more numerical arguments and return one. Usually are continuous and/or differentiable and include trigonometric (''SIN'', ''ACOS'') and hyperbolic (''LN'', ''TANH'') functions.
 ---- ----
  
Line 46: Line 73:
 Programs may take values from the stack, just like any RPL operator or command. To use values from the stack, a program simply needs to assume they are there and operate on them. Our previous example could be rewritten as: Programs may take values from the stack, just like any RPL operator or command. To use values from the stack, a program simply needs to assume they are there and operate on them. Our previous example could be rewritten as:
  
-<code>« + 2 / »</code>+<code>« 
 +  + 
 +  2 / 
 +»</code>
  
 This short program runs the operator + as its first command. Previously, we had included in the program the numbers 1 and 2, which were put on the stack. This version now expects the user to leave two numbers on the stack before running this program. The program will then add them together, and later divide the result by two (computing the average). This short program runs the operator + as its first command. Previously, we had included in the program the numbers 1 and 2, which were put on the stack. This version now expects the user to leave two numbers on the stack before running this program. The program will then add them together, and later divide the result by two (computing the average).
Line 61: Line 91:
 Variables are created with the comand ''STO'' (store) which stores an object into a named variable. Variables are created with the comand ''STO'' (store) which stores an object into a named variable.
  
-<code>« 4 'X' STO »</code>+<code>« 
 +  4 'X' STO 
 +»</code>
 The program above stores the number 4 in a variable named ''X''. Notice the name of a variable must be enclosed in single quotes when it refers to the name itself, and without quotes when it refers to the content of a variable. In this case, we want the name ''%%'X'%%'' The program above stores the number 4 in a variable named ''X''. Notice the name of a variable must be enclosed in single quotes when it refers to the name itself, and without quotes when it refers to the content of a variable. In this case, we want the name ''%%'X'%%''
  to be put on the stack, to be used by the ''STO'' command.  to be put on the stack, to be used by the ''STO'' command.
Line 357: Line 389:
 will leave the numbers 1,3,5,7,9 on the stack. will leave the numbers 1,3,5,7,9 on the stack.
  
 +
 +The behavior of the ''NEXT'' statement is different from the ''STEP'' statement:
 +  * ''NEXT'' always increments the counter by 1, while ''STEP'' could go either direction or leave the same value.
 +  * ''NEXT'' always checks if the counter is ≤ end value to continue the loop. ''STEP'' checks if the counter is ≤ or ≥ end value depending on the direction of the loop.
 +
 +When using ''STEP'', the direction of a loop is determined by the initial start and end values. If the end value is higher than the start value (therefore counting up), the loop will continue while the variable is less than or equal to the end value. On the contrary, if the end value is lower than the start value, the loop will continue as long as the variable is greater than or equal to the end value.
 +
 +When ''STEP'' is used, the magnitude and direction of the step do not affect the condition to end the loop. For example:
 +
 +<file>
 +« 1 'S' STO 
 +    1 10 FOR J 
 +        J 
 +        IF J 4 == THEN -1 'S' STO END
 +        IF J 1 == THEN 2 'S' STO END
 +    S STEP
 +»
 +</file>
 +
 +In the above example ''J'' will count from 1 to 10 (therefore this is a loop counting up) with a step ''S''. The loop begins with a step of 1, being stored in ''S''. The loop will run leaving the values of J in the stack, initially 1,2,3,4 then the condition in the ''IF'' statement becomes true and the step changes to -1.
 +The loop will now begin counting down 3,2,1 and the second ''IF'' statement becomes true, changing the step to 2. The loop will continue running 3,5,7,9, and then the loop will exit when the counter is >10. The complete sequence generated by the code above is then 1,2,3,4,3,2,1,3,5,7,9.
 +
 +When ''NEXT'' is used, the direction is always assumed to be up regardless of start and end values, therefore the following loop:
 +
 +<file>
 +« A 10 FOR J J NEXT »
 +</file>
 +
 +Will produce the following outputs, depending on the value of ''A'':
 +
 +  * ''A=1'' will produce 1,2,3,4,5,6,7,8,9,10
 +  * ''A=10'' it will produce 10
 +  * ''A=11'' it will produce 11
 +
 +Notice that despite the starting value being higher than the end value and the loop using ''NEXT'' (therefore it's a assumed to be a loop counting up), the loop executed at least once. This is because the decision to exit the loop is made when ''NEXT'' is reached.
 +
 +Now let's review a loop using ''STEP'' with a positive step:
 +
 +<file>
 +« A 10 FOR J J 1 STEP »
 +</file>
 +
 +Will produce the following outputs, depending on the value of ''A'':
 +
 +  * ''A=1'' will produce 1,2,3,4,5,6,7,8,9,10
 +  * ''A=10'' it will produce 10
 +  * ''A=11'' it will produce 11,12,13,14,15,... infinite loop
 +
 +Notice that while the loop appears to count up by looking at the code, the condition A>10 causes the loop to be counting down because the start value is larger than the end value, and therefore it will only end when J<10, regardless of the magnitude and direction of the step. Since the step increases the counter, the loop never ends.
 +
 +In some situations it is desirable to keep the direction of the loop fixed regardless of the start/end values. The ''FORUP'' and ''FORDN'' commands can be used in lieu of ''FOR''. These two variants have two advantages:
 +  * The direction of the loop is fixed and known, regardless of the values the limits might have at run time.
 +  * The loop has one additional check when the word ''FORUP'' or ''FORDN'' is executed. This allows for early exit without being forced to execute the loop clause.
 +
 +Back to the example used above for ''NEXT'' but in this case using FORUP:
 +
 +<file>
 +« A 10 FORUP J J NEXT »
 +</file>
 +
 +Will produce the following outputs, depending on the value of ''A'':
 +
 +  * ''A=1'' will produce 1,2,3,4,5,6,7,8,9,10
 +  * ''A=10'' it will produce 10
 +  * ''A=11'' it will not produce any output
 +
 +It differs from using ''FOR'' in the last case: the clause between ''FORUP'' and ''NEXT'' is never executed because the starting value was already larger than the end limit.
 +
 +On the other end:
 +<file>
 +« A 10 FORDN J J -1 STEP »
 +</file>
 +
 +  * ''A=1'' will produce no output
 +  * ''A=10'' it will produce 10
 +  * ''A=11'' will produce 11,10
 +
 +Note that ''NEXT'' always considers the loop direction going up, therefore ''NEXT'' is not compatible with ''FORDN'' which contradicts that assumption.
 +
 +Summarizing, the main differences between all the ''FOR'' constructs:
 +
 +     * ''FOR'' may count up or down, and may be used with both ''NEXT'' and ''STEP''. The loop clause is always executed at least once.
 +     * ''FORUP'' always counts up, may be used with ''NEXT'' or ''STEP''. The loop clause is not executed if the starting value is greater than the end value.
 +     * ''FORDN'' always counts down, can only be used with ''STEP''. The loop clause is not executed if the starting value is less than the end value.
 +
 +
 + 
 === DO loops === === DO loops ===
 The syntax for this construct is: The syntax for this construct is:
  • manual/chapter5/basics.txt
  • Last modified: 2021/09/15 10:32
  • by claudio