Provided by: orpie_1.5.2-2_amd64 bug

NAME

       orpierc is the configuration textfile for the orpie(1) console calculator.

INTRODUCTION

       CAUTION:  while this manpage should be suitable as a quick reference, it may be subject to
       miscellaneous shortcomings in typesetting. The definitive documentation is the user manual
       provided with Orpie in PDF format.

       Orpie     reads     a    run-configuration    textfile    (generally    /etc/orpierc    or
       /usr/local/etc/orpierc)  to  determine  key  and  command  bindings.  You  can  create   a
       personalized  configuration  file  in  $HOME/.orpierc, and select bindings that match your
       usage patterns. The recommended procedure is to ``include'' the orpierc file provided with
       Orpie (see INCLUDING OTHER RCFILES), and add or remove settings as desired.

ORPIERC SYNTAX

       You  may notice that the orpierc syntax is similar to the syntax used in the configuration
       file for the Mutt email client (muttrc).

       Within the orpierc file, strings should be enclosed in double quotes (").  A double  quote
       character  inside  a  string  may  be represented by \" .  The backslash character must be
       represented by doubling it (\\).

   INCLUDING OTHER RCFILES
       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.

   SETTING CONFIGURATION VARIABLES
       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.

   CREATING KEY BINDINGS
       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.

   REMOVING KEY BINDINGS
       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.

   CREATING KEY AUTO-BINDINGS
       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.

   CREATING OPERATION ABBREVIATIONS
       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.

   REMOVING OPERATION ABBREVIATIONS
       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.

   CREATING MACROS
       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.

   CREATING UNITS
       Syntax:
       base_unit unit_symbol preferred_prefix
       unit unit_symbol unit_definition
       Units are defined in a two-step process:

       1.     Define a set of orthogonal ``base units.'' All other units must be  expressible  in
              terms of these base units. The base units can be given a preferred SI prefix, which
              will be used whenever the units are  standardized  (e.g.  via  ustand).   The  unit
              symbols  and  preferred prefixes should all be quoted strings; to prefer no prefix,
              use the empty string ("").

       It is expected that most users will use the fundamental SI units for base units.

       2.     Define all other units in terms of either base units or  previously-defined  units.
              Again, the unit symbol and unit definition should be quoted strings. The definition
              should take the  form  of  a  numeric  value  followed  by  a  units  string,  e.g.
              "2.5_kN*m/s".  See the UNITS FORMATTING section for more details on the unit string
              format.

   CREATING CONSTANTS
       Syntax: constant constant_symbol constant_definition
       This syntax can be used to define a  physical  constant.  Both  the  constant  symbol  and
       definition  must  be  quoted strings. The constant definition should be a numeric constant
       followed by a units string e.g.  "1.60217733e-19_C".   All  units  used  in  the  constant
       definition must already have been defined.

CONFIGURATION VARIABLES

       The following configuration variables may be set as described in the SETTING CONFIGURATION
       VARIABLES section.

       *      datadir
              This variable should be set to the full path of the  Orpie  data  directory,  which
              will  contain  the calculator state save file, temporary buffers, etc.  The default
              directory is "\~/.orpie/".

       *      editor
              This variable may be set to the fullscreen editor of your choice. The default value
              is  "vi".  It  is  recommended  that  you  choose  an editor that offers horizontal
              scrolling in place of word wrapping, so that the columns of large matrices  can  be
              properly  aligned.  (The Vim editor could be used in this fashion by setting editor
              to "vim -c 'set nowrap'".)

       *      hide_help
              Set this variable to "true" to hide the left help/status panel, or leave it on  the
              default of "false" to display the help panel.

       *      conserve_memory
              Set this variable to "true" to minimize memory usage, or leave it on the default of
              "false" to improve rendering performance. (By default, Orpie caches multiple string
              representations  of  all  stack elements. Very large integers in particular require
              significant computation for string representation, so  caching  these  strings  can
              make display updates much faster.)

CALCULATOR OPERATIONS

       Every  calculator  operation  can  be  made  available  to  the interface using the syntax
       described in the sections on CREATING KEY BINDINGS and CREATING  OPERATION  ABBREVIATIONS.
       The following is a list of every available operation.

   FUNCTIONS
       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 exact integer data type, basic arithmetic operations will yield an  exact  integer
       result.  Division  of two exact integers will yield the quotient of the division. The more
       complicated functions will generally promote the integer 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 exact integer 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 exact integer 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  exact  integer  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.)

   COMMANDS
       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_abbrev
              Begin entry of an operation abbreviation.

       *      command_begin_browsing
              Enter stack browsing mode.

       *      command_begin_constant
              Begin entry of a physical constant.

       *      command_begin_variable
              Begin entry of a variable name.

       *      command_bin
              Set the base of exact integer representation to 2 (binary).

       *      command_clear
              Clear all elements from the stack.

       *      command_cycle_base
              Cycle  the base of exact integer 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 exact integer 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 exact integer representation to 16 (hexadecimal).

       *      command_oct
              Set the base of exact integer 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.

   EDIT OPERATIONS
       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 exact integer.

       *      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
              exact integer.

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

   BROWSING OPERATIONS
       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.

   ABBREVIATION ENTRY OPERATIONS
       The following list of operations is available only while entering a  function  or  command
       abbreviation,  or  while  entering  a physical constant. 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.

   VARIABLE ENTRY OPERATIONS
       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.

   INTEGER ENTRY OPERATIONS
       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.

SEE ALSO

       orpie(1), orpie-curses-keys(1)

AUTHOR

       This manpage is written by Paul J. Pelzl <pelzlpj@gmail.com>.

configuration file for the Orpie calculato11 April 2014                                ORPIERC(5)