Local name (quoted) Local name (unquoted)
Put on the stack. Contents put on the stack
As you can see from this table, most types of objects are simply put on the stack but built-in commands and programs called by name cause execution. The following examples show the results of executing programs containing different sequences of objects.

RPL Programming 1-1

Examples of Program Actions Program "Hello" {A B} '1+2' '1+2' NUM + + EVAL Results 2: 1: 2: 1: 1: 1: 1: 1: "Hello" { A B } '1+2' 2 + 3
Programs can also contain structures. A structure is a program segment with a defined organization. Two basic kinds of structure are available: Local variable structure. The command defines local variable names and a corresponding algebraic or program object that's evaluated using those variables. ! Branching structures. Structure words (like DO UNTILEND) define conditional or loop structures to control the order of execution within a program.
A local variable structure has one of the following organizations inside a program: name1 namen ' algebraic ' name1 namen program The " command removes n objects from the stack and stores them in the named local variables. The algebraic or program object in the structure is automatically evaluated because its an element of the structure even though algebraic and program objects are put on the stack in other situations. Each time a local variable name appears in the algebraic or program object, the variables contents are substituted. So the following program takes two numbers from the stack and returns a numeric result: a b 'ABS(a-b)'
Calculations in a Program
Many calculations in programs take data from the stack. Two typical ways to manipulate stack data are: Stack commands. Operate directly on the objects on the stack. Local variable structures. Store the stack objects in temporary local variables, then use the variable names to represent the data in the following algebraic or program object. Numeric calculations provide convenient examples of these methods. The following programs use two numbers from the stack to calculate the hypotenuse of a right triangle using the formula x 2 + y 2. SQ SWAP SQ + x y x SQ y SQ + x y '(x^2+y^2)' The first program uses stack commands to manipulate the numbers on the stack the calculation uses stack syntax. The second program uses a local variable structure to store and retrieve the numbers the calculation uses stack syntax. The third program also uses a local variable structure the calculation uses algebraic syntax. Note that the underlying formula is most apparent in the third program. This third method is often the easiest to write, read, and debug.

Level 1

" "

Program: r h

Comments: Creates local variables r and h for the radius of the sphere and height of the cap.
'1/3**h^2*(3*r-h)' Expresses the defining procedure. In this program, the defining procedure for the local variable structure is an algebraic expression. NUM OSPHLVK Stores the program in variable SPHLV. Converts expression to a number.
Now use SPHLV to calculate the volume of a spherical cap of radius r =10 and height h = 3. Enter the data on the stack in the correct order, then execute the program. 10 `3 J%SPHLV%

Evaluating Local Names

Local names are evaluated differently from global names. When a global name is evaluated, the object stored in the corresponding variable is itself evaluated. (You've seen how programs stored in global variables are automatically evaluated when the name is evaluated.) 1-8 RPL Programming
When a local name is evaluated, the object stored in the corresponding variable is returned to the stack but is not evaluated.When a local variable contains a number, the effect is identical to evaluation of a global name, since putting a number on the stack is equivalent to evaluating it. However, if a local variable contains a program, algebraic expression, or global variable name and if you want it evaluated the program should execute EVAL after the object is put on the stack.
Defining the Scope of Local Variables
Local variables exist only inside the defining procedure. Example: The following program excerpt illustrates the availability of local variables in nested defining procedures (procedures within procedures). Because local variables a, b, and c already exist when the defining procedure for local variables d, e, and f is executed, they're available for use in that procedure.

Program:

Comments:
No local variables are available. Defines local variables a, b, c. Local variables a, b, c are available in this procedure. Defines local variables d, e, f. Local variables a, b, c and d, e, f are available in this procedure. Only local variables a, b, c are available. No local variables are available.
a b c a b + c + d e f 'a/(d*e+f)'

a c /

RPL Programming 1-9
Example: In the following program excerpt, the defining procedure for local variables d, e, and f calls a program that you previously created and stored in global variable P1.
a b c a b + c + d e f 'P1+a/(d*e+f)' Defines local variables d, e, f. Local variables a, b, c and d, e, f are available in this procedure. The defining procedure executes the program stored in variable P1.
The six local variables are not available in program P1 because they didn't exist when you created P1. The objects stored in the local variables are available to program P1 only if you put those objects on the stack for P1 to use or store those objects in global variables. Conversely, program P1 can create its own local variable structure (with any names, such as a, c, and f, for example) without conflicting with the local variables of the same name in the procedure that calls P1. It is possible to create a special type of local variable that can be used in other programs or subroutines. This type of local variable is called a compiled local variable.

RPL Programming 1-19

Syntax Start finish FOR

FOR NEXT Structure

FOR takes start and finish from the stack as the beginning and ending values for the loop counter, then creates the local variable counter as a loop counter. Then the loop-clause is executed counter can appear within the loop-clause. NEXT increments counter by one, and then tests whether its value is less than or equal to finish. If so, the loop-clause is repeated (with the new value of counter) otherwise, execution resumes following NEXT. When the loop is exited, counter is purged. To enter FOR NEXT in a program:

Press !%BRCH% ! %FOR%.

Example: The following program places the squares of the integers 1 through 5 on the stack: FOR j j SQ NEXT Example: The following program takes the value x from the stack and computes the integer powers i of x. For example, when x =12 and start and finish are 3 and 5 respectively, the program returns 123, 124 and 125. It requires as inputs start and finish in level 3 and 2, and x in level 1. ( x removes x from the stack, leaving start and finish there as arguments for FOR.) x FOR n 'x^n' EVAL NEXT The FOR STEP Structure The syntax for this structure is start finish FOR counter loop-clause increment STEP FOR STEP executes the loop-clause sequence just like FOR NEXT does except that the program specifies the increment value for counter, rather than incrementing by 1. The loop-clause is always executed at least once.

1-20 RPL Programming

FOR STEP Structure
FOR takes start and finish from the stack as the beginning and ending values for the loop counter, then creates the local variable counter as a loop counter. Next, the loop-clause is executed counter can appear within the loop-clause. STEP takes the increment value from the stack and increments counter by that value. If the argument of STEP is an algebraic or a name, it's automatically evaluated to a number. The increment value can be positive or negative. If the increment is positive, the loop is executed again if counter is less than or equal to finish. If the increment is negative, the loop is executed if counter is greater than or equal to finish. Otherwise, counter is purged and execution resumes following STEP. In the previous flowchart, the increment value is positive. To enter FOR STEP in a program:

Press ! %BRCH% %FOR%.

Example: The following program places the squares of the integers 1, 3, 5, 7, and 9 on the stack: FOR x x SQ 2 STEP Example: The following program takes n from the stack, and returns the series of numbers 1, 2, 4, 8, 16, , n. If n isn't in the series, the program stops at the last value less than n. 1 SWAP FOR n n n STEP The first n is the local variable declaration for the FOR loop. The second n is put on the stack each iteration of the loop. The third n is used by STEP as the step increment.

RPL Programming 1-49

To specify a particular page of a menu, enter the number as m.pp, where m is the menu number and pp is the page number (such as 94.02 for page 2 of the TIME menu). If page pp doesn't exist, page 1 is displayed (94 gives page 1 of the TIME menu). Example: Enter 69 MENU to get page 1 of the MODES MISC menu. Enter 69.02 MENU to get page 2 of the MODES MISC menu. To restore the previous menu:

Execute 0 MENU.

To recall the menu number for the current menu:
Execute the RCLMENU command (MODES MENU menu).

Using Menus for Input

To display a menu for input in a program: 1. Set up the menu see the previous section. 2. Enter a command sequence that halts execution (such as DISP, PROMPT, or HALT). The program remains halted until it's resumed by a CONT command, such as by pressing !. If you create a custom menu for input, you can include a CONT command to automatically resume the program when you press the menu key. Example: The following program activates page 1 of the MODES ANGL menu and prompts you to set the angle mode. After you press the menu key, you have to press !to resume execution. 65 MENU "Select Angle Mode" PROMPT Example: The PIE program on page 2-34 assigns the CONT command to one key in a temporary menu. Example: The MNX program on page 2-17 sets up a temporary menu that includes a program containing CONT to resume execution automatically.
Using Menus to Run Programs
You can use a custom menu to run other programs. That menu can serve as the main interface for an application (a collection of programs). To create a menu-based application: 1. Create a custom menu list for the application that specifies programs as menu objects. 2. Optional: Create a main program that sets up the application menu either as the CST menu or as a temporary menu. Example: The following program, WGT, calculates the mass of an object in either English or SI units given the weight. WGT displays a temporary custom menu, from which you run the appropriate program. Each program prompts you to enter the weight in the desired unit system, then calculates the mass. The menu remains active until you select a new menu, so you can do as many calculations as you want. Enter the following list and store it in LST: { { "ENGL" "ENTER Wt in POUNDS" PROMPT 32.2 / } { "SI" "ENTER Wt in NEWTONS" PROMPT 98.1 / } } OLST

1-50 RPL Programming

Program: LST TMENU `OWGT
Comments: Displays the custom menu stored in LST. Stores the program in WGT.
Use WGT to calculate the mass of an object of weight 12.5 N. The program sets up the menu, then completes execution. J%WGT% Select the SI unit system, which starts the program in the menu list. %SI%

Value of.pf Shift Value of.pf Shift

.00 or.10.20.30.40.50.60

Unshifted [key]
!(left-shifted) [key] (right-shifted) [key] ~(alpha-shifted) [key] ~!(alpha left-shifted) [key] ~(alpha right-shifted)

.21.31.41.51.61

! & [key] & [key] ~& [key] ~!& [key] ~& [key]
Once ASN has been executed, pressing a given key in User or 1-User mode executes the userassigned object. The user key assignment remains in effect until the assignment is altered by ASN, STOKEYS, or DELKEYS. Keys without user assignments maintain their standard definitions. If the argument obj is the name SKEY, then the specified key is restored to its standard key assignment on the user keyboard. This is meaningful only when all standard key assignments had been suppressed (for the user keyboard) by the command S DELKEYS (see DELKEYS). To make multiple key assignments simultaneously, use STOKEYS. To delete key assignments, use DELKEYS. Be careful not to reassign or suppress the keys necessary to cancel User mode. If this happens, exit User mode by doing a system halt (warm start): press and hold and C simultaneously, releasing Cfirst. This cancels User mode. Access: ASN OR !&H KEYS ASN Flags: User-Mode Lock (61) and User Mode (62) affect the status of the user keyboard Input/Output:

xkey xkey

'SKEY' DELKEYS, RCLKEYS, STOKEYS
ASR Type: Command Description: Arithmetic Shift Right Command: Shifts a binary integer one bit to the right, except for the most significant bit, which is maintained. The most significant bit is preserved while the remaining (wordsize 1) bits are shifted right one bit. The second-most significant bit is replaced with a zero. The least significant bit is shifted out and lost. An arithmetic shift is useful for preserving the sign bit of a binary integer that will be shifted. Although the hp49g+/hp48gII makes no special provision for signed binary integers, you can still interpret a number as a signed quantity.
Full Command and Function Reference 3-15
Access: L BIT ASR ( is the right-shift of the 3key). Flags: Binary Integer Wordsize (5 through 10), Binary Integer Base (11, 12) Input/Output:

SL, SLB, SR, SRB

ASSUME CAS: Place assumptions on variables treated by CAS as real when Complex mode is set. ATAN Type: Analytic Function Description: Arc Tangent Analytic Function: Returns the value of the angle having the given tangent. For a real argument, the result ranges from 90 to +90 degrees (/2 to +/2 radians; 100 to +100 grads). The inverse of TAN is a relation, not a function, since TAN sends more than one argument to the same result. The inverse relation for TAN is expressed by ISOL as the general solution: ATAN(Z)+*n1 The function ATAN is the inverse of a part of TAN, a part defined by restricting the domain of TAN such that: each argument is sent to a distinct result, and each possible result is achieved. The points in this restricted domain of TAN are called the principal values of the inverse relation. ATAN in its entirety is called the principal branch of the inverse relation, and the points sent by ATAN to the boundary of the restricted domain of TAN form the branch cuts of ATAN. The principal branch used by the hp49g+/hp48gII for ATAN was chosen because it is analytic in the regions where the arguments of the real-valued inverse function are defined. The branch cuts for the complex-valued arc tangent function occur where the corresponding real-valued function is undefined. The principal branch also preserves most of the important symmetries. The graphs below show the domain and range of ATAN. The graph of the domain shows where the branch cuts occur: the heavy solid line marks one side of a cut, while the feathered lines mark the other side of a cut. The graph of the range shows where each side of each cut is mapped under the function. These graphs show the inverse relation ATAN(Z)+*n1 for the case n1 = 0. For other values of n1, the vertical band in the lower graph is translated to the right (for n1 positive) or to the left (for n1 negative). Together, the bands cover the whole complex plane, the domain of TAN. View these graphs with domain and range reversed to see how the domain of TAN is restricted to make an inverse function possible. Consider the vertical band in the lower graph as the restricted domain Z = (x, y). TAN sends this domain onto the whole complex plane in the range W = (u, v) = TAN(x, y) in the upper graph.

depend is a list, { Y y0 xErrTol }, containing a name that specifies the dependent variable (the solution), and two numbers that specify the initial value of Y and the global absolute error tolerance in the solution Y. The default values for these elements are { Y 0.0001 } EQ must define the right-hand side of the initial value problem Y'(XF(X,Y). Y can return a real value or real vector when evaluated. The DIFFEQ-plotter attempts to make the interval between values of the independent variable as large as possible, while keeping the computed solution within the specified error tolerance xErrTol. This tolerance may hold only at the computed points. Straight lines are drawn between computed step endpoints, and these lines may not accurately represent the actual shape of the solution. res limits the maximum interval size to provide higher plot resolution. On exit from DIFFEQ plot, the first elements of indep and depnd (identifiers) contain the final values of X and Y, respectively.
3-46 Full Command and Function Reference
If EQ contains a list, the initial value problem is solved and plotted using a combination of Rosenbrock (3,4) and Runge-Kutta-Fehlberg (4,5) methods. In this case DIFFEQ uses RRKSTEP to calculate yf, and EQ must contain two additional elements: The second element of EQ must evaluate to the partial derivative of Y' with respect to X, and can return a real value or real vector when evaluated. The third element of EQ must evaluate to the partial derivative of Y' with respect to Y, and can return a real value or a real matrix when evaluated. Access: DIFFEQ Input/Output: None See also: AXES, CONIC, FUNCTION, PARAMETRIC, POLAR, RKFSTEP, RRKSTEP, TRUTH
DIR Type: Function Description: Creates an empty directory structure in run mode. Can be used as an alternative to CRDIR to create an empty directory by typing DIR NAME STO, which will create an empty directory NAME if it does not already exist in the current directory. Access: DIR Input/Output:

DIR END

DISP Type: Command Description: Display Command: Displays obj in the nth display line. n 1 indicates the top line of the display. To facilitate the display of messages, strings are displayed without the surrounding " " delimiters. All other objects are displayed in the same form as would be used if the object were in level 1 in the multiline display format. If the object display requires more than one display line, the display starts in line n, and continues down the display either to the end of the object or the bottom of the display. The object displayed by DISP persists in the display only until the keyboard is ready for input. The FREEZE command can be used to cause the object to persist in the display until a key is pressed. Access: !LOUT DISP ( is the left-shift of the Nkey). Input/Output:

stack prompt stack prompt
command-line prompt { listcommand-line }

result result

PROMPT, STR Calculate the antiderivative of a function for a given variable at a given point.

INT CAS:

3-86 Full Command and Function Reference
INTEGER CAS: Display a menu or list of CAS integer operations. INTVX CAS:
Find the antiderivative of a function symbolically, with respect to the current default variable.
INV Type: Analytic function Description: Inverse (1/x) Analytic Function: Returns the reciprocal or the matrix inverse. For a complex argument (x, y), the inverse is the complex number:
x y ---------------- , ---------------- x +y x +y
Matrix arguments must be square (real or complex). The computed inverse matrix A-1 satisfies A A-1 = In, where In is the n n identity matrix. Access: Y Flags: Numerical Results (3) Input/Output:
z [[ matrix ]] 'symb' x_unit
1/z [[ matrix ]]1 'INV(symb)' 1/x_1/unit
SINV, / Perform modular inversion on an object, modulo the current modulus.

INVMOD CAS:

IP Type: Function Description: Integer Part Function: Returns the integer part of its argument. The result has the same sign as the argument. Access: ! REALL IP ( is the left-shift of the Pkey). Flags: Numerical Results (3) Input/Output:

n n_unit 'IP(symb)'

FP Return the integer (or Euclidean) quotient of integers a, b; the integer part of a/b.

IQUOT CAS:

IREMAINDER CAS: Return the remainder of the division of one integer by another. ISOL Type:
Full Command and Function Reference 3-87
Description: Isolate Variable Command: Returns an algebraic symb2 that rearranges symb1 to isolate the first occurrence of variable global. The result symb2 is an equation of the form global = expression. If global appears more than once, then symb2 is effectively the right side of an equation obtained by rearranging and solving symb1 to isolate the first occurrence of global on the left side of the equation. If symb1 is an expression, it is treated as the left side of an equation symb1 = 0. If global appears in the argument of a function within symb1, that function must be an analytic function, that is, a function for which the hp49g+/hp48gII provides an inverse. Thus ISOL cannot solve IP(x)=0 for x, since IP has no inverse. ISOL is identical to SOLVE. Access: !ISOL ( is the left-shift of the 7key). Flags: Principal Solution (-1), Numerical Results (3) Input/Output:
'symb1' 'global' COLCT, EXPAN, QUAD, SHOW, SOLVE

'symb2'

ISOM CAS:
Determine the characteristics of a 2-d or 3-d linear isometry.
ISPRIME? CAS: Test if a number is prime. For large numbers test if the number is pseudoprime. IR Type: Function Description: Converts an integer into a real number. Access: REWRITE Flags: Exact mode must be set (flag 105 clear). Numeric mode must not be set (flag 3 clear). The flags affect the output only if the input is not an integer. Input: Level 1/Argument 1: An integer. Output: Level 1/Item 1: The integer converted to a real number.

{ 'symbpat', 'symbrepl' } { 'symbpat', 'symbrepl', 'symbcond' }
MATCH Display a menu or list of CAS mathematics submenus. Display a menu or list of CAS commands for matrix operations. Function
Full Command and Function Reference 3-101
MATHS CAS: MATR CAS: MAX Type:
Description: Maximum Function: Returns the greater of two inputs. Access: !REAL MAX Flags: Numerical Results (-3) Input/Output:
x x 'symb' 'symb1' x_unit1
y 'symb' x 'symb2' y_unit2
max(x,y) 'MAX(x, symb)' 'MAX(symb, x)' 'MAX(symb1, symb2)' max(x_unit1, y_unit2)
MAXR Type: Function Description: Maximum Real Function: Returns the symbolic constant MAXR or its numerical representation 9.99999999999E499. MAXR is the largest real number that can be represented by the hp49g+/hp48gII. Access: !L CONSTANTS LMAXR ( is the left-shift of the Pkey). Flags: Symbolic Constants (-2), Numerical Results (-3) Input/Output:

'MAXR' 9.99999999999E499

e, i, MINR,
MAX Type: Command Description: Maximum Sigma Command: Finds the maximum coordinate value in each of the m columns of the current statistical matrix (reserved value DAT). The maxima are returned as a vector of m real numbers, or as a single real number if m = 1. Access: MAX Input/Output:
xmax [xmax1 xmax2. xmaxm ]
BINS, MEAN, MIN, SDEV, TOT, VAR
MCALC Type: Command Description: Make Calculated Value Command: Designates a variable as a calculated variable for the multipleequation solver. MCALC designates a single variable, a list of variables, or all variables as calculated values. MCALC Access:
3-102 Full Command and Function Reference
'name' { list } "ALL"
MEAN Type: Command Description: Mean Command: Returns the mean of each of the m columns of coordinate values in the current statistics matrix (reserved variable DAT). The mean is returned as a vector of m real numbers, or as a single real number if m = 1. The mean is computed from the formula:

1 n -- xi ni = 1

where xi is the ith coordinate value in a column, and n is the number of data points. MEAN OR Single-variable statistics, Mean (is the right-shift of the 5key and always invokes a choose box). Input/Output: Access:
xmean [xmean1, xmean2,., xmeanm ]
BINS, MAX, MIN, SDEV, TOT, VAR
MEM Type: Command Description: Memory Available Command: Returns the number of bytes of available RAM. The number returned is only a rough indicator of usable available memory, since recovery features (LASTARG= !, , and !) consume or release varying amounts of memory with each operation. Before it can assess the amount of memory available, MEM must remove objects in temporary memory that are no longer being used. This clean-up process (also called garbage collection) also occurs automatically at other times when memory is full. Since this process can slow down calculator operation at undesired times, you can force it to occur at a desired time by executing MEM. In a program, execute MEM DROP. Access: !MEMORY MEM ( is the left-shift of the Nkey). Input/Output:

NEG, SCONJ, SINV

SNRM Type: Command Description: Spectral Norm Command: Returns the spectral norm of an array. The spectral norm of a vector is its Euclidean length, and is equal to the largest singular value of a matrix. Access: ! OPERATIONS L L SNRM ( is the left-shift of the 5key). ! MATRIX NORMALIZE SNRM ( is the left-shift of the Pkey). Input/Output:
[ array ] ABS, CNRM, COND, RNRM, SRAD, TRACE

xspectralnorm

Find zeros of an expression, or solve an equation with respect to a specified variable.
SOLVEQN Type: Command Description: Starts the appropriate solver for a specified set of equations. SOLVEQN sets up and starts the appropriate solver for the specified set of equations, bypassing the Equation Library catalogs. It sets EQ (and Mpar if more than one equation is being solved), sets the unit options according to flags -60 and -61, and starts the appropriate solver. SOLVEQN uses subject and title numbers (levels 3 and 2) and a PICT option (level 1) and returns nothing. Subject and title numbers are listed in chapter 5. For example, a 2 in level 3 and a 9 in level 2 would specify the Electricity category and Capacitive Energy set of equations. If the PICT option is 0, PICT is not affected; otherwise, the equation picture (if any) is copied into PICT. Access: SOLVEQN Flags: Unit Type (-60), Units Usage (-61) Input/Output:
n See also: EQNLIB, MSOLVER
Full Command and Function Reference 3-167
SOLVER Type: Command Description: Displays a menu of commands used in solving equations. Access: SOLVER Input/Output: None SOLVEVX
Find zeros of an expression, or solves an equation with respect to the current variable.
SORT Type: Command Description: Ascending Order Sort Command: Sorts the elements in a list in ascending order. The elements in the list can be real numbers, strings, lists, names, binary integers, or unit objects. However, all elements in the list must all be of the same type. Strings and names are sorted by character code number. Lists of lists are sorted by the first element in each list. To sort in reverse order, use SORT REVLIST. Access: ! LIST SORT ( is the left-shift of the Pkey). ! LIST PROCEDURES L SORT ( is the left-shift of the Nkey). Input/Output:

{ list }1

{ list }2

REVLIST

SPHERE Type: Command Description: Spherical Mode Command: Sets spherical coordinate mode. SPHERE sets flags 15 and 16. In spherical mode, vectors are displayed as polar components. Access: &H ANGLE SPHERE Input/Output: None See also: CYLIN, RECT SQ Type: Analytic function Description: Square Analytic Function: Returns the square of the argument. The square of a complex argument (x, y) is the complex number (x2 y2, 2xy). Matrix arguments must be square. Access: ! ( is the left-shift of the Rkey). Flags: Numerical Results (-3) Input/Output:

LCM Type: Description:

x1 Command: LCM(X^2-1,X-1) Results: X^2-1 See also: GCD Command From a program with two arguments, builds a matrix with the specified number of rows and columns, with aij = f(i,j). Catalog,

LCXM Type: Description:

4-46 Computer Algebra Commands
Level 3/Argument 1: The number of rows you want in the resulting matrix. Level 2/Argument 2: The number of columns you want in the resulting matrix. Level 1/Argument 3: A program that uses two arguments. An expression with the two variables I, J can be used instead. The resulting matrix. Exact mode must be set (flag 105 clear). Numeric mode must not be set (flag -3 clear).
Example: Build a matrix with aij=i+2j. Command: LCXM(2,3, I J 'I+2*J') Result:

357 468

LDEC Type: Description:
Command Solves a linear differential equation with constant coefficients, or a system of first order linear differential equations with constant coefficients. Symbolic solve, !or PSOLVER or !DIFF Level 2/Argument 1: For a single equation, the function forming the right hand side of the equation. For a system of equations, an array comprising the terms not containing the dependent variables. Level 1/Argument 2: For one equation, the auxiliary polynomial. For a system of equations, the matrix of coefficients of the dependent variables. The solution. Exact mode must be set (flag 105 clear). Numeric mode must not be set (flag -3 clear). Radians mode must be set (flag 17 set).
Example: Solve 2sin(x), with the auxiliary polynomial x2+1: Command: LDEC(2*SIN(X),X^2+1) Result: COS(X)*(cC0 -X)+(cC1 -1)*SIN(X) See also: DESOLVE
LEGENDRE Type: Function Description: Returns the nth degree Legendre polynomial.
Access: Input: Output: Flags: Arithmetic, ! POLYNOMIAL LL An integer, n. The nth Legendre polynomial. Exact mode must be set (flag 105 clear). Numeric mode must not be set (flag -3 clear).
Example: Find the Legendre polynomial with degree 4. Command: LEGENDRE(4) Result: (35*X^4-30*X^2+3)/8 See also: HERMITE, TCHEBYCHEFF
Computer Algebra Commands 4-47

LGCD Type: Description:

Function Returns the greatest common divisor of a list of expressions or values. Arithmetic, ! L A list of expressions or values. Level 2/Item 1: The list of elements. Level 1/Item 2: The greatest common divisor of the elements. Exact mode must be set (flag 105 clear). Numeric mode must not be set (flag -3 clear). Radians mode must be set (flag 17 set). GCD Function Returns the limit of a function as its argument approaches a specified value. This function is identical to the lim function, described below, and is included to ensure backwardcompatibility with the HP49G calculator. Catalog, Function Returns the limit of a function as its argument approaches a specified value. Expands and simplifies an algebraic expression. Calculus, ! LIMITS&SERIES Level 2/Argument 1: An expression. Level 1/Argument 2: An expression of the form x = y, where x is the variable and y is the value at which the limit is to be evaluated. If the variable approaching a value is the current CAS variable, it is sufficient to give its value alone. The symbol provided by the calculator can be used to set the limiting value at plus or minus infinity.

Vf n Pf ---- = ----- Vi Pi Pf Tf ----- = ---- Pi Ti

n1 ----------n

Example: Given: Pi=15_psi, Pf=35_psi, Vi=1_ft^3, Vf=0.50_ft^3, Ti=75_F. Solution: n=1.2224, Tf=164.1117_F.

Isentropic Flow (5, 5)

The calculation differs at velocities below and above Mach 1. The Mach number is based on the speed of sound in the compressible fluid.

5-26 Equation Reference

T 2 ------ = ------------------------------------2 T+ (k 1 ) M T k1 P ----- = ------ T0 P0
1 ----------k -----------
T k1 ---- = ------ - T0 0
2 (k 1) 2 A k1 ----- = ---- ----------- 1 + ----------- M k+1 At M 2
k+1 -----------------------
Example: Given: k=2, M=.9, T0=26.85_C, T=373.15_K, 0=100_kg/m^3, P0=100_kPa, A=1_cm^2. Solution: P=464.1152_kPa, At=0.9928_cm^2, =215.4333_kg/m^3.

Real Gas Law (5, 6)

These equations adapt the ideal gas law to emulate real-gas behavior. (See ZFACTOR in Chapter 3.) Equations:

PV = nZRT m = n MW

Example: Given: Pc=48_atm, Tc=298_K, P=5_kPa, V=10_1, MW=64_g/gmol, T=75_C. Solution: n=0.0173_gmol, m=1.1057E3_kg.
Real Gas State Change (5, 7)
This equation adapts the ideal gas state-change equation to emulate real-gas behavior. (See ZFACTOR in Chapter 3.) Equation:
Pi Vi Pf Vf ---------------- = --------------Zf Tf Zi Ti
Example: Given: Pc=48_atm, Pi=100_kPa, Pf=50_kPa, Ti=75_C, Tc=298_K, Vi=10_1, Tf=250_C. (Remember Zf and Zi are automatically calculated using these variables) Solution: Vf=30.1703_l.

Equation Reference 5-27

Kinetic Theory (5, 8)
These equations describe properties of an ideal gas. Equations:
n MW vrms P = -------------------------------------3V

vrms =

3RT -----------------MW
1 = --------------------------------------------------n NA --------------- d V

m = n MW

Example: Given: P=100_kPa, V=2_1, T=26.85_C, MW=18_g/gmol, d=2.5_nm. Solution: vrms=644.7678_m/s, m=1.4433E3_kg, n=0.0802_gmol, =1.4916_nm.

Heat Transfer (6)

1, 2 max
Description Expansion coefficient Elongation Lower and upper wavelength limits Wavelength of maximum emissive power Temperature difference Area Specific heat Emissive power in the range 1 to 2 Total emissive power Fraction of emissive power in the range 1 to 2 Convective heat-transfer coefficient Thermal conductivity Length Mass Heat capacity Heat transfer rate Temperature Cold surface temperature (Conduction), or Cold fluid temperature Hot surface temperature, or Hot fluid temperature (Conduction + Convection) Initial and final temperature Overall heat transfer coefficient

The Development Library 6-13

4.1.13

Compilation directive
The following instruction modifies the way MASD reacts and compiles things. They are valid in all modes: !PATH+ DirName Add the specified directory in the search path list. !NO CODE MASD will not generate a $02DCC prologue but will directly output the data. If the generated file is not a valid object, an error will be generated. !DBGON MASD will generate code when DISP or DISPKEY are found in the source. !DBGOFF MASD will not generate code when DISP or DISPKEY are found in the source. !1-16 Switch to 1-16 mode. !1-15 Switch to 0-15 mode. !RPL Switch to RPL mode. !ASM Switch to ASM mode. !ARM Switch to ARM mode. !FL=0.a Clear the a compilation flag. !FL=1.a Set the a compilation flag. !?FL=0.a Compile the end of the line if flag a is set. !?FL=1.a Compile the end of the line if flag a is clear. !ABSOLUT Addr Switch to absolute mode. The program begins at the address Addr. Note: MASD always considers the prolog $02DCC and code length to be the beginning of the program even if !NO CODE is set. !ABSADR Addr If in absolute mode, add blank nibbles to continue at the specified address. If not possible, errors. !EVEN In absolute mode, cause an error if the directive is not on an even address. !ADR MASD will generate a source defining all constants and labels used in the program instead of the program. !COMPEXP Cause MASD to calculate all previous expressions. !STAT Display/update compilation statistics !DBGINF Causes MASD to generate debugging information (see next section for more information) !JAZZ See local variable documentation in RPL mode !MASD See local variable documentation in RPL mode 4.1.13.1 The !DBGINF directive If you put the !DBGINF directive into a MASD source, the assembler not only generates your compiled object, but it also returns a string (on level 1) full of debug information. The structure of this string is as follows: 5 DOCSTR 5 Length 5 Number of links (source files) n*[ 2 Number of characters. Name of link file ] 5 Number of symbols (labels and constants) n*[ 2 Number of characters. Name of symbol 6-14 The Development Library
1 Type: 9=Label 2=Constant for labels: 5 Address of label for constants: 16 Value of constant ] 5 Number of source->code associations n*[ 5 Offset in code (this list is sorted by offset) 2 Number of link this instruction comes from 5 Character offset in link where this instruction starts ] Notes: If the source string is unnamed, i.e. in TEMPOB, the number of links is 00001 and the number of characters is 00, immediately followed by the symbol table. The label symbol table is supposed to be an *offset* table. However the current MASD may sometimes place *addresses* into this table. The associations table correctly contains offsets. This instruction is intended for the case where someone decides to create a source level debugger.

4.2 Saturn ASM mode

This section is only applicable to the Saturn ASM mode.

Store Byte

STRB{cond} Rd, <a_mode> STRB{cond} Rd, Label
Multiple Store Inc Before Inc After De Before De After multiplication
STM{cond}IB Rd{!}, {reg STM{cond}IA Rd{!}, {reg STM{cond}DB Rd{!}, {reg STM{cond}DA Rd{!}, {reg MUL rd, r1 r2 MLA rd, r1, r2, r3 SMULL rd1, rd2, r1, r2 SMLAL rd1, rd2, r1, r2 UMULL rd1, rd2, r1, r2 UMLAL rd1, rd2, r1, r2

*labelName $ ,

6-26 The Development Library
Where cond can be any of:
EQ NE CS HS CC LO MI PL VS VC HI LS GE LT GT LE
Oprnd can be of the form:
Immediate value Cte Note: cte is encoded on 8 bits + a rotation right encoded on 4 bits. This means that not every value is possible. Rm LSL Cte Rm < Cte Rm LSR Cte Rm > Cte Rm ASR Cte Rm >> Cte Rm ROR Cte Rm >>> Cte Rm Rm LSL Rs Rm < Rs Rm LSR Rs Rm > Rs Rm ASR Rs Rm >> Rs Rm ROR Rs Rm >>> Rs
Logical shift left Logical shift right Arithmetic shift right Rotate right Register Logical shift left Logical shift right Arithmetic shift right Rotate right
In all cases, Cte must be a decimal value or an expression that can be evaluated immediately. A_mode can be:
[Rn [Rn [Rn [Rn [Rn [Rn [Rn [Rn [Rn [Rn [Rn +/-Cte] +/-Rm] +/-Rm LSL Cte] +/-Rm < Cte] +/-Rm LSR Cte] +/-Rm > Cte] +/-Rm ASR Cte] +/-Rm >> Cte] +/-Rm ROR Cte] +/-Rm >>> Cte] +/-Cte]! Value of rn + or - constant Value of rn + or value of rm Value of rn + or value of rm shifted left Value of rn + or value of rm shifted right Value of rn + or value of rm shifted arithmetically right Value of rn + or value of rm rotated right Value of rn + or constant Rn is updated with that value Value of rn + or value of rm Rn is updated with that value Value of rn + or value of rm shifted left Rn is updated with that value Value of rn + or value of rm shifted right Rn is updated with that value Value of rn + or value of rm shifted arithmetically right Rn is updated with that value Value of rn + or value of rm rotated right Rn is updated with that value
[Rn +/-Rm]! [Rn [Rn [Rn [Rn [Rn [Rn [Rn [Rn +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm LSL Cte]! < Cte]! LSR Cte]! > Cte]! ASR Cte]! >> Cte]! ROR Cte]! >>> Cte]!
Carry set, unsigned >= Non equal

Carry clear <

Negative

Positive or 0

Overflow

No overflow

Unsigned <= Unsigned >
The Development Library 6-27
[Rn] +/-Cte [Rn] +/-Rm [Rn] [Rn] [Rn] [Rn] [Rn] [Rn] [Rn] [Rn] 4.3.4 +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm +/-Rm LSL Cte < Cte LSR Cte > Cte ASR Cte >> Cte ROR Cte >>> Cte