Keyboard mapping:				right function keys:
						(not implemented yet)
0    - 0	f    - f			1     2     3
1    - 1	g    - g			4     5     6
2    - 2	e    - EEX			7     8     9
3    - 3	c    - CHS			0     .     CHS
4    - 4	<sp> - ENTER 			ENTER +     -
5    - 5	<nl> - ENTER
6    - 6	,    - ENTER
7    - 7	<del>- backarrow		(note that the first
8    - 8	<bs> - backarrow		four rows match the
9    - 9	^U   - CLX			keyboard layout)
.    - .	^W   - CLX
+    - +	<    - <<
-    - -	>    - >>
*    - x	&    - AND
/    - /	|    - OR
s    - STO	^    - XOR
r    - RCL	~    - NOT
x    - x<->y	?    - this list
k    - K



common functions:

stats:	r2 = n		rect.	polar		%   x=x*y*100
r3 = x	r4 = x**2	x	r		d%  x=(x-y)/y*100
r5 = y	r6 = y**2	y	theta
r7 = xy

------------------------------------------------------------------------

This calculator is loosely based on the HP-11 and HP-16 calculators,
with some refinements and some deletions.  Most notable of the
deletions is the fact that the calculator is not programmable.  Most
notable of the additions is higher precision.

The calculator uses double-precision floating point numbers
internally.  Numbers can range from approximately plus or minus
1.7e308.  The GET and PUT function keys work with the accumulator, so
that values may be put into the calculator from other sunview windows
and results of calculations may be pasted into other sunview windows.

The calculator can perform calculations on full floating point numbers
in binary, octal, decimal or hex.  For instance, pi in hexadecimal is
3.243f6a89, or 11.001001000 in binary.  Logical functions truncate
their results to a 32-bit positive integer.

Functions may be invoked in one of several ways.  The key icons are
actually split into three parts, so that any part of any key may be
selected by the mouse (this gives an effective 117 keys).  Not all keys
are currently implemented.  Selecting the 'f' or 'g' keys will force
the next keystroke to use the upper or lower portion of the key
respectively.

Also, many calculator functions have been mapped to keyboard keys.  For
most calculations it is sufficient to type the majority of functions
and use the mouse only sparingly.  The 'f' and 'g' keys are most useful
when typing at the keyboard; for instance, the sequence to set the
number of displayed digits to 5 is 'f75'.

The 'CONV' and 'PHYS' keys serve to recall conversion factors and
physical constants respectively.  These two keys have pop-up menus
associated with them.  These menus contain lists of constants.  When
you select a constant from the menu, it is entered into the
calculator's display.  If you select the 'CONV' or 'PHYS' key with the
left mouse button, the most recently selected constant for that button
will be recalled.

A brief description of the calculator functions follows:  It is assumed
that you are familiar with the use of HP or other RPN calculators.

The calculator has a four-level stack.  The four levels are labeled x,
y, z and t.  The top level, x, is the number you see in the display.
Also, the entire stack, with x on the bottom, is displayed in small
type on the right.  When you enter a new number, the stack is (usually)
pushed so that x replaces y, y replaces z, z replaces t and t is lost.
When you perform a function that takes two arguments and leaves one
result, the stack is popped.  Register t is replicated during a pop.

Example: entering a new number (5) onto the stack:

		before	after
	t	  1	  2
	z	  2	  3
	y	  3	  4
	x	  4	  5

Example: popping the stack:

		before	after
	t	  2	  2
	z	  3	  2
	y	  4	  3
	x	  5	  4

The digit keys are used for numeric entry.  You can also enter numbers
with the 'pi' key, by recalling one from a memory register or by
selecting a number on the suntools screen, putting it on the shelf and
using the 'get' key when the cursor is in the calculator window.  In
fact, any sequence of keystrokes that are mapped to the keyboard can be
pasted into the calculator.  For example, pasting this string into
the calculator "355 113/g33/f6" will calculate tan(deg(355/113)/3).

Some functions, such as add and subtract, operate on two numbers (X and Y).
X and Y are both popped off the stack, to be replaced by the result of
the operation.

Example: using the '+' key:

		before	after
	t	  1	  1
	z	  2	  1
	y	  3	  2
	x	  4	  7

Other functions, such as 1/X, operate on a single number (X).  X is
replaced by the result of the operation and the stack is unchanged.

Example: using the '1/X' key:

		before	after
	t	  1	  1
	z	  2	  2
	y	  3	  3
	x	  4	  .25

The keys, and what they do:

    Data Entry:

	EEX     begins exponent entry.  If no mantissa has been entered
		yet, a mantissa of 1.0 is assumed.

	CHS	changes the sign of the number or exponent being entered.

	ENTER   key enters a number onto the stack.

	pi	enters pi into X

	CLX	clears X

	<-      The backarrow key deletes digits during numeric entry.
		When a result is being displayed, the backarrow key
		functions the same as CLX (clear x) key.

	prfx	clear prefix.  "undoes" a press of the f or g keys.

	STK	clears the stack.

	REG     clears all registers.

	X<>Y	swap X and Y

	Rv	roll stack down.

			before	after
			  1	  2
			  2	  3
			  3	  4
			  4	  1

	R^	roll stack up.

	lstX	Recalls the last X value that was entered.

	K       places the number in x into y, z and t.  The number
		previously in y is moved to x.

			before	after
			  1	  4
			  2	  4
			  3	  4
			  4	  3

		This is for repetative functions with a constant.

    Display Control:

	FIX n   sets the calculator to n-digit fixed-point display.
		The calculator will revert to n-digit scientific
		notation when it has to.

	SCI n	sets n-digit scientific notation.

	ENG n	sets n-digit engineering notation.

	e       key toggles the display of the letter 'e' in front of
		the exponent part of numbers in scientific notation.

	0x      toggles the display of a leading '0' or '0x' in front
		of octal and hex numbers.  These functions can be very
		useful when pasting calculation results into C source
		code.

	BIN	display in binary
	OCT	display in octal
	DEC	display in decimal
	HEX	display in hex

	SHRINK	calculator becomes tiny; showing only the OCT, DEC and
		HEX keys.  Handy for when you're only using the calculator
		for conversions.

	GROW	Restores calculator to it's normal size.

    Arithmatic:

	+	add X to Y
	-	subtract X from Y
	x	multiply X and Y
	/	divide X into Y

	<sqrt>	sqrt(X)
	 2
	X	X**2

	ln	natural log of X
	 x
	e	e**x

	log	base 10 log of X
	  x
	10	10**x
	 x
	Y	Y**X

	1/X	1/X

	int	integer part of X
	frac	fraction part of X

	X!	X factorial

	->DEG	convert X from radians to degrees
	->RAD	convert X from degrees to radians
	->HMS	convert X from hours to hours.mmss
	->H	convert X from hours.mmss to hours

	->R     converts from polar to rectangular coordinates.
		r,theta becomes x,y.

	->P	converts from rectangular to polar.  x,y becomes r,theta.

	%       calculates percentages;  x,y becomes x*y*100,y.
		In other words, find out what X percent of Y is.  Note
		that y is left unchanged on the stack in this case.

	Delta-%	calculates percent differences; X,Y becomes (X-Y)/Y*100.
		In other words, find out what percent change X is from Y.

	ABS	|X|

	SIN	sin(X)
	COS	cos(X)
	TAN	tan(X)
	SIN-1	asin(X)
	COS-1	acos(X)
	TAN-1	atan(X)

	NOT	bitwise "not" of X
	&32	truncate to 32 bits, i.e. X & 0xffffffff
	&16	truncate to 16 bits, i.e. X & 0xffff
	>>	X >> 1
	<<	X << 1
	>>16	X >> 16
	AND	X & Y
	OR	X | Y
	XOR	X ^ Y
	XNOR	~(X^Y)

	HYP	not implemented yet


    Memory:

	STO n   store X into memory 'n'.  There are ten memories, from
		0 to 9.  The sequences STO+n, STO-n, STO*n and STO/n
		perform the indicated operation on the number in the
		addressed memory.  For example, STO/5 divides the
		number in register 5 by the number in the display.  The
		number in the display is not affected.

	RCL n	recall memory 'n' into X.

    Statistical functions:

	C-sigma	clears the registers used by statistical calculations.
	Sigma+	enters x and y into the statistical registers.
	Sigma-	removes x and y from the statistical registers.
	_
	X       calculates the means of all the x and y values and
		places them on the stack.

	S	(below .) calculates the standard deviations and
		places them on the stack.

	L.R.    performs a linear regression on the x,y data, leaving
		the y-intercept in the x register and the slope in the
		y register.
	_
	Y,r     performs a linear estimate on the value in the x
		register and returns the extimated y value in the x
		register.  The correlation coefficient is returned in
		the y register.

	Py,x	Permutations.  Returns the number of different ways you
		can get X objects from a pool of Y objects.  Y!/(Y-X)!

	Cy,x	Combinations.  Same as Py,x, but you don't care what order
		the X objects come in.  Y! / ((Y-X)! * X!).  For instance,
		to find out how many possible 5-card hands there are in
		a 52-card deck, enter "52 ENTER 5 Cy,x"
