compucorp 322g scientist

this machine was one of several 320 series models made by the computer design corporation (CDC) in 1973 and marketed under the sumlock name.

a large and rather striking unit with a bright orange display and click buttons. the 322 and 324 are programmable whilst the 320 is not but supports the same scientific operations.

the unit comes in a carry case with a psu. its portable and runs off 4 D cell batteries (yes, D cell!).

although somewhat quirky in appearance, functionally it it very good. accuracy is to 13 places and make it a lot more accurate than most machines, even today (see torture test). some buttons like sin/cos perform both operations simultaneously (ie sin and cos). the display shows sin(x) and you retrieve cos(x) by pressing 2nd func. the opposite of the modern way of pressing 2nd beforehand.

unusually, trig functions are either in degrees or gradians, no native radian mode is offered. however a degrees to and from radians keyboard function is available.

well engineered minor details make for shortcuts. it has constant on all 4 basic ops. 10 memories which can be used with the basic ops to perform sto+, sto-, sto*, st/ and (unusually) rcl+, rcl-, rcl* and rcl/. even a^x can be a constant. note that a^x is the general x^y function (non-integers allowed) a can even be negative if x is integral, which is cool. brackets nest to two levels. numerical exponent ranges to +/-100 as is usual, but this was novel in 1973.

here's a cool shortcut to perform sinh(x);  e^x - 1/x / 2 =. it appears that  the display doubles as input by default saving sto/rcl. similar cosh(x) is e^x + 1/x / 2 =.


if you thought that was cool, now read about programming...

the 322 has an 80 step program memory. a switch selects either run mode or load mode. in load mode, keys are recorded as a program sequence. there are no apparent jumps or loops. but there are tricks. the 324 model has 2x80 step program memory. another switch is present to select the program bank. two banks might sound crazy, but it actually works amazing well.

for example, the manual gives a program split over two banks to compute standard deviations. the first bank hosts a program that simply accumulates n, sum(x) and sum(x^2) in memories. the second bank contains a program to use these memories to compute the standard deviation using the familiar textbook formula. the trick here is that no loops are required. you run bank1 over each data entry, switch to bank 2 and execute.

here's a program to compute factorials; ST 1 ST * 2 1 ST - 1 RCL 1 1/x RCL 1. here's what you do. preload 1 into memory 2 (1 ST 2), type in your number (eg 6), and hit start. the trick here is that the program automatically runs off the end back to the start (a loop!) and the 1/x operation causes an error when n decrements to zero. this halts execution leaving n! in memory 2.

if you thought that was a taunt, here's one to find the maximum value of the polynomial y = ax^2 + bx + c

  1. load a, b and c into memories 1, 2 and 3 (eg -2, 3 and 4)
  2. load program,
    RCL 1 * RCL 9 + RCL 2 * RCL 9 + RCL 3 = EXCH 8 ST 7 RCL 8 RCL - 7 sqrt RCL 0 ST + 9
  3. store a starting value for x in memory 9 (eg -5)
  4. store a dx increment in memory 0 (eg 0.25)
  5. hit start and wait for the display to show E---- (ie error)
  6. reset and RCL 9
  7. if your starting value for x is displayed, press start again and wait for an error.
  8. reset RCL 7. this displays the maximum y value (ymax)
  9. for x at ymax hit, RCL 8 - RCl 0 = 

the program simply searches the y values, incrementing x by the given dx (eg 0.25). the tricks here are to use the end to start program loop, like in the factorial program, and to use sqrt as a synthetic conditional jump. this is done by calculating sqrt(y - lastY). when y moves past the maximum, the argument to sqrt will be negative and it will error halting the program at the right place + dx, subject to increment resolution.

another program from the manual shows how, using the 324's two banks, quadratic equations can be solved for both real and complex roots. basically, the first program bank attempts the standard textbook roots for reals (ie (-b+/-sqrt(b^2-4ac)/2a) and if this causes an error, you switch to the second bank which then assumes complex roots and evaluates them for display. altogether a simple, but effective idea.

here are some pictures of the insides. the top removes showing the keyboard layout.
the keyboard lifts away on a ribbon cable revealing the first of three stacked circuit boards.


this is the top of three stacked boards. they can all be removed for servicing and repair.