# HP 50g Advanced Guide — Command Reference

809 commands extracted from the HP 50g Advanced User's Reference Manual. 408 are implemented in this RPL app. Sections are reproduced verbatim from the PDF.

## Index (alphabetical)

## Commands (manual order)

## ABCUV not in app ↑ top

PDF page 125 · printed page 3-5

Type

  Command

Description

  Returns a solution in polynomials u and v of au+bv =c where a and b are polynomials in the current CAS independent variable, and c is a value.

Input

  Level 3/Argument 1: The polynomial corresponding to a. Level 2/Argument 2: The polynomial corresponding to b. Level 1/Argument 3: The value corresponding to c.

Output

  Level 2/Item 1: The solution corresponding to u. Level 1/Item 2: The solution corresponding to v.

Flags

  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

  Find a solution in polynomials u and v for the following equation:

                       2               2

  ( x + x + 1 )u + ( x + 4 ) V = 13

  Command | ABCUV(X^2+X+1,X^2+4,13)
  Result | {-(X+3),X+4}

See also

  IABCUV, EGCD

## ABS in app ↑ top

PDF page 125 · printed page 3-5

Type

  Function

Description

  Absolute Value Function: Returns the absolute value of its argument. ABS has a derivative (SIGN) but not an inverse. In the case of an array, ABS returns the Frobenius (Euclidean) norm of the array, defined as the square root of the sum of the squares of the absolute values of all n elements. That is:

                                                      n     2

  ∑ zi i=1

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | |x|
  (x,y) | → | 2
  x +y 2
  x_unit | → | |x|_unit
  [array] | → | ||array||
  `symb` | → | `ABS(symb)`

See also

  NEG, SIGN

## ACK not in app ↑ top

PDF page 125 · printed page 3-5

Type

  Command

Description

  Acknowledge Alarm Command: Acknowledges the oldest past-due alarm. ACK clears the alert annunciator if there are both no other past-due alarms and no other active alert sources (such as a low battery condition).

  ACK has no effect on control alarms. Control alarms that come due are automatically acknowledged and saved in the system alarm list.

Flags

  Repeat Alarms Not Rescheduled (–43), Acknowledged Alarms Saved (–44)

Input/Output

  None

See also

  ACKALL

## ACKALL not in app ↑ top

PDF page 126 · printed page 3-6

Type

  Command

Description

  Acknowledge All Alarms Command: Acknowledges all past-due alarms. ACKALL clears the alert annunciator if there are no other active alert sources (such as a low battery condition). ACKALL has no effect on control alarms. Control alarms that come due are automatically acknowledged and saved in the system alarm list.

Flags

  Repeat Alarms Not Rescheduled (–43), Acknowledged Alarms Saved (–44)

Input/Output

  None

See also

  ACK

## ACOS in app ↑ top

PDF page 126 · printed page 3-6

Type

  Analytic Function

Description

  Arc Cosine Analytic Function: Returns the value of the angle having the given cosine. For a real argument x in the domain –1 ≤x ≤ 1, the result ranges from 0 to 180 degrees (0 to π radians; 0 to 200 grads). A real argument outside of this domain is converted to a complex argument, z = x + 0i, and the result is complex. The inverse of COS is a relation, not a function, since COS sends more than one argument to the same result. The inverse relation for COS is expressed by ISOL as the general solution s1*ACOS(Z)+2*π*n1 The function ACOS is the inverse of a part of COS, a part defined by restricting the domain of COS such that:

  - each argument is sent to a distinct result, and
  - each possible result is achieved. The points in this restricted domain of COS are called the principal values of the inverse relation. ACOS in its entirety is called the principal branch of the inverse relation, and the points sent by ACOS to the boundary of the restricted domain of COS form the branch cuts of ACOS. The principal branch used by the calculator for ACOS was chosen because it is analytic in the regions where the arguments of the real-valued inverse function are defined. The branch cut for the complex-valued arc cosine function occurs 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 ACOS. 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 s1*ACOS(Z)+2*π*n1 for the case s1=1 and n1 = 0. For other values of s1 and n1, the vertical band in the lower graph is translated to the right or to the left. Taken together, the bands cover the whole complex plane, which is the domain of COS.

  View these graphs with domain and range reversed to see how the domain of COS is restricted to make an inverse function possible. Consider the vertical band in the lower graph as the restricted domain Z = (x, y). COS sends this domain onto the whole complex plane in the range W = (u, v) = COS(x, y) in the upper graph.

Flags

  Principal Solution (–1), Numerical Results (–3), Angle Mode (–17, –18)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | acos z
  `symb` | → | `ACOS(symb)`

See also

  ASIN, ATAN, COS, ISOL

## ACOS2S in app ↑ top

PDF page 127 · printed page 3-7

Type

  Command

Description

  Transforms an expression by replacing acos(x) in subexpressions with π/2–asin(x).

Input

  The expression to transform.

Output

  The transformed expression.

Flags

  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

  Simplify the following expression:

  arc cos -- ---- + arc cos ( x ) 2 3

  Command | ACOS2S(ACOS(2/3)+ACOS(X))
  Result | π/2-ASIN(2/3)+π/2-ASIN(X)

See also

  ASIN2C, ASIN2T, ATAN2S

## ACOSH in app ↑ top

PDF page 128 · printed page 3-8

Type

  Analytic Function

Description

  Inverse Hyperbolic Cosine Analytic Function: Returns the inverse hyperbolic cosine of the argument. For real arguments x < 1, ACOSH returns the complex result obtained for the argument (x, 0). The inverse of ACOSH is a relation, not a function, since COSH sends more than one argument to the same result. The inverse relation for COSH is expressed by ISOL as the general solution: s1*ACOSH(Z)+2*π*i*n1 The function ACOSH is the inverse of a part of COSH, a part defined by restricting the domain of COSH such that:

  - each argument is sent to a distinct result, and
  - each possible result is achieved. The points in this restricted domain of COSH are called the principal values of the inverse relation. ACOSH in its entirety is called the principal branch of the inverse relation, and the points sent by ACOSH to the boundary of the restricted domain of COSH form the branch cuts of ACOSH. The principal branch used by the calculator for ACOSH was chosen because it is analytic in the regions where the arguments of the real-valued inverse function are defined. The branch cut for the complex-valued hyperbolic arc cosine function occurs 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 ACOSH. The graph of the domain shows where the branch cut occurs: the heavy solid line marks one side of the cut, while the feathered lines mark the other side of the cut. The graph of the range shows where each side of the cut is mapped under the function. These graphs show the inverse relation s1*ACOSH(Z)+2*π*i*n1 for the case s1 = 1 and n1 = 0. For other values of s1 and n1, the horizontal half-band in the lower graph is rotated to the left and translated up and down. Taken together, the bands cover the whole complex plane, which is the domain of COSH. View these graphs with domain and range reversed to see how the domain of COSH is restricted to make an inverse function possible. Consider the horizontal half-band in the lower graph as the restricted domain Z = (x, y). COSH sends this domain onto the whole complex plane in the range W = (u, v) = COSH(x, y) in the upper graph.
Flags

  Principal Solution (–1), Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | acosh z
  `symb` | → | `ACOSH(symb)`

See also

  ASINH, ATANH, COSH, ISOL

## ADD not in app ↑ top

PDF page 129 · printed page 3-9

Type

  Command

Description

  Add List Command: Adds corresponding elements of two lists or adds a number to each of the elements of a list. ADD executes the + command once for each of the elements in the list. If two lists are the arguments, they must have the same number of elements as ADD will execute the + command once for each corresponding pair of elements. If one argument is a non-list object, ADD will attempt to execute the + command using the non-list object and each element of the list argument, returning the result to the corresponding position in the result. (See the + command entry to see the object combinations that are defined.) If an undefined addition is encountered, a Bad Argument Type error results.

Flags

  Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  { list1 } | { list2 } | → | { listresult }
  { list } | objnon-list | → | { listresult }
  objnon-list | { list } | → | { listresult }

See also

  +, ΔLIST, ΠLIST, ΣLIST

## ADDTMOD in app ↑ top

PDF page 129 · printed page 3-9

Type

  Function

Description

  Adds two expressions or values, modulo the current modulus.

Input

  Level 2/Argument 1: The first expression. Level 1/Argument 2: The second expression.

Output

  The sum of the two expressions, modulo the current modulus.

Flags

  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

  Express the result of the following addition in modulo 7. (x2+3x+6)+(9x+3) Note: Before trying this example, use the CAS modes input form to set the modulo to 7.

  Command | ADDTMOD(X^2+3*X+6,9*X+3)
  Result | X^2-2*X+2

## ADDTOREAL not in app ↑ top

PDF page 130 · printed page 3-10

Type

  Command

Description

  Adds specified global names to the reserved variable REALASSUME. This is a list of the global variables that will be treated by some CAS operations as real numbers when Complex mode is set. If a variable is already in the REALASSSUME list, this command removes any additional assumptions made on it by ASSUME.

Input

  Level 1/Item 1: The name of the global variable to be added to the REALASSUME list, or a list of names.

Output

  No output in RPN mode, NOVAL in Algebraic mode.

Flags

  If the “all variables are real” flag is set (flag –128 set), ADDTOREAL will not add anything to the REALASSUME list, as all variables are assumed real anyway. In this case it will only remove further assumptions made by ASSUME.

See also

  ASSUME, DEF, STORE, UNASSUME, UNBIND

## ALGB not in app ↑ top

PDF page 130 · printed page 3-10

Type

  Command

Description

  Displays a menu or list of CAS algebraic operations.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## ALOG in app ↑ top

PDF page 130 · printed page 3-10

Type

  Analytic Function

Description

  Common Antilogarithm Analytic Function: Returns the common antilogarithm; that is, 10 raised to the given power. For complex arguments: 10(x,y) = ecx cos cy + i ecx sin cy where c = ln 10.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | 10z
  `symb` | → | `ALOG(symb)`

See also

  EXP, LN, LOG

## AMORT not in app ↑ top

PDF page 131 · printed page 3-11

Type

  Command

Description

  Amortize Command: Amortizes a loan or investment based upon the current amortization settings. Values must be stored in the TVM variables (I%YR, PV, PMT, and PYR). The number of payments n is taken from the input together with flag –14.

Flags

  Financial Payment Mode (–14)

Input/Output

  Level 1/Argument 1 |  | Level 3/Item 1 | Level 2/Item 2 | Level 1/Item 3
  --- | --- | --- | --- | ---
  n | → | principal | interest | balance

See also

  TVM, TVMBEG, TVMEND, TVMROOT

## AND in app ↑ top

PDF page 131 · printed page 3-11

Type

  Function

Description

  And Function: Returns the logical AND of two arguments. When the arguments are binary integers or strings, AND does a bit-by-bit (base 2) logical comparison.

  - An argument that is a binary integer is treated as a sequence of bits as long as the current wordsize. Each bit in the result is determined by comparing the corresponding bits (bit1 and bit2) in the two arguments as shown in the following table.

  bit1 | bit2 | bit1 AND bit2
  --- | --- | ---
  0 | 0 | 0
  0 | 1 | 0
  1 | 0 | 0
  1 | 1 | 1

  - An argument that is a string is treated as a sequence of bits, using 8 bits per character (that is, using the binary version of the character code). The two string arguments must have the same number of characters. When the arguments are real numbers or symbolics, AND simply does a true/false test. The result is 1 (true) if both arguments are non-zero; it is 0 (false) if either or both arguments are zero. This test is usually done to compare two test results. If either or both of the arguments are algebraic expressions, then the result is an algebraic of the form symb1 AND symb2. Execute →NUM (or set flag –3 before executing AND) to produce a numeric result from the algebraic result.
Flags

  Numerical Results (–3), Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  #n1 | #n2 | → | #n3
  “string1” | “string2” | → | “string3”
  T/F1 | T/F2 | → | 0/1
  T/F | `symb` | → | `T/F AND symb`
  `symb` | T/F | → | `symb AND T/F``
  `symb1` | `symb2` | → | `symb1 AND symb2`

See also

  NOT, OR, XOR

## ANIMATE not in app ↑ top

PDF page 132 · printed page 3-12

Type

  Command

Description

  Animate Command: Displays graphic objects in sequence. ANIMATE displays a series of graphics objects (or variables containing them) one after the other. You can use a list to specify the area of the screen you want to animate (pixel coordinates #X and #Y), the number of seconds before the next grob is displayed (delay), and the number of times the sequence is run (rep). If rep is set to 0, the sequence is played approximately one million times (1,048,575 cycles), or until you press − (the $ key). If you use a list on level 1, all parameters must be present. If the list specifier is not used, the delay between each grob will default to 0.1 second. The animation displays PICT while displaying the grobs. The grobs and the animate parameters are left on the stack.

Input/Output

  Ln+1.../A1 | L1/An+1 |  | L1/I1
  --- | --- | --- | ---
  grobn...grob1 | ngrobs | → | same stack
  grobn...grob1 | { n {#X#Y } delay rep } | → | same stack
  L = Level, A = Argument, I = item

Example

      The following program draws half a cylinder and rotates it: « PARSURFACE { `COS(X)` `SIN(X)` Y } STEQ « I 180 I + XXRNG ERASE DRAW PICT RCL » I 0 359 8 SEQ OBJ ANIMATE DROPN » This program also illustrates the use of SEQ and PARSURFACE. You can adjust the increment value used with SEQ (8 is used here) to change the number of images drawn by the program, or to use less memory.

See also

  BLANK, →GROB

## ANS not in app ↑ top

PDF page 132 · printed page 3-12

Type

  Command

Description

  Recalls the nth answer from history, where n is an integer, in algebraic mode only. When called directly from the keybard in RPN mode, it takes no input and performs the LASTARG command. When the command name is typed manually in RPN mode, it performs PICK, with the exception that any stack levels containing null-tagged expressions (surrounded by `

  characters), as might have been left on the stack by entries when running in algebraic mode, will be ignored.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → | objn

See also

  LAST, LASTARG, PICK

## APPLY not in app ↑ top

PDF page 133 · printed page 3-13

Type

  Function

Description

  Apply to Arguments Function: Creates an expression from the specified function name and arguments. A user-defined function f that checks its arguments for special cases often can’t determine whether a symbolic argument x represents one of the special cases. The function f can use APPLY to create a new expression f(x). If the user now evaluates f(x), x is evaluated before f, so the argument to f will be the result obtained by evaluating x. When evaluated in an algebraic expression, APPLY evaluates the arguments (to resolve local names in user-defined functions) before creating the new object.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  { symb1 ... symbn } | `name` | → | `name(symb1 ... symbn)`

Example

      The following user-defined function Asin is a variant of the built-in function ASIN. Asin checks for special numerical arguments. If the argument on the stack is symbolic (the second case in the case structure), Asin uses APPLY to return the expression `Asin(argument)`.
             « → argument « CASE -3 FS? THEN argument ASIN END
          { 6 7 9 } argument TYPE POS THEN `APPLY(Asin,argument)` EVAL END `argument==1` THEN `π/2` END `argument==-1` THEN `-π/2` END argument ASIN END » » `OAsinK

See also

  QUOTE, |

## ARC not in app ↑ top

PDF page 133 · printed page 3-13

Type

  Command

Description

  Draw Arc Command: Draws an arc in PICT counterclockwise from xθ1 to xθ2, with its center at the coordinate specified in argument 1 or level 4 and its radius specified in argument 2 or level 3. ARC always draws an arc of constant radius in pixels, even when the radius and center are specified in user-units, regardless of the relative scales in user-units of the x- and y-axes. With user-unit arguments, the arc starts at the pixel specified by (x, y) + (a, b), where (a, b) is the rectangular conversion of the polar coordinate (xradius, xθ1). The resultant distance in pixels from the starting point to the center pixel is used as the actual radius, r`. The arc stops at the pixel specified by (r`, xθ2). If xθ1 = xθ2, ARC plots one point. If |xθ1 – xθ2| >360 degrees, 2π radians, or 400 grads, ARC draws a complete circle.

Flags

  Angle Mode (–17 and –18). The setting of flags –17 and –18 determine the interpretation of xθ1 and xθ2 (degrees, radians, or grads).

Input/Output

  Level 4/Argument 1 Level 3/Argument 2 Level 2/Argument 3 Level 1/Argument 4 | Level 1/Item 1 |  |  |
  --- | --- | --- | --- | ---
  (x, y) | xradius | x θ1 | x θ2 | →
  { #n,#m } | #nradius | x θ1 | x θ2 | →

Flags

  Angle Mode (–17 and –18)

See also

  BOX, LINE, TLINE

## ARCHIVE not in app ↑ top

PDF page 134 · printed page 3-14

Type

  Command

Description

  Archive HOME Command: Creates a backup copy of the HOME directory (that is, all variables), the user-key assignments, and the alarm catalog in the specified backup object (:nport:name) in RAM or flash ROM. The specified port number can be 0 through 3, where 3 is the SD card. (Port 3 only applies to the HP 50g and 49g+.) An error will result if there is not enough memory in the specified port to copy the HOME directory. If the backup object is “:IO:name”, then the copied directory is transmitted in binary via Kermit protocol through the current I/O port to the specified filename. To save flag settings, execute RCLF and store the resulting list in a variable.

Flags

  I/O Device (–33), I/O Messages (–39), I/O Device for Wire (–78) if the argument is “:IO:name”.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  :nport :name | → |
  :IO :name | → |

See also

  RESTORE

## ARG in app ↑ top

PDF page 134 · printed page 3-14

Type

  Function

Description

  Argument Function: Returns the (real) polar angle θ of a complex number (x, y). The polar angle θ is equal to:

  - atan y/x for x ≥ 0
  - atan y/x + π sign y for x < 0, Radians mode
  - atan y/x + 180 sign y for x < 0, Degrees mode
  - atan y/x + 200 sign y for x < 0, Grads mode A real argument x is treated as the complex argument (x,0).
Flags

  Angle mode (–17, –18)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x, y) | → | θ
  `symb` | → | `ARG(symb)`

See also

  ATAN

## ARIT not in app ↑ top

PDF page 135 · printed page 3-15

Type

  Command

Description

  Displays a menu or list showing the three CAS submenus for arithmetical operations, INTEGER, MODULAR and POLYNOMIAL.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the submenus as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## ARRY→ in app ↑ top

PDF page 135 · printed page 3-15

Type

  Command

Description

  Array to Stack Command: Takes an array and returns its elements as separate real or complex numbers. Also returns a list of the dimensions of the array. If the argument is an n-element vector, the first element is returned to level n + 1 (not level nm + 1), and the nth element to level 2.

Input/Output

  Level 1/Argument 1 |  | Lnm+1/A1 ... L2/Anm | Level1/Itemnm+1
  --- | --- | --- | ---
  [ vector ] | → | z1 ... zn | { nelement }
  [[ matrix ]] | → | z11 ... znm | { nrow mcol }
  L = Level; I = item

See also

  →ARRY, DTAG, EQ→, LIST→, OBJ→, STR→

## →ARRY in app ↑ top

PDF page 135 · printed page 3-15

Type

  Command

Description

  Stack to Array Command: Returns a vector of n real or complex elements or a matrix of n × m real or complex elements. The elements of the result array should be entered in row order. If one or more of the elements is a complex number, the result array will be complex.

Input/Output

  Levelnm+1/Argument1 7 Level2/Argumentnm Level1/Argumentnm+1 | Level1/Item1 |  |
  --- | --- | --- | ---
  z1 … zn | nelement | → | [ vector ]
  z1 1 … zn m | { nrow, mcol } | → | [[ matrix ]]

See also

  ARRY→, LIST→, →LIST, OBJ→, STR→, →TAG, →UNIT

## ASIN in app ↑ top

PDF page 135 · printed page 3-15

Type

  Analytic Function

Description

  Arc Sine Analytic Function: Returns the value of the angle having the given sine. For a real argument x in the domain –1 ≤ x ≤ 1, the result ranges from –90 to +90 degrees (–π/2 to +π/2 radians; –100 to +100 grads). A real argument outside of this domain is converted to a complex argument z = x + 0i, and the result is complex.

  The inverse of SIN is a relation, not a function, since SIN sends more than one argument to the same result. The inverse relation for SIN is expressed by ISOL as the general solution: ASIN(Z)*(-1)^n1+π*n1 The function ASIN is the inverse of a part of SIN, a part defined by restricting the domain of SIN such that:

  - each argument is sent to a distinct result, and
  - each possible result is achieved. The points in this restricted domain of SIN are called the principal values of the inverse relation. ASIN in its entirety is called the principal branch of the inverse relation, and the points sent by ASIN to the boundary of the restricted domain of SIN form the branch cuts of ASIN. The principal branch used by the calculator for ASIN was chosen because it is analytic in the regions where the arguments of the real-valued inverse function are defined. The branch cut for the complex-valued arc sine function occurs 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 ASIN. 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 ASIN(Z)*(–1)^n1+π*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). Taken together, the bands cover the whole complex plane, which is the domain of SIN. View these graphs with domain and range reversed to see how the domain of SIN is restricted to make an inverse function possible. Consider the vertical band in the lower graph as the restricted domain Z = (x, y). SIN sends this domain onto the whole complex plane in the range W = (u, v) = SIN(x, y) in the upper graph.
Flags

  Principal Solution (–1), Numerical Results (–3), Angle Mode (–17, –18)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | asin z
  `symb` | → | `ASIN(symb)`

See also

  ACOS, ATAN, ISOL, SIN

## ASIN2C in app ↑ top

PDF page 137 · printed page 3-17

Type

  Command

Description

  Transforms an expression by replacing asin(x) subexpressions with π/2–acos(x) subexpressions.

Input

  An expression

Output

  The transformed expression.

Flags

  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).

See also

  ACOS2S, ASIN2T, ATAN2S

## ASIN2T in app ↑ top

PDF page 137 · printed page 3-17

Type

  Command

Description

  Transforms an expression by replacing asin(x) subexpressions with the following: - x - atan - ------------------ - 1 – x 2-

Input

  An expression.

Output

  The transformed expression.

Flags

  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).

See also

  ASIN2C, ACOS2S, ATAN2S

## ASINH in app ↑ top

PDF page 137 · printed page 3-17

Type

  Analytic Function

Description

  Arc Hyperbolic Sine Analytic Function: Returns the inverse hyperbolic sine of the argument. The inverse of SINH is a relation, not a function, since SINH sends more than one argument to the same result. The inverse relation for SINH is expressed by ISOL as the general solution: ASINH(Z)*(–1)^n1+π*i*n1 The function ASINH is the inverse of a part of SINH, a part defined by restricting the domain of SINH such that:

  - each argument is sent to a distinct result, and
  - each possible result is achieved. The points in this restricted domain of SINH are called the principal values of the inverse relation. ASINH in its entirety is called the principal branch of the inverse relation, and the points sent by ASINH to the boundary of the restricted domain of SINH form the branch cuts of ASINH.

  The principal branch used by the calculator for ASINH was chosen because it is analytic in the regions where the arguments of the real-valued function are defined. The branch cut for the complex-valued ASINH function occurs where the corresponding real-valued function is undefined. The principal branch also preserves most of the important symmetries. The graph for ASINH can be found from the graph for ASIN (see ASIN) and the relationship asinh z = –i asin iz.

Flags

  Principal Solution (–1), Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | asinh z
  `symb` | → | `ASINH(symb)`

See also

  ACOSH, ATANH, ISOL, SINH

## ASN not in app ↑ top

PDF page 138 · printed page 3-18

Type

  Command

Description

  Assign Command: Defines a single key on the user keyboard by assigning the given object to the key xkey, which is specified as rc.pf. The argument xkey is a real number rc.pf specifying the key by its row number r, column number c, shift plane p and shift-and-hold flag f. A value of f=0 represents a normal shifted key assignment (where the shift is released prior to pressing the key); whereby f=1 corresponds to a shift-and- hold key assignment indicated by “&” in the table below (where the shift is held while pressing the key). The legal values for p and f are as follows:

          Value of                                          Value
                                         Shift                                  Shift
                .pf                                             of .pf

             .00 or .10   Unshifted [key]

             .20          !(left-shifted) [key]                .21       ! & [key]

             .30          …(right-shifted) [key]               .31       … & [key]

             .40          ~(alpha-shifted) [key]               .41       ~& [key]

             .50          ~!(alpha left-shifted) [key]         .51       ~!& [key]

             .60          ~…(alpha right-shifted) [key]        .61       ~…& [key]

  Once ASN has been executed, pressing a given key in User or 1-User mode executes the user- assigned 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.

Flags

  User-Mode Lock (–61) and User Mode (–62) affect the status of the user keyboard

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | xkey | → |
  `SKEY` | xkey | → |

Example

  Executing ASN with GETI in level 2 and 75.3 in level 1 assigns GETI to …Õon the user keyboard. (…Õ has a location of 75.3 because it is seven rows down, five columns across, and right-shifted.) When the calculator is in User mode, pressing …Õ now executes GETI (instead of executing Õ).

See also

  DELKEYS, RCLKEYS, STOKEYS

## ASR in app ↑ top

PDF page 139 · printed page 3-19

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 calculator makes no special provision for signed binary integers, you can still interpret a number as a signed quantity.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  SL, SLB, SR, SRB

## ASSUME not in app ↑ top

PDF page 139 · printed page 3-19

Type

  Function

Description

  Adds global names to the reserved variable REALASSUME, with specific assumptions. REALASSUME is a list of the global variables that will be considered by some CAS operations to represent real numbers when complex mode is set. ASSUME adds further assumptions, for example that a variable is greater than or equal to zero. Assumptions must be of the form v≤expression, or v≥expression, where v is the variable name. Several assumptions can be combined. These assumptions are used by the solve commands; for example if a variable is assumed to be greater than zero then the solvers will not look for solutions where that variable is negative. Some of the solvers will give complex solutions for variables even if they are in REALASSUME.

Input

  Level 1/Item 1: An expression giving the name of the global variable to be added to the REALASSUME list, and the assumption to be placed on it, or a list of such assumptions.

Output

  Level 1/Item 1: The input expression or list of expressions.

Example

  Add the CAS assumption that the global variable Z is real and positive. Note that ASSUME will replace Z>0 with Z≥0, which does not guarantee that Z is positive, so Z≥MINR is used instead, which guarantees that Z is greater than or equal to the smallest positive number the calculator recognizes.

  Command | ASSUME(Z≥MINR)
  Result | Z≥MINR

See also

  ADDTOREAL, UNASSUME

## ATAN in app ↑ top

PDF page 140 · printed page 3-20

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 calculator 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.
Flags

  Principal Solution (–1), Numerical Results (–3), Angle Mode (–17, –18)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | atan z
  `symb` | → | `ATAN(symb)`

See also

  ACOS, ASIN, ISOL, TAN

## ATAN2S in app ↑ top

PDF page 141 · printed page 3-21

Type

  Command

Description

  Transforms an expression by replacing atan(x) subexpressions with the following: - x - asin - ------------------- - x 2 + 1-

Input

  An expression.

Output

  The transformed expression.

Flags

  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).

See also

  ASIN2C, ACOS2S, ASIN2T

## ATANH in app ↑ top

PDF page 142 · printed page 3-22

Type

  Analytic Function

Description

  Arc Hyperbolic Tangent Analytic Function: Returns the inverse hyperbolic tangent of the argument. For real arguments |x| > 1, ATANH returns the complex result obtained for the argument (x, 0). For a real argument x=±1, an Infinite Result exception occurs. If flag –22 is set (no error), the sign of the result (MAXR) matches that of the argument. The inverse of TANH is a relation, not a function, since TANH sends more than one argument to the same result. The inverse relation for TANH is expressed by ISOL as the general solution; ATANH(Z)+π*i*n1 The function ATANH is the inverse of a part of TANH, a part defined by restricting the domain of TANH such that:

  - each argument is sent to a distinct result, and
  - each possible result is achieved. The points in this restricted domain of TANH are called the principal values of the inverse relation. ATANH in its entirety is called the principal branch of the inverse relation, and the points sent by ATANH to the boundary of the restricted domain of TANH form the branch cuts of ATANH. The principal branch used by the calculator for ATANH was chosen because it is analytic in the regions where the arguments of the real-valued function are defined. The branch cut for the complex-valued ATANH function occurs where the corresponding real-valued function is undefined. The principal branch also preserves most of the important symmetries. The graph for ATANH can be found from the graph for ATAN (see ATAN) and the relationship atanh z = –i atan iz.
Flags

  Principal Solution (–1), Numerical Results (–3), Infinite Result Exception (–22)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | atanh z
  `symb` | → | `ATANH(symb)`

See also

  ACOSH, ASINH, ISOL, TANH

## ATICK not in app ↑ top

PDF page 142 · printed page 3-22

Type

  Command

Description

  Axes Tick-Mark Command: Sets the axes tick-mark annotation in the reserved variable PPAR. Given x, ATICK sets the tick-mark annotation to x units on both the x- and the y-axis. For example, 2 would place tick-marks every 2 units on both axes. Given #n, ATICK sets the tick-mark annotation to #n pixels on both the x- and the y-axis. For example, #5 would place tick-marks every 5 pixels on both axes. Given { x y }, ATICK sets the tick-mark unit annotation for each axis individually. For example, { 10 3 } would mark the x-axis at every multiple of 10 units, and the y-axis at every multiple of 3 units. Given { #n #m } ATICK sets the tick-mark pixel annotation for each axis individually. For example, {#6 #2 } would mark the x-axis every 6 pixels, and the y-axis every 2 pixels.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → |
  #n | → |
  {xy} | → |
  { #n #m } | → |

See also

  AXES, DRAX

## ATTACH not in app ↑ top

PDF page 143 · printed page 3-23

Type

  Command

Description

  Attach Library Command: Attaches the library with the specified number to the current directory. Each library has a unique number. If a port number is specified, it is ignored. To use a library object, it must be in a port and it must be attached. A library object copied into RAM (such as through the PC Link) must be stored into a port using STO. Some libraries require you to ATTACH them. You can ascertain whether a library is attached to the current directory by executing LIBS. The number of libraries that can be attached to the HOME directory is limited only by the available memory. However, only one library at a time can be attached to any other directory. If you attempt to attach a second library to a non-HOME directory, the new library will overwrite the old one.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nlibrary | → |
  :nport :nlibrary | → |

See also

  DETACH, LIBS

## AUGMENT in app ↑ top

PDF page 143 · printed page 3-23

Type

  Command

Description

  Concatenate two lists, a list and an element, or a vector and an element. Also creates a matrix from component row vectors.

Input

  Level 2/Argument 1: A vector, a list, a matrix, or a string. Level 1/Argument 2: A vector, a list, a matrix, or an element.

Output

  The matrix, list or string formed by combining the arguments. In the case of a string in level 2, AUGMENT acts exactly like “+” or “ADD”.

  Example 1: Append 3 to the list {1,2}:
  Command | AUGMENT({1,2},3)
  Result | {1,2,3}
  Example 2: Combine the rows [1,2,3] and [4,5,6] into a matrix:
  Command | AUGMENT([1,2,3],[4,5,6])

  1 2 3 4 5 6 Result:

## AUTO not in app ↑ top

PDF page 144 · printed page 3-24

Type

  Command

Description

  Autoscale Command: Calculates a y-axis display range, or an x- and y-axis display range. The action of AUTO depends on the plot type as follows:

  Plot Type | Scaling Action
  --- | ---
  FUNCTION | Samples the equation in EQ at 40 values of the independent

  variable, equally spaced through the x-axis plotting range, discards points that return ±∞, then sets the y-axis display range to include the maximum, minimum, and origin.

  CONIC | Sets the y-axis scale equal to the x-axis scale.
  --- | ---
  POLAR | Samples the equation in EQ at 40 values of the independent

  variable, equally spaced through the plotting range, discards points that return ±∞, then sets both the x- and y-axis display ranges in the same manner as for plot type FUNCTION.

  PARAMETRIC | Same as POLAR.
  --- | ---
  TRUTH | No action.
  BAR | Sets the x-axis display range from 0 to the number of elements in

  ΣDAT, plus 1. Sets the y-range to the minimum and maximum of the elements. The x-axis is always included.

       HISTOGRAM          Sets the x-axis display range to the minimum and maximum of

  the elements in ΣDAT. Sets the y-axis display range from 0 to the number of rows in ΣDAT.

       SCATTER            Sets the x-axis display range to the minimum and maximum of

  the independent variable column (XCOL) in ΣDAT. Sets the y- axis display range to the minimum and maximum of the dependent variable column (YCOL). AUTO does not affect 3D plots. AUTO actually calculates a y-axis display range and then expands that range so that the menu labels do not obscure the resultant plot. AUTO does not draw a plot — execute DRAW to do so.

Input/Output

  None

See also

  DRAW, SCALEH, SCALE, SCLΣ, SCALEW, XRNG, YRNG

## AXES not in app ↑ top

PDF page 144 · printed page 3-24

Type

  Command

Description

  Axes Command: Specifies the intersection coordinates of the x- and y-axes, tick-mark annotation, and the labels for the x- and y-axes. This information is stored in the reserved variable PPAR.

  The argument for AXES (a complex number or list) is stored as the fifth parameter in the reserved variable PPAR. How the argument is used depends on the type of object it is:

  - If the argument is a complex number, it replaces the current entry in PPAR.
  - If the argument is a list containing any or all of the above variables, only variables that are specified are affected. atick has the same format as the argument for the ATICK command. This is the variable that is affected by the ATICK command. The default value for AXES is (0,0). Axes labels are not displayed in PICT until subsequent execution of LABEL.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x, y) | → |
  { (x, y) atick “x-axis label” “y-axis label” } | → |

Example

  The command sequence { (0,0) 2 "t" "y" } AXES LABEL specifies an axes intersection at (0,0), tick-mark annotation every 2 units, and puts the labels t and y PICT. The labels are positioned to identify the horizontal and vertical axes respectively.

See also

  ATICK, DRAW, DRAX, LABEL

## AXL in app ↑ top

PDF page 145 · printed page 3-25

Type

  Command

Description

  Converts a list to an array, or an array to a list.

Input

  A list or an array.

Output

  If the input is a list, returns the corresponding array. If the input is an array, returns the corresponding list.

Example

  Convert the following matrix to a list: 01 10

  Command | AXL([[0,1][1,0]])
  Result | {{0,1},{1,0}}

See also

  AXM, AXQ

## AXM in app ↑ top

PDF page 145 · printed page 3-25

Type

  Command

Description

  Converts a numeric array (object type 3) to a symbolic matrix (object type 29), or a symbolic matrix to a numeric array.

Input

  A numeric array or a symbolic matrix.

Output

  The corresponding symbolic matrix or numeric array.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

See also

  AXL, AXQ

## AXQ not in app ↑ top

PDF page 146 · printed page 3-26

Type

  Command

Description

  Converts a square matrix into the associated quadratic form.

Input

  Level 2/Argument 1: An n×n matrix. Level 1/Argument 2: A vector containing n variables.

Output

  Level 2/Item 1: The corresponding quadratic form. Level 1/Item 2: The vector containing the variables.

Flags

  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

  Find the quadratic form, expressed in terms of x, y, and z, associated with the following matrix: 360 241 111

  Command | AXQ([[3,6,0][2,4,1][1,1,1]],[X,Y,Z])
  Result | {3*X^2+(8*Y+Z)*X+(4*Y^2+2*Z*Y+Z^2),[X,Y,Z]}

See also

  AXL, AXM, GAUSS, QXA

## BAR not in app ↑ top

PDF page 146 · printed page 3-26

Type

  Command

Description

  Bar Plot Type Command: Sets the plot type to BAR. When the plot type is BAR, the DRAW command plots a bar chart using data from one column of the current statistics matrix (reserved variable ΣDAT). The column to be plotted is specified by the XCOL command, and is stored in the first parameter of the reserved variable ΣPAR. The plotting parameters are specified in the reserved variable PPAR, which has the following form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type BAR, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is either a name specifying a label for the horizontal axis, or a list containing such a name and two numbers, with the smaller of the numbers specifying the horizontal location of the first bar. The default value of indep is X.
  - res is a real number specifying the bar width in user-unit coordinates, or a binary integer specifying the bar width in pixels. The default value is 0, which specifies a bar width of 1 in user-unit coordinates.
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command BAR places the command name BAR in PPAR.
  - depend is a name specifying a label for the vertical axis. The default value is Y. A bar is drawn for each element of the column in ΣDAT. Its width is specified by res and its height is the value of the element. The location of the first bar can be specified by indep; otherwise, the value in (xmin, ymin) is used.
Input/Output

  None

See also

  CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## BARPLOT not in app ↑ top

PDF page 147 · printed page 3-27

Type

  Command

Description

  Draw Bar Plot Command: Plots a bar chart of the specified column of the current statistics matrix (reserved variable ΣDAT). The data column to be plotted is specified by XCOL and is stored as the first parameter in reserved variable ΣPAR. The default column is 1. Data can be positive or negative, resulting in bars above or below the axis. The y-axis is autoscaled, and the plot type is set to BAR. When BARPLOT is executed from a program, the resulting plot does not persist unless PICTURE, PVIEW (with an empty list argument), or FREEZE is subsequently executed.

Input

  None

Output

  A bar chart based on ΣDAT.

See also

  FREEZE, HISTPLOT, PICTURE, PVIEW, SCATRPLOT, XCOL

## BASIS not in app ↑ top

PDF page 147 · printed page 3-27

Type

  Command

Description

  Determines the basis of a sub-space of the n-space Rn.

Input

  A list of vectors defining a vector sub-space of Rn.

Output

  A list containing the vectors of a basis of the vector sub-space.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the vectors that form a basis of the sub-space defined by [1,2,3], [1,1,1], and [2,3,4]

  Command | BASIS({[1,2,3],[1,1,1],[2,3,4]})
  Result | {[1,0,-1],[0,1,2]}

See also

  IBASIS

## BAUD not in app ↑ top

PDF page 147 · printed page 3-27

Type

  Command

Description

  Baud Rate Command: Specifies bit-transfer rate. Legal baud rates are 2400, 4800, 9600, 14400, 19200, 38400, 57600 and 115200 (default).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nbaudrate | → |

See also

  CKSM, PARITY, TRANSIO

## BEEP not in app ↑ top

PDF page 148 · printed page 3-28

Type

  Command

Description

  Beep Command: Sounds a tone at n hertz for x seconds. The frequency of the tone is subject to the resolution of the built-in tone generator. The minimum frequency is 1 Hz and the maximum frequency in 15000 Hz. An input that doesn’t round to an integer within this range will cause the BEEP command to be skipped. Durations greater than 1200 seconds are automatically changed to 1200 seconds.

Flags

  Error Beep (–56)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  nfrequency | xduration | → |

See also

  HALT, INPUT, PROMPT, WAIT

## BESTFIT in app ↑ top

PDF page 148 · printed page 3-28

Type

  Command

Description

  Best-Fitting Model Command: Executes LR with each of the four curve fitting models, and selects the model yielding the largest correlation coefficient. The selected model is stored as the fifth parameter in the reserved variable ΣPAR, and the associated regression coefficients, intercept and slope, are stored as the third and fourth parameters, respectively.

Input/Output

  None

See also

  EXPFIT, LINFIT, LOGFIT, LR, PWRFIT

## BIN in app ↑ top

PDF page 148 · printed page 3-28

Type

  Command

Description

  Binary Mode Command: Selects binary base for binary integer operations. (The default base is decimal.) Binary integers require the prefix #. Binary integers entered and returned in binary base automatically show the suffix b. If the current base is not binary, binary numbers can still be entered by using the suffix b (the numbers are displayed in the current base, however). The current base does not affect the internal representation of binary integers as unsigned binary numbers.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  None

See also

  DEC, HEX, OCT, STWS, RCWS

## BINS not in app ↑ top

PDF page 149 · printed page 3-29

Type

  Command

Description

  Sort into Frequency Bins Command: Sorts the elements of the independent column (XCOL) of the current statistics matrix (the reserved variable ΣDAT) into (nbins + 2) bins, where the left edge of bin 1 starts at value xmin and each bin has width xwidth. BINS returns a matrix containing the frequency of occurrences in each bin, and a 2-element array containing the frequency of occurrences falling below or above the defined range of x-values. The array can be stored into the reserved variable ΣDAT and used to plot a bar histogram of the bin data (for example, by executing BARPLOT). For each element x in ΣDAT, the nth bin count nfreq bin n is incremented, where: x – x m in n f r e q b in n = IP ------------------ - x w i d th

  for xmin ≤ x ≤ xmax, where xmax = xmin + (nbins)(xwidth).

Input/Output

  L3/A1 | L2/A2 | L1/A3 |  | L2/I1 | L1/I2
  --- | --- | --- | --- | --- | ---
  xmin | xwidth | nbins | → | [[ nbin 1 ... nbin n ]] | [ nbin L nbin R]
  L = Level; A = Argument; I = item

Example

  If the independent column of ΣDAT contains the following data: 7 2 3 1 4 6 9 0 1 1 3 5 13 2 6 9 5 8 5 1 2 5 BINS returns [[ 5 ][ 3 ][ 5 ][ 2 ][ 2 ]] and [ 1 1 ] The data has been sorted into 5 bins of width 2, starting at x-value 1 and ending at x-value 11. The first element of the matrix shows that 5 x-values (2 1 1 1 2) fell in bin 1, where bin 1 ranges from x-value 1 through 2.99999999999. The vector shows that one x-value was less than xmin (0), and one was greater than xmax (13).

See also

  BARPLOT, XCOL

## BLANK not in app ↑ top

PDF page 149 · printed page 3-29

Type

  Command

Description

  Blank Graphics Object Command: Creates a blank graphics object of the specified width and height.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  #nwidth | #mheight | → | grobblank

See also

  →GROB, LCD→

## BOX not in app ↑ top

PDF page 149 · printed page 3-29

Type

  Command Operation

Description

  Box Command: Draws in PICT a box whose opposite corners are defined by the specified pixel or user-unit coordinates.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  { #n1 #m1 } | { #n2 #m2 } | → |
  (x1, y1) | (x2, y2) | → |

See also

  ARC, LINE, TLINE

## BUFLEN not in app ↑ top

PDF page 150 · printed page 3-30

Type

  Command

Description

  Buffer Length Command: Returns the number of characters in the calculator’s serial input buffer and a single digit indicating whether an error occurred during data reception. The digit returned is 1 if no framing, UART overrun, or input-buffer overflow errors occurred during reception, or 0 if one of these errors did occur. (The input buffer holds up to 255 bytes.) When a framing or overrun error occurs, data reception ceases until the error is cleared (which BUFLEN does); therefore, n represents the data received before the error. Use ERRM to see which error has occurred when BUFLEN returns 0 to level 1.

Input/Output

  | Level 1/Argument 1 | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  → | nchars | 0/1 |

See also

  CLOSEIO, OPENIO, SBRK, SRECV, STIME, XMIT

## BYTES in app ↑ top

PDF page 150 · printed page 3-30

Type

  Command

Description

  Byte Size Command: Returns the number of bytes and the checksum for the given object. If the argument is a built-in object, then the size is 2.5 bytes and the checksum is #0. If the argument is a global name, then the size represents the name and its contents, while the checksum represents the contents only. The size of the name alone is (3.5 + n), where n is the number of characters in the name.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  obj | → | #nchecksum | xsize

Example

      Objects that decompile identically can have different byte sizes and checksums. For instance, {1} and 1 `A` STO A {} + both produce lists containing the number 1. However, the first list contains the built-in object 1 (for a size of 7.5 bytes), while the second list contains a RAM copy of 1 (for a size of 15.5 bytes).

See also

  MEM

## B→R in app ↑ top

PDF page 150 · printed page 3-30

Type

  Command

Description

  Binary to Real Command: Converts a binary integer to its floating-point equivalent.

  If # n ≥ # 1000000000000 (base 10), only the 12 most significant decimal digits are preserved in the resulting mantissa.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n | → | n

See also

  R→B

## C$ not in app ↑ top

PDF page 151 · printed page 3-31

Type

  Command

Description

  Counted String Command: Enters C$ on the command line to help with the manual entry of a string object. Must be followed by a number indicating the number of characters to include in the strings, or an additional $ to indicate that the rest of the command line is a single string. There must be exactly one separator character after the second $ and before the body of the string. If the declared length is greater than the number of characters actually available, the string is automatically truncated to the correct length.

## C2P not in app ↑ top

PDF page 151 · printed page 3-31

Type

  Command

Description

  Takes a list of cycles as an argument, and returns the equivalent permutation. In other words, finds a permutation from its cyclical decomposition.

Input

  A list of cycles equivalent to a permutation. For example, the list {1,3,5} defines a cycle C, such that C(1)=3, C(3)=5 and C(5)=1, while items 2 and 4 are not changed. This could be followed by {2,4} which defines a cycle C, such that C(2)=4, and C(4)=2.

Output

  A list representing the permutation equivalent to the cycles.

Example

  Convert the cycles given by {{1,3,5},{2,4}} into a permutation:

  Command | C2P({{1,3,5},{2,4}})
  Result | {3,4,5,2,1}

See also

  P2C, CIRC

## CASCFG not in app ↑ top

PDF page 151 · printed page 3-31

Type

  Command

Description

  Restores the default CAS mode settings. This command is almost equivalent to pressing L !RESET, then selecting “Reset all” and pressing !!OK!, when the CAS Modes input form is displayed. The difference is that CASCFG sets the modulus value to 13, whereas “Reset all” sets the modulus to 3.

## CASCMD not in app ↑ top

PDF page 152 · printed page 3-32

Type

  Command

Description

  Displays a list of CAS operations. Selecting one with OK displays a description, related operations, an example of the operation, and the option to copy the example to the command line. More details are given in Appendix C and Appendix H of the User’s Guide. If level 1 of the stack contains a string, the list of CAS operations will be displayed beginning at this point.

See also

  HELP

## CASE not in app ↑ top

PDF page 152 · printed page 3-32

Type

  Command

Description

  CASE Conditional Structure Command: Starts CASE … END conditional structure. The CASE … END structure executes a series of cases (tests). The first test that returns a true result causes execution of the corresponding true-clause, ending the CASE … END structure. A default clause can also be included: this clause executes if all tests evaluate to false. The CASE command is available in RPN programming only. You cannot use it in algebraic programming. The CASE … END structure has this syntax: CASE test-clause1 THEN true-clause1 END test-clause2 THEN true-clause2 END . . test-clausen THEN true-clausen END default-clause (optional) END When CASE executes, test-clause1 is evaluated. If the test is true, true-clause1 executes, then execution skips to END. If test-clause1 is false, test-clause2 executes. Execution within the CASE structure continues until a true clause is executed, or until all the test clauses evaluate to false. If the default clause is included, it executes if all test clauses evaluate to false.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  CASE | → |
  THEN | T/F | →
  END | → |
  END | → |

Example

      The following program takes a numeric argument from the stack:if the argument is negative, it is added to itselfif the argument is positive, it is negatedif the argument is zero, the program aborts
          « → X « CASE
          `X>0` THEN X NEG END `X<0` THEN X DUP + END `X==0` THEN 0 DOERR END END » »

See also

  END, IF, IFERR, THEN

## CEIL in app ↑ top

PDF page 153 · printed page 3-33

Type

  Function

Description

  Ceiling Function: Returns the smallest integer greater than or equal to the argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | n
  x_unit | → | n_unit
  `symb` | → | `CEIL(symb)`

See also

  FLOOR, IP, RND, TRNC

## CENTR not in app ↑ top

PDF page 153 · printed page 3-33

Type

  Command

Description

  Center Command: Adjusts the first two parameters in the reserved variable PPAR, (xmin, ymin) and (xmax, ymax), so that the point represented by the argument (x, y) is the plot center. On the HP 50g and 49g+, the center pixel is in row 40, column 65 when PICT is its default size (131 × 80). On the 48gII, the center pixel is in row 32, column 65 when PICT is its default size (131 × 64). If the argument is a real number x, CENTR makes the point (x,0) the plot center.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x, y) | → |
  x | → |

See also

  SCALE

## CF in app ↑ top

PDF page 153 · printed page 3-33

Type

  Command

Description

  Clear Flag Command: Clears the specified user or system flag. User flags are numbered 1 through 128. System flags are numbered –1 through –128. See Appendix C for a listing of the calculator’s system flags and their flag numbers.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nflagnumber | → |

See also

  FC?, FC?C, FS?, FS?C, SF

## %CH in app ↑ top

PDF page 153 · printed page 3-33

Type

  Function

Description

  Percent Change Function: Returns the percent change from x to y as a percentage of x. If both arguments are unit objects, the units must be consistent with each other. The dimensions of a unit object are dropped from the result, but units are part of the calculation. For more information on using temperature units with arithmetic functions, refer to the keyword entry of +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | 100(y – x)/x
  x | `symb` | → | `%CH(x,symb)`
  `symb` | x | → | `%CH(symb,x)`
  `symb1` | `symb2` | → | `%CH(symb1, symb2)`
  x_unit | y_unit | → | 100(y_unit – x_unit)/x_unit
  x_unit | `symb` | → | `%CH(x_unit,symb)`
  `symb` | x_unit | → | `%CH(symb,x_unit)`
  Example 1: 1_m 500_cm %CH returns 400, because 500 cm represents an increase of 400% over 1 m.
  Example 2: 100_K 150_K %CH returns 50.

See also

  %, %T

## CHINREM not in app ↑ top

PDF page 154 · printed page 3-34

Type

  Command

Description

  Chinese Remainder function. Solves a system of simultaneous polynomial congruences in the ring Z[x].

Input

  Level 2/Argument 1: A vector of the first congruence (expression and modulus). Level 1/Argument 2: A vector of the second congruence (expression and modulus).

Output

  A vector of the solution congruence (expression and modulus).

Flags

  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 the following simultaneous congruences for the polynomial u: 2 u ≡ x + 1 (mod x+2) u ≡ x – 1 (mod x+3)

  Command | CHINREM([X^2+1,X+2],[X-1,X+3])
  Result | [X^3+2*X^2+5,-(X^2+5*X+6)]

See also

  EGCD, ICHINREM

## CHOLESKY in app ↑ top

PDF page 154 · printed page 3-34

Type

  Command

Description

  Returns the Cholesky factorization of a square matrix.

Input

  A positive square matrix, M

Output

  An upper triangular matrix, P, such that tP*P=M. (tP is the transpose of P.)

Flags

  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

  Find the Cholesky factorization of: 11 15

                              -     -

  CHOLESKY - 1 1 - - 15- Command: 1 1 0 2 Result:

## CHOOSE not in app ↑ top

PDF page 155 · printed page 3-35

Type

  Command

Description

  Create User-Defined Choose Box Command: Creates a user-defined choose box. CHOOSE creates a standard single-choice choose box based on the following specifications:

  Variable | Function
  --- | ---
  “prompt” | A message that appears at the top of choose box. If “prompt” is an

  empty string (“”), no message is displayed.

       {c1 … cn}                  Definitions that appear within the choose box. A choice definition

  (cx) can have two formats.

  - obj, any object
  - { objdisplay objresult }, the object to be displayed followed by the result returned to the stack if that object is selected.

       npos                       The position number of an item definition. This item is highlighted

  when the choose box appears. If npos = 0, no item is highlighted, and the choose box can be used to view items only. If you choose an item from the choose box and press OK, CHOOSE returns the result (or the object itself if no result is specified) to level 2 and 1 to level 1. If you press −, CHOOSE returns 0. Also, if npos = 0, CHOOSE returns 0.

Input/Output

  L3/A1 | L2/A2 | L1/A3 |  | L2/I1 | L1/I2
  --- | --- | --- | --- | --- | ---
  “prompt” | { c1 ... cn } | npos | → | obj or result | “1”
  “prompt” | { c1 ... cn } | npos | → | “0” |
  L = Level; A = Argument; I = item

Example

      CHOOSE with the following three lines as input would produce a three-line choose box: "Select a Program" { { "Pie Chart" «PIE» } { "Inverse Function" «ROOTR» } { "Animate Taylor" «TSA» } } 1

See also

  INFORM, NOVAL

## CHR in app ↑ top

PDF page 155 · printed page 3-35

Type

  Command

Description

  Character Command: Returns a string representing the character corresponding to the character code n.

  The character codes are an extension of ISO 8859/1. Codes 128 through 160 are unique to the calculator. See Appendix J for a complete list of characters and character codes. The default character ā is supplied for all character codes that are not part of the normal calculator’s display character set. Character code 0 is used for the special purpose of marking the end of the command line. Attempting to edit a string containing this character causes the error Can`t Edit Null Char. You can use the CHARS application to find the character code for any character used by the calculator. See “Additional Character Set” in Appendix D of the HP 50g User’s Guide.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → | “string”

See also

  NUM, POS, REPL, SIZE, SUB

## CIRC not in app ↑ top

PDF page 156 · printed page 3-36

Type

  Command

Description

  Composes two permutations.

Input

  Two lists, L1 and L2, representing two permutations. The composition L1○L2 is the permutation equivalent to performing permutation L2 first and L1 second. Level 2/Argument 1: L1 Level 1/Argument 2: L2

Output

  A list representing the single equivalent permutation, L = L1○L2

Example

  Compose the permutations given by {3,4,5,2,1} and {2,1,4,3,5}

  Command | CIRC({3,4,5,2,1},{2,1,4,3,5})
  Result | {4,3,2,5,1}

See also

  C2P, P2C

## CKSM not in app ↑ top

PDF page 156 · printed page 3-36

Type

  Command

Description

  Checksum Command: Specifies the error-detection scheme. Legal values for nchecksum are as follows:

  - 1-digit arithmetic checksum.
  - 2-digit arithmetic checksum.
  - 3-digit cyclic redundancy check (default). The CKSM specified is the error-detection scheme that will be requested by KGET, PKT, or SEND. If the sender and receiver disagree about the request, however, then a 1-digit arithmetic checksum will be used.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nchecksum | → |

See also

  BAUD, PARITY, TRANSIO

## CLEAR in app ↑ top

PDF page 157 · printed page 3-37

Type

  Command

Description

  Clear Command: Removes all objects from the stack or history. To recover a cleared stack or history, press …¯ (the right-shift of the Mkey) before executing any other operation. There is no programmable command to recover the stack or history.

Input/Output

  Leveln/Argument 1 ... Level 1/Argumentn |  | Leveln/Item 1 ... Level 1/Itemn
  --- | --- | ---
  objn ...obj1 | → |

See also

  CLVAR, PURGE

## CLKADJ not in app ↑ top

PDF page 157 · printed page 3-37

Type

  Command

Description

  Adjust System Clock Command: Adjusts the system time by x clock ticks, where 8192 clock ticks equal 1 second. If x is positive, x clock ticks are added to the system time. If x is negative, x clock ticks are subtracted from the system time. If X>10^12, it will be changed to 10^12 ticks (which is approximately 3.87 years).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → |

See also

  →TIME

## CLLCD not in app ↑ top

PDF page 157 · printed page 3-37

Type

  Command

Description

  Clear LCD Command: Clears (blanks) the stack display. The menu labels continue to be displayed after execution of CLLCD. When executed from a program, the blank display persists only until the keyboard is ready for input. To cause the blank display to persist until a key is pressed, execute FREEZE after executing CLLCD. (When executed from the keyboard, CLLCD automatically freezes the display.)

Input/Output

  None

Example

      Evaluating « CLLCD 7 FREEZE » blanks the display (except the menu labels), then freezes the entire display.

See also

  DISP, FREEZE

## CLOSEIO not in app ↑ top

PDF page 157 · printed page 3-37

Type

  Command

Description

  Close I/O Port Command: Closes the serial port, and clears the input buffer and any error messages for KERRM. When the calculator turns off, it automatically closes the serial port, but does not clear KERRM. Therefore, CLOSEIO is not needed to close the port, but can conserve power without turning off the calculator. Executing Kermit protocol commands automatically clears the input buffer; however, executing non-Kermit commands (such as SRECV and XMIT) does not. CLOSEIO also clears error messages from KERRM. This can be useful when debugging.

Input/Output

  None

See also

  BUFLEN, OPENIO

## CLΣ not in app ↑ top

PDF page 158 · printed page 3-38

Type

  Command

Description

  Purges the current statistics matrix (reserved variable ΣDAT).

Input/Output

  None

See also

  RCLΣ, STOΣ, Σ+, Σ–

## CLUSR not in app ↑ top

PDF page 158 · printed page 3-38

Type

  Command

Description

  Clear Variables Command: Provided for compatibility with the HP 28 series. CLUSR is the same as CLVAR. See CLVAR.

## CLVAR not in app ↑ top

PDF page 158 · printed page 3-38

Type

  Command

Description

  Clear Variables Command: Purges all variables and empty subdirectories in the current directory.

Input/Output

  None

See also

  PGDIR, PURGE

## CMPLX in app ↑ top

PDF page 158 · printed page 3-38

Type

  Command

Description

  Displays a menu of commands pertaining to complex numbers.

Input/Output

  None

See also

  ARIT, DIFF, EXP&LN, SOLVER, TRIGO

## CNRM in app ↑ top

PDF page 158 · printed page 3-38

Type

  Command

Description

  Column Norm Command: Returns the column norm (one-norm) of the array argument. The column norm of a matrix is the maximum (over all columns) of the sum of the absolute values of all elements in each column. For a vector, the column norm is the sum of the absolute values of the vector elements. For complex arrays, the absolute value of a given element (x, y) is

  2 | 2
  --- | ---
  x +y | .

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ array ] | → | xcolumnnorm

See also

  CROSS, DET, DOT, RNRM

## →COL in app ↑ top

PDF page 159 · printed page 3-39

Type

  Command

Description

  Matrix to Columns Command: Transforms a matrix into a series of column vectors and returns the vectors and a column count, or transforms a vector into its elements and returns the elements and an element count. →COL introduces no rounding error.

Input/Output

  Level 1/Argument 1 |  | Leveln+1/Item 1 ... | Level 2/Item 2 | Level 1/Item 3
  --- | --- | --- | --- | ---
  [[ matrix ]] | → | [ vector ]col1 | [ vector ]coln | ncolcount
  [ vector ] | → | element1 | elementn | nelementcount

See also

  COL→, →ROW, ROW→ COL→

Type

  Command

Description

  Columns to Matrix Command: Transforms a series of column vectors and a column count into a matrix containing those columns, or transforms a sequence of numbers and an element count into a vector with those numbers as elements. All vectors must have the same length. The column or element count is rounded to the nearest integer.

Input/Output

  Ln+1/A1 ... | L2/A2 | L1/An+1 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [ vector ]col1 | [ vector ]coln | ncolcount | → | [[ matrix ]]
  element1 | elementn | nelementcount | → | [ vector ]
  L = Level; A = Argument; I = item

See also

  →COL, →ROW, ROW→

## COL– not in app ↑ top

PDF page 159 · printed page 3-39

Type

  Command

Description

  Delete Column Command: Deletes column n of a matrix (or element n of a vector), and returns the modified matrix (or vector) and the deleted column (or element). n is rounded to the nearest integer.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | ncolumn | → | [[ matrix ]]2 | [ vector ]column
  [ vector ]1 | nelement | → | [ vector ]2 | elementn

See also

  COL+, CSWP, ROW+, ROW–

## COL+ in app ↑ top

PDF page 160 · printed page 3-40

Type

  Command

Description

  Insert Column Command: Inserts an array (vector or matrix) into a matrix (or one or more elements into a vector) at the position indicated by nindex, and returns the modified array. The inserted array must have the same number of rows as the target array. nindex is rounded to the nearest integer. The original array is redimensioned to include the new columns or elements, and the elements at and to the right of the insertion point are shifted to the right.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | [[ matrix ]]2 | nindex | → | [[ matrix ]]3
  [[ matrix ]]1 | [ vector ]column | nindex | → | [[ matrix ]]2
  [ vector ]1 | nelement | nindex | → | [ vector ]2

See also

  COL–, CSWP, ROW+, ROW–

## COLCT not in app ↑ top

PDF page 160 · printed page 3-40

Type

  Command

Description

  Factorizes a polynomial or an integer. Almost identical to COLLECT.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `symb1` | → | `symb2`
  x | → | x
  (x, y) | → | (x, y)
  Example 1: | COLCT(`5+X+9`) returns `X+14` |
  Example 2: | COLCT(`X*1_m+X*9_cm`) returns `X*1.09_m` |
  Example 3: | COLCT(`X^Z*Y*X^T*Y`) returns `Y^2*X^Z*X^T` |
  Example 4: | COLCT(`X+3*X+Y+Y`) returns `4*X+2*Y` |

See also

  EXPAN, FACTOR, ISOL, QUAD, SHOW

## COLLECT in app ↑ top

PDF page 160 · printed page 3-40

Type

  Command

Description

  Factorizes a polynomial or an integer. This command is almost identical to the COLCT command and similar to the FACTOR command. Unlike FACTOR it does not factorize symbolically into square roots. It is included to ensure backward-compatibility with earlier calculators.

Input

  An expression or an integer

Output

  The factorized expression, or the integer expressed as the product of prime numbers.

Flags

  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). If complex inputs are given, complex mode must be set (flag –103 set).

Example

  Factorize the following: 2 x + 5x + 6

  Command | COLLECT(X^2+5*X+6)
  Result | (X+2)(X+3)

See also

  COLCT, EXPAND, FACTOR

## COLΣ not in app ↑ top

PDF page 161 · printed page 3-41

Type

  Command

Description

  Column Sigma Command: Specifies the independent-variable and dependent-variable columns of the current statistics matrix (the reserved variable ΣDAT). COLΣ combines the functionality of XCOL and YCOL. The independent-variable column number xxcol is stored as the first parameter in the reserved variable ΣPAR (the default is 1). The dependent-variable column number xycol is stored as the second parameter in the reserved variable ΣPAR (the default is 2). COLΣ accepts and stores noninteger values, but subsequent commands that use these two parameters in ΣPAR will cause errors.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xcol | ycol | → |

Example

  2 5 COLΣ sets column 2 in ΣDAT as the independent-variable column, sets column 5 as the dependent-variable column, and stores 2 and 5 as the first and second elements in ΣPAR.

See also

  BARPLOT, BESTFIT, CORR, COV, EXPFIT, HISTPLOT, LINFIT, LOGFIT, LR, PREDX, PREDY, PWRFIT, SCATRPLOT, XCOL, YCOL

## COMB in app ↑ top

PDF page 161 · printed page 3-41

Type

  Function

Description

  Combinations Function: Returns the number of possible combinations of n items taken m at a time. The following formula is used: n! C n, m = ------------------------------ m! ⋅ ( n – m )! The arguments n and m must each be less than 1012. If n<m, zero is returned.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  n | m | → | Cn;m
  `symbn` | m | → | `COMB(symbn,m)`
  n | `symbm` | → | `COMB(n, symbm)`
  `symbn` | `symbm` | → | `COMB(symbn,symbm)`

See also

  FACT, PERM, !

## CON in app ↑ top

PDF page 161 · printed page 3-41

Type

  Command

Description

  Constant Array Command: Returns a constant array, defined as an array whose elements all have the same value.

  The constant value is a real or complex number taken from argument 2/level 1. The resulting array is either a new array, or an existing array with its elements replaced by the constant, depending on the object in argument 1/level 2.

  - Creating a new array: If argument 1/level 2 contains a list of one or two integers, CON returns a new array. If the list contains a single integer ncolumns, CON returns a constant vector with n elements. If the list contains two integers nrows and mcolumns, CON returns a constant matrix with n rows and m columns.
  - Replacing the elements of an existing array: If argument 1/level 2 contains an array, CON returns an array of the same dimensions, with each element equal to the constant. If the constant is a complex number, the original array must also be complex.
  - If argument 1/level 2 contains a name, the name must identify a variable that contains an array. In this case, the elements of the array are replaced by the constant. If the constant is a complex number, the original array must also be complex.
Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  { ncolumns } | zconstant | → | [ vectorconstant ]
  { nrows mcolumns } | zconstant | → | [[ matrixconstant ]]
  [ R-array ] | xconstant | → | [ R-arrayconstant ]
  [ C-array ] | zconstant | → | [ C-arrayconstant ]
  `name` zconstant →
  Example 1: { 2 2 } 6 CON returns the matrix [[ 6 6 ][ 6 6 ]].
  Example 2: [ (2,4) (7,9) ] 3 CON returns the complex vector [ (3,0) (3,0) ].

See also

  IDN

## COND in app ↑ top

PDF page 162 · printed page 3-42

Type

  Command

Description

  Condition Number Command: Returns the 1-norm (column norm) condition number of a square matrix. The condition number of a matrix is the product of the norm of the matrix and the norm of the inverse of the matrix. COND uses the 1-norm and computes the condition number of the matrix without computing the inverse of the matrix. The condition number expresses the sensitivity of the problem of solving a system of linear equations having coefficients represented by the elements of the matrix (this includes inverting the matrix). That is, it indicates how much an error in the inputs may be magnified in the outputs of calculations using the matrix. In many linear algebra computations, the base 10 logarithm of the condition number of the matrix is an estimate of the number of digits of precision that might be lost in computations using that matrix. A reasonable rule of thumb is that the number of digits of accuracy in the result is approximately MIN(12,15–log10(COND)).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]]m×n | → | xconditionnumber

Example

      The following program computes the above rule of thumb for the number of accurate digits: « DUP SIZE 1 GET LOG SWAP COND LOG + 11 SWAP - »

See also

  SNRM, SRAD, TRACE

## CONIC not in app ↑ top

PDF page 163 · printed page 3-43

Type

  Command

Description

  Conic Plot Type Command: Sets the plot type to CONIC. When the plot type is CONIC, the DRAW command plots the current equation as a second- order polynomial of two real variables. The current equation is specified in the reserved variable EQ. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type CONIC, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is a name specifying the independent variable, or a list containing such a name and two numbers specifying the minimum and maximum values for the independent variable (the plotting range). The default value is X.
  - res is a real number specifying the interval (in user-unit coordinates) between plotted values of the independent variable, or a binary integer specifying the interval in pixels. The default value is 0, which specifies an interval of 1 pixel.
  - axes is a complex number specifying the user-unit coordinates of the intersection of the horizontal and vertical axes, or a list containing such a number and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command CONIC places the command name CONIC in PPAR.
  - depend is a name specifying the dependent variable. The default value is Y. The current equation is used to define a pair of functions of the independent variable. These functions are derived from the second-order Taylor’s approximation to the current equation. The minimum and maximum values of the independent variable (the plotting range) can be specified in indep; otherwise, the values in (xmin, ymin) and (xmax, ymax) (the display range) are used. Lines are drawn between plotted points unless flag –31 is set.
Input/Output

  None

See also

  BAR, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## CONJ in app ↑ top

PDF page 163 · printed page 3-43

Type

  Function

Description

  Conjugate Analytic Function: Conjugates a complex number or a complex array. Conjugation is the negation (sign reversal) of the imaginary part of a complex number. For real numbers and real arrays, the conjugate is identical to the original argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | x
  (x, y) | → | (x, –y)
  [ R-array ] | → | [ R-array ]
  [ C-array ]1 | → | [ C-array ]2
  `symb` | → | `CONJ(symb)`
  Example 1: | [ (3,4) (7,2) ] CONJ returns [ (3,-4) (7,-2) ] |
  Example 2: | A square matrix A containing complex elements is said to be Hermitian if AH = A, where AH is |
  the same as a normal transpose except that the complex conjugate of each element is used. The following program returns 1 if the input matrix is Hermitian, and a 0 if it is not. « DUP TRN CONJ SAME »

See also

  ABS, IM, RE, SCONJ, SIGN

## CONLIB not in app ↑ top

PDF page 164 · printed page 3-44

Type

  Command

Description

  Open Constants Library Command: Opens the Constants Library catalog.

Input/Output

  None

See also

  CONST

## CONST not in app ↑ top

PDF page 164 · printed page 3-44

Type

  Function

Description

  Constant Value Command: Returns the value of a constant. CONST returns the value of the specified constant. It chooses the unit type depending on flag 60: SI if clear, English if set, and uses the units depending on flag 61: units if clear, no units if set. See “Tables of Units and Constants” in appendix B of this reference for a list of the constants available in the Constants Library.

Flags

  Units Type (60), Units Usage (61)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → | x

See also

  CONLIB

## CONSTANTS not in app ↑ top

PDF page 164 · printed page 3-44

Type

  Command

Description

  Displays a menu or list of CAS symbolic constants.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

Input/Output

  None

See also

  ALGB, ARIT, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## CONT in app ↑ top

PDF page 165 · printed page 3-45

Type

  Command

Description

  Continue Program Execution Command: Resumes execution of a halted program. Since CONT is a command, it can be assigned to a key or to a custom menu.

Input/Output

  None

Example

      The program « "Enter A, press { CONT }" { CONT } MENU PROMPT » displays a prompt message, builds a menu with the CONT command assigned to the first menu key, and halts the program for data input. After entering data, pressing %CONT% resumes program execution. (Note that pressing !æ is equivalent to pressing %CONT%.)

See also

  HALT, KILL, PROMPT

## CONVERT in app ↑ top

PDF page 165 · printed page 3-45

Type

  Command

Description

  Convert Units Command: Converts a source unit object to the dimensions of a target unit. The source and target units must be compatible. The number part x2 of the target unit object is ignored.

Input/Output

  Level 2/Argument 1 |  | Level 1/Argument 2 | Level 1/Item 1
  --- | --- | --- | ---
  x1_unitssource x2_unitstarget | → | x3_unitstarget |

See also

  UBASE, UFACT, →UNIT, UVAL

## CORR in app ↑ top

PDF page 165 · printed page 3-45

Type

  Command

Description

  Correlation Command: Returns the correlation coefficient of the independent and dependent data columns in the current statistics matrix (reserved variable ΣDAT). The columns are specified by the first two elements in the reserved variable ΣPAR, set by XCOL and YCOL, respectively. If ΣPAR does not exist, CORR creates it and sets the elements to their default values (1 and 2). The correlation is computed with the following formula: n ∑ ( xin – xn ) ( xin – xn )

                                                                   1           1             2            2

  i=1 ----------------------------------------------------------------------------------

                                             n                                2 n                                    2

  ∑ ( x in – xn ) ∑ ( xin – xn )

                                                             1            1                         2            2
                                              i=1                                    i=1

                    x in 1                                                                                        x in 2
          where              is the ith coordinate value in column n1,                                                         is the ith coordinate value in the column
             x n1                                                                              x n2
          n2 , is the mean of the data in column n1,                                                    is the mean of the data in column n2, and n is the

  number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xcorrelation |

See also

  COLΣ, COV, PREDX, PREDY, XCOL, YCOL

## COS in app ↑ top

PDF page 166 · printed page 3-46

Type

  Analytic Function

Description

  Cosine Analytic Function: Returns the cosine of the argument. For real arguments, the current angle mode determines the number’s interpretation as an angle, unless the angular units are specified. For complex arguments, cos(x + iy) = cosx coshy – i sinx sinhy. If the argument for COS is a unit object, then the specified angular unit overrides the angle mode to determine the result. Integration and differentiation, on the other hand, always observe the angle mode. Therefore, to correctly integrate or differentiate expressions containing COS with a unit object, the angle mode must be set to Radians (since this is a “neutral” mode).

Flags

  Numerical Results (–3), Angle Mode (–17, –18)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | cos z
  `symb` | → | `COS(symb)`
  x_unitangular | → | cos (x_unitangular)

See also

  ACOS, SIN, TAN

## COSH in app ↑ top

PDF page 166 · printed page 3-46

Type

  Analytic Function

Description

  Hyperbolic Cosine Analytic Function: Returns the hyperbolic cosine of the argument. For complex arguments, cosh(x + iy) = coshx cosy + i sinhx siny.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | cosh z
  `symb` | → | `COSH(symb)`

See also

  ACOSH, SINH, TANH

## COV in app ↑ top

PDF page 166 · printed page 3-46

Type

  Command

Description

  Covariance Command: Returns the sample covariance of the independent and dependent data columns in the current statistics matrix (reserved variable ΣDAT). The columns are specified by the first two elements in reserved variable ΣPAR, set by XCOL and YCOL respectively. If ΣPAR does not exist, COV creates it and sets the elements to their default values (1 and 2). The covariance is calculated with the following formula: 1 n ----------- ∑ ( x in 1 – x n 1 ) ( x in 2 – x n 2 ) n – 1i = 1

  where x in1 is the ith coordinate value in column n1, x in2 is the ith coordinate value in the column

  n2 , | is the
  --- | ---
  xn1mean of the data in column n1, | is thexnmean

  2 of the data in column n2, and n is the number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xcovariance |

See also

  COLΣ, CORR, PCOV, PREDX, PREDY, XCOL, YCOL

## CR not in app ↑ top

PDF page 167 · printed page 3-47

Type

  Command

Description

  Carriage Right Command: Prints the contents, if any, of the printer buffer. When printing to the serial port (flag –34 set), CR sends to the printer a string that encodes the line termination method. The default termination method is carriage-return/linefeed. The string is the fourth parameter in the reserved variable PRTPAR. When using the HP 82240B Infrared Printer (flag –34 clear), CR leaves the printhead on the right end of the just printed line.

Flags

  I/O Device (–33), Printing Device (–34), Double-Spaced Printing (–37), I/O Device for Wire (– 78)

Input/Output

  None

See also

  DELAY, OLDPRT, PRLCD, PRST, PRSTC, PRVAR, PR1

## CRDIR in app ↑ top

PDF page 167 · printed page 3-47

Type

  Command

Description

  Create Directory Command: Creates an empty subdirectory with the specified name in the current directory. CRDIR does not change the current directory; evaluate the name of the new subdirectory to make it the current directory.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `global` | → |

See also

  HOME, PATH, PGDIR, UPDIR

## CROSS in app ↑ top

PDF page 167 · printed page 3-47

Type

  Command

Description

  Cross Product Command: CROSS returns the cross product C = A × B of vectors A and B. The arguments must be vectors having two or three elements, and need not have the same number of elements. (The calculator automatically converts a two-element argument [ d1 d2 ] to a three-element argument [ d1 d2 0 ].)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  [ vector ]A | [ vector ]B | → | [ vector ]A × B

See also

  CNRM, DET, DOT, RNRM

## CSWP in app ↑ top

PDF page 167 · printed page 3-47

Type

  Command

Description

  Column Swap Command: Swaps columns i and j of the argument matrix and returns the modified matrix, or swaps elements i and j of the argument vector and returns the modified vector. Column numbers are rounded to the nearest integer. Vector arguments are treated as row vectors.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | ncolumni | ncolumnj | → | [[ matrix ]]2
  [ vector ]1 | nelementi | nelementj | → | [ vector ]2

See also

  COL+, COL–, RSWP

## CURL not in app ↑ top

PDF page 168 · printed page 3-48

Type

  Function

Description

  Returns the curl of a three-dimensional vector function.

Input

  Level 2/Argument 1: A three-dimensional vector function of three variables. Level 1/Argument 2: An array comprising the three variables.

Output

  The curl of the vector function with respect to the specified variables.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the curl of the following vector function:

                            2      2       2

  v = x yi + x yj + y zk

                              ˜      ˜      ˜
          Command:         CURL([X^2*Y, X^2*Y, Y^2*Z],[X,Y,Z])
          Result:          [Z*2*Y,0,Y*2*X-X^2]

See Also

  DIV, HESS, VPOTENTIAL

## CYCLOTOMIC in app ↑ top

PDF page 168 · printed page 3-48

Type

  Function

Description

  Returns the cyclotomic polynomial of order n. This is the polynomial whose roots are all the nth roots of 1, except those that are also roots of 1 for smaller values of n. For example, if n is 4, the 4th roots of 1 are {1, i, -1, -i}, but 1 is the 1st root of 1 and –1 is a 2nd root of 1, so only i and -i are left, giving the polynomial (x-i)(x+i) = x2+1.

Input

  A non-negative integer n

Output

  The cyclotomic polynomial of order n.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

  Example: Find the 20th cyclotomic polynomial.
  Command | CYCLOTOMIC(20)

Result

  X^8-X^6+X^4-X^2+1

## CYLIN in app ↑ top

PDF page 168 · printed page 3-48

Type

  Command

Description

  Cylindrical Mode Command: Sets Cylindrical coordinate mode. CYLIN clears flag –15 and sets flag –16. In Cylindrical mode, vectors are displayed as polar components. Therefore, a 3D vector would appear as [ R θ Z ].

Input/Output

  None

See also

  RECT, SPHERE

## C→PX not in app ↑ top

PDF page 169 · printed page 3-49

Type

  Command

Description

  Complex to Pixel Command: Converts the specified user-unit coordinates to pixel coordinates. The user-unit coordinates are derived from the (xmin, ymin) and (xmax, ymax) parameters in the reserved variable PPAR.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x, y) | → | { #n, #m }

See also

  PX→C C→R

Type

  Command

Description

  Complex to Real Command: Separates the real and imaginary parts of a complex number or complex array. The result in item 1/level 2 represents the real part of the complex argument. The result in item 2/ level 1 represents the imaginary part of the complex argument.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  (x, y) | → | x | y
  [ C-array ] | → | [R-array ]1 | [R-array ]2

See also

  R→C, RE, IM

## DARCY not in app ↑ top

PDF page 169 · printed page 3-49

Type

  Function

Description

  Darcy Friction Factor Function: Calculates the Darcy friction factor of certain fluid flows. DARCY calculates the Fanning friction factor and multiplies it by 4. xe/D is the relative roughness — the ratio of the conduit roughness to its diameter. yRe is the Reynolds number. The function uses different computation routines for laminar flow (Re ≤ 2100) and turbulent flow (Re > 2100). xe/D and yRe must be real numbers or unit objects that reduce to dimensionless numbers, and both numbers must be greater than 0.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xe / D | yRe | → | xDarcy

See also

  FANNING

## DATE not in app ↑ top

PDF page 169 · printed page 3-49

Type

  Command

Description

  Date Command: Returns the system date.

Flags

  Date Format (–42)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | date |

Example

  If the current date is May 12, 2010, if flag –42 is clear, and if the display mode is Standard, DATE returns 5.12201. (The trailing zeros are dropped.)

See also

  DATE+, DDAYS, TIME, TSTR

  →DATE

Type

  Command

Description

  Set Date Command: Sets the system date to date. date has the form MM.DDYYYY or DD.MMYYYY, depending on the state of flag –42. MM is month, DD is day, and YYYY is year. If YYYY is not supplied, the current specification for the year is used. The range of allowable dates is January 1, 2000 to December 31, 2090. Inputs between January 1, 1991 and December 31, 1999 are silently rejected by →DATE; no error is reported and the system date is left unchanged.

Flags

  Date Format (–42)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  date | → |

Example

  If flag –42 is set and the current system year is 2005, then 28.07 →DATE sets the system date as July 28, 2005.

See also

  →TIME

## DATE+ not in app ↑ top

PDF page 170 · printed page 3-50

Type

  Command

Description

  Date Addition Command: Returns a past or future date, given a date in argument 1/level 2 and a number of days in argument 2/level 1. If xdays is negative, DATE+ calculates a past date. The range of allowable dates is October 15, 1582, to December 31, 9999.

Flags

  Date Format (–42)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  date1 | xdays | → | datenew

See also

  DATE, DDAYS

## DBUG in app ↑ top

PDF page 170 · printed page 3-50

Type

  Operation

Description

  Debug Operation: Starts program execution, then suspends it as if HALT were the first program command. DBUG is programmable.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  « program » or `program name` | → |

See also

  HALT, NEXT

## DDAYS not in app ↑ top

PDF page 171 · printed page 3-51

Type

  Command

Description

  Delta Days Command: Returns the number of days between two dates. If the argument 1/level 2 date is chronologically later than the argument 2/ level 1 date, the result is negative. The range of allowable dates is October 15, 1582, to December 31, 9999.

Flags

  Date Format (–42)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  date1 | date2 | → | xdays

See also

  DATE, DATE+

## DEC in app ↑ top

PDF page 171 · printed page 3-51

Type

  Command

Description

  Decimal Mode Command: Selects decimal base for binary integer operations. (The default base is decimal.) Binary integers require the prefix #. Binary integers entered and returned in decimal base automatically show the suffix d. If the current base is not decimal, then you can enter a decimal number by ending it with d. It will be displayed in the current base when it is entered. The current base does not affect the internal representation of binary integers as unsigned binary numbers.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  None

See also

  BIN, HEX, OCT, RCWS, STWS

## DECR in app ↑ top

PDF page 171 · printed page 3-51

Type

  Command

Description

  Decrement Command: Takes a variable, subtracts 1, stores the new value back into the original variable, and returns the new value. The contents of name must be a real number or an integer.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → | xnew
  Example 1: | If 35.7 is stored in A, `A` DECR returns 34.7. |
  Example 2: | The following program counts down from 100 to 0 and leaves the integers 100 to 0 on the stack: |
  « 100 `A` STO WHILE A REPEAT `A` DECR END `A` PURGE »

See also

  INCR, STO+, STO–

## DEDICACE not in app ↑ top

PDF page 172 · printed page 3-52

Type

  Function

Description

  Displays a greeting from the CAS team and dedication to all HP calculator users.

Example

  In algebraic mode, the message can be extended. Try: DEDICACE(Salutations)

## DEF not in app ↑ top

PDF page 172 · printed page 3-52

Type

  Function

Description

  Defines a variable or a function. Works like the DEFINE command, except that it returns a result and can be included in an algebraic expression. Given an expression as input, DEF stores the expression, unlike STORE which evaluates the expression and stores the numerical value.

Input

  Level 1/Argument 1: An expression of the form name=expression or name(name1, … namen)=expression(name1,… name n) In the first case, name is the name of a variable, and expression is an expression or a number to be stored in the variable. If the variable does not exist, it is created in the current directory. In the second case, name is the name of a variable that will be treated as a function, name1 to namen are formal variables used to define inputs the function will take.

Output

  Level 1/Item 1: Unlike DEFINE, which returns NOVAL in Algebraic mode, and no result in RPN mode, DEF returns the expression used as the input.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

      Example 1:     Define a new function that calculates:

  (a-b)/(a+b)

  Command | DEF(NEW(A,B)=(A-B)/(A+B))
  Result | NEW(A,B)=(A-B)/(A+B) Example 2: Check that the newly defined function works:
  Command | NEW(2,1)
  Result | 1/3

See also

  DEFINE, STORE

## DEFINE not in app ↑ top

PDF page 172 · printed page 3-52

Type

  Command

Description

  Define Variable or Function Command: Stores the expression on the right side of the = in the variable specified on the left side, or creates a user-defined function. If the left side of the equation is name only, DEFINE stores exp in the variable name. If the left side of the equation is name followed by parenthetical arguments name1 … namen, DEFINE creates a user-defined function and stores it in the variable name.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name=exp` | → |
  `name(name1 ... namen)=exp(name1 ... namen)` →
      Example 1:      `A=2*X` DEFINE stores `2*X` in variable A.
          Example 2:      `A(X,Y)=2*X+3/Y` DEFINE creates a user-defined function A. The contents of A is
                          the program « → X Y `2*X+3/Y` »

See also

  DEF, STO, UNASSIGN

## DEG in app ↑ top

PDF page 173 · printed page 3-53

Type

  Command

Description

  Degrees Command: Sets Degrees angle mode. DEG clears flags –17 and –18, and displays the DEG annunciator. In Degrees angle mode, real-number arguments that represent angles are interpreted as degrees, and real-number results that represent angles are expressed in degrees.

Input/Output

  None

See also

  GRAD, RAD

## DEGREE not in app ↑ top

PDF page 173 · printed page 3-53

Type

  Function

Description

  Returns the degree of a polynomial expression. Returns 0 for a constant expression, but –1 if the expression is zero.

Input

  Level 1/Argument 1: A polynomial expression or equation; all powers must be integers or real numbers with no fractional part.

Output

  Level 1/Item 1: An integer representing the highest power in the polynomial. If the input contains powers of more than one variable, including the current variable, returns the highest power of the current variable. If the input contains powers of more than one variable, not including the current variable, returns the highest power of the first symbolic variable (one that is not stored in the current directory path). If the input contains powers of more than one variable, and all the variables are stored in the current directory path, returns the highest power of any of the variables.

Flags

  If exact mode is set (flag –105 clear), the result is returned as an integer, otherwise it is returned as a real number.

      Example 1:      Find the degree of the polynomial represented by:

  x2-17=x3+2x

  Command | DEGREE(x^2-17=x^3+2*X)
  Result | 3

## DELALARM not in app ↑ top

PDF page 173 · printed page 3-53

Type

  Command

Description

  Delete Alarm Command: Deletes the specified alarm. If nindex is 0, all alarms in the system alarm list are deleted.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nindex | → |

See also

  FINDALARM, RCLALARM, STOALARM

## DELAY not in app ↑ top

PDF page 174 · printed page 3-54

Type

  Command

Description

  Delay Command: Specifies how many seconds the calculator waits between sending lines of information to the printer. Setting flag –34 directs printer output to the serial port. In this case, flag –33 must be clear. If flag –34 is set and transmit pacing is enabled (nonzero) in reserved variable IOPAR, then XON/XOFF handshaking controls data transmission and the delay setting has no effect. xdelay specifies the delay time in seconds. The default delay is 0 seconds. The maximum delay is 6.9 seconds. (The sign of xdelay is ignored, so –4 DELAY is equivalent to 4 DELAY.) The delay setting is the first parameter in the reserved variable PRTPAR. A shorter delay setting can be useful when the calculator sends multiple lines of information to your printer (for example, when printing a program). To optimize printing efficiency, set the delay just longer than the time the printhead requires to print one line of information. If you set the delay shorter than the time to print one line, you may lose information. Also, as the batteries in the printer lose their charge, the printhead slows down, and, if you have previously decreased the delay, you may have to increase it to avoid losing information. (Battery discharge will not cause the printhead to slow to more than the 1.8-second default delay setting.)

Flags

  I/O Device (–33), Printing Device (–34), I/O Device for Wire (–78)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xdelay | → |

See also

  CR, OLDPRT, PRLCD, PRST, PRSTC, PRVAR, PR1

## DELKEYS not in app ↑ top

PDF page 174 · printed page 3-54

Type

  Command

Description

  Delete Key Assignments Command: Clears user-defined key assignments. The argument xkey is a real number rc.p specifying the key by its row number, its column number, and its plane (shift). For a definition of plane, see ASN. Specifying 0 for xkey clears all user key assignments and restores the standard key assignments. Specifying S as the argument for DELKEYS suppresses all standard key assignments on the user keyboard. This makes keys without user key assignments inactive on the user keyboard. (You can make exceptions using ASN, or restore them all using STOKEYS.) If you are stuck in User mode — probably with a “locked” keyboard — because you have reassigned or suppressed the keys necessary to cancel User mode, do a system halt (“warm start”): press and hold ‡ and C simultaneously, releasing C first. This cancels User mode. Deleted user key assignments still take up from 2.5 to 62.5 bytes of memory each. You can free this memory by packing your user key assignments by executing RCLKEYS 0 DELKEYS STOKEYS.

Flags

  User-Mode Lock (–61) and User Mode (–62) affect the status of the user keyboard.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xkey | → |
  { xkey1, ... ,xkey n } | → |
  0 | → |
  `S` | → |

See also

  ASN, RCLKEYS, STOKEYS

## DEPND not in app ↑ top

PDF page 175 · printed page 3-55

Type

  Command

Description

  Dependent Variable Command: Specifies the dependent variable (and its plotting range for TRUTH plots). The specification for the dependent variable name and its plotting range is stored in the reserved variable PPAR as follows:

  - If the argument is a global variable name, that name replaces the dependent variable entry in PPAR.
  - If the argument is a list containing a global name, that name replaces the dependent variable name but leaves unchanged any existing plotting range.
  - If the argument is a list containing a global name and two real numbers, or a list containing a name, array, and real number, that list replaces the dependent variable entry.
  - If the argument is a list containing two real numbers, or two real numbers from levels 1 and 2, those two numbers specify a new plotting range, leaving the dependent variable name unchanged. (LASTARG returns a list, even if the two numbers were entered separately.) The default entry is Y. The plotting range for the dependent variable is meaningful only for plot type TRUTH, where it restricts the region for which the equation is tested, and for plot type DIFFEQ, where it specifies the initial solution value and absolute error tolerance.
Input/Output

  Level 2/Argument 1 |  | Level 1/Argument 2 | Level 1/Item 1
  --- | --- | --- | ---
  `global` | → |  |
  { global } | → |  |
  { global, ystart, yend } | → |  |
  {ystart, yend } | → |  |
  ystart | yend | → |

See also

  INDEP

## DEPTH in app ↑ top

PDF page 175 · printed page 3-55

Type

  RPL Command

Description

  Depth Command: Returns a real number representing the number of objects present on the stack (before DEPTH was executed).

Input/Output

  | Level n7Level 1 | Level 1
  --- | --- | ---
  → | n |

See also

  CLEAR, DROPN

## DERIV in app ↑ top

PDF page 176 · printed page 3-56

Type

  Function

Description

  Returns the partial derivatives of a function, with respect to the specified variables.

Input

  Level 2/Argument 1: A function or a list of functions. Level 1/Argument 2: A variable, or a vector of variables. The variable or variables must not exist as variables stored in the current directory nor directories above it.

Output

  The derivative, or a vector of the derivatives, of the function or functions.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the gradient of the following function of the spatial variables x, y, and z:

                      2         2

  2x y + 3y z + zx

      Command:      DERIV(2*X^2*Y+3*Y^2*Z+Z*X, [X,Y,Z])

  EXPAND(ANS(1))

      Result:       [4*Y*X+Z,2*X^2+6*Z*Y,X+3*Y^2]

See also

  DERVX, dn, ∂, POTENTIAL

## DERVX in app ↑ top

PDF page 176 · printed page 3-56

Type

  Function

Description

  Returns the derivative of a function with respect to the current variable. This variable must not exist as a variable stored in the current directory path.

Input

  The function or list of functions to be differentiated.

Output

  The derivative, or a vector of the derivatives, of the function or functions.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

See also

  DERIV, dn, ∂

## DERIVX in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Verbose alias for DERVX — differentiates the level-1 expression with respect to the current CAS variable VX. Provided so HP-family programs that spell out the name still work.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `f(VX)` | → | `d/dVX f`

See also

  DERVX, DERIV, VX, SVX

## DESOLVE not in app ↑ top

PDF page 176 · printed page 3-56

Type

  Command

Description

  Solves certain first-order ordinary differential equations with respect to the current variable.

Input

  Level 2/Argument 1: A first-order differential equation. Level 1/Argument 2: The function to solve for.

Output

  The solution to the equation, either y as a function of x or x as a function of y, or x and y as functions of a parameter.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Solve the following differential equation: 3x y′ ( x ) + 2 y ( x ) = e

      Command:      DESOLVE(d1Y(X)+2*Y(X)=EXP(3*X),Y(X))

  (See the description of dn and Chapter 16 of the User’s Guide for an explanation of the use of “d1” for a derivative.)

       Result:       {Y(X)=(1/5*EXP(5*X)+cC0)*(1/EXP(X)^2)}

See also

  dn, LDEC

## DET in app ↑ top

PDF page 177 · printed page 3-57

Type

  Command

Description

  Determinant Function: Returns the determinant of a square matrix. The argument matrix must be square. DET computes the determinant of 1 × 1 and 2 × 2 matrices directly from the defining expression for the determinant. DET computes the determinant of a larger matrix by computing the Crout LU decomposition of the matrix and accumulating the product of the decomposition’s diagonal elements. Since floating-point division is used to do this, the computed determinant of an integer matrix is often not an integer, even though the actual determinant of an integer matrix must be an integer. DET corrects this by rounding the computed determinant to an integer value. This technique is also used for noninteger matrices with determinants having fewer than 15 nonzero digits: the computed determinant is rounded at the appropriate digit position to restore some or all of the accuracy lost to floating-point arithmetic. This refining technique can cause the computed determinant to exhibit discontinuity. To avoid this, you can disable the refinement by setting flag –54.

Flags

  Tiny Element (–54)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]] | → | xdeterminant

Example

      For a square matrix A, the minor of element aij is the determinant of the submatrix that remains after deleting row i and column j from the original matrix. Given a square matrix in level 3, i in level 2, and j in level 1, the following program, MINOR determines the minor of the submatrix:
          « → M row col
          « M row ROW- DROP col COL- DROP DET » » For example, entering [[ 1 2 3 ][ 4 5 6 ][ 7 8 9 ]] 2 3 MINOR returns -6.

See also

  CNRM, CROSS, DOT, RNRM

## DETACH not in app ↑ top

PDF page 177 · printed page 3-57

Type

  Command

Description

  Detach Library Command: Detaches the library with the specified number from the current directory. Each library has a unique number. If a port number is specified, it is ignored. A library object attached to a non-HOME directory is automatically detached (without using DETACH) whenever a new library object is attached there.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nlibrary | → |
  :nport :nlibrary | → |

See also

  ATTACH, LIBS, PURGE

## DIAG→ not in app ↑ top

PDF page 178 · printed page 3-58

Type

  Command

Description

  Vector to Matrix Diagonal Command: Takes an array and a specified dimension and returns a matrix whose major diagonal elements are the elements of the array. Real number dimensions are rounded to integers. If a single dimension is given, a square matrix is returned. If two dimensions are given, the proper order is { number of rows, number of columns }. No more than two dimensions can be specified. If the main diagonal of the resulting matrix has more elements than the array, additional diagonal elements are set to zero. If the main diagonal of the resulting matrix has fewer elements than the array, extra array elements are dropped.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  [ array ]diagonals | { dim } | → | [[ matrix ]]

See also

  →DIAG

## →DIAG not in app ↑ top

PDF page 178 · printed page 3-58

Type

  Command

Description

  Matrix Diagonal to Array Command: Returns a vector that contains the major diagonal elements of a matrix. The input matrix does not have to be square.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]] | → | [ vector ]diagonals

See also

  DIAG→

## DIAGMAP not in app ↑ top

PDF page 178 · printed page 3-58

Type

  Command

Description

  Applies a holomorphic operator to a diagonalizable matrix.

Input

  Level 2/Argument 1: A diagonalizable matrix. Level 1/Argument 2: An operator, expressed as a function. The function can be stored in a variable with DEF, or can be a program, or a single expression.

Output

  The matrix that results from applying the operator to the matrix.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). 11 02

Example

  Apply the operator ex to the matrix

                             -                           -
                         DIAGMAP - 1 1 , << → X<<EXP(X) >> >>-
                                 - 0 2                       -

  Command: or DIAGMAP([[1,1],[0,2]],exp(X)) EXP ( 1 ) – EXP ( 1 ) + EXP ( 2 )

                        0            EXP ( 2 )

## DIFF not in app ↑ top

PDF page 179 · printed page 3-59

Type

  Command

Description

  Displays a menu or list containing the CAS commands for differential calculus, including commands for working with series.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## DIFFEQ not in app ↑ top

PDF page 179 · printed page 3-59

Type

  Command

Description

  Differential Equation Plot Type Command: Sets the plot type to DIFFEQ. When the plot type is DIFFEQ and the reserved variable EQ does not contain a list, the initial value problem is solved and plotted over an interval using the Runge–Kutta–Fehlberg (4,5) method. The plotting parameters are specified in the reserved variable PPAR, which has the following form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type DIFFEQ, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is a list, { X x0 xf }, containing a name that specifies the independent variable, and two numbers that specify the initial and final values for the independent variable. The default values for these elements are { X 0 xmax }.
  - res is a real number specifying the maximum interval, in user-unit coordinates, between values of the independent variable. The default value is 0. If res does not equal zero, then the maximum interval is res. If res equals zero, the maximum interval is unlimited.
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. If the solution is real- valued, these strings can specify the dependent or the independent variable; if the solution is vector valued, the strings can specify a solution component: – 0 specifies the dependent variable (X) – 1 specifies the dependent variable (Y) – n specifies a solution component Yn

  – If axes contains any strings other than 0, 1 or n, the DIFFEQ plotter uses the default strings 0 and 1, and plots the independent variable on the horizontal axis and the dependent variable on the vertical.

  - ptype is a command name specifying the plot type. Executing the command DIFFEQ places the command name DIFFEQ in PPAR.
  - 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. 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.
Input/Output

  None

See also

  AXES, CONIC, FUNCTION, PARAMETRIC, POLAR, RKFSTEP, RRKSTEP, TRUTH

## DIR not in app ↑ top

PDF page 180 · printed page 3-60

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.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | DIR …END |

See also

  CRDIR

## DISP not in app ↑ top

PDF page 180 · printed page 3-60

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.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | n | → |

Example

      The program « "ENTER Data Now" 1 DISP 7 FREEZE HALT » displays ENTER Data Now at the top of the display, “freezes” the entire display, and halts.

See also

  DISPXY, FREEZE, HALT, INPUT, PROMPT

## DISPXY not in app ↑ top

PDF page 181 · printed page 3-61

Type

  Command

Description

  Display Command: Displays obj at the specified screen coordinates using a specified font size. The list argument expects exactly two binary integers to specify the X and Y coordinates. The level one integer argument n will display the obj using a small font if n is 1 and using the system font if n is 2. 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 at coordinate #x #y, and continues down the display either to the end of the object or the bottom of the display. NOTE: DISPXY is not useful for displaying grobs. The object displayed by DISPXY 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.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  obj | { list } | n | → |

See also

  DISP, FREEZE, HALT, INPUT, PROMPT

## DISTRIB in app ↑ top

PDF page 181 · printed page 3-61

Type

  Command

Description

  Applies one step of the distributive property of multiplication and division with respect to addition and subtraction. Used for single-stepping through a multi-step distribution.

Input

  An expression.

Output

  An equivalent expression that results from applying the distributive property of multiplication over addition one time.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Expand (X+1)( X-1)( X+2).

  Command | DISTRIB((X+1)*(X-1)*(X+2))
  Result | X*(X-1)*(X+2)+1*(X-1)*(X+2)

See also

  FDISTRIB

## DIV not in app ↑ top

PDF page 182 · printed page 3-62

Type

  Command

Description

  Returns the divergence of a vector function.

Input

  Level 2/Argument 1: An array representing a vector function. Level 1/Argument 2: An array containing the variables.

Output

  The divergence of the vector function with respect to the specified variables.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the divergence of the following vector function:

                                  2          2   2

  v = x y i + x yj + y zk

                           ˜       ˜      ˜
          Command:      DIV([X^2*Y, X^2*Y, Y^2*Z],[X,Y,Z])
          Result:       Y*(2*X)+(X^2+Y^2)

See also

  CURL, HESS

## DIV2 not in app ↑ top

PDF page 182 · printed page 3-62

Type

  Command

Description

  Performs Euclidean division on two expressions. Step-by-step mode is available with this command.

Input

  Level 2/Argument 1: The dividend. Level 1/Argument 2: The divisor.

Output

  Level 2/Item 1: The quotient. Level 1/Item 2: The remainder.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). Step-by-step mode can be set (flag –100 set). Radians mode must be set (flag –17 set).

Example

  Perform the following division: 2 x +x+1 ---------------------- 2x + 4

  Command | DIV2(X^2+X+1,2*X+4)
  Result | {1/2(X-1),3}

## DIV2MOD in app ↑ top

PDF page 182 · printed page 3-62

Type

  Command

Description

  Performs Euclidean division on two expressions modulo the current modulus.

Input

  Level 2/Argument 1: The dividend. Level 1/Argument 2: The divisor.

Output

  Level 2/Item 1: The quotient. Level 1/Item 2: The remainder.

Flags

  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). 3 x +4 ------------- 2

Example

  Find the result of x – 1 , modulo 3.

  Command | DIV2MOD(X^3+4,X^2-1)
  Result | {X X+1}

## DIVIS in app ↑ top

PDF page 183 · printed page 3-63

Type

  Command

Description

  Returns a list of divisors of a polynomial or an integer.

Input

  A polynomial or an integer.

Output

  A list containing the expressions or integers that exactly divide into the input.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the divisors of the following polynomial: 2 x + 3x + 2

  Command | DIVIS(X^2+3*X+2)
  Result | {1,X+1,X+2,X^2+3*X+2}

See also

  DIV2

## DIVMOD in app ↑ top

PDF page 183 · printed page 3-63

Type

  Function

Description

  Divides two expressions modulo the current modulus.

Input

  Level 2/Argument 1: The dividend. Level 1/Argument 2: The divisor.

Output

  The quotient of the terms modulo the current modulus.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Modulo 3, divide 5x2+4x+2 by x2+1.

  Command | DIVMOD(5*X^2+4*X+2,X^2+1)
  Result | -((X^2-X+1)/X^2+1))

## DIVPC not in app ↑ top

PDF page 183 · printed page 3-63

Type

  Command

Description

  Returns a Taylor polynomial for the quotient of two polynomial expressions.

Input

  Level 3/Argument 1: The numerator expression. Level 2/Argument 2: The denominator expression. Level 1/Argument 3: The degree of the Taylor polynomial.

Output

  The Taylor polynomial at x = 0 of the quotient of the two expressions, to the specified degree.

Flags

  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). Incremental power mode must be set (flag –114 set).

Example

  Find the fourth degree Taylor polynomial for the following: 3 x + 4x + 12 ----------------------------- 11 11x + 1

  Command | DIVPC(X^3+4*X+12,11*X^11+1,4)
  Result | 12+4*X+X^3

See also

  TAYLOR0, TAYLR, SERIES dn

Type

  Function

Description

  Differential of a function with respect to its argument n. For example d1f(x,y) is the differential of f(x,y) with respect to x and d3g(y,z,t) is the differential of g(y,z,t) with respect to t. The second- order derivative of f(x,y) with respect to x is written d1d1f(x,y). The dn function is an alternative to the ∂ function; d1f(x,y) is the same as ∂x(f(x,y)). dn does not require brackets after it, it must be followed immediately by the function name, with no spaces. dn differentiates with respect to the whole of argument n, see the example. dn is mainly used for formal arguments, see the example in DESOLVE, but can be used to differentiate expressions, as in the example.

Output

  dn does not change its argument, it works like the negative sign placed before a number or an expression. If the argument can be differentiated, N will carry out the differentiation.

Flags

  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

  Differentiate the function sin(2x) with respect to its argument:

  Command | EVAL(d1SIN(2*X))
  Result | COS(2*X)

  (Note that the function was differentiated with respect to its argument 2x, not with respect to the variable x.)

See also

  DERIV, DERVX, DESOLVE, ∂

## DO not in app ↑ top

PDF page 184 · printed page 3-64

Type

  Command

Description

  DO Indefinite Loop Structure Command: Starts DO…UNTIL…END indefinite loop structure. DO … UNTIL … END executes a loop repeatedly until a test returns a true (nonzero) result. Since the test clause is executed after the loop clause, the loop is always executed at least once. The syntax is: DO loop-clause UNTIL test-clause END DO starts execution of the loop clause. UNTIL ends the loop clause and begins the test clause. The test clause must return a test result to the stack. END removes the test result from the stack. If its value is zero, the loop clause is executed again; otherwise execution resumes following END.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  DO | → |
  UNTIL | → |
  END | T/F → |

Example

      The following program counts down from 100 to 0 and leaves the integers 100 to 0 on the stack: « 100 `A` STO A DO `A` DECR UNTIL `A==0` END `A` PURGE »

See also

  END, UNTIL, WHILE

## DOERR in app ↑ top

PDF page 185 · printed page 3-65

Type

  Command

Description

  Do Error Command: Executes a “user-specified” error, causing a program to behave exactly as if a normal error had occurred during program execution. DOERR causes a program to behave exactly as if a normal error has occurred during program execution. The error message depends on the argument provided to DOERR:

  - nerror or #nerror display the corresponding built-in error message.
  - "error" displays the contents of the string. (A subsequent execution of ERRM returns "error". ERRN returns # 70000h.)
  - 0 abandons program execution with an ‘interrupted’ error message (ERRN = #13Fh).
  - 0 DOERR is equivalent to pressing −.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nerror | → |
  #nerror | → |
  “error” | → |
  0 | → |

Example

      The following program takes a number from the stack and returns an error if the number is greater than 10:
          « → X « CASE `X>10` THEN "X IS TOO BIG" DOERR END END » »

See also

  ERRM, ERRN, ERR0

## DOLIST in app ↑ top

PDF page 185 · printed page 3-65

Type

  Command

Description

  Do to List Command: Applies commands, programs, or user-defined functions to lists. The number of lists, n, can be omitted when the first or level 1 argument is any of the following:

  - A command.
  - A program containing exactly one command (e.g. « DUP »)
  - A program conforming to the structure of a user-defined function. The final argument 1 (or level 1 object) can be a local or global name that refers to a program or command. All lists must be the same length l. The program is executed l times: on the ith iteration, n objects each taken from the ith position in each list are entered on the stack in the same order as in their original lists, and the program is executed. The results from each execution are left on the stack. After the final iteration, any new results are combined into a single list.
Input/Output

  Ln+2/A1 ... L3/An–2 | L2/An+1 | L1/An+2 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  { list }1 ... { list }n | n | « program » | → | { results }
  { list }1 ... { list }n | n | command | → | { results }
  { list }1 ... { list }n | n | name | → | { results }
  { list }1 ... | { list }n+1 | « program » | → | { results }
  { list }1 ... | { list }n+1 | command | → | { results }
  { list }1 ... | { list }n+1 | name | → | { results }
  L = Level; A = Argument

Example

      { 1 2 3 } { 4 5 6 } { 7 8 9 } 3 « + * » DOLIST returns { 11 26 45 }.

See also

  DOSUBS, ENDSUB, NSUB, STREAM

## DOMAIN not in app ↑ top

PDF page 186 · printed page 3-66

Type

  Command

Description

  For a function of the current variable, lists the domains of real numbers for which the function is defined and for which it is undefined. DOMAIN works for functions of more than one argument, for example DOMAIN (X*X), and for user defined functions, as in the example below. For functions which it does not recognize, DOMAIN returns the message “Unknown operator”.

Input

  Level 1/Item 1: A function, or an expression, in terms of the current variable.

Output

  Level 1/Item 1: A list with regions where the function is undefined marked by `?` and regions where the function is defined marked by +. Rational singularities, such as 0 in 1/x, are not listed.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

      Define a function f =√(a+1) by typing DEF(F(A)=√(A+1)). Then tabulate the domain over which it is defined and undefined.
          Command:       DOMAIN(F(X))
          Result:        {`-∞` `?` –1 + `+∞`}, showing that the function f is undefined for values from –∞ to –1 and is
          defined from –1 to +∞.

See also

  SIGNTAB, TABVAR

## DOSUBS in app ↑ top

PDF page 186 · printed page 3-66

Type

  Command

Description

  Do to Sublist Command: Applies a program or command to groups of elements in a list. The real number n can be omitted when the first argument is one of the following:

  - A command.
  - A user program containing a single command.
  - A program with a user-defined function structure.
  - A global or local name that refers to one of the above. The first iteration uses elements 1 through n from the list; the second iteration uses elements 2 through n + 1; and so on. In general, the mth iteration uses the elements from the list corresponding to positions m through m + n – 1. During an iteration, the position of the first element used in that iteration is available to the user using the command NSUB, and the number of groups of elements is available using the

  command ENDSUB. Both of these commands return an Undefined Local Name error if executed when DOSUBS is not active. DOSUBS returns the Invalid User Function error if the object at level 1/argument 3 is a user program that does not contain only one command and does not have a user-defined function structure. DOSUBS also returns the Wrong Argument Count error if the object at level 1/argument 3 is a command that does not accept 1 to 5 arguments of specific types (DUP, ROT, or →LIST, for example).

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  { list }1 | n | « program » | → | { list }2
  { list }1 | n | command | → | { list }2
  { list }1 | n | name | → | { list }2
  { list }1 | « program » | → | { list }2 |
  { list }1 | command | → | { list }2 |
  { list }1 name → { list }2
  Example 1: { A B C D E } « - » DOSUBS returns
  { `A-B` `B-C` `C-D` `D-E` }.
      Example 2:      { A B C } 2 « DUP * * » DOSUBS returns
  { `A*(B*B)` `B*(C*C)` }.
      Example 3:      Entering
                           { 1 2 3 4 5 } « → a b
  « CASE `NSUB==1` THEN a END `NSUB==ENDSUB` THEN b END `a+b` EVAL END » » DOSUBS returns { 1 5 7 5 }.

See also

  DOLIST, ENDSUB, NSUB, STREAM

## DOT in app ↑ top

PDF page 187 · printed page 3-67

Type

  Command

Description

  Dot Product Command: Returns the dot product A•B of two arrays A and B, calculated as the sum of the products of the corresponding elements of the two arrays. Both arrays must have the same dimensions. Some authorities define the dot product of two complex arrays as the sum of the products of the conjugated elements of one array with their corresponding elements from the other array. The calculator uses the ordinary products without conjugation. If you prefer the alternative definition, apply CONJ to one array before using DOT.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  [ array A ] | [ array B ] | → | x

Example

  [ 1 2 3 ][ 4 5 6 ] DOT returns 32 (by calculating 1 x 4 + 2 x 5 + 3 x 6).

See also

  CNRM, CROSS, DET, RNRM

## DRAW not in app ↑ top

PDF page 188 · printed page 3-68

Type

  Command Operation

Description

  Draw Plot Command: Plots the mathematical data in the reserved variable EQ or the statistical data in the reserved variable ΣDAT, using the specified x- and y-axis display ranges. The plot type determines if the data in the reserved variable EQ or the data in the reserved variable ΣDAT is plotted. DRAW does not erase PICT before plotting; execute ERASE to do so. DRAW does not draw axes; execute DRAX to do so. When DRAW is executed from a program, the graphics display, which shows the resultant plot, does not persist unless PICTURE, PVIEW (with an empty list argument), or FREEZE is subsequently executed.

Flags

  Simultaneous or Sequential Plot (–28), Curve Filling (–31)

Input/Output

  None

See also

  AUTO, AXES, DRAX, ERASE, FREEZE, PICTURE, LABEL, PVIEW

## DRAW3DMATRIX not in app ↑ top

PDF page 188 · printed page 3-68

Type

  Command

Description

  Draws a 3D plot from the values in a specified matrix. The number of rows indicates the number of units along the x axis, the number of columns indicates the number of units along the y axis, and the values in the matrix give the magnitudes of the plotted points along the z axis. In other words, the coordinates of a plotted point are (r, c, v) where r is the row number, c the column number and v the value in the corresponding cell of the matrix. You can limit the points that are plotted by specifying a minimum value (vmin) and a maximum value (vmax). Values in the matrix outside this range are not plotted. If all values are included, the total number of points plotted is r × c. Once the plot has been drawn, you can rotate it in various ways by pressing the following keys: ™ and š rotate the plot around the x axis (in different directions) — and ˜ rotate the plot around the y axis (in different directions) Iand L rotate the plot around the z axis (in different directions)

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]] | vmin | vmax | → |

See also

  FAST3D

## DRAX not in app ↑ top

PDF page 188 · printed page 3-68

Type

  Command

Description

  Draw Axes Command: Draws axes in PICT. The coordinates of the axes intersection are specified by AXES. Axes tick-marks are specified in PPAR with the ATICK, or AXES command. DRAX does not draw axes labels; execute LABEL to do so.

Input/Output

  None

See also

  AXES, DRAW, LABEL

## DROITE not in app ↑ top

PDF page 189 · printed page 3-69

Type

  Function

Description

  Returns an equation for the line through two given points in a plane. For more than two points, LAGRANGE will fit a polynomial.

Input

  Level 2/Argument 1: The first point, in the form a+b *i, or (a,b), where a and b must be numbers, or variables or expressions that evaluate to numbers. Level 1/Argument 2: The second point, in the form c+d *i, or (c,d), where c and d must be numbers, or variables or expressions that evaluate to numbers.

Output

  Level 1/Item 1: An equation for the straight line through the two points. The general form is Y=(d-b)/(c-a)*(X-a)+b.

Flags

  Numeric mode must not be set (flag –3 clear). Complex mode must be set (flag –103 set). In algebraic mode, if any of a, b, c, d are variables, they will be converted to their numeric values, even if “argument to symbolic” mode is set (flag –3 clear). In RPN mode, they will be returned as variables. If ALG mode is set and “constants to numeric” mode is selected (flag –2 set) π and e used in inputs will be converted to their real number approximations, otherwise they will be returned in symbolic form.

  Example 1: Find an equation for the straight line through the points (1, 2), (3, 4).
  Command | DROITE((1, 2), (3, 4))
  Result | Y=X-1.+2.
  Example 2: Find a symbolic equation for the straight line through the points (π, e), (e, π).
  Command | With “constants to symbolic ” mode selected and exact mode set, type:

  DROITE(π+e*i, e+π*i)

       Result:        Y=(π-e)/(e-π)*(X-π)+e

See also

  LAGRANGE

## DROP in app ↑ top

PDF page 189 · printed page 3-69

Type

  RPL Command

Description

  Drop Object Command: Removes the level 1 object from the stack.

Input/Output

  Level 1 |  | Level 1
  --- | --- | ---
  obj | → |

See also

  CLEAR, DROPN, DROP2

## DROP2 in app ↑ top

PDF page 189 · printed page 3-69

Type

  RPL Command

Description

  Drop 2 Objects Command: Removes the first two objects from the stack.

Input/Output

  Level 2 | Level 1 |  | Level 1
  --- | --- | --- | ---
  obj1 | obj2 | → |

See also

  CLEAR, DROP, DROPN

## DROPN in app ↑ top

PDF page 190 · printed page 3-70

Type

  RPL Command

Description

  Drop n Objects Command: Removes the first n + 1 objects from the stack (the first n objects excluding the integer n itself).

Input/Output

  Leveln+1 ... Level 2 | Level 1 |  | Level 1
  --- | --- | --- | ---
  obj1 ... objn | n | → |

See also

  CLEAR, DROP, DROP2

## DTAG in app ↑ top

PDF page 190 · printed page 3-70

Type

  Command

Description

  Delete Tag Command: DTAG removes all tags (labels) from an object. The leading colon is not shown for readability when the tagged object is on the stack. DTAG has no effect on an untagged object.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  tag:obj | → | obj

See also

  LIST→, →TAG

## DUP in app ↑ top

PDF page 190 · printed page 3-70

Type

  RPL Command

Description

  Duplicate Object Command: DUP returns a copy of the argument (or the object on level 1).

Input/Output

  Level 1 |  | Level 2 | Level 1
  --- | --- | --- | ---
  obj | → | obj | obj

See also

  DUPN, DUP2, PICK

## DUP2 in app ↑ top

PDF page 190 · printed page 3-70

Type

  RPL Command

Description

  Duplicate 2 Objects Command: DUP2 returns copies of the two objects on levels 1 and 2 of the stack.

Input/Output

  L2 | L1 |  | L4 | L3 | L2 | L1
  --- | --- | --- | --- | --- | --- | ---
  obj2 | obj1 | → | obj2 | obj1 | obj2 | obj1
  L = Level

See also

  DUP, DUPN, PICK

## DUPDUP in app ↑ top

PDF page 191 · printed page 3-71

Type

  RPL Command

Description

  Duplicates an object twice. Same as DUP DUP.

Input/Output

  Level 1 |  | Level 3 | Level 2 | Level 1
  --- | --- | --- | --- | ---
  obj | → | obj | obj | obj

See also

  DUP, NDUPN, DUPN, DUP2

## DUPN in app ↑ top

PDF page 191 · printed page 3-71

Type

  RPL Command

Description

  Duplicate n Objects Command: Takes an integer n from level 1 of the stack, and returns copies of the objects on stack levels 2 through n + 1.

Input/Output

  Li+1 | Li …L3 | L2 | L1 |  | Li+n | Li+n–1 ... L2 | L1
  --- | --- | --- | --- | --- | --- | --- | ---
  obj1 | obj2 … obji–1 | obji | n | → | obj1 | obj2 ... obji–1 | obji
  L = Level

See also

  DUP, DUP2, PICK

## D→R in app ↑ top

PDF page 191 · printed page 3-71

Type

  Function

Description

  Degrees to Radians Function: Converts a real number representing an angle in degrees to its equivalent in radians. This function operates independently of the angle mode.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | (π/180)x
  `symb` | → | `D→R(symb)`

See also

  R→D

## e not in app ↑ top

PDF page 191 · printed page 3-71

Type

  Function

Description

  e Function: Returns the symbolic constant e or its numerical representation, 2.71828182846.

  When evaluated, e returns its numerical representation if flag –2 or –3 is set; otherwise, e returns its symbolic representation. The number returned for e is the closest approximation to 12-digit accuracy. For exponentiation, use the expression `EXP(x)` rather than e^x, since the function EXP uses a special algorithm to compute the exponential to greater accuracy. Even though the calculator often displays `EXP(x)` as e^x, it’s still `EXP(x)` internally.

Flags

  Symbolic Constants (–2), Numerical Results (–3)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | `e` |
  → | 2.71828182846 |

See also

  EXP, EXPM, i, LN, LNP1, MAXR, MINR, π

## EDIT not in app ↑ top

PDF page 192 · printed page 3-72

Type

  Command

Description

  Edit Command: Moves specified object to the command line where it can be edited.

Input/Output

  None

See also

  EDITB, VISIT

## EDITB not in app ↑ top

PDF page 192 · printed page 3-72

Type

  Command

Description

  Edit Best Command: Opens the specified object in the most suitable editor. For example, if you use a matrix as the specified object, the command opens it in Matrix Writer.

Input/Output

  None

See also

  EDIT, VISIT

## EGCD not in app ↑ top

PDF page 192 · printed page 3-72

Type

  Command

Description

  Given two polynomials, a and b, returns polynomials u, v, and c where: au+bv=c In the equation, c is the greatest common divisor of a and b.

Input

  Level 2/Argument 1: The expression corresponding to a in the equation. Level 1/Argument 2: The expression corresponding to b in the equation.

Output

  Level 3/Item 1: The result corresponding to c in the equation. Level 2/Item 2: The result corresponding to u in the equation. Level 1/Item 3: The result corresponding to v in the equation.

Flags

  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

  Find the polynomials for u, v, and c, where c is the greatest common divisor of a and b such that: 2 u(x + 1) + v(x – 1) = c

  Command | EGCD(X^2+1,X-1)
  Result | {2,1,-(X+1)}

See also

  IEGCD, ABCUV

## EGV in app ↑ top

PDF page 193 · printed page 3-73

Type

  Command

Description

  Eigenvalues and Eigenvectors Command: Computes the eigenvalues and right eigenvectors for a square matrix. The resulting vector EVal contains the computed eigenvalues. The columns of matrix EVec contain the right eigenvectors corresponding to the elements of vector EVal. The computed results should minimize (within computational precision): A ⋅ EVec – EVec ⋅ diag ( EVal ) ------------------------------------------------------------------------------ n⋅ A

  where diag (EVal) denotes the n × n diagonal matrix containing the eigenvalues EVal.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  [[matrix ]]A | → | [[matrix ]]EVec | [vector ]EVal

See also

  EGVL

## EGVL in app ↑ top

PDF page 193 · printed page 3-73

Type

  Command

Description

  Eigenvalues Command: Computes the eigenvalues of a square matrix. The resulting vector L contains the computed eigenvalues.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[matrix ]]A | → | [vector ]EVal

See also

  EGV

## ELSE not in app ↑ top

PDF page 193 · printed page 3-73

Type

  Command

Description

  ELSE Command: Starts false clause in conditional or error-trapping structure. See the IF and IFERR keyword entries for more information.

Input/Output

  None

See also

  IF, CASE, DO, ELSE, IFERR, REPEAT, THEN, UNTIL, WHILE

## END not in app ↑ top

PDF page 193 · printed page 3-73

Type

  Command

Description

  END Command: Ends conditional, error-trapping, and indefinite loop structures.

  See the IF, CASE, IFERR, DO, and WHILE keyword entries for more information.

Input/Output

  None

See also

  IF, CASE, DO, ELSE, IFERR, REPEAT, THEN, UNTIL, WHILE

## ENDSUB in app ↑ top

PDF page 194 · printed page 3-74

Type

  Command

Description

  Ending Sublist Command: Provides a way to access the total number of sublists contained in the list used by DOSUBS. Returns an Undefined Local Name error if executed when DOSUBS is not active.

Input/Output

  None

Example

      The following program subtracts the number of elements in a list from each element in the list
          « → a « a 1 « ENDSUB - » » DOSUBS »

See also

  DOSUBS, NSUB

## ENG in app ↑ top

PDF page 194 · printed page 3-74

Type

  Command

Description

  Engineering Mode Command: Sets the number display format to engineering mode, which displays one to three digits to the left of the fraction mark (decimal point) and an exponent that is a multiple of three. The total number of significant digits displayed is n + 1. Engineering mode uses n + 1 significant digits, where 0 ≤ n ≤ 11. (Values for n outside this range are rounded up or down.) A number is displayed or printed as follows: (sign) mantissa E (sign) exponent where the mantissa is of the form (nn)n.(n…) (with up to 12 digits total) and the exponent has one to three digits. A number with an exponent of –499 is displayed automatically in scientific mode.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → |

Example

  The number 103.6 in Engineering mode with five significant digits (n=4) would appear as 103.60E0. This same number with one significant digit (n=0) would appear as 100.E0.

See also

  FIX, SCI, STD

## EPSX0 in app ↑ top

PDF page 194 · printed page 3-74

Type

  Function

Description

  Replaces all coefficients in a polynomial that have an absolute value less than that held in the CASDIR variable EPS, with 0. The default value of EPS is 1E-10, which can be changed by storing a new number in the variable EPS in the CASDIR directory; this must be less than 1.

Input

  A polynomial.

Output

  The polynomial with conforming coefficients replaced with 0.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Replace with zero the terms smaller than EPS in the expression: 10-13x + 10-2

  Command | EPSX0(1E-13*X+.01)
  Result | 0*X+.01

## EQNLIB not in app ↑ top

PDF page 195 · printed page 3-75

Type

  Command

Description

  Starts the Equation Library application.

Input/Output

  None

See also

  MSOLVR, SOLVEQN

## EQW not in app ↑ top

PDF page 195 · printed page 3-75

Type

  Command

Description

  Opens Equation Writer, where you can edit an expression. Puts an object into the Equation Writer.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  exp1 | → | exp2

See also

  EDIT, EDITB, VISIT, VISITB

## EQ→ not in app ↑ top

PDF page 195 · printed page 3-75

Type

  Command

Description

  Equation to Stack Command: Separates an equation into its left and right sides. If the argument is an expression, it is treated as an equation whose right side equals zero.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  `symb1=symb2` | → | `symb1` | `symb2`
  z | → | z | 0
  `name` | → | `name` | 0
  `x_unit` | → | `x_unit` | 0
  `symb` | → | `symb` | 0

See also

  ARRY→, DTAG, LIST→, OBJ→, STR→

## ERASE not in app ↑ top

PDF page 195 · printed page 3-75

Type

  Command

Description

  Erase PICT Command: Erases PICT, leaving a blank PICT of the same dimensions.

Input/Output

  None

See also

  DRAW

## ERR0 in app ↑ top

PDF page 196 · printed page 3-76

Type

  Command

Description

  Clear Last Error Number Command: Clears the last error number so that a subsequent execution of ERRN returns # 0h, and clears the last error message.

Input/Output

  None

See also

  DOERR, ERRM, ERRN

## ERRM in app ↑ top

PDF page 196 · printed page 3-76

Type

  Command

Description

  Error Message Command: Returns a string containing the error message of the most recent calculator error. ERRM returns the string for an error generated by DOERR. If the argument to DOERR was 0, the string returned by ERRM is ‘Interrupted’.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | “error message” |

Example

      The program « IFERR + THEN ERRM END » returns "Bad Argument Type" to level 1 if improper arguments (for example, a complex number and a binary integer) are in levels 1 and 2.

See also

  DOERR, ERRN, ERR0

## ERRN in app ↑ top

PDF page 196 · printed page 3-76

Type

  Command

Description

  Error Number Command: Returns the error number of the most recent calculator error. If the most recent error was generated by DOERR with a string argument, ERRN returns #70000h. If the most recent error was generated by DOERR with a binary integer argument, ERRN returns that binary integer. (If the most recent error was generated by DOERR with a real number argument, ERRN returns the binary integer conversion of the real number.) The only exceptions to these rules are 0 DOERR and #0 DOERR, both of which set ERRN to #31Fh and ERRM to ‘Interrupted’.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | #nerror |

Example

      The program « IFERR + THEN ERRN END » returns # 202h to level 1 if improper arguments (for example, a complex number and a binary integer) are in levels 1 and 2.

See also

  DOERR, ERRM, ERR0

## EULER in app ↑ top

PDF page 196 · printed page 3-76

Type

  Function

Description

  For a given integer, returns the number of integers less than the integer that are co-prime with the integer. (Euler’s Φ function.)

Input

  A non-negative integer, or an expression that evaluates to a non-negative integer.

Output

  The number of positive integers, less than, and co-prime with, the integer.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

## EVAL in app ↑ top

PDF page 197 · printed page 3-77

Type

  Command

Description

  Evaluate Object Command: Evaluates the object. The following table describes the effect of the evaluation on different object types.

  Object Type | Effect of Evaluation
  --- | ---
  Local Name | Recalls the contents of the variable.
  Global Name | Calls the contents of the variable:

  - A name is evaluated.
  - A program is evaluated.
  - A directory becomes the current directory.
  - Other objects are put on the stack. If no variable exists for a given name, evaluating the name returns the name to the stack.

                    Program                    Enters each object in the program:

  - Names are evaluated (unless quoted).
  - Commands are evaluated.
  - Other objects are put on the stack.

                      List                     Enters each object in the list:

  - Names are evaluated.
  - Commands are evaluated
  - Programs are evaluated.
  - Other objects are put on the stack.

                    Tagged                     If the tag specifies a port, recalls and evaluates the

  specified object. Otherwise, puts the untagged object on the stack.

                   Algebraic                   Enters each object in the algebraic expression:

  - Names are evaluated.
  - Commands are evaluated.
  - Other objects are put on the stack.

  Command, Function, XLIB Name | Evaluates the specified object.
  --- | ---
  Other Objects | Puts the object on the stack.

  To evaluate a symbolic argument to a numerical result, evaluate the argument in Numerical Results mode (flag –3 set) or execute →NUM on that argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → | (see above)

See also

  →NUM, SYSEVAL

## EXLR in app ↑ top

PDF page 197 · printed page 3-77

Type

  Command

Description

  Returns the left- and right-hand sides of an equation as discrete expressions.

Input

  An equation.

Output

  Level 2/Item 1: The expression to the left of the “=” sign in the original equation, or, if the input is an expression and not an equation, the independent variable. Level 1/Item 2: The expression to the right of the “=” sign in the original equation, or, if the input is an expression, the expression.

Flags

  Numeric mode must not be set (flag –3 clear). In Algebraic mode (flag –95 set), the output expressions are evaluated (variables are replaced by numeric values) before the result is returned.

Example

  Split the following equation into its two component expressions: sin(x)=5x+y

  Command | EXLR(SIN(X)=5*X+Y)
  Result | {SIN(X), 5*X+Y}

See also

  FXND

## EXP&LN not in app ↑ top

PDF page 198 · printed page 3-78

Type

  Command

Description

  Displays a menu or list of the CAS exponential and logarithmic operations.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## EXP in app ↑ top

PDF page 198 · printed page 3-78

Type

  Analytic Function

Description

  Exponential Analytic Function: Returns the exponential, or natural antilogarithm, of the argument; that is, e raised to the given power. EXP uses extended precision constants and a special algorithm to compute its result to full 12- digit precision for all arguments that do not trigger an underflow or overflow error. EXP provides a more accurate result for the exponential than can be obtained by using e Q. The difference in accuracy increases as z increases. For example:

  z | EXP(z) | ez
  --- | --- | ---
  3 | 20.0855369232 | 20.0855369232
  10 | 22026.4657948 | 22026.4657949
  100 | 2.68811714182E43 | 2.68811714191E43
  500 | 1.40359221785E217 | 1.40359221809E217
  1000 | 1.9707111402E434 | 1.9707111469E434

  For complex arguments: e(x,y) = excosy + iexsiny

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | ez
  `symb` | → | `EXP(symb)`

See also

  ALOG, EXPM, LN, LOG

## EXP2HYP not in app ↑ top

PDF page 199 · printed page 3-79

Type

  Function

Description

  Converts expressions involving the exponential function into expressions with hyperbolic functions.

Input

  An expression

Output

  The rewritten expression.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). 5 ⋅ ln ( x )

Example

  Rewrite in terms of hyperbolic functions the expression e

  Command | EXP2HYP(EXP(5*LN(X)))
  Result | SINH(5*LN(X))+COSH(5*LN(X))

## EXP2POW not in app ↑ top

PDF page 199 · printed page 3-79

Type

  Function

Description

  Simplifies expressions involving the composition of the exponential and logarithmic functions. Compare this to LNCOLLECT which combines logarithmic terms; the difference is shown in the results of the second example used here and for LNCOLLECT.

Input

  An expression

Output

  The simplified expression.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

  Example 1: Simplify the expression e 5·ln(x)
  Command | EXP2POW(EXP(5*LN(X)))

  5

  Result | X Example 2: Simplify the expression e n·ln(x)
  Command | EXP2POW(EXP(N*LN(X)))

  N

       Result:        X

See also

  LNCOLLECT

## EXPAN not in app ↑ top

PDF page 199 · printed page 3-79

Type

  Command

Description

  Expand Products Command: Rewrites an algebraic expression or equation by expanding products and powers. This command is similar to the old HP 48G series command, with minor modifications (such as adding RISCH for integration).

Flags

  Numerical Results (–3), Exact Mode (–105)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | x
  `symb1` | → | `symb2`
  (x, y) | → | (x, y)
  Example 1: | `A^(B+C)` EXPAN returns `A^C*A^B` |
  Example 2: | `(X+Y)^2` EXPAN returns `X^2+2*Y*X+Y^2` |

See also

  COLCT, EXPAND, ISOL, QUAD, SHOW

## EXPAND in app ↑ top

PDF page 200 · printed page 3-80

Type

  Command

Description

  Expands and simplifies an algebraic expression. This command is similar to the EXPAN command (which is included to ensure backward-compatibility with the HP 48-series calculators), except that EXPAND does more a more in-depth analysis and often does a better job at simplifying an expression than EXPAN.

Input

  An expression, or an array of expressions.

Output

  The expanded and simplified expression or array of expressions.

Flags

  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

  Simplify the following expression: 2 ( x + 2x + 1 ) ------------------------------- x+1

  Command | EXPAND((X^2+2*X+1)/(X+1))
  Result | X+1

See also

  EXPAN

## EXPANDMOD in app ↑ top

PDF page 200 · printed page 3-80

Type

  Function

Description

  Expands and simplifies an algebraic expression, or an array of expressions, modulo the current modulus.

Input

  An expression, or an array of expressions.

Output

  The expanded and simplified expression, or array of expressions, modulo the current modulus.

Flags

  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

  Expand the following expression and give the result modulo 3: ( x + 3 )( x + 4 )

  Command | EXPANDMOD((X+3)*(X+4))
  Result | X^2+X

## EXPFIT in app ↑ top

PDF page 201 · printed page 3-81

Type

  Command

Description

  Exponential Curve Fit Command: Stores EXPFIT as the fifth parameter in the reserved variable ΣPAR, indicating that subsequent executions of LR are to use the exponential curve fitting model. LINFIT is the default specification in ΣPAR.

Input/Output

  None

See also

  BESTFIT, LR, LINFIT, LOGFIT, PWRFIT

## EXPLN in app ↑ top

PDF page 201 · printed page 3-81

Type

  Command

Description

  Transforms the trigonometric terms in an expression to exponential and logarithmic terms.

Input

  An expression

Output

  The transformed expression.

Flags

  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). Complex mode must be set (flag –103 set).

Example

  Transform the following expression and simplify the result using the EXPAND command: 2 2 cos ( x )

      Command:        EXPLN(2*COS(X^2))

  EXPAND(ANS(1))

      Result:         (EXP(i*X^2)^2+1)/EXP(i*X^2)

See also

  SINCOS

## EXPM in app ↑ top

PDF page 201 · printed page 3-81

Type

  Analytic Function

Description

  Exponential Minus 1 Analytic Function: Returns ex – 1. For values of x close to zero, EXPM(x) returns a more accurate result than does EXP(x)–1. (Using EXPM allows both the argument and the result to be near zero, and avoids an intermediate result near 1. The calculator can express numbers within 10–449 of zero, but within only 10–11 of 1.)

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | ex – 1
  `symb` | → | `EXPM(symb)`

See also

  EXP, LNP1

## EYEPT not in app ↑ top

PDF page 201 · printed page 3-81

Type

  Command

Description

  Eye Point Command: Specifies the coordinates of the eye point in a perspective plot.

  xpoint, ypoint, and zpoint are real numbers that set the x-, y-, and z-coordinates as the eye-point from which to view a 3D plot’s view volume. The y-coordinate must always be 1 unit less than the view volume’s nearest point (ynear of YVOL). These coordinates are stored in the reserved variable VPAR.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  xpoint | ypoint | zpoint | → |

See also

  NUMX, NUMY, XVOL, XXRNG, YVOL, YYRNG, ZVOL

## F0λ not in app ↑ top

PDF page 202 · printed page 3-82

Type

  Function

Description

  Black Body Emissive Power Function: Returns the fraction of total black-body emissive power at temperature xT between wavelengths 0 and ylambda. If units are not specified, ylambda has implied units of meters and xT has implied units of K. F0λ returns a dimensionless fraction.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  ylambda | xT | → | xpower
  ylambda | `symb` | → | `F0λ(ylambda,symb)`
  `symb` | xT | → | `F0λ(symb,xT)`
  `symb1` | `symb2` | → | `F0λ(symb1,symb2)`

## FACT in app ↑ top

PDF page 202 · printed page 3-82

Type

  Command

Description

  Factorial (Gamma) Function: FACT is the same as ! and is provided for compatibility with the HP 28. See !.

Flags

  Numerical Results (–3), Underflow Exception (–20), Overflow Exception (–21)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → | n!
  x | → | Γ(x + 1)
  `symb` | → | `(symb)!`

See also

  COMB, PERM, !

## FACTOR in app ↑ top

PDF page 202 · printed page 3-82

Type

  Command

Description

  Factorizes a polynomial or an integer:

  - The function expresses a polynomial as the product of irreducible polynomials.
  - The function expresses an integer as the product of prime numbers.
Input

  An expression or an integer.

Output

  The factorized expression, or the integer expressed as the product of prime numbers.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). Results including complex terms are returned if complex mode is set (flag –103 set).

Example

  Factorize the following: 2 x + 5x + 6

  Command | FACTOR(X^2+5*X+6)
  Result | (X+2)(X+3)

See also

  EXPAN, EXPAND

## FACTORMOD in app ↑ top

PDF page 203 · printed page 3-83

Type

  Function

Description

  Factorizes a polynomial modulo the current modulus. The modulus must be less than 100, and a prime number, it can be changed by MODSTO.

Input

  The expression to be factorized.

Output

  The factorized expression modulo the current modulus.

Flags

  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

  Factorize the following expression modulo 3. x2+2

  Command | FACTORMOD(X^2+2)
  Result | (X+1)*(X-1)

See also

  MODSTO

## FACTORS in app ↑ top

PDF page 203 · printed page 3-83

Type

  Command

Description

  For a value or expression, returns a list of prime factors and their multiplicities.

Input

  A value or expression.

Output

  A list of prime factors of the value or expression, with each factor followed by its multiplicity expressed as a real number.

Flags

  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 1: Find the prime factors of 100.
  Command | FACTORS(100)
  Result | {5 2. 2 2.}

  2

  Example 2: Find the irreducible factors of: x + 4x + 4
  Command | FACTORS(X^2+4*X+4)
  Result | {X+2,2.}

## FANNING not in app ↑ top

PDF page 204 · printed page 3-84

Type

  Function

Description

  Fanning Friction Factor Function: Calculates the Fanning friction factor of certain fluid flows. FANNING calculates the Fanning friction factor, a correction factor for the frictional effects of fluid flows having constant temperature, cross-section, velocity, and viscosity (a typical pipe flow, for example). xx/D is the relative roughness (the ratio of the conduit roughness to its diameter). yRe is the Reynolds number. The function uses different computation routines for laminar flow (Re ≤ 2100) and turbulent flow (Re > 2100). xx/D and yRe must be real numbers or unit objects that reduce to dimensionless numbers, and both numbers must be greater than 0.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xx/D | yRe | → | xfanning
  xx/D | `symb` | → | `FANNING(xx/D,symb)`
  `symb` | yRe | → | `FANNING(symb,yRe)`
  `symb1` | `symb2` | → | `FANNING(symb1,symb2)`

See also

  DARCY

## FAST3D not in app ↑ top

PDF page 204 · printed page 3-84

Type

  Command

Description

  Fast 3D Plot Type Command: Sets the plot type to FAST 3D. When plot type is set to FAST3D, the DRAW command plots an image graph of a 3-vector- valued function of two variables. FAST3D requires values in the reserved variables EQ, VPAR, and PPAR. VPAR is made up of the following elements: { xleft,xright, ynear, yfar,zlow,zhigh,xmin,xmax, ymin, ymax,xeye, yeye,zeye,xstep, ystep } For plot type FAST3D, the elements of VPAR are used as follows:

  - xleft and xright are real numbers that specify the width of the view space.
  - ynear and yfar are real numbers that specify the depth of the view space.
  - zlow and zhigh are real numbers that specify the height of the view space.
  - xmin and xmax are not used.
  - ymin and ymax are not used.
  - xeye, yeye, and zeye are are not used.
  - xstep and ystep are real numbers that set the number of x-coordinates versus the number of y- coordinates plotted. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin),(xmax, ymax),indep,res,axes,ptype,depend } For plot type FAST3D, the elements of PPAR are used as follows:
  - (xmin, ymin) is not used.
  - (xmax, ymax) is not used.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is not used.
  - axes is not used.
  - ptype is a command name specifying the plot type. Executing the command FAST3D places the name FAST3D in ptype.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## FCOEF in app ↑ top

PDF page 205 · printed page 3-85

Type

  Command

Description

  From an array of roots and multiplicities/poles, returns a rational polynomial with a leading coefficient of 1, with the specified set of roots or poles, and with the specified multiplicities.

Input

  An array of the form [Root 1, multiplicity/pole 1, Root 2, multiplicity/pole 2, . . .] The multiplicity/pole must be an integer. A positive number signifies a multiplicity. A negative number signifies a pole.

Output

  The rational polynomial with the specified roots and multiplicities/poles. The polynomial is written using the current independent variable.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the rational polynomial corresponding to the following set of roots and poles: 1, 2, 3, –1

  Command | FCOEF([1,2,3,-1])
  Result | (X-1)^2/(X-3)

See also

  FROOTS

## FC? in app ↑ top

PDF page 205 · printed page 3-85

Type

  Command

Description

  Flag Clear? Command: Tests whether the system or user flag specified by nflag number is clear, and returns a corresponding test result: 1 (true) if the flag is clear or 0 (false) if the flag is set.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nflag number | → | 0/1

See also

  CF, FC?C, FS? FS?C, SF

## FC?C in app ↑ top

PDF page 205 · printed page 3-85

Type

  Command

Description

  Flag Clear? Clear Command: Tests whether the system or user flag specified by nflag number is clear, and returns a corresponding test result: 1 (true) if the flag is clear or 0 (false) if the flag is set. After testing, clears the flag.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nflag number | → | 0/1

Example

  If flag –44 is set, -44 FC?C returns 0 to level 1 and clears flag –44.

See also

  CF, FC?, FS? FS?C, SF

## FDISTRIB not in app ↑ top

PDF page 206 · printed page 3-86

Type

  Command

Description

  Performs a full distribution of multiplication and division with respect to addition and subtraction in a single step.

Input

  An expression.

Output

  An equivalent expression that results from fully applying the distributive property of multiplication and division over addition and subtraction.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Expand (X+1)(X-1)(X+2):

  Command | FDISTRIB((X+1)*(X-1)*(X+2))
  Result | X*(X*X)+2*(X*X)+(-(X*(1*X))+-(2*(1*X)))+ (X*(X*1)+2*(X*1)+

  (-(X*(1*1))+-(2*(1*1))))

See also

  DISTRIB

## FFT not in app ↑ top

PDF page 206 · printed page 3-86

Type

  Command

Description

  Discrete Fourier Transform Command: Computes the one- or two-dimensional discrete Fourier transform of an array. If the argument is an N-vector or an N × 1 or 1 × N matrix, FFT computes the one-dimensional transform. If the argument is an M × N matrix, FFT computes the two-dimensional transform. M and N must be integral powers of 2. The one-dimensional discrete Fourier transform of an N-vector X is the N-vector Y where:

      –1         2πi kn

  – --------------

                                                    Yk =    ∑    Xn e
           , i =                    –1

  n=0

  for k = 0, 1, …, N – 1. The two dimensional discrete Fourier transform of an M × N matrix X is the M × N matrix Y where: M–1

      –1              2 πik m 2πi ln

  – ---------------- – -----------------

                                         Y kl =    ∑       ∑ xm n   e M e
           ,i =                              –1

  m=0 n=0

  for k = 0, 1, …, M – 1 and l = 0, 1, …, N – 1. The discrete Fourier transform and its inverse are defined for any positive sequence length. However, the calculation can be performed very rapidly when the sequence length is a power of two, and the resulting algorithms are called the fast Fourier transform (FFT) and inverse fast Fourier transform (IFFT). The FFT command uses truncated 15-digit arithmetic and intermediate storage, then rounds the result to 12-digit precision.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ array ]1 | → | [ array ]2

See also

  IFFT

## FILER not in app ↑ top

PDF page 207 · printed page 3-87

Type

  Command

Description

  Opens File Manager.

Input/Output

  None

## FINDALARM not in app ↑ top

PDF page 207 · printed page 3-87

Type

  Command

Description

  Find Alarm Command: Returns the alarm index nindex of the first alarm due after the specified time. If the input is a real number date, FINDALARM returns the index of the first alarm due after 12:00 AM on that date. If the input is a list { date time }, it returns the index of the first alarm due after that date and time. If the input is the real number 0, FINDALARM returns the first past-due alarm. For any of the three arguments, FINDALARM returns 0 if no alarm is found.

Flags

  Date Format (–42)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  date | → | nindex
  { date time } | → | nindex
  0 | → | nindex

See also

  DELALARM, RCLALARM, STOALARM

## FINISH not in app ↑ top

PDF page 207 · printed page 3-87

Type

  Command

Description

  Finish Server Mode Command: Terminates Kermit Server mode in a device connected to the calculator. FINISH is used by a local Kermit device to tell a server Kermit (connected via the serial port or the IR port) to exit Server mode.

Flags

  I/O Device flag (–33), I/O Messages (–39), I/O Device for Wire (–78)

Input/Output

  None

See also

  BAUD, CKSM, KGET, PARITY, PKT, RECN, RECV, SEND, SERVER

## FIX in app ↑ top

PDF page 207 · printed page 3-87

Type

  Command

Description

  Fix Mode Command: Sets the number display format to fix mode, which rounds the display to n decimal places.

  Fix mode shows n digits to the right of the fraction mark (decimal point), where 0 ≤ n ≤ 11. (Values for n outside this range are rounded to the nearest integer.) A number is displayed or printed as (sign) mantissa, where the mantissa can be of any form. However, the calculator automatically displays a number in scientific mode if either of the following is true:

  - The number of digits to be displayed exceeds 12.
  - A nonzero value rounded to n decimal places otherwise would be displayed as zero.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → |

Example

  The number 103.6 in Fix mode to four decimal places would appear as 103.6000.

See also

  SCI, STD

## FLASHEVAL not in app ↑ top

PDF page 208 · printed page 3-88

Type

  Command

Description

  Evaluate Flash Function Command: Evaluates unnamed Flash functions. WARNING: Use extreme care when executing this function. Using FLASHEVAL with random addresses will almost always cause a memory loss. Do not use this function unless you know what you are doing. #nfunction is of the form ffffbbbh, where bbb is the bank ID, and ffff is the function number.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #nfunction | → |

See also

  EVAL, LIBEVAL, SYSEVAL

## FLOOR in app ↑ top

PDF page 208 · printed page 3-88

Type

  Function

Description

  Floor Function: Returns the greatest integer that is less than or equal to the argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | n
  x_unit | → | n_unit
  `symb` | → | `FLOOR(symb)`
  Example 1: | 3.2 FLOOR returns 3. |
  Example 2: | -3.2 FLOOR returns –4. |

See also

  CEIL, IP, RND, TRNC

## FONT6 not in app ↑ top

PDF page 208 · printed page 3-88

Type

  Function

Description

  Font Function: Returns the system FONT6 object. You use this in conjunction with the →FONT command to set the system font to type 6.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Font object |

See also

  FONT7, FONT8, →FONT, FONT→

## FONT7 not in app ↑ top

PDF page 209 · printed page 3-89

Type

  Function

Description

  Font Function: Returns the system FONT7 object. You use this in conjunction with the →FONT command to set the system font to type 7.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Font object |

See also

  FONT6, FONT8, →FONT, FONT→

## FONT8 not in app ↑ top

PDF page 209 · printed page 3-89

Type

  Function

Description

  Font Function: Returns the system FONT8 object. You use this in conjunction with the →FONT command to set the system font to type 8.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Font object |

See also

  FONT6, FONT7, →FONT, FONT→

  FONT→

Type

  Function

Description

  Returns the current system font.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Font object |

See also

  FONT6, FONT7, FONT8, →FONT

## →FONT not in app ↑ top

PDF page 209 · printed page 3-89

Type

  Function

Description

  Set font Function: Sets the system font. You use this in conjunction with one of the three font commands to set the system font. Valid input is any font object (TYPE 30) of size 6, 7, or 8.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  Font object | → |

See also

  FONT6, FONT7, FONT8, FONT→

## FOR not in app ↑ top

PDF page 210 · printed page 3-90

Type

  Command Operation

Description

  FOR Definite Loop Structure Command: Starts FOR … NEXT and FOR … STEP definite loop structures. Definite loop structures execute a command or sequence of commands a specified number of times.

  - A FOR … NEXT loop executes a program segment a specified number of times using a local variable as the loop counter. You can use this variable within the loop. The RPL syntax is this: xstart xfinish FOR counter loop-clause NEXT The algebraic syntax is this: FOR(counter, xstart, xfinish) loop-clause NEXT FOR takes xstart and xfinish 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 be referenced or have its value changed within the loop clause. NEXT increments counter by one, and then tests whether counter is less than or equal to xfinish. If so, the loop clause is repeated (with the new value of counter). When the loop is exited, counter is purged.
  - FOR … STEP works just like FOR … NEXT, except that it lets you specify an increment value other than 1. The syntax RPL is: xstart xfinish FOR counter loop-clause xincrement STEP The algebraic syntax is: FOR(counter, xstart, xfinish) loop-clause, STEP (xincrement) FOR takes xstart and xfinish 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 be referenced or have its value changed within the loop clause. STEP takes xincrement and increments counter by that value. If the argument of STEP is an algebraic expression or a name, it is automatically evaluated to a number. The increment value can be positive or negative. If the increment is positive, the loop is executed again when counter is less than or equal to xfinish. If the increment is negative, the loop is executed when counter is greater than or equal to xfinish. When the loop is exited, counter is purged.
Input/Output

  Level 2/ | Level 1 |  | Level 1/Item 1
  --- | --- | --- | ---
  FOR xstart | xfinish | → |
  NEXT →
  FOR xstart | xfinish | → |
  STEP | xincrement | → |
  STEP | `symbincrement` | → |

Note

  It should be noted that FOR inputs may also be integers (object type 28) and binary integers (type 10). FOR actually runs fastest on binary integers, runs “normally” on reals and slightly slower on integers.

Example

      The following program sums all odd integers in the range 1 to 100: « 0 1 100 FOR I I + 2 STEP »

See also

  NEXT, START, STEP

## FOURIER not in app ↑ top

PDF page 211 · printed page 3-91

Type

  Function

Description

  Returns the nth coefficient of a complex Fourier series expansion. The PERIOD variable must be in the CAS directory, CASDIR, or in current path, and set to hold L, the period of the input function. The expression is expanded in terms of the current CAS variable.

Input

  Level 1/Argument 2: An expression in terms of the current variable Level 2/Argument 1: The number, n, of the coefficient to return.

Output

  The nth Fourier coefficient of the expression.

Flags

  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). Complex mode must be set, that is, flag –103 must be set.

Example

  Obtain the Fourier coefficient as below, with the default value of 2π in the PERIOD variable in CASDIR, and simplify it with EXPAND:

      Command:       FOURIER(X^2,0)

  EXPAND(ANS(1))

      Result:        4/3* π^2

## FP in app ↑ top

PDF page 211 · printed page 3-91

Type

  Function

Description

  Fractional Part Function: Returns the fractional part of the argument. The result has the same sign as the argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | y
  x_unit | → | y_unit
  `symb` | → | `FP(symb)`
  Example 1: | -32.3 FP returns -.3. |
  Example 2: | 32.3_m FP returns .3_m. |

See also

  IP

## FREE not in app ↑ top

PDF page 211 · printed page 3-91

Type

  Command

Description

  Do not use this command, a carry-over from the HP 48SX for handling plug-in RAM cards.

## FREEZE not in app ↑ top

PDF page 211 · printed page 3-91

Type

  Command

Description

  Freeze Display Command: Freezes the part of the display specified by ndisplay area, so that it is not updated until a key is pressed. Normally, the stack display is updated as soon as the calculator is ready for data input. For example, when HALT stops a running program, or when a program ends, any displayed messages are cleared. The FREEZE command “freezes” a part or all of the display so that it is not updated until a key is pressed. This allows, for example, a prompting message to persist after a program halts to await data input. ndisplay area is the sum of the value codes for the areas to be frozen:

  Display Area | Value Code
  --- | ---
  Status area | 1
  History/Stack/Command-line area | 2
  Menu area | 4

  So, for example, 2 FREEZE freezes the history/stack/command-line area, 3 FREEZE freezes the status area and the history/stack/command-line area, and 7 FREEZE freezes all three areas. Values of ndisplay area ≥ 7 or ≤ 0 freeze the entire display (are equivalent to value 7). To freeze the graphics display, you must freeze the status and stack/command-line areas (by entering 3), or the entire display (by entering 7).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  ndisplayarea | → |
  Example 1: | This program: |
  « "Ready for data" 1 DISP 1 FREEZE HALT » displays the contents of the string in the top line of the display, then freezes the status area so that the string contents persist in the display after HALT is executed.
      Example 2:       This program:
  « { # 0d # 0d } PVIEW 7 FREEZE » selects the graphics display and then freezes the entire display so that the graphics display persists after the program ends. (If FREEZE was not executed, the stack display would be selected after the program ends.) To use FREEZE with PVIEW (or any graphics display), you must enter 3 or 7.

Flags

  None

See also

  CLLCD, DISP, HALT

## FROOTS in app ↑ top

PDF page 212 · printed page 3-92

Type

  Command

Description

  For a rational polynomial, returns an array of its roots and poles, with their corresponding multiplicities. This is the inverse of FCOEF and uses the same notation for roots and poles.

Input

  A rational polynomial.

Output

  An array of the form [Root 1, Multiplicity 1, Root 2, Multiplicity 2, . . .] A negative multiplicity indicates a pole.

Flags

  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). If complex mode is set (flag –103 set), FROOTS looks for complex solutions as well as real solutions. If approximate mode is set (flag –105 set) FROOTS searches for numeric roots.

See also

  FCOEF

## FS? in app ↑ top

PDF page 212 · printed page 3-92

Type

  Command

Description

  Flag Set? Command: Tests whether the system or user flag specified by nflag number is set, and returns a corresponding test result: 1 (true) if the flag is set or 0 (false) if the flag is clear.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nflag number | → | 0/1

See also

  CF, FC?, FC?C, FS?C, SF

## FS?C in app ↑ top

PDF page 213 · printed page 3-93

Type

  Command

Description

  Flag Set? Clear Command: Tests whether the system or user flag specified by nflag number is set, and returns a corresponding test result: 1 (true) if the flag is set or 0 (false) if the flag is clear. After testing, clears the flag.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nflag number | → | 0/1

Example

  If flag –44 is set, -44 FS?C returns 1 to level 1 and clears flag –44.

See also

  CF, FC?, FC?C, FS?, SF

## FUNCTION not in app ↑ top

PDF page 213 · printed page 3-93

Type

  Command

Description

  Function Plot Type Command: Sets the plot type to FUNCTION. When the plot type is FUNCTION, the DRAW command plots the current equation as a real- valued function of one real variable. The current equation is specified in the reserved variable EQ. The plotting parameters are specified in the reserved variable PPAR, which has the form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type FUNCTION, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is a name specifying the independent variable, or a list containing such a name and two numbers specifying the minimum and maximum values for the independent variable (the plotting range). The default value of indep is X.
  - res is a real number specifying the interval (in user-unit coordinates) between plotted values of the independent variable, or a binary integer specifying the interval in pixels. The default value is 0, which specifies an interval of 1 pixel.
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command FUNCTION places the name FUNCTION in PPAR.
  - depend is a name specifying a label for the vertical axis. The default value is Y. The current equation is plotted as a function of the variable specified in indep. The minimum and maximum values of the independent variable (the plotting range) can be specified in indep;

  otherwise, the values in (xmin, ymin) and (xmax, ymax)(the display range) are used. Lines are drawn between plotted points unless flag –31 is set. If EQ contains an expression or program, the expression or program is evaluated in Numerical Results mode for each value of the independent variable to give the values of the dependent variable. If EQ contains an equation, the plotting action depends on the form of the equation, as shown in the following table.

  Form of Current Equation | Plotting Action
  --- | ---
  expr = expr | Each expression is plotted separately. The intersection of

  the two graphs shows where the expressions are equal.

  name = expr | Only the expression is plotted.
  --- | ---
  indep = constant | A vertical line is plotted.

  If flag –28 is set, all equations are plotted simultaneously. If the independent variable in the current equation represents a unit object, you must specify the units by storing a unit object in the corresponding variable in the current directory. For example, if the current equation is X+3_m, and you want X to represent some number of inches, you would store 1_in (the number part of the unit object is ignored) in X. For each plotted point, the numerical value of the independent variable is combined with the specified unit (inches in this example) before the current equation is evaluated. If the result is a unit object, only the number part is plotted.

Flags

  Simultaneous Plotting (–28), Curve Filling (–31)

Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FAST3D, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## FXND not in app ↑ top

PDF page 214 · printed page 3-94

Type

  Command

Description

  Splits an object into a numerator and a denominator.

Input

  A fraction, or an object that evaluates to a fraction.

Output

  The object split into numerator and denominator. Level 2/Item 1: The numerator. Level 1/Item 2: The denominator.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Return the numerator and the denominator of the following expression: 2 (x – 3) ------------------ z+4

  Command | FXND((X-3)^2/(Z+4))
  Result | {(X-3)^2, Z+4}

See also

  EXLR

## GAMMA in app ↑ top

PDF page 215 · printed page 3-95

Type

  Function

Description

  Evaluate the Γ function at the given point. For a positive integer x, Γ(x) is equal to (x +1)! GAMMA differs from the FACT and ! functions because it allows complex arguments. The Γ function is defined by

                                               +∞ – t     x–1
                                       Γ(x ) = ∫       e ⋅t         dt

  0 .

Input

  A real or complex number, x.

Output

  Γ(x). If the input x is an integer greater than 100, returns the symbolic expression GAMMA(x).

Flags

  If the Underflow Exception (–20) or Overflow Exception (–21) flags are set then underflow or overflow conditions give errors, otherwise they give zero or the maximum real number the calculator can express. Complex mode must be set (flag –103 set) if x is complex.

See also

  FACT, PSI, Psi, !

## GAUSS not in app ↑ top

PDF page 215 · printed page 3-95

Type

  Command

Description

  Returns the diagonal representation of a quadratic form.

Input

  Level 2/Argument 1: The quadratic form. Level 1/Argument 2: A vector containing the independent variables.

Output

  Level 4/Item 1: An array of the coefficients of the diagonal. Level 3/Item 2: A matrix, P, such that the quadratic form is represented as PTDP, where the diagonal matrix D contains the coefficients of the diagonal representation. Level 2/Item 3: The diagonal representation of the quadratic form. Level 1/Item 4: The vector of the variables.

Flags

  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

  Find the Gaussian symbolic quadratic form of the following: 2 x + 2axy

  Command | GAUSS(X^2+2*A*X*Y,[X,Y])
  Result | {[1,-A^2], [[1,A][0,1]], -(A^2*Y^2)+(A*Y+X)^2,[X,Y]}

See also

  AXQ, QXA

## GBASIS in app ↑ top

PDF page 215 · printed page 3-95

Type

  Command

Description

  Returns a set of polynomials that are a Gröbner basis G of the ideal I generated from an input set of polynomials F.

Input

  Level 2/Argument 1: A vector F of polynomials in several variables. Level 1/Argument 2: A vector giving the names of the variables.

Output

  Level 1/Item 1: A vector containing the resulting set G of polynomials. The command attempts to order the polynomials as given in the vector of variable names.

Flags

  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

  Find a Gröbner basis of the ideal polynomial generated by the polynomials: x2 + 2xy2, xy + 2y3 – 1

  Command | GBASIS([X^2 + 2*X*Y^2, X*Y + 2*Y^3 – 1], [X,Y])
  Result | [X, 2*Y^3-1]

  Note this is not the minimal Gröbner basis, as the leading coefficient of the second term is not 1; the algorithm used avoids giving results with fractions.

See also

  GREDUCE

## GCD in app ↑ top

PDF page 216 · printed page 3-96

Type

  Function

Description

  Returns the greatest common divisor of two objects.

Input

  Level 2/Argument 1: An expression, or an object that evaluates to a number. Level 1/Argument 2: An expression, or an object that evaluates to a number.

Output

  The greatest common divisor of the two objects.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the greatest common divisor of 2805 and 99.

  Command | GCD(2805,99)
  Result | 33

See also

  GCDMOD, EGCD, IEGCD, LCM

## GCDMOD in app ↑ top

PDF page 216 · printed page 3-96

Type

  Function

Description

  Finds the greatest common divisor of two polynomials modulo the current modulus.

Input

  Level 2/Argument 1: A polynomial expression. Level 1/Argument 2: A polynomial expression.

Output

  The greatest common divisor of the two expressions modulo the current modulus.

Flags

  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

  Find the greatest common divisor of 2x^2+5 and 4x^2-5x, modulo 13.

  Command | GCDMOD(2X^2+5,4X^2-5X)
  Result | -(4X-5)

See also

  GCD

## GET in app ↑ top

PDF page 216 · printed page 3-96

Type

  Command

Description

  Get Element Command: Returns from the argument 1/level 2 array or list (or named array or list) the real or complex number zget or object objget whose position is specified in argument 2/level 1. For matrices, nposition is incremented in row order.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  [[ matrix ]] | nposition | → | zget
  [[ matrix ]] | { nrow, mcolumn } | → | zget
  `namematrix` | nposition | → | zget
  `namematrix` | { nrow, mcolumn } | → | zget
  [ vector ] | nposition | → | zget
  [ vector ] | {nposition } | → | zget
  `namevector` | nposition | → | zget
  `namevector` | {nposition } | → | zget
  { list } | nposition | → | objget
  { list } | {nposition } | → | objget
  `namelist` | nposition | → | objget
  `namelist` {nposition } → objget
  Example 1: [[ 2 3 7 ][ 3 2 9 ][ 2 1 3 ] { 2 3 } GET returns 9.
  Example 2: [[ 2 3 7 ][ 3 2 9 ][ 2 1 3 ] 8 GET returns 1.
  Example 3: { A B C D E } { 1 } GET returns `A`.

See also

  GETI, PUT, PUTI

## GETI in app ↑ top

PDF page 217 · printed page 3-97

Type

  Command

Description

  Get and Increment Index Command: Returns from the argument 1/level 2 array or list (or named array or list) the real or complex number zget or object objget whose position is specified in argument 2/level 1, along with the first (level 2) argument and the next position in that argument. For matrices, the position is incremented in row order.

Flags

  Index Wrap Indicator (–64)

Input/Output

  L2/A1 | L1/A2 |  | L3/I1 | L2/I2 | L1/I3
  --- | --- | --- | --- | --- | ---
  [[ matrix ]] | nposition1 | → | [[ matrix ]] | nposition2 | zget
  [[ matrix ]] | { nrow, mcolumn }1 | → | [[ matrix ]] | { nrow, mcolumn }2 | zget
  `namematrix` | nposition1 | → | `namematrix` | nposition2 | zget
  `namematrix` | { nrow, mcolumn }1 | → | `namematrix` | { nrow, mcolumn }2 | zget
  [ vector ] | nposition | → | [ vector ] | nposition2 | zget
  [ vector ] | {nposition1 } | → | [ vector ] | {nposition2 } | zget
  `namevector` | nposition1 | → | `namevector | nposition2 | zget
  `namevector` | {nposition1 } | → | `namevector | {nposition2 } | zget
  { list } | nposition1 | → | { list } | nposition2 | objget
  { list } | {nposition1 } | → | { list } | {nposition2 } | objget
  `namelist` | nposition1 | → | `namelist` | nposition2 | objget
  `namelist` | {nposition1 } | → | `namelist` | {nposition2 } | objget
  L = Level; A = Argument; I = Item

See also

  GET, PUT, PUTI

## GOR not in app ↑ top

PDF page 218 · printed page 3-98

Type

  Command

Description

  Graphics OR Command: Superimposes grob1 onto grobtarget or PICT, with the upper left corner pixel of grob1 positioned at the specified coordinate in grobtarget or PICT. GOR uses a logical OR to determine the state (on or off) of each pixel in the overlapping portion of the argument graphics object. If the first argument (stack level 3) is any graphics object other than PICT, then grobresult is returned to the stack. If the first argument (level 3) is PICT, no result is returned to the stack. Any portion of grob1 that extends past grobtarget or PICT is truncated.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  grobtarget | { #n #m } | grob1 | → | grobresult
  grobtarget | (x, y) | grob1 | → | grobresult
  PICT | { #n #m } | grob1 | → |
  PICT | (x, y) | grob1 | → |

See also

  GXOR, REPL, SUB

## GRAD in app ↑ top

PDF page 218 · printed page 3-98

Type

  Command

Description

  Grads Mode Command: Sets Grads angle mode. GRAD clears flag –17 and sets flag –18, and displays the GRD annunciator. In Grads angle mode, real-number arguments that represent angles are interpreted as grads, and real-number results that represent angles are expressed in grads.

Input/Output

  None

See also

  DEG, RAD

## GRAMSCHMIDT in app ↑ top

PDF page 219 · printed page 3-99

Type

  Command

Description

  Finds an orthonormal base of a vector space with respect to a given scalar product.

Input

  Level 2/Argument 1: A vector representing a basis of a vector space. Level 1/Argument 2: A function that defines a scalar product in that space. This can be given as a program, or as the name of a variable containing the definition of the function.

Output

  An orthonormal base of the vector space with respect to the given scalar product.

Flags

  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

      Find an orthonormal base for the vector space with base [1, 1+X] with respect to the scalar product defined by : 1 P ⋅ Q = ∫ P ( x ) ⋅ Q ( x ) dx –1
          Command:        GRAMSCHMIDT([1,1+X], « → P Q « PREVAL(INTVX(P*Q),-1,1) » »)

                             1          X
          ------ -------------- 1 2 -- ⋅ 6 3 Result:

## GRAPH not in app ↑ top

PDF page 219 · printed page 3-99

Type

  Command

Description

  Picture Environment Command: Selects the Picture environment GRAPH is provided for compatibility with the HP 28 series. GRAPH is the same as PICTURE; see its listing for details.

## GREDUCE in app ↑ top

PDF page 219 · printed page 3-99

Type

  Command

Description

  Reduces a polynomial with respect to a Gröbner basis.

Input

  Level 3/Argument 1: A vector of polynomials in several variables. Level 2/Argument 2: A vector of polynomials that is a Gröbner basis in the same variables. Level 1/Argument 3: A vector giving the names of the variables.

Output

  Level 1/Item 1: A vector containing the input polynomial reduced with respect to the Gröbner basis, up to a constant; as with GBASIS, fractions in the result are avoided.

Flags

  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

  Reduce the polynomial: x2y – xy – 1 with respect to the Gröbner basis (obtained in the example for GBASIS): x, 2y3 – 1

  Command | GREDUCE(X^2*Y–X*Y–1, [X,2*Y^3–1], [X,Y])
  Result | -1

  Note this is the remainder of the input polynomial modulo the term x in the Gröbner basis

See also

  GBASIS

## GRIDMAP not in app ↑ top

PDF page 220 · printed page 3-100

Type

  Command

Description

  GRIDMAP Plot Type Command: Sets the plot type to GRIDMAP. When plot type is set GRIDMAP, the DRAW command plots a mapping grid representation of a 2-vector-valued function of two variables. GRIDMAP requires values in the reserved variables EQ, VPAR, and PPAR. VPAR has the following form: {xleft, xright, ynear, yfar, zlow, zhigh, xmin, xmax, ymin, ymax, xeye, yeye, zeye, xstep, ystep} For plot type GRIDMAP, the elements of VPAR are used as follows:

  - xleft and xright are real numbers that specify the width of the view space.
  - ynear and yfar are real numbers that specify the depth of the view space.
  - zlow and zhigh are real numbers that specify the height of the view space.
  - xmin and xmax are real numbers that specify the input region’s width. The default value is (–1,1).
  - ymin and ymax are real numbers that specify the input region’s depth. The default value is (–1,1).
  - xeye, yeye, and zeye are real numbers that specify the point in space from which you view the graph.
  - xstep and ystep are real numbers that set the number of x-coordinates versus the number of y- coordinates plotted. These can be used instead of (or in combination with) RES. The plotting parameters are specified in the reserved variable PPAR, which has the following form: { (xmin, ymin), (xmax, ymax), indep, res, axes, ptype, depend } For plot type GRIDMAP, the elements of PPAR are used as follows:
  - (xmin, ymin) is not used.
  - (xmax, ymax) is not used.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is a real number specifying the interval (in user-unit coordinates) between plotted values of the independent variable, or a binary integer specifying the interval in pixels. The default value is 0, which specifies an interval of 1 pixel.
  - axes is not used.
  - ptype is a command name specifying the plot type. Executing the command GRIDMAP places the command name GRIDMAP in PPAR.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## →GROB not in app ↑ top

PDF page 220 · printed page 3-100

Type

  Command

Description

  Stack to Graphics Object Command: Creates a graphics object from a specified object, where the argument nchar size specifies the character size of the object. nchar size can be 0, 1 (small), 2 (medium), or 3 (large). nchar size = 0 is the same as nchar size = 3, except for unit objects and algebraic objects, where 0 specifies the Equation Writer application picture.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | ncharsize | → | grob

Example

      This program: « `Y=3*X^2` 0 →GROB PICT STO { } PVIEW » returns a graphics object to the stack representing the Equation Writer application picture of `Y=3*X^2`, then stores the graphics object in PICT and shows it in the graphics display with scrolling activated.

See also

  →LCD, LCD→

## GROB not in app ↑ top

PDF page 221 · printed page 3-101

Type

  Command

Description

  Enters GROB on the command line to help with the manual entry of a graphic object.

## GROBADD not in app ↑ top

PDF page 221 · printed page 3-101

Type

  Command

Description

  Combines two graphic objects by appending the second argument onto the bottom of the first.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  GROB1 | GROB2 | → | GROB3

## GXOR not in app ↑ top

PDF page 221 · printed page 3-101

Type

  Command

Description

  Graphics Exclusive OR Command: Superimposes grob1 onto grobtarget or PICT, with the upper left corner pixel of grob1 positioned at the specified coordinate in grobtarget or PICT. GXOR is used for creating cursors, for example, to make the cursor image appear dark on a light background and light on a dark background. Executing GXOR again with the same image restores the original picture. GXOR uses a logical exclusive OR to determine the state of the pixels (on or off) in the overlapping portion of the argument graphics objects. Any portion of grob1 that extends past grobtarget or PICT is truncated. If the first (level 3) argument (the target graphics object) is any graphics object other than PICT, then grobresult is returned to the stack. If the first (level 3) argument is PICT, no result is returned to the stack.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  grobtarget | { #n, #m } | grob1 | → | grobresult
  grobtarget | (x, y) | grob1 | → | grobresult
  PICT | { #n, #m } | grob1 | → |
  PICT | (x, y) | grob1 | → |

Example

      This program: « ERASE PICT NEG PICT { # 0d # 0d }
          GROB 5 x 5 11A040A011 GXOR LASTARG GXOR » turns on (makes dark) every pixel in PICT, then superimposes a 5 x 5 graphics object on PICT at pixel coordinates { # 0d # 0d }. Each on-pixel in the 5 by 5 graphics object turns off (makes light) the corresponding pixel in PICT. Then, the original picture is restored by executing GXOR again with the same arguments.

See also

  GOR, REPL, SUB

## *H not in app ↑ top

PDF page 222 · printed page 3-102

Type

  Command

Description

  Multiply Height Command: Multiplies the vertical plot scale by xfactor. *H is provided for compatibility with the HP 48. *H is the same as SCALEH; see its listing for details.

## HADAMARD in app ↑ top

PDF page 222 · printed page 3-102

Type

  Command

Description

  Performs an element by element multiplication of two matrices (Hadamard product).

Input

  Level 2/Argument 1: Matrix 1. Level 1/Argument 2: Matrix 2. The matrices must have the same order.

Output

  The matrix representing the result of the multiplication.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the Hadamard product of the following two matrices:

  3 –1 2 | 2 3 0
  --- | ---
  0 1 4 | 1 5 2

  and

  Command | HADAMARD([[3,-1,2][0,1,4]],[2,3,0][1,5,2]])
  Result | [[6,-3,0][0,5,8]]

## HALFTAN in app ↑ top

PDF page 222 · printed page 3-102

Type

  Command

Description

  Transforms an expression by replacing sin(x), cos(x) and tan(x) subexpressions with tan(x/2) terms.

Input

  An expression

Output

  The transformed expression.

Flags

  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).

See also

  TAN2CS2, TAN2SC2

## HALT in app ↑ top

PDF page 222 · printed page 3-102

Type

  Command

Description

  Halt Program Command: Halts program execution. Program execution is halted at the location of the HALT command in the program. The HLT annunciator is turned on. Program execution is resumed by executing CONT (that is, by pressing !æ). Executing KILL cancels all halted programs.

Input/Output

  None

See also

  CONT, KILL

## HEAD in app ↑ top

PDF page 223 · printed page 3-103

Type

  Command

Description

  First Listed Element Command: Returns the first element of a list or string.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { obj1, ... ,objn } | → | obj1
  “string” | → | “element1”
  Example 1: | "Dead" HEAD returns "D". |
  Example 2: | The following program takes a list of coordinates { A B C } that define a right triangle, and finds |
  the length of the hypotenuse AC: « DUP HEAD SWAP REVLIST HEAD - ABS » For example, entering { (0,0) (0,3) (3,4) } returns 5.

See also

  TAIL

## HEADER→ not in app ↑ top

PDF page 223 · printed page 3-103

Type

  Command

Description

  Header size: Returns the current size of the header in lines.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Header size |

See also

  →HEADER

## →HEADER not in app ↑ top

PDF page 223 · printed page 3-103

Type

  Command

Description

  Header size: Sets the current size of the header in lines: to 0, 1, or 2 lines.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  Header size | → |

See also

  HEADER→

## HELP not in app ↑ top

PDF page 223 · printed page 3-103

Type

  Command

Description

  Similar to CASCMD, displays a list of CAS operations. Selecting one with OK displays help for it, an example of the operation, and the option to copy the example to the command line. More details are given in Appendix C and Appendix H of the User’s Guide.

See also

  CASCMD

## HERMITE in app ↑ top

PDF page 224 · printed page 3-104

Type

  Function

Description

  Returns the nth Hermite polynomial.

Input

  A non-negative integer.

Output

  The corresponding polynomial expression.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the Hermite polynomial with degree 4.

  Command | HERMITE(4)
  Result | 16*X^4-48*X^2+12

See also

  LEGENDRE, TCHEBYCHEFF

## HESS not in app ↑ top

PDF page 224 · printed page 3-104

Type

  Command

Description

  Returns the Hessian matrix and the gradient of an expression with respect to the specified variables.

Input

  Level 2/Argument 1: An expression. Level 1/Argument 2: A vector of the variables.

Output

  Level 3/Item 1: The Hessian matrix with respect to the specified variables. Level 2/Item 2: The gradient with respect to the variables. Level 1/Item 3: The vector of the variables.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the Hessian matrix, and the gradient with respect to each variable, of the expression: t2 + 2tu2.

  Command | HESS(T^2+2*T*U^2, [T, U])
  Result | {[[2, 2*(2*U)], [2*(2*U), 2*(2*T)]], [2*T+2*U^2, 2*T*(2*U)], [T, U]}

See also

  CURL, DIV

## HEX in app ↑ top

PDF page 224 · printed page 3-104

Type

  Command

Description

  Hexadecimal Mode Command: Selects hexadecimal base for binary integer operations. (The default base is decimal.) Binary integers require the prefix #. Binary integers entered and returned in hexadecimal base automatically show the suffix h. If the current base is not hexadecimal, then you can enter a hexadecimal number by ending it with h. It will be displayed in the current base when it is entered. The current base does not affect the internal representation of binary integers as unsigned binary numbers.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  None

See also

  BIN, DEC, OCT, RCWS, STWS

## HILBERT in app ↑ top

PDF page 225 · printed page 3-105

Type

  Command

Description

  Returns a square Hilbert matrix of the specified order.

Input

  A positive integer, representing the order.

Output

  The Hilbert matrix of the specified order.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the order 3 Hilbert matrix.

      Command:          HILBERT(3)

  1 1 1 -- -- 2 3 1 1 1 -- -- -- 2 3 4 1 1 1 -- -- -- 3 4 5

See also

  CON, IDN, RANM, VANDERMONDE

## HISTOGRAM not in app ↑ top

PDF page 225 · printed page 3-105

Type

  Command

Description

  Histogram Plot Type Command: Sets the plot type to HISTOGRAM. When the plot type is HISTOGRAM, the DRAW command creates a histogram using data from one column of the current statistics matrix (reserved variable ΣDAT). The column is specified by the first parameter in the reserved variable ΣPAR (using the XCOL command). The plotting parameters are specified in the reserved variable PPAR, which has the form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type HISTOGRAM, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is either a name specifying a label for the horizontal axis, or a list containing such a name and two numbers that specify the minimum and maximum values of the data to be plotted. The default value of indep is X.
  - res is a real number specifying the bin size, in user-unit coordinates, or a binary integer specifying the bin size in pixels. The default value is 0, which specifies the bin size to be 1/13 of the difference between the specified minimum and maximum values of the data.
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command HISTOGRAM places the command name HISTOGRAM in PPAR.
  - depend is a name specifying a label for the vertical axis. The default value is Y. The frequency of the data is plotted as bars, where each bar represents a collection of data points. The base of each bar spans the values of the data points, and the height indicates the number of data points. The width of each bar is specified by res. The overall maximum and minimum values for the data can be specified by indep; otherwise, the values in (xmin, ymin) and (xmax, ymax) are used.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## HISTPLOT not in app ↑ top

PDF page 226 · printed page 3-106

Type

  Command

Description

  Draw Histogram Plot Command: Plots a frequency histogram of the specified column in the current statistics matrix (reserved variable ΣDAT). The data column to be plotted is specified by XCOL and is stored as the first parameter in the reserved variable ΣPAR. If no data column is specified, column 1 is selected by default. The y-axis is autoscaled and the plot type is set to HISTOGRAM. HISTPLOT plots relative frequencies, using 13 bins as the default number of partitions. The RES command lets you specify a different number of bins by specifying the bin width. To plot a frequency histogram with numerical frequencies, store the frequencies in ΣDAT and execute BINS and then BARPLOT. When HISTPLOT is executed from a program, the graphics display, which shows the resultant plot, does not persist unless PICTURE, PVIEW (with an empty list argument), or FREEZE is subsequently executed.

Input/Output

  None

See also

  BARPLOT, BINS, FREEZE, PICTURE, PVIEW, RES, SCATRPLOT, XCOL

## HMS– not in app ↑ top

PDF page 226 · printed page 3-106

Type

  Command

Description

  Hours-Minutes-Seconds Minus Command: Returns the difference of two real numbers, where the arguments and the result are interpreted in hours-minutes-seconds format. The format for HMS (a time or an angle) is H.MMSSs, where:

  - H is zero or more digits representing the integer part of the number (hours or degrees).
  - MM are two digits representing the number of minutes.
  - SS are two digits representing the number of seconds.
  - s is zero or more digits (as many as allowed by the current display mode) representing the decimal fractional part of seconds.
Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  HMS1 | HMS2 | → | HMS1 – HMS2

See also

  HMS→, →HMS, HMS+

## HMS+ in app ↑ top

PDF page 226 · printed page 3-106

Type

  Command

Description

  Hours-Minutes-Seconds Plus Command: Returns the sum of two real numbers, where the arguments and the result are interpreted in hours-minutes-seconds format.

  The format for HMS (a time or an angle) is H.MMSSs, where:

  - H is zero or more digits representing the integer part of the number (hours or degrees).
  - MM are two digits representing the number of minutes.
  - SS are two digits representing the number of seconds.
  - s is zero or more digits (as many as allowed by the current display mode) representing the decimal fractional part of seconds.
Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  HMS1 | HMS2 | → | HMS1 + HMS2

See also

  HMS→, →HMS, HMS–

## HMS→ in app ↑ top

PDF page 227 · printed page 3-107

Type

  Command

Description

  Hours-Minutes-Seconds to Decimal Command: Converts a real number in hours-minutes- seconds format to its decimal form (hours or degrees with a decimal fraction). The format for HMS (a time or an angle) is H.MMSSs, where:

  - H is zero or more digits representing the integer part of the number (hours or degrees).
  - MM are two digits representing the number of minutes.
  - SS are two digits representing the number of seconds.
  - s is zero or more digits (as many as allowed by the current display mode) representing the decimal fractional part of seconds.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  HMS | → | x

See also

  →HMS, HMS+, HMS–

## →HMS in app ↑ top

PDF page 227 · printed page 3-107

Type

  Command

Description

  Decimal to Hours-Minutes-Seconds Command: Converts a real number representing hours or degrees with a decimal fraction to hours-minutes-seconds format. The format for HMS (a time or an angle) is H.MMSSs, where:

  - H is zero or more digits representing the integer part of the number.
  - MM are two digits representing the number of minutes.
  - SS are two digits representing the number of seconds.
  - s is zero or more digits (as many as allowed by the current display mode) representing the decimal fractional part of seconds.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | HMS

See also

  HMS→, HMS+, HMS–

## HOME in app ↑ top

PDF page 228 · printed page 3-108

Type

  Command

Description

  HOME Directory Command: Makes the HOME directory the current directory.

Input/Output

  None

See also

  CRDIR, PATH, PGDIR, UPDIR

## HORNER in app ↑ top

PDF page 228 · printed page 3-108

Type

  Command

Description

  Executes a Horner scheme on a polynomial. That is, for a given polynomial P, and a number r, HORNER returns QUOT(P/(x–r)), r and also P(r)

Input

  Level 2/Argument 1: A polynomial, P. Level 1/Argument 2: A number, r.

Output

  Level 3/Item 1: QUOT(P/(x–r)) Level 2/Item 2: r Level 1/Item 3: P(r), the remainder of the division process.

Flags

  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

  For r = 3, find the result of executing a Horner scheme on the following polynomial: 2 x +x+1

  Command | HORNER(X^2+X+1,3)
  Results | (X+4,3,13)

## i not in app ↑ top

PDF page 228 · printed page 3-108

Type

  Function

Description

  i Function: Returns the symbolic constant i or its numerical representation, (0, 1).

Flags

  Symbolic Constants (–2), Numerical Results (–3)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | `i` |
  → | (0,1) |

See also

  e, MAXR, MINR, π

## IABCUV in app ↑ top

PDF page 228 · printed page 3-108

Type

  Command

Description

  Returns a solution in integers u and v of au + bv = c, where a, b, and c are integers.

Input

  Level 3/Argument 1: the value of a. Level 2/Argument 2: the value of b. Level 1/Argument 3: the value of c.

Output

  Level 2/Item 1: The value for u. Level 1/Item 2: The value for v.

Flags

  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

  Find a solution in integers of the equation: 6a + 11b = 3

  Command | IABCUV(6,11,3)
  Result | {6,-3}

See also

  ABCUV, IEGCD

## IBASIS not in app ↑ top

PDF page 229 · printed page 3-109

Type

  Command

Description

  Determines the basis of the intersection between two vector spaces.

Input

  Two lists of vectors

Output

  A list of vectors.

Flags

  Exact mode must be set (flag –105 clear).

Example

  Find a vector of a basis of the intersection of the vector sub-spaces defined by [1, 2] and [2, 4]

  Command | IBASIS({[1,2]}, {[2,4]})
  Result | {[1,2]}

See also

  BASIS

## IBERNOULLI in app ↑ top

PDF page 229 · printed page 3-109

Type

  Function

Description

  Returns the nth Bernoulli number for a given integer n.

Input

  Level 1/Argument 1: an integer.

Output

  Level 1/Item 1: The corresponding nth Bernoulli number for the integer. For numbers greater than about 40 the calculation can take a long time.

Flags

  Numeric mode must not be set (flag –3 clear).

## IBP not in app ↑ top

PDF page 229 · printed page 3-109

Type

  Command

Description

  Performs integration by parts on a function. The function must be able to be represented as a product of two functions, where the antiderivative of one of the functions is known: f(x) = u(x).v’(x) Note that the command is designed for use in RPN mode only.

Input

  Level 2: The integrand expressed as a product of two functions, u(x).v’(x) Level 1: The antiderivative of one of the component functions, v(x).

Output

  Level 2: u(x)v(x) Level 1: -u`(x)v(x)

Flags

  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

  Use integration by parts to calculate the following: ∫ x cos ( x ) dx Command 1: Apply the IBP command in RPN mode: Level 2: X*COS(X) Level 1: SIN(X)

      Result:    Level 2: SIN(X)*X

  Level 1: -SIN(X) Command 2: Apply the INTVX command to level 1, -SIN(X)

      Result:    Level 2: SIN(X)*X

  Level 1: COS(X) Command 3: Press + to add the result to the value at level 2 to obtain the final result.

      Result:    SIN(X)*(X)+COS(X)

See also

  INTVX, INT, PREVAL, RISCH

## ICHINREM in app ↑ top

PDF page 230 · printed page 3-110

Type

  Command

Description

  Solves a system of two congruences in integers using the Chinese Remainder theorem.

Input

  Level 2/Argument 1: A vector of the first value and the modulus. Level 1/Argument 2: A vector of the second value and the modulus.

Output

  A vector of the solution.

Flags

  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 the following system of congruences: x ≡ 2 Modulo 3 x ≡ 1 Modulo 5

  Command | ICHINREM([2,3],[1,5])
  Results | [-4, 15]

See also

  CHINREM

## IDN in app ↑ top

PDF page 230 · printed page 3-110

Type

  Command

Description

  Identity Matrix Command: Returns an identity matrix; that is, a square matrix with its diagonal elements equal to 1 and its off-diagonal elements equal to 0. The result is either a new square matrix, or an existing square matrix with its elements replaced by the elements of the identity matrix, according to the argument.

  - Creating a new matrix: If the argument is a real number n, a new real identity matrix is returned, with its number of rows and number of columns equal to n.
  - Replacing the elements of an existing matrix: If the argument is a square matrix, an identity matrix of the same dimensions is returned. If the original matrix is complex, the resulting identity matrix will also be complex, with diagonal values (1,0).
  - If the argument is a name, the name must identify a variable containing a square matrix. In this case, the elements of the matrix are replaced by those of the identity matrix (complex if the original matrix is complex).
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → | [[ R-matrixidentity ]]
  [[ matrix ]] | → | [[ matrixidentity ]]
  `name` | → | [[ matrixidentity ]]

See also

  CON

## IDIV2 in app ↑ top

PDF page 231 · printed page 3-111

Type

  Command

Description

  For two integers, a and b, returns the integer part of a/b, and the remainder, r.

Input

  Level 2/Argument 1: a. Level 1/Argument 2: b.

Output

  Level 2/Item 1: The integer part of a/b. Level 1/Item 2: The remainder.

Flags

  Numeric mode must not be set (flag –3 clear). Radians mode must be set (flag –17 set).

Example

  Return the integer part and the remainder of 11632/864.

  Command | IDIV2(11632,864)
  Result | {13,400}

See also

  DIV2, IQUOT

## IEGCD in app ↑ top

PDF page 231 · printed page 3-111

Type

  Command

Description

  Given two integers x and y, returns three integers, a, b, and c, such that: ax+by=c where c is the GCD of x and y.

Input

  Level 2/Argument 1: x. Level 1/Argument 2: y.

Output

  Level 3/Item 1: c. Level 2/Item 2: a. Level 1/Item 3: b. Note the order, c is first.

Flags

  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

  Find a, b and c such that a18 + b24 = c, where c is the GCD of 18 and 24.

  Command | IEGCD(18,24)
  Result | {6,-1,1}

See also

  ABCUV, EGCD, IABCUV

## IF not in app ↑ top

PDF page 232 · printed page 3-112

Type

  Command Operation

Description

  IF Conditional Structure Command: Starts IF … THEN … END and IF … THEN … ELSE … END conditional structures. Conditional structures, used in combination with program tests, enable a program to make decisions.

  - IF … THEN … END executes a sequence of commands only if a test returns a nonzero (true) result. The syntax is: IF test-clause THEN true-clause END IF begins the test clause, which must return a test result to the stack. THEN removes the test result from the stack. If the value is nonzero, the true clause is executed. Otherwise, program execution resumes following END.
  - IF … THEN … ELSE … END executes one sequence of commands if a test returns a true (nonzero) result, or another sequence of commands if that test returns a false (zero) result. The syntax is: IF test-clause THEN true-clause ELSE false-clause END IF begins the test clause, which must return a test result to the stack. THEN removes the test result from the stack. If the value is nonzero, the true clause is executed. Otherwise, the false clause is executed. After the appropriate clause is executed, execution resumes following END. In RPL mode, the test clause can be a command sequence (for example, A B ‰) or an algebraic (for example, `A‰B`). If the test clause is an algebraic, it is automatically evaluated to a number (→NUM or EVAL isn’t necessary).
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  IF | → |
  THEN | T/F | →
  END IF
  THEN | T/F | →
  ELSE →
  END →

See also

  CASE, ELSE, END, IFERR, THEN

## IFERR not in app ↑ top

PDF page 232 · printed page 3-112

Type

  Command

Description

  If Error Conditional Structure Command: Starts IFERR … THEN … END and IFERR … THEN … ELSE … END error trapping structures. Error trapping structures enable program execution to continue after a “trapped” error occurs.

  - IFERR … THEN … END executes a sequence of commands if an error occurs. The syntax of IFERR … THEN … END is: IFERR trap-clause THEN error-clause END If an error occurs during execution of the trap clause: 1 The error is ignored. 2 The remainder of the trap clause is discarded.

  3 The key buffer is cleared. 4 If any or all of the display is “frozen” (by FREEZE), that state is cancelled. 5 If Last Arguments is enabled, the arguments to the command that caused the error are returned to the stack. 6 Program execution jumps to the error clause. The commands in the error clause are executed only if an error is generated during execution of the trap clause.

  - IFERR … THEN … ELSE … END executes one sequence of commands if an error occurs or another sequence of commands if an error does not occur. The syntax of IFERR … THEN … ELSE … END is: IFERR trap-clause THEN error-clause ELSE normal-clause END If an error occurs during execution of the trap clause, the same six events listed above occur. If no error occurs, execution jumps to the normal clause at the completion of the trap clause.
Flags

  Last Arguments (–55)

Input/Output

  None

Example

      The following program uses IFERR much like the built-in linear system of equations solver. The program takes a result vector and a matrix of coefficients and returns a least-squares solution to the equations.
          « → a b « IFERR a b / THEN LSQ END » »

See also

  CASE, ELSE, END, IF, THEN

## IFFT not in app ↑ top

PDF page 233 · printed page 3-113

Type

  Command

Description

  Inverse Discrete Fourier Transform Command: Computes the one- or two-dimensional inverse discrete Fourier transform of an array. If the argument is an N-vector or an N × 1 or 1 × N matrix, IFFT computes the one-dimensional inverse transform. If the argument is an M × N matrix, IFFT computes the two-dimensional inverse transform. M and N must be integral powers of 2. The one-dimensional inverse discrete Fourier transform of an N-vector Y is the N-vector X where: 2πik n

      –1         --------------

  1

                                                     X n = --- ∑ Y k e                      ,i =   –1

  k=0

  for n = 0, 1, …, N – 1. The two-dimensional inverse discrete Fourier transform of an M × N matrix Y is the M × N matrix X where: M – 1

       – 1           2πi km 2πi ln

  ---------------- ----------------- 1 X mn = -------- ∑ ∑ Y kl e M e

       , i =                         –1

  M k = 0 l = 0

  for m = 0, 1, …, M – 1 and n = 0, 1, …, N – 1. The discrete Fourier transform and its inverse are defined for any positive sequence length. However, the calculation can be performed very rapidly when the sequence length is a power of two, and the resulting algorithms are called the fast Fourier transform (FFT) and inverse fast Fourier transform (IFFT). The IFFT command uses truncated 15-digit arithmetic and intermediate storage, then rounds the result to 12-digit precision.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ array ]1 | → | [ array ]2

See also

  FFT

## IFT in app ↑ top

PDF page 234 · printed page 3-114

Type

  Command

Description

  IF-THEN Command: Executes obj if T/F is nonzero. Discards obj if T/F is zero. IFT lets you execute in stack syntax the decision-making process of the IF … THEN … END conditional structure. The “true clause” is obj in argument 2 (level 1).

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  T/F | obj | → | It depends!

Example

      « X 0 > "Positive" IFT » puts "Positive" in level 1 if X contains a positive real number.

See also

  IFTE

## IFTE in app ↑ top

PDF page 234 · printed page 3-114

Type

  Function

Description

  IF-THEN-ELSE Function: Executes the obj in argument 2 or level 2 if T/F is nonzero. Executes the obj in argument 3 or level 1 if T/F is zero. IFTE lets you execute in stack syntax the decision-making process of the IF … THEN … ELSE … END conditional structure. The “true clause” is objtrue in argument 2 or level 2. The “false clause” is objfalse in argument 3 or level 1. IFTE is also allowed in algebraic expressions, with the following syntax: IFTE(test,true-clause,false-clause) When an algebraic containing IFTE is evaluated, its first argument test is evaluated to a test result. If it returns a nonzero real number, true-clause is evaluated. If it returns zero, false-clause is evaluated.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  T/F | objtrue | objfalse | → | It depends!
  Example 1: The command sequence X 0 Š "Positive" "Negative" IFTE leaves
  "Positive" on the stack if X contains a non-negative real number, or "Negative" if X contains a negative real number.
      Example 2:      The algebraic `IFTE(X‹0,SIN(X)/X,1)` returns the value of sin(x)/x, even for x = 0,
  which would normally cause an Infinite Result error.

See also

  IFT

## ILAP in app ↑ top

PDF page 234 · printed page 3-114

Type

  Function

Description

  Returns the inverse Laplace transform of an expression. The expression must evaluate to a rational fraction.

Input

  A rational expression.

Output

  The inverse Laplace transformation of the expression.

Flags

  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). 1

Example

  Find the inverse Laplace transform of:------------------2 (x – 5 )

  Command | ILAP(1/(X-5)^2)
  Result | X*EXP(5*X)

See also

  LAP, LAPL

## IM in app ↑ top

PDF page 235 · printed page 3-115

Type

  Function

Description

  Imaginary Part Function: Returns the imaginary part of its complex argument. If the argument is an array, IM returns a real array, the elements of which are equal to the imaginary parts of the corresponding elements of the argument array. If the argument array is real, all of the elements of the result array are zero.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | 0
  (x, y) | → | y
  [ R-array ] | → | [ R-array ]
  [ C-array ] | → | [ R-array ]
  `symb` | → | `IM(symb)`

See also

  C→R, RE, R→C

## IMAGE not in app ↑ top

PDF page 235 · printed page 3-115

Type

  Command

Description

  Computes the basis of the image (also called the range) of a linear application f.

Input

  A matrix representing a linear application f in terms of the standard basis.

Output

  A list of vectors representing a basis of the image of f.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). 112 213 314

Example

  Find the image of

  Command | IMAGE([1,1,2] [2,1,3] [3,1,4])
  Result | {[1,0,-1] [0,1,2]}

See also

  BASIS, KER

## INCR in app ↑ top

PDF page 236 · printed page 3-116

Type

  Command

Description

  Increment Command: Takes a variable, adds 1, stores the new value back into the original variable, and returns the new value. The value in name must be a real number or an integer.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → | xincrement

Example

      If 35.7 is stored in A, `A` INCR returns 36.7.

See also

  DECR

## INDEP not in app ↑ top

PDF page 236 · printed page 3-116

Type

  Command

Description

  Independent Variable Command: Specifies the independent variable and its plotting range. The specification for the independent variable name and its plotting range is stored as the third parameter in the reserved variable PPAR. If the argument to INDEP is a:

  - Global variable name, that name replaces the independent variable entry in PPAR.
  - List containing a global name, that name replaces the independent variable name but leaves unchanged any existing plotting range.
  - List containing a global name and two real numbers, that list replaces the independent variable entry.
  - List containing two real numbers, or two real numbers from levels 1 and 2, those two numbers specify a new plotting range, leaving the independent variable name unchanged. (LASTARG returns a list, even if the two numbers were entered separately.) The default entry is X.
Input/Output

  Level 2/Argument 1 |  | Level 1/Argument 2 | Level 1/Item 1
  --- | --- | --- | ---
  `global` | → |  |
  { global } | → |  |
  { global xstart xend } | → |  |
  {xstart xend } | → |  |
  xstart | xend | → |

See also

  DEPND

## INFORM not in app ↑ top

PDF page 236 · printed page 3-116

Type

  Command

Description

  User-Defined Dialog Box Command: Creates a user-defined input form (dialog box). INFORM creates a standard dialog box based upon the following specifications:

  Variable | Function
  --- | ---
  “title” | Title. This appears at the top of the dialog box.
  Variable | Function
  {s1 s2 … sn} | Field definitions. A field definition (sx) can have two formats: “label”, a field

  label, or { “label” “helpInfo” type0 type1 … typen }, a field label with optional help text that appears near the bottom of the screen, and an optional list of valid object types for that field. If object types aren’t specified, all object types are valid. For information about object types, see the TYPE command. When creating a multi-column dialog box, you can span columns by using an empty list as a field definition. A field that appears to the left of an empty field automatically expands to fill the empty space.

      format              Field format information. This is the number col or a list of the form { col tabs

  }: col is the number of columns the dialog box has, and tabs optionally specifies the number of tab stops between the labels and the highlighted fields. This list can be empty. col defaults to 1 and tabs defaults to 3.

      { resets }          Default values displayed when RESET is selected. Specify reset values in the

  list in the same order as the fields were specified. To specify no value, use the NOVAL command as a place holder. This list can be empty.

      { init }            Initial values displayed when the dialog box appears. Specify initial values in

  the list in the same order as the fields were specified. To specify no value, use the NOVAL command as a place holder. This list can be empty.

  If you exit the dialog box by selecting OK or `, INFORM returns the field values { vals } in item 1 or level 2, and puts a 1 in item 2 or level 1. (If a field is empty, NOVAL is returned as a place holder.) If you exit the dialog box by selecting CANCEL or B, INFORM returns 0.

Input/Output

  L5/A1 | L4/A2 | L 3 A3 | L2/A4 | L1/A5 |  | L2/I1 | L1/I2
  --- | --- | --- | --- | --- | --- | --- | ---
  “title” | {s1 s2 ... sn } | format | {resets } | {init } | → { vals } | 1 |
  “title” | {s1 s2 ... sn } | format | {resets } | {init } | → | 0 |
  L = Level; A = Argument; I = item

Example

  Place the following five lines on the stack and run INFORM: "The Title" { { "ONE" "Name?" 2 } { } { "TWO" "Age?" } { "THREE" "Lucky numbers?" 5 } } { 2 } { NOVAL NOVAL { 1 2 3 } } { "Charlotte" NOVAL { 4 5 6 } }

See also

  CHOOSE, INPUT, NOVAL, TYPE

## INPUT not in app ↑ top

PDF page 237 · printed page 3-117

Type

  Command

Description

  Input Command: Prompts for data input to the command line and prevents the user access to stack operations. When INPUT is executed, the stack or history area is blanked and program execution is suspended for data input to the command line. The contents of “stack prompt” are displayed at the top of the screen. Depending on the second argument (level 1), the command line may also contain the contents of a string, or it may be empty. Pressing ` resumes program execution and returns the contents of the command line in string form.

  In its general form, the second argument (level 1) for INPUT is a list that specifies the content and interpretation of the command line. The list can contain one or more of the following parameters, in any order:

  - "command-line prompt", whose contents are placed on the command line for prompting when the program pauses.
  - Either a real number, or a list containing two real numbers, that specifies the initial cursor position on the command line: – A real number n at the nth character from the left end of the first row (line) of the command line. A positive n specifies the insert cursor; a negative n specifies the replace cursor. 0 specifies the end of the command-line string. – A list that specifies the initial row and column position of the cursor: the first number in the list specifies a row in the command line (1 specifies the first row of the command line); the second number counts by characters from the left end of the specified line. 0 specifies the end of the command-line string in the specified row. A positive row number specifies the insert cursor; a negative row number specifies the replace cursor.
  - One or more of the parameters ALG, α, or V, entered as unquoted names: – ALG activates Algebraic/Program-entry mode. – α specifies alpha lock. – V verifies if the characters in the result string "result", without the " delimiters, compose a valid object or objects. If the result-string characters do not compose a valid object or objects, INPUT displays the Invalid Syntax warning and prompts again for data. You can choose to specify as few as one of the argument 2 (level 1) list parameters. The default states for these parameters are:
  - Blank command line.
  - Insert cursor placed at the end of the command-line prompt string.
  - Program-entry mode.
  - Result string not checked for invalid syntax. If you specify only a command-line prompt string for the second argument (level 1), you don’t need to put it in a list.
Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  “stack prompt” | “command-line prompt” | → | “result”
  “stack prompt” | { listcommand-line } | → | “result”

See also

  PROMPT, STR→

## INT not in app ↑ top

PDF page 238 · printed page 3-118

Type

  Function

Description

  Calculates the antiderivative of a function for a given variable, at a given point.

Input

  Level 3/Argument 1: A function. Level 2/Argument 2: The variable to obtain the derivative with respect to. Level 1/Argument 3: The point at which to calculate the antiderivative. This point can be a variable or an expression.

Output

  The antiderivative of the function for the given variable, at the point you specified.

Flags

  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

  Find the integral of sin(x) with respect to x, at the point where x=y.

  Command | INT(SIN(X),X,Y)
  Result | -COS(Y)

See also

  INTVX, RISCH

## INTEGER not in app ↑ top

PDF page 239 · printed page 3-119

Type

  Command

Description

  Displays a menu or list of CAS integer operations.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## INTVX in app ↑ top

PDF page 239 · printed page 3-119

Type

  Function

Description

  Finds the antiderivative of a function symbolically, with respect to the current default variable.

Input

  An expression.

Output

  The antiderivative of the expression.

Flags

  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

  Find the antiderivative of the following: 2 x ln x

  Command | INTVX(X^2*LN(X))
  Result | 1/3*X^3*LN(X)+(-1/9)*X^3

See also

  IBP, RISCH, PREVAL

## INV in app ↑ top

PDF page 239 · printed page 3-119

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 -

  2, 2 - ---------------- 2 ----------------2 - -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.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | 1/z
  [[ matrix ]] | → | [[ matrix ]]–1
  `symb` | → | `INV(symb)`
  x_unit | → | 1/x_1/unit

See also

  SINV, /

## INVMOD in app ↑ top

PDF page 240 · printed page 3-120

Type

  Function

Description

  Performs modular inversion on an object modulo the current modulus.

Input

  An object.

Output

  The modular inverse of the object.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Solve the following for x, modulo the default modulus, 13. ( 2x ≡ 1 )

  Command | INVMOD(2)
  Result | -6

## IP in app ↑ top

PDF page 240 · printed page 3-120

Type

  Function

Description

  Integer Part Function: Returns the integer part of its argument. The result has the same sign as the argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | n
  x_unit | → | n_unit
  `symb` | → | `IP(symb)`

Example

  32.3_m IP returns 32_m.

See also

  FP

## IQUOT in app ↑ top

PDF page 240 · printed page 3-120

Type

  Function

Description

  Returns the integer quotient (or Euclidean quotient) of two integers. That is, given two integers, a and b, returns the integer q, such that: a = qb + r, and 0 ≤ r < b

Input

  Level 2/Argument 1: The dividend. Level 1/Argument 2: The divisor.

Output

  The integer quotient.

Flags

  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).

See also

  QUOT, IDIV2

## IREMAINDER in app ↑ top

PDF page 241 · printed page 3-121

Type

  Function

Description

  Returns the remainder of an integer division.

Input

  Level 2/Argument 1: The numerator. Level 1/Argument 2: The denominator.

Output

  The remainder.

Flags

  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).

See also

  IDIV2

## ISOL in app ↑ top

PDF page 241 · printed page 3-121

Type

  Command

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 calculator provides an inverse. Thus ISOL cannot solve IP(x)=0 for x, since IP has no inverse. ISOL is identical to SOLVE.

Flags

  Principal Solution (–1), Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  `symb1` | `global` | → | `symb2`

See also

  COLCT, EXPAN, QUAD, SHOW, SOLVE

## ISOM not in app ↑ top

PDF page 241 · printed page 3-121

Type

  Command

Description

  Determine the characteristics of a 2-d or 3-d linear isometry.

Input

  A square matrix representing a linear isometry.

Output

  A vector and/or an angle that represent the symmetry of the matrix, and 1 (for a direct isometry) or –1 (for an indirect isometry).

Flags

  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 1:     Analyze the isometry given by the matrix

  0 –1 –1 0

  Command | ISOM([[0,-1] [-1,0]])
  Result | { [1, 1] –1}, meaning the matrix represents a symmetry in the line y = –x, and this is an indirect

  isometry.

  1 – 3 -- --------- 2 2

  3 | 1
  --- | ---
  ------ | --
  2 | 2
  Example 2: | Analyze the isometry given by the matrix
  Command: | ISOM([[1/2, -√3/2][√3/2, 1/2]])
  Result: | { π/3, 1 }, meaning the matrix represents a rotation of π/3 radians, and this is a direct isometry.

See also

  MKISOM

## ISPRIME? in app ↑ top

PDF page 242 · printed page 3-122

Type

  Function

Description

  Tests if a number is prime. For numbers of the order of 1014 or greater (to be exact, greater than 341550071728321), tests if the number is a pseudoprime; this has a chance of less than 1 in 1012 of wrongly identifying a number as a prime.

Input

  An object that evaluates to an integer or a whole real number.

Output

  1 (True) if the number is prime, 0 (False) if it is not.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

See also

  NEXTPRIME, PREVPRIME

## I→R not in app ↑ top

PDF page 242 · printed page 3-122

Type

  Function

Description

  Converts an integer into a real number.

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 or real number.

Output

  Level 1/Item 1: The integer converted to a real number.

See also

  →NUM, R→I, XNUM

## JORDAN not in app ↑ top

PDF page 242 · printed page 3-122

Type

  Command

Description

  Diagonalization, or Jordan cycle decomposition, of a matrix. Computes the eigenvalues, eigenvectors, minimum polynomial, and characteristic polynomial of a matrix.

Input

  An n × n matrix.

Output

  Level 4/Item 1: The minimum polynomial. Level 3/Item 2: The characteristic polynomial. Level 2/Item 3: A list of characteristic spaces tagged by the corresponding eigenvalue (either a

  vector or a list of Jordan chains, each of them ending with an "Eigen:"-tagged eigenvector). Level 1/Item 4: An array of the eigenvalues, with multiplicities

Flags

  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

  Perform the following diagonalization:

  Command | JORDAN([1,1][1,1])
  Result | {X^2-2*X,

  X^2-2*X, {0: [1,-1]}, 2: [1,1]} [0,2]}

## KER not in app ↑ top

PDF page 243 · printed page 3-123

Type

  Command

Description

  Computes the basis of the kernel of a linear application f.

Input

  A matrix representing a linear application f in terms of the standard basis.

Output

  A list of vectors representing a basis of the kernel (also called the nullspace) of f.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). 112 213 314

Example

  Find the kernel of

  Command | KER([1,1,2][2,1,3][3,1,4])
  Result | {[1,1,-1]}

See also

  BASIS, IMAGE

## KERRM not in app ↑ top

PDF page 243 · printed page 3-123

Type

  Command

Description

  Kermit Error Message Command: Returns the text of the most recent Kermit error packet. If a Kermit transfer fails due to an error packet sent from the connected Kermit device to the calculator, then executing KERRM retrieves and displays the error message. (Kermit errors not in packets are retrieved by ERRM rather than KERRM.)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | “error message” |

See also

  FINISH, KGET, PKT, RECN, RECV, SEND, SERVER

## KEY not in app ↑ top

PDF page 243 · printed page 3-123

Type

  Command

Description

  Key Command: Returns a test result and, if a key is pressed, returns the row-column location xn m of that key. KEY returns a false result (0) to item 2 (stack level 1) until a key is pressed. When a key is pressed, it returns a true result (1) to item 2 (stack level 1) and xn m to item 1 (stack level 2). The result xn m is a two- or three-digit number that identifies the row and column location of the key just pressed.

  Unlike WAIT, which returns a three-digit number that identifies alpha and shifted keyboard planes, KEY returns the row-column location of any key pressed, including !, …, and ~.

Input/Output

  | Level 1/Argument 1 | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  → | xn m | 1 |
  → | 0 |  |

Example

      The program « DO UNTIL KEY END 81 SAME » returns 1 to the stack if the ! key is pressed while the indefinite loop is running.

See also

  WAIT, KEYEVAL

## KEYEVAL not in app ↑ top

PDF page 244 · printed page 3-124

Type

  Command

Description

  Actions the specified key press. You input a number, in the format ab.c, that represents the key. In the number ab.c:

  - a is the row coordinate number, where row 1 is the top-most row.
  - b is the column number, where column 1 is the left-most column.
  - c is the shift state of the key, i.e., whether it is normal, alpha-shifted, left shifted, etc. The shift state representations are as follows: 1: Normal function.

  2: Left-shift function. | 21: Left shift-and-hold function.
  --- | ---
  3. Right-shift function. | 31: Right shift-and-hold function.
  4. Alpha-function. | 41: Alpha shift-and-hold function.
  5. Alpha-left-shift function. | 51: Alpha-left-shift-and-hold function.
  6. Alpha-right-shift function. | 61: Alpha-right-shift-and-hold function.

  The sign of the input controls whether USER mode key assignments are used. Positive inputs specify the USER mode key definition. Negative inputs specify the default system keyboard.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nn.n | → |

Example

  Turn the calculator off using a command.

  Command | KEYEVAL(101.3)
  Result | The calculator is turned off.

## →KEYTIME not in app ↑ top

PDF page 244 · printed page 3-124

Type

  Command

Description

  Sets a new keytime value. Keytime is the time after a keypress during which further keypresses will not be actioned. It is measured in ticks, with valid values between 0 and 4096 ticks. If you experience key bounce, you can increase the value of keytime. If you experience lost keystrokes when rapidly hitting the same key in succession, you can decrease the value of keytime. The default is 1138 ticks.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  time | → |

See also

  KEYTIME→

  KEYTIME→

Type

  Command

Description

  Displays the current keytime value. Keytime is the time after a keypress during which further keypresses will not be actioned. It is measured in ticks. If you experience key bounce, you can increase the value of keytime.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | time |

See also

  →KEYTIME

## KGET not in app ↑ top

PDF page 245 · printed page 3-125

Type

  Command

Description

  Kermit Get Command: Used by a local Kermit to get a Kermit server to transmit the named object(s). To rename an object when the local device gets it, include the old and new names in an embedded list. For example, {{ AAA BBB }} KGET gets the variable named AAA but changes its name to BBB. {{ AAA BBB } CCC } KGET gets AAA as BBB and gets CCC under its own name. (If the original name is not legal on the calculator, enter it as a string.)

Flags

  I/O Device (–33), RECV Overwrite (–36), I/O Messages (–39), I/O Device for Wire (–78)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |
  “name” | → |
  { nameold namenew } | → |
  { name1 ... namen } | → |
  {{ nameold namenew } name ... } →

See also

  BAUD, CKSM, FINISH, PARITY, RECN, RECV, SEND, SERVER, TRANSIO

## KILL in app ↑ top

PDF page 245 · printed page 3-125

Type

  Command

Description

  Cancel Halted Programs Command: Cancels all currently halted programs. If KILL is executed within a program, that program is also canceled. Canceled programs cannot be resumed. KILL cancels only halted programs and the program from which KILL was executed, if any. Commands that halt programs are HALT and PROMPT. Suspended programs cannot be canceled. Commands that suspend programs are INPUT and WAIT.

Input/Output

  None

See also

  CONT, DOERR, HALT, PROMPT

## LABEL not in app ↑ top

PDF page 245 · printed page 3-125

Type

  Command

Description

  Label Axes Command: Labels axes in PICT with x- and y-axis variable names and with the minimum and maximum values of the display ranges. The horizontal axis name is chosen in the following priority order: 1. If the axes parameter in the reserved variable PPAR is a list, then the x-axis element from that list is used.

  2. If axes parameter is not a list, then the independent variable name in PPAR is used. The vertical axis name is chosen in the following priority order: 1. If the axes parameter in PPAR is a list, then the y-axis element from that list is used. 2. If axes is not a list, then the dependent variable name from PPAR is used.

Input/Output

  None

See also

  AXES, DRAW, DRAX

## LAGRANGE not in app ↑ top

PDF page 246 · printed page 3-126

Type

  Command

Description

  Returns the interpolating polynomial of minimum degree for a set of pairs of values. For two pairs, DROITE will fit a straight line.

Input

  A two × n matrix of the n pairs of values.

Output

  The polynomial that results from the Lagrange interpolation of the data.

Flags

  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

  Find an interpolating polynomial for the data (1,6), (3,7), (4,8), (2,9)

  Command: | LAGRANGE([[1,3,4,2][6,7,8,9]])
  --- | ---
  3 | 2

  8x – 63x + 151 x – 60 -------------------------------------------------------

       Result:                                    6

See also

  DROITE

## LANGUAGE→ not in app ↑ top

PDF page 246 · printed page 3-126

Type

  Command

Description

  Language: Returns the language that is currently set. 0 for English, 1 for French, and 2 for Spanish.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | value |

See also

  →LANGUAGE →LANGUAGE

Type

  Command

Description

  Language: Sets the language for things such as error messages: 0 for English, 1 for French, and 2 for Spanish.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  value | → |

See also

  LANGUAGE→

## LAP not in app ↑ top

PDF page 247 · printed page 3-127

Type

  Function

Description

  Performs a Laplace transform on an expression with respect to the current default variable.

Input

  An expression.

Output

  The Laplace transform of the expression.

Flags

  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

  Find the Laplace transform of ex.

  Command | LAP(EXP(X))
  Result | 1/(X-1)

See also

  ILAP, LAPL

## LAPL not in app ↑ top

PDF page 247 · printed page 3-127

Type

  Command

Description

  Returns the Laplacian of a function with respect to a list of variables.

Input

  Level 2/Argument 1:An expression. Level 1/Argument 2: A vector of variables.

Output

  The Laplacian of the expression with respect to the variables.

Flags

  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

  Find, and simplify, the Laplacian of the following expression: x e cos ( zy )

      Command:       LAPL(EXP(X)*COS(Z*Y),[X,Y,Z])

  EXPAND(ANS(1))

      Result:        -((Y^2+Z^2-1)*EXP(X)*COS(Z*Y))

See also

  LAP, ILAP

## LAST in app ↑ top

PDF page 247 · printed page 3-127

Type

  Command

Description

  Returns copies of the arguments of the most recently executed command. LAST is provided for compatibility with the HP 28S. LAST is the same as LASTARG.

Flags

  Last Arguments (–55)

Input/Output

  | Level 1 | Level n | 7 | Level 1
  --- | --- | --- | --- | ---
  → | objn | … | obj1 |

See also

  ANS, LASTARG

## LASTARG in app ↑ top

PDF page 248 · printed page 3-128

Type

  Command

Description

  Returns copies of the arguments of the most recently executed command. The objects return to the same stack levels that they originally occupied. Commands that take no arguments leave the current saved arguments unchanged. When LASTARG follows a command that evaluates an algebraic expression or program, the last arguments saved are from the evaluated algebraic expression or program, not from the original command.

Flags

  Last Arguments (–55)

Input/Output

  | Level 1 | Level n | 7 | Level 1
  --- | --- | --- | --- | ---
  → | objn | … | obj1 |

See also

  ANS, LAST

## LCD→ not in app ↑ top

PDF page 248 · printed page 3-128

Type

  Command

Description

  LCD to Graphics Object Command: Returns the current stack and menu display as a 131 × 80 (on the HP 50g and 49g+) or 131 × 64 (on the HP 48gII) graphics object.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | grob |

Example

  LCD→ PICT STO PICTURE returns the current display to level 1 as a graphics object, stores it in PICT, then shows the image in the Picture environment.

See also

  →GROB, →LCD

## →LCD not in app ↑ top

PDF page 248 · printed page 3-128

Type

  Command

Description

  Graphics Object to LCD Command: Displays the specified graphics object with its upper left pixel in the upper left corner of the display. If the graphics object is larger than 131 × 72 (on the HP 50g and 49g+) or 131 × 56 (on the HP 48gII), it is truncated.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  grob | → |

See also

  BLANK, →GROB, LCD→

## LCM in app ↑ top

PDF page 248 · printed page 3-128

Type

  Function

Description

  Returns the least common multiple of two objects.

Input

  Level 2/Argument 1: An expression, a number, or object that evaluates to a number. Level 1/Argument 2: An expression, a number, or object that evaluates to a number.

Output

  The least common multiple of the objects.

Flags

  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

  Find the least common multiple of the following two expressions: 2 x –1 x–1

  Command | LCM(X^2-1,X-1)
  Results | X^2-1

See also

  GCD

## LCXM not in app ↑ top

PDF page 249 · printed page 3-129

Type

  Command

Description

  From a program with two arguments, builds a matrix with the specified number of rows and columns, with aij = f(i,j).

Input

  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.

Output

  The resulting matrix.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

      Build a 2 × 3 matrix with aij=i+2j.
          Command:      LCXM(2,3,« →I J `I+2*J`»)
          3 5 7 4 6 8 Result:

## LDEC not in app ↑ top

PDF page 249 · printed page 3-129

Type

  Command

Description

  Solves a linear differential equation with constant coefficients, or a system of first order linear differential equations with constant coefficients.

Input

  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.

Output

  The solution.

Flags

  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 in app ↑ top

PDF page 250 · printed page 3-130

Type

  Function

Description

  Returns the nth degree Legendre polynomial.

Input

  An integer, n.

Output

  The nth Legendre polynomial.

Flags

  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

## LGCD not in app ↑ top

PDF page 250 · printed page 3-130

Type

  Function

Description

  Returns the greatest common divisor of a list of expressions or values.

Input

  A list of expressions or values.

Output

  Level 2/Item 1: The list of elements. Level 1/Item 2: The greatest common divisor of the elements.

Flags

  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).

See also

  GCD

## LIBEVAL not in app ↑ top

PDF page 250 · printed page 3-130

Type

  Command

Description

  Evaluate Library Function Command: Evaluates unnamed library functions. WARNING: Use extreme care when executing this function. Using LIBEVAL with random addresses will almost always cause a memory loss. Do not use this function unless you know what you are doing. #nfunction is of the form lllfffh, where lll is the library number, and fff the function number.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #nfunction | → |

See also

  EVAL, FLASHEVAL, SYSEVAL

## LIBS not in app ↑ top

PDF page 250 · printed page 3-130

Type

  Command

Description

  Libraries Command: Lists the title, number, and port of each library attached to the current directory. The title of a library often takes the form LIBRARY-NAME : Description. A library without a title is displayed as " ".

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | {“title”, nlib, nport, ...,“title”, nlib, nport } |

See also

  ATTACH, DETACH lim

Type

  Function

Description

  Returns the limit of a function as its argument approaches a specified value. Expands and simplifies an algebraic expression.

Input

  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.

Output

  The limit of the expression at the limit point.

Flags

  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

  Find the following limit:

                                   n      n

  - lim - x--------------- –y

                    - x → y- x – y

          Command:      lim((X^N-Y^N)/(X-Y), X=Y)
          Result:       N*EXP(N*LN(Y))/Y

See also

  SERIES

## LIMIT in app ↑ top

PDF page 251 · printed page 3-131

Type

  Function

Description

  Returns the limit of a function as its argument approaches a specified value. This function is identical to the lim function, described above, and is included to ensure backward-compatibility with the HP 49G calculator.

## LIN in app ↑ top

PDF page 251 · printed page 3-131

Type

  Command

Description

  Linearizes expressions involving exponential terms.

Input

  An expression.

Output

  The linearized expression.

Flags

  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

  Linearize the following expression: x y 4 x(e e )

  Command | LIN(X*(EXP(X)*EXP(Y))^4)
  Result | X*EXP(4X+4Y)

See also

  TEXPAND

## LINE not in app ↑ top

PDF page 252 · printed page 3-132

Type

  Command Operation

Description

  Draw Line Command: Draws a line in PICT between the input coordinates.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  (x1, y1) | (x2, y2) | → |
  { #n1, #m1} | { #n2, #m2} | → |

Example

      This program: « (0,0) (2,3) LINE { # 0d # 0d } PVIEW 7 FREEZE » draws a line in PICT between two user-unit coordinates, displays PICT with pixel coordinate { # 0d # 0d } at the upper left corner of the picture display, and freezes the display.

See also

  ARC, BOX, TLINE

## ΣLINE not in app ↑ top

PDF page 252 · printed page 3-132

Type

  Command

Description

  Regression Model Formula Command: Returns an expression representing the best fit line according to the current statistical model, using X as the independent variable name, and explicit values of the slope and intercept taken from the reserved variable ΣPAR. For each curve fitting model, the following table indicates the form of the expression returned by ΣLINE, where m is the slope, x is the independent variable, and b is the intercept.

  Model | Form of Expression
  --- | ---
  LINFIT | mx + b
  LOGFIT | m ln(x) + b
  EXPFIT | bemx
  PWRFIT | bxm

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | `symbformula` |

Example

      If the current model is EXPFIT, and if the slope is 5 and the intercept 3, ΣLINE returns `3*EXP(5*X)`.

See also

  BESTFIT, COLΣ, CORR, COV, EXPFIT, LINFIT, LOGFIT, LR, PREDX, PREDY, PWRFIT, XCOL, YCOL

## LINFIT in app ↑ top

PDF page 252 · printed page 3-132

Type

  Command

Description

  Linear Curve Fit Command: Stores LINFIT as the fifth parameter in the reserved variable ΣPAR, indicating that subsequent executions of LR are to use the linear curve fitting model. LINFIT is the default specification in ΣPAR.

Input/Output

  None

See also

  BESTFIT, EXPFIT, LOGFIT, LR, PWRFIT

## LININ not in app ↑ top

PDF page 253 · printed page 3-133

Type

  Function

Description

  Linear Test Function: Tests whether an algebraic is structurally linear for a given variable. If any two subexpressions containing a variable (name) are combined only with addition and subtraction, and any subexpression containing the variable is at most multiplied or divided by another factor not containing the variable, the algebraic (symb) is determined to be linear for that variable. LININ returns a 1 if the algebraic is linear for the variable, and a 0 if not.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  `symb` | `name` | → | 0/1
  Example 1: `(X+1)*(Y^-2^Z)+(X/(3-Z^3)` `X` LININ returns 1.
  Example 2: `(X^2-1)/(X+1)` `X` LININ returns 0.
  (Although this equation yields a linear equation when factored, LININ tests the equation as described above.)

## LINSOLVE not in app ↑ top

PDF page 253 · printed page 3-133

Type

  Command

Description

  Solves a system of linear equations.

Input

  Level 2/Argument 1: An array of equations. Level1/Argument 2: A vector of the variables to solve for.

Output

  Level 3/Item 1: The system of equations, as a list containing the inputs as above. Level 2/Item 2: A list of the pivot points. Level 1/Item 3: The solution.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

See also

  DESOLVE, SOLVE, MSLV

## LIST→ in app ↑ top

PDF page 253 · printed page 3-133

Type

  Command

Description

  List to Stack Command: Takes a list of n objects and returns each object to a separate level, and returns the total number of objects to item n+1 (stack level 1). The command OBJ→ also provides this function.

Input/Output

          Level 1/Argument 1           Leveln+1/Item1 ...    Level2/Itemn          Level1/Itemn+1

          { obj1, ...,objn } →   obj1 ...                            objn                    n

See also

  ARRY→, DTAG, EQ→, →LIST, OBJ→, STR→

## →LIST in app ↑ top

PDF page 253 · printed page 3-133

Type

  Command

Description

  Stack to List Command: Takes n specified objects and returns a list of those objects.

Input/Output

  Leveln+1/Argument1 7Level2/Argumentn |  | Level1/Argumentn+1 | Level 1/Item 1
  --- | --- | --- | ---
  obj1 … objn n | → | { obj1, … ,objn } |

Example

      The program « DEPTH →LIST `A` STO » combines the entire contents of the stack into a list that is stored in variable A.

See also

  →ARRY, LIST→, →STR, →TAG, →UNIT

  ΔLIST

Type

  Command

Description

  List Differences Command: Returns the first differences of the elements in a list. Adjacent elements in the list must be suitable for mutual subtraction.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { list } | → | { differences }
  Example 1: | { 4 20 1 17 60 91 } ›LIST returns { 16 -19 16 43 31 }. |
  Example 2: | { A B C 1 2 3 } ›LIST returns { `B-A` `C-B` `1-C` 1 1 }. |
  Example 3: | { `A+3` `X/5` `Y^4` } ›LIST returns { `X/5-(A+3)` `Y^4-X/5` }. |

See also

  ΣLIST, ΠLIST, STREAM

## ΠLIST in app ↑ top

PDF page 254 · printed page 3-134

Type

  Command

Description

  List Product Command: Returns the product of the elements in a list. The elements in the list must be suitable for mutual multiplication.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { list } | → | product
  Example 1: | { 5 8 2 } œLIST returns 80. |
  Example 2: | { A B C 1 } œLIST returns `A*B*C`. |

See also

  ΣLIST, ΔLIST, STREAM

## ΣLIST in app ↑ top

PDF page 254 · printed page 3-134

Type

  Command

Description

  List Sum Command: Returns the sum of the elements in a list. The elements in the list must be suitable for mutual addition.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { list } | → | sum
  Example 1: | { 5 8 2 } ΣLIST returns 15. |
  Example 2: | { A B C 1 } ΣLIST returns `A+B+C+1`. |

See also

  ΠLIST, ΔLIST, STREAM

## LN in app ↑ top

PDF page 254 · printed page 3-134

Type

  Analytic function

Description

  Natural Logarithm Analytic Function: Returns the natural (base e) logarithm of the argument.

  For x = 0 or (0, 0), an Infinite Result exception occurs, or, if flag –22 is set, –MAXR is returned. The inverse of EXP is a relation, not a function, since EXP sends more than one argument to the same result. The inverse relation for EXP is the general solution: LN(Z)+2*π*i*n1 The function LN is the inverse of a part of EXP, a part defined by restricting the domain of EXP such that: each argument is sent to a distinct result, and each possible result is achieved. The points in this restricted domain of EXP are called the principal values of the inverse relation. LN in its entirety is called the principal branch of the inverse relation, and the points sent by LN to the boundary of the restricted domain of EXP form the branch cuts of LN. The principal branch used by the calculator for LN was chosen because it is analytic in the regions where the arguments of the real-valued inverse function are defined. The branch cut for the complex-valued natural log function occurs 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 LN. The graph of the domain shows where the branch cut occurs: the heavy solid line marks one side of the cut, while the feathered lines mark the other side of the cut. The graph of the range shows where each side of the cut is mapped under the function. These graphs show the inverse relation LN(Z)+2*π*i*n1 for the case n1=0. For other values of n1, the horizontal band in the lower graph is translated up (for n1 positive) or down (for n1 negative). Taken together, the bands cover the whole complex plane, which is the domain of EXP.

  You can view these graphs with domain and range reversed to see how the domain of EXP is restricted to make an inverse function possible. Consider the vertical band in the lower graph as the restricted domain Z = (x,y). EXP sends this domain onto the whole complex plane in the range W = (u,v) = EXP(x,y) in the upper graph.

Flags

  Principal Solution (–1), Numerical Results (–3), Infinite Result Exception (–22)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | ln z
  `symb` | → | `LN(symb)`

See also

  ALOG, EXP, ISOL, LNP1, LOG

## LNAME in app ↑ top

PDF page 256 · printed page 3-136

Type

  Command

Description

  Returns the variable names contained in a symbolic expression.

Input

  A symbolic expression.

Output

  Level 2/Argument 1: The original expression. Level 1/Argument 2: A vector containing the variable names. The variable names are sorted by length, longest first, and ones of equal length are sorted alphabetically.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  List the variables in the expression COS(B)/2*A + MYFUNC(PQ) + 1/T.

  Command | LNAME(COS(B)/2*A + MYFUNC(PQ) + INV(T))
  Result | {COS(B)/2*A + MYFUNC(PQ) + 1/T, [MYFUNC,PQ,A,B,T]}

See also

  LVAR

## LNCOLLECT in app ↑ top

PDF page 256 · printed page 3-136

Type

  Command

Description

  Simplifies an expression by collecting logarithmic terms. For symbolic powers does not perform the same simplification as EXP2POW; compare example 2 here with example 2 for EXP2POW.

Input

  An expression.

Output

  The simplified expression.

Flags

  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 1:   Simplify the following expression:

  2(ln(x)+ln(y))

  Command | LNCOLLECT(2(LN(X)+LN(Y))
  Result | LN(X^2*Y) Example 2: Compare the effect of LNCOLLECT with the effect of EXP2POW on the expression e n·ln(x)
  Command | LNCOLLECT(EXP(N*LN(X))
  Result | EXP(N*LN(X))

See also

  EXP2POW, TEXPAND

## LNP1 in app ↑ top

PDF page 256 · printed page 3-136

Type

  Analytic function

Description

  Natural Log of x Plus 1 Analytic Function: Returns ln(x + 1). For values of x close to zero, LNP1(x) returns a more accurate result than does LN(x+1). Using LNP1 allows both the argument and the result to be near zero, and it avoids an intermediate result near 1. The calculator can express numbers within 10-449 of zero, but within only 10–11 of 1. For values of x < –1, an Undefined Result error results. For x=–1, an Infinite Result exception occurs, or, if flag –22 is set, LNP1 returns –MAXR.

Flags

  Numerical Results (–3), Infinite Result Exception (–22)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | ln (x + 1)
  `symb` | → | `LNP1(symb)`

See also

  EXPM, LN

## LOCAL not in app ↑ top

PDF page 257 · printed page 3-137

Type

  Command

Description

  Creates one or more local variables. This command is intended mainly for use in Algebraic mode; it can not be single stepped when a program containing it is being debugged in Algebraic mode.

Input

  Level 1/Argument 1: A list of one or more local variable names (names beginning with the local variable identifier ←), each one followed by an equals sign and the value to be stored in it. Any variable not followed by an equal sign and a value is set equal to zero.

Output

  Level 1/Item 1: The input list.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Create local variables ←A and ←B and store the values 0 in the first and 2 in the second.

  Command | LOCAL({←A,←B=2})
  Result | {←A,←B=2}

See also

  DEF, STORE, UNBIND

## LOG in app ↑ top

PDF page 257 · printed page 3-137

Type

  Analytic function

Description

  Common Logarithm Analytic Function: Returns the common logarithm (base 10) of the argument. For x=0 or (0, 0), an Infinite Result exception occurs, or, if flag –22 is set (no error), LOG returns –MAXR. The inverse of ALOG is a relation, not a function, since ALOG sends more than one argument to the same result. The inverse relation for ALOG is the general solution: LOG(Z)+2*π*i*n1/2.30258509299 The function LOG is the inverse of a part of ALOG, a part defined by restricting the domain of ALOG such that 1) each argument is sent to a distinct result, and 2) each possible result is achieved. The points in this restricted domain of ALOG are called the principal values of the inverse relation. LOG in its entirety is called the principal branch of the inverse relation, and the points sent by LOG to the boundary of the restricted domain of ALOG form the branch cuts of LOG. The principal branch used by the calculator for LOG(z) was chosen because it is analytic in the regions where the arguments of the real-valued function are defined. The branch cut for the complex-valued LOG function occurs where the corresponding real-valued function is undefined. The principal branch also preserves most of the important symmetries. You can determine the graph for LOG(z) from the graph for LN (see LN) and the relationship log z = ln z / ln 10.

Flags

  Principal Solution (–1), Numerical Results (–3), Infinite Result Exception (–22)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | log z
  `symb` | → | `LOG(symb)`

See also

  ALOG, EXP, ISOL, LN

## LOGFIT in app ↑ top

PDF page 258 · printed page 3-138

Type

  Command

Description

  Logarithmic Curve Fit Command: Stores LOGFIT as the fifth parameter in the reserved variable ΣPAR, indicating that subsequent executions of LR are to use the logarithmic curve-fitting model. LINFIT is the default specification in ΣPAR.

Input/Output

  None

See also

  BESTFIT, EXPFIT, LINFIT, LR, PWRFIT

## LQ in app ↑ top

PDF page 258 · printed page 3-138

Type

  Command

Description

  LQ Factorization of a Matrix Command: Returns the LQ factorization of an m × n matrix. LQ factors an m × n matrix A into three matrices:

  - L is a lower m × n trapezoidal matrix.
  - Q is an n × n orthogonal matrix.
  - P is a m × m permutation matrix. Where P × A = L × Q.
Input/Output

  Level 1/Argument 1 |  | Level 3/Item 1 | Level 2/Item 2 | Level 1/Item 3
  --- | --- | --- | --- | ---
  [[ matrix ]]A | → | [[ matrix ]]L | [[ matrix ]]Q | [[ matrix ]]P

See also

  LSQ, QR

## LR not in app ↑ top

PDF page 258 · printed page 3-138

Type

  Command

Description

  Linear Regression Command: Uses the currently selected statistical model to calculate the linear regression coefficients (intercept and slope) for the selected dependent and independent variables in the current statistics matrix (reserved variable ΣDAT). The columns of independent and dependent data are specified by the first two elements in the reserved variable ΣPAR, set by XCOL and YCOL, respectively. (The default independent and dependent columns are 1 and 2.) The selected statistical model is the fifth element in ΣPAR. LR stores the intercept and slope (untagged) as the third and fourth elements, respectively, in ΣPAR. The coefficients of the exponential (EXPFIT), logarithmic (LOGFIT), and power (PWRFIT) models are calculated using transformations that allow the data to be fitted by standard linear regression. The equations for these transformations appear in the table below, where b is the intercept and m is the slope. The logarithmic model requires positive x-values (XCOL), the exponential model requires positive y-values (YCOL), and the power model requires positive x- and y-values.

  Model | Transformation
  --- | ---
  Logarithmic | y = b + m ln(x)
  Exponential | ln(y) = ln(b) + mx
  Power | ln(y) = ln(b) + m ln(x)

Input/Output

      Level 1/Argument 1                     Level 2/Item 1          Level 1/Item 2

  →

                               Intercept: x1        Slope: x2

See also

  BESTFIT, COLΣ, CORR, COV, EXPFIT, ΣLINE, LINFIT, LOGFIT, PREDX, PREDY, PWRFIT, XCOL, YCOL

## LSQ in app ↑ top

PDF page 259 · printed page 3-139

Type

  Command

Description

  Least Squares Solution Command: Returns the minimum norm least squares solution to any system of linear equations where A × X = B. If B is a vector, the resulting vector has a minimum Euclidean norm ||X|| over all vector solutions that minimize the residual Euclidean norm ||A × X – B||. If B is a matrix, each column of the resulting matrix, Xi, has a minimum Euclidean norm ||Xi|| over all vector solutions that minimize the residual Euclidean norm ||A × Xi – Bi||. If A has less than full row rank (the system of equations is underdetermined), an infinite number of solutions exist. LSQ returns the solution with the minimum Euclidean length. If A has less than full column rank (the system of equations is overdetermined), a solution that satisfies all the equations may not exist. LSQ returns the solution with the minimum residuals of A × X – B.

Flags

  Singular Values (–54)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  [ array ]B | [[ matrix ]]A | → | [ array ]x
  [[ matrix ]]B | [[ matrix ]]A | → | [[ matrix ]]x

See also

  LQ, RANK, QR, /

## LU in app ↑ top

PDF page 259 · printed page 3-139

Type

  Command

Description

  LU Decomposition of a Square Matrix Command: Returns the LU decomposition of a square matrix. When solving an exactly determined system of equations, inverting a square matrix, or computing the determinant of a matrix, the calculator factors a square matrix into its Crout LU decomposition using partial pivoting. The Crout LU decomposition of A is a lower-triangular matrix L, an upper-triangular matrix U with ones on its diagonal, and a permutation matrix P, such that P × A = L × U. The results satisfy P × A ≅ L × U.

Input/Output

  Level 1/Argument 1 |  | Level 3/Item 1 | Level 2/Item 2 | Level 1/Item 3
  --- | --- | --- | --- | ---
  [[ matrix ]]A | → | [[ matrix ]]L | [[ matrix ]]U | [[ matrix ]]P

See also

  DET, INV, LSQ, /

## LVAR not in app ↑ top

PDF page 260 · printed page 3-140

Type

  Command

Description

  Returns a list of variables in an algebraic object. Differs from LNAME above in that functions of variables, such as COS(X) or LN(AB) are returned, instead of the variable names, X or AB. INV() and SQ() are not treated as functions. Compare the example here with the same example in LNAME.

Input

  An algebraic object.

Output

  Level 2/Item 1: The algebraic object. Level 1/Item 2: A list which includes both the original expression and a vector containing the variable names. Variable names include functions of variables, as described above. The names are sorted by length, longest first, and ones of equal length are sorted alphabetically.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  List the variables and function names in the expression COS(B)/2*A + MYFUNC(PQ) + 1/T.

  Command | LVAR(COS(B)/2*A + MYFUNC(PQ) + INV(T))
  Result | {COS(B)/2*A + MYFUNC(PQ) + 1/T, [MYFUNC(PQ),COS(B),A,T]}

See also

  LNAME

## MAD in app ↑ top

PDF page 260 · printed page 3-140

Type

  Command

Description

  Returns details of a square matrix, including the information needed to obtain the adjoint matrix. The adjoint matrix is obtained by multiplying the inverse matrix by the determinant.

Input

  A square matrix

Output

  Level 4/Item 1: The determinant. Level 3/Item 2: The formal inverse. Level 2/Item 3: The matrix coefficients of the polynomial, p, defined by (xi–a)p(x)=m(x)i, where a is the matrix, and m is the characteristic polynomial of a. Level 1/Item 4: The characteristic polynomial.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Obtain the adjoint matrix of: 0 –1 1 0

  Command | MAD([[0, -1][1, 0]])
  Result | {1,[[0, 1][-1, 0]],{[[1, 0][0, 1]], [[0, -1][1, 0]]}, X^2+1}

  The determinant is 1, so the adjoint is the second item[[0, 1][-1, 0]].

See also

  LNAME

## MAIN not in app ↑ top

PDF page 261 · printed page 3-141

Type

  Command

Description

  Displays the main menu (or list) of CAS operations. This displays the CASCFG command, the ALGB, ARIT, DIFF, EXP&LN, MATHS MATR, REWRITE and TRIGO menu commands described in this part of the Command Reference, and the CMPLX and SOLVER menu commands described in the Full Command and Function Reference (Chapter 3). Other menus are not shown because they are within the submenus given by MAIN. More details are given in Appendix K of the User’s Guide.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## MANT in app ↑ top

PDF page 261 · printed page 3-141

Type

  Function

Description

  Mantissa Function: Returns the mantissa of the argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | ymant
  `symb` | → | `MANT(symb)`

See also

  SIGN, XPON

## MAP in app ↑ top

PDF page 261 · printed page 3-141

Type

  Command

Description

  Applies a specified program to a list of objects or values. If one of the objects is a list, MAP will apply the program recursively to the items in the inner list.

  - Level 1/Argument 2 contains the program to apply to the objects or values.
  - Level 2/Argument 1 contains the list, matrix, or vector.
Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  {list}1 | «program» | → | {list}2

Example

      { 1 2 { 3 4 } } « →STR » MAP returns { "1" "2" { "3" "4" } }.

## ↓MATCH not in app ↑ top

PDF page 261 · printed page 3-141

Type

  Command

Description

  Match Pattern Down Command: Rewrites an expression that matches a specified pattern. ↓MATCH rewrites expressions or subexpressions that match a specified pattern `symbpat`. An optional condition, `symbcond`, can further restrict whether a rewrite occurs. A test result is also returned to indicate if command execution produced a rewrite; 1 if it did, 0 if it did not.

  The pattern `symbpat` and replacement `symbrepl` can be normal expressions; for example, you can replace .5 with `SIN(π/6)`. You can also use a “wildcard” in the pattern (to match any subexpression) and in the replacement (to represent that expression). A wildcard is a name that begins with &, such as the name `&A`, used in replacing `SIN(&A+&B)` with `SIN(&A)*COS(&B)+COS(&A)*SIN(&B)`. Multiple occurrences of a particular wildcard in a pattern must match identical subexpressions. ↓MATCH works from top down; that is, it checks the entire expression first. This approach works well for expansion. An expression expanded during one execution of ↓MATCH will contain additional subexpressions, and those subexpressions can be expanded by another execution of ↓MATCH. Several expressions can be expanded by one execution of ↓MATCH provided none is a subexpression of any other.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 2/Item 1 |
  --- | --- | --- | --- | ---
  Level 1/Item
  `symb1` | { `symbpat` `symbrepl` } | → | `symb2` | 0/1
  `symb1` { `symbpat` `symbrepl` `symbcond` } → `symb2` 0/1
  Example 1: .5 { .5 `SIN(π/6)` } ↓MATCH returns `SIN(π/6)` to level 2 and 1 to level
  1. Example 2: `SIN(U+V)` { `SIN(&A+&B)` `SIN(&A)*COS(&B)+COS(&A)*SIN(&B)` } ↓MATCH returns `SIN(U)*COS(V)+COS(U)*SIN(V)` to level 2 and 1 to level 1. Example 3: This sequence: `SIN(5*Z)` { `SIN(&A+&B)` `Σ(K=0,&A,COMB(&A,K)*SIN(K*π)*COS(&B^(&A-K)*SIN(&B)^K)` `ABS(IP(&A))==&A` } ↓MATCH returns `Σ(K=0,5,COMB(5,K)*SIN(K*π)*COS(Z^(5-K)*SIN(Z)^K)` to level 2 and 1 to level 1.

See also

  ↑MATCH

## ↑MATCH not in app ↑ top

PDF page 262 · printed page 3-142

Type

  Command

Description

  Bottom-Up Match and Replace Command: Rewrites an expression. ↑MATCH rewrites expressions or subexpressions that match a specified pattern `symbpat`. An optional condition, `symbcond`, can further restrict whether a rewrite occurs. A test result is also returned to indicate if command execution produced a rewrite; 1 if it did, 0 if it did not. The pattern `symbpat` and replacement `symbrepl` can be normal expressions; for example, you can replace `SIN(π/6)` with `1/2`. You can also use a “wildcard” in the pattern (to match any subexpression) and in the replacement (to represent that expression). A wildcard is a name that begins with &, such as the name `&A`, used in replacing `SIN(&A+π)` with `–SIN(&A)`. Multiple occurrences of a particular wildcard in a pattern must match identical subexpressions. ↑MATCH works from bottom up; that is, it checks the lowest level (most deeply nested) subexpressions first. This approach works well for simplification. A subexpression simplified during one execution of ↑MATCH will be a simpler argument of its parent expression, so the parent expression can be simplified by another execution of ↑MATCH. Several subexpressions can be simplified by one execution of ↑MATCH provided none is a subexpression of any other.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | --- | ---
  `symb1` | { `symbpat`, `symbrepl` } | → | `symb2` | 0/1
  `symb1` | { `symbpat`, `symbrepl`, `symbcond` } → | `symb2` 0/1 |  |
  Example 1: This sequence: `SIN(π/6)` { `SIN(π/6)` `1/2` } ↑MATCH returns
  `1/2` to level 2 and 1 (indicating a replacement was made) to level 1.
      Example 2:      This sequence: `SIN(X+π)` { `SIN(&A+π)` `-SIN(&A)` } ↑MATCH
  returns `-SIN(X)` to level 2 and 1 to level 1.
      Example 3:      This sequence: `W+ƒ(SQ(5))` { `ƒ(SQ(&A))` `&A` `&AŠ0` } ↑MATCH
  returns `W+5` to level 2 and 1 to level 1.

See also

  ↓MATCH

## MATHS not in app ↑ top

PDF page 263 · printed page 3-143

Type

  Command

Description

  Displays a menu or list of CAS mathematics submenus. Details are given in Appendix J of the User’s Guide.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the submenus as a list. If the flag is set, displays the submenus as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## MATR not in app ↑ top

PDF page 263 · printed page 3-143

Type

  Command

Description

  Displays a menu or list containing the CAS commands for matrix operations.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MODULAR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## MAX in app ↑ top

PDF page 263 · printed page 3-143

Type

  Function

Description

  Maximum Function: Returns the greater of two inputs.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | max(x,y)
  x | `symb` | → | `MAX(x, symb)`
  `symb` | x | → | `MAX(symb, x)`
  `symb1` | `symb2` | → | `MAX(symb1, symb2)`
  x_unit1 | y_unit2 | → | max(x_unit1, y_unit2)
  Example 1: 10 -23 MAX returns 10.
  Example 2: -10 -23 MAX returns -10.
  Example 3: 1_m 9_cm MAX returns 1_m.

See also

  MIN

## MAXR in app ↑ top

PDF page 264 · printed page 3-144

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 calculator.

Flags

  Symbolic Constants (–2), Numerical Results (–3)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | `MAXR` |
  → | 9.99999999999E499 |

See also

  e, i, MINR, π

## MAXΣ in app ↑ top

PDF page 264 · printed page 3-144

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.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xmax |
  → | [xmax1 xmax2 ... xmaxm ] |

See also

  BINS, MEAN, MINΣ, SDEV, TOT, VAR

## MCALC not in app ↑ top

PDF page 264 · printed page 3-144

Type

  Command

Description

  Make Calculated Value Command: Designates a variable as a calculated variable for the multiple- equation solver. MCALC designates a single variable, a list of variables, or all variables as calculated values.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |
  { list } | → |
  "ALL" | → |

See also

  MUSER

## MEAN in app ↑ top

PDF page 265 · printed page 3-145

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 -- ∑ x i ni = 1

  where xi is the ith coordinate value in a column, and n is the number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xmean |
  → | [xmean1, xmean2, ..., xmeanm ] |

See also

  BINS, MAXΣ, MINΣ, SDEV, TOT, VAR

## MEM in app ↑ top

PDF page 265 · printed page 3-145

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.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | x |

See also

  BYTES

## MENU not in app ↑ top

PDF page 265 · printed page 3-145

Type

  Command Operation

Description

  Display Menu Command: Displays a built-in menu or a library menu, or defines and displays a custom menu. A built-in menu is specified by a real number xmenu. The format of xmenu is mm.pp, where mm is the menu number and pp is the page of the menu. If pp doesn’t correspond to a page of the specified menu, the first page is displayed. Library menus are specified in the same way as built-in menus, with the library number serving as the menu number. Custom menus are specified by a list of the form { "label-object" action-object } or a name containing a list (namedefinition). Either argument is stored in reserved variable CST, and the custom menu is subsequently displayed. MENU takes any object as a valid argument and stores it in CST. However, the calculator can build a custom menu only if CST contains a list or a name containing a list. Thus, if an object other

  than a list or name containing a list is supplied to MENU, a Bad Argument Type error will occur when the calculator attempts to display the custom menu. A full list of all menus can be found in Appendix H of this reference.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xmenu | → |
  { listdefinition } | → |
  `namedefinition` | → |
  obj | → |
  Example 1: | 5 MENU displays the first page of the MTH MATR NORM menu. |
  Example 2: | 48.02 MENU displays the second page of the UNITS MASS menu. |
  Example 3: | { A 123 "ABC" } MENU displays the custom menu defined by the list argument. |
  Example 4: | `MYMENU` MENU displays the custom menu defined by the name argument. |

See also

  RCLMENU, TMENU

## MENUXY not in app ↑ top

PDF page 266 · printed page 3-146

Type

  Command

Description

  Displays a function key menu of computer algebra commands in a specified range.

Input

  Level 2/Argument 1: The number of the first command in the range to be displayed. Level 1/Argument 2: The number of the last command in the range to be displayed. Arguments below 0 are treated as 0; arguments above 140 are treated as 140.

Output

  On the function key menu, the computer algebra commands in the range specified. NOVAL is returned in Algebraic mode. This list gives the number of each operation that can be displayed by the command. The complete menu below can be generated by MENUXY(0,140). Items 127 through to 135 allow access from the top row of keys to CAS menus.

        Number                                        Operation
            0-5        EXPAND        FACTOR               SUBST       DERVX      INTVX          lim
            6-11       TAYLOR0       SERIES               SOLVEVX     PLOT       PLOTADD        IBP
            12-17      PREVAL        RISCH                DERIV       DESOLVE    LAP            ILAP
            18-23      LDEC          TEXPAND              LIN         TSIMP      LNCOLLECT      EXPLN
            24-29      SINCOS        TLIN                 TCOLLECT    TRIG       TRIGCOS        TRIGSIN
            30-35      TRIGTAN       TAN2SC               HALFTAN     TAN2SC2    ATAN2S         ASIN2T
            36-41      ASIN2C        ACOS2S               DIV2        IDIV2      QUOT           IQUOT
            42-47      REMAINDER     IREMAINDER           GCD         LCM        EGCD           IEGCD
            48-53      ABCUV         IABCUV               LGCD        SIMP2      PARTFRAC       PROPFRAC
            54-59      PTAYL         HORNER               EULER       PA2B2      CHINREM        ICHINREM
            60-65      ISPRIME?      NEXTPRIME            PREVPRIME   SOLVE      ZEROS          FCOEF
            66-71      FROOTS        FACTORS              DIVIS       TRAN       HADAMARD       rref
            72-77      REF           AXM                  AXL         QXA        AXQ            GAUSS
            78-83      SYLVESTER     PCAR                 JORDAN      MAD        LINSOLVE       VANDERMONDE
            84-89      HILBERT       LCXM                 DIV         CURL       LAPL           HESS
            90-95      LEGENDRE      TCHEBYCHEFF          HERMITE     LAGRANGE   FOURIER        SIGNTAB
            96-101     TABVAR        TABVAL               DIVPC       TRUNC      SEVAL          TEVAL
            102-107    MAP           XNUM                 XQ          REORDER    LVAR           FXND

          108-113    EXLR           LNAME              ADDTMOD         SUBTMOD    MULTMOD         DIVMOD
          114-119    DIV2MOD        POWMOD             INVMOD          GCDMOD     EXPANDMOD       FACTORMOD
          120-125    RREFMOD        MODSTO             MENUXY          KEYEVAL    GROBADD         SCROLL
          126-131    CASCFG         MAIN               ALGB            CMPLX      TRIGO           MATR
          132-137    DIFF           ARIT               SOLVER          EXP&LN     EPSX0           ?
          138-140    ∞              PROMPTSTO          VER

Example

  Display a menu containing ATAN2S, ASIN2T, ASIN2C and ACOS2S.

  Command | MENUXY(34,37)
  Result | The four functions are displayed above the A to D keys. In Algebraic mode, NOVAL is

  returned as item 1.

See also

  MENU, TMENU

## MERGE in app ↑ top

PDF page 267 · printed page 3-147

Type

  Command

Description

  Do not use this command, a carry-over from the HP 48SX for handling plug-in RAM cards.

## MIN in app ↑ top

PDF page 267 · printed page 3-147

Type

  Function

Description

  Minimum Function: Returns the lesser of two inputs.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | min(x,y)
  x | `symb` | → | `MIN(x, symb)`
  `symb` | x | → | `MIN(symb, x)`
  `symb1` | `symb2` | → | `MIN(symb1, symb2)`
  x_unit1 | y_unit2 | → | min(x_unit1, y_unit2)
  Example 1: 10 23 MIN returns 10.
  Example 2: -10 -23 MIN returns -23.
  Example 3: 1_m 9_cm MIN returns 9_cm.

See also

  MAX

## MINEHUNT not in app ↑ top

PDF page 267 · printed page 3-147

Type

  Command

Description

  Starts the MINEHUNT game. In this game, you are standing in the upper-left corner of an 8x16 battlefield grid. Your mission is to travel safely to the lower-right corner, avoiding invisible mines along the way. The game tells you how many mines are under the eight squares adjacent to your position.

  Use the number or arrow keys to cross the battlefield one square at a time (use 7, 9, 1, and 3to move diagonally.) You can exit the game at any time by pressing −(the $ key). To interrupt and save a game, press K. This creates a variable MHpar in the current directory and ends the game. If MHpar exists when you start MINEHUNT, the interrupted game resumes and MHpar is purged. You can change the number of mines in the battlefield by creating a variable named Nmines containing the desired number. Nmines must contain a real number (1 to 64). If Nmines is negative, the mines are visible during the game (allowing you to cheat).

Input/Output

  None.

## MINIFONT→ not in app ↑ top

PDF page 268 · printed page 3-148

Type

  Command

Description

  Minifont: Returns the font that is set as the minifont.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Font object |

See also

  →MINIFONT →MINIFONT

Type

  Command

Description

  Minifont: Sets the font that is used as the minifont.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  Font object | → |

See also

  MINIFONT→

## MINIT not in app ↑ top

PDF page 268 · printed page 3-148

Type

  Command

Description

  Multiple-equation Menu Initialization Command. Creates the reserved variable Mpar, which includes the equations in EQ and the variables in these equations.

See also

  MITM, MROOT, MSOLVR

## MINR in app ↑ top

PDF page 268 · printed page 3-148

Type

  Function

Description

  Minimum Real Function: Returns the symbolic constant MINR or its numerical representation, 1.00000000000E–499. MINR is the smallest positive real number that can be represented by the calculator.

Flags

  Symbolic Constants (–2), Numerical Results (–3)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | `MINR` |
  → | 1.00000000000E–499 |

See also

  e, i, MAXR, π

## MINΣ in app ↑ top

PDF page 269 · printed page 3-149

Type

  Command

Description

  Minimum Sigma Command: Finds the minimum coordinate value in each of the m columns of the current statistics matrix (reserved variable ΣDAT). The minima are returned as a vector of m real numbers, or as a single real number if m = 1.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xmin |
  → | { xmin 1 xmin 2 … xmin m } |

See also

  BINS, MAXΣ, MEAN, SDEV, TOT, VAR

## MITM not in app ↑ top

PDF page 269 · printed page 3-149

Type

  Command

Description

  Multiple-equation Menu Item Order Command. Changes multiple equation menu titles and order. The argument list contains the variable names in the order you want. Use "" to indicate a blank label. You must include all variables in the original menu and no others.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  "title" | { list } | → |

See also

  MINIT

## MKISOM not in app ↑ top

PDF page 269 · printed page 3-149

Type

  Command

Description

  Returns the matrix representation for a given isometry.

Input

  Level 2/Argument 1: For a 3-d isometry, a list of the characteristic elements of the isometry. For a 2-d isometry, the characteristic element of the isometry (either an angle or a vector). Level 1/Argument 2: +1 for a direct isometry or –1 for an indirect isometry.

Output

  The matrix that represents the given isometry.

Flags

  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 1: Find the matrix for a rotation of π/2 radians in two dimensions
  Command | MKISOM(π/2, 1)

  0 –1 1 0 Result:

      Example 2:      Find the matrix for a rotation with axis [1 1 1] and angle π/3 radians combined with a reflection in

  the plane x + y + z = 0

       Command:       MKISOM({ [1, 1, 1],π/3}, -1) then simplify with EXPAND(ANS(1))

  0 –1 0 0 0 –1 –1 0 0 Result:

See also

  ISOM

## MOD in app ↑ top

PDF page 270 · printed page 3-150

Type

  Function

Description

  Modulo Function: Returns a remainder defined by: x mod y = x – y floor (x/y) Mod (x, y) is periodic in x with period y. Mod (x, y) lies in the interval [0, y) for y > 0 and in (y, 0] for y < 0. Algebraic syntax: argument 1 MOD argument 2

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | x mod y
  x | `symb` | → | `MOD(x, symb)`
  `symb` | x | → | `MOD(symb, x)`
  `symb1` | `symb2` | → | `MOD(symb1, symb2)`

See also

  FLOOR, /

## MODSTO in app ↑ top

PDF page 270 · printed page 3-150

Type

  Command

Description

  Changes the modulo setting to the specified number. The number that you set is reflected in the CAS Modes input form. Negative numbers are replaced by their positive value, 0 and 1 are replaced by 2.

Input

  The modulo value that you want to set, an integer or an expression that evaluates to an integer.

Output

  The modulo setting is changed to the specified number. In Algebraic mode, NOVAL is returned as argument 1.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

## MODULAR not in app ↑ top

PDF page 270 · printed page 3-150

Type

  Command

Description

  Displays a menu or list of the CAS modulo operations.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, POLYNOMIAL, REWRITE, TESTS, TRIGO

## MOLWT not in app ↑ top

PDF page 271 · printed page 3-151

Type

  Function

Description

  Returns the molecular weight for the specified molecular formula. It takes the formula as a string (such as "H2O") or name (with certain restrictions, such as `H2O`). It returns the molecular weight. It chooses to use or not use units according to the Units Usage flag (flag 61: SI units if clear, no units if set). You can store a molecular formula in a variable, then use the variable name with MOLWT. You should do this when you want to use MOLWT in an expression and the formula contains parentheses or matches a command name. You must take care when naming a variable that contains a formula string or name. Make sure the variable name isn’t a valid formula — for example, start the variable name with a lowercase letter. (If the variable name is a valid formula, using MOLWT with the variable name returns the molecular weight for the variable name, not for the formula it contains.)

Flags

  Units Usage (61)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → | x or x_unit
  “string” | → | x or x_unit
  Example 1: | The command sequence "CH3C6H2(NO2)3" MOLWT returns |
  `227.133_g/gmol` when flag 61 is clear.
      Example 2:      The command sequence `C12H17ClN4OS` MOLWT returns 300.8055 when flag 61
  is set.

See also

  PERINFO, PERTBL, PTPROP

## MROOT not in app ↑ top

PDF page 271 · printed page 3-151

Type

  Command

Description

  Multiple Roots Command: Uses the multiple-equation solver to solve for one or more variables using the equations in EQ. Given a variable name, MROOT returns the found value; with "ALL" MROOT stores a found value for each variable but returns nothing.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → | x
  "ALL" | → |

See also

  MCALC, MUSER

## MSGBOX not in app ↑ top

PDF page 271 · printed page 3-151

Type

  Command

Description

  Message Box Command: Creates a user-defined message box. MSGBOX displays “message” in the form of a standard message box. Message text too long to appear on the screen is truncated. You can use spaces and new-line characters (…ë) to control word-wrapping and line breaks within the message. Program execution resumes when the message box is exited by selecting OK or CANCL.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  “message” | → |

See also

  CHOOSE, INFORM, PROMPT

## MSLV not in app ↑ top

PDF page 272 · printed page 3-152

Type

  Command

Description

  Numerically approximates a solution to a system of equations. Searches for a solution accurate to 12 digits, regardless of the display setting. Underdetermined and overdetermined systems are rejected. Complex solutions will be looked for if any of the inputs contain complex values. If a single expression or equation is to be solved, use SOLVE instead, or for linear equations, use LINSOLVE. This command is similar to MSOLVR, but is more appropriate for use with the CAS as it automates the solution instead of working through a menu. Step-by-step mode is available with this command.

Input

  Level 3/Argument 1: A vector containing the equations or expressions (assumed equal to zero) to solve. Level 2/Argument 2: A vector containing the variables to solve for Level 1/Argument 3: A vector containing initial guesses

Output

  Level 3/Item 1: The vector containing the equations to solve. Level 2/Item 2: The vector containing the variables to solve for Level 1/Item 3: A vector representing an approximate solution to the system of equations.

Flags

  Exact mode must be set (flag –105 clear), The calculator will set approximate mode and will look for approximate results if exact results are not found. Numeric mode must not be set (flag –3 clear). Radians mode must be set (flag –17 set). Complex mode must be set (flag –103 set) if complex results are wanted. Step-by-step mode can be set (flag –100 set).

Example

      Find x and y values, allowing for complex solutions, that solve the following two equations. The first equation is an expression equal to zero, so only the expression needs to be given. Setting the second expression equal to a complex number forces the solver to look for complex solutions: sin(x)+y=0, x+sin(y)=1:
          Command:       MSLV(`[SIN(X)+Y, X+SIN(Y)=(1,0)]`, `[X,Y]`, [0,0])
          Results:       (`[SIN(X)+Y, X+SIN(Y)=(1,0)]`, `[X,Y]`, [(1.82384112611,0.),
          (-.968154636174,0.)])

See also

  DESOLVE, LINSOLVE, MSOLVR, SOLVE

## MSOLVR not in app ↑ top

PDF page 272 · printed page 3-152

Type

  Command

Description

  Multiple Equation Solver Command: Gets the multiple-equation solver variable menu for the set of equations defined by Mpar. The multiple-equation solver application can solve a set of two or more equations for unknown variables by finding the roots of each equation, one at a time. The Multiple-Equation Solver uses the list of equations stored in EQ. “Equations” in this context includes programs, expressions, and variable names that evaluate to a single value. The Multiple- Equation Solver requires that EQ contain more than one equation — that is, the HP Solve application would include the NXEQ menu label for EQ. The solver uses EQ to create a reserved

  variable Mpar that is used during the solution process. Mpar contains the equation set plus additional information. See appendix D, “Reserved Variables”, for information about Mpar.

Input/Output

  None

See also

  EQNLIB, MCALC, MINIT, MITM, MROOT, MSLV, MUSER

## MULTMOD in app ↑ top

PDF page 273 · printed page 3-153

Type

  Function

Description

  Performs modular multiplication of two objects, modulo the current modulus.

Input

  Level 2/Argument 1: A number or an expression. Level 1/Argument 2: A number or an expression.

Output

  The result of modular multiplication of the two objects, modulo the current modulus.

Flags

  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

  Find the product of 2x and 38x2, modulo the default modulus, 3.

  Command | MULTMOD(2*X,38*X^2)
  Result | X^3

## MUSER not in app ↑ top

PDF page 273 · printed page 3-153

Type

  Command

Description

  Make User-Defined Variable Command: Designates a variable as user-defined for the multiple- equation solver. MUSER designates a single variable, a list of variables, or all variables as user-defined.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |
  { list } | → |
  "ALL" | → |

See also

  MCALC

## →NDISP not in app ↑ top

PDF page 273 · printed page 3-153

Type

  Command

Description

  Sets the number of program lines displayed on the screen. The default value on the calculator is 9. On the HP 50g and 49g+ a value of 12 should be set for →NDISP, which will allow more of these models’ taller screen to be used when the font is FONT7, FONT6, or the MINIFONT. Also, note that the →NDISP setting is reset to 9 at every warmstart. Including << 12 →NDISP >> in `STARTUP` will automatically reset the value to 12.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → |

## NDIST not in app ↑ top

PDF page 274 · printed page 3-154

Type

  Command

Description

  Normal Distribution Command: Returns the normal probability distribution (bell curve) at x based on the mean m and variance v of the normal distribution. NDIST is calculated using this formula: 2 (x – m) – ------------------- 2v e ndist ( m, v, x ) = -------------------- 2πv

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  m | v | x | → | ndist(m, v, x)

See also

  UTPN

## NDUPN in app ↑ top

PDF page 274 · printed page 3-154

Type

  RPL command

Description

  Duplicates an object n times, and returns n.

Input/Output

  Level 2 | Level 1 |  | Leveln+1 … Level2 | Level1
  --- | --- | --- | --- | ---
  obj | n | → | obj … obj | n

Example

  To make a list of 100 “X”s, run "X" 100 NDUPN →LIST.

See also

  DUP, DUPDUP, DUPN, DUP2

## NEG in app ↑ top

PDF page 274 · printed page 3-154

Type

  Analytic function

Description

  Negate Analytic Function: Changes the sign or negates an object. Negating an array creates a new array containing the negative of each of the original elements. Negating a binary number takes its two’s complement (complements each bit and adds 1). Negating a graphics object “inverts” it (toggles each pixel from on to off, or vice-versa). If the argument is PICT, the graphics object stored in PICT is inverted.

Flags

  Numerical Results (–3), Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | –z
  #n1 | → | #n2
  [ array ] | → | [ –array ]
  `symb` | → | `–(symb)`
  x_unit | → | –x_unit
  grob1 | → | grob2
  PICT1 | → | PICT2

See also

  ABS, CONJ, NOT, SIGN

## NEWOB in app ↑ top

PDF page 275 · printed page 3-155

Type

  Command

Description

  New Object Command: Creates a new copy of the specified object. NEWOB has two main uses:

  - NEWOB enables the purging of a library or backup object that has been recalled from a port. NEWOB creates a new, separate copy of the object in memory, thereby allowing the original copy to be purged.
  - Creating a new copy of an object that originated in a larger composite object (such as a list) allows you to recover the memory associated with the larger object when that larger object is no longer needed.
Flags

  Last Arguments (–55). In order for NEWOB to immediately release the memory occupied by the original copy, flag –55 must be set so that the copy is not saved as a last argument.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → | obj
  Example 1: | :0:BKUP1 RCL NEWOB :0:BKUP1 PURGE recalls and purges the backup object |
  BKUP1.
      Example 2:       3 GET NEWOB retrieves the third element out of a list on the stack, recovering the memory
  occupied by the whole list.

See also

  MEM, PURGE

## NEXT not in app ↑ top

PDF page 275 · printed page 3-155

Type

  Command

Description

  NEXT Command: Ends definite loop structures. See the FOR and START keyword entries for more information.

Input/Output

  None

See also

  FOR, START, STEP NEXT

Type

  Operation

Description

  NEXT Operation: Returns but does not execute the next one or two steps of a program.

Input/Output

  None

See also

  SST, SST↓

## NEXTPRIME in app ↑ top

PDF page 275 · printed page 3-155

Type

  Function

Description

  Given an integer, returns the next prime number larger than the integer. Like ISPRIME?, it uses a pseudoprime check for large numbers.

Input

  An integer or an expression that evaluates to an integer.

Output

  The next prime number larger than the integer.

Example

  Find the closest, larger prime number to 145.

  Command | NEXTPRIME(145)
  Result | 149

See also

  ISPRIME?, PREVPRIME

## NIP in app ↑ top

PDF page 276 · printed page 3-156

Type

  RPL command

Description

  Drops the (n–1)th argument, where n is the number of arguments or items on the stack. (that is, the object on level 2 of the stack). This is equivalent to executing SWAP followed by DROP in RPN mode.

Input/Output

  Level 2 | Level 1 |  | Level 1
  --- | --- | --- | ---
  obj1 | obj2 | → | obj2

Example

  333 222 1 NIP returns 333 1

See also

  DUP, DUPDUP, DUPN, DUP2

## NOT in app ↑ top

PDF page 276 · printed page 3-156

Type

  Function

Description

  NOT Command: Returns the one’s complement or logical inverse of the argument. When the argument is a binary integer or string, NOT complements each bit in the argument to produce the result.

  - A binary integer is treated as a sequence of bits as long as the current wordsize.
  - A string is treated as a sequence of bits, using 8 bits per character (that is, using the binary version of the character code). When the argument is a real number or symbolic, NOT does a true/false test. The result is 1 (true) if the argument is zero; it is 0 (false) if the argument is nonzero. This test is usually done on a test result (T/F). If the argument is an algebraic object, then the result is an algebraic of the form NOT symb. Execute →NUM (or set flag –3 before executing NOT) to produce a numeric result from the algebraic result.
Flags

  Numerical Results (–3), Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2
  T/F | → | 0/1
  “string1” | → | “string2”
  `symb` | → | `NOT symb`

See also

  AND, OR, XOR

## NOVAL not in app ↑ top

PDF page 276 · printed page 3-156

Type

  Command

Description

  INFORM Place Holder/Result Command: Place holder for reset and initial values in user-defined dialog boxes. NOVAL is returned when a field is empty.

  NOVAL is used to mark an empty field in a user-defined dialog box created with the INFORM command. INFORM defines fields sequentially. If default values are used for those fields, the defaults must be defined in the same order as the fields were defined. To skip over (not provide defaults for) some of the fields, use the NOVAL command. After INFORM terminates, NOVAL is returned if a field is empty and OK or ` is selected.

Input/Output

  None

See also

  INFORM

## NΣ in app ↑ top

PDF page 277 · printed page 3-157

Type

  Command

Description

  Number of Rows Command: Returns the number of rows in the current statistical matrix (reserved variable ΣDAT).

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | nrows |

See also

  ΣX, ΣXY, ΣX2, ΣY, ΣY2

## NSUB in app ↑ top

PDF page 277 · printed page 3-157

Type

  Command

Description

  Number of Sublist Command: Provides a way to access the current sublist position during an iteration of a program or command applied using DOSUBS. Returns an Undefined Local Name error if executed when DOSUBS is not active.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | nposition |

See also

  DOSUBS, ENDSUB

## →NUM in app ↑ top

PDF page 277 · printed page 3-157

Type

  Command

Description

  Evaluate to Number Command. Evaluates a symbolic argument object (other than a list) and returns the numerical result. →NUM repeatedly evaluates a symbolic argument until a numerical result is achieved. The effect is the same as evaluating a symbolic argument in Numerical Result Mode (flag –3 set).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  objsymb | → | z

See also

  EVAL

## NUM in app ↑ top

PDF page 277 · printed page 3-157

Type

  Command

Description

  Character Number Command: Returns the character code n for the first character in the string. The character codes are an extension of ISO 8859/1. Codes 128 through 159 are unique to the calculators.

  The number of a character can be found by accessing the Characters tool (…±) and highlighting that character. The number appears near the bottom of the screen. These are also listed in Appendix J of this manual.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  “string” | → | n

See also

  CHR, POS, REPL, SIZE, SUB

## NUMX not in app ↑ top

PDF page 278 · printed page 3-158

Type

  Command

Description

  Number of X-Steps Command: Sets the number of x-steps for each y-step in 3D perspective plots. The number of x-steps is the number of independent variable points plotted for each dependent variable point plotted. This number must be 2 or more. This value is stored in the reserved variable VPAR. YSLICE is the only 3D plot type that does not use this value.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nx | → |

See also

  NUMY

## NUMY not in app ↑ top

PDF page 278 · printed page 3-158

Type

  Command

Description

  Number of Y-Steps Command: Sets the number of y-steps across the view volume in 3D perspective plots. The number of y-steps is the number of dependent variable points plotted across the view volume. This number must be 2 or more. This value is stored in the reserved variable VPAR.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  ny | → |

See also

  NUMX

## OBJ→ in app ↑ top

PDF page 278 · printed page 3-158

Type

  Command

Description

  Object to Stack Command: Separates an object into its components. For some object types, the number of components is returned as item n+1 (stack level 1). If the argument is a complex number, list, array, or string, OBJ→ provides the same functions as C→R, LIST→, ARRY→, and STR→, respectively. For lists, OBJ→ also returns the number of list elements. If the argument is an array, OBJ→ also returns the dimensions { m n } of the array, where m is the number of rows and n is the number of columns. For algebraic objects, OBJ→ returns the arguments of the top-level (least-nested) function (arg1 … argn), the number of arguments of the top-level function (n), and the name of the top-level function (function). If the argument is a string, the object sequence defined by the string is executed.

Input/Output

  Level 1/Argument 1 |  | Leveln+1/Item1 | Level2/Itemn | Level1/Itemn+1 |
  --- | --- | --- | --- | --- | ---
  (x, y) | → | x | y |  |
  { obj1, ... ,objn } | → | obj1 | … | objn | n
  [ x1, ... ,xn ] | → | x1 | … | xn | {n}
  [[ x1 1, ... ,xm n ]] | → | x1 1 | … | xm n | { m, n }
  “obj” | → | evaluated object |  |  |
  `symb` | → | arg1 ... argn | … | n | `function`
  x_unit | → | x | 1_unit |  |
  :tag:obj | → | obj | “tag” |  |

Example

      The command sequence `„(0,1,SIN(X),X)` OBJ→ returns:
          6:           0       first argument
          5:           1       second argument
          4: `SIN(X)`          third argument
          3:        `X`        fourth argument
          2:           4       number of arguments for „
          1:           „       function name

See also

  ARRY→, C→R, DTAG, EQ→, LIST→, R→C, STR→, →TAG

## OCT in app ↑ top

PDF page 279 · printed page 3-159

Type

  Command

Description

  Octal Mode Command: Selects octal base for binary integer operations. (The default base is decimal.) Binary integers require the prefix #. Binary integers entered and returned in octal base automatically show the suffix o. If the current base is not octal, enter an octal number by ending it with o. It will be displayed in the current base when entered. The current base does not affect the internal representation of binary integers as unsigned binary numbers.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  None

See also

  BIN, DEC, HEX, RCWS, STWS

## OFF not in app ↑ top

PDF page 279 · printed page 3-159

Type

  Command

Description

  Off Command: Turns off the calculator. When executed from a program, that program will resume execution when the calculator is turned on. This provides a programmable “autostart.” ( i.e., a programmable …ç).

Input/Output

  None

See also

  CONT, HALT, KILL

## OLDPRT not in app ↑ top

PDF page 279 · printed page 3-159

Type

  Command

Description

  Modifies the remapping string in the reserved variable PRTPAR so that the extended character set of the calculator matches that of the HP 82240A Infrared Printer.

  The character set in the HP 82240A Infrared Printer does not match the character set of the calculator:

  - 24 characters in the calculator’s character set are not available in the HP 82240A Infrared Printer. (From the table in Appendix J, these characters are numbers 129, 130, 143-157, 159, 166, 169, 172, 174, 184, and 185.) The HP 82240A prints a in substitution.
  - Many characters in the extended character table (character codes 128 through 255) do not have the same character code. For example, the « character has code 171 in the calculator and code 146 in the HP 82240A Infrared Printer. To use the CHR command to print extended characters with an HP 82240A Infrared Printer, first execute OLDPRT. The remapping string modified by OLDPRT is the second parameter in PRTPAR. This string (which is empty in the default state) changes the character code of each byte to match the codes in the HP 82240A Infrared Printer character table. To cancel OLDPRT character mapping in order to print to an HP 82240B Infrared Printer, purge the PRTPAR variable. To print a string containing graphics data, disable OLDPRT.
See also

  CR, DELAY, PRLCD, PRST, PRSTC, PRVAR, PR1

## OPENIO not in app ↑ top

PDF page 280 · printed page 3-160

Type

  Command

Description

  Open I/O Port Command: Opens a serial port using the I/O parameters in the reserved variable IOPAR. Since all Kermit-protocol commands automatically effect an OPENIO first, OPENIO is not normally needed, but can be used if an I/O transmission does not work. OPENIO is necessary for interaction with devices that interpret a closed port as a break. OPENIO is also necessary for the automatic reception of data into the input buffer using non- Kermit commands. If the port is closed, incoming characters are ignored. If the port is open, incoming characters are automatically placed in the input buffer (up to 255 characters). These characters can be detected with BUFLEN, and can be read out of the input buffer using SRECV. If the port is already open, OPENIO does not affect the data in the input buffer. However, if the port is closed, executing OPENIO clears the data in the input buffer. For more information, refer to the reserved variable IOPAR in appendix D, “Reserved Variables”.

Flags

  I/O Device (–33), I/O Device for Wire (–78)

Input/Output

  None

See also

  BUFLEN, CLOSEIO, SBRK, SRECV, STIME, XMIT

## OR in app ↑ top

PDF page 280 · printed page 3-160

Type

  Function

Description

  OR Function: Returns the logical OR of two arguments. When the arguments are binary integers or strings, OR does a bit-by-bit (base 2) logical comparison.

  - An argument that is a binary integer is treated as a sequence of bits as long as the current wordsize. Each bit in the result is determined by comparing the corresponding bits (bit1 and bit2) in the two arguments as shown in the following table:

  bit1 | bit2 | bit1 OR bit2
  --- | --- | ---
  0 | 0 | 0
  0 | 1 | 1
  1 | 0 | 1
  1 | 1 | 1

  - An argument that is a string is treated as a sequence of bits, using 8 bits per character (that is, using the binary version of the character code). The two string arguments must be the same length. When the arguments are real numbers or symbolics, OR simply does a true/false test. The result is 1 (true) if either or both arguments are nonzero; it is 0 (false) if both arguments are zero. This test is usually done to compare two test results. If either or both of the arguments are algebraic objects, then the result is an algebraic of the form symb1 OR symb2. Execute →NUM (or set flag –3 before executing OR) to produce a numeric result from the algebraic result.
Flags

  Numerical Results (–3), Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  #n1 | #n2 | → | #n3
  “string1” | “string2” | → | “string3”
  T/F1 | T/F2 | → | 0/1
  T/F | `symb` | → | `T/F OR symb`
  `symb` | T/F | → | `symb OR T/F`
  `symb1` | `symb2` | → | `symb1 OR symb2`

See also

  AND, NOT, XOR

## ORDER in app ↑ top

PDF page 281 · printed page 3-161

Type

  Command

Description

  Order Variables Command: Reorders the variables in the current directory (shown in the VAR menu) to the order specified. The names that appear first in the list will be the first to appear in the VAR menu. Variables not specified in the list are placed after the reordered variables. If the list includes the name of a large subdirectory, there may be insufficient memory to execute ORDER.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { global1 ... globaln } | → |

See also

  VARS

## OVER in app ↑ top

PDF page 281 · printed page 3-161

Type

  RPL command

Description

  Over Command: Returns a copy to stack level 1 of the object in level 2.

Input/Output

  Level 2 | Level 1 |  | Level 3 | Level 2 | Level 1
  --- | --- | --- | --- | --- | ---
  obj1 | obj2 | → | obj1 | obj2 | obj1

See also

  PICK, ROLL, ROLLD, ROT, SWAP

## P2C not in app ↑ top

PDF page 282 · printed page 3-162

Type

  Command

Description

  Takes a list representing a permutation as an argument, and returns the permutation decomposed into lists that represent cycles.

Input

  A list representing a permutation. For example, the list {3,1,2,5,4} defines a permutation P, such that P(1)=3, P(2)=1, P(3)=2, P(4)=5, and P(5)=4

Output

  Level 2/Item 1:A list of cycles equivalent to the permutation. For example, the list {3,1,2,5,4} defines a cycle C, such that C(3)=1, C(1)=2, C(2)=5, C(5)=4, and C(4)=3 Level 1, Item 2: The signature of the permutation, 1 or –1.

Example

  Convert the permutation given by {3,4,5,2,1} into cycles:

  Command | P2C({3,4,5,2,1})
  Result | {{{1,3,5},{2,4}},-1}

See also

  C2P, CIRC

## PA2B2 in app ↑ top

PDF page 282 · printed page 3-162

Type

  Function

Description

  Takes a prime number, p, such that p=2 orp ≡ 1 modulo 4, and returns a Gaussian integer a + ib such that p = a2 + b2. This function is useful for factorizing Gaussian integers.

Input

      A prime number, p, such that p=2 orp ≡ 1       modulo 4

Output

  A Gaussian integer a+ib such that p=a2+b2

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). Complex mode must be set (flag –103 set).

See also

  GAUSS

## PARAMETRIC not in app ↑ top

PDF page 282 · printed page 3-162

Type

  Command

Description

  Parametric Plot Type Command: Sets the plot type to PARAMETRIC. When the plot type is PARAMETRIC, the DRAW command plots the current equation as a complex-valued function of one real variable. The current equation is specified in the reserved variable EQ. The plotting parameters are specified in the reserved variable PPAR, which has the following form: { (xmin, ymin), (xmax, ymax), indep, res, axes, ptype, depend } For plot type PARAMETRIC, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is a list containing a name that specifies the independent variable, and two numbers specifying the minimum and maximum values for the independent variable (the plotting range). Note that the default value is X. If X is not modified and included in a list with a plotting range, the values in (xmin, ymin) and (xmax, ymax) are used as the plotting range, which generally leads to meaningless results.
  - res is a real number specifying the interval, in user-unit coordinates, between values of the independent variable. The default value is 0, which specifies an interval equal to 1/130 of the difference between the maximum and minimum values in indep (the plotting range).
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command PARAMETRIC places the name PARAMETRIC in PPAR.
  - depend is a name specifying a label for the vertical axis. The default value is Y. The contents of EQ must be an expression or program; it cannot be an equation. It is evaluated for each value of the independent variable. The results, which must be complex numbers, give the coordinates of the points to be plotted. Lines are drawn between plotted points unless flag –31 is set.
Flags

  Simultaneous Plotting (–28), Curve Filling (–31)

Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## PARITY not in app ↑ top

PDF page 283 · printed page 3-163

Type

  Command

Description

  Parity Command: Sets the parity value in the reserved variable IOPAR. Legal values are shown below. A negative value means the calculator does not check parity on bytes received during Kermit transfers or with SRECV. Parity is still used during data transmission, however.

  n-Value | Meaning
  --- | ---
  0 | no parity (the default value)
  1 | odd parity
  2 | even parity
  3 | mark
  4 | space

  For more information, refer to the reserved variable IOPAR in appendix D, “Reserved Variables”.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nparity | → |

See also

  BAUD, CKSM, TRANSIO

## PARSURFACE not in app ↑ top

PDF page 284 · printed page 3-164

Type

  Command

Description

  PARSURFACE Plot Type Command: Sets plot type to PARSURFACE. When plot type is set to PARSURFACE, the DRAW command plots an image graph of a 3- vector-valued function of two variables. PARSURFACE requires values in the reserved variables EQ, VPAR, and PPAR. VPAR is made up of the following elements: { xleft, xright, ynear, yfar, zlow, zhigh, xmin, xmax, ymin, ymax, xeye, yeye, zeye, xstep, ystep } For plot type PARSURFACE, the elements of VPAR are used as follows:

  - xleft and xright are real numbers that specify the width of the view space.
  - ynear and yfar are real numbers that specify the depth of the view space.
  - zlow and zhigh are real numbers that specify the height of the view space.
  - xmin and xmax are real numbers that specify the input region’s width. The default value is (–1,1).
  - ymin and ymax are real numbers that specify the input region’s depth. The default value is (–1,1).
  - xeye, yeye, and zeye are real numbers that specify the point in space from which the graph is viewed.
  - xstep and ystep are real numbers that set the number of x-coordinates versus the number of y- coordinates plotted. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin), (xmax, ymax), indep, res, axes, ptype, depend } For plot type PARSURFACE, the elements of PPAR are used as follows:
  - (xmin, ymin) is not used.
  - (xmax, ymax) is not used.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is not used.
  - axes is not used.
  - ptype is a command name specifying the plot type. Executing the command PARSURFACE places the name PARSURFACE in ptype.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FAST3D, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## PARTFRAC in app ↑ top

PDF page 284 · printed page 3-164

Type

  Command

Description

  Performs partial fraction decomposition on a partial fraction.

Input

  An algebraic expression.

Output

  The partial fraction decomposition of the expression.

Flags

  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

  Perform a partial fraction decomposition of the following expression: 1 ------------- 2 x –1

  Command | PARTFRAC(1/(X^2-1))
  Result | 1/2/(X-1)+-1/2/(X+1)

See also

  PROPFRAC

## PATH in app ↑ top

PDF page 285 · printed page 3-165

Type

  Command

Description

  Current Path Command: Returns a list specifying the path to the current directory. The first directory is always HOME, and the last directory is always the current directory. If a program needs to switch to a specific directory, it can do so by evaluating a directory list, such as one created earlier by PATH.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | { HOME directory-name1 ... directory-namen } |

See also

  CRDIR, HOME, PGDIR, UPDIR

## PCAR in app ↑ top

PDF page 285 · printed page 3-165

Type

  Command

Description

  Returns the characteristic polynomial of an n × n matrix.

Input

  A square matrix.

Output

  The characteristic polynomial of the matrix.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Find the characteristic polynomial of the following matrix: 5 8 16 4 1 8 – 4 – 4 – 11

  Command | PCAR([[5,8,16][4,1,8][-4,-4,-11]])
  Result | X^3+5*X^2+3*X-9

See also

  JORDAN, PMINI

## PCOEF in app ↑ top

PDF page 285 · printed page 3-165

Type

  Command

Description

  Monic Polynomial Coefficients Command: Returns the coefficients of a monic polynomial (a polynomial with a leading coefficient of 1) having specific roots. The argument must be a real or complex array of length n containing the polynomial’s roots. The result is a real or complex vector of length n+1 containing the coefficients listed from highest order to lowest, with a leading coefficient of 1.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ array ]roots | → | [ array ]coefficients

Example

  Find the polynomial that has the roots 2, –3, 4, –5:

  Command | [ 2 –3 4 –5 ] PCOEF
  Result | [ 1 2 –25 –26 120 ], representing the polynomial x4 + 2x3 - 25x2 - 26x + 120.

See also

  PEVAL, PROOT

## PCONTOUR not in app ↑ top

PDF page 286 · printed page 3-166

Type

  Command

Description

  PCONTOUR Plot Type Command: Sets the plot type to PCONTOUR. When plot type is set PCONTOUR, the DRAW command plots a contour-map view of a scalar function of two variables. PCONTOUR requires values in the reserved variables EQ, VPAR, and PPAR. VPAR is made up of the following elements: { xleft xright ynear yfar zlow zhigh xmin xmax ymin ymax xeye yeye zeye xstep ystep } For plot type PCONTOUR, the elements of VPAR are used as follows:

  - xleft and xright are real numbers that specify the width of the view space.
  - ynear and yfar are real numbers that specify the depth of the view space.
  - zlow and zhigh are real numbers that specify the height of the view space.
  - xmin and xmax are not used.
  - ymin and ymax are not used.
  - xeye, yeye, and zeye are real numbers that specify the point in space from which the graph is viewed.
  - xstep and ystep are real numbers that set the number of x-coordinates versus the number of y- coordinates plotted. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type PCONTOUR, the elements of PPAR are used as follows:
  - (xmin, ymin) and (xmax, ymax) are not used.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is not used.
  - axes is not used.
  - ptype is a command name specifying the plot type. Executing the command PCONTOUR places the name PCONTOUR in ptype.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## PCOV not in app ↑ top

PDF page 286 · printed page 3-166

Type

  Command

Description

  Population Covariance Command: Returns the population covariance of the independent and dependent data columns in the current statistics matrix (reserved variable ΣDAT). The columns are specified by the first two elements in reserved variable ΣPAR, set by XCOL and YCOL respectively. If ΣPAR does not exist, PCOV creates it and sets the elements to their default values (1 and 2). The population covariance is calculated with the following formula: 1 n -- ∑ ( xkn1 – x n 1 ) ( x kn2 – x n2 ) nk = 1

              x kn 1                                              n 1 x kn 2
          where            is the kth coordinate value in column         ,       is the kth coordinate value in the
                    n      x                                           n1 xn                                  n
          column 2 , n1 is the mean of the data in column                , 2 is the mean of the data in column 2 ,

  and n is the number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xpcovariance |

See also

  COLΣ, CORR, COV, PREDX, PREDY, XCOL, YCOL

## PDIM not in app ↑ top

PDF page 287 · printed page 3-167

Type

  Command

Description

  PICT Dimension Command: Replaces PICT with a blank PICT of the specified dimensions. If the arguments are complex numbers, PDIM changes the size of PICT and makes the arguments the new values of (xmin, ymin) and (xmax, ymax) in the reserved variable PPAR. Thus, the scale of a subsequent plot is not changed. If the arguments are binary integers, PPAR remains unchanged, so the scale of a subsequent plot is changed. PICT cannot be smaller than 131 pixels wide × 80 pixels high on the HP 50g and 49g+ (64 pixels high on the HP 48gII) nor wider than 2048 pixels (height is unlimited).

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  (xmin, ymin) | (xmax, ymax) | → |
  #nwidth | #mheight | → |

See also

  PMAX, PMIN

## PERINFO not in app ↑ top

PDF page 287 · printed page 3-167

Type

  Command

Description

  Displays the Periodic Table version and copyright information. It doesn’t affect the stack.

Input/Output

  None

See also

  MOLWT, PERTBL, PTPROP

## PERM in app ↑ top

PDF page 287 · printed page 3-167

Type

  Function

Description

  Permutations Function: Returns the number of possible permutations of n items taken m at a time. The formula used to calculate Pn,m is: n! P n, m = ------------------- ( n – m )!

  The arguments n and m must each be less than 1012. If n < m, zero is returned.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  n | m | → | Pn,m
  `symbn` | m | → | `PERM(symbn,m)`
  n | `symbm` | → | `PERM(n, symbm)`
  `symbn` | `symbm` | → | `PERM(symbn,symbm)`

See also

  COMB, FACT, !

## PERTBL not in app ↑ top

PDF page 288 · printed page 3-168

Type

  Command

Description

  Starts the Periodic Table. It doesn’t affect the stack.

Flags

  Units Usage (61), Units Type (60)

Input/Output

  None

See also

  MOLWT, PERINFO, PTPROP

## PEVAL in app ↑ top

PDF page 288 · printed page 3-168

Type

  Command

Description

  Polynomial Evaluation Command: Evaluates an n-degree polynomial at x. The arguments must be an array of length n + 1 containing the polynomial’s coefficients listed from highest order to lowest, and the value x at which the polynomial is to be evaluated.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  [ array ]coefficients | x | → | p(x)

Example

  Find the polynomial x4 + 2x3 - 25x2 - 26x + 120 at x = 8:

  Command | [ 1 2 –25 –26 120 ] 8 PEVAL
  Result | 3432

See also

  PCOEF, PROOT

## PGDIR in app ↑ top

PDF page 288 · printed page 3-168

Type

  Command

Description

  Purge Directory Command: Purges the named directory (whether empty or not).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `global` | → |

See also

  CLVAR, CRDIR, HOME, PATH, PURGE, UPDIR

## PICK in app ↑ top

PDF page 288 · printed page 3-168

Type

  RPL Command

Description

  Pick Object Command: Copies the contents of a specified stack level to level 1.

Input/Output

  Ln+1... | L2 | L1 |  | Ln+1 | L2 | L1
  --- | --- | --- | --- | --- | --- | ---
  objn ... | obj1 | n | → | objn ... | obj1 | obji
  L = Level

See also

  DUP, DUPN, DUP2, OVER, ROLL, ROLLD, ROT, SWAP

## PICK3 in app ↑ top

PDF page 288 · printed page 3-168

Type

  RPL Command

Description

  Duplicates the object on level 3 of the stack.

Input/Output

  L3 | L2 | L1 |  | L4 | L3 | L2 | L1
  --- | --- | --- | --- | --- | --- | --- | ---
  obj1 | obj2 | obj3 | → | obj1 | obj2 | obj3 | obj1
  L = Level; A = Argument; I =Item

Example

  333 22 1 PICK3 returns 333 22 1 333.

See also

  PICK, OVER, DUP

## PICT not in app ↑ top

PDF page 289 · printed page 3-169

Type

  Command

Description

  PICT Command: Puts the name PICT on the stack. PICT is the name of a storage location in calculator memory containing the current graphics object. The command PICT enables access to the contents of that memory location as if it were a variable. Note, however, that PICT is not a variable as defined in the calculator: its name cannot be quoted, and only graphics objects may be stored in it. If a graphics object smaller than 131 wide × 80 pixels high is stored in PICT, it is enlarged to 131 × 80. (These values are 131 x 64 on the HP 48gII). A graphics object of unlimited pixel height and up to 2048 pixels wide can be stored in PICT.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | PICT |

Example

  PICT RCL returns the current graphics object to the stack.

See also

  GOR, GXOR, NEG, PICTURE, PVIEW, RCL, REPL, SIZE, STO, SUB

## PICTURE not in app ↑ top

PDF page 289 · printed page 3-169

Type

  Command

Description

  Picture Environment Command: Selects the Picture environment (that is, selects the graphics display and activates the graphics cursor and Picture menu). When executed from a program, PICTURE suspends program execution until −is pressed.

Input/Output

  None

Example

      This program: « "Press CANCEL to return to stack" 1 DISP 3 WAIT PICTURE »
          displays a message for 3 seconds, then selects the Picture environment. (The            character in the
          program indicates a linefeed.)

See also

  PICT, PVIEW, TEXT

## PINIT not in app ↑ top

PDF page 289 · printed page 3-169

Type

  Command

Description

  Port Initialize Command: Initializes all currently active ports. It may affect data already stored in a port. PINIT is particularly useful when a third-party library has corrupted memory. It stores and then purges an object in each internal port. This has the effect of initializing each port without disturbing any previous-stored data, while removing any invalid objects.

Input/Output

  None

## PIX? not in app ↑ top

PDF page 290 · printed page 3-170

Type

  Command

Description

  Pixel On? Command: Tests whether the specified pixel in PICT is on; returns 1 (true) if the pixel is on, and 0 (false) if the pixel is off.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x,y) | → | 0/1
  { #n #m } | → | 0/1

See also

  PIXON, PIXOFF

## PIXOFF not in app ↑ top

PDF page 290 · printed page 3-170

Type

  Command

Description

  Pixel Off Command: Turns off the pixel at the specified coordinate in PICT.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x,y) | → |
  { #n #m } | → |

See also

  PIXON, PIX?

## PIXON not in app ↑ top

PDF page 290 · printed page 3-170

Type

  Command

Description

  Pixel On Command: Turns on the pixel at the specified coordinate in PICT.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x,y) | → |
  { #n #m } | → |

See also

  PIXOFF, PIX?

## PKT not in app ↑ top

PDF page 290 · printed page 3-170

Type

  Command

Description

  Packet Command: Used to send command “packets” (and receive requested data) to a Kermit server. To send calculator objects, use SEND. PKT allows additional commands to be sent to a Kermit server. The packet data, packet type, and the response to the packet transmission are all in string form. PKT first does an I (initialization) packet exchange with the Kermit server, then sends the server a packet constructed from the data and packet-type arguments supplied to PKT. The response to PKT will be either an acknowledging string (possibly blank) or an error packet (see KERRM). For the type argument, only the first letter is significant.

Flags

  I/O Device (–33), I/O Messages (–39), I/O Device for Wire (–78). The I/O Data Format flag (– 35) can be significant if the server sends back more than one packet.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  “data” | “type” | → | “response”
  Example 1: A PKT command to send a generic directory request is "D" "G" PKT.
  Example 2: To send a host command packet, use a command from the server’s operating system for the data
  string and "C" for the type string. For example, "`ABC` PURGE" "C" PKT on a local calculator would instructor a server calculator to purge variable ABC.

See also

  CLOSEIO, KERRM, SERVER

## PLOT not in app ↑ top

PDF page 291 · printed page 3-171

Type

  Command

Description

  Stores its argument in EQ and opens the PLOT SETUP screen.

Input

  An expression.

Output

  The input expression.

Example

  Store SIN(X) in EQ and open the PLOT SETUP screen:

      Command:        PLOT(SIN(X))

Result

  PLOT SETUP screen is open with SIN(X) in EQ. SIN(X) is copied to history (LASTARG in RPN mode).

See also

  PLOTADD

## PLOTADD not in app ↑ top

PDF page 291 · printed page 3-171

Type

  Function

Description

  Adds a function to the existing plot function list, and opens the Plot Setup screen.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (symb) | → |

## PMAX not in app ↑ top

PDF page 291 · printed page 3-171

Type

  Command

Description

  PICT Maximum Command: Specifies (x, y) as the coordinates at the upper right corner of the display. The complex number (x, y) is stored as the second element in the reserved variable PPAR.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x,y) | → |

See also

  PDIM, PMIN, XRNG, YRNG

## PMIN not in app ↑ top

PDF page 291 · printed page 3-171

Type

  Command

Description

  PICT Minimum Command: Specifies (x, y) as the coordinates at the lower left corner of the display. The complex number (x, y) is stored as the first element in the reserved variable PPAR.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x,y) | → |

See also

  PDIM, PMAX, XRNG, YRNG

## PMINI not in app ↑ top

PDF page 292 · printed page 3-172

Type

  Command

Description

  Finds the minimal polynomial of a matrix.

Input

  An nxn matrix A.

Output

  A matrix whose first zero-row contains the minimal polynomial of A. In step-by-step mode, PMINI shows the row-reduction steps.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). Step-by-step mode can be set (flag –100 set). 01 10

Example

  Find the minimal polynomial of | :
  --- | ---
  Command: | PMINI([[0,1][1,0]])
  1 0 0 1 | 1
  0 1 1 0 | X

  2 0 0 0 0 X –1

      Result:                        So, the minimal polynomial is X2-1, as it is in the first row to contain entirely

  zeros, except for the result.

See also

  JORDAN, PCAR

## POLAR not in app ↑ top

PDF page 292 · printed page 3-172

Type

  Command

Description

  Polar Plot Type Command: Sets the plot type to POLAR. When the plot type is POLAR, the DRAW command plots the current equation in polar coordinates, where the independent variable is the polar angle and the dependent variable is the radius. The current equation is specified in the reserved variable EQ. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type POLAR, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is a name specifying the independent variable, or a list containing such a name and two numbers specifying the minimum and maximum values for the independent variable (the plotting range). The default value of indep is X.
  - res is a real number specifying the interval, in user-unit coordinates, between values of the independent variable. The default value is 0, which specifies an interval of 2 degrees, 2 grads, or π/90 radians.
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command POLAR places the name POLAR in ptype.
  - depend is a name specifying a label for the vertical axis. The default value is Y. The current equation is plotted as a function of the variable specified in indep. The minimum and maximum values of the independent variable (the plotting range) can be specified in indep; otherwise, the default minimum value is 0 and the default maximum value corresponds to one full circle in the current angle mode (360 degrees, 400 grads, or 2π radians). Lines are drawn between plotted points unless flag –31 is set. If flag –28 is set, all equations are plotted simultaneously. If EQ contains an expression or program, the expression or program is evaluated in Numerical Results mode for each value of the independent variable to give the values of the dependent variable. If EQ contains an equation, the plotting action depends on the form of the equation. Form of Current Plotting Action Equation

        expr = expr                    Each expression is plotted separately. The intersection of the

  two graphs shows where the expressions are equal

        name = expr                    Only the expression is plotted

Flags

  Simultaneous Plotting (–28), Curve Filling (–31)

Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## POLYNOMIAL not in app ↑ top

PDF page 293 · printed page 3-173

Type

  Command

Description

  Displays a menu or list of CAS operations with polynomials.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, REWRITE, TESTS, TRIGO

## POP not in app ↑ top

PDF page 293 · printed page 3-173

Type

  Command

Description

  Restores the flags and current directory saved by the most recent execution of PUSH. If no PUSH saves are left, the command has no effect.

Input

  None

Output

  In Algebraic mode the command returns NOVAL to level 1 of the stack.

See also

  PUSH, RCLF, STOF

## POS in app ↑ top

PDF page 294 · printed page 3-174

Type

  Command

Description

  Position Command: Returns the position of a substring within a string or the position of an object within a list. If there is no match for obj or substring, POS returns zero.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  “string” | “substring” | → | n
  { list } | obj | → | n

See also

  CHR, NUM, REPL, SIZE, SUB

## POTENTIAL not in app ↑ top

PDF page 294 · printed page 3-174

Type

  Command

Description

  Find the potential field function describing a field whose vector gradient is input. This command is the opposite of DERIV. Given a vector V it attempts to return a function U such that grad U is equal to V; ∇U = V . For this to be possible, CURL(V) must be zero, otherwise the command reports a “Bad Argument Value” error. Step-by-step mode is available with this command.

Input

  Level 2/Argument 1: A vector V of expressions. Level 1/Argument 2: A vector of the names of the variables.

Output

  Level 1/Item 1: A function U of the variables that is the potential from which V is derived. An arbitrary constant can be added, the command does not do this.

Flags

  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). Step-by-step mode can be set (flag –100 set).

Example

  To confirm that this command is the opposite of DERIV, use the output of the example in DERIV, and show that the result is the same as the input given in the DERIV example. Find the function of the spatial variables x, y, and z whose gradient is: (4xy+z)i + (2x2 + 6yz)j + (x+3y2)k

      Command:        POTENTIAL([4*X*Y+Z, 2*X^2+6*Y*Z, X+3*Y^2], [X,Y,Z])

  EXPAND(ANS(1))

      Result:         2*Y*X^2+Z*X+3*Z*Y^2

See also

  DERIV, VPOTENTIAL

## POWEXPAND not in app ↑ top

PDF page 294 · printed page 3-174

Type

  Function

Description

  Rewrites an expression raised to a power as a product. If followed by repeated execution of DISTRIB allows an expression to be expanded fully, step by step.

Input

  An expression raised to a power.

Output

  The result from applying the distributive property of exponentiation over multiplication.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

  Example: Expand (X+1)3.
  Command | POWEXPAND((X+1)^3)

Result

  (X+1)·(X+1)·(X+1)

## POWMOD in app ↑ top

PDF page 295 · printed page 3-175

Type

  Function

Description

  Raises an object (number or expression) to the specified power, and expresses the result modulo the current modulus.

Input

  Level 2/Argument 1: The object. Level 1/Argument 2: The exponent.

Output

  The result of the object raised to the exponent, modulo the current modulus.

Flags

  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).

## PR1 not in app ↑ top

PDF page 295 · printed page 3-175

Type

  Command

Description

  Print Level 1 Command: Prints an object in multiline printer format. All objects except strings are printed with their identifying delimiters. Strings are printed without the leading and trailing " delimiters. If flag –34 is set (printer output directed to the serial port), flag –33 must be clear. Multiline printer format is similar to multiline display format, with the following exceptions:

  - Strings and names that are more than 24 characters long are continued on the next printer line.
  - The real and imaginary parts of complex numbers are printed on separate lines if they don’t fit on the same line.
  - Grobs are printed graphically.
  - Arrays are printed with a numbered heading for each row and with a column number before each element. For example, the 2 × 3 array 1 2 3 4 5 6 would be printed as follows: Array { 2 3 } Row 1 1] 1 2] 2 3] 3

  Row 2 1] 4 2] 5 3] 6

Flags

  I/O Device (–33), Printing Device (–34), Double-spaced Printing (–37), Linefeed (–38), I/O Device for Wire (–78). If flag –34 is set, flag –33 must be clear.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  object | → | object

See also

  CR, DELAY, OLDPRT, PRLCD, PRST, PRSTC, PRVAR

## PREDV in app ↑ top

PDF page 296 · printed page 3-176

Type

  Command

Description

  Predicted y-Value Command: Returns the predicted dependent-variable value ydependent, based on the independent-variable value xindependent, the currently selected statistical model, and the current regression coefficients in the reserved variable ΣPAR. PREDV is the same as PREDY. See PREDY.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xindependent | → | ydependent

See also

  PREDY

## PREDX in app ↑ top

PDF page 296 · printed page 3-176

Type

  Command

Description

  Predicted x-Value Command: Returns the predicted independent-variable value xindependent, based on the dependent-variable value ydependent, the currently selected statistical model, and the current regression coefficients in the reserved variable ΣPAR. The value is predicted using the regression coefficients most recently computed with LR and stored in the reserved variable ΣPAR. For the linear statistical model, the equation used is this: ydependent = (mxindependent) + b where m is the slope (the third element in ΣPAR) and b is the intercept (the fourth element in ΣPAR). For the other statistical models, the equations used by PREDX are listed in the LR entry. If PREDX is executed without having previously generated regression coefficients in ΣPAR, a default value of zero is used for both regression coefficients, and an error results.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  ydependent | → | xindependent

Example

  Given five columns of data in ΣDAT, the command sequence: 2 XCOL 5 YCOL LOGFIT LR 23 PREDX sets column 2 as the independent variable column, sets column 5 as the dependent variable column, and sets the logarithmic statistical model. It then executes LR, generating intercept and slope regression coefficients, and storing them in ΣPAR. Then, given a dependent value of 23, it returns a predicted independent value based on the regression coefficients and the statistical model.

See also

  COLΣ, CORR, COV, EXPFIT, ΣLINE, LINFIT, LOGFIT, LR, PREDY, PWRFIT, XCOL, YCOL

## PREDY not in app ↑ top

PDF page 297 · printed page 3-177

Type

  Command

Description

  Predicted y-Value Command: Returns the predicted dependent-variable value ydependent, based on the independent-variable value xindependent, the currently selected statistical model, and the current regression coefficients in the reserved variable ΣPAR. The value is predicted using the regression coefficients most recently computed with LR and stored in the reserved variable ΣPAR. For the linear statistical model, the equation used is this: ydependent = (mxindependent) + b where m is the slope (the third element in ΣPAR) and b is the intercept (the fourth element in ΣPAR). For the other statistical models, the equations used by PREDY are listed in the LR entry. If PREDY is executed without having previously generated regression coefficients in ΣPAR, a default value of zero is used for both regression coefficients–in this case PREDY will return 0 for statistical models LINFIT and LOGFIT, and error for statistical models EXPFIT and PWRFIT.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xindependent | → | ydependent

Example

  Given four columns of data in ΣDAT, the command sequence: 2 XCOL 4 YCOL PWRFIT LR 11 PREDY sets column 2 as the independent variable column, sets column 4 as the dependent variable column, and sets the power statistical model. It then executes LR, generating intercept and slope regression coefficients, and storing them in ΣPAR. Then, given an independent value of 11, it returns a predicted dependent value based on the regression coefficients and the statistical model.

See also

  COLΣ, CORR, COV, EXPFIT, ΣLINE, LINFIT, LOGFIT, LR, PREDX, PWRFIT, XCOL, YCOL

## PREVAL in app ↑ top

PDF page 297 · printed page 3-177

Type

  Function

Description

  With respect to the current default variable, returns the difference between the values of a function at two specified values of the variable. PREVAL can be used in conjunction with INTVX to evaluate definite integrals. See the example below.

Input

  Level 3/Argument 1: A function. Level 2/Argument 2: The lower bound. Level 3/Argument 1: The upper bound. The bounds can be expressions.

Output

  The result of the evaluation.

Flags

  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

  Evaluate the following:

                     3   3

  ∫0 ( x + 3 x ) dx

  Command | PREVAL(INTVX(X^3+3*X),0,3)
  Result | 135/4

## PREVPRIME in app ↑ top

PDF page 298 · printed page 3-178

Type

  Function

Description

  Given an integer, finds the closest prime number smaller than the integer. Like ISPRIME?, it uses a pseudoprime check for large numbers.

Input

  An integer or an expression that evaluates to an integer.

Output

  The closest prime number smaller than the integer.

Example

  Find the closest, smaller prime number to 145.

  Command | PREVPRIME(145)
  Result | 139

See also

  ISPRIME?, NEXTPRIME

## PRLCD not in app ↑ top

PDF page 298 · printed page 3-178

Type

  Command

Description

  Print LCD Command: Prints a pixel-by-pixel image of the current display (excluding the annunciators). The width of the printed image of characters in the display is narrower using PRLCD than using a print command such as PR1. The difference results from the spacing between characters. On the display there is a single blank column between characters, and PRLCD prints this spacing. Print commands such as PR1 print two blank columns between adjacent characters.

Flags

  I/O Device (–33), Printing Device (–34), Double-spaced Printing (–37), Linefeed (–38). Flag –38 must be clear, I/O Device for Wire (–78). If flag –34 is set, flag –33 must be clear.

Input/Output

  None

Example

  The command sequence ERASE DRAW PRLCD clears PICT, plots the current equation, then prints the graphics display.

See also

  CR, DELAY, OLDPRT, PRST, PRSTC, PRVAR, PR1

## PROMPT in app ↑ top

PDF page 298 · printed page 3-178

Type

  Command

Description

  Prompt Command: Displays the contents of “prompt” in the status area, and halts program execution. PROMPT is equivalent to 1 DISP 1 FREEZE HALT.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  “prompt” | → |

See also

  CONT, DISP, FREEZE, HALT, INFORM, INPUT, MSGBOX

## PROMPTSTO not in app ↑ top

PDF page 298 · printed page 3-178

Type

  Command

Description

  Prompt Command: Creates a variable with the name supplied as an argument, prompts for a value, and stores the value you enter in the variable.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  “global” | → |

See also

  PROMPT, STO

## PROOT in app ↑ top

PDF page 299 · printed page 3-179

Type

  Command

Description

  Polynomial Roots Command: Returns all roots of an n-degree polynomial having real or complex coefficients. For an nth-order polynomial, the argument must be a real or complex array of length n + 1 containing the coefficients listed from highest order to lowest. The result is a real or complex vector of length n containing the computed roots. PROOT interprets leading coefficients of zero in a limiting sense. As a leading coefficient approaches zero, a root of the polynomial approaches infinity: therefore, if flag –22 is clear (the default), PROOT reports an Infinite Result error if a leading coefficient is zero. If flag –22 is set, PROOT returns a root of (MAXREAL,0) for each leading zero in an array containing real coefficients, and a root of (MAXREAL,MAXREAL) for each leading zero in an array containing complex coefficients.

Flags

  Infinite Result Exception (–22)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ array ]coefficients | → | [ array ]roots

Example

  Find the roots of the polynomial x4 + 2x3 - 25x2 - 26x + 120: Command: [ 1 2 –25 –26 120 ] PROOT

      Result:   [ 2 –3 4 –5 ]

See also

  PCOEF, PEVAL

## PROPFRAC in app ↑ top

PDF page 299 · printed page 3-179

Type

  Command

Description

  Toggles between an improper fraction and its corresponding integer and fractional part.

Input

  An improper fraction, or an object that evaluates to an improper fraction. It must not contain real numbers. Alternately, the input may be an integer part plus a proper fraction.

Output

  An integer part plus a proper fraction; or alternately, if the input was an integer part plus a proper fraction, an improper fraction.

Flags

  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

  Express the following as a proper fraction: 3 x +4 ------------- 2 x

  Command | PROPFRAC((X^3+4)/X^2))
  Result | X+(4/X^2)

## PRST not in app ↑ top

PDF page 300 · printed page 3-180

Type

  Command

Description

  Print Stack Command: Prints all objects in the stack, starting with the object on the highest level. Objects are printed in multiline printer format. See the PR1 entry for a description of multiline printer format.

Flags

  I/O Device (–33), Printing Device (–34), Double-spaced Printing (–37), Linefeed (–38), I/O Device for Wire (–78). If flag –34 is set, flag –33 must be clear. Generally, flag –38 should be clear.

Input/Output

  None

See also

  CR, DELAY, OLDPRT, PRLCD, PRSTC, PRVAR, PR1

## PRSTC not in app ↑ top

PDF page 300 · printed page 3-180

Type

  Command

Description

  Print Stack (Compact) Command: Prints in compact form all objects in the stack, starting with the object on the highest level. If flag –34 is set (printer output directed to the serial port), flag –33 must be clear. When flag –38 is set, linefeeds are not added at the end of each print line. Generally, flag –38 should be clear for execution of PRSTC. Compact printer format is the same as compact display format. Multiline objects are truncated and appear on one line only.

Flags

  I/O Device (–33), Printing Device (–34), Double-spaced Printing (–37), Linefeed (–38), I/O Device for Wire (–78)

Input/Output

  None

See also

  CR, DELAY, OLDPRT, PRLCD, PRST, PRVAR, PR1

## PRVAR not in app ↑ top

PDF page 300 · printed page 3-180

Type

  Command

Description

  Print Variable Command: Searches the current directory path or port for the specified variables and prints the name and contents of each variable. Objects are printed in multiline printer format. See the PR1 entry for a description of multiline printer format. If flag –34 is set (printer output directed to the serial port), flag –33 must be clear. When flag –38 is set, linefeeds are not added at the end of each print line. Generally, flag –38 should be clear for execution of PRVAR.

Flags

  I/O Device (–33), Printing Device (–34), Double-spaced Printing (–37), Linefeed (–38), I/O Device for Wire (–78). If flag –34 is set, flag –33 must be clear. Generally, flag –38 should be clear.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |
  { name1 name2 ... } | → |
  :nport : `global` | → |

See also

  CR, DELAY, OLDPRT, PR1, PRLCD, PRST, PRSTC

## PSDEV not in app ↑ top

PDF page 301 · printed page 3-181

Type

  Command

Description

  Population Standard Deviation Command: Calculates the population standard deviation of each of the m columns of coordinate values in the current statistics matrix (reserved variable ΣDAT). PSDEV returns a vector of m real numbers, or a single real number if m = 1. The population standard deviation is computed using this formula: n

                                                     1                2

  -- ∑ ( x k – x ) nk = 1

  where xk is the kth coordinate value in a column, x is the mean of the data in this column, and n is the number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xpsdev |
  → | [ xpsdev1 xpsdev2 ... xpsdevm } |

See also

  MEAN, PCOV, PVAR, SDEV, TOT, VAR

## PSI in app ↑ top

PDF page 301 · printed page 3-181

Type

  Function

Description

  Calculates the polygamma function, the nth derivative of the digamma function, at a point a. PSI(a, 0) is equivalent to Psi(a).

Input

  Level 2/Argument 1: A real or complex expression specifying the point a. Level 1/Argument 2: A non-negative integer, n.

Output

  The value of the polygamma function PSI(a, n).

Flags

  Exact mode must be set (flag –105 clear), and numeric mode must not be set (flag –3 clear), if symbolic results are wanted. Complex mode must be set (flag –103 set) if a complex value is used for point a.

See also

  Psi Psi

Type

  Function

Description

  Calculates the digamma function at a point a. The digamma function is the derivative of the natural logarithm (ln) of the gamma function. The function can be represented as follows: ′

                 d                    Γ (z )

  Ψ ( z ) = ----- ( ln Γ ( z )) = ------------

                dz                     Γ (z)

Input

  A real or complex expression specifying the point a.

Output

  The digamma function at the specified point.

Flags

  Exact mode must be set (flag –105 clear), and numeric mode must not be set (flag –3 clear), if symbolic results are wanted. For example, with these settings, Psi(3) evaluates to the symbolic value Psi(3). Complex mode must be set (flag –103 set) if a complex value is used for point a.

See also

  PSI

## PTAYL in app ↑ top

PDF page 302 · printed page 3-182

Type

  Function

Description

  Returns the Taylor polynomial at x = a for a specified polynomial.

Input

  Level 2/Argument 1: A polynomial, P. Level 1/Argument 2: A number, a.

Output

  A polynomial, Q such that Q(x – a)=P(x).

Flags

  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

  Find the polynomial Q(x) such that Q(x-2)=x2+3x+2.

  Command | PTAYL(X^2+3*X+2, 2)
  Result | X^2+7*X+12

## PTPROP not in app ↑ top

PDF page 302 · printed page 3-182

Type

  Function

Description

  Returns the specified property for the specified element. It takes the element’s atomic number or symbol as a name (with certain restrictions) and the property number. It returns the property, usually a value or a string. It chooses to use or not use units according to the Units Usage flag (flag 61: SI units if clear, no units if set). If you use PTPROP as an algebraic function, you must use the symbol to define the element — you can’t use its atomic number. See Appendix B for a full list of available properties.

Flags

  Units Usage (61)

Input/Output

  Level 2 | Level 1 |  | Level 1
  --- | --- | --- | ---
  `symb` | x | → | “string” or x or x_unit or `name`
  y | x | → | “string” or x or x_unit or `name`
  Example 1: The command sequence `Hg` 6 PTPROP returns "[Xe]4f14·5d10·6s2".
  Example 2: The command sequence 79 8 PTPROP returns 1337.58 when flag 61 is set.

See also

  MOLWT, PERINFO, PERTBL

## PURGE in app ↑ top

PDF page 302 · printed page 3-182

Type

  Command

Description

  Purge Command: Purges the named variables or empty subdirectories from the current directory. PURGE executed in a program does not save its argument for recovery by LASTARG. To empty a named directory before purging it, use PGDIR. To help prepare a list of variables for purging, use VARS. Purging PICT replaces the current graphics object with a 0 × 0 graphics object. If a list of objects (with global names, backup objects, library objects, or PICT) for purging contains an invalid object, then the objects preceding the invalid object are purged, and the error Bad Argument Type occurs. To purge a library or backup object, tag the library number or backup name with the appropriate port number (:nport), which must be in the range from 0 to 3. For a backup object, the port

  number can be replaced with the wildcard character &, in which case the calculator will search ports 0 through 2, and then main memory for the named backup object. A library object must be detached before it can be purged from the HOME directory. Neither a library object nor a backup object can be purged if it is currently “referenced” internally by stack pointers (such as an object on the stack, in a local variable, on the LAST stack, or on an internal return stack). This produces the error Object in Use. To avoid these restrictions, use NEWOB before purging. (See NEWOB.)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `global` | → |
  { global1 ... globaln } | → |
  PICT | → |
  :nport :namebackup | → |
  :nport :nlibrary | → |

See also

  CLEAR, CLVAR, NEWOB, PGDIR

## PUSH not in app ↑ top

PDF page 303 · printed page 3-183

Type

  Command

Description

  Saves the current status of the flags, and the current directory path. This allows the user to change the flags or the directory path, then restore them all with the command POP. PUSH is equivalent to saving the results of the commands RCLF and PATH, but it saves them in a stack from which the most recently saved values are recovered by POP, with no need to use named variables. The flags and the path are stored in the CASDIR directory, as a list of lists, in the variable ENVSTACK.

Input

  None.

Output

  Item 1: In Algebraic mode the command returns NOVAL.

See also

  POP, RCLF, STOF

## PUT in app ↑ top

PDF page 303 · printed page 3-183

Type

  Command

Description

  Put Element Command: Replaces the object at a specified position (second input) in a specified array or list (first input) with a specified object (third input). If the array or list is unnamed, returns the new array or list. For matrices, nposition counts in row order.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | nposition | zput | → | [[ matrix ]]2
  [[ matrix ]]1 | { nrow mcol } | zput | → | [[ matrix ]]2
  `namematrix` | nposition | zput | → |
  `namematrix` | { nrow mcol } | zput | → |
  [ vector ]1 | nposition | zput | → | [ vector ]2
  [ vector ]1 | { nposition } | zput | → | [ vector ]2
  `namevector` | nposition | zput | → |
  `namevector` | { nposition } | zput | → |
  { list }1 | nposition | objput | → | { list }2
  { list }1 | { nposition } | objput | → | { list }2
  `namelist` | nposition | objput | → |
  `namelist` { nposition } objput →
      Example 1:      This command sequence:
  [[ 2 3 4 ][ 4 1 2 ]] { 1 3 } 96 PUT returns [[ 2 3 96 ][ 4 1 2 ]].
      Example 2:      The command sequence:
  [[ 2 3 4 ][ 4 1 2 ]] 5 96 PUT returns [[ 2 3 4 ][ 4 96 2 ]].
      Example 3:      The command sequence:
  { A B C D E } { 3 } `Z` PUT returns { A B Z D E }.

See also

  GET, GETI, PUTI

## PUTI in app ↑ top

PDF page 304 · printed page 3-184

Type

  Command

Description

  Put and Increment Index Command: Replaces the object at a specified position (second input) in a specified array or list (first input) with a specified object (third input), returning a new array or list together with the next position in the array or list. For matrices, the position is incremented in row order. Unlike PUT, PUTI returns a named array or list. This enables a subsequent execution of PUTI at the next position of a named array or list.

Flags

  Index Wrap Indicator (–64)

Input/Output

  L3/A1 | L2/A2 | L1/A3 |  | L2/I1 | L1/I2
  --- | --- | --- | --- | --- | ---
  [[ matrix ]]1 | nposition1 | zput | → | [[ matrix ]]2 | nposition2
  [[ matrix ]]1 | { nrow mcol }1 | zput | → | [[ matrix ]]2 | { nrow mcol }2
  `namematrix` | nposition1 | zput | → | `namematrix` | nposition2
  `namematrix` | { nrow mcol }1 | zput | → | `namematrix` | { nrow mcol }2
  [ vector ]1 | nposition1 | zput | → | [ vector ]2 | nposition2
  [ vector ]1 | { nposition1 } | zput | → | [ vector ]2 | { nposition2 }
  `namevector` | nposition1 | zput | → | `namevector` | nposition2
  `namevector` | { nposition1 } | zput | → | `namevector` | { nposition2 }
  { list }1 | nposition1 | objput | → | { list }2 | nposition2
  { list }1 | { nposition1 } | objput | → | { list }2 | { nposition2 }
  `namelist` | nposition1 | objput | → | `namelist` | nposition2
  `namelist` | { nposition1 } | objput | → | `namelist` | { nposition2 }
  L = Level; A = Argument; I = item

Example

      The following program uses PUTI and flag –64 to replace A, B, and C in the list with X. « { A B C } DO `X` PUTI UNTIL -64 FS? END »

See also

  GET, GETI, PUT

## PVAR not in app ↑ top

PDF page 305 · printed page 3-185

Type

  Command

Description

  Population Variance Command: Calculates the population variance of the coordinate values in each of the m columns in the current statistics matrix (ΣDAT). The population variance (equal to the square of the population standard deviation) is returned as a vector of m real numbers, or as a single real number if m = 1. The population variances are computed using this formula: n

                                                               1                2

  -- ∑ ( x k – x ) nk = 1

  where xk is the kth coordinate value in a column, x is the mean of the data in this column, and n is the number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xpvariance |
  → | [ xpvariance1, ...,xpvariancem ] |

See also

  MEAN, PCOV, PSDEV, SDEV, VAR

## PVARS not in app ↑ top

PDF page 305 · printed page 3-185

Type

  Command

Description

  Port-Variables Command: Returns a list of the backup objects (:nport:name) and the library objects (:nport:nlibrary) in the specified port. Also returns the available memory size (RAM). The port number, nport, must be in the range from 0 to 2.

  If nport = 0, then memory is bytes of available main RAM; otherwise memory is bytes of available RAM in the specified port.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  nport | → | { :nport :namebackup ... } | memory
  nport | → | { :nport :nlibrary ... } | memory

See also

  PVARS, VARS

## PVIEW not in app ↑ top

PDF page 306 · printed page 3-186

Type

  Command

Description

  PICT View Command: Displays PICT with the specified coordinate at the upper left corner of the graphics display. PICT must fill the entire display on execution of PVIEW. Thus, if a position other than the upper left corner of PICT is specified, PICT must be large enough to fill a rectangle that extends 131 pixels to the right and 80 pixels down on the HP 50g and 49g+ (64 pixels down on the HP 48gII). If PVIEW is executed from a program with a coordinate argument (versus an empty list), the graphics display persists only until the keyboard is ready for input (for example, until the end of program execution). However, the FREEZE command freezes the display until a key is pressed. If PVIEW is executed with an empty list argument, PICT is centered in the graphics display with scrolling mode activated. In this case, the graphics display persists until −is pressed. PVIEW does not activate the graphics cursor or the Picture menu. To activate the graphics cursor and Picture menu, execute PICTURE.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x,y) | → |
  { #n, #m } | → |
  {} | → |

Example

      The program « { # 0d # 0d } PVIEW 7 FREEZE » displays PICT in the graphics display with coordinates { # 0d # 0d } in the upper left corner of the display, then freezes the full display until a key is pressed.

See also

  FREEZE, PICTURE, TEXT

## PWRFIT in app ↑ top

PDF page 306 · printed page 3-186

Type

  Command

Description

  Power Curve Fit Command: Stores PWRFIT as the fifth parameter in the reserved variable ΣPAR, indicating that subsequent executions of LR are to use the power curve fitting model. LINFIT is the default specification in ΣPAR.

Input/Output

  None

See also

  BESTFIT, EXPFIT, LINFIT, LOGFIT, LR

## PX→C not in app ↑ top

PDF page 307 · printed page 3-187

Type

  Command

Description

  Pixel to Complex Command: Converts the specified pixel coordinates to user-unit coordinates. The user-unit coordinates are derived from the (xmin, ymin) and (xmax, ymax) parameters in the reserved variable PPAR. The coordinates correspond to the geometrical center of the pixel.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { #n #m } | → | (x,y)

See also

  C→PX

## →Q in app ↑ top

PDF page 307 · printed page 3-187

Type

  Command

Description

  To Quotient Command: Returns a rational form of the argument. The rational result is a “best guess”, since there might be more than one rational expression consistent with the argument. →Q finds a quotient of integers that agrees with the argument to within the number of decimal places specified by the display format mode. →Q also acts on numbers that are part of algebraic expressions or equations.

Flags

  Number Display Format (–45 to –50)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | `a/b`
  (x,y) | → | `a/b + c/d*i`
  `symb1` | → | `symb2`

Example

      `Y+2.5` →Q returns `Y+5/2`

See also

  →Qπ, /, XQ

## →Qπ in app ↑ top

PDF page 307 · printed page 3-187

Type

  Command

Description

  To Quotient Times π Command: Returns a rational form of the argument, or a rational form of the argument with π, square roots, natural logs, and exponentials factored out, whichever yields the smaller denominator. The rational result is a “best guess”, since there might be more than one rational expression consistent with the argument. →Qπ finds a quotient of integers that agrees with the argument to the number of decimal places specified by the display format mode. →Qπ also acts on numbers that are part of algebraic expressions or equations. For a complex argument, the real or imaginary part (or both) can have π as a factor.

Flags

  Number Display Format (–45 to –50)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | `a/b*π`
  x | → | `a/b`
  `symb1` | → | `symb2`
  (x,y) | → | `a/b*π + c/d*π*i`
  (x,y) | → | `a/b + c/d*i`

Example

      In Fix mode to three decimal places, 6.2832 →Qπ returns `44/7`. In Standard mode, however, 6.2832 →Qπ returns `3927/625`.

See also

  →Q, /, XQ, π

## qr in app ↑ top

PDF page 308 · printed page 3-188

Type

  Command

Description

  qr Factorization of a square Matrix Command: Returns the qr factorization of an n × n matrix. qr factors an n × n matrix A into two matrices:

  - Q is an n × m orthogonal matrix.
  - R is an n × n triangular matrix. Where A = Q × R.
Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  [[ matrix ]]A | → | [[ matrix ]]Q | [[ matrix ]]R

See also

  LQ, LSQ QR

Type

  Command

Description

  QR Factorization of a Matrix Command: Returns the QR factorization of an m × n matrix. QR factors an m × n matrix A into three matrices:

  - Q is an m × m orthogonal matrix.
  - R is an m × n upper trapezoidal matrix.
  - P is a n × n permutation matrix. Where A × P = Q × R.
Input/Output

  Level 1/Argument 1 |  | Level 3/Item 1 | Level 2/Item 2 | Level 1/Item 3
  --- | --- | --- | --- | ---
  [[ matrix ]]A | → | [[ matrix ]]Q | [[ matrix ]]R | [[ matrix ]]P

See also

  LQ, LSQ

## QUAD not in app ↑ top

PDF page 308 · printed page 3-188

Type

  Command

Description

  Solve Quadratic Equation Command: This command is identical to the computer algebra command SOLVE, and is included for backward compatibility with the HP 48G series.

Flags

  Principal Solution (–1)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  `symb1` | `global` | → | `symb2`

See also

  COLCT, EXPAN, ISOL, SHOW, SOLVE

## QUOT in app ↑ top

PDF page 309 · printed page 3-189

Type

  Function

Description

  Returns the quotient part of the Euclidean division of two polynomials.

Input

  Level 2/Argument 1: The numerator polynomial. Level 1/Argument 2: The denominator polynomial.

Output

  The quotient of the Euclidean division.

Flags

  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).

                                             3      2              2

Example

  Find the quotient of the division of x + 6 x + 11 x + 6 by x + 5 x + 6 .

      Command:          QUOT(X^3+6*X^2+11*X+6, X^2+5*X+6)

Result

  X+1

See also

  REMAINDER, DIV2, IQUOT

## QUOTE not in app ↑ top

PDF page 309 · printed page 3-189

Type

  Function

Description

  Quote Argument Function: Returns its argument unevaluated. When an algebraic expression is evaluated, the arguments to a function in the expression are evaluated before the function. For example, when SIN(X) is evaluated, the name X is evaluated first, and the result is placed on the stack as the argument for SIN. This process creates a problem for functions that require symbolic arguments. For example, the integration function requires as one of its arguments a name specifying the variable of integration. If evaluating an integral expression caused the name to be evaluated, the result of evaluation would be left on the stack for the integral, rather than the name itself. To avoid this problem, the calculator automatically (and invisibly) quotes such arguments. When the quoted argument is evaluated, the unquoted argument is returned. If a user-defined function takes symbolic arguments, quote the arguments using QUOTE.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → | obj

Example

      The following user-defined function ArcLen calculates the arc length of a function:
             « → start end expr var
          « start end expr var ˆ SQ 1 + ƒ var » » `OArcLen K To use this user-defined function in an algebraic expression, the symbolic arguments must be quoted: `ArcLen(0,π,QUOTE(SIN(X)),QUOTE(X))`

See also

  APPLY, | (Where)

## QXA not in app ↑ top

PDF page 310 · printed page 3-190

Type

  Command

Description

  Expresses a quadratic form in matrix form.

Input

  Level 2/Argument 1: A quadratic form. Level 1/Argument 2: A vector containing the variables.

Output

  Level 2/Item 1: The quadratic form expressed in matrix form. Level 1/Item 2: The vector containing the variables.

Flags

  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

  Express the following quadratic form in matrix form:

                       2           2

  x + xy + y

      Command:        QXA(X^2+X*Y+Y^2, [X,Y])

Result

  {[[1,1/2][1/2,1]],[X,Y]}

See also

  AXQ, GAUSS, SYLVESTER

## RAD in app ↑ top

PDF page 310 · printed page 3-190

Type

  Command

Description

  Radians Mode Command: Sets Radians angle mode. RAD sets flag –17 and clears flag –18, and displays the RAD annunciator. In Radians angle mode, real-number arguments that represent angles are interpreted as radians, and real-number results that represent angles are expressed in radians.

Input/Output

  None

See also

  DEG, GRAD

## RAND in app ↑ top

PDF page 310 · printed page 3-190

Type

  Command

Description

  Random Number Command: Returns a pseudo-random number generated using a seed value, and updates the seed value. The calculator uses a linear congruential method and a seed value to generate a random number xrandom in the range 0 ≤ x < 1. Each succeeding execution of RAND returns a value computed from a seed value based upon the previous RAND value. (Use RDZ to change the seed.)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xrandom |

See also

  COMB, PERM RDZ, !

## RANK in app ↑ top

PDF page 310 · printed page 3-190

Type

  Command

Description

  Matrix Rank Command: Returns the rank of a rectangular matrix.

  Rank is computed by calculating the singular values of the matrix and counting the number of non-negligible values. If all computed singular values are zero, RANK returns zero. Otherwise RANK consults flag –54 as follows:

  - If flag –54 is clear (the default), RANK counts all computed singular values that are less than or equal to 1.E–14 times the largest computed singular value.
  - If flag –54 is set, RANK counts all nonzero computed singular values.
Flags

  Singular Value (–54)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]] | → | Nrank

See also

  LQ, LSQ, QR

## RANM in app ↑ top

PDF page 311 · printed page 3-191

Type

  Command

Description

  Random Matrix Command: Returns a matrix of specified dimensions that contains random integers in the range –9 through 9. The probability of a particular nonzero digit occurring is 0.05; the probability of 0 occurring is 0.1.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  {mn} | → | [[ random matrix ]]m×n
  [[ matrix ]]m×n | → | [[ random matrix ]]m×n

See also

  RAND, RDZ

## RATIO not in app ↑ top

PDF page 311 · printed page 3-191

Type

  Function

Description

  Prefix Divide Function: Prefix form of / (divide). RATIO is identical to / (divide), except that, in algebraic syntax, RATIO is a prefix function, while / is an infix function. For example, RATIO(A,2) is equivalent to A/2.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | z2 | → | z1/z2
  [ array ] | {[ matrix ]] | → | [[ array × matrix–1]]
  [ array ] | z | → | [ array/z ]
  z | `symb` | → | `z/symb`
  `symb` | z | → | `symb/z`
  `symb1` | `symb2` | → | `symb1/symb2`
  #n1 | n2 | → | #n3
  n1 | #n2 | → | #n3
  #n1 | #n2 | → | #n3
  x_unit1 | y_unit2 | → | (x/y)_unit1/unit2
  x | y_unit | → | (x/y)_1/unit
  x_unit | y | → | (x/y)_unit
  `symb` | x_unit | → | `symb/x_unit`
  x_unit | `symb` | → | `x_unit/symb`

See also

  /

## RCEQ not in app ↑ top

PDF page 312 · printed page 3-192

Type

  Command

Description

  Recall from EQ Command: Returns the unevaluated contents of the reserved variable EQ from the current directory. To recall the contents of EQ from a parent directory (when EQ doesn’t exist in the current directory) evaluate the name EQ.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | objEQ |

See also

  STEQ

## RCI in app ↑ top

PDF page 312 · printed page 3-192

Type

  Command

Description

  Multiply Row by Constant Command: Multiplies row n of a matrix (or element n of a vector) by a constant xfactor, and returns the modified matrix. RCI rounds the row number to the nearest integer, and treats vector arguments as column vectors.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | xfactor | nrow number | → | [[ matrix ]]3
  [ vector ]1 | xfactor | nelement number | → | [ vector ]2

See also

  RCIJ

## RCIJ in app ↑ top

PDF page 312 · printed page 3-192

Type

  Command

Description

  Add Multiplied Row Command: Multiplies row i of a matrix by a constant xfactor, adds this product to row j of the matrix, and returns the modified matrix; or multiplies element i of a vector

  by a constant xfactor, adds this product to element j of the vector, and returns the modified vector. RCIJ rounds the row numbers to the nearest integer, and treats vector arguments as column vectors.

Input/Output

  Level 4/Argument 1 Level 3/Argument 2 Level 2/Argument 3 Level 1/Argument 4 | Level 1/Item 1 |  |  |  |
  --- | --- | --- | --- | --- | ---
  [[ matrix ]]1 | xfactor | nrow i | nrow j | → [[ matrix ]]2 |
  [ vector ]1 | xfactor | nelement i | nelement j | → | [ vector ]2

See also

  RCI

## RCL in app ↑ top

PDF page 313 · printed page 3-193

Type

  Command Operation

Description

  Recall Command: Returns the unevaluated contents of a specified variable. RCL searches the entire current path, starting with the current directory. To search a different path, specify { path name }, where path is the new path to the variable name. The path subdirectory does not become the current subdirectory (unlike EVAL). To recall a library or backup object, tag the library number or backup name with the appropriate port number (nport), which must be an integer in the range 0 to 3. Recalling a backup object brings a copy of its contents to the stack, not the entire backup object. To search for a backup object, replace the port number with the wildcard character &, in which case the calculator will search (in order) ports 0 through 3, and the main memory for the named backup object. You can specify a port (that is, nport) in one of two ways:

  - H, 0, 1, 2, or 3
  - H, R, E, F, or SD In each case, the ports are home, RAM, extended RAM, flash memory, and the plug-in SD card slot, respectively.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `obj` | → | obj
  PICT | → | grob
  :nport :nlibrary | → | obj
  :nport :namebackup | → | obj
  :nport :{ path } | → | obj

See also

  STO

## RCLALARM not in app ↑ top

PDF page 313 · printed page 3-193

Type

  Command

Description

  Recall Alarm Command: Recalls a specified alarm. objaction is the alarm execution action. If an execution action was not specified, objaction defaults to an empty string. xrepeat is the repeat interval in clock ticks, where 1 clock tick equals 1/8192 second. If a repeat interval was not specified, the default is 0.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nindex | → | { date time objaction xrepeat }

See also

  DELALARM, FINDALARM, STOALARM

## RCLF in app ↑ top

PDF page 314 · printed page 3-194

Type

  Command

Description

  Recall Flags Command: Returns a list of integers representing the states of the system and user flags, respectively. A bit with value 1 indicates that the corresponding flag is set; a bit with value 0 indicates that the corresponding flag is clear. The rightmost (least significant) bit of #nsystem and #nuser indicate the states of system flag –1 and user flag +1, respectively. Used with STOF, RCLF lets a program that alters the state of a flag or flags during program execution preserve the pre-program-execution flag status.

Flags

  Binary Integer Wordsize (–5 through –10)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | { #nsystem #nuser #nsystem2 #nuser2 } |

See also

  STOF, PUSH, POP

## RCLKEYS not in app ↑ top

PDF page 314 · printed page 3-194

Type

  Command

Description

  Recall Key Assignments Command: Returns the current user key assignments. This includes an S if the standard definitions are active (not suppressed) for those keys without user key assignments. The argument xkey is a real number of the form rc.p specifying the key by its row number r, its column number c, and its plane (shift) p. (For a definition of plane, see the entry for ASN.)

Flags

  User-Mode Lock (–61) and User Mode (–62) affect the status of the user keyboard

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | { obj1, xkey 1, ... ,objn, xkey n } |
  → | { S, obj1, xkey 1, ... objn, xkey n } |

See also

  ASN, DELKEYS, STOKEYS

## RCLMENU not in app ↑ top

PDF page 314 · printed page 3-194

Type

  Command

Description

  Recall Menu Number Command: Returns the menu number of the currently displayed menu. xmenu has the form mm.pp, where mm is the menu number and pp is the page of the menu.

  Executing RCLMENU when the current menu is a user-defined menu (build by TMENU) returns 0.01 (in 2 Fix mode), indicating “Last menu”.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xmenu |

Example

  If the third page of the PRG STACK menu is currently active, RCLMENU returns 73.03.

See also

  MENU, TMENU

## RCLVX not in app ↑ top

PDF page 315 · printed page 3-195

Type

  Command

Description

  Returns the name or list of names stored in the current CAS variable. This is the same action as recalling the contents of the variable VX in the CASDIR directory.

Input

  None.

Output

  Level 1/Item 1: The name of the current CAS variable.

See also

  STOVX

## RCLΣ not in app ↑ top

PDF page 315 · printed page 3-195

Type

  Command

Description

  Recall Sigma Command: Returns the current statistical matrix (the contents of reserved variable ΣDAT) from the current directory. To recall ΣDAT from the parent directory (when ΣDAT doesn’t exist in the current directory), evaluate the name ΣDAT.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | obj |

See also

  CLΣ, STOΣ, Σ+, Σ–

## RCWS in app ↑ top

PDF page 315 · printed page 3-195

Type

  Command

Description

  Recall Wordsize Command: Returns the current wordsize in bits (1 through 64).

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | n |

See also

  BIN, DEC, HEX, OCT, STWS

## RDM in app ↑ top

PDF page 315 · printed page 3-195

Type

  Command

Description

  Redimension Array Command: Rearranges the elements of the argument according to specified dimensions.

  If the list contains a single number nelements, the result is an n-element vector. If the list contains two numbers nrows and mcols, the result is an n × m matrix. Elements taken from the argument vector or matrix preserve the same row order in the resulting vector or matrix. If the result is dimensioned to contain fewer elements than the argument vector or matrix, excess elements from the argument vector or matrix at the end of the row order are discarded. If the result is dimensioned to contain more elements than the argument vector or matrix, the additional elements in the result at the end of the row order are filled with zeros. If the argument vector or matrix is specified by global, the result replaces the argument as the contents of the variable.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  [ vector ]1 | { nelements } | → | [ vector ]2
  [ vector ] | { nrows, mcols } | → | [[ matrix ]]
  [[ matrix ]] | { nelements } | → | [ vector ]
  [[ matrix ]]1 | { nrows, mcols } | → | [[ matrix ]]2
  `global` | { nelements } | → |
  `global` { nrows, mcols } →
  Example 1: | [ 2 4 6 8 ] { 2 2 } RDM returns [[ 2 4 ][ 6 8 ]].
  --- | ---
  Example 2: | [[ 2 3 4][ 1 6 9 ]] 8 RDM returns [ 2 3 4 1 6 9 0 0 ].

See also

  TRN

## RDZ in app ↑ top

PDF page 316 · printed page 3-196

Type

  Command

Description

  Randomize Command: Uses a real number xseed as a seed for the RAND command. If the argument is 0, a random value based on the system clock is used as the seed.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xseed | → |

See also

  COMB, PERM, RAND, !

## RE in app ↑ top

PDF page 316 · printed page 3-196

Type

  Function

Description

  Real Part Function: Returns the real part of the argument. If the argument is a vector or matrix, RE returns a real array, the elements of which are equal to the real parts of the corresponding elements of the argument array.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | x
  x_unit | → | x
  (x,y) | → | x
  [ R-array ] | → | [ R-array ]
  [ C-array ] | → | [ R-array ]
  `symb` | → | `RE(symb`)

See also

  C→R, IM, R→C

## RECN not in app ↑ top

PDF page 317 · printed page 3-197

Type

  Command

Description

  Receive Renamed Object Command: Prepares the calculator to receive a file from another Kermit server device, and to store the file in a specified variable. RECN is identical to RECV except that the name under which the received data is stored is specified.

Flags

  I/O Device flag (–33), I/O Data Format (–35), RECV Overwrite (–36), I/O Messages (–39), I/O Device for Wire (–78)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |
  “name” | → |

See also

  BAUD, CKSM, CLOSEIO, FINISH, KERRM, KGET, PARITY, RECV, SEND, SERVER, TRANSIO

## RECT in app ↑ top

PDF page 317 · printed page 3-197

Type

  Command

Description

  Rectangular Mode Command: Sets Rectangular coordinate mode. RECT clears flags –15 and –16. In Rectangular mode, vectors are displayed as rectangular components. Therefore, a 3D vector would appear as [X Y Z].

Input/Output

  None

See also

  CYLIN, SPHERE

## RECV not in app ↑ top

PDF page 317 · printed page 3-197

Type

  Command

Description

  Receive Object Command: Instructs the calculator to look for a named file from another Kermit server device. The received file is stored in a variable named by the sender. Since the calculator does not normally look for incoming Kermit files, you must use RECV to tell it to do so.

Flags

  I/O Device flag (–33), I/O Data Format (–35), RECV Overwrite (–36), I/O Messages (–39), I/O Device for Wire (–78)

Input/Output

  None

See also

  BAUD, CKSM, FINISH, KGET, PARITY, RECN, SEND, SERVER, TRANSIO

## REF in app ↑ top

PDF page 318 · printed page 3-198

Type

  Command

Description

  Reduces a matrix to echelon form. This is a subdiagonal reduction (Gauss, not Gauss-Jordan).

Input

  A real or complex matrix.

Output

  The equivalent matrix in echelon form.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). Complex mode must be set (flag –103 set) if the input is complex.

See also

  rref, RREFMOD

## REMAINDER in app ↑ top

PDF page 318 · printed page 3-198

Type

  Function

Description

  Returns the remainder of the Euclidean division of two polynomials.

Input

  Level 2/Argument 1: The numerator polynomial. Level 1/Argument 2: The denominator polynomial.

Output

  The remainder resulting from the Euclidean division.

Flags

  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). Complex mode must be set (flag –103 set) if either input is complex.

                                                3   2               2

Example

  Find the remainder of the division of x + 6 x + 11 x + 6 by x + 5 x + 6 .

  Command | REMAINDER(X^3+6*X^2+11*X+6, X^2+5*X+6)
  Result | 0

See also

  QUOT

## RENAME not in app ↑ top

PDF page 318 · printed page 3-198

Type

  Command

Description

  Rename Object Command: Renames an object to the name that you specify.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  new `name` | old `name` | → |

See also

  COPY

## REORDER not in app ↑ top

PDF page 319 · printed page 3-199

Type

  Function

Description

  Given a polynomial expression and a variable, reorders the variables in the expression in the order of powers set on the CAS Modes screen, that is, either in increasing or decreasing order.

Input

  Level 2/Argument 1: The polynomial expression. Level 1/Argument 2: The variable with respect to which the reordering is performed.

Output

  The reordered expression.

Flags

  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). Complex mode must be set (flag –103 set) if the polynomial contains complex terms. The polynomial terms order flag (flag –114) must be set for increasing power order, or clear (the default) for decreasing power order.

Example

  Reorder the polynomial x2 + 2y2 +2x +3y in order of powers of y. Assume that increasing power mode has been set in the CAS modes.

  Command | REORDER(X^2+2*Y^2+2*X+6+3*Y, Y)
  Result | 2*Y^2+3*Y+(X^2+2*X)

## REPEAT not in app ↑ top

PDF page 319 · printed page 3-199

Type

  Command

Description

  REPEAT Command: Starts loop clause in WHILE … REPEAT … END indefinite loop structure. See the WHILE entry for more information.

Input/Output

  None

See also

  END, WHILE

## REPL in app ↑ top

PDF page 319 · printed page 3-199

Type

  Command

Description

  Replace Command: Replaces a portion of the target object (first input) with a specified object (third input), beginning at a specified position (second input). For arrays, nposition counts in row order. For matrices, nposition specifies the new location of the upper left-hand element of the replacement matrix. For graphics objects, the upper left corner of grob1 is positioned at the user-unit or pixel coordinates (x,y) or { #n #m }. From there, it overwrites a rectangular portion of grobtarget or PICT. If grob1 extends past grobtarget or PICT in either direction, it is truncated in that direction. If the specified coordinate is not on the target graphics object, the target graphics object does not change.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | nposition | [[ matrix ]]2 | → | [[ matrix ]]3
  [[ matrix ]]1 | { nrow, ncolumn } | [[ matrix ]]2 | → | [[ matrix ]]3
  [ vector ]1 | nposition | [ vector ]2 | → | [ vector ]3
  { listtarget } | nposition | { list1 } | → | { listresult }
  “stringtarget” | nposition | “string1” | → | “stringresult”
  grobtarget | (#n, #m) | grob1 | → | grobresult
  grobtarget | (x,y) | grob1 | → | grobresult
  PICT | (#n, #m) | grob1 | → |
  PICT | (x,y) | grob1 | → |
  Example 1: [[ 1 1 1 1 ][ 1 1 1 1 ][ 1 1 1 1 ]] 6 [[ 2 2 ][ 2 2 ]]
  REPL returns [[ 1 1 1 1 ][ 1 2 2 1 ][ 1 2 2 1 ]].
  Example 2: | { A B C D E } 2 { F G } REPL returns { A F G D E }.
  --- | ---
  Example 3: | ERASE PICT (0,0) # 5d # 5d BLANK NEG REPL replaces a portion of
  PICT with a 5 x 5 graphics object, each of whose pixels is on (dark), and whose upper left corner is positioned at (0,0) in PICT.

See also

  CHR, GOR, GXOR, NUM, POS, SIZE, SUB

## RES not in app ↑ top

PDF page 320 · printed page 3-200

Type

  Command

Description

  Resolution Command: Specifies the resolution of mathematical and statistical plots, where the resolution is the interval between values of the independent variable used to generate the plot. A real number ninterval specifies the interval in user units. A binary integer #ninterval specifies the interval in pixels. The resolution is stored as the fourth item in PPAR, with default value 0. The interpretation of the default value is summarized in the following table.

  Plot Type | Default Interval
  --- | ---
  BAR | 10 pixels (bar width = 10 pixel columns)
  DIFFEQ | unlimited: step size is not constrained
  FUNCTION | 2 pixels (plots a point in every other column of pixels)
  CONIC | 2 pixels (plots a point in every other column of pixels)
  TRUTH | 2 pixels (plots a point in every other column of pixels)
  GRIDMAP | RES does not apply
  HISTOGRAM | 10 pixels (bin width = 10 pixel columns)
  PARAMETRIC | [independent variable range in user units]/130
  PARSURFACE | RES does not apply
  Plot Type | Default Interval
  PCONTOUR | RES does not apply
  POLAR | 2°, 2 grads, or π/90 radians
  SCATTER | RES does not apply
  SLOPEFIELD | RES does not apply
  WIREFRAME | RES does not apply
  YSLICE | 2 pixels (plots a point in every other column of pixels)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  ninterval | → |
  #ninterval | → |

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## RESTORE not in app ↑ top

PDF page 321 · printed page 3-201

Type

  Command

Description

  Restore HOME Command: Replaces the current HOME directory with the specified backup copy (:nport:namebackup) previously created by ARCHIVE. The specified port number must be in the range 0 to 3. To restore a HOME directory that was saved on a remote system using :IO:name ARCHIVE, put the backup object itself on the stack, execute RESTORE and then execute a warm start.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  :nport :namebackup | → |
  backup | → |

Example

      To restore a HOME directory that was saved as the file AUG1 on a remote system, execute `AUG1` SEND on the remote system, then execute the following on the local calculator: RECV `AUG1` RCL RESTORE

See also

  ARCHIVE

## RESULTANT not in app ↑ top

PDF page 321 · printed page 3-201

Type

  Function

Description

  Returns the resultant of two polynomials of the current variable. That is, it returns the determinant of the Sylvester matrix of the two polynomials.

Input

  Level 2/Argument 1: The first polynomial. Level 1/Argument 2: The second polynomial.

Output

  The determinant of the two matrices that correspond to the polynomials.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). Complex mode must be set (flag –103 set) if either input contains complex terms.

Example

  Obtain the resultant of the two polynomials x3-px+q and 3x2-p.

  Command | RESULTANT(X^3-P*X+Q, 3*X^2-P)
  Result | 27*Q^2-4*P^3

## REVLIST in app ↑ top

PDF page 322 · printed page 3-202

Type

  Command

Description

  Reverse List Command: Reverses the order of the elements in a list.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { objn ... obj1 } | → | { obj1 ... objn }

See also

  SORT

## REWRITE not in app ↑ top

PDF page 322 · printed page 3-202

Type

  Command

Description

  Displays a menu or list of CAS operations that rewrite expressions.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, TESTS, TRIGO

## RISCH not in app ↑ top

PDF page 322 · printed page 3-202

Type

  Function

Description

  Performs symbolic integration on a function using the Risch algorithm. RISCH is similar to the INTVX command, except that it allows you to specify the variable of integration.

Input

  Level 2/Argument 1: The function to integrate. Level 1/Argument 2: The variable of integration.

Output

  The antiderivative of the function with respect to the variable.

Flags

  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

  Find the antiderivative of the following function, with respect to y: 2 y + 3y + 2

  Command | RISCH(Y^2-3*Y+2,Y)
  Result | 1/3*Y^3-3*(1/2*Y^2)+2*Y

See also

  IBP, INT, INTVX

## RKF not in app ↑ top

PDF page 323 · printed page 3-203

Type

  Command

Description

  Solve for Initial Values (Runge–Kutta–Fehlberg) Command: Computes the solution to an initial value problem for a differential equation, using the Runge-Kutta-Fehlberg (4,5) method. RKF solves y`(t) = f(t,y), where y(t0) = y0. The arguments and results are as follows:

  - { list } contains three items in this order: the independent (t) and solution (y) variables, and the right-hand side of the differential equation (or a variable where the expression is stored).
  - xtol sets the absolute error tolerance. If a list is used, the first value is the absolute error tolerance and the second value is the initial candidate step size.
  - xTfinal specifies the final value of the independent variable. RKF repeatedly calls RKFSTEP as it steps from the initial value to xTfinal.
Input/Output

  L3/A1 | L2/A2 | L1/A3 |  | L2/I1 | L1/I2
  --- | --- | --- | --- | --- | ---
  { list } | xtol | xT final | → | { list } | xtol
  { list } | { xtol xhstep } | xT final | → | { list } | xtol
  L = Level; A = Argument; I = item

Example

  Solve the following initial value problem for y(8), given that y(0) = 0: 1

                                            y′ =           − 2 y 2 = f (t , y )

  1+ t 2 1. Store the independent variable’s initial value, 0, in T. 2. Store the dependent variable’s initial value, 0, in Y. 1

      3. Store the expression,           − 2 y 2 , in F.

  1+ t 2

  4. Enter a list containing these three items: { T Y F }. 5. Enter the tolerance. Use estimated decimal place accuracy as a guideline for choosing a tolerance: 0.00001. 6. Enter the final value for the independent variable: 8. The stack should look like this: { T Y F } .00001 8 7. Press RKF. The variable T now contains 8, and Y now contains the value .123077277659. The actual answer is .123076923077, so the calculated answer has an error of approximately .00000035, well within the specified tolerance.

See also

  RKFERR, RKFSTEP, RRK, RRKSTEP, RSBERR

## RKFERR not in app ↑ top

PDF page 323 · printed page 3-203

Type

  Command

Description

  Error Estimate for Runge–Kutta–Fehlberg Method Command: Returns the absolute error estimate for a given step h when solving an initial value problem for a differential equation. The arguments and results are as follows:

  - { list } contains three items in this order: the independent (t) and solution (y) variables, and the right-hand side of the differential equation (or a variable where the expression is stored).
  - h is a real number that specifies the step.
  - ydelta displays the change in solution for the specified step.
  - error displays the absolute error for that step. A zero error indicates that the Runge–Kutta– Fehlberg method failed and that Euler’s method was used instead. The absolute error is the absolute value of the estimated error for a scalar problem, and the row (infinity) norm of the estimated error vector for a vector problem. (The latter is a bound on the maximum error of any component of the solution.)
Input/Output

  L2/A1 | L1/A2 |  | L4/I1 | L3/I2 | L2/I3 | L1/I4
  --- | --- | --- | --- | --- | --- | ---
  { list } | h | → | { list } | h | ydelta | error
  L = Level; A = Argument; I = item

See also

  RKF, RKFSTEP, RRK, RRKSTEP, RSBERR

## RKFSTEP not in app ↑ top

PDF page 324 · printed page 3-204

Type

  Command

Description

  Next Solution Step for RKF Command: Computes the next solution step (hnext) to an initial value problem for a differential equation. The arguments and results are as follows:

  - { list } contains three items in this order: the independent (t) and solution (y) variables, and the right-hand side of the differential equation (or a variable where the expression is stored).
  - xtol sets the tolerance value.
  - h specifies the initial candidate step.
  - hnext is the next candidate step. The independent and solution variables must have values stored in them. RKFSTEP steps these variables to the next point upon completion. Note that the actual step used by RKFSTEP will be less than the input value h if the global error tolerance is not satisfied by that value. If a stringent global error tolerance forces RKFSTEP to reduce its stepsize to the point that the Runge–Kutta–Fehlberg methods fails, then RKFSTEP will use the Euler method to compute the next solution step and will consider the error tolerance satisfied. The Runge-Kutta-Fehlberg method will fail if the current independent variable is zero and the stepsize ≤ 1.3 × 10-498 or if the variable is nonzero and the stepsize is 1.3 × 10-10 times its magnitude.
Input/Output

  L3/A1 | L2/An | L1/An+1 |  | L3/I1 | L2/I2 | L1/I3
  --- | --- | --- | --- | --- | --- | ---
  { list } | xtol | h | → | { list } | xtol | hnext
  L = Level; A = Argument; I = item

See also

  RKF, RKFERR, RRK, RRKSTEP, RSBERR

## RL in app ↑ top

PDF page 324 · printed page 3-204

Type

  Command

Description

  Rotate Left Command: Rotates a binary integer one bit to the left. The leftmost bit of #n1 becomes the rightmost bit of #n2.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  RLB, RR, RRB

## RLB in app ↑ top

PDF page 325 · printed page 3-205

Type

  Command

Description

  Rotate Left Byte Command: Rotates a binary integer one byte to the left. The leftmost byte of #n1 becomes the rightmost byte of #n2. RLB is equivalent to executing RL eight times.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  RL, RR, RRB

## RND in app ↑ top

PDF page 325 · printed page 3-205

Type

  Function

Description

  Round Function: Rounds an object to a specified number of decimal places or significant digits, or to fit the current display format. nround (or symbround if flag –3 is set) controls how the level 2 argument is rounded, as follows:

  nround or symbround | Effect on Level 2 Argument
  --- | ---
  0 through 11 | Rounded to n decimal places.
  –1 through –11 | Rounded to n significant digits.
  12 | Rounded to the current display format.

  For complex numbers and arrays, each real number element is rounded. For unit objects, the numerical part of the object is rounded.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | nround | → | z2
  z | `symbround` | → | `RND(symbround)`
  `symb` | nround | → | `RND(symb,nround)`
  `symb1` | `symbround` | → | `RND(`symb1, symbround)`
  [ array1 ] | nround | → | [ array2 ]
  x_unit | nround | → | y_unit
  x_unit | `symbround` → | `RND(x_unit, symbround)` |
  Example 1: (4.5792,8.1275) 2 RND returns (4.58,8.13).
  Example 2: [ 2.34907 3.96351 2.73453 ] -2 RND returns [ 2.3 4 2.7 ].

See also

  TRNC

## RNRM in app ↑ top

PDF page 326 · printed page 3-206

Type

  Command

Description

  Row Norm Command: Returns the row norm (infinity norm) of its argument array. The row norm is the maximum (over all rows) of the sums of the absolute values of all elements in each row. For a vector, the row norm is the largest absolute value of any of its elements.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ array ] | → | xrow norm

See also

  CNRM, CROSS, DET, DOT

## ROLL in app ↑ top

PDF page 326 · printed page 3-206

Type

  RPL command

Description

  Roll Objects Command: Moves the contents of a specified level to level 1, and rolls upwards the portion of the stack beneath the specified level. In RPN mode, 3 ROLL is equivalent to ROT.

Input/Output

  Ln+1... L2 | L1 |  | Ln ... | L2 | L1
  --- | --- | --- | --- | --- | ---
  objn ... obj1 | n | → | objn–1 ... | obj1 | objn
  L = Level

See also

  OVER, PICK, ROLLD, ROT, SWAP

## ROLLD in app ↑ top

PDF page 326 · printed page 3-206

Type

  RPL command

Description

  Roll Down Command: Moves the contents of level 2 to a specified level, n, and rolls downward the portion of the stack beneath the specified level.

Input/Output

  Ln+1... L2 | L1 |  | Ln | Ln–1 ... | L1
  --- | --- | --- | --- | --- | ---
  objn ... obj2 | n (obj1) | → | obj1 | objn ... | obj2
  L = Level

See also

  OVER, PICK, ROLL, ROT, SWAP

## ROMUPLOAD not in app ↑ top

PDF page 326 · printed page 3-206

Type

  Command

Description

  This command remains from earlier HP graphing calculators and should not be used. It was used to transfer the ROM from one HP 49G to another.

## ROOT not in app ↑ top

PDF page 327 · printed page 3-207

Type

  Command

Description

  Root-Finder Command: Returns a real number xroot that is a value of the specified variable global for which the specified program or algebraic object most nearly evaluates to zero or a local extremum. ROOT is the programmable form of the HP Solve application. guess is an initial estimate of the solution. ROOT produces an error if it cannot find a solution, returning the message Bad Guess(es) if one or more of the guesses lie outside the domain of the equation, or returns the message Constant? if the equation returns the same value at every sample point. ROOT does not return interpretive messages when a root is found.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  «program» | `global` | guess | → | xroot
  «program» | `global` | { guesses } | → | xroot
  `symb` | `global` | guess | → | xroot
  `symb` | `global` | { guesses } | → | xroot

## ROT in app ↑ top

PDF page 327 · printed page 3-207

Type

  RPL Command

Description

  Rotate Objects Command: Rotates the first three objects on the stack, moving the object on level 3 to level 1. In RPN mode, ROT is equivalent to 3 ROLL.

Input/Output

  L3 | L2 | L1 |  | L3 | L2 | L1
  --- | --- | --- | --- | --- | --- | ---
  obj3 | obj2 | obj1 | → | obj2 | obj1 | obj3
  L = Level

See also

  OVER, PICK, ROLL, ROLLD, SWAP, UNROT

## ROW– not in app ↑ top

PDF page 327 · printed page 3-207

Type

  Command

Description

  Delete Row Command: Deletes row n of a matrix (or element n of a vector), and returns the modified matrix (or vector) and the deleted row (or element). nrow or nelement is rounded to the nearest integer.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | nrow | → | [[ matrix ]]2 | [ vector ]row
  [ vector ]1 | nelement | → | [ vector ]2 | elementn

See also

  COL–, COL+, ROW+, RSWP

## ROW+ in app ↑ top

PDF page 328 · printed page 3-208

Type

  Command

Description

  Insert Row Command: Inserts an array into a matrix (or one or more numbers into a vector) at the position indicated by nindex, and returns the modified matrix (or vector). The inserted array must have the same number of columns as the target array. nindex is rounded to the nearest integer. The original array is redimensioned to include the new columns or elements, and the elements at and below the insertion point are shifted down.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | [[ matrix ]]2 | nindex | → | [[ matrix ]]3
  [[ matrix ]]1 | [ vector ]row | nindex | → | [[ matrix ]]2
  [ vector ]1 | nelement | nindex | → | [ vector ]2

See also

  COL–, COL+, ROW–, RSWP

## ROW→ in app ↑ top

PDF page 328 · printed page 3-208

Type

  Command

Description

  Rows to Matrix Command: Transforms a series of row vectors and a row count into a matrix containing those rows, or transforms a sequence of numbers and an element count into a vector with those numbers as elements.

Input/Output

  Ln+1/A1 7 | L2/An | L1/An+1 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [ vector ]row 1 + | [ vector ]row n | nrow count | → | [[ matrix ]]
  element1 + | elementn | nelement count | → | [ vector ]column
  L = Level; A = Argument; I = item

See also

  →COL, COL→, →ROW

## →ROW in app ↑ top

PDF page 328 · printed page 3-208

Type

  Command

Description

  Matrix to Rows Command: Transforms a matrix into a series of row vectors, returning the vectors and row count, or transforms a vector into its elements, returning the elements and element count.

Input/Output

  L1/Argument1 |  | Ln+1/I1 7 L2/In | L1/In+1
  --- | --- | --- | ---
  [[ matrix ]] | → | [ vector ]row n … [ vector ]row n | nrowcount
  [ vector ] | → | element1 … elementn | nelementcount
  L =Level; A = Argument; I = Item

See also

  →COL, COL→, ROW→

## RPL> not in app ↑ top

PDF page 329 · printed page 3-209

Type

  Command

Description

  User RPL program function. This function allows for the entry and execution of User RPL programs while in algebraic mode. While RPL programs can be written in algebraic mode without the use of this function, some RPL constructs, such as FOR…NEXT loops, will produce an error message if not preceded by the RPL> function. As an algebraic function, it will be placed on the command line with a pair of parentheses attached, which must be removed before its use. For example, to enter the user RPL program of « 1 5 + » in algebraic mode, choose the RPL> function from the catalog and press `. Remove the parentheses by pressing ™ƒƒ. Then enter the program by pressing …å1#5#+`. The program object will now be on the first command line. It can be evaluated by pressing N!î`.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | obj |

## RR in app ↑ top

PDF page 329 · printed page 3-209

Type

  Command

Description

  Rotate Right Command: Rotates a binary integer one bit to the right. The rightmost bit of #n1 becomes the leftmost bit of #n2.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  RL, RLB, RRB

## RRB in app ↑ top

PDF page 329 · printed page 3-209

Type

  Command

Description

  Rotate Right Byte Command: Rotates a binary integer one byte to the right. The rightmost byte of #n1 becomes the leftmost byte of #n2. RRB is equivalent to doing RR eight times.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  RL, RLB, RR

## rref in app ↑ top

PDF page 330 · printed page 3-210

Type

  Command

Description

  Reduces a matrix to row-reduced echelon form, and provides a list of pivot points.

Input

  A matrix.

Output

  Level 2/Item 1: The pivot points. Level 1/Item 2: An equivalent matrix in row reduced echelon form.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear) If flag –126 is clear (the default), row reduction is done with the last column. If the flag is set, row reduction is done without reducing the last column, but the last column will be modified by the reduction of the rest of the matrix.

Example

  Reduce to row-reduced echelon form, and find the pivot points, for the matrix: 2 1 3 4

  Command | rref([[2,1][3,4]])
  Result | {Pivots: {5,1.,2,1.},[[10,0][0,5]]}

See also

  RREFMOD RREF

Type

  Command

Description

  Reduces a matrix to row-reduced echelon form. The reduction is carried out completely, so a square matrix is reduced to an identity matrix. Step-by-step mode can be used to show how the reduction proceeds.

Input

  A matrix.

Output

  An equivalent matrix in row reduced echelon form.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). Step-by-step mode can be set (flag –100 set).

Example

  Solve the system of linear equations: 3x + 4y = 5 5x + 6y = 7 by reducing the augmented matrix that represents this system.

  Command | RREF([[3, 4, 5] [ 5, 6, 7]])
  Result | [[1, 0, -1] [0, 1, 2]]

  This reduced matrix represents the system: 1x + 0y = –1 0x + 1y = 2 so that the solution is x = –1, y = 2 .

See also

  rref, RREFMOD

## RREFMOD not in app ↑ top

PDF page 331 · printed page 3-211

Type

  Command

Description

  Performs modular row-reduction to echelon form on a matrix, modulo the current modulus.

Input

  A matrix.

Output

  The modular row-reduced matrix. The modulo value is set using the Modes CAS input form.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). If flag –126 is clear (the default), row reduction is done with the last column. If the flag is set, row reduction is done without reducing the last column, but the last column will be modified by the reduction of the rest of the matrix.

Example

  Reduce to row-reduced echelon form, modulo 3, the matrix: 2 1 3 4

  Command | rref[[2,1][3,4]]
  Result | [[-1,0][0,1]]

See also

  rref

## RRK not in app ↑ top

PDF page 331 · printed page 3-211

Type

  Command

Description

  Solve for Initial Values (Rosenbrock, Runge–Kutta) Command: Computes the solution to an initial value problem for a differential equation with known partial derivatives. RRK solves y`(t) = f(t,y), where y(t0) = y0. The arguments and results are as follows:

  - { list } contains five items in this order: – The independent variable (t). – The solution variable (y). – The right-hand side of the differential equation (or a variable where the expression is stored). – The partial derivative of y`(t) with respect to the solution variable (or a variable where the expression is stored). – The partial derivative of y`(t) with respect to the independent variable (or a variable where the expression is stored).
  - xtol sets the tolerance value. If a list is used, the first value is the tolerance and the second value is the initial candidate step size.
  - xTfinal specifies the final value of the independent variable. RRK repeatedly calls RKFSTEP as its steps from the initial value to xTfinal.
Input/Output

  L3/A1 | L2/A2 | L1/A3 |  | L2/I1 | L1/I2
  --- | --- | --- | --- | --- | ---
  { list } | xtol | xT final | → | { list } | xtol
  { list } | { xtol xhstep } | xT final | { list } | xtol |
  L = Level; A = Argument; I = item

Example

  Solve the following initial value problem for y(8), given that y(0) = 0: 1

                                           y′ =        − 2 y 2 = f (t , y )

  1+ t 2

  The derivative of the function with respect to y (∂f/∂y) is –4y, and the derivative of the function − 2t

      with respect to t (∂f/∂t) is                 .

  (1 + t 2 ) 2 1. Store the independent variable’s initial value, 0, in T. 2. Store the dependent variable’s initial value, 0, in Y. 1

      3. Store the expression,               − 2 y 2 , in F.

  1+ t 2

  4. Store ∂f/∂y, –4y, in FY. − 2t

      5. Store ∂f/∂t,                , in FT.

  (1 + t 2 ) 2 6. Enter these five items in a list: { T Y F FY FT }. 7. Enter the tolerance. Use estimated decimal place accuracy as a guideline for choosing a tolerance: 0.00001. 8. Enter the final value for the independent variable: 8. The stack should look like this: { T Y F FY FT } .00001 8 9. Press RRK. The variable T now contains 8, and Y now contains the value .123077277659. The actual answer is .123076923077, so the calculated answer has an error of approximately .00000035, well within the specified tolerance.

See also

  RKF, RKFERR, RKFSTEP, RRKSTEP, RSBERR

## RRKSTEP not in app ↑ top

PDF page 332 · printed page 3-212

Type

  Command

Description

  Next Solution Step and Method (RKF or RRK) Command: Computes the next solution step (hnext) to an initial value problem for a differential equation, and displays the method used to arrive at that result. The arguments and results are as follows:

  - { list } contains five items in this order: – The independent variable (t). – The solution variable (y). – The right-hand side of the differential equation (or a variable where the expression is stored). – The partial derivative of y`(t) with respect to the solution variable (or a variable where the expression is stored). – The partial derivative of y`(t) with respect to the independent variable (or a variable where the expression is stored).
  - xtol is the tolerance value.
  - h specifies the initial candidate step.
  - last specifies the last method used (RKF = 1, RRK = 2). If this is the first time you are using RRKSTEP, enter 0.
  - current displays the current method used to arrive at the next step.
  - hnext is the next candidate step. The independent and solution variables must have values stored in them. RRKSTEP steps these variables to the next point upon completion. Note that the actual step used by RRKSTEP will be less than the input value h if the global error tolerance is not satisfied by that value. If a stringent global error tolerance forces RRKSTEP to reduce its stepsize to the point that the Runge–Kutta–Fehlberg or Rosenbrock methods fails, then

  RRKSTEP will use the Euler method to compute the next solution step and will consider the error tolerance satisfied. The Rosenbrock method will fail if the current independent variable is zero and the stepsize ≤ 2.5 × 10-499 or if the variable is nonzero and the stepsize is 2.5 × 10-11 times its magnitude. The Runge–Kutta–Fehlberg method will fail if the current independent variable is zero and the stepsize ≤ 1.3 × 10-498 or if the variable is nonzero and the stepsize is 1.3 × 10-10 times its magnitude.

Input/Output

       L4/A1      L3/A2           L2/A3       L1/A4            L4/I1      L3/I2            L2/I3     L1/I4

          { list }     xtol            h          last        → { list }       xtol            hnext   current

  L = Level; A = Argument; I = item

See also

  RKF, RKFERR, RKFSTEP, RRK, RSBERR

## RSBERR not in app ↑ top

PDF page 333 · printed page 3-213

Type

  Command

Description

  Error Estimate for Rosenbrock Method Command: Returns an error estimate for a given step h when solving an initial values problem for a differential equation. The arguments and results are as follows:

  - { list } contains five items in this order: – The independent variable (t). – The solution variable (y). – The right-hand side of the differential equation (or a variable where the expression is stored). – The partial derivative of y`(t) with respect to the solution variable (or a variable where the expression is stored). – The partial derivative of y`(t) with respect to the independent variable (or a variable where the expression is stored).
  - h is a real number that specifies the initial step.
  - ydelta displays the change in solution.
  - error displays the absolute error for that step. The absolute error is the absolute value of the estimated error for a scalar problem, and the row (infinity) norm of the estimated error vector for a vector problem. (The latter is a bound on the maximum error of any component of the solution.) A zero error indicates that the Rosenbrock method failed and Euler’s method was used instead.
Input/Output

  L2/A1 | L1/A2 |  | L4/I1 | L3/I2 | L2/I3 | L1/I4
  --- | --- | --- | --- | --- | --- | ---
  { list } | h | → | { list } | h | ydelta | error
  L = Level; A = Argument; I = item

See also

  RKF, RKFERR, RKFSTEP, RRK, RRKSTEP

## RSD in app ↑ top

PDF page 333 · printed page 3-213

Type

  Command

Description

  Residual Command: Computes the residual B – AZ of the arrays B, A, and Z. A, B, and Z are restricted as follows:

  - A must be a matrix.
  - The number of columns of A must equal the number of elements of Z if Z is a vector, or the number of rows of Z if Z is a matrix.
  - The number of rows of A must equal the number of elements of B if B is a vector, or the number of rows of B if B is a matrix.
  - B and Z must both be vectors or both be matrices.
  - B and Z must have the same number of columns if they are matrices. RSD is typically used for computing a correction to Z, where Z has been obtained as an approximation to the solution X to the system of equations AX = B.
Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [ vector ]B | [[ matrix ]]A | [ vector ]Z | → | [ vector ]B–AZ
  [[ matrix ]]B | [[ matrix ]]A | [[ matrix ]]Z | → | [[ matrix ]]B–AZ

See also

  DET, IDN

## RSWP in app ↑ top

PDF page 334 · printed page 3-214

Type

  Command

Description

  Row Swap Command: Swaps rows i and j of a matrix and returns the modified matrix, or swaps elements i and j of a vector and returns the modified vector. Row numbers are rounded to the nearest integer. Vector arguments are treated as column vectors.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | nrow i | nrow j | → | [[ matrix ]]2
  [ vector ]1 | nelement i | nelement j | → | [ vector ]2

See also

  CSWP, ROW+, ROW–

## RULES not in app ↑ top

PDF page 334 · printed page 3-214

Type

  Command

Description

  Displays a list of names of individuals involved with the HP 49G calculator project.

Input/Output

  None

## R→B in app ↑ top

PDF page 334 · printed page 3-214

Type

  Command

Description

  Real to Binary Command: Converts a positive real to its binary integer equivalent. For any value of n ≤ 0, the result is # 0. For any value of n ≥ 1.84467440738E19 (base 10), the result is # FFFFFFFFFFFFFFFF (base 16).

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → | #n

See also

  B→R

## R→C in app ↑ top

PDF page 335 · printed page 3-215

Type

  Command

Description

  Real to Complex Command: Combines two real numbers or real arrays into a single complex number or complex array. The first input represents the real element(s) of the complex result. The second input represents the imaginary element(s) of the complex result. Array arguments must have the same dimensions.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | (x,y)
  [ R-array1 ] | [ R-array2 ] | → | [ C-array ]

See also

  C→R, IM, RE

## R→D in app ↑ top

PDF page 335 · printed page 3-215

Type

  Function

Description

  Radians to Degrees Function: Converts a real number expressed in radians to its equivalent in degrees. This function operates independently of the angle mode.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | (180/π)x
  `symb` | → | `R→D(symb)`

See also

  D→R

## R→I not in app ↑ top

PDF page 335 · printed page 3-215

Type

  Function

Description

  Converts a real number to an integer.

Flags

  Numeric mode must not be set (flag –3 clear).

Input

  Level 1/Argument 1: An integral real number or an expression that evaluates to an integral real.

Output

  Level 1/Item 1: The real value converted to an integer.

See also

  I→R

## SAME in app ↑ top

PDF page 335 · printed page 3-215

Type

  Command

Description

  Same Object Command: Compares two objects, and returns a true result (1) if they are identical, and a false result (0) if they are not. SAME is identical in effect to == for all object types except algebraics, names, and some units. (For algebraics and names, == returns an expression that can be evaluated to produce a test result based on numerical values.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj1 | obj2 | → | 0/1
  Example 1: { A B } (4,5) SAME returns 0.
  Example 2: { A B } { B A } SAME returns 0.
  Example 3: "CATS" "CATS" SAME returns 1.

See also

  TYPE, ==

## SBRK not in app ↑ top

PDF page 336 · printed page 3-216

Type

  Command

Description

  Serial Break Command: Interrupts serial transmission or reception. SBRK is typically used when a problem occurs in a serial data transmission.

Flags

  I/O Device (–33), I/O Device for Wire (–78)

Input/Output

  None

See also

  BUFLEN, SRECV, STIME, XMIT

## SCALE not in app ↑ top

PDF page 336 · printed page 3-216

Type

  Command

Description

  Scale Plot Command: Adjusts the first two parameters in PPAR, (xmin, ymin) and (xmax, ymax), so that xscale and yscale are the new plot horizontal and vertical scales, and the center point doesn’t change. The scale in either direction is the number of user units per tick mark. The default scale in both directions is 1 user-unit per tick mark.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xscale | yscale | → |

See also

  AUTO, CENTR, SCALEH, SCALEW

## SCALEH not in app ↑ top

PDF page 336 · printed page 3-216

Type

  Command

Description

  Multiply Height Command: Multiplies the vertical plot scale by xfactor. Executing SCALEH changes the y-axis display range — the ymin and ymax components of the first two complex numbers in the reserved variable PPAR. The plot origin (the user-unit coordinate of the center pixel) is not changed.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xfactor | → |

See also

  AUTO, SCALEW, YRNG

## SCALEW not in app ↑ top

PDF page 336 · printed page 3-216

Type

  Command

Description

  Multiply Width Command: Multiplies the horizontal plot scale by xfactor.

  Executing SCALEW changes the x-axis display range—the xmin and xmax components of the first two complex numbers in the reserved variable PPAR. The plot origin (the user-unit coordinate of the center pixel) is not changed.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xfactor | → |

See also

  AUTO, SCALEH, XRNG

## SCATRPLOT not in app ↑ top

PDF page 337 · printed page 3-217

Type

  Command

Description

  Draw Scatter Plot Command: Draws a scatterplot of (x, y) data points from the specified columns of the current statistics matrix (reserved variable ΣDAT ). The data columns plotted are specified by XCOL and YCOL, and are stored as the first two parameters in the reserved variable ΣPAR. If no data columns are specified, columns 1 (independent) and 2 (dependent) are selected by default. The y-axis is autoscaled and the plot type is set to SCATTER. When SCATRPLOT is executed from a program, the resulting display does not persist unless PICTURE or PVIEW is subsequently executed.

Input/Output

  None

Example

      The following program plots a scatter plot of the data in columns 3 and 4 of ΣDAT, draws a best fit line, and displays the plot: « 3 XCOL 4 YCOL SCATRPLOT BESTFIT ΣLINE STEQ FUNCTION DRAW { # 0d # 0d } PVIEW 7 FREEZE »

See also

  BARPLOT, PICTURE, HISTPLOT, PVIEW, SCLΣ, XCOL, YCOL

## SCATTER not in app ↑ top

PDF page 337 · printed page 3-217

Type

  Command

Description

  Scatter Plot Type Command: Sets the plot type to SCATTER. When the plot type is SCATTER, the DRAW command plots points by obtaining x and y coordinates from two columns of the current statistics matrix (reserved variable ΣDAT). The columns are specified by the first and second parameters in the reserved variable ΣPAR (using the XCOL and YCOL commands). The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin), (xmax, ymax), indep, res, axes, ptype, depend } For plot type SCATTER, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is not used.
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command SCATTER places the name SCATTER in ptype.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SLOPEFIELD, TRUTH, WIREFRAME, YSLICE

## SCHUR not in app ↑ top

PDF page 338 · printed page 3-218

Type

  Command

Description

  Schur Decomposition of a Square Matrix Command: Returns the Schur decomposition of a square matrix. SCHUR decomposes A into two matrices Q and T:

  - If A is a complex matrix, Q is a unitary matrix, and T is an upper-triangular matrix.
  - If A is a real matrix, Q is an orthogonal matrix, and T is an upper quasi-triangular matrix (T is upper block triangular with 1 × 1 or 2 × 2 diagonal blocks where the 2 × 2 blocks have complex conjugate eigenvalues). In either case, A ≅ Q × T × TRN(Q)
Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  [[ matrix ]]A | → | [[ matrix ]]Q | [[ matrix ]]T

See also

  LQ, LU, QR, SVD, SVL, TRN

## SCI in app ↑ top

PDF page 338 · printed page 3-218

Type

  Command

Description

  Scientific Mode Command: Sets the number display format to scientific mode, which displays one digit to the left of the fraction mark and n significant digits to the right. Scientific mode is equivalent to scientific notation using n + 1 significant digits, where 0 ≤ n ≤ 11. (Values for n outside this range are rounded to the nearest integer.) In scientific mode, numbers are displayed and printed like this: (sign) mantissa E (sign) exponent where the mantissa has the form n.(n … ) and has zero to 11 decimal places, and the exponent has one to three digits.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → |

Example

  The number 103.6 in Scientific mode to four decimal places appears as 1.0360E2.

See also

  ENG, FIX, STD

## SCLΣ not in app ↑ top

PDF page 338 · printed page 3-218

Type

  Command

Description

  Scale Sigma Command: Adjusts (xmin, y min) and (xmax, ymax) in PPAR so that a subsequent scatter plot exactly fills PICT. When the plot type is SCATTER, the command AUTO incorporates the functions of SCLΣ. In addition, the command SCATRPLOT automatically executes AUTO to achieve the same result. SCLΣ is included for compatibility with the HP 28.

Input/Output

  None

See also

  AUTO, SCATRPLOT

## SCONJ in app ↑ top

PDF page 339 · printed page 3-219

Type

  Command

Description

  Store Conjugate Command: Conjugates the contents of a named object. The named object must be a number, an array, or an algebraic object. For information on conjugation, see CONJ.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |

See also

  CONJ, SINV, SNEG

## SCROLL not in app ↑ top

PDF page 339 · printed page 3-219

Type

  Command

Description

  Displays any object. This is the programmable equivalent of pressing I%VIEW% and is the best way to view any object larger than the screen, such as complicated algebraic expressions.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  Grob | → |

## SDEV in app ↑ top

PDF page 339 · printed page 3-219

Type

  Command

Description

  Standard Deviation Command: Calculates the sample standard deviation of each of the m columns of coordinate values in the current statistics matrix (reserved variable ΣDAT). SDEV returns a vector of m real numbers, or a single real number if m = 1. The standard deviation (the square root of the variances) is computed using this formula:

                                                     1 n                  2

  ----------- ∑ ( x i – x ) n – 1i = 1

  where xi is the ith coordinate value in a column, x is the mean of the data in this column, and n is the number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xsdev |
  → | [ xsdev 1 xsdev 2 ... xsdev m ] |

See also

  MAXΣ, MEAN, MINΣ, PSDEV, PVAR, TOT, VAR

## SEND not in app ↑ top

PDF page 339 · printed page 3-219

Type

  Command

Description

  Send Object Command: Sends a copy of the named objects to a Kermit device.

  Data is always sent from a local Kermit, but can be sent either to another local Kermit (which must execute RECV or RECN) or to a server Kermit. To rename an object when sending it, include the old and new names in an embedded list.

Flags

  I/O Device flag (–33), I/O Data Format (–35), I/O Messages (–39), I/O Device for Wire (–78) If flag –35 is clear (ASCII transfer), the translation setting also has an effect.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |
  { name1 ... namen } | → |
  {{ nameold namenew } name ... } | → |
  Example 1: | Executing {{ AAA BBB }} SEND sends the variable named AAA but changes its name |
  to BBB.
      Example 2:      Executing {{ AAA BBB } CCC } SEND sends AAA as BBB and sends CCC under its
  own name. (If the new name is not legal on the calculator, just enter it as a string.)

See also

  BAUD, CLOSEIO, CKSM, FINISH, KERRM, KGET, PARITY, RECN, RECV, SERVER, TRANSIO

## SEQ in app ↑ top

PDF page 340 · printed page 3-220

Type

  Command

Description

  Sequential Calculation Command: Returns a list of results generated by repeatedly executing objexec using index over the range xstart to xend, in increments of xincr. objexec is a program or algebraic object that is a function of index. index must be a global or local name. The remaining objects can be anything that will evaluate to real numbers. The action of SEQ for arbitrary inputs can be predicted exactly from this equivalent program.

                       xstart xend FOR index objexec EVAL xincr STEP n → LIST

  where n is the number of new objects left on the stack by the FOR … STEP loop. Notice that index becomes a local variable regardless of its original type.

Input/Output

  L5/A1 | L4/A2 | L3/A3 | L2/A4 | L1/A5 |  | Li/I1
  --- | --- | --- | --- | --- | --- | ---
  objexec | index | xstart | xend | xincr | → | { list }
  L = Level; A = Argument; I = item
      Example 1:      `n^2` `n` 1 4 1 returns { 1 4 9 16 }.
          Example 2:      « n SQ » `n` 2 4 1 returns { 4 9 16 }.

See also

  DOSUBS, STREAM

## SERIES not in app ↑ top

PDF page 340 · printed page 3-220

Type

  Command

Description

  For a given function, computes Taylor series, asymptotic development and limit at finite or infinite points.

Input

  Level 3/Argument 1: The function f(x) Level 2/Argument 2: The variable if the limit point is 0, or an equation x = a if the limit point is a. If the function is in terms of the current variable, this can be given as just the value a.

  Level 1/Argument 3: The order for the series expansion. The minimum value is 2, and the maximum value is 20.

Output

  Level 2/Item 1: A list containing the limit as a value and as the equivalent expression, an expression approximating the function near the limit point, and the order of the remainder. These are expressed in terms of a small parameter h. Level 1/Item 2: An expression for h in terms of the original variable.

Flags

  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

  Obtain the second order Taylor series expansion of ln(x) at x=1.

  Command | SERIES(LN(X),1,2)
  Result | {{Limit: 0, Equiv: h, Expans: -1/2*h^2+h, Remain: h^3}, h=X- 1}

See also

  TAYLOR0

## SERVER not in app ↑ top

PDF page 341 · printed page 3-221

Type

  Command

Description

  Server Mode Command: Selects Kermit Server mode. A Kermit server (a Kermit device in Server mode) passively processes requests sent to it by the local Kermit. The server receives data in response to SEND, transmits data in response to KGET, terminates Server mode in response to FINISH or LOGOUT, and transmits a directory listing in response to a generic directory request.

Flags

  I/O Device (–33), I/O Data Format (–35), RECV Overwrite (–36), I/O Messages (–39), I/O Device for Wire (–78)

Input/Output

  None

See also

  BAUD, CKSM, FINISH, KERRM, KGET, PARITY, PKT, RECN, RECV, SEND, TRANSIO

## SEVAL not in app ↑ top

PDF page 341 · printed page 3-221

Type

  Function

Description

  Simplifies the given expression. Simplifies the expression except at the highest level, and also evaluates any existing variables that the expression contains and substitutes these back into the expression.

Input

  Level 1/Argument 1: An algebraic expression.

Output

  The expression simplified and with existing variables evaluated.

Flags

  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

  With π stored in the variable Y, and the variables X and Z not in the current path, simplify the following expression. Note that the top-level simplification is not carried out. Sin(3x – y + 2z – (2x – z)) – Sin(x – 2y + (y + 3z))

      Command:         SEVAL(SIN(3*X-Y+2*Z-(2*X-Z)) - SIN(X-2*Y+(Y+3*Z))

Result

  -SIN(π –(X+3*Z)) -SIN(π –(X+3*Z))

See also

  EXPAND, SIMPLIFY

## SF in app ↑ top

PDF page 341 · printed page 3-221

Type

  Command

Description

  Set Flag Command: Sets a specified user or system flag.

  User flags are numbered 1 through 128. System flags are numbered –1 through –128. See Appendix C for a listing of system flags and their flag numbers.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  nflagnumber | → |

See also

  CF, FC?, FC?C, FS?, FS?C

## SHOW not in app ↑ top

PDF page 342 · printed page 3-222

Type

  Command

Description

  Show Variable Command: Returns symb2, which is equivalent to symb1 except that all implicit references to a variable name are made explicit. If the level 1 argument is a list, SHOW evaluates all global variables in symb1 not contained in the list.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  `symb1` | `name` | → | `symb2`
  `symb1` | { name1 name2 ... } → | `symb2` |

Example

      If 7 is stored in C and 5 is stored in D:
          Command:      `X-Y+2*C+3*D` { X Y } SHOW
          Result:       `X-Y+14+15`

See also

  COLCT, EXPAN, ISOL, QUAD

## SIDENS not in app ↑ top

PDF page 342 · printed page 3-222

Type

  Function

Description

  Silicon Intrinsic Density Command: Calculates the intrinsic density of silicon as a function of temperature, xT. If xT is a unit object, it must reduce to a pure temperature, and the density is returned as a unit object with units of 1/cm3. If xT is a real number, its units are assumed to be K, and the density is returned as a real number with implied units of 1/cm3. xT must be between 0 and 1685 K.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xT | → | xdensity
  x_unit | → | x_1/cm3
  `symb` | → | `SIDENS(symb)`

## SIGMA not in app ↑ top

PDF page 342 · printed page 3-222

Type

  Function

Description

  Calculates the discrete antiderivative of a function f with respect to a specified variable. This is a function G such that:

  G(x + 1) – G(x) = f(x) where x is the specified variable.

Input

  Level 2/Argument 1: A function Level 1/Argument 2: The variable to calculate the antiderivative with respect to.

Output

  The discrete antiderivative of the function.

Flags

  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

  Obtain the discrete antiderivative with respect to the variable y of the expression: 2x-2y

  Command | SIGMA(2*X-2*Y,Y)
  Result | -(Y^2 –(2*X+1)*Y)

See also

  SIGMAVX, RISCH

## SIGMAVX not in app ↑ top

PDF page 343 · printed page 3-223

Type

  Function

Description

  Calculates the discrete antiderivative of a function f with respect to the current variable. This is a function G such that: G(x + 1) – G(x) = f(x) where x is the current variable.

Input

  Level 1/Argument 1: A function.

Output

  The discrete antiderivative of the function.

Flags

  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

  Obtain the discrete antiderivative with respect to the current variable x of the expression: 2x-2y

  Command | SIGMAVX(2*X-2*Y)
  Result | X^2 –(2*Y+1)*X

See also

  SIGMA, RISCH

## SIGN in app ↑ top

PDF page 343 · printed page 3-223

Type

  Function

Description

  Sign Function: Returns the sign of a real number argument, the sign of the numerical part of a unit object argument, or the unit vector in the direction of a complex number argument. For real number and unit object arguments, the sign is defined as +1 for positive arguments, –1 for negative arguments. In exact mode, the sign for argument 0 is undefined (?). In approximate mode, the sign for argument 0 is 0. SIGN in the !´menu returns the sign of a number, while SIGN in the …ß menu returns the unit vector of a complex number. For a complex argument:

                                                        x                     iy

  SIGN ( x + iy ) = -------------------- + --------------------

                                                      2           2          2           2
                                                       x +y                   x +y

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z1 | → | z2
  x_unit | → | xsign
  `symb` | → |
  `SIGN(symb)`
  Example 1: | 32_ft SIGN returns 1.
  --- | ---
  Example 2: | (1,1) SIGN returns (.707106781187,.707106781187).

See also

  ABS, MANT, XPON

## SIGNTAB not in app ↑ top

PDF page 344 · printed page 3-224

Type

  Command

Description

  Tabulates the sign of a rational function of the current CAS variable.

Input

  An algebraic expression.

Output

  A list containing, the points where the expression changes sign, and between each pair of points, the sign of the expression between those points.

Flags

  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

      Show the ranges of values of x for which the expression 2-x2 is positive and negative.
          Command:       SIGNTAB(2 – X^2)
          Result:        { `-∞` – `-√2` + `√2` – `+∞` }

See also

  TABVAR

## SIMP2 not in app ↑ top

PDF page 344 · printed page 3-224

Type

  Command

Description

  Simplifies two objects by dividing them by their greatest common divisor.

Input

  Level 2/Argument 1: The first object. Level 1/Argument 2: The second object.

Output

  Level 2/Item 1: The first object divided by the greatest common divisor. Level 1/Item 2: The second object divided by the greatest common divisor.

Flags

  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

  Divide the following expressions by their greatest common divisor:

                      3     2

  x + 6 x + 11 x + 6 3 x – 7x – 6

  Command | SIMP2(X^3+6*X^2+11*X+6, X^3-7*X-6)
  Result | {X+3,X-3}

See also

  EGCD

## SIMPLIFY in app ↑ top

PDF page 345 · printed page 3-225

Type

  Command

Description

  Simplifies an expression.

Input

  An expression

Output

  An equivalent simplified expression. SIMPLIFY follows an extensive built-in set of rules, but these might not give exactly the simplification the user expects.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). SI ( 3 ⋅ X ) + SI ( 7 ⋅ X ) ---------------------------------------------------------

Example

                     Simplify                 SI

  ( 5 ⋅ X )

  Command | SIMPLIFY((SIN(3*X)+SIN(7*X))/SIN(5*X))
  Result | 4*COS(X)^2 - 2

See also

  COLLECT, EXPAND

## SIN in app ↑ top

PDF page 345 · printed page 3-225

Type

  Analytic function

Description

  Sine Analytic Function: Returns the sine of the argument. For real arguments, the current angle mode determines the number’s units, unless angular units are specified. For complex arguments, sin(x + iy) = sinx coshy + i cosx sinhy. If the argument for SIN is a unit object, then the specified angular unit overrides the angle mode to determine the result. Integration and differentiation, on the other hand, always observe the angle mode. Therefore, to correctly integrate or differentiate expressions containing SIN with a unit object, the angle mode must be set to radians (since this is a “neutral” mode).

Flags

  Numerical Results (–3), Angle Mode (–17, –18)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | sin z
  x_unitangular | → | sin(x_unitangular)
  `symb` | → | `SIN(symb)`

See also

  ASIN, COS, TAN

## SINCOS not in app ↑ top

PDF page 345 · printed page 3-225

Type

  Command

Description

  Converts complex logarithmic and exponential expressions to expressions with trigonometric terms.

Input

  An expression with complex linear and exponential terms.

Output

  The expression with logarithmic and exponential subexpressions converted to trigonometric and inverse trigonometric expressions.

Flags

  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). Must be in complex mode (flag –103 set).

Example

  Express eix in trigonometric terms.

  Command | SINCOS(EXP(i*X))
  Result | COS(X)+iSIN(X)

See also

  EXPLN

## SINH in app ↑ top

PDF page 346 · printed page 3-226

Type

  Analytic function

Description

  Hyperbolic Sine Analytic Function: Returns the hyperbolic sine of the argument. For complex arguments, sinh(x + iy) = sinhx cosy + i coshx siny.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | sinh z
  `symb` | → | `SINH(symb)`

See also

  ASINH, COSH, TANH

## SINV in app ↑ top

PDF page 346 · printed page 3-226

Type

  Command

Description

  Store Inverse Command: Replaces the contents of the named variable with its inverse. The named object must be a number, a matrix, an algebraic object, or a unit object. For information on reciprocals, see INV.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |

See also

  INV, SCONJ, SNEG

## SIZE in app ↑ top

PDF page 346 · printed page 3-226

Type

  Command Operation

Description

  Size Command: Returns the number of characters in a string, the number of digits in an integer, the number of elements in a list, the dimensions of an array, the number of objects in a unit object or algebraic object, or the dimensions of a graphics object. The size of a unit is computed as follows: the scalar (+1), the underscore (+1), each unit name (+1), operator or exponent (+1), and each prefix (+2). Any object type not listed above returns a value of 1.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  “string” | → | n |
  integer | → | n |
  { list } | → | n |
  [ vector ] | → | {n} |
  [[ matrix ]] | → | { n m} |
  `symb` | → | n |
  grob | → | #nwidth | #mheight
  PICT | → | #nwidth | #mheight
  x_unit | → | n |

See also

  CHR, NUM, POS, REPL, SUB

## SL in app ↑ top

PDF page 347 · printed page 3-227

Type

  Command

Description

  Shift Left Command: Shift a binary integer one bit to the left. The most significant bit is shifted out to the left and lost, while the least significant bit is regenerated as a zero. SL is equivalent to binary multiplication by 2, truncated to the current wordsize.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  ASR, SLB, SR, SRB

## SLB in app ↑ top

PDF page 347 · printed page 3-227

Type

  Command

Description

  Shift Left Byte Command: Shifts a binary integer one byte to the left. The most significant byte is shifted out to the left and lost, while the least significant byte is regenerated as zero. SLB is equivalent to binary multiplication by 28 (256) (or executing SL eight times), truncated to the current wordsize.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  ASR, SL, SR, SRB

## SLOPEFIELD not in app ↑ top

PDF page 347 · printed page 3-227

Type

  Command

Description

  SLOPEFIELD Plot Type Command: Sets the plot type to SLOPEFIELD.

  When plot type is set to SLOPEFIELD, the DRAW command plots a slope representation of a scalar function with two variables. SLOPEFIELD requires values in the reserved variables EQ, VPAR, and PPAR. VPAR has the following form: { xleft xright ynear yfar zlow zhigh xmin xmax ymin ymax xeye yeye zeye xstep ystep } For plot type SLOPEFIELD, the elements of VPAR are used as follows:

  - xleft and xright are real numbers that specify the width of the view space.
  - ynear and yfar are real numbers that specify the depth of the view space.
  - zlow and zhigh are real numbers that specify the height of the view space.
  - xmin and xmax are not used.
  - ymin and ymax are not used.
  - xeye, yeye, and zeye are real numbers that specify the point in space from which the graph is viewed.
  - xstep and ystep are real numbers that set the number of x-coordinates versus the number of y- coordinates plotted. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type SLOPEFIELD, the elements of PPAR are used as follows:
  - (xmin, ymin) is not used.
  - (xmax, ymax) is not used.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is not used.
  - axes is not used.
  - ptype is a command name specifying the plot type. Executing the command SLOPEFIELD places the command name SLOPEFIELD in ptype.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, TRUTH, WIREFRAME, YSLICE

## SNEG in app ↑ top

PDF page 348 · printed page 3-228

Type

  Command

Description

  Store Negate Command: Replaces the contents of a variable with its negative. The named object must be a number, an array, an algebraic object, a unit object, or a graphics object. For information on negation, see NEG.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |

See also

  NEG, SCONJ, SINV

## SNRM not in app ↑ top

PDF page 348 · printed page 3-228

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.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ array ] | → | xspectralnorm

See also

  ABS, CNRM, COND, RNRM, SRAD, TRACE

## SOLVE in app ↑ top

PDF page 349 · printed page 3-229

Type

  Command

Description

  Finds zeros of an expression equated to 0, or solves an equation.

Input

  Level 2/Argument 1: The expression or equation. A list of equations and expressions can be given too, each will be solved for the same variable. Level 1/Argument 2: The variable to solve for.

Output

  A zero or solution, or a list of zeros or solutions.

Flags

  Radians mode must be set (flag –17 set). If exact mode is set (flag –105 clear) and there are no exact solutions, the command returns a null list even when there are approximate solutions. Radians mode must be set (flag –17 set). If complex mode is set (flag –103 set) then SOLVE will search for complex roots as well as real ones. Complex roots are displayed according to the coordinate system selected.

      Example 1:      Find the zeros of the following expression:

  3 x –x–9

  Command | SOLVE(X^3-X-9,X)
  Result | X=2.24004098747 Example 2: Find the real and complex roots of the two equations:

  x – 1=3 ,

                       4              2

  x – A= 0

       Command:       Clear numeric mode, clear approximate mode, set complex mode, set rectangular mode, enter:

  SOLVE({X^4-1=3,X^2-A=0},X)

       Result:        {{X=√2×i,X=√2×-1,X=-(√2×i),X=√2},

  {X=√A×-1,X=√A}} Note that in this case, imaginary solutions for X are returned, even if X is in REALASSUME.

See also

  DESOLVE, LDEC, LINSOLVE, MSLV, QUAD, SOLVEVX

## SOLVEQN not in app ↑ top

PDF page 349 · printed page 3-229

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.

Flags

  Unit Type (60), Units Usage (61)

Flags

  Units Type (60), Units Usage (61)

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  n | m | 0/1 | → |

See also

  EQNLIB, MSOLVR

## SOLVER not in app ↑ top

PDF page 350 · printed page 3-230

Type

  Command

Description

  Displays a menu of commands used in solving equations.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

Input/Output

  None

## SOLVEVX not in app ↑ top

PDF page 350 · printed page 3-230

Type

  Command

Description

  Finds zeros of an expression with respect to the current variable, or solves an equation with respect to the current variable. (You use the CAS modes input form to set the current variable.)

Input

  An expression or equation in the current variable. A list of equations and expressions can be given too, each will be solved for the current variable.

Output

  A zero or solution, or a list of zeros or solutions.

Flags

  Radians mode must be set (flag –17 set). For a symbolic result, clear the CAS modes numeric option (flag –3 clear). If Exact mode is set (flag –105 clear) and there are no exact solutions, the command returns a null list even when there are approximate solutions. If complex mode is set (flag –103 set) then SOLVE will search for complex roots as well as real ones. Complex roots are displayed according to the coordinate system selected.

Example

  Solve the following expression for 0, where X is the default variable on the calculator: 3 x –x–9

  Command | SOLVEVX(X^3-X-9)
  Result | X=2.24004098747

  Note that if exact mode is set, this example returns a null list as there are no exact solutions to the equation.

See also

  LINSOLVE, SOLVE

## SORT in app ↑ top

PDF page 350 · printed page 3-230

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.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { list }1 | → | { list }2

See also

  REVLIST

## SPHERE in app ↑ top

PDF page 351 · printed page 3-231

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.

Input/Output

  None

See also

  CYLIN, RECT

## SQ in app ↑ top

PDF page 351 · printed page 3-231

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.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | z2
  x_unit | → | x2_unit2
  [[ matrix ]] | → | [[ matrix × matrix ]]
  `symb` | → | `SQ(symb)`

See also

  √, ^

## √(Square Root) in app ↑ top

PDF page 406 · printed page 3-286

Type

  Function

Description

  Square Root Analytic Function: Returns the (positive) square root of the argument. For a complex number (x1, y1), the square root is this complex number:

                                                               θ          θ

  ( x 2, y 2 ) = -- r cos -- , r sin ----

                                                               2          2

  where r = ABS (x1, y1), and θ = ARG (x1, y1). If (x1, y1) = (0,0), then the square root is (0, 0). The inverse of SQ is a relation, not a function, since SQ sends more than one argument to the same result. The inverse relation for SQ is expressed by ISOL as this general solution: `s1*√Z` The function √ is the inverse of a part of SQ, a part defined by restricting the domain of SQ such that: 1. each argument is sent to a distinct result, and 2. each possible result is achieved. The points in this restricted domain of SQ are called the principal values of the inverse relation. The √ function in its entirety is called the principal branch of the inverse relation, and the points sent by √ to the boundary of the restricted domain of SQ form the branch cuts of √.

  The principal branch used by the calculator for √ was chosen because it is analytic in the regions where the arguments of the real-valued inverse function are defined. The branch cut for the complex-valued square root function occurs 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 √. The graph of the domain shows where the branch cut occurs: the heavy solid line marks one side of the cut, while the feathered lines mark the other side of the cut. The graph of the range shows where each side of the cut is mapped under the function.

  These graphs show the inverse relation `s1*√Z` for the case s1=1. For the other value of s1, the half-plane in the lower graph is rotated. Taken together, the half-planes cover the whole complex plane, which is the domain of SQ. View these graphs with domain and range reversed to see how the domain of SQ is restricted to make an inverse function possible. Consider the half-plane in the lower graph as the restricted domain Z = (x, y). SQ sends this domain onto the whole complex plane in the range W = (u, v) = SQ(x, y) in the upper graph.

Flags

  Principal Solution (–1), Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | z
  x_unit | → | x unit
  1⁄2
  `symb` | → | ` ( symb ) `

See also

  SQ, ^, ISOL

## SR in app ↑ top

PDF page 351 · printed page 3-231

Type

  Command

Description

  Shift Right Command: Shifts a binary integer one bit to the right. The least significant bit is shifted out to the right and lost, while the most significant bit is regenerated as a zero. SR is equivalent to binary division by 2.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  ASR, SL, SLB, SRB

## SRAD not in app ↑ top

PDF page 351 · printed page 3-231

Type

  Command

Description

  Spectral Radius Command: Returns the spectral radius of a square matrix.

  The spectral radius of a matrix is a measure of the size of the matrix, and is equal to the absolute value of the largest eigenvalue of the matrix.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]]n×n | → | xspectralradius

See also

  COND, SNRM, TRACE

## SRB in app ↑ top

PDF page 352 · printed page 3-232

Type

  Command

Description

  Shift Right Byte Command: Shifts a binary integer one byte to the right. The least significant byte is shifted out to the right and lost, while the most significant byte is regenerated as zero. SRB is equivalent to binary division by 28 (or executing SR eight times).

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #n1 | → | #n2

See also

  ASR, SL, SLB, SR

## SRECV not in app ↑ top

PDF page 352 · printed page 3-232

Type

  Command

Description

  Serial Receive Command: Reads up to n characters from the serial input buffer and returns them as a string, along with a digit indicating whether errors occurred. SRECV does not use Kermit protocol. If n characters are not received within the time specified by STIME (default is 10 seconds), SRECV “times out”, returning a 0 to level 1 and as many characters as were received to level 2. If the level 2 output from BUFLEN is used as the input for SRECV, SRECV will not have to wait for more characters to be received. Instead, it returns the characters already in the input buffer. If you want to accumulate bytes in the input buffer before executing SRECV, you must first open the port using OPENIO (if the port isn’t already open). SRECV can detect three types of error when reading the input buffer:

  - Framing errors and UART overruns (both causing "Receive Error" in ERRM).
  - Input-buffer overflows (causing "Receive Buffer Overflow" in ERRM).
  - Parity errors (causing "Parity Error" in ERRM). SRECV returns 0 if an error is detected when reading the input buffer, or 1 if no error is detected. Parity errors do not stop data flow into the input buffer. However, if a parity error occurs, SRECV stops reading data after encountering a character with an error. Framing, overrun, and overflow errors cause all subsequently received characters to be ignored until the error is cleared. SRECV does not detect and clear any of these types of errors until it tries to read the byte where the error occurred. Since these three errors cause the byte where the error occurred and all subsequent bytes to be ignored, the input buffer will be empty after all previously received good bytes have been read. Therefore, SRECV detects and clears these errors when it tries to read a byte from an empty input buffer.

  Note that BUFLEN also clears the above-mentioned framing, overrun, and overflow errors. Therefore, SRECV cannot detect an input-buffer overflow after BUFLEN is executed, unless more characters were received after BUFLEN was executed (causing the input buffer to overflow again). SRECV also cannot detect framing and UART overrun errors cleared by BUFLEN. To find where the data error occurred, save the number of characters returned by BUFLEN (which gives the number of “good” characters received), because as soon as the error is cleared, new characters can enter the input buffer.

Flags

  I/O Device (–33), I/O Device for Wire (–78)

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  n | → | `string` | 0/1

Example

  If 10 good bytes were received followed by a framing error, then an SRECV command told to read 10 bytes would not indicate an error. Only when SRECV tries to read the byte that caused the framing error does it return a 0. Similarly, if the input buffer overflowed, SRECV would not indicate an error until it tried to read the first byte that was lost due to the overflow.

See also

  BUFLEN, CLOSEIO, OPENIO, SBRK, STIME, XMIT

## SREPL in app ↑ top

PDF page 353 · printed page 3-233

Type

  Command

Description

  Find and replace: Finds and replaces a string in a given text object. You supply the following inputs: Level 3/argument 1: the string to search. Level 2/argument 2: the string to find. Level 1/argument 3: the string to replace it with.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  `string` | `string` | `string` | → | `string`

See also

  REPL

## SST in app ↑ top

PDF page 353 · printed page 3-233

Type

  Operation

Description

  Execute Program Step Operation: Returns and executes the next step of a program. If the next step is a subroutine, executes the subroutine in a single step. SST is not programmable.

Input/Output

  None

See also

  NEXT, SST↓

## SST↓ in app ↑ top

PDF page 353 · printed page 3-233

Type

  Operation

Description

  Execute Subroutine Step Operation: Returns and executes the next step of a program or subroutine. If the next step is a subroutine, returns and executes the first step of the subroutine. SST↓ is not programmable.

Input/Output

  None

See also

  NEXT, SST

## START not in app ↑ top

PDF page 354 · printed page 3-234

Type

  Command Operation

Description

  START Definite Loop Structure Command: Begins START … NEXT and START … STEP definite loop structures. Definite loop structures execute a command or sequence of commands a specified number of times.

  - START … NEXT executes a portion of a program a specified number of times. The RPL syntax is this: xstart xfinish START loop-clause NEXT The algebraic syntax is this: START(xstart xfinish) loop-clause NEXT START takes two numbers (xstart and xfinish) from the stack and stores them as the starting and ending values for a loop counter. Then the loop clause is executed. NEXT increments the counter by 1 and tests to see if its value is less than or equal to xfinish. If so, the loop clause is executed again. Notice that the loop clause is always executed at least once.
  - START … STEP works just like START … NEXT, except that it can use an increment value other than 1. The RPL syntax is this: xstart xfinish START loop-clause xincrement STEP The algebraic syntax is this: START (xstart xfinish) loop-clause STEP(xincrement) START takes two numbers (xstart and xfinish) from the stack and stores them as the starting and ending values for the loop counter. Then the loop clause is executed. STEP takes xincrement from the stack and increments the counter by that value. If the argument of STEP is an algebraic or a name, it is automatically evaluated to a number. The increment value can be positive or negative: – If positive, the loop is executed again when the counter is less than or equal to xfinish. – If negative, the loop is executed when the counter is greater than or equal to xfinish.
Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  START xstart | xfinish | → |
  NEXT →
  STEP | xincrement | → |
  STEP | `symbincrement` | → |

See also

  FOR, NEXT, STEP

## STD in app ↑ top

PDF page 354 · printed page 3-234

Type

  Command

Description

  Standard Mode Command: Sets the number display format to standard mode. Executing STD has the same effect as clearing flags –49 and –50. Standard format (ANSI Minimal BASIC Standard X3J2) produces the following results when displaying or printing a number.

  - Numbers that can be represented exactly as integers with 12 or fewer digits are displayed without a fraction mark or exponent. Zero is displayed as 0.
  - Numbers that can be represented exactly with 12 or fewer digits, but not as integers, are displayed with a fraction mark but no exponent. Leading zeros to the left of the fraction mark and trailing zeros to the right of the fraction mark are omitted.
  - All other numbers are displayed in scientific notation (see SCI) with both a fraction mark (with one number to the left) and an exponent (of one or three digits). There are no leading or trailing zeros. In algebraic objects, integers less than 103 are always displayed in standard mode.
Input/Output

  None

Example

  The following table provides examples of numbers displayed in Standard mode:

  Representable With

                   Number              Displayed As

  12 Digits?

  1011 | 100000000000 | Yes (integer)
  --- | --- | ---
  1012 | 1.E12 | No
  10-11 | .000000000001 | Yes
  1.2 x 10-11 | 1.23E-11 | No
  12.345 | 12.345 | Yes

See also

  ENG, FIX, SCI

## STEP not in app ↑ top

PDF page 355 · printed page 3-235

Type

  Command Operation

Description

  STEP Command: Defines the increment (step) value, and ends definite loop structure. See the FOR and START keyword entries for more information.

Input/Output

  None

See also

  FOR, NEXT, START

## STEQ not in app ↑ top

PDF page 355 · printed page 3-235

Type

  Command

Description

  Store in EQ Command: Stores an object into the reserved variable EQ in the current directory.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → |

See also

  RCEQ

## STIME not in app ↑ top

PDF page 355 · printed page 3-235

Type

  Command

Description

  Serial Time-Out Command: Specifies the period that SRECV (serial reception) and XMIT (serial transmission) wait before timing out. The value for x is interpreted as a positive value from 0 to 25.4 seconds. If no value is given, the default is 10 seconds. If x is 0, there is no time-out; that is, the device waits indefinitely, which can drain the batteries. STIME is not used for Kermit time-out.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xseconds | → |
  0 | → |

See also

  BUFLEN, CLOSEIO, SBRK, SRECV, XMIT

## STO in app ↑ top

PDF page 356 · printed page 3-236

Type

  Command

Description

  Store Command: Stores an object into a specified variable or object. Storing a graphics object into PICT makes it the current graphics object. To create a backup object, store the obj into the desired backup location (identified as :nport:namebackup). STO will not overwrite an existing backup object. To store backup objects and library objects, specify a port number (0 through 3). After storing a library object in a port, it must then be attached to its directory before it can be used. The easiest way to do this is to execute a warm start (by pressing $& C). This also causes the calculator to perform a system halt, which clears the stack, the LAST stack, and all local variables. STO can also replace a single element of an array or list stored in a variable. Specify the variable in level 1 as name(index), which is a user function with index as the argument. The index can be n or n,m, where n specifies the row position in a vector or list, and n,m specifies the row-and-column position in a matrix.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | `name` | → |
  grob | PICT | → |
  obj | :nport :namebackup | → |
  obj | `name(index)` | → |
  backup | nport | → |
  library | nport | → |
  library | :nport :nlibrary | → |
  Example 1: `A+B+C+D` `SUMAD` STO stores the expression A+B+C+D in the variable SUMAD.
  Example 2: 5 `A(3)` STO stores the integer 5 in the third element in a list or vector A.
  Example 3: 2 `A(3,5)` STO stores the integer 2 in the element in the third row and fifth column of
  matrix A.

See also

  DEFINE, RCL, →,

## STOALARM not in app ↑ top

PDF page 356 · printed page 3-236

Type

  Command

Description

  Store Alarm Command: Stores an alarm in the system alarm list and returns its alarm index number. If the argument is a real number xtime, the alarm date will be the current system date by default. If objaction is a string, the alarm is an appointment alarm, and the string is the alarm message. If objaction is any other object type, the alarm is a control alarm, and the object is executed when the alarm comes due. xrepeat is the repeat interval for the alarm in clock ticks, where 8192 ticks equals 1 second.

  nindex is a real integer identifying the alarm based on its chronological position in the system alarm list.

Flags

  Date Format (–42), Repeat Alarms Not Rescheduled (–43), Acknowledged Alarms Saved (–44)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xtime | → | nindex
  { date time } | → | nindex
  { date time objaction } | → | nindex
  { date time objaction xrepeat } | → | nindex

Example

  With flag –42 clear, this command: { 11.06 15.2530 RUN 491520 } STOALARM sets a repeating alarm for November 6 of the currently specified year, at 3:25:30 pm. The alarm action is to execute variable RUN. The repeat interval is 491520 clock ticks (1 minute).

See also

  DELALARM, FINDALARM, RCLALARM

## STOF in app ↑ top

PDF page 357 · printed page 3-237

Type

  Command

Description

  Store Flags Command: Sets the states of the system flags or the system and user flags. With argument #nsystem, STOF sets the states of the system flags (–1 through –128) only. With argument { #nsystem, #nuser, #nsystem2 #nuser2 }, STOF sets the states of both the system and user flags. A bit with value 1 sets the corresponding flag; a bit with value 0 clears the corresponding flag. The rightmost (least significant) bit of #nsystem and #nuser correspond to the states of system flag –1 and user flag +1, respectively. STOF can preserve the states of flags before a program executes and changes the states. RCLF can then recall the flag’s states after the program is executed.

Flags

  Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #nsystem | → |
  { #nsystem #nuser #nsystem2 #nuser2 } | → |

See also

  RCLF, PUSH, POP, STWS, RCWS

## STOKEYS not in app ↑ top

PDF page 357 · printed page 3-237

Type

  Command

Description

  Store Key Assignments Command: Defines multiple keys on the user keyboard by assigning objects to specified keys. xkey is a real number of the form rc.p specifying the key by its row number r, its column number c, and its plane (shift) p. (For a definition of plane, see the entry for ASN). The optional initial list parameter or argument S restores all keys without user assignments to their standard key assignments 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. If the argument obj is the name SKEY, the specified key is restored to its standard key assignment.

Flags

  User-Mode Lock (–61) and User Mode (–62) affect the status of the user keyboard

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { obj1, xkey 1, ... objn, xkey n } | → |
  { S, obj1, xkey 1, ... objn, xkey n } | → |
  `S` | → |

See also

  ASN, DELKEYS, RCLKEYS

## STORE not in app ↑ top

PDF page 358 · printed page 3-238

Type

  Function

Description

  Stores a number in a global variable. Given an expression as input, STORE evaluates the expression and stores the numerical value, unlike DEF which stores the expression.

Input

  Level 2/Argument 1: A number or an expression that evaluates to a numeric value. Level 1/Argument 2: The name of the variable in which the number is to be stored. If this variable does not already exist in the current directory path then it is created.

Output

  Level 1/Item 1: The number to which the first argument is evaluated, and which is stored in the variable.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Store in variable Z the result of calculating 17*Y. Assume that Y contains the integer number 2.

  Command | STORE(17*Y, Z)
  Result | 34

See also

  DEF, DEFINE, UNASSIGN

## STOVX not in app ↑ top

PDF page 358 · printed page 3-238

Type

  Command

Description

  Stores a name or list of names in the current CAS variable. This is the same as storing into the VX variable in the CASDIR directory. By default, the CAS variable is called X; this command allows a program to change that name.

Input

  Level 1/Argument 1: A name or list of names.

Output

  None in RPN mode, NOVAL in Algebraic mode.

See also

  RCLVX

## STO+ in app ↑ top

PDF page 358 · printed page 3-238

Type

  Command

Description

  Store Plus Command: Adds a number or other object to the contents of a specified variable. The object on the stack and the object in the variable must be suitable for addition to each other. STO+ can add any combination of objects suitable for addition. Using STO+ to add two arrays (where obj is an array and name is the global name of an array) requires less memory than using the stack to add them.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | `name` | → |
  `name` | obj | → |

See also

  STO–, STO*, STO/, +

## STO– not in app ↑ top

PDF page 359 · printed page 3-239

Type

  Command

Description

  Store Minus Command: Calculates the difference between a number (or other object) and the contents of a specified variable, and stores the new value in the specified variable. The object on the stack and the object in the variable must be suitable for subtraction with each other. STO– can subtract any combination of objects suitable for stack subtraction. Using STO– to subtract two arrays (where obj is an array and name is the global name of an array) requires less memory than using the stack to subtract them.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | `name` | → |
  `name` | obj | → |

See also

  STO+, STO*, STO/, –

## STO* in app ↑ top

PDF page 359 · printed page 3-239

Type

  Command

Description

  Store Times Command: Multiplies the contents of a specified variable by a number or other object. The object on the stack and the object in the variable must be suitable for multiplication with each other. When multiplying two arrays, the result depends on the order of the arguments. The new object of the named variable is the level 2 array times the level 1 array. The arrays must be conformable for multiplication. Using STO* to multiply two arrays or to multiply a number and an array (where obj is an array or a number and name is the global name of an array) requires less memory than using the stack to multiply them.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | `name` | → |
  `name` | obj | → |

See also

  STO+, STO–, STO/, *

## STO/ in app ↑ top

PDF page 359 · printed page 3-239

Type

  Command

Description

  Store Divide Command: Calculates the quotient of a number (or other object) and the contents of a specified variable, and stores the new value in the specified variable. The new object of the specified variable is the level 2 object divided by the level 1 object. The object on the stack and the object in the variable must be suitable for division with each other. If both objects are arrays, the divisor (level 1) must be a square matrix, and the dividend (level 2) must have the same number of columns as the divisor.

  Using STO/ to divide one array by another array or to divide an array by a number (where obj is an array or a number and name is the global name of an array) requires less memory than using the stack to divide them.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | `name` | → |
  `name` | obj | → |

See also

  STO+, STO–, STO*, /

## STOΣ not in app ↑ top

PDF page 360 · printed page 3-240

Type

  Command

Description

  Store Sigma Command: Stores obj in the reserved variable ΣDAT. STOΣ accepts any object and stores it in ΣDAT. However, if the object is not a matrix or the name of a variable containing a matrix, an Invalid ΣDATA error occurs upon subsequent execution of a statistics command.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → |

See also

  CLΣ, RCLΣ, Σ+, Σ–

## STR→ in app ↑ top

PDF page 360 · printed page 3-240

Type

  Command

Description

  Evaluate String Command: Evaluates the text of a string as if the text were entered from the command line. OBJ→ also includes this function. STR→ is included for compatibility with the HP 28S.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  “obj” | → | evaluated-object

See also

  ARRY→, DTAG, EQ→, LIST→, OBJ→, →STR

## →STR in app ↑ top

PDF page 360 · printed page 3-240

Type

  Command

Description

  Object to String Command: Converts any object to string form. The full-precision internal form of a number is not necessarily represented in the result string. To ensure that →STR preserves the full precision of a number, select Standard number display format or a wordsize of 64 bits (or both) before executing →STR. The result string includes the entire object, even if the displayed form of the object is too large to fit in the display. If the argument object is normally displayed in two or more lines, the result string will contain newline characters (character 10) at the end of each line. The newlines are displayed as the character ␍. If the argument object is already a string, →STR returns the string.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12), Number Display Format (–49, –50)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → | “obj”

Example

  →STR can create special displays to label program output or provide prompts for input. The sequence "Result = " SWAP →STR + 1 DISP 1 FREEZE displays Result = object in line 1 of the display, where object is a string form of an object taken from level 1.

See also

  →ARRY, →LIST, STR→, →TAG, →UNIT

## STREAM in app ↑ top

PDF page 361 · printed page 3-241

Type

  Command

Description

  Stream Execution Command: Moves the first two elements from the list onto the stack, and executes obj. Then moves the next element (if any) onto the stack, and executes obj again using the previous result and the new element. Repeats this until the list is exhausted, and returns the final result. STREAM is nominally designed for obj to be a program or command that requires two arguments and returns one result.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  { list } | obj | → | result
  Example 1: { 1 2 3 4 5 } « * » STREAM returns 120.
  Example 2: « + » STREAM is equivalent to ΣLIST.

See also

  DOSUBS

## STRM not in app ↑ top

PDF page 361 · printed page 3-241

Type

  Command

Description

  Starts the StreamSmart application.

Input/Output

  None

## STURM not in app ↑ top

PDF page 361 · printed page 3-241

Type

  Command

Description

  For a polynomial P, STURM returns a list containing Sturm’s sequences of P and their multiplicities

Input

  A polynomial P

Output

  A list containing the Sturm’s sequences for P, and the multiplicity for each (as a real number).

Flags

  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

  Find the Sturm sequences and their multiplicities for the polynomial: 3 x +1

  Command | STURM(X^3+1)
  Result | {[1],-1.,[1],1.,[X^3+1,-(3*X^2),-1],1.}

See also

  STURMAB

## STURMAB not in app ↑ top

PDF page 362 · printed page 3-242

Type

  Command

Description

  For a polynomial P and a closed interval [a, b], STURMAB determines the number of zeroes P has in [a, b]

Input

  A polynomial P

Output

  A list containing a number that is the same sign as P(a) and the number of zeroes P has in [a, b].

Flags

  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

  For the polynomial: 3 x +2 in the interval [-2,0] find the sign at the lower bound, and the number of zeroes

  Command | STURMAB(X^3+2, -2, 0)
  Result | {-6,1}

See also

  STURM, ZEROS

## STWS in app ↑ top

PDF page 362 · printed page 3-242

Type

  Command

Description

  Set Wordsize Command: Sets the current binary integer wordsize to n bits, where n is a value from 1 through 64 (the default is 64). Values of n less than 1 or greater than 64 are interpreted as 1 or 64, respectively. If the wordsize is smaller than an integer entered on the command line, then the most significant bits are not displayed upon entry. The truncated bits are still present internally (unless they exceed 64), but they are not used for calculations and they are lost when a command uses this binary integer as an argument. Results that exceed the given wordsize are also truncated to the wordsize.

Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → |
  #n | → |

See also

  BIN, DEC, HEX, OCT, RCWS

## SUB in app ↑ top

PDF page 362 · printed page 3-242

Type

  Command Operation

Description

  Subset Command: Returns the portion of a string or list defined by specified positions, or returns the rectangular portion of a graphics object or PICT defined by two corner pixel coordinates. If nend position is less than nstart position, SUB returns an empty string or list. Values of n less than 1 are treated as 1; values of n exceeding the length of the string or list are treated as that length. For graphics objects, a user-unit coordinate less than the minimum user-unit coordinate of the graphics object is treated as that minimum. A pixel or user-unit coordinate greater than the maximum pixel or user-unit coordinate of the graphics object is treated as that maximum.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  [[ matrix ]]1 | nstartposition | nendposition | → | [[ matrix ]]2
  [[ matrix ]]1 | {nrow, ncolumn } | nendposition | → | [[ matrix ]]2
  [[ matrix ]]1 | nstartposition | {nrow,, ncolumn } | → | [[ matrix ]]2
  [[ matrix ]]1 | {nrow, ncolumn } | {nrow,, ncolumn } | → | [[ matrix ]]2
  “stringtarget” | nstartposition | nendposition | → | “stringresult”
  { listtarget } | nstartposition | nendposition | → | { listresult }
  grobtarget | { #n1, #m1 } | { #n2 #m2 } | → | grobresult
  grobtarget | ( x 1 , y1 ) | ( x 2 , y2 ) | → | grobresult
  PICT | { #n1, #m1 } | { #n2 #m2 } | → | grobresult
  PICT | ( x 1 , y1 ) | ( x 2 , y2 ) | → | grobresult
  Example 1: { A B C D E } 2 4 SUB returns { B C D }.
  Example 2: "ABCDE" 0 10 SUB returns "ABCDE".
  Example 3: PICT { # 10d #20d } { # 20d # 40d } SUB returns
  Graphic 11 x 21.

See also

  CHR, GOR, GXOR, NUM, POS, REPL, SIZE

## SUBST in app ↑ top

PDF page 363 · printed page 3-243

Type

  Function

Description

  Substitutes a value for a variable in an expression. The value can be numeric or an expression. This is similar to the Where function, denoted by the symbol |, but SUBST substitutes without evaluating the resulting expression.

Input

  Level 2/Argument 1: An expression. Level 1/Argument 2: The value or expression to be substituted.

Output

  The expression with the substitution made.

Flags

  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

  Substitute x = z+1 for x in the following expression, and apply the EXPAND command to simplify the result: 2 x + 3x + 7

      Command:      SUBST(X^2+3*X+7,X=Z+1)

  EXPAND(ANS(1))

      Result:       Z^2+5*Z+11

See also

  | (where command)

## SUBTMOD in app ↑ top

PDF page 363 · printed page 3-243

Type

  Function

Description

  Performs a subtraction, modulo the current modulus.

Input

  Level 2/Argument 1: The object or number to be subtracted from. Level 1/Argument 2: The object or number to subtract.

Output

  The result of the subtraction, modulo the current modulus.

Flags

  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).

## SVD not in app ↑ top

PDF page 364 · printed page 3-244

Type

  Command

Description

  Singular Value Decomposition Command: Returns the singular value decomposition of an m × n matrix. SVD decomposes A into 2 matrices and a vector. U is an m × m orthogonal matrix, V is an n × n orthogonal matrix, and S is a real vector, such that A = U × diag(S) × V . S has length MIN(m,n) and contains the singular values of A in nonincreasing order. The matrix diag(S) is an m×n diagonal matrix containing the singular values S. The computed results should minimize (within computational precision): A – U ⋅ diag ( S ) ⋅ V -------------------------------------------------- min ( m, n ) ⋅ A where diag(S) denotes the m × n diagonal matrix containing the singular values S.

Input/Output

  Level 1/Argument 1 |  | Level 3/Item 1 | Level 2/Item 2 | Level 1/Item 3
  --- | --- | --- | --- | ---
  [[ matrix ]]A | → | [[ matrix ]]U | [[ matrix ]]V | [ vector ]S

See also

  DIAG→, MIN, SVL

## SVL not in app ↑ top

PDF page 364 · printed page 3-244

Type

  Command

Description

  Singular Values Command: Returns the singular values of an m × n matrix. SLV returns a real vector that contains the singular values of an m × n matrix in non-increasing order. The vector has length MIN(m,n).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]] | → | [ vector ]

See also

  MIN, SVD

## SWAP in app ↑ top

PDF page 364 · printed page 3-244

Type

  RPL Command

Description

  Swap Objects Command: Swaps the position of the two inputs.

Input/Output

  Level 2 | Level 1 |  | Level 2 | Level 1
  --- | --- | --- | --- | ---
  obj1 | obj2 | → | obj2 | obj1

See also

  DUP, DUPN, DUP2, OVER, PICK, ROLL, ROLLD, ROT

## SYSEVAL not in app ↑ top

PDF page 365 · printed page 3-245

Type

  Command

Description

  Evaluate System Object Command: Evaluates unnamed operating system objects specified by their memory addresses. WARNING: Use extreme care when executing this function. Using SYSEVAL with random addresses will almost always cause a memory loss. Do not use this function unless you know what you are doing.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  #naddress | → |

Example

  Display the version string of a calculator by executing #2F389h SYSEVAL. This should display "HPHP49-C".

See also

  EVAL, LIBEVAL, FLASHEVAL

## SYLVESTER not in app ↑ top

PDF page 365 · printed page 3-245

Type

  Command

Description

  For a symmetric matrix A, returns D and P where D is a diagonal matrix and A = PTDP

Input

  A symmetric matrix.

Output

  Level 2/Item 1: the diagonal matrix, D. Level 1/Item 2: The matrix P.

Flags

  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

  Rewrite in PTDP form the matrix: 12 24

  Command | SYLVESTER([1, 2][2, 4])
  Result | {[1, 0], [[1, 2][0, 1]]}

## SYST2MAT not in app ↑ top

PDF page 365 · printed page 3-245

Type

  Command

Description

  Converts a system of linear equations in algebraic form to matrix form.

Input

  Level 2/Argument 1: A vector containing a system of linear equations. An expression with no equal sign is treated as an equation setting the expression equal to zero. Level 1/Argument 2: A vector whose elements are the system’s variables. The variables must not exist in the current path.

Output

  A matrix that represents the system of linear equations.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Convert this system to a matrix: X–Y=0 2X + Y = 5

      Command:       SYST2MAT([X-Y, 2*X+Y=5],[X, Y])

  1 –1 0

      Result:         2 1 –5

## %T in app ↑ top

PDF page 366 · printed page 3-246

Type

  Function

Description

  Percent of Total Function: Returns the percent of the first argument that is represented by the second argument. If both arguments are unit objects, the units must be consistent with each other. The dimensions of a unit object are dropped from the result, but units are part of the calculation. For more information on using temperature units with arithmetic functions, refer to the entry for +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | 100y/x
  x | `symb` | → | `%T(x,symb)`
  `symb` | x | → | `%T(symb,x)`
  `symb1` | `symb2` | → | `%T(symb1, symb2)`
  x_unit1 | y_unit2 | → | 100y_unit2/x_unit1
  x_unit | `symb` | → | `%T(x_unit,symb)`
  `symb` | x_unit | → | `%T(symb,x_unit)`
  Example 1: 1_m 500_cm %T returns 500, because 500 cm represents 500% of 1 m.
  Example 2: 100_K 50_K %T returns 50.

See also

  +, %, %CH

## TABVAL not in app ↑ top

PDF page 366 · printed page 3-246

Type

  Command

Description

  For an expression and a list of values, stores the expression in EQ, and returns the results of substituting the values for the current variable in the expression.

Input

  Level 2/Argument 1: An algebraic expression in terms of the current variable. Level 1/Argument 2: A list of values for which the expression is to be evaluated.

Output

  Level 2/Item 1: The algebraic expression. Level 1/Item 2: A list containing two lists: a list of the values and a list of the corresponding results.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear). 2

Example

  Substitute 1, 2, and 3 into x + 1 .

  Command | TABVAL(X^2+1,{1, 2, 3})
  Result | { X^2+1,{{1, 2, 3},{2, 5, 10}}}

## TABVAR not in app ↑ top

PDF page 367 · printed page 3-247

Type

  Command

Description

  For a function of the current variable, with a rational derivative, computes the variation table, that is the turning points of the function and where the function is increasing or decreasing.

Input

  An expression in terms of the current variable, which has a rational derivative.

Output

  Level 3/Item 1: The original rational function. Level 2/Item 2: A list of two lists. The first list indicates the variation of the function (where it is increasing or decreasing) in terms of the independent variable. The second list indicates the variation in terms of the dependent variable, the function value. Level 1/Item 3: A graphic object that shows how the variation table was computed.

Flags

  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

      Tabulate the variation of the function: 2 x –1
          Command:        TABVAR(X^2-1)
          Result:         {`X^2-1` {{ `-∞` – 0 + `∞` }{ `+∞` ↓ `-1` ↑ `+∞` }} Graphic 96 × 55 }
          Viewing the graphic, one sees the original function F and its derivative, as functions of X, and the variation table for X and F, shown as a matrix

See also

  SIGNTAB

## →TAG in app ↑ top

PDF page 367 · printed page 3-247

Type

  Command

Description

  Stack to Tag Command: Combines objects in levels 1 and 2 to create tagged (labeled) object. The “tag” argument is a string of fewer than 256 characters.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | “tag” | → | :tag:obj
  obj | `name` | → | :name:obj
  obj | x | → | :x:obj

See also

  →ARRY, DTAG, →LIST, OBJ→, →STR, →UNIT

## TAIL in app ↑ top

PDF page 367 · printed page 3-247

Type

  Command

Description

  Last Listed Elements Command: Returns all but the first element of a list or string.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { obj1 ... objn } | → | { obj2 ... objn }
  “string1” | → | “string2”

Example

  "tall" TAIL returns "all".

See also

  HEAD

## TAN in app ↑ top

PDF page 368 · printed page 3-248

Type

  Analytic function

Description

  Tangent Analytic Function: Returns the tangent of the argument. For real arguments, the current angle mode determines the number’s interpretation as an angle, unless the angular units are specified. For a real argument that is an odd-integer multiple of 90 in Degrees mode, an Infinite Result exception occurs. If flag –22 is set (no error), the sign of the result (MAXR) matches that of the argument. For complex arguments: ( sin x) ( cos x ) + i ( sinh y ) ( cosh y ) tan ( x + iy ) = ------------------------------------------------------------------------------

                                                                         2                    2

  sin h y + cos x If the argument for TAN is a unit object, then the specified angular unit overrides the angle mode to determine the result. Integration and differentiation, on the other hand, always observe the angle mode. Therefore, to correctly integrate or differentiate expressions containing TAN with a unit object, the angle mode must be set to Radians (since this is a “neutral” mode).

Flags

  Numerical Results (–3), Angle Mode (–17, –18), Infinite Result Exception (–22)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | tan z
  `symb` | → | `TAN(symb)`
  x_unitangular | → | tan (x_unitangular)

See also

  ATAN, COS, SIN

## TAN2CS2 in app ↑ top

PDF page 368 · printed page 3-248

Type

  Command

Description

  Replaces tan(x) terms in an expression with (1-cos(2x))/sin(2x) terms.

Input

  An expression

Output

  The transformed expression.

Flags

  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

  Replace tan(x) terms in the function: ( tan ( x ) ) 2

  Command | TAN2CS2(TAN(X)^2)
  Result | ((1-COS(2*X))/SIN(2*X))^2

See also

  TAN2SC, TAN2SC2

## TAN2SC in app ↑ top

PDF page 368 · printed page 3-248

Type

  Command

Description

  Replaces tan(x) sub-expressions with sin(x)/cos(x).

Input

  An expression

Output

  The transformed expression.

Flags

  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

  Replace tan(x) terms in the function: ( tan ( x ) ) 2

  Command | TAN2SC(TAN(X)^2)
  Result | (SIN(X)/COS(X))^2

See also

  HALFTAN, TAN2CS2, TAN2SC2

## TAN2SC2 in app ↑ top

PDF page 369 · printed page 3-249

Type

  Command

Description

  Replaces tan(x) terms in an expression with sin(2x)/1+cos(2x) terms.

Input

  An expression

Output

  The transformed expression.

Flags

  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). In previous versions of the CAS, if flag –116 was set (Prefer sin()), then TAN2SC2 replaced tan(x) terms with: 1 – cos(2x)/sin(2x). This action is now performed by the TAN2CS2 command.

Example

  Replace tan(x) terms in the function: ( tan ( x ) ) 2

  Command | TAN2SC2(TAN(X)^2)
  Result | (SIN(2*X)/(1+COS(2*X)))^2

See also

  HALFTAN, TAN2CS2, TAN2SC

## TANH in app ↑ top

PDF page 369 · printed page 3-249

Type

  Analytic function

Description

  Hyperbolic Tangent Analytic Function: Returns the hyperbolic tangent of the argument. For complex arguments, sinh 2x + i sin 2y tanh ( x + iy ) = -------------------------------------- cosh 2x + cos 2y

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  z | → | tanh z
  `symb` | → | `TANH(symb)`

See also

  ATANH, COSH, SINH

## TAYLOR0 not in app ↑ top

PDF page 370 · printed page 3-250

Type

  Function

Description

  Performs a fourth-order Taylor expansion of an expression at x = 0.

Input

  An expression

Output

  The Taylor expansion of the expression.

Flags

  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

  Obtain the fourth-order Taylor series expansion of cos(x) at x=0.

  Command | TAYLOR0(COS(X))
  Result | 1/24*X^4+-1/2*X^2+1

See also

  DIVPC, lim, TAYLR, SERIES

## TAYLR not in app ↑ top

PDF page 370 · printed page 3-250

Type

  Command

Description

  Taylor Polynomial Command: Calculates the nth order Taylor polynomial of symb in the variable global. The polynomial is calculated at the point global = 0. The expression symb may have a removable singularity at 0. The order, n, is the relative order of the Taylor polynomial — the difference in order between the largest and smallest power of global in the polynomial. TAYLR always returns a symbolic result, regardless of the state of the Numeric Results flag (–3).

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  `symb` | `global` | norder | → | `symbTaylor`

Example

      The command sequence `1+SIN(X)^2` `X` 5 TAYLR returns `1+X^2-8/4!*X^4`.

See also

  ∂, ∫, Σ

## TCHEBYCHEFF in app ↑ top

PDF page 370 · printed page 3-250

Type

  Function

Description

  Returns the nth Tchebycheff polynomial.

Input

  A non-negative integer, n.

Output

  The nth Tchebycheff polynomial.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Obtain the fourth Tchebycheff polynomial.

  Command | TCHEBYCHEFF(4)
  Result | 8*X^4-8*X^2+1

See also

  HERMITE, LEGENDRE

## TCOLLECT in app ↑ top

PDF page 371 · printed page 3-251

Type

  Command

Description

  Linearizes products in a trigonometric expression by collecting sine and cosine terms, and by combining sine and cosine terms of the same argument.

Input

  An expression with trigonometric terms.

Output

  The simplified expression.

Flags

  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

  Collect terms in the expression: sin 2x + cos 2x

  Command | TCOLLECT(SIN(2*X)+COS(2*X))
  Result | √2*COS(2*X-π/4)

See also

  TEXPAND, TLIN

## TDELTA not in app ↑ top

PDF page 371 · printed page 3-251

Type

  Function

Description

  Temperature Delta Function: Calculates a temperature change. TDELTA subtracts two points on a temperature scale, yielding a temperature increment (not an actual temperature). x or x_unit1 is the final temperature, and y or y_unit2 is the initial temperature. If unit objects are given, the increment is returned as a unit object with the same units as x_unit1. If real numbers are given, the increment is returned as a real number.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | xdelta
  x_unit1 | x_unit2 | → | x_unit1delta
  x_unit | `symb` | → | `TDELTA(x_unit, symb)`
  `symb` | y_unit | → | `TDELTA(symb, y_unit)`
  `symb1` | `symb2` | → | `TDELTA(symb1, symb2)`

See also

  TINC

## TESTS not in app ↑ top

PDF page 371 · printed page 3-251

Type

  Command

Description

  Displays a menu or list containing the ASSUME and UNASSUME commands, and tests that can be included in algebraic expressions.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TRIGO

## TEVAL not in app ↑ top

PDF page 372 · printed page 3-252

Type

  Function

Description

  For the specified operation, performs the same function as EVAL, and returns the time taken to perform the evaluation as well as the result.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 2 | Level 1/Item 1
  --- | --- | --- | ---
  Object | → | result | time taken

See also

  EVAL

## TEXPAND in app ↑ top

PDF page 372 · printed page 3-252

Type

  Command

Description

  Expands transcendental functions.

Input

  An expression.

Output

  The transformation of the expression.

Flags

  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

  Expand the following expression: ln(sin(x+y))

  Command | TEXPAND(LN(SIN(X+Y)))
  Result | LN(COS(Y)*SIN(X)+SIN(Y)* COS(X))

See also

  TCOLLECT, TLIN

## TEXT not in app ↑ top

PDF page 372 · printed page 3-252

Type

  Command

Description

  Show Stack Display Command: Displays the stack display. TEXT switches from the graphics display to the stack display. TEXT does not update the stack display.

Input/Output

  None

Example

  The command sequence DRAW 5 WAIT TEXT selects the graphics display and plots the contents of the reserved variable EQ (or reserved variable ΣDAT). It subsequently waits for 5 seconds, and then switches back from the graphics display to the stack display.

See also

  PICTURE, PVIEW

## THEN not in app ↑ top

PDF page 372 · printed page 3-252

Type

  Command

Description

  THEN Command: Starts the true-clause in conditional or error-trapping structure. See the IF and IFFER entries for more information.

Input/Output

  None

See also

  CASE, ELSE, END, IF IFERR

## TICKS not in app ↑ top

PDF page 373 · printed page 3-253

Type

  Command

Description

  Ticks Command: Returns the system time as a binary integer, in units of 1/8192 second.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | #ntime |

Example

  If the result from a previous invocation from TICKS is on level 1 of the stack, then the command sequence TICKS SWAP - B->R 8192 / returns a real number whose value is the elapsed time in seconds between the two invocations.

See also

  TIME

## TIME not in app ↑ top

PDF page 373 · printed page 3-253

Type

  Command

Description

  Time Command: Returns the system time in the form HH.MMSSs. time has the form HH.MMSSs, where HH is hours, MM is minutes, SS is seconds, and s is zero or more digits (as many as allowed by the current display mode) representing fractional seconds. time is always returned in 24-hour format, regardless of the state of the Clock Format flag (–41).

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | time |

See also

  DATE, TICKS, TSTR

## →TIME not in app ↑ top

PDF page 373 · printed page 3-253

Type

  Command

Description

  Set System Time Command: Sets the system time. time must have the form HH.MMSSs, where HH is hours, MM is minutes, SS is seconds, and s is zero or more digits (as many as allowed by the current display mode) representing fractional seconds. time must use 24-hour format.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  time | → |

See also

  CLKADJ, →DATE

## TINC not in app ↑ top

PDF page 373 · printed page 3-253

Type

  Function

Description

  Temperature Increment Command: Calculates a temperature increment. TINC adds a temperature increment (not an actual temperature) to a point on a temperature scale. Use a negative increment to subtract the increment from the temperature. xinitial or x_unit1 is the initial temperature, and ydelta or y_unit2delta is the temperature increment. The returned temperature is the resulting final temperature. If unit objects are given, the final temperature is returned as a unit object with the same units as x_unit1. If real numbers are given, the final temperature is returned as a real number.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xinitial | ydelta | → | xfinal
  x_unit1 | y_unit2delta | → | x_unit1final
  x_unit | `symb` | → | `TINC(x_unit, symb)`
  `symb` | y_unitdelta | → | `TINC(symb, y_unitdelta)`
  `symb1` | `symb2` | → | `TINC(symb1, symb2)`

See also

  TDELTA

## TLIN in app ↑ top

PDF page 374 · printed page 3-254

Type

  Command

Description

  Linearizes and simplifies trigonometric expressions. Note that this function does not collect sin and cos terms of the same angle.

Input

  An expression.

Output

  The transformation of the expression.

Flags

  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

  Linearize and simplify the following: 4 ( cos ( x ) )

  Command | TLIN(COS(X)^4)
  Result | (1/8)*COS(4X)+(1/2)*COS(2X)+(3/8)

See also

  SIMPLIFY, TCOLLECT, TEXPAND

## TLINE not in app ↑ top

PDF page 374 · printed page 3-254

Type

  Command

Description

  Toggle Line Command: For each pixel along the line in PICT defined by the specified coordinates, TLINE turns off every pixel that is on, and turns on every pixel that is off.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  (x1,y1) | (x2,y2) | → |
  { #n1 #m1 } | { #n2 #m2 } | → |

Example

      The following program toggles on and off 10 times the pixels on the line defined by user-unit coordinates (1,1) and (9,9). Each state is maintained for .25 seconds. « ERASE 0 10 XRNG 0 10 YRNG { # 0d # 0d } PVIEW « 1 10 START (1,1) (9,9) TLINE .25 WAIT NEXT » »

See also

  ARC, BOX, LINE

## TMENU not in app ↑ top

PDF page 375 · printed page 3-255

Type

  Command

Description

  Temporary Menu Command: Displays a built-in menu, library menu, or user-defined menu. TMENU works just like MENU, except for user-defined menus (specified by a list or by the name of a variable that contains a list). Such menus are displayed like a custom menu and work like a custom menu, but are not stored in reserved variable CST. Thus, a menu defined and displayed by TMENU cannot be redisplayed by evaluating CST. See Appendix H for a list of the calculator’s built-in menus and the corresponding menu numbers (xmenu).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  xmenu | → |
  { listdefinition } | → |
  `namedefinition` | → |
  Example 1: | 7 TMENU displays the first page of the MTH MATR menu. |
  Example 2: | 48.02 TMENU displays the second page of the UNITS MASS menu. |
  Example 3: | 256 TMENU displays the first page of commands in library 256. |
  Example 4: | { A 123 "ABC" } TMENU displays the custom menu defined by the list argument. |
  Example 5: | `MYMENU` TMENU displays the custom menu defined by the name argument. |

See also

  MENU, RCLMENU

## TOT in app ↑ top

PDF page 375 · printed page 3-255

Type

  Command

Description

  Total Command: Computes the sum of each of the m columns of coordinate values in the current statistics matrix (reserved variable ΣDAT). The sums are returned as a vector of m real numbers, or as a single real number if m = 1.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xsum |
  → | [ xsum 1, xsum 2, ... ,xsum m ] |

See also

  MAXΣ, MINΣ, MEAN, PSDEV, PVAR, SDEV, VAR

## TRACE in app ↑ top

PDF page 375 · printed page 3-255

Type

  Command

Description

  Matrix Trace Command: Returns the trace of a square matrix. The trace of a square matrix is the sum of its diagonal elements.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]]n×n | → | xtrace

See also

  CONJ, DET, IDN

## TRAN not in app ↑ top

PDF page 375 · printed page 3-255

Type

  Command

Description

  Transpose Matrix Command: Returns the transpose of a matrix. Same as TRN, but without conjugation of complex numbers.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]] | → | [[ matrix ]]transpose
  `name` | → |

See also

  CONJ, TRN

## TRANSIO not in app ↑ top

PDF page 376 · printed page 3-256

Type

  Command

Description

  I/O Translation Command: Specifies the character translation option. These translations affect only ASCII Kermit transfers and files printed to the serial port. Legal values for n are as follows:

  n | Effect
  --- | ---
  0 | No translation
  1 | Translate character 10 (line feed only) to /from characters 10 and 13 (line feed

  with carriage return, the Kermit protocol) (the default value)

  2 | Translate characters 128 through 159 (80 through 9F hexadecimal)
  --- | ---
  3 | Translate all characters (128 through 255)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  noption | → |

See also

  BAUD, CKSM, PARITY

## TRIG not in app ↑ top

PDF page 376 · printed page 3-256

Type

  Command

Description

  Converts complex logarithmic and exponential subexpressions into their equivalent trigonometric

                                                                                   2           2

  expressions. It also simplifies trigonometric expressions by using: ( sin x ) + ( cos x ) = 1

Input

  A complex expression with logarithmic and/or exponential terms, or a trigonometric expression.

Output

  The transformed expression.

Flags

  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). Prefers cosine terms if “prefer cos” is selected (flag –116 clear), prefers sine terms if flag –116 is set. Must be in Complex mode (flag –103 set) if a complex expression is being simplified.

Example

  Express the following in trigonometric terms: ln ( x + i )

  Command: | TRIG(LN(X+i))
  --- | ---
  2 | 1

  L N( X + 1 ) + 2 × i × A TA N- --- - x- ------------------------------------------------------------------------------ 2 Result:

See also

  TRIGCOS, TRIGSIN, TRIGTAN

## TRIGCOS not in app ↑ top

PDF page 377 · printed page 3-257

Type

  Command

Description

  Simplifies a trigonometric expression by applying the identity:

                          2                        2

  ( sin x ) + ( cos x ) = 1 Returns only cosine terms if possible.

Input

  An expression with trigonometric terms.

Output

  The transformed expression.

Flags

  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).

See also

  TRIG, TRIGSIN, TRIGTAN

## TRIGO not in app ↑ top

PDF page 377 · printed page 3-257

Type

  Command

Description

  Displays a menu or list containing the CAS commands for transforming trigonometric expressions.

Flags

  If the CHOOSE boxes flag is clear (flag –117 clear), displays the operations as a numbered list. If the flag is set, displays the operations as a menu of function keys.

See also

  ALGB, ARIT, CONSTANTS, DIFF, EXP&LN, INTEGER, MAIN, MATHS, MATR, MODULAR, POLYNOMIAL, REWRITE, TESTS

## TRIGSIN not in app ↑ top

PDF page 377 · printed page 3-257

Type

  Command

Description

  Simplifies a trigonometric expression by applying the identity:

                    2                        2

  ( sin x ) + ( cos x ) = 1 Returns only sine terms if possible.

Input

  An expression with trigonometric terms.

Output

  The transformed expression.

Flags

  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).

See also

  TRIG, TRIGCOS, TRIGTAN

## TRIGTAN not in app ↑ top

PDF page 377 · printed page 3-257

Type

  Command

Description

  Replaces sine and cosine terms in a trigonometric expression with tangent terms.

Input

  An expression with trigonometric terms.

Output

  The transformed expression.

Flags

  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

  Express the following in tan terms: 2 ( sinx)

      Command:        TRIGTAN(SIN(X)^2)

Result

  TAN(X)^2/(TAN(X)^2+1)

See also

  TRIG, TRIGCOS, TRIGSIN

## TRN in app ↑ top

PDF page 378 · printed page 3-258

Type

  Command

Description

  Transpose Matrix Command: Returns the (conjugate) transpose of a matrix. TRN replaces an n × m matrix A with an m × n matrix AT, where: AijT = Aji for real matrices and AijT = CONJ(Aji) for complex matrices If the matrix is specified by name, AT replaces A in name.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [[ matrix ]] | → | [[ matrix ]]transpose
  `name` | → |

Example

  [[ 2 3 1 ][ 4 6 9]] TRN returns [[ 2 4 ][ 3 6 ][ 1 9 ]].

See also

  CONJ, TRAN

## TRNC in app ↑ top

PDF page 378 · printed page 3-258

Type

  Function

Description

  Truncate Function: Truncates an object to a specified number of decimal places or significant digits, or to fit the current display format. ntruncate (or symbtruncate if flag –3 is set) controls how the level 2 argument is truncated, as follows:

  ntruncate | Effect on Level 2 Argument
  --- | ---
  0 through 11 | truncated to n decimal places

  –1 through –11 truncated to n significant digits

                12                     truncated to the current display format

  For complex numbers and arrays, each real number element is truncated. For unit objects, the number part of the object is truncated.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | ntruncate | → | z2
  z1 | `symbtruncate` | → | `TRNC(z1,symbtruncate)`
  `symb1` | ntruncate | → | `TRNC(symb1,ntruncate)`
  `symb1` | `symbtruncate` | → | `TRNC(symb1,symbtruncate)`
  [ array ]1 | ntruncate | → | [ array ]2
  x_unit | ntruncate | → | y_unit
  x_unit | `symbtruncate` → | `TRNC(x_unit,symbtruncate)` |
  Example 1: (4.5792,8.1275) 2 TRNC returns (4.57,8.12).
  Example 2: [ 2.34907 3.96351 2.73453 ] -2 TRNC returns [ 2.3 3.9 2.7 ].

See also

  RND

## TRUNC in app ↑ top

PDF page 379 · printed page 3-259

Type

  Function

Description

  Truncates a series expansion.

Input

  Level 2/Argument 1: The expression that you want to truncate. Level 1/Argument 2: The expression to truncate with respect to.

Output

  The expression from Level 2/Argument 1, with terms of order greater than or equal to the order of the expression in Level 1/Argument 2 removed.

Flags

  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

  Expand the expression (x+1)7, and remove all terms in x4 and higher powers of x

  Command | TRUNC((X+1)^7,X^4)
  Result | 35*X^3+21*X^2+7*X+1

See also

  DIVPC, EXPAND, SERIES

## TRUTH not in app ↑ top

PDF page 379 · printed page 3-259

Type

  Command

Description

  Truth Plot Type Command: Sets the plot type to TRUTH. When the plot type is TRUTH, the DRAW command plots the current equation as a truth-valued function of two real variables. The current equation is specified in the reserved variable EQ. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type TRUTH, the elements of PPAR are used as follows:

  - (xmin, ymin) is a complex number specifying the lower left corner of PICT (the lower left corner of the display range). The default value is (–6.5,–3.1) for the HP 48gII and (–6.5,–3.9) for the HP 50g and 49g+.
  - (xmax, ymax) is a complex number specifying the upper right corner of PICT (the upper right corner of the display range). The default value is (6.5,3.2) for the HP 48gII and (6.5,4.0) for the HP 50g and 49g+.
  - indep is a name specifying the independent variable on the horizontal axis, or a list containing such a name and two numbers specifying the minimum and maximum values for the independent variable (the horizontal plotting range). The default value is X.
  - res is a real number specifying the interval (in user-unit coordinates) between plotted values of the independent variable on the horizontal axis, or a binary integer specifying that interval in pixels. The default value is 0, which specifies an interval of 1 pixel.
  - axes is a list containing one or more of the following, in the order listed: a complex number specifying the user-unit coordinates of the plot origin, a list specifying the tick-mark annotation, and two strings specifying labels for the horizontal and vertical axes. The default value is (0,0).
  - ptype is a command name specifying the plot type. Executing the command TRUTH places the name TRUTH in ptype.
  - depend is a name specifying the independent variable on the vertical axis, or a list containing such a name and two numbers specifying the minimum and maximum values for the independent variable on the vertical axis (the vertical plotting range). The default value is Y. The contents of EQ must be an expression or program, and cannot be an equation. It is evaluated for each pixel in the plot region. The minimum and maximum values of the independent variables (the plotting ranges) can be specified in indep and depend; otherwise, the values in (xmin, ymin) and (xmax, ymax)(the display range) are used. The result of each evaluation must be a real number. If the result is zero, the state of the pixel is unchanged. If the result is nonzero, the pixel is turned on (made dark).
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, WIREFRAME, YSLICE

## TSIMP in app ↑ top

PDF page 380 · printed page 3-260

Type

  Command

Description

  Performs simplifications on expressions involving exponentials and logarithms. Converts base 10 logarithms to natural logarithms

Input

  An expression

Output

  The simplified expression.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Simplify log(x+x)

  Command | TSIMP(LOG(X+X))
  Result | (LN(2)+LN(X))/(LN(5)+LN(2))

See also

  TEXPAND, TLIN

## TSTR not in app ↑ top

PDF page 380 · printed page 3-260

Type

  Command

Description

  Date and Time String Command: Returns a string derived from the date and time. The string has the form "DOW DATE TIME", where DOW is a three-letter abbreviation of the day of the week corresponding to the argument date and time, DATE is the argument date in the current date format, and TIME is the argument time in the current time format.

Flags

  Time Format (–41), Date Format (–42)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  date | time | → | “DOW DATE TIME“

Example

  With flags –42 and –41 clear, 2.061990 14.55 TSTR returns "TUE 02/06/90 02:55:00P".

See also

  DATE, TICKS, TIME

## TVARS in app ↑ top

PDF page 381 · printed page 3-261

Type

  Command

Description

  Typed Variables Command: Lists all global variables in the current directory that contain objects of the specified types. If the current directory contains no variables of the specified types, TVARS returns an empty list. For a table of the object-type numbers, see the entry for TYPE.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  ntype | → | { global ... }
  { ntype ...} | → | { global ... }

See also

  PVARS, TYPE, VARS

## TVM not in app ↑ top

PDF page 381 · printed page 3-261

Type

  Command

Description

  TVM Menu Command: Displays the TVM Solver menu.

Input/Output

  None

See also

  AMORT, TVMBEG, TVMEND, TVMROOT

## TVMBEG not in app ↑ top

PDF page 381 · printed page 3-261

Type

  Command

Description

  Payment at Start of Period Command: Specifies that TVM calculations treat payments as being made at the beginning of the compounding periods.

Input/Output

  None

See also

  AMORT, TVM, TVMEND, TVMROOT

## TVMEND not in app ↑ top

PDF page 381 · printed page 3-261

Type

  Command

Description

  Payment at End of Period Command: Specifies that TVM calculations treat payments as being made at the end of the compounding periods.

Input/Output

  None

See also

  AMORT, TVM, TVMBEG, TVMROOT

## TVMROOT not in app ↑ top

PDF page 381 · printed page 3-261

Type

  Command

Description

  TVM Root Command: Solves for the specified TVM variable using values from the remaining TVM variables.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `TVM variable` | → | xTVM variable

See also

  AMORT, TVM, TVMBEG, TVMEND

## TYPE in app ↑ top

PDF page 382 · printed page 3-262

Type

  Command

Description

  Type Command: Returns the type number of an object, as shown in the following table:

                Object Type:             Number:                         Object Type:                   Number:
                     User objects:                                     User objects (continued):
          Real number                             0                 Backup object                               17
          Complex number                          1                 Real integer                                28
          Character string                        2                 Symbolic vector/matrix                      29
          Real array                              3                        Built-in Commands:
          Complex array                           4                 Built-in function                           18
          List                                    5                 Built-in command                            19
          Global name                             6                           System Objects:
          Local name                              7                 System binary                               20
          Program                                 8                 Extended real                               21
          Algebraic object                        9                 Extended complex                            22
          Binary integer                         10                 Linked array                                23
          Graphics object                        11                 Character                                   24
          Tagged object                          12                 Code object                                 25
          Unit object                            13                 Library data                                26
          XLIB name                              14                 Mini font                                   27
          Directory object                       15                 Font                                        30
          Library                                16                 Extended object                             31

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → | ntype

See also

  SAME, TVARS, VTYPE, ==

## UBASE in app ↑ top

PDF page 382 · printed page 3-262

Type

  Function

Description

  Convert to SI Base Units Function: Converts a unit object to SI base units.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x_unit | → | y_base-units
  `symb` | → | `UBASE(symb)`

Example

  30_knot UBASE returns 15.4333333333_m/s.

See also

  CONVERT, UFACT, →UNIT, UVAL

## UFACT not in app ↑ top

PDF page 383 · printed page 3-263

Type

  Command

Description

  Factor Unit Command: Factors the level 1 unit from the unit expression of the level 2 unit object.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x1_unit1 | x2_unit2 | → | x3_unit2*unit3

Example

  1_W 1_N UFACT returns 1_N*m/s.

See also

  CONVERT, UBASE, →UNIT, UVAL

## UFL1→MINIF not in app ↑ top

PDF page 383 · printed page 3-263

Type

  Command

Description

  Converts a UFL1 (universal font library) fontset to a minifont compatible with the calculator. You specify the fontset and give it an ID (0–255). The font must be a 6-by-4 font.

Input/Output

       Level 2/Argument 1   Level 1/Argument 2                       Level 1/Item 1

          objfontset                    nID           → The font converted to minifont.

See also

  →MINIFONT, MINIFONT→

## UNASSIGN not in app ↑ top

PDF page 383 · printed page 3-263

Type

  Command

Description

  Removes global variables and returns their values. This is an algebraic version of the PURGE command.

Input

  Level 1/Item 1: The name of a global variable, or a list of global names, to be purged.

Output

  Level 1/Item 1: The value or list of values that were stored in the now purged variables. If a variable does not exist, or is not in the current directory path, it is not removed, and its name is returned.

Flags

  The status of the purge confirm flag (flag –76) is ignored, variables are purged with no request for confirmation.

Example

  Try to remove the global variable U, which contains 17.5, and the global variable V, which is not on the current directory path.

  Command | UNASSIGN({U, V})
  Result | {17.5, V}

See also

  ADDTOREAL, ASSUME, DEF, LOCAL, PURGE, STO, STORE, UNASSUME, UNBIND

## UNASSUME not in app ↑ top

PDF page 383 · printed page 3-263

Type

  Command

Description

  Removes all assumptions on specified global variables, whether created by default, by ADDTOREAL or by ASSUME. Does this by removing the variable names from the list REALASSUME. Returns the variable names. To remove assumptions on a variable but leave it in REALASSUME, use ADDTOREAL instead of UNASSUME.

Input

  Level 1/Item 1: The name of a global variable, or a list of global names, to be removed from the REALASSUME list.

Output

  Level 1/Item 1: The same name or list of names as was input, even if any of the named variables were not in REALASSUME.

Example

  Remove the variables S1 and S2 which are include in the REALASSUME list by default.

  Command | UNASSUME({S1, S2})
  Result | {S1, S2}

See also

  ADDTOREAL, ASSUME, DEF, LOCAL, UNASSIGN, UNBIND

## UNBIND not in app ↑ top

PDF page 384 · printed page 3-264

Type

  Command

Description

  Removes all local variables created by the LOCAL command, and returns their values. This is useful only if a program needs to remove local variables created earlier in the same program.

Input

  None

Output

  Level 1/Item 1: A list of the local variables that have been removed, with their values.

Example

  Remove the local variables ←A and ←B created by the example for LOCAL.

  Command | UNBIND
  Result | {←B=2, ←A=0}

See also

  DEF, LOCAL, STORE, UNASSIGN, UNASSUME

## →UNIT in app ↑ top

PDF page 384 · printed page 3-264

Type

  Command

Description

  Stack to Unit Object Command: Creates a unit object from a real number and the unit part of a unit object. →UNIT adds units to a real number, combining the number and the unit part of a unit object (the numerical part of the unit object is ignored). →UNIT is the reverse of OBJ→ applied to a unit object.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y_unit | → | x_unit

See also

  →ARRY, →LIST, →STR, →TAG

## UNPICK in app ↑ top

PDF page 384 · printed page 3-264

Type

  RPL Command

Description

  Replaces the object at level n+2 with the object at level 2 and deletes the objects at levels 1 and 2. Can be though of as a “stack poke”.

Input/Output

       Ln+2      Ln+1       L3            L2    L1                  Ln        Ln–1     L1

          objn     objn-1    obj1 obj n → obj objn-1 obj1

Example

  Replace the fourth object with an "X": 55555 4444 333 22 1 "X" 4 UNPICK returns 55555 "X" 333 22 1.

See also

  OVER, PICK, ROLL, ROLLD, SWAP, ROT

## UNROT not in app ↑ top

PDF page 385 · printed page 3-265

Type

  RPL Command

Description

  Changes the order of the first three objects on the stack. The order of the change is the opposite to that of the ROT command.

Input/Output

  L3 | L2 | L1 |  | L3 | L2 | L1
  --- | --- | --- | --- | --- | --- | ---
  obj3 | obj2 | obj1 | → | obj1 | obj3 | obj2

Example

  333 22 1 UNROT returns 1 333 22.

See also

  OVER, PICK, ROLL, ROLLD, SWAP, ROT

## UNTIL not in app ↑ top

PDF page 385 · printed page 3-265

Type

  Command

Description

  UNTIL Command: Starts the test clause in a DO … UNTIL … END indefinite loop structure. See the DO entry for more information.

Input/Output

  None

See also

  DO, END

## UPDIR in app ↑ top

PDF page 385 · printed page 3-265

Type

  Command

Description

  Up Directory Command: Makes the parent of the current directory the new current directory. UPDIR has no effect if the current directory is HOME.

Input/Output

  None

See also

  CRDIR, HOME, PATH, PGDIR

## UTPC in app ↑ top

PDF page 385 · printed page 3-265

Type

  Command

Description

  Upper Chi-Square Distribution Command: Returns the probability utpc(n, x) that a chi-square random variable is greater than x, where n is the number of degrees of freedom of the distribution. The defining equations are these:

  - For x ≥ 0:

                                                                            1        ∞ n              t

  - t --2 – 1 ⋅ e– --2 dt utpc ( n, x ) = --------------- n

                                                                        --           ∫

  2 2 Γ ( n--2 ) x

  - For x < 0: utpc ( n, x ) ) = 1

  Γ -- ---- = -- -- – 1-- !

  z | z
  --- | ---
  2 | 2
  For any value z, | , where ! is the factorial command.

  The value n is rounded to the nearest integer and, when rounded, must be positive.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  n | x | → | utpc(n,x)

See also

  UTPF, UTPN, UTPT

## UTPF in app ↑ top

PDF page 386 · printed page 3-266

Type

  Command

Description

  Upper Snedecor’s F Distribution Command: Returns the probability utpf(n1, n2, x) that a Snedecor’s F random variable is greater than x, where n1 and n2 are the numerator and denominator degrees of freedom of the F distribution. The defining equations for utpf(n1, n2, x) are these:

  - For x ≥ 0:

                                                                n 1 + n 2-                                           ( n1 + n2 )

  ----- Γ - ---------------- n1

                                                                                   ∞ n1 – 2                        – ----------------------

  - n - -----1- 2

                                                             - 2 -                      --------------      n1 -               2

  -

                                                                                   ∫x t       2
                                             - n - ------------------------------                          1 + ----- t                          dt
                                                  2               n            n                              -n -

  Γ -- ----1-- Γ -- ----2-- 2

                                                               2            2

  - For x < 0: utp f ( n 1, n 2, x ) = 1

  Γ -- ---- = -- -- – 1-- !

  z | z
  --- | ---
  2 | 2
  For any value z, | , where ! is the calculator’s factorial command.

  The values n1 and n2 are rounded to the nearest integers and, when rounded, must be positive.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  n1 | n2 | x | → | utpf(n1,n2,x)

See also

  UTPC, UTPN, UTPT

## UTPN in app ↑ top

PDF page 386 · printed page 3-266

Type

  Command

Description

  Upper Normal Distribution Command: Returns the probability utpn(m, v, x) that a normal random variable is greater than x, where m and v are the mean and variance, respectively, of the normal distribution. For all x and m, and for v > 0, the defining equation is this: 2 (t – m) ∞ – ------------------ 1 utpn ( m, v, x ) = ------------- 2v 2πv x

                                                                   ∫e                                        dt

  For v = 0, UTPN returns 0 for x ≥ m, and 1 for x < m.

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  m | v | x | → | utpn(m,v,x)

See also

  UTPC, UTPF, UTPT

## UTPT in app ↑ top

PDF page 387 · printed page 3-267

Type

  Command

Description

  Upper Student’s t Distribution Command: Returns the probability utpt(n, x) that a Student’s t random variable is greater than x, where n is the number of degrees of freedom of the distribution. The following is the defining equation for all x: n+1 Γ -- ----------- -- ∞

  n+1 | – -----------
  --- | ---
  2 | 2

  utpt ( n, x ) = ----------------------- ∫ -- 1 + --- --

                                                          2                    t

  dt n Γ -- ---- nπ

                                                     n                x

  2

  Γ -- ---- = -- -- – 1-- !

  z | z
  --- | ---
  2 | 2
  For any value z, | , where ! is the factorial command.

  The value n is rounded to the nearest integer and, when rounded, must be positive.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  n | x | → | utpt(n,x)

See also

  UTPC, UTPF, UTPN

## UVAL in app ↑ top

PDF page 387 · printed page 3-267

Type

  Function

Description

  Unit Value Function: Returns the numerical part of a unit object.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x_unit | → | x
  `symb` | → | `UVAL(symb)`

See also

  CONVERT, UBASE, UFACT, →UNIT

## V→ in app ↑ top

PDF page 387 · printed page 3-267

Type

  Command

Description

  Vector/Complex Number to Stack Command: Separates a vector or complex number into its component elements. For vectors with four or more elements, V→ executes independently of the coordinate system mode, and always returns the elements of the vector to the stack as they are stored internally (in rectangular form). Thus, V→ is equivalent to OBJ→ for vectors with four or more elements.

Flags

  Coordinate System (–15 and –16)

Input/Output

  L1/A1 |  | Ln/I1 ... L3/In–2 | L2/In–1 | L1/In
  --- | --- | --- | --- | ---
  [xy] | → | x | y |
  [ xr, ytheta ] | → | xr | ytheta |
  [ x1 , x2 , x3 ] | → | x1 | x2 | x3
  [ x1, xtheta, xz ] | → | x1 | xtheta | xz
  [ x1, xtheta, xphi ] | → | x1 | xtheta | xphi
  [ x1, x2, ..., xn ] | → | x1 ... xn–2 | xn–1 | xn
  (x, y) | → | x | y |
  (xr, ytheta) | → | xr | ytheta |
  L = Level; A = Argument; I = item
      Example 1:      With flag –16 clear (Rectangular mode), (2,3) V→ returns 2 to level 2 and 1 to level 1.
          Example 2:      With flag –15 clear and –16 set (Polar/Cylindrical mode), [ 2 7 4 ] V→ returns 2 to
  level 3, 7 to level 2, and 4 to level 1.
      Example 3:      [ 9 7 5 3 ] V→ returns 9 to level 4, 7 to level 3, 5 to level 2, and 3 to level 1,
  independent of the state of flags –15 and –16.

See also

  →V2, →V3

## →V2 in app ↑ top

PDF page 388 · printed page 3-268

Type

  Command

Description

  Stack to Vector/Complex Number Command: Converts two specified numbers into a 2-element vector or a complex number. The result returned depends on the setting of flags –16 and –19, as shown in the following table:

                                                                   Flag –19 clear             Flag –19 set

             Flag –16 clear (Rectangular mode)                       [xy]               (x, y)

             Flag –16 set (Polar mode)                              [xy]                (x,  y)

Flags

  Coordinate System (–16), Complex Mode (–19)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | [xy]
  x | y | → | [xy]
  x | y | → | (x, y)
  x | y | → | (x, y)
  Example 1: With flags –19 and –16 clear, 2 3 →V2 returns [ 2 3 ].
  Example 2: With flags –19 and –16 set (Polar/Spherical mode), 2 3 →V2 returns (2,3).

See also

  V→, →V3

## →V3 in app ↑ top

PDF page 388 · printed page 3-268

Type

  Command

Description

  Stack to 3-Element Vector Command: Converts three numbers into a 3-element vector. The result returned depends on the coordinate mode used, as shown in the following table:

  Mode | Result
  --- | ---
  Rectangular (flag –16 clear) | [ x1 x2 x3 ]
  Polar/Cylindrical (flag –15 clear and –16 set) | [ x1 xtheta xz ]
  Polar/Spherical (flag –15 and –16 set) | [ x1 xtheta xphi ]

Flags

  Coordinate System (–15 and –16)

Input/Output

  Level 3/Argument 1 | Level 2/Argument 2 | Level 1/Argument 3 |  | Level 1/Item 1
  --- | --- | --- | --- | ---
  x1 | x2 | x3 | → | [ x1 x2 x3 ]
  x1 | xtheta | xz | → | [ x1 xtheta xz ]
  x1 | xtheta | xphi | → | [ x1 xtheta xphi ]
  Example 1: With flag –16 clear (Rectangular mode), 1 2 3 →V3 returns [ 1 2 3 ].
  Example 2: With flag –15 clear and –16 set (Polar/Cylindrical mode), 1 2 3 →V3 returns
  [ 1 2 3 ].
      Example 3:       With flags –15 and –16 set (Polar/Spherical mode), 1 2 3 →V3 returns [ 1 2 3 ].

See also

  V→, →V2

## VANDERMONDE in app ↑ top

PDF page 389 · printed page 3-269

Type

  Command

Description

  Builds the Vandermonde matrix (also called the alternant matrix) from a list of objects. That is, for a list of n objects, the command creates an n × n matrix. The ith column in the matrix consists of the list items raised to the power of (i–1). Sometimes the Vandermonde matrix is defined with the ith row containing the items raised to the power of (i–1); to obtain this, transpose the result with the command TRAN.

Input

  A list of objects. A vector is allowed too.

Output

  The corresponding Vandermonde matrix.

Flags

  Exact mode must be set (flag –105 clear). Numeric mode must not be set (flag –3 clear).

Example

  Build the row version of the Vandermonde matrix from the following list of objects: {x, y, z}

      Command:        TRAN(VANDERMONDE({x,y,z}))

  1 1 1 x y z

                         2   2   2

  x y z Result:

See also

  CON, HILBERT, IDN, RANM

## VAR in app ↑ top

PDF page 389 · printed page 3-269

Type

  Command

Description

  Variance Command: Calculates the sample variance of the coordinate values in each of the m columns in the current statistics matrix (ΣDAT).

  The variance (equal to the square of the standard deviation) is returned as a vector of m real numbers, or as a single real number if m = 1. The variances are computed using this formula: n

                                         1                       2

  ----------- ⋅ ∑ ( x i – x ) n–1 i=1

  where xi is the ith coordinate value in a column, x is the mean of the data in this column, and n is the number of data points.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xvariance |
  → | [ xvariance1, ..., xvariancem ] |

See also

  MAXΣ, MEAN, MINΣ, PSDEV, PVAR, SDEV, TOT

## VARS in app ↑ top

PDF page 390 · printed page 3-270

Type

  Command

Description

  Variables Command: Returns a list of the names of all variables in the VAR menu for the current directory.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | { global1 ... globaln } |

See also

  ORDER, PVARS, TVARS

## VER not in app ↑ top

PDF page 390 · printed page 3-270

Type

  Command

Description

  Returns the Computer Algebra System version number, and date of release.

Input

  No input required.

Output

  A real number giving the version and release date of the Computer Algebra System software.

Flags

  The version and release date are given as a number of the form V.YYYYMMDD, so a display mode showing at least 8 digits after the fraction mark is needed to display the result in full.

## VERSION not in app ↑ top

PDF page 390 · printed page 3-270

Type

  Command

Description

  Software Version Command: Displays the software version and copyright message.

Input/Output

  | Level 1/Argument 1 | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  → | “version number” | “copyright message” |

## VISIT not in app ↑ top

PDF page 391 · printed page 3-271

Type

  Command

Description

  For a specified variable, opens the contents in the command-line editor.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  A variable name | → | The contents opened in the command line
  editor.

See also

  VISITB, EDIT, EDITB

## VISITB not in app ↑ top

PDF page 391 · printed page 3-271

Type

  Command

Description

  For a specified variable, opens the contents in the most suitable editor for the object type. For example, if the specified variable holds an equation, the equation is opened in Equation Writer.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  A variable name | → | The contents opened in the most suitable
  editor.

See also

  VISIT, EDIT, EDITB

## VPOTENTIAL not in app ↑ top

PDF page 391 · printed page 3-271

Type

  Command

Description

  Find a vector potential function describing a field whose curl (or “rot”) is the input. This command is the opposite of CURL. Given a vector V it attempts to return a function U such that curl U is equal to V; ∇ × U = V . For this to be possible, DIV(V) must be zero, otherwise the command reports a “Bad Argument Value” error. Step-by-step mode is available with this command.

Input

  Level 2/Argument 1: A vector V of expressions. Level 1/Argument 2: A vector of the names of the variables.

Output

  Level 1/Item 1: A vector U of the variables that is the potential from which V is obtained. An arbitrary constant can be added, the command does not do this.

Flags

  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). Step-by-step mode can be set (flag –100 set).

Example

  To see if this command is the opposite of CURL, use the output of the example in CURL as input to VPOTENTIAL. Find a vector in the spatial variables x, y, and z whose curl is: (2yz)i + (0)j + (2xy – x2)k

      Command:        VPOTENTIAL([2*Y*Z, 0, 2*X*Y-X^2], [X,Y,Z])

  EXPAND(ANS(1))

      Result:         [0, -((X^3-3*Y*X^2)/3), Z*Y^2]

  This shows that the reversal is not unique – more than one vector can have the same curl.

  However, obtaining the curl of the above result, and then applying VPOTENTIAL to it again will give the same result.

See also

  CURL, POTENTIAL

## VTYPE in app ↑ top

PDF page 392 · printed page 3-272

Type

  Command

Description

  Variable Type Command: Returns the type number of the object contained in the named variable. If the named variable does not exist, VTYPE returns –1. For a table of the objects’ type numbers, see the entry for TYPE.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → | ntype
  :nport : namebackup | → | ntype
  :nport : nlibrary | → | ntype

See also

  TYPE

## *W not in app ↑ top

PDF page 392 · printed page 3-272

Type

  Command

Description

  Multiply Width Command: Multiplies the horizontal plot scale by xfactor. *W is provided for compatibility with the HP 48. *W is the same as SCALEW; see its listing for details.

## WAIT not in app ↑ top

PDF page 392 · printed page 3-272

Type

  Command

Description

  Wait Command: Suspends program execution for specified time, or until a key is pressed. The function of WAIT depends on the argument, as follows:

  - Argument x interrupts program execution for x seconds.
  - Argument 0 suspends program execution until a valid key is pressed (see below). WAIT then returns xkey, which defines where the pressed key is on the keyboard, and resumes program execution. xkey is a three-digit number that identifies a key’s location on the keyboard. See the entry for ASN for a description of the format of xkey.
  - Argument –1 works as with argument 0, except that the currently specified menu is also displayed. !, …, ~, ~!, and ~… are not by themselves valid keys. Arguments 0 and –1 do not affect the display, so that messages persist even though the keyboard is ready for input (FREEZE is not required). Normally, the MENU command does not update the menu keys until a program halts or ends. WAIT with argument –1 enables a previous execution of MENU to display that menu while the program is suspended for a key press.
Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → |
  0 | → | xkey
  –1 | → | xkey
  Example 1: | This program: |
  « "Press [1] to add Press any other key to subtract" 1 DISP 0 WAIT IF 92.1 SAME THEN + ELSE - END » displays a prompting message and halts program execution until a key is pressed. If the 1 key (location 92.1) is pressed, two numbers on the stack are added. If any other key is pressed, two numbers on the stack are subtracted.
      Example 2:      This program:
  « { ADD { } { } { } { } SUB } MENU "Press [ADD] to add Press [SUB] to subtract" 1 DISP -1 WAIT IF 11.1 SAME THEN + ELSE - END » builds a custom menu with labels ADD and SUB and a prompting message. Executing -1 WAIT displays the custom menu (note that it’s not active) and suspends execution for keyboard input. If the ADD menu key (location 11.1) is pressed, two numbers on the stack are added. If any other key is pressed, two numbers on the stack are subtracted.

See also

  KEY

## WHILE not in app ↑ top

PDF page 393 · printed page 3-273

Type

  Command Operation

Description

  WHILE Indefinite Loop Structure Command: Starts the WHILE … REPEAT … END indefinite loop structure. WHILE … REPEAT … END repeatedly evaluates a test and executes a loop clause if the test is true. Since the test clause occurs before the loop-clause, the loop clause is never executed if the test is initially false. The syntax is this: WHILE test-clause REPEAT loop-clause END The test clause is executed and must return a test result to the stack. REPEAT takes the value from the stack. If the value is not zero, execution continues with the loop clause; otherwise, execution resumes following END.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  WHILE | → |
  REPEAT | T/F | →
  END | → |

See also

  DO, END, REPEAT

## WIREFRAME not in app ↑ top

PDF page 393 · printed page 3-273

Type

  Command

Description

  WIREFRAME Plot Type Command: Sets the plot type to WIREFRAME. When the plot type is set to WIREFRAME, the DRAW command plots a perspective view of the graph of a scalar function of two variables. WIREFRAME requires values in the reserved variables EQ, VPAR, and PPAR.

  VPAR has the following form: { xleft, xright, ynear, yfar, zlow, zhigh, xmin, xmax, ymin, ymax, xeye, yeye, zeye, xstep, ystep } For plot type WIREFRAME, the elements of VPAR are used as follows:

  - xleft and xright are real numbers that specify the width of the view space.
  - ynear and yfar are real numbers that specify the depth of the view space.
  - zlow and zhigh are real numbers that specify the height of the view space.
  - xmin and xmax are not used.
  - ymin and ymax are not used.
  - xeye, yeye, and zeye are real numbers that specify the point in space from which the graph is viewed.
  - xstep and ystep are real numbers that set the number of x-coordinates versus the number of y- coordinates plotted. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin) (xmax, ymax) indep res axes ptype depend } For plot type WIREFRAME, the elements of PPAR are used as follows:
  - (xmin, ymin) is not used.
  - (xmax, ymax) is not used.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is not used.
  - axes is not used.
  - ptype is a name specifying the plot type. Executing the command WIREFRAME places the command name WIREFRAME in ptype.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, YSLICE

## WSLOG not in app ↑ top

PDF page 394 · printed page 3-274

Type

  Command

Description

  Warmstart Log Command: Returns four strings recording the date, time, and cause of the four most recent warmstart events. Each string "logn" has the form "code–date time". The following table summarizes the legal values of code and their meanings.

  Code | Description
  --- | ---
  0 | The warmstart log was cleared.
  1 | The interrupt system detected a very low battery condition at the battery contacts

  (not the same as a low system voltage), and put the calculator in “Deep Sleep mode” (with the system clock running). When $ is pressed after the battery voltage is restored, the system warmstarts and puts a 1 in the log.

  2 | Hardware failed during transmission (timeout).
  --- | ---
  3 | Run through address 0.
  4 | System time is corrupt
  Code | Description
  5 | A Deep Sleep wakeup (for example, $, Alarm).
  6 | Not used
  7 | A 5-nibble word (CMOS test word) in RAM was corrupt. (This word is checked

  on every interrupt, but it is used only as an indicator of potentially corrupt RAM.)

  8 | Not used
  --- | ---
  9 | The alarm list is corrupt.
  A | System RPL jump to #0.
  B | The card module was removed (or card bounce).
  C | Hardware reset occurred (for example, an electrostatic discharge or user reset)
  D | An expected System (RPL) error handler was not found in runstream.

  The date and time stamp (date time) part of the log may be displayed as 00…0000 for one of three reasons:

  - The system time was corrupt when the stamp was recorded.
  - The date and time stamp itself is corrupt (bad checksum).
  - Fewer than four warmstarts have occurred since the log was last cleared.
Flags

  Date Format (–42)

Input/Output

  | Level 1/Argument 1 | Level 4/Item 1 ... Level 1/Item 4
  --- | --- | ---
  → | “log4” ... “log1” |

## ΣX in app ↑ top

PDF page 395 · printed page 3-275

Type

  Command

Description

  Sum of x-Values Command: Sums the values in the independent-variable column of the current statistical matrix (reserved variable ΣDAT). The independent-variable column is specified by XCOL and is stored as the first parameter in the reserved variable ΣPAR. The default independent-variable column number is 1.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | xsum |

See also

  NΣ, XCOL, ΣXY, ΣX2, ΣY, ΣY2

## ΣX2 in app ↑ top

PDF page 395 · printed page 3-275

Type

  Command

Description

  Sum of Squares of x-Values Command: Sums the squares of the values in the independent- variable column of the current statistical matrix (reserved variable ΣDAT). The independent-variable column is specified by XCOL and is stored as the first parameter in the reserved variable ΣPAR. The default independent-variable column number is 1.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Sum of X2 |

See also

  NΣ, ΣX, XCOL, ΣXY, ΣY, ΣY2

## ΣX^2 not in app ↑ top

PDF page 396 · printed page 3-276

Type

  Command

Description

  Sum of Squares of x-Values Command: Sums the squares of the values in the independent- variable column of the current statistical matrix. ΣX^2 is provided for compatibility with the HP 28. ΣX^2 is the same as ΣX2; see its listing for details.

## XCOL not in app ↑ top

PDF page 396 · printed page 3-276

Type

  Command

Description

  Independent Column Command: Specifies the independent-variable column of the current statistics matrix (reserved variable ΣDAT). The independent-variable column number is stored as the first parameter in the reserved variable ΣPAR. The default independent-variable column number is 1. XCOL will accept a noninteger real number and store it in ΣPAR, but subsequent commands that utilize the XCOL specification in ΣPAR will cause an error.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  ncol | → |

See also

  BARPLOT, BESTFIT, COLΣ, CORR, COV, EXPFIT, HISTPLOT, LINFIT, LOGFIT, LR, PREDX, PREDY, PWRFIT, SCATRPLOT, YCOL

## XGET not in app ↑ top

PDF page 396 · printed page 3-276

Type

  Command

Description

  XModem Get Command: Retrieves a specified filename via XMODEM from another calculator. The other calculator needs to be in server mode for the operation to work (G I/O FUNCTIONS START SERVER).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |

See also

  BAUD, RECN, RECV, SEND, XRECV, XSERV, XPUT

## XMIT not in app ↑ top

PDF page 396 · printed page 3-276

Type

  Command

Description

  Serial Transmit Command: Sends a string serially without using Kermit protocol, and returns a single digit that indicates whether the transmission was successful. XMIT is useful for communicating with non-Kermit devices such as RS-232 printers. If the transmission is successful, XMIT returns a 1. If the transmission is not successful, XMIT returns the unsent portion of the string and a 0. Use ERRM to get the error message.

  After receiving an XOFF command (with transmit pacing in the reserved variable IOPAR set), XMIT stops transmitting and waits for an XON command. XMIT resumes transmitting if an XON is received before the time-out set by STIME elapses; otherwise, XMIT terminates, returns a 0, and stores "Timeout" in ERRM.

Flags

  I/O Device (–33), I/O Device for Wire (–78)

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  “string” | → | 1 |
  “string” | → | “substringunsent” | 0

See also

  BUFLEN, SBRK, SRECV, STIME

## XNUM in app ↑ top

PDF page 397 · printed page 3-277

Type

  Command

Description

  Converts an object or a list of objects to 12-digit decimal numeric format. Similar to →NUM except that →NUM does not work with lists, nor in programs in algebraic mode.

Input

  An object or list of objects.

Output

  The objects in numeric format.

Example

  Find the 12-digit numeric values of π/2, 3e, and 4cos(2).

  Command | XNUM({π/2,3*e,4*COS(2})
  Results | {1.5707963268 8.15484548538 -1.66458734619}

See also

  I→R, →NUM

## XOR in app ↑ top

PDF page 397 · printed page 3-277

Type

  Function

Description

  Exclusive OR Function: Returns the logical exclusive OR of two arguments. When the arguments are binary integers or strings, XOR does a bit-by-bit (base 2) logical comparison:

  - Binary integer arguments are treated as sequences of bits with length equal to the current wordsize. Each bit in the result is determined by comparing the corresponding bits (bit1 and bit2) in the two arguments, as shown in the following table:

  bit1 | bit2 | bit1 XOR bit2
  --- | --- | ---
  0 | 0 | 0
  0 | 1 | 1
  1 | 0 | 1
  1 | 1 | 0

  - String arguments are treated as sequences of bits, using 8 bits per character (that is, using the binary version of the character code). The two string arguments must be the same length. When the arguments are real numbers or symbolics, XOR simply does a true/false test. The result is 1 (true) if either, but not both, arguments are nonzero; it is 0 (false) if both arguments are nonzero or zero. This test is usually done to compare two test results. If either or both of the arguments are algebraic objects, then the result is an algebraic of the form symb1 XOR symb2. Execute →NUM (or set flag –3 before executing XOR) to produce a numeric result from the algebraic result.
Flags

  Binary Integer Wordsize (–5 through –10), Binary Integer Base (–11, –12)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  #n1 | #n2 | → | #n3
  “string1” | “string2” | → | “string3”
  T/F1 | T/F2 | → | 0/1
  T/F | `symb` | → | `T/F XOR symb`
  `symb` | T/F | → | `symb XOR T/F`
  `symb1` | `symb2` | → | `symb1 XOR symb2`

See also

  AND, NOT, OR

## XPON in app ↑ top

PDF page 398 · printed page 3-278

Type

  Function

Description

  Exponent Function: Returns the exponent of the argument.

Flags

  Numerical Results (–3)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | nexpon
  `symb` | → | `XPON(symb)`
  Example 1: | 1.2E34 XPON returns 34. |
  Example 2: | 12.4E3 XPON returns 4. |
  Example 3: | `A*1E34` XPON returns `XPON(A*1E34)`. |

See also

  MANT, SIGN

## XPUT not in app ↑ top

PDF page 398 · printed page 3-278

Type

  Command

Description

  XModem Send Command: Sends a specified filename via XMODEM to a calculator. The receiving calculator needs to be in Server mode (G I/O FUNCTIONS START SERVER).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |

See also

  BAUD, RECN, RECV, SEND XRECV, XSERV, XGET

## XQ in app ↑ top

PDF page 398 · printed page 3-278

Type

  Command

Description

  Converts a number, or a list of numbers in decimal format, to quotient (rational) format. Similar to the →Qπ command, but also clears numeric constants mode (flag –2) and sets exact mode (flag –105).

Input

  A number, or a list of numbers.

Output

  The number or list of numbers in rational format. This rational number converts to the input value to the accuracy of the current display setting.

  Example 1: Express .3658 in rational format, in Std mode:
  Command | XQ(.3658)
  Results | 1829/5000
  Example 2: Express .3658 in rational format, in Fix 4 mode:
  Command | XQ(.3658)
  Results | √(19/142)
  Example 3: Express 1.04719755120 in rational format, in Eng 11 mode:
  Command | XQ(1.04719755120)
  Results | 1/3*π

See also

  →Q, →Qπ

## XRECV not in app ↑ top

PDF page 399 · printed page 3-279

Type

  Command

Description

  XModem Receive Command: Prepares the calculator to receive an object via XModem. The received object is stored in the given variable name. The transfer will start more quickly if you start the XModem sender before executing XRECV. Invalid object names cause an error. If flag –36 is clear, object names that are already in use also cause an error. If you are transferring data between two calculators, executing {AAA BBB CCC} XRECV receives AAA, BBB, and CCC. You also need to use a list on the sending end ({AAA BBB CCC} XSEND, for example).

Flags

  I/O Device (–33), RECV Overwrite (–36), I/O Device for Wire (–78)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |

See also

  BAUD, RECV, RECN, SEND, XSEND

## XRNG not in app ↑ top

PDF page 399 · printed page 3-279

Type

  Command

Description

  x-Axis Display Range Command: Specifies the x-axis display range. The x-axis display range is stored in the reserved variable PPAR as xmin and xmax in the complex numbers (xmin, ymin) and (xmax, ymax). These complex numbers are the first two elements of PPAR and specify the coordinates of the lower left and upper right corners of the display ranges. The default values of xmin and xmax are –6.5 and 6.5, respectively.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xmin | xmax | → |

See also

  AUTO, PDIM, PMAX, PMIN, YRNG

## XROOT in app ↑ top

PDF page 399 · printed page 3-279

Type

  Analytic function

Description

  xth Root of y Command: Computes the xth root of a real number. XROOT is equivalent to y1/x, but with greater accuracy. If y < 0, x must be an integer.

Flags

  Numerical Results (–3)

  Input/Output (RPN):

                                        Level 2               Level 1                           Level 1

                                               y                        x      →                        x y

                                            `symb1`               `symb2`      →           `XROOT(symb2,symb1)`
                                            `symb`                      x      →              `XROOT(x,symb)`
                                               y                  `symb`       →              `XROOT(symb,y)`
                                            y_unit                      x      →                  x y

  _unit1/x

                                        y_unit                `symb`       →           `XROOT(symb,y_unit)`

  Input/Output (ALG):

                                      Argument 1            Argument 2                          Level 1

  y x

                                           y                        x      →
                                            `symb1`               `symb2`      →           `XROOT(symb1,symb2)`
                                            `symb`                      x      →              `XROOT(symb,x)`
                                               y                  `symb`       →              `XROOT(y,symb)`
                                               x                   y_unit      →                  x y

  _unit1/x

                                        `symb`                 y_unit      →           `XROOT(symb,y_unit)`

## XSEND not in app ↑ top

PDF page 400 · printed page 3-280

Type

  Command

Description

  XModem Send Command: Sends a copy of the named object via XModem. A receiving calculator must execute XRECV to receive an object via XModem. The transfer occurs more quickly if you start the receiving XModem after executing XSEND. Also, configuring the receiving modem not to do CRC checksums (if possible) will avoid a 30 to 60-second delay when starting the transfer. If you are transferring data between two calculators, executing {AAA BBB CCC} XSEND sends AAA, BBB, and CCC. You also need to use a list on the receiving end ({AAA BBB CCC} XRECV, for example).

Flags

  I/O Device (–33), I/O Device for Wire (–78)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `name` | → |

See also

  BAUD, RECN, RECV, SEND XRECV

## XSERV not in app ↑ top

PDF page 400 · printed page 3-280

Type

  Command

Description

  XModem Server Command: Puts the calculator in XModem server mode. When in server mode, the following commands are available: P: Put a file in the calculator G: Get a file from the calculator E: Execute a command line

  M Get the calculator memory L: List the files in the current directory

See also

  BAUD, RECN, RECV, SEND XRECV, XGET, XPUT

## XVOL not in app ↑ top

PDF page 401 · printed page 3-281

Type

  Command

Description

  X Volume Coordinates Command: Sets the width of the view volume in the reserved variable VPAR. xleft and xright set the x-coordinates for the view volume used in 3D plots. These values are stored in the reserved variable VPAR.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xleft | xright | → |

See also

  EYEPT, XXRNG, YVOL, YYRNG, ZVOL

## XXRNG not in app ↑ top

PDF page 401 · printed page 3-281

Type

  Command

Description

  X Range of an Input Plane (Domain) Command: Specifies the x range of an input plane (domain) for GRIDMAP and PARSURFACE plots. xmin and xmax are real numbers that set the x-coordinates for the input plane. These values are stored in the reserved variable VPAR.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xmin | xmax | → |

See also

  EYEPT, NUMX, NUMY, XVOL, YVOL, YYRNG, ZVOL

## ΣXY in app ↑ top

PDF page 401 · printed page 3-281

Type

  Command

Description

  Sum of X times Y command: Sums the products of each of the corresponding values in the independent- and dependent-variable columns of the current statistical matrix (reserved variable ΣDAT). The independent column is the column designated as XCOL and the dependent column is the column designated as YCOL.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Sum of X*Y |

See also

  NΣ, ΣX, XCOL, ΣXY, ΣX2, YCOL, ΣY2

## ΣX*Y not in app ↑ top

PDF page 401 · printed page 3-281

Type

  Command

Description

  Sum of X times Y command: Sums the products of each of the corresponding values in the independent- and dependent-variable columns of the current statistical matrix. ΣX*Y is provided for compatibility with the HP 28. ΣX*Y is the same as ΣXY; see its listing for details.

## ΣY in app ↑ top

PDF page 402 · printed page 3-282

Type

  Command

Description

  Sum of y-Values Command: Sums the values in the dependent variable column of the current statistical matrix (reserved variable ΣDAT). The dependent variable column is specified by YCOL, and is stored as the second parameter in the reserved variable ΣPAR. The default dependent variable column number is 2.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Sum of Y |

See also

  NΣ, ΣX, XCOL, ΣXY, ΣX2, YCOL, ΣY2

## ΣY2 in app ↑ top

PDF page 402 · printed page 3-282

Type

  Command

Description

  Sum of Squares of y-Values Command: Sums the squares of the values in the dependent-variable columns of the current statistical matrix (reserved variable ΣDAT). The dependent column is the column designated as YCOL

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | Sum of Y2 |

See also

  NΣ, ΣX, XCOL, ΣXY, ΣX2, YCOL

## ΣY^2 not in app ↑ top

PDF page 402 · printed page 3-282

Type

  Command

Description

  Sum of Squares of y-Values Command: Sums the squares of the values in the dependent-variable columns of the current statistical matrix. ΣY^2 is provided for compatibility with the HP 28. ΣY^2 is the same as ΣY2; see its listing for details.

## YCOL not in app ↑ top

PDF page 402 · printed page 3-282

Type

  Command

Description

  Dependent Column Command: Specifies the dependent variable column of the current statistics matrix (reserved variable ΣDAT). The dependent variable column number is stored as the second parameter in the reserved variable ΣPAR. The default dependent variable column number is 2. YCOL will accept a noninteger real number and store it in ΣPAR, but subsequent commands that utilize the YCOL specification in ΣPAR will cause an error.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  ncol | → |

See also

  BARPLOT, BESTFIT, COLΣ, CORR, COV, EXPFIT, HISTPLOT, LINFIT, LOGFIT, LR, PREDX, PREDY, PWRFIT, SCATRPLOT, XCOL

## YRNG not in app ↑ top

PDF page 403 · printed page 3-283

Type

  Command

Description

  y-Axis Display Range Command: Specifies the y-axis display range. The y-axis display range is stored in the reserved variable PPAR as ymin and ymax in the complex numbers (xmin, ymin) and (xmax, ymax). These complex numbers are the first two elements of PPAR and specify the coordinates of the lower left and upper right corners of the display ranges. The default values of ymin and ymax are –3.1 and 3.2, respectively for the HP 48gII and -3.9 and 4.0, respectively for the HP 50g and 49g+.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  ymin | ymax | → |

See also

  AUTO, PDIM, PMAX, PMIN, XRNG

## YSLICE not in app ↑ top

PDF page 403 · printed page 3-283

Type

  Command

Description

  Y-Slice Plot Command: Sets the plot type to YSLICE. When plot type is set YSLICE, the DRAW command plots a slicing view of a scalar function of two variables. YSLICE requires values in the reserved variables EQ, VPAR, and PPAR. VPAR has the following form: { xleft, xright, ynear, yfar, zlow, zhigh, xmin, xmax, ymin, ymax, xeye, yeye, zeye, xstep, ystep } For plot type YSLICE, the elements of VPAR are used as follows:

  - xleft and xright are real numbers that specify the width of the view space.
  - ynear and yfar are real numbers that specify the depth of the view space.
  - zlow and zhigh are real numbers that specify the height of the view space.
  - xmin and xmax are not used.
  - ymin and ymax are not used.
  - xeye, yeye, and zeye are real numbers that specify the point in space from which the graph is viewed.
  - xstep determines the interval between plotted x-values within each “slice”.
  - ystep determines the number of slices to draw. The plotting parameters are specified in the reserved variable PPAR, which has this form: { (xmin, ymin), (xmax, ymax), indep, res, axes, ptype, depend } For plot type YSLICE, the elements of PPAR are used as follows:
  - (xmin, ymin) is not used.
  - (xmax, ymax) is not used.
  - indep is a name specifying the independent variable. The default value of indep is X.
  - res is a real number specifying the interval, in user-unit coordinates, between plotted values of the independent variable; or a binary integer specifying the interval in pixels. The default value is 0, which specifies an interval of 1 pixel.
  - axes is not used.
  - ptype is a command name specifying the plot type. Executing the command YSLICE places YSLICE in ptype.
  - depend is a name specifying the dependent variable. The default value is Y.
Input/Output

  None

See also

  BAR, CONIC, DIFFEQ, FUNCTION, GRIDMAP, HISTOGRAM, PARAMETRIC, PARSURFACE, PCONTOUR, POLAR, SCATTER, SLOPEFIELD, TRUTH, WIREFRAME

## YVOL not in app ↑ top

PDF page 404 · printed page 3-284

Type

  Command

Description

  Y Volume Coordinates Command: Sets the depth of the view volume in the reserved variable VPAR. The variables ynear and yfar are real numbers that set the y-coordinates for the view volume used in 3D plots. ynear must be less than yfar. These values are stored in the reserved variable VPAR.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  ynear | yfar | → |

See also

  EYEPT, XVOL, XXRNG, YYRNG, ZVOL

## YYRNG not in app ↑ top

PDF page 404 · printed page 3-284

Type

  Command

Description

  Y Range of an Input Plane (Domain) Command: Specifies the y range of an input plane (domain) for GRIDMAP and PARSURFACE plots. The variables yy near and yy far are real numbers that set the y-coordinates for the input plane. These values are stored in the reserved variable VPAR.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  ynear | yfar | → |

See also

  EYEPT, XVOL, XXRNG, YVOL, ZVOL

## ZEROS not in app ↑ top

PDF page 404 · printed page 3-284

Type

  Command

Description

  Returns the zeros of a function of one variable, without multiplicity.

Input

  Level 2/Argument 1: An expression. Level 1/Argument 2: The variable to solve for.

Output

  The solution, or a list of solutions, for the expression equated to 0.

Flags

  Radians mode must be set (flag –17 set). For a symbolic result, clear the CAS modes Numeric option (flag –3 clear). The following flag settings affect the result:

  - If Exact mode is set (flag –105 is clear), attempts to find exact solutions only. This may return a null list, even if approximate solutions exist.
  - If Approximate mode is set (flag –105 set), finds numeric roots.
  - If Complex mode is set (flag –103 set), searches for real and complex roots.
Example

  Find the roots of the following equation in x, without specifying that x=2 is a root twice. x3 – x2 – 8x + 12 = 0:

      Command:        ZEROS(X^3-X^2-8*X+12)

Results

  {-3, 2}

## ZFACTOR not in app ↑ top

PDF page 405 · printed page 3-285

Type

  Function

Description

  Gas Compressibility Z Factor Function: Calculates the gas compressibility correction factor for non-ideal behavior of a hydrocarbon gas. xTr is the reduced temperature: the ratio of the actual temperature (T) to the pseudocritical temperature (Tc). (Calculate the ratio using absolute temperatures.) xTr must be between 1.05 and 3.0. yPr is the reduced pressure: the ratio of the actual pressure (P) to the pseudocritical pressure (Pc). yPr must be between 0 and 30. xTr and yPr must be real numbers or unit objects that reduce to dimensionless numbers.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xTr | yPr | → | xZfactor
  xTr | `symb` | → | `ZFACTOR(xTr,symb)`
  `symb` | yPr | → | `ZFACTOR(symb,yPr)`
  `symb1` | `symb2` | → | `ZFACTOR(symb1,symb2)`

## ZVOL not in app ↑ top

PDF page 405 · printed page 3-285

Type

  Command

Description

  Z Volume Coordinates Command: Sets the height of the view volume in the reserved variable VPAR. xlow and xhigh are real numbers that set the z-coordinates for the view volume used in 3D plots. These values are stored in the reserved variable VPAR.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  xlow | xhigh | → |

See also

  EYEPT, XVOL, XXRNG, YVOL, YYRNG

## ^(Power) in app ↑ top

PDF page 405 · printed page 3-285

Type

  Function

Description

  Power Analytic Function: Returns the value of the level 2 object raised to the power of the level 1 object. This can also apply to a square matrix raised to a whole-number power. If either argument is complex, the result is complex. The branch cuts and inverse relations for wz are determined by this relationship: wz = exp(z(ln w))

Flags

  Principal Solution (–1), Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  w | z | → | wz
  z | `symb` | → | `z^(symb)`
  `symb` | z | → | `(symb)^z`
  `symb1` | `symb2` | → | `symb1^(`symb2)`
  x_unit | y | → | xy_unity
  x_unit | `symb` | → | `(x_unit)^(symb)`

See also

  EXP, ISOL, LN, XROOT

## |(Where) not in app ↑ top

PDF page 406 · printed page 3-286

Type

  Function

Description

  Where Function: Substitutes values for names in an expression. | is used primarily in algebraic objects, where its syntax is: `symbold | (name1 = symb1, name2 = symb2 …)` It enables algebraics to include variable-like substitution information about names. Symbolic functions that delay name evaluation (such as ∫ and ∂) can then extract substitution information from local variables and include that information in the expression, avoiding the problem that would occur if the local variables no longer existed when the local names were finally evaluated.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  `symbold` | { name1, `symb1`, name2, `symb2` … } | → | `symbnew`
  x | { name1, `symb1`, name2, `symb2` … } | → | x
  (x,y) | { name1, `symb1`, name2, `symb2` … } | → | (x,y)

See also

  APPLY, QUOTE

## ∫(Integrate) in app ↑ top

PDF page 408 · printed page 3-288

Type

  Function

Description

  Integral Function: Integrates an integrand from lower limit to upper limit with respect to a specified variable of integration. The algebraic syntax for ∫ parallels its stack syntax: ∫ (lower limit, upper limit, integrand, name) where lower limit, upper limit, and integrand can be real or complex numbers, unit objects, names, or algebraic expressions. Evaluating ∫ in Symbolic Results mode (flag –3 clear) returns a symbolic result. Some functions that the calculator can integrate include the following:

  - All built-in functions whose antiderivatives can be expressed in terms of other built-in functions — for example, SIN can be integrated since its antiderivative, COS, is a built-in function. The arguments for these functions must be linear.
  - Sums, differences, and negations of built-in functions whose antiderivatives can be expressed in terms of other built-in functions — for example, `SIN(X)–COS(X)`.
  - Derivatives of all built-in functions — for example, `INV(1+X^2)` can be integrated because it is the derivative of the built-in function ATAN.
  - Polynomials whose base term is linear — for example, `X^3+X^2–2*X+6` can be integrated since X is a linear term. `(X^2–6)^3+(X^2–6)^2` cannot be integrated since X^2–6 is not linear.
  - Selected patterns composed of functions whose antiderivatives can be expressed in terms of other built-in functions — for example, `1/(COS(X)*SIN(X))` returns `LN(TAN(X))`. If the result of the integration is an expression with no integral sign in the result, the symbolic integration was successful. If, however, the result still contains an integral sign, try rearranging the expression and evaluating again, or estimate the answer using numerical integration. Evaluating ∫ in Numerical Results mode (flag –3 set) returns a numerical approximation, and stores the error of integration in variable IERR. ∫ consults the number format setting to determine how accurately to compute the result.
Flags

  Numerical Result (–3), Number Format (–45 to –50)

Input/Output

  L4/A1 | L3/A2 | L2/A3 | L1/A4 |  | L1/I1
  --- | --- | --- | --- | --- | ---
  lower limit | upper limit | integrand | `name` | → | `symbintegral`
  L = Level; A = Argument; I = Item

Example

      In Symbolic Results mode (flag –3 clear) this command sequence: 1 2 `10*X` `X` „ returns 15. In Numeric Results mode (flag –3 set) the above command sequence returns the numeric approximation 15.. In addition, the variable IERR is created, and contains the error of integration .00000000015.

See also

  TAYLR, ∂, Σ

## ?(Undefined) not in app ↑ top

PDF page 408 · printed page 3-288

Type

  Function

Description

  The “undefined” symbol. Used to signify a numeric result that is not defined by the rules of arithmetic, such as the result of dividing zero by zero, or infinity by infinity. Mathematical operations on ? return ? as a result. Can be used in programs to check for an earlier undefined operation. This use of ? is unrelated to the use of ? as a spare unit in the units system. The unit ? can be used to create new units based on it, units that can not be expressed in terms of other base units. For

  example you could define $=1_? Then other currencies could be defined as multiples or fractions of 1_? The calculator has symbols for Yen, Pounds and Euros; other currencies could be defined using their names. The unit conversion system would then check conversions between them for consistency because ? is recognized as a base unit.

## ∞(Infinity) not in app ↑ top

PDF page 409 · printed page 3-289

Type

  Function

Description

  Infinity: used to signify a numeric result that is infinite by the rules of arithmetic, such as the result of dividing a non-zero number by zero. The calculator recognizes two kinds of infinity: signed and unsigned. Evaluating `1/0` gives an unsigned infinity `∞`. Selecting infinity from the keyboard, from the CHARS table, or from the catalog …µ returns `+∞` and the sign can be changed. Calculations with the unsigned infinity return unsigned infinity or ? as their result. Calculations with the signed infinity can return ordinary numeric results, as in the example. Positive infinity and unsigned infinity are equal if tested with ==, but are not identical if tested with SAME.

Flags

  Exact mode must be set (flag –105 clear), and numeric mode must not be set (flag –3 clear) for mathematical operations to give ∞ as a result, and for executing ∞ from the keyboard or catalog to give +∞ and not an error.

Example

  Find the arc tangent of minus infinity. Assume that radians mode is set.

  Command | ATAN(-∞)
  Results | -(π/2) Σ (Summation)

Type

  Function

Description

  Summation Function: Calculates the value of a finite series. The summand argument smnd can be a real number, a complex number, a unit object, a local or global name, or an algebraic object. The algebraic syntax for Σ differs from the stack syntax. The algebraic syntax is: `Σ(index=initial,final,summand)`

Flags

  Symbolic Constants (–2), Numerical Results (–3)

Input/Output

  L4/A1 | L3/A2 | L2/A3 | L1/A4 |  | L1/I1
  --- | --- | --- | --- | --- | ---
  `indx` | xinit | xfinal | smnd | → | xsum
  `indx` | `init` | xfinal | smnd | → | `Σ(indx = init, xfinal, smnd)`
  `indx` | xinit | `final` | smnd | → | `Σ(indx = xinit, final, smnd)`
  `indx` | `init` | `final` | smnd | → | `Σ(indx = init, final, smnd)`
  L = Level; A = Argument; I = Item

Example

      The command sequence `N` 1 5 `A^N` Σ returns `(EXP(6*LN(A))-A)/(A-1)`.

See also

  TAYLR, ∫, ∂

## Σ+(Sigma Plus) not in app ↑ top

PDF page 409 · printed page 3-289

Type

  Command

Description

  Sigma Plus Command: Adds one or more data points to the current statistics matrix (reserved variable ΣDAT). For a statistics matrix with m columns, arguments for Σ+ can be entered several ways:

  - To enter one data point with a single coordinate value, the argument for Σ+ must be a real number.
  - To enter one data point with multiple coordinate values, the argument for Σ+ must be a vector with m real coordinate values.
  - To enter several data points, the argument for Σ+ must be a matrix of n rows of m real coordinate values. In each case, the coordinate values of the data point(s) are added as new rows to the current statistics matrix (reserved variable ΣDAT). If ΣDAT does not exist, Σ+ creates an n x m matrix and stores the matrix in ΣDAT. If ΣDAT does exist, an error occurs if it does not contain a real matrix, or if the number of coordinate values in each data point entered with Σ+ does not match the number of columns in the current statistics matrix. Once ΣDAT exists, individual data points of m coordinates can be entered as m separate real numbers or an m-element vector. LASTARG returns the m-element vector in either case.
Input/Output

  Lm/A1 … L2/Am–1 |  | L1/Am | L1/I1
  --- | --- | --- | ---
  x | → |  |
  [ x1, x2, …, xm ] | → |  |
  [[ x1 1, …, x1 m ] [ xn 1, … ,xn m ]] | → |  |
  x1 … xm–1 | xm | → |
  L = Level; A = Argument; I = Item

Example

  The sequence CLΣ [ 2 3 4 ] Σ+ 3 1 7 Σ+ creates the matrix [[ 2 3 4 ][ 3 1 7 ]] in ΣDAT.

See also

  CLΣ, RCLΣ, STOΣ, Σ–

## Σ–(Sigma Minus) not in app ↑ top

PDF page 410 · printed page 3-290

Type

  Command

Description

  Sigma Minus Command: Returns a vector of m real numbers (or one number x if m = 1) corresponding to the coordinate values of the last data point entered by Σ+ into the current statistics matrix (reserved variable ΣDAT). The last row of the statistics matrix is deleted. The vector returned by Σ– can be edited or replaced, then restored to the statistics matrix by Σ+.

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | x |
  → | [ x1 x2 … xm ] |

See also

  CLΣ, RCLΣ, STOΣ, Σ+

## π(Pi) not in app ↑ top

PDF page 410 · printed page 3-290

Type

  Function

Description

  π Function: Returns the symbolic constant ` π ` or its numerical representation, 3.14159265359. The number returned for π is the closest approximation of the constant π to 12-digit accuracy. In Radians mode with flag –2 and –3 clear (to return symbolic results), trigonometric functions of π and π/2 are automatically simplified. For example, evaluating `SIN(π)` returns zero. However, if

  flag –2 or flag –3 is set (to return numerical results), then evaluating `SIN(π)` returns the numerical approximation –2.06761537357E–13.

Flags

  Symbolic Constants (–2), Numerical Results (–3)

Input/Output

  | Level 1/Argument 1 | Level 1/Item 1
  --- | --- | ---
  → | `π` |
  → | 3.14159265359… |

See also

  e, i, MAXR, MINR, →Qπ

## ∂(Derivative) not in app ↑ top

PDF page 411 · printed page 3-291

Type

  Function

Description

  Derivative Function: Takes the derivative of an expression, number, or unit object with respect to a specified variable of differentiation. When executed in stack syntax, ∂ executes a complete differentiation: the expression `symb1` is evaluated repeatedly until it contains no derivatives. As part of this process, if the variable of differentiation name has a value, the final form of the expression substitutes that value substituted for all occurrences of the variable. The algebraic syntax for ∂ is `∂name(symb1`). When executed in algebraic syntax, ∂ executes a stepwise differentiation of symb1, invoking the chain rule of differentiation — the result of one evaluation of the expression is the derivative of the argument expression symb1, multiplied by a new subexpression representing the derivative of symb1’s argument. If ∂ is applied to a function for which the calculator does not provide a derivative, ∂ returns a new function whose name is der followed by the original function name.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  `symb1` | `name` | → | `symb2`
  z | `name` | → | 0
  x_unit | `name` | → | 0

Example

      In Radians mode, the command sequence `ˆX(SIN(Y))` EVAL returns 0. When Y has the value `X^2`, the command sequence `SIN(Y)` `X` ˆ returns `COS(X^2)*(2*X)`. The differentiation has been executed in stack syntax, so that all of the steps of differentiation have been carried out in a single operation.

See also

  TAYLOR, ∫, Σ

## !(Factorial) in app ↑ top

PDF page 411 · printed page 3-291

Type

  Function

Description

  Factorial (Gamma) Function: Returns the factorial n! of a positive integer argument n, or the gamma function Γ(x+1) of a non-integer argument x. For x ≥ 253.1190554375 or n < 0, ! causes an overflow exception (if flag –21 is set, the exception is treated as an error). For non-integer x ≤ –254.1082426465, ! causes an underflow exception (if flag –20 is set, the exception is treated as an error). In algebraic syntax, ! follows its argument. Thus the algebraic syntax for the factorial of 7 is 7!. For non-integer arguments x, x! = Γ(x + 1), defined for x > –1 as:

  ∞ –t x Γ ( x + 1 ) = ∫ e t dt 0

  and defined for other values of x by analytic continuation: Γ(x + 1) = n Γ(x)

Flags

  Numerical Results (–3), Underflow Exception (–20), Overflow Exception (–21)

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  n | → | n!
  x | → | Γ(x + 1)
  `symb` | → | `(symb!)`

See also

  COMB, PERM

## %(Percent) in app ↑ top

PDF page 412 · printed page 3-292

Type

  Function

Description

  Percent Function: Returns x percent of y. Common usage is ambiguous about some units of temperature. When °C or °F represents a thermometer reading, then the temperature is a unit with an additive constant: 0 °C=273.15 K, and 0 °F=459.67 °R. But when °C or °F represents a difference in thermometer readings, then the temperature is a unit with no additive constant: 1 °C=1 K and 1 °F=1 °R. The arithmetic operators +, –, %, %CH, and %T treat temperatures as differences, without any additive constant. However, +, –, %CH, and %T require both arguments to be either absolute (K and °R), both °C, or both °F. No other combinations are allowed. For more information on using temperature units with arithmetic functions, see the entry for +.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | xy/100
  x | `symb` | → | `%(x,symb)`
  `symb` | x | → | `%(symb,x)`
  `symb1` | `symb2` | → | `%(symb1, symb2)`
  x | y_unit | → | (xy/100)_unit
  x_unit | y | → | (xy/100)_unit
  `symb` | x_unit | → | `%(symb,x_unit)`
  x_unit | `symb` | → | `%(x_unit,symb)`
  Example 1: 23.7 995 % returns 235.815.
  Example 2: 15 176_kg % returns 26.4_kg.
  Example 3: 100_°C 50 % returns 50_°C.

See also

  +, %CH, %T

## _(Unit attachment) not in app ↑ top

PDF page 412 · printed page 3-292

Type

  Unit attachment

Description

  Unit attachment symbol: Attaches a unit type to a numeric value.

  The calculator handles units by attaching the unit to a numeric value using the underscore symbol. For example, the value of 3 kilometers is shown as 3_km, and is created by entering 3 and then the underscore character, followed by attaching the kilometer unit.

Input

  Numeric value

Output

  Numeric value ready for a unit attachment

## « »(Program delimiters) not in app ↑ top

PDF page 413 · printed page 3-293

Type

  Object

Description

  Program delimiter object: Enters a pair of program delimiter objects. A program is a set of instructions enclosed by an open program object delimiter and a close program object delimiter. These can be nested to have a program procedure enclosed within an outer program object.

Input

  None

Output

  A pair of program delimiters

## <(Less than) in app ↑ top

PDF page 413 · printed page 3-293

Type

  Function

Description

  Less Than Function: Tests whether one object is less than another object. The function < returns a true test result (1) if the first argument is less than the second argument, or a false test result (0) otherwise. If one object is a symbolic (an algebraic or a name), and the other is a number or symbolic or unit object, < returns a symbolic comparison expression that can be evaluated to return a test result. For real numbers and binary integers, “less than” means numerically smaller (1 is less than 2). For real numbers, “less than” also means more negative (–2 is less than –1). For strings, “less than” means alphabetically previous (“ABC” is less than “DEF”; “AAA” is less than “AAB”; “A” is less than “AA”). In general, characters are ordered according to their character codes. This means, for example, that “B” is less than “a”, since “B” is character code 66, and “a” is character code 97. For unit objects, the two objects must be dimensionally consistent, and are converted to common units for comparison. If you use simple temperature units, the calculator assumes the values represent temperatures and not differences in temperatures. For compound temperature units, the calculator assumes temperature units represent temperature differences. For more information on using temperature units with arithmetic functions, refer to the entry for +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | 0/1
  #n1 | #n2 | → | 0/1
  “string1” | “string2” | → | 0/1
  x | `symb` | → | `x < symb`
  `symb` | x | → | `symb < x`
  `symb1` | `symb2` | → | `symb1 < symb2`
  x_unit1 | y_unit2 | → | 0/1
  x_unit | `symb` | → | `x_unit < symb`
  `symb` | x_unit | → | `symb < x_unit`

See also

  ≤, >, ≥, ==, ≠

## ≤(Less than or Equal) in app ↑ top

PDF page 414 · printed page 3-294

Type

  Function

Description

  Less Than or Equal Function: Tests whether one object is less than or equal to another object. The function ≤ returns a true test result (1) if the first argument is less than or equal to the second argument, or a false test result (0) otherwise. If one object is a symbolic (an algebraic or a name), and the other is a number or symbolic or unit object, ≤ returns a symbolic comparison expression that can be evaluated to return a test result. For real numbers and binary integers, “less than or equal” means numerically equal or smaller (1 is less than 2). For real numbers, “less than or equal” also means equally or more negative (–2 is less than –1). For strings, “less than or equal” means alphabetically equal or previous (“ABC” is less than or equal to “DEF”; “AAA” is less than or equal to “AAB”; “A” is less than or equal to “AA”). In general, characters are ordered according to their character codes. This means, for example, that “B” is less than “a”, since “B” is character code 66, and “a” is character code 97. For unit objects, the two objects must be dimensionally consistent and are converted to common units for comparison. If you use simple temperature units, the calculator assumes the values represent temperature and not differences in temperatures. For compound temperature units, the calculator assumes temperature units represent temperature differences. For more information on using temperature units with arithmetic functions, refer to the entry for +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | 0/1
  #n1 | #n2 | → | 0/1
  “string1” | “string2” | → | 0/1
  x | `symb` | → | `x ≤symb`
  `symb` | x | → | `symb ≤x`
  `symb1` | `symb2` | → | `symb1 ≤symb2`
  x_unit1 | y_unit2 | → | 0/1
  x_unit | `symb` | → | `x_unit ≤symb`
  `symb` | x_unit | → | `symb ≤x_unit`

See also

  <, >, ≥, ==, ≠

## >(Greater than) in app ↑ top

PDF page 415 · printed page 3-295

Type

  Function

Description

  Greater Than Function: Tests whether one object is greater than another object. The function > returns a true test result (1) if the first argument is greater than the second argument, or a false test result (0) otherwise. If one object is a symbolic (an algebraic or a name), and the other is a number or symbolic or unit object, > returns a symbolic comparison expression that can be evaluated to return a test result. For real numbers and binary integers, “greater than” means numerically greater (2 is greater than 1). For real numbers, “greater than” also means less negative (–1 is greater than –2). For strings, “greater than” means alphabetically subsequent (“DEF” is greater than “ABC”; “AAB” is greater than “AAA”; “AA” is greater than “A”). In general, characters are ordered according to their character codes. This means, for example, that “a” is greater than “B”, since “B” is character code 66, and “a” is character code 97. For unit objects, the two objects must be dimensionally consistent and are converted to common units for comparison. If you use simple temperature units, the calculator assumes the values represent temperatures and not differences in temperatures. For compound temperature units, the calculator assumes temperature units represent temperature differences. For more information on using temperature units with arithmetic functions, refer to the entry for +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | 0/1
  #n1 | #n2 | → | 0/1
  “string1” | “string2” | → | 0/1
  x | `symb` | → | `x > symb`
  `symb` | x | → | `symb > x`
  `symb1` | `symb2` | → | `symb1 > symb2`
  x_unit1 | y_unit2 | → | 0/1
  x_unit | `symb` | → | `x_unit > symb`
  `symb` | x_unit | → | `symb > x_unit`

See also

  <, ≤, ≥, ==, ≠

## ≥(Greater than or Equal) in app ↑ top

PDF page 415 · printed page 3-295

Type

  Function

Description

  Greater Than or Equal Function: Tests whether one object is greater than or equal to another object. The function ≥ returns a true test result (1) if the first argument is greater than or equal to the second argument, or a false test result (0) otherwise. If one object is a symbolic (an algebraic or a name), and the other is a number or symbolic or unit object, ≥ returns a symbolic comparison expression that can be evaluated to return a test result. For real numbers and binary integers, “greater than or equal to” means numerically equal or greater (2 is greater than or equal to 1). For real numbers, “greater than or equal to” also means equally or less negative (–1 is greater than or equal to –2). For strings, “greater than or equal to” means alphabetically equal or subsequent (“DEF” is greater than or equal to “ABC”; “AAB” is greater than or equal to “AAA”; “AA” is greater than or equal to “A”). In general, characters are ordered according to their character codes. This means, for

  example, that “a” is greater than or equal to “B”, since “B” is character code 66, and “a” is character code 97. For unit objects, the two objects must be dimensionally consistent and are converted to common units for comparison. If you use simple temperature units, the calculator assumes the values represent temperatures and not differences in temperatures. For compound temperature units, the calculator assumes temperature units represent temperature differences. For more information on using temperature units with arithmetic functions, refer to the entry for +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  x | y | → | 0/1
  #n1 | #n2 | → | 0/1
  “string1” | “string2” | → | 0/1
  x | `symb` | → | `x ≥ symb`
  `symb` | x | → | `symb ≥ x`
  `symb1` | `symb2` | → | `symb1 ≥ symb2`
  x_unit1 | y_unit2 | → | 0/1
  x_unit | `symb` | → | `x_unit ≥ symb`
  `symb` | x_unit | → | `symb ≥ x_unit`

See also

  <, ≤, >, ==, ≠

## ≠(Not equal) in app ↑ top

PDF page 416 · printed page 3-296

Type

  Function

Description

  Not Equal Function: Tests if two objects are not equal. The function ≠ returns a true result (1) if the two objects have different values, or a false result (0) otherwise. (Lists and programs are considered to have the same values if the objects they contain are identical.) If one object is algebraic or a name, and the other is a number, a name, or algebraic, ≠ returns a symbolic comparison expression that can be evaluated to return a test result. If the imaginary part of a complex number is 0, it is ignored when the complex number is compared to a real number, so, for example, 6 and (6,0) and considered to be equal. For unit objects, the two objects must be dimensionally consistent and are converted to common units for comparison. If you use simple temperature units, the calculator assumes the values represent temperatures and not differences in temperatures. For compound temperature units, the calculator assumes temperature units represent temperature differences. For more information on using temperature units with arithmetic functions, refer to the entry for +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj1 | obj2 | → | 0/1
  (x,0) | x | → | 0/1
  x | (x,0) | → | 0/1
  z | `symb` | → | `z ≠ symb`
  `symb` | z | → | `symb ≠ z`
  `symb1` | `symb2` | → | `symb1 ≠symb2`

See also

  SAME, TYPE, <, ≤, >,≥, ==, =

## *(Multiply) in app ↑ top

PDF page 417 · printed page 3-297

Type

  Function

Description

  Multiply Analytic Function: Returns the product of the arguments. The product of a real number a and a complex number (x, y) is the complex number (xa, ya). The product of two complex numbers (x1, y1) and (x2, y2) is the complex number (x1 x2 – y1 y2, x1 y2 + x2 y1). The product of a real array and a complex array or number is a complex array. Each element x of the real array is treated as a complex element (x, 0). Multiplying a matrix by an array returns a matrix product. The matrix must have the same number of columns as the array has rows (or elements, if it is a vector). Although a vector is entered and displayed as a row of numbers, the calculator treats a vector as an n × 1 matrix when multiplying matrices or computing matrix norms. Multiplying a binary integer by a real number returns a binary integer that is the product of the two arguments, truncated to the current wordsize. (The real number is converted to a binary integer before the multiplication.) The product of two binary integers is truncated to the current binary integer wordsize. When multiplying two unit objects, the scalar parts and the unit parts are multiplied separately.

Flags

  Numerical Results (–3), Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | z2 | → | z1 z2
  [[ matrix ]] | [ array ] | → | [[ matrix × array ]]
  z | [ array ] | → | [ z × array ]
  [ array ] | z | → | [ array × z ]
  z | `symb` | → | `z * symb`
  `symb` | z | → | `symb * z`
  `symb1` | `symb2` | → | `symb1 *symb2`
  #n1 | n2 | → | #n3
  n1 | #n2 | → | #n3
  #n1 | #n2 | → | #n3
  x_unit | y_unit | → | xy_unitx × unity
  x | y_unit | → | xy_unit
  x_unit | y | → | xy_unit
  `symb` | x_unit | → | `symb * x_unit`
  x_unit | `symb` | → | `x_unit * symb`

See also

  +, –, /, =

## +(Add) in app ↑ top

PDF page 418 · printed page 3-298

Type

  Function

Description

  Add Analytic Function: Returns the sum of the arguments. The sum of a real number a and a complex number (x, y) is the complex number (x+a, y). The sum of two complex numbers (x1, y1) and (x2, y2) is the complex number (x1+x2, y1+y2). The sum of a real array and a complex array is a complex array, where each element x of the real array is treated as a complex element (x, 0). The arrays must have the same dimensions. The sum of a binary integer and a real number is a binary integer that is the sum of the two arguments, truncated to the current wordsize. (The real number is converted to a binary integer before the addition.) The sum of two binary integers is truncated to the current binary integer wordsize. The sum of two unit objects is a unit object with the same dimensions as the second argument. The units of the two arguments must be consistent. The sum of two graphics objects is the same as the result of performing a logical OR, except that the two graphics objects must have the same dimensions. Common usage is ambiguous about some units of temperature. When °C or °F represents a thermometer reading, then the temperature is a unit with an additive constant: 0 °C = 273.15 K, and 0°F = 459.67°R. But when °C or °F represents a difference in thermometer readings, then the temperature is a unit with no additive constant: 1 °C=1 K and 1 °F =1 °R. The calculator assumes that the simple temperature units x_°C and x_°F represent thermometer temperatures when used as arguments to the functions <, >, ≤, ≥, ==, and ≠. This means that, in order to do the calculation, the calculator will first convert any Celsius temperature to Kelvin and any Fahrenheit temperature to Rankine. (For other functions or compound temperature units, such as x_°C/min, the calculator assumes temperature units represent temperature differences, so there is no additive constant involved, and hence no conversion.) The arithmetic operators +, –, %CH,

  and %T treat temperatures as differences, without any additive constant, but require both arguments to be either absolute (K and °R), both °C, or both °F. No other combinations are allowed.

Flags

  Numerical Results (–3), Binary Integer Wordsize (–5 through –10)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | z2 | → | z1 + z2
  [ array ]1 | [ array ]2 | → | [ array ]3
  z | `symb` | → | `z +symb`
  `symb` | z | → | `symb +z`
  `symb1` | `symb2` | → | `symb1 + symb2`
  { list1 } | { list2 | → | { list1 list2 }
  objA | { obj1 … objn } | → | { objA obj1 … objn }
  { obj1 … objn } | objA | → | {obj1 … objn objA }
  “string1” | “string2” | → | “string1 string2”
  obj | “string” | → | “obj string”
  “string” | obj | → | “string obj”
  #n1 | n2 | → | #n3
  n1 | #n2 | → | #n3
  #n1 | #n2 | → | #n3
  x1_unit1 | y_unit2 | → | (x2 + y)_unit2
  `symb` | x_unit | → | `symb + x_unit`
  x_unit | `symb` | → | `x_unit + symb`
  grob1 | grob2 | → | grob3
  Example 1: { 1 2 3 } { A B C } + returns { 1 2 3 A B C }.
  Example 2: 5_ft 9_in + returns 69_in.
  Example 3: [[ 0 1 ][ 1 3 ]] [[ 2 1 ][ 0 1 ]] + returns
  [[ 2 2 ][ 1 4 ]].
      Example 4:        `FIRST` `SECOND` + returns `FIRST+SECOND`.

See also

  –, *, /, =, ADD

## – (Subtract)in app ↑ top

PDF page 419 · printed page 3-299

Type

  Function

Description

  Subtract Analytic Function: Returns the difference of the arguments. The difference of a real number a and a complex number (x, y) is (x–a, y) or (a–x, –y). The difference of two complex numbers (x1, y1) and (x2, y2) is (x1 – x2, y1 – y2). The difference of a real array and a complex array is a complex array, where each element x of the real array is treated as a complex element (x, 0). The two array arguments must have the same dimensions. The difference of a binary integer and a real number is a binary integer that is the sum of the first argument and the two’s complement of the second argument. (The real number is converted to a binary integer before the subtraction.)

  The difference of two binary integers is a binary integer that is the sum of the first argument and the two’s complement of the second argument. The difference of two unit objects is a unit object with the same dimensions as the second argument. The units of the two arguments must be consistent. Common usage is ambiguous about some units of temperature. When °C or °F represents a thermometer reading, then the temperature is a unit with an additive constant: 0 °C = 273.15 K, and 0 °F = 459.67 °R. But when °C or °F represents a difference in thermometer readings, then the temperature is a unit with no additive constant: 1 °C = 1 K and 1 °F = 1 °R. The calculator assumes that the simple temperature units x_°C and x_°F represent thermometer temperatures when used as arguments to the functions <, >, ≤, ≥, ==, and ≠. This means that, in order to do the calculation, the calculator will first convert any Celsius temperature to Kelvin and any Fahrenheit temperature to Rankine. (For other functions or compound temperature units, such as x_°C/min, the calculator assumes temperature units represent temperature differences, so there is no additive constant involved, and hence no conversion.) The arithmetic operators +, –, %, %CH, and %T treat temperatures as differences, without any additive constant, but require both arguments to be either absolute (K and °R), both °C, or both °F. No other combinations are allowed.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | z2 | → | z1 – z2
  [ array ]1 | [ array ]2 | → | [ array ]1–2
  z | `symb` | → | `z – symb`
  `symb` | z | → | `symb – z`
  `symb1` | `symb2` | → | `symb1 – symb2`
  #n1 | n2 | → | #n3
  n1 | #n2 | → | #n3
  #n1 | #n2 | → | #n3
  x1_unit1 | y_unit2 | → | (x2 – y)_unit2
  `symb` | x_unit | → | `symb – x_unit`
  x_unit | `symb` | → | `x_unit – symb`
  Example 1: 25_ft 8_in - returns 292_in.
  Example 2: [[ 5 1 ][ 3 3 ]] [[ 2 1 ][ 0 1 ]] - returns
  [[ 3 0 ][ 3 2 ]].
      Example 3:       `TOTAL` `PART` - returns `TOTAL-PART`.

See also

  +, *, /, =

## /(Divide) in app ↑ top

PDF page 420 · printed page 3-300

Type

  Function

Description

  Divide Analytic Function: Returns the quotient of the arguments: the first argument is divided by the second argument. A real number a divided by a complex number (x, y) returns:

  - ---------------- ax , ------------------ ay

                                                - 2              2 2                2

  x +y x +y

  A complex number (x, y) divided by a real number a returns the complex number (x/a, y/a). A complex number (x1, y1) divided by another complex number (x2, y2) returns this complex quotient: - x 1 x 2 + y 1 y 2 y 1 x 2 – x 1 y 2- - --------------------------- , ----------------------------

                                      - x2 + y2                               2

  x +y - 2

                                                2          2                 2            2

  An array B divided by a matrix A solves the system of equations AX=B for X; that is, X = A–1 B. This operation uses 15-digit internal precision, providing a more precise result than the calculation INV(A)*B. The matrix must be square, and must have the same number of columns as the array has rows (or elements, if the array is a vector). A binary integer divided by a real or binary number returns a binary integer that is the integral part of the quotient. (The real number is converted to a binary integer before the division.) A divisor of zero returns # 0. When dividing two unit objects, the scalar parts and the unit parts are divided separately.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | z2 | → | z1 / z2
  [ array ] | [[ matrix ]] | → | [[ matrix–1 ×array ]]
  z | `symb` | → | `z /symb`
  `symb` | z | → | `symb /z`
  `symb1` | `symb2` | → | `symb1 / symb2`
  #n1 | n2 | → | #n3
  n1 | #n2 | → | #n3
  #n1 | #n2 | → | #n3
  x_unit1 | y_unit2 | → | (x / y)_unit1/unit2
  x | y_unit | → | (x / y)_1/unit
  x_unit | y | → | (x / y)_unit
  `symb` | x_unit | → | `symb / x_unit`
  x_unit | `symb` | → | `x_unit / symb`

See also

  +, –, *, =

## =(Equal) in app ↑ top

PDF page 421 · printed page 3-301

Type

  Function

Description

  Equals Analytic Function: Returns an equation formed from the two arguments. The equals sign equates two expressions such that the difference between them is zero. In Symbolic Results mode, the result is an algebraic equation. In Numerical Results mode, the result is the difference of the two arguments because = acts equivalent to –. This allows expressions and equations to be used interchangeably as arguments for symbolic and numerical rootfinders.

  Common usage is ambiguous about some units of temperature. When °C or °F represents a thermometer reading, then the temperature is a unit with an additive constant: 0 °C = 273.15 K, and 0°F = 459.67°R. But when °C or °F represents a difference in thermometer readings, then the temperature is a unit with no additive constant: 1°C=1 K and 1°F = 1°R. The arithmetic operators +, –, %, %CH, and %T treat temperatures as differences, without any additive constant. However, +, –, %CH, and %T require both arguments to be either absolute (K and °R), both °C, or both °F. No other combinations are allowed.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  z1 | z2 | → | z1 = z2
  z | `symb` | → | `z = symb`
  `symb` | z | → | `symb = z`
  `symb1` | `symb2` | → | `symb1 = symb2`
  y_unit | x | → | y_unit1 = x
  y_unit | x_unit | → | y_unit1 = x_unit
  `symb` | x_unit | → | `symb = x_unit`
  x_unit | `symb` | → | `x_unit = symb`

See also

  DEFINE, EVAL, –

## ==(Logical Equality) in app ↑ top

PDF page 422 · printed page 3-302

Type

  Function

Description

  Logical Equality Function: Tests if two objects are equal. The function == returns a true result (1) if the two objects are the same type and have the same value, or a false result (0) otherwise. Lists and programs are considered to have the same values if the objects they contain are identical. If one object is algebraic (or a name), and the other is a number (real or complex) or an algebraic, == returns a symbolic comparison expression that can be evaluated to return a test result. Note that == is used for comparisons, while = separates two sides of an equation. If the imaginary part of a complex number is 0, it is ignored when the complex number is compared to a real number. For unit objects, the two objects must be dimensionally consistent and are converted to common units for comparison. If you use simple temperature units, the calculator assumes the values represent temperatures and not differences in temperatures. For compound temperature units, the calculator assumes temperature units represent temperature differences. For more information on using temperature units with arithmetic functions, refer to the entry for +.

Flags

  Numerical Results (–3)

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj1 | obj2 | → | 0/1
  (x,0) | x | → | 0/1
  x | (x,0) | → | 0/1
  z | `symb` | → | `z == symb`
  `symb` | z | → | `symb == z`
  `symb1` | `symb2` | → | `symb1 == symb2`

See also

  SAME, TYPE, <, ≤, >, ≥, ≠

## (Store) not in app ↑ top

PDF page 423 · printed page 3-303

Type

  Command

Description

  Store Command: Stores an object into a specified variable. To create a backup object, store the obj into the desired backup location (identified as :nport:namebackup). will not overwrite an existing backup object. To replace an element of an array or list, use STO. Also use STO to store a graphic object into PICT or a library or backup object into a port.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  obj | `name` | → | obj
  obj | :nport :namebackup | → | obj

See also

  DEFINE, RCL, →, STO

## →(Create Local) not in app ↑ top

PDF page 423 · printed page 3-303

Type

  Command

Description

  Create Local Variables Command: Creates local variables. Local variable structures specify one or more local variables and a defining procedure.

      A local variable structure consists of the → command, followed by one or more names, followed
          by a defining procedure — either a program or an algebraic. The → command stores objects into

  local variables with the specified names. The resultant local variables exist only while the defining procedure is being executed. The syntax of a local variable structure is one of the following:

      • → name1 name2 … namen « program »
          • → name1 name2 … namen `algebraic expression`

Input/Output

  Leveln/Argument1 7 Level1/Argumentn |  | Level 1/Item 1
  --- | --- | ---
  obj1 … objn | → |
  Example 1: | This program: |
  « → x y « x y * x y - + » »
  takes an object from level 2 and stores it in local variable x, takes an object from level 1 and stores it in local variable y, and executes calculations with x and y in the defining procedure (in this case a program). When the defining procedure ends, local variables x and y disappear.
      Example 2:        A user-defined function is a variable containing a program that consists solely of a local variable
  structure. For example, the variable A, containing this program:
                      « → x y z `x*y/2+z` »
  is a user-defined function. Like a built-in function, a user-defined function can take its arguments in stack syntax or algebraic syntax, and can take symbolic arguments. In addition, a user-defined function is differentiable if its defining procedure is an algebraic expression that contains only differentiable functions.

See also

  DEFINE, LOCAL, STO

## ;(Semicolon) not in app ↑ top

PDF page 424 · printed page 3-304

Type

  Command

Description

  Drop Safe Command: Removes the level 1 object from the stack if there is one, otherwise does nothing.

Input/Output

  Level 1 |  | Level 1
  --- | --- | ---
  obj | → |
  →

See also

  CLEAR, DROP, DROPN, DROP2

## Additional commands (this RPL implementation)

## UNDO in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Restores the calculator stack to the state immediately before the most recent operation. Repeated UNDOs walk back through the saved undo ring buffer. Stack-mutating ops (commits, pushes, pops, ops with side effects) are recorded; mode and entry-buffer changes are not.

Input/Output

  None

See also

  REDO, LASTSTACK

## REDO in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Replays the most recently undone stack state. After UNDO walks back N steps, REDO walks forward one step at a time so long as no new mutating op has been issued (any new push / pop / op clears the redo buffer).

Input/Output

  None

See also

  UNDO, LASTSTACK

## LASTSTACK in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Synonym for UNDO — restores the previous stack snapshot. Provided so HP50 programs that call LASTSTACK keep working unchanged.

Input/Output

  None

See also

  UNDO, REDO

## UNDER in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Splits a tagged object into its underlying value and tag string. The value is left at level 2 with the tag string at level 1, allowing the tag to be inspected, edited, or reattached with →TAG.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  "tag":obj | → | obj | "tag"

See also

  →TAG, DTAG

## D→HMS in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Decimal Hours to Hours-Minutes-Seconds: converts a real number representing hours (or any HMS-compatible value) into HH.MMSSss notation. The integer part is whole hours, the next two digits are minutes, and the remaining digits are decimal seconds.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | HH.MMSSss

See also

  HMS→D, →HMS, HMS→

## HMS→D in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Hours-Minutes-Seconds to Decimal Hours: converts an HMS-formatted real number HH.MMSSss to a plain decimal hours value. Inverse of D→HMS.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  HH.MMSSss | → | x

See also

  D→HMS, →HMS, HMS→

## C→R in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Complex to Real: splits a complex number into its real and imaginary parts as two separate real numbers, with the real part at level 2 and the imaginary part at level 1.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  (x, y) | → | x | y

See also

  R→C, RE, IM

## C→P in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Cartesian to Polar: converts a complex number from rectangular form (x, y) into polar form (r, θ), where r = √(x² + y²) and θ is the argument. The angle uses the current angle mode (DEG / RAD / GRD).

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (x, y) | → | (r, θ)

See also

  P→C, R→C, ARG

## P→C in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Polar to Cartesian: converts a complex number from polar form (r, θ) into rectangular form (x, y), where x = r cos θ and y = r sin θ. The angle is interpreted in the current angle mode.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  (r, θ) | → | (x, y)

See also

  C→P, R→C, RECT, CYLIN

## CMPLX? in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Returns 1 if the calculator is currently in Complex mode, 0 otherwise. Use it inside programs that need to gate complex-aware logic.

Input/Output

  |  | Level 1/Item 1
  --- | --- | ---
  | → | 0/1

See also

  CMPLX

## TRUE in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Pushes the boolean literal 1 (true). Useful as an explicit return value for predicate programs.

Input/Output

  |  | Level 1/Item 1
  --- | --- | ---
  | → | 1

See also

  FALSE, AND, OR, NOT

## FALSE in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Pushes the boolean literal 0 (false).

Input/Output

  |  | Level 1/Item 1
  --- | --- | ---
  | → | 0

See also

  TRUE, AND, OR, NOT

## GRD in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Sets the angle mode to gradians (400 grad = 360°). Subsequent trig calls (SIN, COS, TAN, …) interpret their argument in grads. Same effect as setting flag –17 / –18 to the GRD combination.

Input/Output

  None

See also

  DEG, RAD, GRAD

## TEXTBOOK in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Selects textbook (pretty-printed) display of expressions on the stack — fractions stack vertically, exponents render as superscripts, etc. Toggle off with FLAT.

Input/Output

  None

See also

  FLAT

## FLAT in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Selects flat (linear) display of expressions on the stack — everything renders on one line in monospaced ASCII. Inverse of TEXTBOOK.

Input/Output

  None

See also

  TEXTBOOK

## CLB in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Clears the display-base override applied by HEX / DEC / OCT / BIN. After CLB, each binary integer renders in its stored base and at minimum width (no STWS padding) — the HP50-default behavior before any base mode has been set.

Input/Output

  None

See also

  HEX, DEC, OCT, BIN, STWS

## APPROX in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Sets numeric (approximate) evaluation mode: subsequent evaluations replace exact constants like π or fractions with their floating-point approximations and short-circuit symbolic results. Equivalent to setting flag –3.

Input/Output

  None

See also

  EXACT, →NUM

## EXACT in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Sets exact (symbolic) evaluation mode: subsequent evaluations preserve constants like π and exact rationals instead of folding them to floats. Inverse of APPROX.

Input/Output

  None

See also

  APPROX, →NUM

## KIND in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Returns the HP50 numeric type code of the level-1 object. Same encoding as TYPE for the types this app supports — Real = 0, Complex = 1, String = 2, Vector/Matrix = 3, List = 5, Name = 6, Symbolic = 9, Tagged = 12, Directory = 15, etc. Use TYPE in new code; KIND is provided for HP50 compatibility.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  obj | → | n

See also

  TYPE, VTYPE

## →PRG in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Composes a program object from objects on the stack. Argument 1 is a positive integer n; the next n stack levels become the program body in order (level n at the start, level 1 at the end). An n of 0 produces an empty program « ».

Input/Output

  Levels n+1…2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  objₙ … obj₁ | n | → | « objₙ … obj₁ »

See also

  OBJ→, →LIST, →ARRY

## ABORT in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Unwinds the currently-executing program (and any nested IF / WHILE / CASE / etc. frames) and returns control to the user. ABORT is not catchable by IFERR; the stack is left as it was at the moment of ABORT.

Input/Output

  None

See also

  HALT, KILL, IFERR, DOERR

## RUN in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Resumes a halted program at full speed, suppressing any single-step / step-into mode that may be active. Equivalent to CONT after clearing debug flags.

Input/Output

  None

See also

  CONT, HALT, DBUG, SST

## EUCLID in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Extended Euclidean algorithm for two integers. Given a and b, returns three integers u, v, and d = gcd(a, b) such that a·u + b·v = d. Wraps Bézout’s identity for HP50-style integer arithmetic.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 3/Item 1 | Level 2/Item 2 | Level 1/Item 3
  --- | --- | --- | --- | --- | ---
  a | b | → | u | v | d

See also

  GCD, IEGCD, IABCUV

## DECOMP in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Decompiles a program object into its source-string form, the same text the editor would show. Intended as a programming aid for inspecting compiled programs at runtime.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  « prg » | → | "« prg »"

See also

  →STR, OBJ→, STR→

## Q→ in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Splits a rational symbolic expression into its numerator and denominator. Works on Symbolic, Integer, or Real arguments — bare numerics return {x, 1}. Inverse companion to →Q.

Input/Output

  Level 1/Argument 1 |  | Level 2/Item 1 | Level 1/Item 2
  --- | --- | --- | ---
  `a/b` | → | `a` | `b`

See also

  →Q, →QΠ

## COSSIN in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Rewrites tan(x) in a symbolic expression as sin(x)/cos(x), expanding tangent factors into their sine-cosine equivalents. Inverse direction of TAN2SC.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `symb` | → | `COSSIN(symb)`

See also

  TAN2SC, HALFTAN, SINCOS

## HEAVISIDE in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Heaviside unit step function H(x): returns 0 for x < 0 and 1 for x ≥ 0. Numerical arguments fold immediately; symbolic arguments produce `HEAVISIDE(expr)` for downstream LAPLACE / piecewise work.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | 0/1
  `symb` | → | `HEAVISIDE(symb)`

See also

  DIRAC, LAPLACE, ILAP

## DIRAC in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Dirac delta distribution δ(x): folds non-zero numerics to 0; an exact zero stays symbolic as `DIRAC(0)` since the spike at the origin is singular. Symbolic arguments wrap as `DIRAC(expr)` for further LAPLACE work.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x ≠ 0 | → | 0
  0 | → | `DIRAC(0)`
  `symb` | → | `DIRAC(symb)`

See also

  HEAVISIDE, LAPLACE, ILAP

## LAPLACE in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Laplace transform of a symbolic expression with respect to the current CAS variable VX. Routes through the Giac engine; the input must be Symbolic. Use ILAP for the inverse transform.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  `f(x)` | → | `LAPLACE(f)(x)`

See also

  ILAP, HEAVISIDE, DIRAC, VX, SVX

## VX in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Pushes the name of the current CAS independent variable (default `X`) onto the stack as a Name. Used as the implicit variable for ops like DERVX / INTVX / LAPLACE. Set with SVX.

Input/Output

  |  | Level 1/Item 1
  --- | --- | ---
  | → | `name`

See also

  SVX, DERVX, INTVX, LAPLACE

## SVX in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Stores a new CAS independent variable. Argument 1 is a Name or String; subsequent uses of VX, DERVX, INTVX, LAPLACE, etc. operate on this variable.

Input/Output

  Level 1/Argument 1 |  |
  --- | --- | ---
  `name` | → |

See also

  VX, DERVX, INTVX

## LNGAMMA in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Natural logarithm of the gamma function: returns ln Γ(x). Faster and numerically safer than `GAMMA LN` for large x. Accepts Real, Integer, or Vector / Matrix; symbolic arguments wrap as `LNGAMMA(symb)`.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | ln Γ(x)

See also

  GAMMA, PSI

## BETA in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Beta function: B(a, b) = Γ(a)·Γ(b) / Γ(a + b). Takes two real arguments at levels 2 and 1; symbolic arguments wrap as `BETA(a, b)`.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  a | b | → | B(a, b)

See also

  GAMMA, LNGAMMA

## ERF in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Gauss error function: erf(x) = (2/√π) ∫₀ˣ e^(−t²) dt. Folds Real / Integer / Vector / Matrix inputs; symbolic arguments wrap as `ERF(symb)`.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | erf(x)

See also

  ERFC, GAMMA

## ERFC in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Complementary error function: erfc(x) = 1 − erf(x). Numerically more accurate than `1 ERF -` for large x.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | erfc(x)

See also

  ERF, GAMMA

## EI in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Exponential integral Ei(x) = −∫_{−x}^∞ (e^{−t}/t) dt for x > 0; the Cauchy principal value is taken at the singularity at t = 0. Real / Integer arguments fold numerically; symbolic arguments wrap as `Ei(symb)`.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | Ei(x)

See also

  CI, SI, GAMMA

## CI in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Cosine integral Ci(x) = γ + ln x + ∫₀ˣ ((cos t − 1)/t) dt for x > 0. Folds Real / Integer; symbolic arguments wrap as `Ci(symb)`.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | Ci(x)

See also

  SI, EI

## SI in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Sine integral Si(x) = ∫₀ˣ (sin t / t) dt. Folds Real / Integer; symbolic arguments wrap as `Si(symb)`.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | Si(x)

See also

  CI, EI

## ZETA in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Riemann zeta function ζ(s) = Σ_{n=1}^∞ n^{−s}. Folds Real / Integer / Vector / Matrix; symbolic arguments wrap as `ZETA(symb)`.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  s | → | ζ(s)

See also

  GAMMA

## LAMBERT in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Principal branch of the Lambert W function: returns the W₀(x) such that W·e^W = x for x ≥ −1/e. Folds Real / Integer / Vector / Matrix; symbolic arguments wrap as `LAMBERT(symb)`.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  x | → | W(x)

See also

  EXP, LN

## NORM in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Euclidean norm of a vector or matrix. For a vector, returns √(Σxᵢ²); for a matrix, the Frobenius norm √(Σ|aᵢⱼ|²). Equivalent to ABS for arrays.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ vector ] | → | |vector|
  [[ matrix ]] | → | |matrix|

See also

  ABS, CNRM, RNRM

## COL→ in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Decomposes a matrix into its columns. A matrix on level 1 is replaced by its column count `c` on level 1, with c column vectors below it (left-most column at the deepest level).

Input/Output

  Level 1/Argument 1 |  | Levels k+1…1/Items
  --- | --- | ---
  [[ matrix ]] | → | [col₁] … [colₖ] k

See also

  →COL, ROW→, →ROW

## APPEND in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Appends an object to the end of a list. Level 2 must be a list; level 1 is the object to append (any type). Returns a new list with the original elements followed by the new one.

Input/Output

  Level 2/Argument 1 | Level 1/Argument 2 |  | Level 1/Item 1
  --- | --- | --- | ---
  { obj₁ … objₙ } | objₐ | → | { obj₁ … objₙ objₐ }

See also

  +, HEAD, TAIL, →LIST

## ΔLIST in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  First-difference list: returns a new list whose i-th element is xᵢ − xᵢ₋₁ for the input list { x₁ x₂ … xₙ }. The output is always one element shorter than the input. Useful for smoothing and discrete-difference programs.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { x₁ … xₙ } | → | { x₂−x₁ … xₙ−xₙ₋₁ }

See also

  ΣLIST, ΠLIST, DLIST

## SUM in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Adds the elements of a list or vector. All elements must be numeric (Real, Integer, or Complex); empty arguments return Integer(0). Symbolic arguments wrap as `Σ(expr)` for downstream evaluation.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  { x₁ … xₙ } | → | Σxᵢ
  [ x₁ … xₙ ] | → | Σxᵢ

See also

  ΣLIST, MEAN, ΣX

## MEDIAN in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Median of a vector or per-column median of a matrix. Uses the standard "average of two middle values" rule for even-length samples.

Input/Output

  Level 1/Argument 1 |  | Level 1/Item 1
  --- | --- | ---
  [ vector ] | → | med
  [[ matrix ]] | → | [ med per column ]

See also

  MEAN, VAR, SDEV

## STMXE in app ↑ top

Reference written for this RPL implementation.

Type

  Command

Description

  Store Max Exponent: sets the magnitude of the real-number exponent range. The argument must be an integer in [10, 9 × 10¹⁵]; after STMXE, MAXR equals 9.99999999999 × 10ᵉ and MINR equals 1 × 10⁻ᵉ, and the Decimal arithmetic engine clamps overflow to ±MAXR using this exponent. This is an rpl5050 extension with no HP50 equivalent.

Input/Output

  Level 1/Argument 1 |  |
  --- | --- | ---
  n | → |

See also

  RCMXE, MAXR, MINR

## RCMXE in app ↑ top

Reference written for this RPL implementation.

Type

  Function

Description

  Recall Max Exponent: pushes the current real-number exponent magnitude (set by STMXE) onto the stack as an Integer. Default is 999. rpl5050 extension with no HP50 equivalent.

Input/Output

  |  | Level 1/Item 1
  --- | --- | ---
  | → | n

See also

  STMXE, MAXR, MINR