Python to RPN - Examples

Example
Starting Out If you are transitioning to Python, this is the example for you. We start by defining a label at the top of your Python program, which will become the first string label in your generated HP42 RPN program. You can then execute code beginning at `main` on the 42S or Free42 by pressing the `XEQ` button followed by the menu button `MAIN`. Of course you can call your program anything you like - although only the first 7 characters of any label or function name are used (42S limitation). Note that if you are a Python programmer, there are no such things as labels - so think of this code example as a module (file) and the syntax LBL("main") as a hack to be able to execute that module from the command line, which you would usually do with `python some_module.py`. We then assign some variables e.g. `length`, and call a subroutine called `report()` which displays them. The 'report' subroutine will end up with LBL A in the generated RPN, and will therefore be anonymous - which is usually what you want with helper functions. If you don't define a LBL then the first function you define with 'def' becomes the first string label of your generated RPN program. The benefit of using LBL at the top of your program is that you can define variables in the outermost 'global' scope of the Python program, which is outside of any function. These variables will then become accessible inside all functions - often very handy. Python looks for variables by looking in the current function, and if not found, looks to the outer function etc. all the way out to the global scope, which is outside any function. On the other hand, if you define variables inside functions, those variables are private to those functions - the only way to communicate them to other functions is to pass them as parameters to those other functions.	`LBL("main") length = 10 width = 20 report() def report(): print('length is', length, '[LF]width is', width)`	Load in Converter Editor
Demo 1 This example shows off many things: for loops, variable assignments and function calls incl. the passing of parameters. Notice the nifty lowercase `print()` function, which takes long strings and breaks them up for you, making it easier to create messages in the alpha register. You can also build up long message strings by referring to variable names mixed in with descriptive text. e.g. `print('Counter ', i, ' result= ', total)` Time saver! P.S. The only difference between alpha() and print() is that print() adds an AVIEW to the RPN. Also `print()` is a synonym for AVIEW(), and would be familiar to Python programmers.	`def demo(): total = 0 for i in range(10): result = calc_something(i, 5) print('Counter', i, 'result=', total) total += result print('Final total was:', total) def calc_something(a,b): # adds two numbers then squares them return (a + b)**2`	Load in Converter Editor
Long expressions You can type in long complex expressions and they will be converted to RPN. There are limits to how big your expressions can be, because of the HP42S four level stack. The conversion process will generate an error if the stack is at risk. `x = 1+2(3+4) # ok x = 1+2(3+4)(5+6) # still ok x = 1+2(3+4)(5+67) # too complex for 4 level stack by 1 x = 1+2(3+4(5+6(7+89))) # really too complex for 4 level stack!`	`x = 1 + 2 * 6 + 1 * 9 / 100 + 1 + 2 * 6 y = ((1 + 2) * (6 + 2 - 3) * (2 + 7)) / 200 # brackets`	Load in Converter Editor
Varmenu A “variable menu” is a technique for displaying a HP42S menu containing the names of several variables. See page 92 of the HP42S manual. You can then take your time storing values into those variables, and reviewing them, using those same menu buttons (no need to use STO) - then press R/S to continue into the calculation. The Python to RPN converter supports the traditional native commands needed to use this handy facility, as well as supporting an easier way using `varmenu()`. The simplified varmenu() technique allows you to specify all the variables in the one function call. Then in the generated RPN, “boilerplate” calls to MVAR, VARMENU, STOP and EXITALL are automatically inserted for you. Traditional Technique: `def area_traditional(): # traditional technique MVAR("length") MVAR("width") VARMENU("mvadd") STOP() EXITALL() return length * width`	`def area_app(): varmenu("length", "width") # new easy technique return length * width`	Load in Converter Editor
Prompting for input You need to specify native uppercase HP42S commands in your Python code for doing user input. The basic difference between HP42S native PROMPT and INPUT is that the former specifies a custom text prompt, whilst the latter prompts with the name of the variable, and shows the current value of that variable. Both commands stop program execution till you press R/S on the calculator. INPUT Takes a normal Python variable as a parameter - do not put variable in quotes. Specifying HP42S registers not supported. E.g. `INPUT(v2)` PROMPT Display the Alpha register and halts program execution. To store the value entered during the prompt into a variable simply assign to that variable e.g. `myvar = PROMPT('enter val')`. Remember that you must type a numeric value, then when ready, hit R/S on your calculator to continue running the program after a prompt. * * * Discussions How Python variables are converted to RPN You generally don't have to worry about how Python variables are converted to either RPN named variables vs RPN registers - because when you are programming in Python, you don't really care how your Python variables are converted to RPN. You just basicaly think in Python and treat the generated RPN as "machine code" that you never look at. However, for those interested, read the "RPN tips" in the example code for information on what RPN code is generated. You might be interested in this if you want your Python program to end up with some RPN named variables for use and access later. Its easy to access named variables rather than have to figure out what random numbered register might have been used to store the Python variable. But on the other hand, named variables pollute the global HP42S namespace, thus generally its better to allow the default behaviour of using numbered registers. Interestingly the default numbered register behaviour is not followed with the INPUT command: the variable referred to as the parameter will be converted into RPN as a named variable rather than converted into an auto allocated numbered RPN register. The only exception to this rule is if that variable has previously been assigned to - then it will be converted into RPN as an auto allocated numbered register. I'm not sure why this implementation decision was made and this behaviour may be change in the future. Using AVIEW and INPUT together Interestingly, I have observed that if you do a AVIEW("some message") prior to an INPUT, you get the message on the top line of the HP42S and the input prompt on the second line - nice. Warning: If you are viewing a message using AVIEW("some really long multi-line message") that takes up two lines, then you won't see the subsequent prompt generated by INPUT. This is because the prompt on the second line of the HP42S display is occupied by the multiline alpha string and the INPUT command doesn't seem to clear it. To work around this edge case of Free42/HP42S? behaviour view an empty string in the alpha register using print(""). Clearing the alpha register with CLA() is not enough. Discussion on the forum here. Future developments There is a proposal for this Python to RPN converter to support the native Python `input()` command but this is not yet supported.	LBL("user_input_examples") # Ask user for input and store into named variable v1 # The prompt by the calculator will be the name of # the variable. RPN tip: Python "v1" is # converted/mapped to RPN named variable "v1" INPUT(v1) print("You entered", v1, "answer is", v1 + 200) PSE() PSE() # clear long message in alpha or you won't see # next input prompt print("") # Ask user for number input and store into variable v2 # The prompt by the calculator will be the name of the # variable RPN tip: Python "v2" is converted/mapped to # RPN auto allocated numbered register, due to early # use/initialisation of variable v2 v2 = 100 INPUT(v2) print("You entered", v2, "answer is", v2 + 1) PSE() PSE() # Prompt user with "length?" prompt and store result # into variable length RPN tip: Python "length" mapped # to auto allocated numbered register # 0 # optionally set initial value in RPN X register myvar = PROMPT("length?") print("sine of", myvar, "is", SIN(myvar)) PSE() PSE() # Prompt user with "enter something!" prompt # and store result into variable MYVAR # RPN tip: Python "MYVAR" mapped to RPN named variable # MYVAR, because MYVAR is uppercase in Python # (it's the converter's convention to map lowercase # variables to RPN auto allocated numbered registers # and to map uppercase Python variables to # RPN named variables # 0 # optionally set initial value in RPN X register MYVAR = PROMPT("enter something!") print("you entered", MYVAR) PSE() PSE() # Prompt user with "enter value:" prompt and store # the result into Python variable "myvar" # RPN tip: Python variable "myvar" mapped to RPN named # variable "myvar", because of the comment # "# rpn: named" which is a special directive to the # converter to please create a named RPN variable, which # is not the default conversion behaviour. # 0 # optionally set initial value in RPN X register myvar = PROMPT("enter value:") # rpn: named print("thank you, you entered", myvar) long_pause() print("Finished demo, thank you.") # Util def long_pause(): for i in range(3): PSE()	Load in Converter Editor
Matrix Looping Looping through a matrix.	`def loop_matrix(): m = NEWMAT(2,4) # two rows, four columns for row in range(2): # 0..2 excluding 2 for col in range(4): # 0..4 excluding 4 print('row', row, 'col', col, 'value', m[row, col])`	Load in Converter Editor
Lists You must use uppercase variables for lists. You can also initialise a list with values then append to it later e.g. `A = [200] A.append(5)` Lists are implemented as matrices with one column, and as many rows as is needed (matrix grows as you append elements). You can get elements of an array with e.g. `A[2]` though remember Python lists are 0 based, so to get the first element, you want `A[0]`. You can of course also set elements of an array e.g. `def set_array_n_to_99(n): A = [1,2,3] A[n] = 99` You can even store short strings (max 6 chars) as list elements in lists. `def strmanip(): A = ["hi", "there"] A[0] = "hello"`	`def a10(): A = [] for i in range(10): A.append(i)`	Load in Converter Editor
For loops For loops a common way of looping in Python. The range function specifies from, to and step. You can leave out 'step' and it defaults to a step of 1. Note that under the hood, for range loops are implemented with RPN's `ISG` command, which has a max of 1000 due to the ISG ccccccc.fffii format of fff. If you want to loop more than 1000 then use a while loop and your own counter variable. I might add a rpn: comment directive one day to bypass ISG and implement for using while loops automatically.	`def for_demo(): total = 0 for i in range(10): # from 0 to 10 (but excluding 10) total += i for x in range(5,500, 50): # from 5 to 500 in steps of 50 total = x for i in range(1,5): # if you leave step out, it defaults to 1. if i == 2: break total = total total ALL() # change display to show all digits print('Final total was:', total)`	Load in Converter Editor
While While loops are a fantastic alternative to `for` loops. Continue and break are supported.	`def while_demo(): # while loop n = 0 total = 0 while n < 100: n += 1 total += SIN(n) print('done', total) # continue and break are supported n = 0 while n < 100: n += 1 if n > 60: continue if n == 50: break`	Load in Converter Editor
Menu The "programmable menu" feature of the HP42S lets you create your own menu - pressing the key underneath each menu item will execute the associated function. There is both a traditional and new simplified way of building these menus. The new simplified `menu()` function takes a list of string menu items - representing the function names you want to call. The assigning to keys and all other wiring will be done automatically. You must of course define the user functions being called, which by default will be converted into local labels beginning with A, and thus won't pollute the global namespace. If you want one of your called functions to be a named label, then as usual, use the comment directive `rpn: export` on the function definition 'def' line. If you want to pass parameters to your functions then key them in onto the stack before pressing the menu button. For example to satisfy the call to `add(a, b)` type `10 ENTER 20` before pressing the menu button for add. The number 10 will arrive as the parameter 'a' and 20 will arrive as the parameter 'b'. Traditional MENU technique If you want to build HP42S the traditional way you can do so thus: `def ui1_traditional(): # traditional technique CLMENU() "Do A" KEYG(1, "do_a") "B" KEYG(2, "do_b") MENU() def do_a(): # this will turn into local label A print('you chose blah1') def do_b(): # this will be a named label - rpn: export print('you chose blah2')` The traditional approach is more laborious, but gives you the advantage of being able to call the menu items something different than the name of the function e.g. notice above that the menu item "Do A" calls the function do_a. With the traditional approach you may need to clear the menu before you build it - because old MENU definitions hang around till explicitly cleared. The simplified `menu()` automatically does a `CLMENU` for you. Finally, the simplified menu() command implements `KEYG` semantics, which means each key will run the specified function - this is the behaviour most people expect. If you actually want the KEYX semantics of XEQ then you will need to build the menu in the traditional way, where you get more control and can specify either KEYG or KEYX.	`def ui1(): menu("hello", "func2", "add") # new easy menu technique def hello(): print('you chose hello') def func2(): print('you chose func2') return 50 def add(a, b): return a + b`	Load in Converter Editor
Square a matrix Creates a matrix of 2's and square them into 4's, then checks the result.	`def matsquare(): m = NEWMAT(1,4) m += 2 # make every element in matrix equal 2 m = m**2 # matrix ^2 i.e. square each element PRX(m) # print the matrix to printer for col in range(4): assert m[0,col] == 4 # ensure the correct result print('correct result in all matrix cells')`	Load in Converter Editor
Complex test Test of complex number handling. Note that the HP42S commands `COMPLEX`, `toPOL` and `toREC` can take either one or two parameters - and return either one or two parameters. See HP42S RPN reference page on this website or study this example for details. The Python way of entering complex numbers is also supported viz. You can also enter complex numbers without this COMPLEX function using native Python syntax e.g. `0 + 1j` which is engineering notation for `0 + i1`. Yes, Python uses the letter 'j' not the letter 'i' and puts it after the imaginary number, not before.	def complex_play(): RAD() # Set angular mode RECT() # Set coordinate mode FIX(3) # For effective comparisons, need to round down with RND # Arbitrarily set here so that RND will adhere to 3 decimal places # Use native Python syntax for entering complex numbers c = (5 + 3j) + (7 - 9j) assert c == (12 - 6j) assert isCPX(c) # Use HP42 way of entering complex numbers c = COMPLEX(5, 3) + COMPLEX(7, -9) assert c == (12 - 6j) assert isCPX(c) # Break a complex number into its parts real, imag = COMPLEX(c) assert real == 12 assert IP(imag) == -6 # Convert a complex number from RAD to POL cpol = toPOL(c) # check result real, imag = COMPLEX(cpol) assert RND(real) == 13.416 assert RND(imag) == -0.464 # another way of checking the result assert RND(cpol) == RND(COMPLEX(13.416, -0.464)) # or more pythonically assert RND(cpol) == RND(13.416 - 0.464j) # Convert the complex number back to RAD angular mode c = toREC(cpol) real, imag = COMPLEX(c) assert real == 12 assert IP(imag) == -6 # Some operations result in a complex number # If you suspect this might happen, use the 'rpn: named' directive # so that the resulting complex number gets assigned to a named variable # and not the default, which is a numbered register. Tricky! csq = SQRT(-25) # rpn: named real, imag = COMPLEX(csq) # check result which should be 0 + i5 assert real == 0 assert IP(imag) == 5 # check again assert RND(csq) == RND(0 + 5j) # check again assert RND(csq) == RND(COMPLEX(0, 5)) # to polar and check again cpol = toPOL(csq) assert RND(cpol) == RND(COMPLEX(5, 1.571)) assert RND(cpol) == RND(5 + 1.571j) # To polar can also take two parameters. # Converts x and y to the corresponding polar coordinates r and θ. a, b = toPOL(1, 2) assert RND(a) == 0.464 assert RND(b) == 2.236 # To rect can also take two parameters. a, b = toREC(1, 2) assert RND(a) == 1.683 assert RND(b) == 1.081 print('complex tests pass ok')	Load in Converter Editor
Calculate Pi My version of Walsh algorithm to calculate pi by adding 1/n where n is 1, 3, 5, 7... where you add and subtract alternately. Note that the variable 'subtract' is a boolean, and controls whether we are doing an add or a subtract operation. In HP42S we would have used a flag - in Python we simply use any variable as a flag. Note that when converted to RPN, True and False map to the values 1 and 0, though in Python any non zero value will be treated as True. Note: Call this with max iterations of max 1000 because RPN's ISG has max of 1000. To work around this, the loop could be done with a regular variable and a while loop, which has no limitations. Or the converter could be changed to implement for loops without ISG.	`def calc_pi(max_iterations): result = 1.0 subtract = True for i in range(3, max_iterations, 2): if subtract: result -= 1.0/i subtract = False else: result += 1.0/i subtract = True result *= 4 return result`	Load in Converter Editor
While else Not many people know this advanced Python syntax for while. The else clause is only executed when your while condition becomes false. If you break out of the loop, or if an exception is raised, it won't be executed. The else clause is executed if you exit a block normally, by hitting the loop condition or falling off the bottom of a try block. It is not executed if you break or return out of a block, or raise an exception. It works for not only while and for loops, but also try blocks.	`# while..else is supported n = 10 while n > 2: n -= 1 else: VIEW(n)`	Load in Converter Editor
Variables The directive rpn: named will force a Python variable to be mapped to a HP42S register of the same name, instead of being mapped to a numeric register. Use this directive any time you want a a Python variable to be stored in a HP42S lowercase named register mapping instead of the default numbered register. Normally Python variables are mapped to numeric registers 00..nn in order to avoid polluting the HP42S global variable namespace. However in some circumstances you may wish to expose the variable to look at or use later. This directive forces the converter to allocate a named register. For example, its useful for the INPUT command to be given descriptive variable names e.g. Normally `INPUT(weight)` would result in INPUT 00, resulting in a user prompt for 00 which is not really helpful. You could work around this and use the uppercase convention whereby all uppercase Python variables are named resigter thus `INPUT(WEIGHT)` would result in INPUT "WEIGHT". But if you prefer lower case, you can use the directive and `INPUT(weight) # rpn: named` which would result in INPUT "weight".	`x = 100 y = 100 # rpn: named INPUT(weight) # rpn: named`	Load in Converter Editor
Assign to variable All lowercase python variables (recommended) are mapped to RPN registers, in the order that the converter parser sees them. Thus a = 10 and b = 20 will be mapped to registers 00 and 01 respectively. All uppercase python variables are mapped to named string variables. Thus X = 10 will be mapped to register “X”. To allow the creation of lowercase or mixed case named HP42S registers from your Python variable names by using the rpn directive “named” e.g. y = 100 # rpn: named Lists and Dictionaries are always mapped to named registers, because they are implemented as matrices, which need to be in named registers.	`x = 1 # will store 1 in a numbered register Y = 1 # will store 1 in a named register "Y" a = [1] # will store an list in named register "a"`	Load in Converter Editor
Displaying Information Example of all the ways you can display info to the user. And how to prompt for input.	""" To run this example, just keep hitting R/S to move past the stop points. """ def ui_display_info(): # Easiest way to display a message print('Hello world, it is a really big world.') STOP() # Mix strings and numbers print('The value', 2, 'is bigger than', 1) STOP() # Specifying a lone string on a line will enter it into the alpha # register but only the first six chars will make it. "this is a string" AVIEW() STOP() # Use the new alpha() function to add any length string into the alpha register alpha("this is a really long string") AVIEW() STOP() # All alpha/print/AVIEW/PROMPT commands take the 'append' option, print(' added more info', append=True) STOP() # Control the formatting of numbers by setting the FIX/SCI/ENG mode FIX(1) # The 'sep' keyword lets you remove the space that usually # gets inserted between each parameter. You can set sep to nothing. print("this", 1, "is", 2, "my", 3, "string", sep='') STOP() # You can set sep to a different character. print("this", 1, "is", 2, "my", 3, "string", sep='\|') STOP() # PROMPT auto stops so no explicit STOP() is needed PROMPT('This is a prompt - press r/s to continue') # PROMPT auto stops and stores the number you type in, into the variable myvar myvar = PROMPT('Please enter a value') # INPUT takes a variable name, do not put variable in quotes # Pressing R/S (or ■SST) stores what you enter into x into the variable INPUT(val) # Show a variable with VIEW # Does not support multiple parameters. 42S auto adds a label. #val = 42 VIEW(val) STOP() # Clear the alpha register, though not usually needed because # new messages auto clear the alpha register, unless append=True CLA() alpha("the val = ") # ARCL has the same multi parameter features as alpha, except always # appends to the alpha register. ARCL(val) AVIEW() STOP() # AIP appends the Integer part of x to the Alpha register. alpha('The integer portion of', val2, 'is ') val2 = 12.34 AIP(val2) AVIEW() STOP() print('done')	Load in Converter Editor
Test code for arrays and dictionaries Test code for arrays and dictionaries - runs a suite of tests on your calculator.	# Test code for arrays and dictionaries def t1(): # List tests b = [1, 2, 3] b.append(4) assert b[0] == 1 assert b[1] == 2 assert b[2] == 3 assert b[3] == 4 assert b[-1] == 4 b[2] = 333 assert b[2] == 333 assert b[-2] == 333 b2 = b assert b[0] == 1 assert b[-4] == 1 b = [1, 2, 3] assert len(b) == 3 assert b[-1] == 3 b.pop() assert b[-1] == 2 # List alpha tests b = ['a', 'b', 'c'] assert b[0] == 'a' assert b[-1] == 'c' b.append('fred') assert b[3] == 'fred' assert b[-1] == 'fred' # Dictionary tests d = {1: 11, 5: 22} assert d[5] == 22 assert d[1] == 11 d[1] = 88 assert d[1] == 88 d[6] = 66 assert d[6] == 66 assert d[5] == 22 assert d[1] == 88 # PROMPT(A[1]) # PROMPT(A[222]) # Alpha Dictionary tests d = {'first': 11, 'second': 22} assert d['second'] == 22 assert d['first'] == 11 d['another'] = 33 assert d['another'] == 33 # test dictionary assignment to another variable a = {'aa': 2, 'bb': 3} d2 = d # though will create copy not reference - unlike real Python assert d2['another'] == 33 print("all tests pass")	Load in Converter Editor
Reciprocal To generate the HP42S command 1/X use function Reciprocal. This renaming was necessary because Python does not accept / and many other symbols as part of function names. There are a few other renamed function - for a complete list click on help and then click on RPN command reference.	`def input_reciprocal(): INPUT(weight) print("1/weight of", weight, "is", Reciprocal(weight))`	Load in Converter Editor
Multiple return values Traditionally in RPN you can return multiple values from a subroutine by pushing those values onto the stack. In Python you can return multiple values from a function using the return statement e.g. `return c, b+1`. These values can then be assigned to multiple variables e.g. `a, b = calc(1, 2)`. Various HP42S commands return multiple values and to access those values you will need to use this Python tuple syntax. For example the `→POL` command which is accessed from Python using `toPOL()` is called like this: `a, b = toPOL(1, 2)`	`def multret(): a, b = calc(1, 2) assert a == 100 assert b == 3 print("multiple return values works ok") def calc(a,b): c = a * 100 return c, b+1`	Load in Converter Editor
Nested Menus An example of using a master menu in the global scope, launching various sub functions, including a sub menu. Hit the Exit button on Free42 to back out of the submenu.	`LBL("nested_menus") length = 10 width = 20 menu("hello", "report", "add", "sub") def hello(): print('you chose hello') def report(): print('length is', length, '[LF]width is', width) def add(a, b): return a + b def sub(): menu("ha1", "hello") KEYG(9, "nested_menus") # sets Exit button to jump to start def ha1(): print('you laughed ha')`	Load in Converter Editor
Edit a matrix Creates a matrix and then calls up the built in HP42S matrix editor. In the editor, you can navigate to all the cells and also modify cell values. When you exit the editor by hitting the EXIT key on your calculator or Free42, the program will end. Tip: If you want program execution to resume after editing your matrix, you will need to call EDITN inside a RPN program with an outer menu structure, so that when you hit the EXIT key you will return to the main menu, and then can hit another menu key to continue some processing. Here is part of an example from the manual "HP42S Programming Examples and Techniques" p.158 pure RPN code. `... ... EXITALL CLMENU "P" KEY 1 GTO 1 "T" KEY 2 XEQ 02 MENU STOP ... ... LBL 1 ... EDITN "mymatr" ...` TODO: convert the above example into Python.	`def edit_matrix(): m = NEWMAT(1,4) EDITN(m)`	Load in Converter Editor
Matrix Injection Create a matrix of 0’s and inject into it a matrix of 1’s. Then goes on to visualise the matrix as pixels! See the full explanation of this example in the help file, including discussion about the NumPy compatible syntax being used here.	`def numpy1(): zeros = NEWMAT(10,11) ones = NEWMAT(2,3) ones += 1 #PRX(zeros) #PRX(ones) ones[0,1] = 99 ones[1,1] = 98 #PRX(ones) zeros[2:4, 5:8] = ones #PRX(zeros) # Visualize the zeros matrix as pixels :-) CLLCD() for row in range(0,10): for col in range(0,11): if zeros[row, col] == 0: PIXEL(row, col)`	Load in Converter Editor
Matrix Multiply Multiply two matrices. `[ 1, 2 x [3, 4 = [3, 4 0, 0 ] 0, 0 ] 0, 0 ]` Its a kind of boring example. Note that there is a special technique to multiplying matrices, click here to learn about it. Explore this example in Wolfram. For the curious, the Desktop Python equivalent is `import numpy as np m1 = np.array([[1,2],[0,0]]) m2 = np.array([3,4],[0,0]]) m1 @ m2 #result array([[3, 4], [0, 0]])`	`def matrix_multiply(): m1 = NEWMAT(2,2) m1[0,0] = 1 m1[0,1] = 2 m2 = NEWMAT(2,2) m2[0,0] = 3 m2[0,1] = 4 mresult = m1 * m2 PRV(mresult) assert mresult[0,0] == 3 assert mresult[0,1] == 4 assert mresult[1,0] == 0 assert mresult[1,1] == 0 return mresult`	Load in Converter Editor
DIM Matrixes Create, redimension and test the size of matrices.	`def dim_matrix(): m = NEWMAT(1, 4) rows, cols = whatDIM(m) assert rows == 1 assert cols == 4 m.dim(2,3) rows, cols = whatDIM(m) assert rows == 2 assert cols == 3 print('matrix dim functions ok')`	Load in Converter Editor
Complex Matrices Complex matrices test.	def matrix_complex_play(): RAD() RECT() FIX(4) m1 = NEWMAT(1,4) m2 = NEWMAT(1,4) complex_matrix = COMPLEX(m1, m2) #assert isCPX(complex_matrix) # HP42S does not say yes to this complex_matrix[0,0] = (5 + 3j) # remember Python matrices are 0 based val = complex_matrix[0,0] assert val == (5 + 3j) assert val == COMPLEX(5, 3) # Convert complex matrix into two normal matrices m1, m2 = COMPLEX(complex_matrix) assert not isCPX(m1) assert not isCPX(m2) # Check the contents of the individual matrices assert m1[0,0] == 5 assert m2[0,0] == 3 print('complex matrix tests pass ok')	Load in Converter Editor
List and Dict lookup operations Demo of list and dict lookup operations.	`# test of list and dict lookups def z1(): X = [1,2,3,4] PROMPT('element 2 in list is', X[2], 'should be 3') Y = {1:99, 2:100} PROMPT('key 2 in dict is', Y[2], 'should be 100')`	Load in Converter Editor
If A very simple example of if else and expressions. A function which figures out which number is bigger than another, and displays a message on the screen telling you the result. To run `bigger(100, 1)` load the RPN into your calculator then type `100 ENTER 1 XEQ "bigger"`	`def bigger(a, b): if a > b: print('Param a=', a, ' is bigger than b=', b, ' yey!') else: print('Param a=', a, ' is not bigger than b=', b, ' sorry!')`	Load in Converter Editor
Range by 2 range with step of two	`def by2(): n = 10 for i in range(-50, 200, n): print('Counter ', i)`	Load in Converter Editor
Flags Flags are not used in Python programming - instead, any Python variable can be used to hold a boolean. However if you need to test, set or clear various HP42S flags then use these functions: `CF`, `SF`, FS? use `isFS` and for FC? use `isFC`. Note these all take the flag number as a parameter. This example tests if system flag 21 (controls print on/off from within a HP42S/Free42 program) is set. Note that the HP42S commands `FS?, FC?, FC?C and FS?C` are not supported because they are flow of control altering commands - not relevant in Python programming. Those commands are not even legal Python syntax (no question marks allowed).	`isFS(21)`	Load in Converter Editor
Fibonacci Found the algorithm here, and adapted it slightly because multiple return statements are not yet supported by the converter. Results in Python and in Free42 are the same: `10 XEQ "fib"` gives 55. `40 XEQ "fib"` gives 102,334,155. TODO: now that returning multiple values has been implemented, this example could be altered.	`def fib(n): a = 0 b = 1 for i in range(0, n): old_b = b b = a + b a = old_b return a`	Load in Converter Editor
Export directive Every function you define with def (except for the first one) will be a local function with a local label. By adding `# rpn: export` next to the def, it will be converted into a global string label.	`def main(): useful() def useful(): # rpn: export pass`	Load in Converter Editor
Pixel drawing Drawing with pixels.	`def dr1(): for i in range(1,132,2): PIXEL(5,i)`	Load in Converter Editor
Drawing Lines Drawing lines.	def dd1(): FIX(0) CLLCD() draw_line(0, 0, 10, 10) draw_line(10, 10, 20, 5) draw_line(20, 5, 100, 16) draw_line(100, 16, 131, 1) def draw_line(x0, y0, x1, y1): dx = ABS(x1 - x0) dy = ABS(y1 - y0) if x0 < x1: sx = 1 else: sx = -1 if y0 < y1: sy = 1 else: sy = -1 err = dx - dy done = 0 while not done: #alpha('pixel ', x0, ' ', y0) #PRA() PIXEL(y0, x0); # note col, row not row, col #alpha('if ', x0, ' ', x1, ' ', y0, ' ', y1) #PRA() if (x0 == x1) and (y0 == y1): done = 1 else: e2 = 2 * err if e2 > -dy: err = err - dy x0 = x0 + sx if e2 < dx: err = err + dx y0 = y0 + sy	Load in Converter Editor
Draw Demo 1 Massive demo of drawing with lines, circles, rectangles, filled rectangles and filled circles. Warning: you need to increase the number of registers from the default of 25 to something like 60 using `SIZE 0060` The graphic drawing functions are: draw_line(x0, y0, x1, y1) draw_rect(x0, y0, w, h) fill_rect(x0, y0, w, h) draw_circle(x0, y0, r) fill_circle(x0, y0, r) About coordinate systems. These drawing routines are based on C and javascript algorithms which use a coordinate system: `0,0 --- MAX x \| \| MAX x` which is similar to the HP42S graphic coordinate system `1,1 --- MAX col \| \| MAX row` Besides the 0 based vs 1 based difference, the main thing to note is that these drawing algorithms treat left to right as x, like on a graph - which sounds right, doesn't it? Interestingly, the 42S treats left to right as columns - which also sounds right when thinking about matrices and tables. Both ways are 'right' depending on what convention you want to adopt. Why does this matter? If you study these algorithms, you will notice that the original (C and javascript) implementation's calls to pixel(x,y) have been altered into the 42S way of PIXEL(y,x) which means PIXEL(row, col) in the 42S world. In other words, these drawing algorithm graphic x,y coordinates translate into col,row coordinates on a 42S and because the PIXEL function takes (row, col), the algorithm calls to pixel have had their parameters swapped. This means that if you are drawing anything with these graphic routines, you need to think about a x,y based coordinate system and not the row,col coordinate system. When calling PIXEL(row, col) directly, then yes of course, think about the row,col coordinate system. The final irony is that PIXEL(row, col) converts into RPN where y:row x:col on the stack - which is as it should be in the HP42S manual. The stack position names happen to correspond perfectly to mapping between these two coordinate system concepts. :-)	""" You want to change the number of registers to about 60 for this code to run on Free42. SIZE 0060 should do it. Run the demos with: XEQ "dd1_dra" XEQ "dd2_dra" XEQ "dd3_dra" """ def dd1_draw_demo1(): FIX(0) SIZE(60) CLLCD() draw_line(0, 0, 10, 10) draw_line(10, 10, 20, 5) draw_line(20, 5, 100, 16) draw_line(100, 16, 131, 1) draw_rect(70, 4, 5, 5) fill_rect(18, 9, 12, 4) draw_circle(96, 8, 5) fill_circle(125, 10, 3) def dd2_draw_demo(): # rpn: export FIX(0) SIZE(60) CLLCD() XRES = 131 YRES = 16 # some pixels for i in range(1, XRES, 5): x = i row = YRES / 2 col = x PIXEL(row, col) # some lines (note the quite likely 'Moire pattern') for i in range(1, XRES / 4, 2): x = i #PRA('moire', 0, 0, x, YRES) draw_line(0, 0, x, YRES) # some rectangles fromx = XRES / 4 fromy = YRES / 2 width = XRES / 4 height = YRES / 4 draw_rect(fromx, fromy, width, height) fromx = XRES / 4 + 10 fromy = YRES / 2 + 4 width = XRES / 4 - 20 height = YRES / 4 draw_rect(fromx, fromy, width, height) fromx = XRES / 8 width = XRES / 4 height = YRES / 4 fill_rect(fromx, 1, width, height) # some circles for i in range(2, YRES / 2, 2): d = i draw_circle(3 * XRES / 4, 2 * YRES / 4, d) fill_circle(15 * XRES / 16, 2 * YRES / 4, YRES / 3) fill_circle(8 * XRES / 13, 3 * YRES / 4, YRES / 2) def dd3_draw_demo1(): # rpn: export SIZE(60) CLLCD() XRES = 131 # change for bigger DM42 display if you like YRES = 16 for x in range(0, XRES/2, 30): draw_line(0, 0, x, YRES) # some rectangles fromx = XRES / 2 width = XRES / 18 height = YRES / 2 fill_rect(fromx, 2, width, height) fromx = XRES / 2 fromy = YRES / 8 width = XRES / 6 height = YRES / 6 draw_rect(fromx, fromy, width, height) # some circles for i in range(2, YRES / 2, 2): d = i draw_circle(3 * XRES / 4, 2 * YRES / 4, d) # some circles for d in range(2, YRES/6, 2): draw_circle(3 * XRES / 4, 2 * YRES / 4, d) def draw_line(x0, y0, x1, y1): # rpn: int dx = ABS(x1 - x0) dy = ABS(y1 - y0) if x0 < x1: sx = 1 else: sx = -1 if y0 < y1: sy = 1 else: sy = -1 err = dx - dy done = 0 while not done: #PRA('pixel', x0, y0) row = y0 col = x0 PIXEL(row, col) if (x0 == x1) and (y0 == y1): done = 1 else: e2 = 2 * err if e2 > -dy: err = err - dy x0 = x0 + sx if e2 < dx: err = err + dx y0 = y0 + sy # (x0, y0) = left top corner coordinates # w = width and h = height def draw_rect(x0, y0, w, h): # rpn: int #PRA('draw_rect', x0, y0, w, h) y1 = y0 + h draw_line(x0, y0, x0 + w, y0) # top draw_line(x0, y0, x0, y1) # left draw_line(x0, y0 + h, x0 + w, y1) # bottom draw_line(x0 + w, y0, x0 + w, y1) # right def fill_rect(x0, y0, w, h): # rpn: int #for (y = 0; y < h; y++): # TODO make any var work in a for loop for i in range(h): # TODO make any var work in a for loop y = i y1 = y0 + y draw_line(x0, y0 + y, x0 + w, y1) def draw_circle(x0, y0, r): # rpn: int x = r; y = 0; radiusError = 1 - x; while (x >= y): # Note: 42S pixel row is a y coordinate (top to bottom), 42S col is the x coordinate (left to right) # So I swap the parameters from the javascript version # PIXEL(-y + x0, -x + y0) # top left # PIXEL(y + x0, -x + y0) # top right # PIXEL(-x + x0, -y + y0) # upper middle left # PIXEL(x + x0, -y + y0) # upper middle right # PIXEL(-x + x0, y + y0) # lower middle left # PIXEL(x + x0, y + y0) # lower middle right # PIXEL(-y + x0, x + y0) # bottom left # PIXEL(y + x0, x + y0) # bottom right PIXEL(-x + y0, -y + x0) # top left PIXEL(-x + y0, y + x0) # top right PIXEL(-y + y0, -x + x0) # upper middle left PIXEL(-y + y0, x + x0) # upper middle right PIXEL(y + y0, -x + x0) # lower middle left PIXEL(y + y0, x + x0) # lower middle right PIXEL(x + y0, -y + x0) # bottom left PIXEL(x + y0, y + x0) # bottom right y += 1; if (radiusError < 0): radiusError += 2 * y + 1 else: x -= 1 radiusError += 2 * (y - x + 1) def fill_circle(x0, y0, r): # rpn: int x = r y = 0 radiusError = 1 - x while (x >= y): fromx = -y + x0 fromy = -x + y0 tox = y + x0 toy = -x + y0 draw_line(fromx, fromy, tox, toy) # top fromx = -x + x0 fromy = -y + y0 tox = x + x0 toy = -y + y0 draw_line(fromx, fromy, tox, toy) # upper middle fromx = -x + x0 fromy = y + y0 tox = x + x0 toy = y + y0 draw_line(fromx, fromy, tox, toy) # lower middle fromx = -y + x0 fromy = x + y0 tox = y + x0 toy = x + y0 draw_line(fromx, fromy, tox, toy) # bottom y += 1 if radiusError < 0: radiusError += 2 * y + 1 else: x -= 1 radiusError += 2 * (y - x + 1)	Load in Converter Editor
Calculate Pi repeatedly This calls the algorithm to calculate PI repeatedly, and shows how the value converges towards real PI as the max iterations increases.	`def calc_pi(max_iterations): result = 1.0 subtract = True for i in range(3, max_iterations, 2): if subtract: result -= 1.0/i subtract = False else: result += 1.0/i subtract = True result *= 4 PRX(result) # print variable return result def cc1(): # rpn: export ALL() calc_pi(4) calc_pi(10) calc_pi(50) calc_pi(100) calc_pi(500) calc_pi(1000) # max is 1000 because RPN's ISG has max of 1000`	Load in Converter Editor
Assert The `assert` statement exists in almost every programming language. When you do... `assert condition` ... you're telling the program to test that condition, and trigger an error if the condition is false. Note: The `assert(2 == 2)` syntax is not recommended, because Python assert does not actually take brackets! `assert` is a keyword and not a function. Thus the brackets will be interpreted as part of an expression, or even as a Python tuple, which may always evaluate True. More info here.	`assert 2 == 2 assert(2 == 2) # not correct, because Python's assert is a keyword and not a function`	Load in Converter Editor
Function to add positive numbers Adds two numbers if they are both positive, otherwise returns 0. Demonstrates, if statements, boolean operations and returning a calculation.	`def add_positive(a, b): # Adds two numbers if they are both positive, otherwise returns 0 if a < 0 or b < 0: return 0 return a+b`	Load in Converter Editor

Starting Out

If you are transitioning to Python, this is the example for you.

We start by defining a label at the top of your Python program, which will become the first string label in your generated HP42 RPN program. You can then execute code beginning at main on the 42S or Free42 by pressing the XEQ button followed by the menu button MAIN. Of course you can call your program anything you like - although only the first 7 characters of any label or function name are used (42S limitation).

Note that if you are a Python programmer, there are no such things as labels - so think of this code example as a module (file) and the syntax LBL("main") as a hack to be able to execute that module from the command line, which you would usually do with python some_module.py.

We then assign some variables e.g. length, and call a subroutine called report() which displays them. The 'report' subroutine will end up with LBL A in the generated RPN, and will therefore be anonymous - which is usually what you want with helper functions.

If you don't define a LBL then the first function you define with 'def' becomes the first string label of your generated RPN program. The benefit of using LBL at the top of your program is that you can define variables in the outermost 'global' scope of the Python program, which is outside of any function. These variables will then become accessible inside all functions - often very handy. Python looks for variables by looking in the current function, and if not found, looks to the outer function etc. all the way out to the global scope, which is outside any function.

On the other hand, if you define variables inside functions, those variables are private to those functions - the only way to communicate them to other functions is to pass them as parameters to those other functions.

LBL("main")

length = 10
width = 20

report()

def report():
  print('length is', length, '[LF]width is', width)

Python to RPN - Examples

Starting Out

Demo 1

Long expressions

Varmenu

Prompting for input

INPUT

PROMPT

Discussions

Matrix Looping

Lists

For loops

While

Menu

Square a matrix

Complex test

Calculate Pi

While else

Variables

Assign to variable

Displaying Information

Test code for arrays and dictionaries

Reciprocal

Multiple return values

Nested Menus

Edit a matrix

Matrix Injection

Matrix Multiply

DIM Matrixes

Complex Matrices

List and Dict lookup operations

If

Range by 2

Flags

Fibonacci

Export directive

Pixel drawing

Drawing Lines

Draw Demo 1

Calculate Pi repeatedly

Assert

Function to add positive numbers

Related Calculator Stuff