Casio fx-3600P

Datasheet legend
Ab/c: Fractions calculation
AC: Alternating current
BaseN: Number base calculations
Card: Magnetic card storage
Cmem: Continuous memory
Cond: Conditional execution
Const: Scientific constants
Cplx: Complex number arithmetic
DC: Direct current
Eqlib: Equation library
Exp: Exponential/logarithmic functions
Fin: Financial functions
Grph: Graphing capability
Hyp: Hyperbolic functions
Ind: Indirect addressing
Intg: Numerical integration
Jump: Unconditional jump (GOTO)
Lbl: Program labels
LCD: Liquid Crystal Display
LED: Light-Emitting Diode
Li-ion: Lithium-ion rechargeable battery
Lreg: Linear regression (2-variable statistics)
mA: Milliamperes of current
Mtrx: Matrix support
NiCd: Nickel-Cadmium rechargeable battery
NiMH: Nickel-metal-hydrite rechargeable battery
Prnt: Printer
RTC: Real-time clock
Sdev: Standard deviation (1-variable statistics)
Solv: Equation solver
Subr: Subroutine call capability
Symb: Symbolic computing
Tape: Magnetic tape storage
Trig: Trigonometric functions
Units: Unit conversions
VAC: Volts AC
VDC: Volts DC
Years of production: 1981  Display type: Numeric display  
New price:   Display color: Black  
    Display technology: Liquid crystal display 
Size: 5½"×3"×½" Display size: 10+2 digits
Weight: 4 oz    
    Entry method: Algebraic with precedence 
Batteries: 1×"CR-2025" Lithium Advanced functions: Trig Exp Hyp Lreg Intg Ab/c Cmem 
External power:   Memory functions: +/-/×/÷ 
    Programming model: Fully-merged keystroke entry 
Precision: 11 digits Program functions: Cond  
Memories: 7 numbers Program display:  
Program memory: 38 program steps Program editing:  
Chipset:   Forensic result:  

fx3600p.jpg (25211 bytes)I just received this calculator today, a gift from a friend in Hungary (thank you, István!) Battered as it may look, this older Casio machine still works perfectly. Like other lower-end Casio programmable machines of the same vintage, the fx-3600P offers a full complement of scientific functions, but its programming model is very limited. Program storage is limited to 38 program steps. A simple set of conditional instructions allows the program to be restarted from the beginning, but no other control transfer is possible. No facilities are provided for reviewing or editing programs.

The use of conditional instructions is neatly demonstrated by the following simple implementation of the factorial:


Not too long ago, I thought that 38 program steps and a limited branching capability make this calculator inadequate for a problem as complex as my favorite programming example, the Gamma function. But then I received an e-mail from Herman van Elburg who pointed out that this calculator offers full memory arithmetic (all four functions) on its six K-registers; moreover, the operations are fully merged (i.e., Kin × 6 uses only one step in program memory.) Herman quickly followed up with another e-mail, a working implementation of the incomplete Gamma function, and a pretty good one at that! Unlike the algorithms I used for the incomplete Gamma function elsewhere, Herman's even works for negative arguments. Needless to say, I am suitably amazed.

Herman's program is reproduced below. To use the program, clear all registers (INV KAC; needed only when the program is run for the first time), enter the integration limit, hit INV x<->y, enter the argument, and hit P1. The result should usually appear within a minute or so. Choosing a high enough integration limit closely approximates the Gamma function; Herman reports that in integration limit of 1.5z+25 on the fx-3600P provides suitably accurate results.

1   Kin 5       first pass: init z next passes: not needed
2 X<->Y INV Kin  
3 Kin 6   first pass: init x next passes: store 0 (zero)
4 1   (the loop below is only functional during 'next passes')
5 Kin + 1 Kin + 1 inc(z)
6 Kout 1   recall (z+n)
7 Kin ÷ 3 Kin ÷ 3  
8 Kout 2   recall n
9 Kin × 3    
10 Kout 3   recall next summation term
11 +    
12 Kout 4   old sum
13 -    
14 X<->K 4 INV Kout 4 put new sum in K4
15 =    
16 x>0 INV 7 loop up if sum has changed...
17 +/-    
18 x>0 INV 7 ... same for negative gammas
19 X<->K 6 INV Kout 6 swap 0 with x (first pass) or 0 (second pass)
20 Kin 2   store x (first pass) or 0 (second pass)
21 xy INV × z^ (first pass) or 0^(unimportant)(2nd pass)
22 Kout 4   recall 0 (first pass) or gamma(z) (second pass)
23 X<->K 5 INV Kout 5 recall z (first pass) or store gamma(z) in K5 (second pass)
24 Kin 1   store z in K1
25 ÷    
26 Kout 2   divide by exp(x)...
27 ex INV ln ...
28 ÷   divide by z...
29 Kout 1   ...
30 =   first summation term done (1st pass) or Zero (second pass)
31 Kin 3   store first term in term memory (K3) (2nd pass: zero)
32 Kin 4   store first term or 0 (2nd pass) in summation memory (K4)
33 x2 INV +/- square to make negative terms (for half of z<0) positive
34 x>0 INV 7 loop to beginning to calculate gamma, continue if gamma done
35 Kout 5   recall gamma(x,z)
36 Min   store gamma(x,z) in memory.