Syntax: include filename_string



This syntax can be used to include one run-configuration file within another. This command could be used to load the default orpierc file (probably found in /etc/orpierc) within your personalized rcfile, {/.orpierc}. The filename string should be enclosed in quotes.

Syntax: set variable=value_string



Several configuration variables can be set using this syntax; check the CONFIGURATION VARIABLES description to see a list. The variables are unquoted, but the values should be quoted strings.

Syntax: bind key_identifier operation



This command will bind a keypress to execute a calculator operation. The various operations, which should not be enclosed in quotes, may be found in the section on CALCULATOR OPERATIONS. Key identifiers may be specified by strings that represent a single keypress, for example "m" (quotes included). The key may be prefixed with "\\C" or "\\M" to represent Control or Meta (Alt) modifiers, respectively; note that the backslash must be doubled. A number of special keys lack single-character representations, so the following strings may be used to represent them:

*

"<esc>"

*

"<tab>"

*

"<enter>"

*

"<return>"

*

"<insert>"

*

"<home>"

*

"<end>"

*

"<pageup>"

*

"<pagedown>"

*

"<space>"

*

"<left>"

*

"<right>"

*

"<up>"

*

"<down>"

*

"<f1>" to "<f12>"

Due to differences between various terminal emulators, this key identifier syntax may not be adequate to describe every keypress. As a workaround, Orpie will also accept key identifiers in octal notation. As an example, you could use \024 (do not enclose it in quotes) to represent Ctrl-T.

Orpie includes a secondary executable, orpie-curses-keys, that prints out the key identifiers associated with keypresses. You may find it useful when customizing orpierc.

Multiple keys may be bound to the same operation, if desired.

Syntax:

unbind_function key_identifier

unbind_command key_identifier

unbind_edit key_identifier

unbind_browse key_identifier

unbind_abbrev key_identifier

unbind_variable key_identifier

unbind_integer key_identifier



These commands will remove key bindings associated with the various entry modes (functions, commands, editing operations, etc.). The key identifiers should be defined using the syntax described in the previous section.

Syntax: autobind key_identifier



In order to make repetitive calculations more pleasant, Orpie offers an automatic key binding feature. When a function or command is executed using its abbreviation, one of the keys selected by the autobind syntax will be automatically bound to that operation (unless the operation has already been bound to a key). The current set of autobindings can be viewed in the help panel by executing command_cycle_help (bound to 'h' by default).

The syntax for the key identifiers is provided in the previous section.

Syntax: abbrev operation_abbreviation operation



You can use this syntax to set the abbreviations used within Orpie to represent the various functions and commands. A list of available operations may be found in the CALCULATOR OPERATIONS section. The operation abbreviations should be quoted strings, for example "sin" or "log".

Orpie performs autocompletion on these abbreviations, allowing you to type usually just a few letters in order to select the desired command. The order of the autocompletion matches will be the same as the order in which the abbreviations are registered by the rcfile--so you may wish to place the more commonly used operation abbreviations earlier in the list.

Multiple abbreviations may be bound to the same operation, if desired.

Syntax: unabbrev operation_abbreviation



This syntax can be used to remove an operation abbreviation. The operation abbreviations should be quoted strings, as described in the previous section.

Syntax: macro key_identifier macro_string



You can use this syntax to cause a single keypress (the key_identifier) to be interpreted as the series of keypresses listed in macro_string. The syntax for defining a keypress is the same as that defined in the section on CREATING KEY BINDINGS. The macro string should be a list of whitespace-separated keypresses, e.g. "2 <return> 2 +" (including quotes).

This macro syntax provides a way to create small programs; by way of example, the default orpierc file includes macros for the base 2 logarithm and the binary entropy function (bound to L and H, respectively), as well as ``register'' variable shortcuts (<f1> to <f12>).

Macros may call other macros recursively. However, take care that a macro does not call itself recursively; Orpie will not trap the infinite loop.

Note that operation abbreviations may be accessed within macros. For example, macro "A" "' a b o u t <return>" would bind A to display the ``about Orpie'' screen.

The following operations are functions--that is, they will consume at least one argument from the stack. Orpie will generally abort the computation and provide an informative error message if a function cannot be successfully applied (for example, if you try to compute the transpose of something that is not a matrix).

For the integer constant data type, basic arithmetic operations will yield an exact integer constant result. Division of two integer constants will yield the quotient of the division. The more complicated functions will generally promote the integer constant to a real number, and as such the arithmetic will no longer be exact.

*

function_10_x

Raise 10 to the power of the last stack element (inverse of function_log10).

*

function_abs

Compute the absolute value of the last stack element.

*

function_acos

Compute the inverse cosine of the last stack element. For real numbers, The result will be provided either in degrees or radians, depending on the angle mode of the calculator.

*

function_acosh

Compute the inverse hyperbolic cosine of the last stack element.

*

function_add

Add last two stack elements.

*

function_arg

Compute the argument (phase angle of complex number) of the last stack element. The value will be provided in either degrees or radians, depending on the current angle mode of the calculator.

*

function_asin

Compute the inverse sine of the last stack element. For real numbers, The result will be provided either in degrees or radians, depending on the angle mode of the calculator.

*

function_asinh

Compute the inverse hyperbolic sine of the last stack element.

*

function_atan

Compute the inverse tangent of the last stack element. For real numbers, The result will be provided either in degrees or radians, depending on the angle mode of the calculator.

*

function_atanh

Compute the inverse hyperbolic tangent of the last stack element.

*

function_binomial_coeff

Compute the binomial coefficient (``n choose k'') formed by the last two stack elements. If these arguments are real, the coefficient is computed using a fast approximation to the log of the gamma function, and therefore the result is subject to rounding errors. For integer constant arguments, the coefficient is computed using exact arithmetic; this has the potential to be a slow operation.

*

function_ceiling

Compute the ceiling of the last stack element.

*

function_convert_units

Convert stack element 2 to an equivalent expression in the units of element 1. Element 1 should be real-valued, and its magnitude will be ignored when computing the conversion.

*

function_cos

Compute the cosine of the last stack element. If the argument is real, it will be assumed to be either degrees or radians, depending on the angle mode of the calculator.

*

function_cosh

Compute the hyperbolic cosine of the last stack element.

*

function_conj

Compute the complex conjugate of the last stack element.

*

function_div

Divide element 2 by element 1.

*

function_erf

Compute the error function of the last stack element.

*

function_erfc

Compute the complementary error function of the last stack element.

*

function_eval

Obtain the contents of the variable in the last stack position.

*

function_exp

Evaluate the exponential function of the last stack element.

*

function_factorial

Compute the factorial of the last stack element. For a real argument, this is computed using a fast approximation to the gamma function, and therefore the result may be subject to rounding errors (or overflow). For an integer constant argument, the factorial is computed using exact arithmetic; this has the potential to be a slow operation.

*

function_floor

Compute the floor of the last stack element.

*

function_gamma

Compute the Euler gamma function of the last stack element.

*

function_gcd

Compute the greatest common divisor of the last two stack elements. This operation may be applied only to integer type data.

*

function_im

Compute the imaginary part of the last stack element.

*

function_inv

Compute the multiplicative inverse of the last stack element.

*

function_lcm

Compute the least common multiple of the last two stack elements. This operation may be applied only to integer type data.

*

function_ln

Compute the natural logarithm of the last stack element.

*

function_lngamma

Compute the natural logarithm of the Euler gamma function of the last stack element.

*

function_log10

Compute the base-10 logarithm of the last stack element.

*

function_maximum

Find the maximum values of each of the columns of a real NxM matrix, returning a 1xM matrix as a result.

*

function_minimum

Find the minimum values of each of the columns of a real NxM matrix, returning a 1xM matrix as a result.

*

function_mean

Compute the sample means of each of the columns of a real NxM matrix, returning a 1xM matrix as a result.

*

function_mod

Compute element 2 mod element 1. This operation can be applied only to integer type data.

*

function_mult

Multiply last two stack elements.

*

function_neg

Negate last stack element.

*

function_permutation

Compute the permutation coefficient determined by the last two stack elements 'n' and 'k': the number of ways of obtaining an ordered subset of k elements from a set of n elements. If these arguments are real, the coefficient is computed using a fast approximation to the log of the gamma function, and therefore the result is subject to rounding errors. For integer constant arguments, the coefficient is computed using exact arithmetic; this has the potential to be a slow operation.

*

function_pow

Raise element 2 to the power of element 1.

*

function_purge

Delete the variable in the last stack position.

*

function_re

Compute the real part of the last stack element.

*

function_sin

Compute the sine of the last stack element. If the argument is real, it will be assumed to be either degrees or radians, depending on the angle mode of the calculator.

*

function_sinh

Compute the hyperbolic sine of the last stack element.

*

function_solve_linear

Solve a linear system of the form Ax = b, where A and b are the last two elements on the stack. A must be a square matrix and b must be a matrix with one column. This function does not compute inv(A), but obtains the solution by a more efficient LU decomposition method. This function is recommended over explicitly computing the inverse, especially when solving linear systems with relatively large dimension or with poorly conditioned matrices.

*

function_sq

Square the last stack element.

*

function_sqrt

Compute the square root of the last stack element.

*

function_standardize_units

Convert the last stack element to an equivalent expression using the SI standard base units (kg, m, s, etc.).

*

function_stdev_unbiased

Compute the unbiased sample standard deviation of each of the columns of a real NxM matrix, returning a 1xM matrix as a result. (Compare to HP48's sdev function.)

*

function_stdev_biased

Compute the biased (population) sample standard deviation of each of the columns of a real NxM matrix, returning a 1xM matrix as a result. (Compare to HP48's psdev function.)

*

function_store

Store element 2 in (variable) element 1.

*

function_sub

Subtract element 1 from element 2.

*

function_sumsq

Sum the squares of each of the columns of a real NxM matrix, returning a 1xM matrix as a result.

*

function_tan

Compute the tangent of the last stack element. If the argument is real, it will be assumed to be either degrees or radians, depending on the angle mode of the calculator.

*

function_tanh

Compute the hyperbolic tangent of the last stack element.

*

function_to_int

Convert a real number to an integer type.

*

function_to_real

Convert an integer type to a real number.

*

function_total

Sum each of the columns of a real NxM matrix, returning a 1xM matrix as a result.

*

function_trace

Compute the trace of a square matrix.

*

function_transpose

Compute the matrix transpose of the last stack element.

*

function_unit_value

Drop the units of the last stack element.

*

function_utpn

Compute the upper tail probability of a normal distribution.

UTPN(m, v, x) = Integrate[ 1/Sqrt[2 Pi v] Exp[-(m-y)^2/(2 v)], {y, x, Infinity}]

*

function_var_unbiased

Compute the unbiased sample variance of each of the columns of a real NxM matrix, returning a 1xM matrix as a result. (Compare to HP48's var function.)

*

function_var_biased

Compute the biased (population) sample variance of each of the columns of a real NxM matrix, returning a 1xM matrix as a result. (Compare to HP48's pvar function.)

The following operations are referred to as commands; they differ from functions because they do not take an argument. Many calculator interface settings are implemented as commands.

*

command_about

Display a nifty ``about Orpie'' credits screen.

*

command_begin_browsing

Enter stack browsing mode.

*

command_begin_abbrev

Begin entry of an operation abbreviation.

*

command_begin_variable

Begin entry of a variable name.

*

command_bin

Set the base of integer constant representation to 2 (binary).

*

command_clear

Clear all elements from the stack.

*

command_cycle_base

Cycle the base of integer constant representation between 2, 8, 10, and 16 (bin, oct, dec, and hex).

*

command_cycle_help

Cycle through multiple help pages. The first page displays commonly used bindings, and the second page displays the current autobindings.

*

command_dec

Set the base of integer constant representation to 10 (decimal).

*

command_deg

Set the angle mode to degrees.

*

command_drop

Drop the last element off the stack.

*

command_dup

Duplicate the last stack element.

*

command_enter_pi

Enter 3.1415... on the stack.

*

command_hex

Set the base of integer constant representation to 16 (hexadecimal).

*

command_oct

Set the base of integer constant representation to 8 (octal).

*

command_polar

Set the complex display mode to polar.

*

command_rad

Set the angle mode to radians.

*

command_rand

Generate a random real-valued number between 0 (inclusive) and 1 (exclusive). The deviates are uniformly distributed.

*

command_rect

Set the complex display mode to rectangular (cartesian).

*

command_refresh

Refresh the display.

*

command_swap

Swap stack elements 1 and 2.

*

command_quit

Quit Orpie.

*

command_toggle_angle_mode

Toggle the angle mode between degrees and radians.

*

command_toggle_complex_mode

Toggle the complex display mode between rectangular and polar.

*

command_undo

Undo the last calculator operation.

*

command_view

View the last stack element in an external fullscreen editor.

*

command_edit_input

Create a new stack element using an external editor.

The following operations are related to editing during data entry. These commands cannot be made available as operation abbreviations, since abbreviations are not accessible while entering data. These operations should be made available as single keypresses using the bind keyword.

*

edit_angle

Begin entering the phase angle of a complex number. (Orpie will assume the angle is in either degrees or radians, depending on the current angle mode.)

*

edit_backspace

Delete the last character entered.

*

edit_begin_integer

Begin entering an integer constant.

*

edit_begin_units

Begin appending units to a numeric expression.

*

edit_complex

Begin entering a complex number.

*

edit_enter

Enter the data that is currently being edited.

*

edit_matrix

Begin entering a matrix, or begin entering the next row of a matrix.

*

edit_minus

Enter a minus sign in input.

*

edit_scientific_notation_base

Begin entering the scientific notation exponent of a real number, or the base of an integer constant.

*

edit_separator

Begin editing the next element of a complex number or matrix. (This will insert a comma between elements.)

The following list of operations is available only in stack browsing mode. As abbreviations are unavailable while browsing the stack, these operations should be bound to single keypresses using the bind keyword.

*

browse_echo

Echo the currently selected element to stack level 1.

*

browse_end

Exit stack browsing mode.

*

browse_drop

Drop the currently selected stack element.

*

browse_dropn

Drop all stack elements below the current selection (inclusive).

*

browse_keep

Drop all stack elements except the current selection. (This is complementary to browse_drop.

*

browse_keepn

Drop all stack elements above the current selection (non-inclusive). (This is complementary to browse_dropn.

*

browse_next_line

Move the selection cursor down one line.

*

browse_prev_line

Move the selection cursor up one line.

*

browse_rolldown

Cyclically ``roll'' stack elements downward, below the selected element (inclusive).

*

browse_rollup

Cyclically ``roll'' stack elements upward, below the selected element (inclusive) .

*

browse_scroll_left

Scroll the selected element to the left (for viewing very large entries such as matrices).

*

browse_scroll_right

Scroll the selected element to the right.

*

browse_view

View the currently selected stack element in a fullscreen editor.

*

browse_edit

Edit the currently selected stack element using an external editor.

The following list of operations is available only while entering a function or command abbreviation. These operations must be bound to single keypresses using the bind keyword.

*

abbrev_backspace

Delete a character from the abbreviation string.

*

abbrev_enter

Execute the operation associated with the selected abbreviation.

*

abbrev_exit

Cancel abbreviation entry.

The following list of operations is available only while entering a variable name. As abbreviations are unavailable while entering variables, these operations should be bound to single keypresses using the bind keyword.

*

variable_backspace

Delete a character from the variable name.

*

variable_cancel

Cancel entry of the variable name.

*

variable_complete

Autocomplete the variable name.

*

variable_enter

Enter the variable name on the stack.

The following operation is available only while entering an integer; it can be made accessible by binding it to a single keypress using the bind keyword.

*

integer_cancel

Cancel entry of an integer.