HP 15c Manual

							 Section 2: Numeric Functions 31 
 
Rectangular Conversion. Pressing ´; (rectangular) converts a set of 
polar coordinates (magnitude r angle θ) into rectangular coordinates (x, y). θ 
must  be  entered  first  then r. Upon  executing ´;, x will  be  displayed 
first; press ® to display y. 
 
 
 
 
 
 
 
 
Keystrokes Display  
|D  Set to Degrees mode (no annunciator). 
5 v 5.0000 y-value. 
10 10 x-value. 
|: 11.1803 r. 
® 26.5651 θ; rectangular coordinates converted to 
polar coordinates. 
30 v 30.0000 θ. 
12 12 r. 
´; 10.3923 x-value. 
® 6.0000 y-value. Polar coordinates converted to 
rectangular coordinates.   
						

							 
32 
Section 3 
The Automatic Memory Stack, 
LAST X, and Data Storage 
The Automatic Memory Stack 
and Stack Manipulation 
HP  operating  logic  is  based  on  a  mathematical  logic  known  as ―Polish 
Notation,‖  developed  by  the  noted  Polish  logician  Jan Łukasiewicz 
(Wookashyeveech) (1878-1956). Conventional algebraic notation places the 
algebraic  operators between the  relevant  numbers  or  variables  when 
evaluating  algebraic  expressions. Łukasiewicz’s  notation  specifies  the 
operators before the  variables. For  optimal  efficiency  of  calculator  use,  HP 
applied  the  convention  of  specifying  (entering)  the  operators after 
specifying  (entering)  the  variable(s).  Hence  the  term  Reverse  Polish 
Notation (RPN). 
The  HP-15C  uses  RPN  to  solve  complicated  calculations  in a 
straightforward  manner,  without  parentheses  or  punctuation.  It  does  so  by 
automatically  retaining  and  returning  intermediate  results.  This  system  is 
implemented  through  the  automatic  memory  stack and  the v key, 
minimizing total keystrokes. 
The Automatic 
Memory Stack Registers 
T 0.0000  
Z 0.0000  
Y 0.0000  
X 0.0000 Always displayed 
When  the  HP-15C  is  in  Run  mode  (no PRGM annunciator  displayed),  the 
number that appears in the display is the number in the X-register.  
						

							Section 3: The Memory Stack, LAST X, and Data Storage 33 
 
Any  number  that  is  keyed  in  or  results  from  the  execution  of  a  numeric 
function  is  placed  into  the  display  (X-register).  This  action  will  cause 
numbers  already  in  the  stack  to  lift,  remain  in  the  same  register,  or  drop, 
depending  upon  both  the  immediately  preceding  and  the  current  operation. 
Numbers in the stack are stored on a last-in, first-out basis. The three stacks 
drawn  below  illustrate  the  three  types  of  stack  movement.  Assume x,  y,  z, 
and t represent any numbers which may be in the stack. 
Stack Lift No Stack Lift or Drop 
   lost      
T t  z  T t  t 
Z z  y  Z z  z 
Y y  x  Y y  y 
X x  π  X x   
Keys:  |$     ¤  
 
 Stack Drop 
T t  t 
Z z  t 
Y y  z 
X x  x + y 
Keys:      + 
Notice  the  number  in  the  T-register  remains  there  when  the  stack  drops, 
allowing this number to be used repetitively as an arithmetic constant. 
Stack Manipulation Functions 
v. Pressing v separates  two  numbers  keyed  in  one  after  the 
other. It does so by lifting the stack and copying the number in the display 
(X-register)  into  the  Y-register.  The  next  number  entered  then  writes  over 
the value in the X-register; there is no stack lift. The example below shows 
what  happens  as  the  stack  is filled  with  the  numbers  1,  2,  3,  4.  (The x  
						

							34 Section 3: The Memory Stack, LAST X, and Data Storage 
 
shading indicates  that  the  contents  of  that  register  will  be  written  over 
when the next number is keyed in or recalled.) 
 
   lost  lost    lost 
T t  z  y  y  x 
Z z  y  x  x  1 
Y y  x  1  1  2 
X x  1  1  2  2 
Keys:  1  v  2  v  
 
     lost   
T x  x  1  1 
Z 1  1  2  2 
Y 2  2  3  3 
X 2  3  3  4 
Keys:  3  v  4  
 
) (roll down), ( (roll up), and ® (X exchange Y). ) and ( 
roll the  contents of the  stack registers up or down one  register (one  value 
moves  between  the  X- and  the  T-register).  No  values  are  lost. ® 
exchanges the numbers in the X- and Y-registers. If the stack were loaded 
with  the  sequence  1,  2,  3,  4,  the  following  shifts  would  result  from 
pressing )) and ®. 
 
T 1  4  1  1 
Z 2  1  2  2 
Y 3  2  3  4 
X 4  3  4  3 
Keys:  )  |
(  ®  
  
						

							Section 3: The Memory Stack, LAST X, and Data Storage 35 
 
The LAST X Register and K 
The  LAST  X  register,  a  separate  memory  register,  preserves  the  value  that 
was  last  in  the  display before  execution  of  a  numeric  operation.* Pressing 
|K (LAST  X) places  a  copy  of  the  contents  of  the  LAST  X  register 
into the display (X-register). For example: 
 
     lost 
T t  t  z 
Z z  z  y 
Y y  y  16 
X 4  16  4 
Keys:  |x  |K  
LAST X: /  4  4 
The K feature  saves  you  from  having  to  re-enter  numbers  you  want  to 
use  again  (as  shown  under  Arithmetic  Calculations  With  Constants,  page 
39).  It  can  also  assist  you in  error  recovery,  such  as  executing  the  wrong 
function or keying in the wrong number. 
For  example,  suppose  you  mistakenly  entered  the  wrong  divisor  in  a  chain 
calculation: 
Keystrokes Display  
287 v 287.0000  
12.9 + 22.2481 Oops! The wrong divisor. 
| K 12.9000 Retrieves from LAST X the last 
entry to the X-register (the 
incorrect divisor) before + 
was executed. 
 
                                                           * Unless that  operation  was ’, S,  or L,  which  don’t  use  or  preserve  the  value  in  the  display  (X-register), but  instead calculate  from data  in the statistics storage  registers (R2 to R7).  For a complete  list of operations which save x in LAST X, refer to appendix B.  
						

							36 Section 3: The Memory Stack, LAST X, and Data Storage 
 
 
Keystrokes  Display  
* 287.0000 Reverses the function that 
produced the wrong answer. 
13.9 + 20.6475 The correct answer. 
Calculator Functions and the Stack 
When  you  want  to  key  in  two  numbers,  one  after  the  other,  you  press 
v between  entries  of  the  numbers.  However,  when  you  want  to  key 
in  a  number  immediately  following  any  function  (including  manipulations 
like )),  you  do  not  need  to  use v.  Why?  Executing  most  HP-15C 
functions has this additional effect: 
• The  automatic  memory  stack  is  lift-enabled that  is,  the  stack  will  lift 
automatically  when  the next number  is  keyed  or  recalled  into  the 
display. 
• Digit entry is terminated, so the next number starts a new entry. 
 
     lost   
T t  t  z  z 
Z z  z  y  z 
Y y  y  2  y 
X 4  2  5  7 
Keys:  ¤  5  +  
There  are  four  functions – v, `, z,  and w – that disable stack 
lift.* They  do not provide  for  the  lifting  of  the  stack  when  the  next  number  is 
keyed  in  or  recalled.  Following  the  execution  of  one  of  these  functions,  a  new 
number will simple write over the currently displayed number instead of causing 
the stack to lift. (Although the stack lifts when v is pressed, it will not lift 
when  the next number  is  keyed  in  or  recalled.  The  operation  of v 
illustrated  on  page  34  shows  how v thus disables  the  stack.)  In  most 
cases,  the  above  effects  will  come  so  naturally  that  you  won’t  even  think 
about them. 
                                                           * − will  also  disable  the  stack  lift if  digit  entry  is  terminated,  making − clear  the  entire  display  like `. Otherwise, it is neutral. For a further discussion of the stack, refer to appendix B.  
						

							Section 3: The Memory Stack, LAST X, and Data Storage 37 
 
 
     lost   
T z  z  z  z 
Z z  z  z  z 
Y y  y  y  y 
X 7  0  6  y6 
Keys:  |`  6  Y  
Order of Entry and the v Key 
An  important  aspect  of  two-number  functions  is  the  positioning  of  the 
numbers in the stack. To execute an arithmetic function, the numbers should 
be  positioned  in  the  stack  in  the  same  way  that  you  would  vertically 
position them on paper. For example: 
98  98  98  98 
-15  +15  x15  15 
As  you  can  see,  the  first  (or  top)  number  would  be  in  the  Y-register,  while 
the  second  (or  bottom)  number  would  be  in  the  X-register.  When  the 
mathematics  operation  is  performed,  the  stack  drops,  leaving  the  result  in 
the  X-register.  Here  is  how  a  subtraction  operation  is  executed  in  the 
calculator: 
 
   lost  lost     
T t  z  y  y  y 
Z z  y  x  x  y 
Y y  x  98  98  x 
X x  98  98  15  83 
Keys:  98  v  15  -  
The same number positioning would be used to add 15 to 98, multiply 98 by 
15, or divide 98 by 15.  
						

							38 Section 3: The Memory Stack, LAST X, and Data Storage 
 
Nested Calculations 
The  automatic  stack  lift  and  stack  drop  make  it  possible  to  do  nested 
calculations  without  using  parentheses  or  storing  intermediate  results.  A 
nested  calculation  is  solved  simply as  a  series  of  one- and  two-number 
operations. 
Almost  every  nested  calculation  you  are  likely  to  encounter  can  be  done 
using  just  the  four  stack  registers.  It  is  usually  wisest  to  begin  the 
calculation  at  the  innermost  number  or  pair  of  parentheses  and  work 
outward (as you would for a  manual calculation). Otherwise, you may need 
to place an intermediate result into a storage register. For example, consider 
the calculation of 
3 [4 + 5 (6 + 7)] : 
Keystrokes Display  
6 v 7 + 13.0000 Intermediate result of  
(6 + 7). 
5 * 65.0000 Intermediate result of  
5 (6 + 7). 
4 + 69.0000 Intermediate result of  
[4 + 5 (6 + 7)]. 
3 * 207.0000 Final result:  
3 [4 + 5 (6 + 7)]. 
The  following  sequence  illustrates  the  stack  manipulation  in  this  example. 
The  stack  automatically drops  after  each  two-number  calculation,  and  then 
lifts when a new number is keyed in. (For simplicity, throughout the rest of 
this handbook we will not show arrows between the stacks.) 
 
T t  z  y  y  y 
Z z  y  x  x  y 
Y y  x  6  6  x 
X x  6  6  7  13 
Keys:  6  v  7  +   
						

							Section 3: The Memory Stack, LAST X, and Data Storage 39 
 
 
T y  y  y  y 
Z y  x  y  x 
Y x  13  x  65 
X 13  5  65  4 
Keys:  5  *  4  
 
T y  y  y  y 
Z x  y  x  y 
Y 65  x  69  x 
X 4  69  3  207 
Keys:  +  3  *  
 
Arithmetic Calculations With Constants 
There  are  three  ways  (without  using  a storage  register)  to  manipulate  the 
memory stack to perform repeated calculations with a constant: 
1. Use the LAST X register. 
2. Load the stack with a constant and operate upon different 
numbers. (Clear the X-register every time you want to change 
the number operated upon)  
3. Load the stack with a constant and operate upon an 
accumulating number. (Do not change the number in the X-
register.) 
LAST  X. Use  your  constant  in  the  X-register  (that  is,  enter  it  second)  so 
that it always will be saved in the LAST X register. Pressing |K will 
retrieve  the  constant  and  place  it  into  the  X-register  (the  display).  This  can 
be done repeatedly.  
						

							40 Section 3: The Memory Stack, LAST X, and Data Storage 
 
Example: Two close stellar neighbors of Earth 
are Rigel  Centaurus (4.3 light-years away) and 
Sirius (8.7 light-years away).  Use the  speed of 
light, c (3.0×108 meters/second,  or  9.5×1015 
meters/year),  to  figure  the  distances  to  these 
stars in meters. (The stack diagrams show only 
one decimal place.) 
 
 
T t  z  y  y 
Z z  y  x  x 
Y y  x  4.3  4.3 
X x  4.3  4.3  9.5   15 
Keys:  4.3  v 9.5 ‛ 15 
LAST X: /  /  /  / 
        
T y  y  y  x 
Z x  y  x  4.1   16 
Y 4.3  x  4.1  16  8.7 
X 9.5   15  4.1   16  8.7  9.5   15 
Keys:  *  8.7 |K 
LAST X: /  9.5   15  9.5   15  9.5   15 
      
T x  x     
Z 4.1   16  x     
Y 8.7  4.1   16  (Rigel Centaurus is 4.1×1016 meters away.) 
(Sirius is 8.3×1016 meters away.)  
X 9.5   15  8.3   16  
Keys:  *   
LAST X: 9.5   15  9.5   15