Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ORPIERC(5)	 configuration file for	the Orpie calculator	    ORPIERC(5)

NAME
       orpierc is the configuration textfile for the orpie(1) console calcula-
       tor.

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

       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 rep-
       resent Control or Meta (Alt) modifiers,	respectively;  note  that  the
       backslash must be doubled. A number of special keys lack	single-charac-
       ter 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 identi-
       fier syntax may not be adequate to describe every keypress. As a	 work-
       around, 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 en-
       try modes (functions, commands,	editing	 operations,  etc.).  The  key
       identifiers  should be defined using the	syntax described in the	previ-
       ous 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 oper-
       ations may be found in the CALCULATOR OPERATIONS	section.   The	opera-
       tion  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	opera-
       tion abbreviations should be quoted strings, as described in the	previ-
       ous 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 loga-
       rithm 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	 infi-
       nite 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	previ-
	      ously-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  con-
       stant  symbol and definition must be quoted strings. The	constant defi-
       nition should be	a numeric constant followed by	a  units  string  e.g.
       "1.60217733e-19_C".  All	units used in the constant definition must al-
       ready 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  sig-
	      nificant 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 CRE-
       ATING OPERATION ABBREVIATIONS.  The following is	a list of every	avail-
       able operation.

   FUNCTIONS
       The  following  operations are functions--that is, they will consume at
       least one argument from the stack. Orpie	will generally abort the  com-
       putation	 and provide an	informative error message if a function	cannot
       be successfully applied (for example, if	you try	to compute the	trans-
       pose 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 radi-
	      ans, 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 radi-
	      ans, 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 radi-
	      ans, depending on	the angle mode of the calculator.

       *      function_atanh
	      Compute the inverse hyperbolic tangent of	the  last  stack  ele-
	      ment.

       *      function_binomial_coeff
	      Compute  the binomial coefficient	(``n choose k'') formed	by the
	      last two stack elements. If these	arguments are real, the	 coef-
	      ficient 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  op-
	      eration.

       *      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,  de-
	      pending 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 ele-
	      ment.

       *      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  ar-
	      gument, 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	facto-
	      rial 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 ele-
	      ments. 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  ele-
	      ments. 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 ma-
	      trix, returning a	1xM matrix as a	result.

       *      function_minimum
	      Find the minimum values of each of the columns of	a real NxM ma-
	      trix, 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 ap-
	      proximation to the log of	the gamma function, and	therefore  the
	      result  is  subject  to rounding errors. For exact integer argu-
	      ments, 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,  de-
	      pending 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 decompo-
	      sition  method.	This  function	is recommended over explicitly
	      computing	the inverse, especially	when  solving  linear  systems
	      with  relatively	large dimension	or with	poorly conditioned ma-
	      trices.

       *      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  re-
	      sult. (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, re-
	      turning 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, de-
	      pending 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 re-
	      sult. (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	inter-
       face 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 com-
	      monly 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 (hexadeci-
	      mal).

       *      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 oper-
       ations 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 ma-
	      trix.

       *      edit_minus
	      Enter a minus sign in input.

       *      edit_scientific_notation_base
	      Begin entering the scientific notation exponent of a  real  num-
	      ber, 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-inclu-
	      sive). (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 edi-
	      tor.

       *      browse_edit
	      Edit the currently selected stack	element	using an external edi-
	      tor.

   ABBREVIATION	ENTRY OPERATIONS
       The  following  list  of	 operations is available only while entering a
       function	or command abbreviation, or while  entering  a	physical  con-
       stant.  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 vari-
       ables, 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 11lAprilo2014			    ORPIERC(5)

NAME | INTRODUCTION | ORPIERC SYNTAX | CONFIGURATION VARIABLES | CALCULATOR OPERATIONS | SEE ALSO | AUTHOR

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=orpierc&sektion=5&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help