HP 15c Manual

							 Appendix B: Stack Lift and the LAST X Register 211 
 
 
T y  y  y  y 
Z x  x  x  x 
Y 4.0000  53.1301  53.1301  53.1301 
X 3  5.0000  0.0000  7 
Keys: |:               |` 7  
   Stack 
enabled. 
 Stack 
disabled. 
 No stack 
lift. 
Imaginary  X-Register. All  enabling  functions  provide  for  a  zero  to  be 
placed  in  the  imaginary  X-register when  the  next  number  is  keyed  or 
recalled into the display. 
Neutral Operations 
Stack  Lift. Some  operations,  like •,  are  neutral;  that  is,  they  do  not 
alter  the  previous  status of  the stack  lift.  Thus,  if  you  disable  the  stack  lift 
by pressing v, then press ´ • n and key in a new number, that 
number  will  write  over  the  number  in  the  X-register  and  the  stack  will  not 
lift.  Similarly,  if  you  have  previously  enabled  the  stack  lift  by  executing, 
say ¤,  then  execute  a • instruction  followed  by a  digit  entry 
sequence, the stack will lift.* 
The following operations are neutral on the HP-15C: 
• g U ¦ 
i t “ nnn CLEAR u ¥ 
^ ‚ CLEAR Q %†=
D Â CLEAR ∑  
R W ©  
Imaginary X-Register. The above operations are also neutral with respect 
to clearing the imaginary X-register. 
                                                           * All digit entry functions are also neutral during digit entry. After digit entry termination, “ and ‛ are lift enabling, − is disabling. † That is, the ´ % sequence used to view the imaginary X-register.  
						

							212 Appendix B: Stack Lift and the LAST X Register 
 
LAST X Register 
The following operations save x in the LAST X register: 
 
- x H \ k 
+ [ H ] ∆ 
* \ h : 
÷ ] À ; 
a , d p* 
q { r c* 
‘ / N z 
& P[  w 
∕ P\ o j 
! P] @ > 5 through 9 
¤ H[ Y f† 
 
                                                           * Except when used as a matrix function. † f uses the LAST X register in a special way, as described in appendix E.  
						

							 
213 
Appendix C 
Memory Allocation 
The Memory Space 
Storage registers, program lines, and advanced function execution* all draw 
on a common memory space in the HP-15C. The availability of memory for 
a  specific  purpose  depends  on  the  current allocation of  memory,  as  well  as 
on the total memory capacity of the calculator. 
Registers 
Memory  space  in  the  HP-15C  is  allocated  on  the  basis  of registers. This 
space is partitioned into two pools, which strictly define how a register may 
be used. There is always a combined total of 67 registers in these two pools. 
 The data  storage  pool contains  registers  which may be  used only 
for  data  storage.  At  power-up  (Continuous  Memory  reset)  this 
equals 21 registers. This pool contains at  least three registers at  all 
times: RI, R0, and R1. 
 The common  pool contains  uncommitted  registers  available  for 
allocation  to  programming,  matrices,  the  imaginary  stack,  and 
_ and f operation. At power-up there are 46 uncommitted 
registers in the common pool. 
                                                           * The  use  of _, f,  Complex  mode,  or  matrices  temporarily  requires  extra  memory  space,  as explained later in this appendix.  
						

							214 Appendix C: Memory Allocation 
 
 
Total  allocatable memory: 64  registers,  numbered  R2 through  R65.  
[(dd – 1)  + uu + pp + (matrix  elements)  +  (imaginary  stack)  +  (_ 
and f)] =  64.  For  memory  allocation  and  indirect  addressing,  data 
registers R.0 through R.9 are referred to as R10 through R19.   
						

							 Appendix C: Memory Allocation 215 
 
Memory Status (W) 
To  view  the  current  memory  configuration  of  the  calculator,  press | 
W (memory),  holding W to  retain  the  display.* The  display  will  be 
four numbers, 
dd    uu   pp-b 
where: 
dd = the  number  of  the highest-numbered register  in  the  data  storage 
pool (making the total number of data registers dd + 2 because of R0 
and RI); 
uu = the number of uncommitted registers in the common pool; 
pp = the number of registers containing program instructions; and 
b   = the number of bytes left before uu is decremented (to supply seven 
more bytes of program memory) and pp is incremented. 
The initial status of the HP-15C at power-up is: 
19    46    0-0 
The  movable  boundary  between  the  data  storage  and  common  pools  is 
always between Rdd and Rdd + 1. 
Memory Reallocation 
There  are  67  registers  in  memory,  worth  seven  bytes  each.  Sixty-four  of 
these registers (R2 to  R65) are  interconvertible  between the  data  storage  and 
common pools. 
The m % Function 
If  you  should  require  more  common  space (as  for  programming)  or  more 
data  storage  space  (but  not  both  simultaneously!),  you  can  make  the 
necessary register reallocation using m %.† The procedure is: 
 
                                                           * MEM is nonprogrammable. † m (dimension)  is  so  called  because  it  is  also  used  (with A through E or V)  to  dimension matrices. Above, however, it is used (with %) to ―dimension‖ the size of the data storage pool.  
						

							216 Appendix C: Memory Allocation 
 
1. Place dd,  the number  of  the  highest  data  storage  register  you want 
allocated, into  the  display.  1dd65.  The  number  of  registers  in  the 
uncommitted  pool  (and  therefore potentially available  for 
programming) will be (65 – dd). 
2. Press ´ m %. 
There are two ways to review your allocation: 
 Press lm % to recall into the stack the number of the 
highest-allocated data storage register, dd. (Programmable.) 
 Press | W (as explained above) to view a more complete 
memory status (dd uu pp-b). 
Keystrokes Display  
(assuming a cleared program memory)* 
1 ´ m % 1.0000 R1, R0, and RI 
allocated for data storage. Sixty-
four registers are uncommitted; 
none contain program instructions. 
| W (hold) 1 64  0-0 
19 ´ m 
% 
19.0000 R19 (R.9) is the highest-numbered 
data storage register. Forty-six 
registers left in the common pool. l m % 19.0000 
Restrictions on Reallocation 
Continuous  Memory  will  maintain  the  configuration  you  allocate  until  a 
new m % is  executed  or  Continuous  Memory  is  reset.  If  you  try  to 
allocate a number less than 1, dd = 1. If you try to allocate a number greater 
than 65, Error 10 results. 
                                                           * If program  memory is not cleared, the number of uncommitted registers (uu) is less owing to allocation of registers to program memory (pp). Therefore, pp would be >0 and b would vary.  
						

							 Appendix C: Memory Allocation 217 
 
When converting registers, note that: 
 You can convert registers from the common pool only if they are 
uncommitted. If, for example, you try to convert registers which 
contain program instructions, you will get an Error 10 (insufficient 
memory). 
 You can convert occupied registers from the data storage pool, 
causing a loss of stored data. An Error 3 results if you try to 
address a lost – that is, nonexistent – register. Therefore, it is 
good practice to store data in the lowest-numbered registers first, 
as these are the last to be converted. 
 
Program Memory 
As  mentioned  before,  each  register  consists  of  seven  bytes  of  memory. 
Program  instructions  use  one  or  two  bytes  of  memory.  Most  program  lines 
use one byte; those using two bytes are listed on page 218. 
The maximum programming  capacity  of  the  HP-15C  is  448  program  bytes 
(64 convertible  registers at  seven bytes per register). At power-up,  memory 
can  hold  up  to  322  program  bytes  (46  allocated  registers  at  seven  bytes 
per register). 
Automatic Program Memory Reallocation 
Within  the  common  register  pool,  program  memory  will  automatically 
expand  as  needed.  One uncommitted  register  at  a  time,  starting  with  the 
highest-numbered  register  available,  will  be  allocated  to  seven  bytes  of 
program memory. 
Conversion of Uncommitted Registers to Program Memory 
   
						

							218 Appendix C: Memory Allocation 
 
Your  very  first  program  instruction  will  commit  R65 (all  seven  bytes)  from 
an  uncommitted  register  to  a  program  register.  Your  eighth  program 
instruction commits  R64, and so on, until the  boundary of the  common pool 
is encountered. Registers from the data storage pool (at power-up, this is R19 
and  below)  are  not  available  for  program  memory  without  reallocating 
registers using m %. 
Two-Byte Program Instructions 
The  following  instructions  are  the  only  ones  which  require  two bytes  of 
calculator memory. (All others require only one byte.) 
´ b . label ´ > {0 to 9} 
t . label ´ X {2 to 9, .0 to .9} 
|  (n or V) ´ e {2 to 9, .0 to .9} 
|F (n or V) ´ I {2 to 9, .0 to .9} 
| ? (n or V) O {+, -, *, ÷} 
´ • (n or V) l {+, -, *, ÷} 
´ i (n or V) O > {A to E} 
´ ^ (n or V) O {A to E, %} in User 
mode 
´ _ l {A to E, %} in User 
mode 
´ f O | % 
 l | % 
Memory Requirements for the Advanced Functions 
The four advanced functions require temporary register space from the 
common register pool. 
Function Registers Needed 
_  
f  
 
5 
23 
 
 23 if executed 
together 
Complex Stack 5 
Matrices 1 per matrix element  
						

							 Appendix C: Memory Allocation 219 
 
For _ and f,  allocation  and  deallocation  of  the  required  register 
space  takes  place  automatically.* Memory  is  thereby  allocated  only  for  the 
duration of these operations. 
Space  for  the  imaginary  stack  is  allocated  whenever ´ V, ´ 
}, or | F 8 is pressed. The imaginary stack is deallocated when 
 8 is executed. 
Space  for  matrix  registers  is  not  allocated until  you  dimension  it (using 
m).  Reallocation  takes  place  when  you  redimension  a  matrix. > 
0 dimensions all matrices to 0  0. 
 
                                                           * If  you  should  interrupt  a _ or f routine in  progress by  pressing  a  key,  you could  deallocate  its registers by pressing |n or ´ CLEAR M in Run mode.  
						

							 
220 
Appendix D 
A Detailed Look at _ 
Section  13,  Finding  the  Roots  of  an  Equation,  includes  the  basic 
information  needed  for  the  effective  use  of  the _ algorithm.  This 
appendix  presents  more  advanced,  supplemental  considerations  regarding 
_. 
How _ Works 
You  will  be  able  to  use _ most  effectively  by  having  a  basic 
understanding of how the algorithm works. 
In  the  process  of  searching  for  a  zero  of  the 
specified  function,  the  algorithm  uses  the 
value  of  the  function  at  two  or  three 
previous estimates to approximate  the  shape 
of  the  function’s  graph.  The  algorithm  uses 
this  shape  to  intelligently  ―predict‖  a  new 
estimate  where  the  graph  might  cross  the x-
axis.  The  function  subroutine  is  then 
executed,  computing  the  value  of  the 
function at the new estimate. This procedure is performed repeatedly by the 
_ algorithm. 
If  any  two  estimates  yield  function  values 
with  opposite  signs,  the  algorithm  presumes 
that  the  functions  graph  must  cross  the x-
axis  in  at  least  one  place  in  the  interval 
between  these  estimates.  The  interval  is 
systematically  narrowed  until  a  root  of  the 
equation is found. 
A  root  is  successfully  found  either  if  the 
computed  function  value  is  equal  to  zero  or 
if  two estimates,  differing  by  one  unit  in  their  last  significant  digit,  give 
function  values  having  opposite  signs.  In  this  case,  execution  stops  and  the 
estimate is displayed.