WANG 452
Version Française 
WikipédiA 
Features  Keyboard  Arithmetic calculations  Scientific calculations  Registers  Programmation  Memory 
It's a surprising programmable calculator

Unfortunately, I never saw nor read more about it. 
The keyboard is divided in 5 zones:

Note  Left accumulator  Right accumulator  Display 

First temporary result  8.9 STORE 43 + 12 ÷= 
+4.325000000000 

That we store on the right  STORE  +4.325000000000 

Second temporary result  52 STORE 4.1 ×= 
+213.2000000000 

Added to the right  +  +217.5250000000 
For the white funtions, SP down and the white key K(x) down 
For the black funtions, SP down and the black key k(x) down 
Note  Left accumulator  Display 

Select white functions  πSTORE 
+3.141592653590 
Calculate the denominator  5 X! 
+120.0000000000 
And divide !  ÷= 
+.0261799387799 
Select black functions  √X 
+.1618021593800 

The WANG 452 gives access to 16 registers. To use them, every of the 16 multipurpose keys represent one register (note the numbers on the labels).
In additon, you must use one of the selectors to indicate what you want to do with the register. The SP must be down except for the Ex function where it must be up.
The functions are the ones you already know for the accumulators:

Ask for an access to my Cloud to get the User's Manual and technical schematics.  His museum can be found here. 
To program, press the LEARN button. The display turns as the one shown right:



Note : when using the left accumulator, you use register 15. For the right accumulator, it's register 14. Then, using "+" on the left accumulator generates the code 0215. RECALL on the right accumulator generates the code 0714. 

Black Function  LOGa(x)  LOG10(x)  LOGe(x)  RAD>DEG  SIN  COS  TAN  √X  a^x  10^x  e^x  DEG>RAD  SIN1  COS1  TAN1  X² 

Codes  1200  1201  1202  1203  1204  1205  1206  1207  1208  1209  1210  1211  1212  1213  1214  1215 
White Function  ×a  π  n, Σx, Σx²  REC>POL  SINh  COSh  TANh  INT  ÷a  X!  x, σ², σ  POL>REC  SINh1  COSh1  TANh1  ABS 

Codes  1300  1301  1302  1303  1304  1305  1306  1307  1308  1309  1310  1311  1312  1313  1314  1315 
Function  Codes  Note 

LABEL + key  0900 + xxxx  Sets a label, the key is the one you want. 
LABEL + f(x)nn  0900 + 10nn  Particular case: marks the beginning of a user defined function that you can call with one of the 16 keys with selector f(x) down. Function must end with RETURN. 
LABEL + F(x)nn  0900 + 11nn  Particular case: marks the beginning of a user defined function that you can call with one of the 16 keys with selector F(x) down. Function must end with RETURN. 

Access to user defined functions. 

The two steps skipped are commonly used for a jump instruction GOTO + label / Goto + offset.
But you can imagine any other usage, for example recall a register that could be the result and stop: 0714 recall right accumulator 0903 stop program. 

How to get some special codes:

0000 0002 2 0001 0000 0 0002 0614 STORE right right accumulator = 20, will be the counter 0003 0002 2 0004 0615 STORE left left accumulator = 2, starting value 0005 0715 RECALL left (start of 1st loop) 0006 1207 √X 0007 0615 STORE left replace left with its square root. 0008 0001 1 0009 0314  right Decrement counter 0010 0804 SKIP IF X=0 it's done when reaching zero 0011 1505 1510 GOTO 6 else, back to start of loop 0013 0002 2 0014 0000 0 0015 0614 STORE right counter = 20. 0016 0715 RECALL left (start of 2nd loop) 0017 0415 ×= left replace left with its square 0018 0001 1 0019 0314  right Decrement counter 0020 0804 SKIP IF X=0 it's done when reaching zero 0021 1505 1511 GOTO 5 else, back to start of loop 0023 0715 RECALL left display final value 0024 0903 STOP stop program 0025 0914 END Optional mark 
Again the famous Hebdogiciel test. Starting from 2, take 20 times the square root. Then 20 times the square. Compare to 2. To run the program, SET P.C. 0000 (back to first step) Then GO key. Here, the result is quite good! Note for backward jumps : on one byte, 6 equals 2566 = 250 = FA = (15)(10). 
0000 0900 1000 LABEL f(x) 00 start of function 00 0002 0600 STORE 0 bound a in register 0 0003 0915 RETURN 0004 0900 1001 LABEL f(x) 01 start of function 01 0006 0601 STORE 1 bound b in register 1 0007 0915 RETURN 0008 0900 1002 LABEL f(x) 02 start of function 02 0010 0605 STORE 5 n in register 5 0011 0701 RECALL 1 0012 0615 STORE left 0013 0700 RECALL 0 0014 0603 STORE 3 init register 3 with x=a 0015 0315  left 0016 0705 RECALL 5 0017 0515 ÷= left compute h=(ba)/n 0018 0602 STORE 2 h in register 2 0019 0000 0 0020 0604 STORE 4 reset integral 0021 0703 RECALL 3 start of loop: recall x 0022 1015 CALL f(x) 15 compute f(x) 0023 0204 + 4 add to integral 0024 0702 RECALL 2 0025 0203 + 3 add h to x 0026 0001 1 0027 0305  5 decrement counter 0028 0804 SKIP IF X=0 si 0, it's done 0029 1505 1508 GOTO 8 else, back to start of loop 0031 0702 RECALL 2 0032 0404 ×= 4 multiply integral by h 0033 0915 RETURN 0034 0900 1015 LABEL f(x) 15 start of function to integrate 0036 1215 X² 0037 0915 RETURN 
To approximate the integral We select the number n of intervals and let Finally, , it's the rectangle method, a one that is not really accurate! Into the program:
Another example with With 100 intervals, the machine returns I=+3.16... in 24 seconds. 
09 00 LABEL 10 00 fx0 start of program f(0) 06 15 STO left init the random generator 00 00 0 and set to zero... 06 01 STO 01 the "under" counter 06 02 STO 02 and the "total" counter 09 15 RETURN 09 00 LABEL 10 01 fx1 start of program f(1) 06 00 STO 00 init the loop counter 02 02 STO+ 02 and update the "total" counter 07 15 RCL left start of main loop, recall the seed 13 01 π 02 15 + left 00 05 5 12 08 a^x compute (x+π)^5 06 15 STO left 13 07 INT 03 15  left keep the fractional part 12 15 x² to the square 06 14 STO right 00 10 , 00 05 5 03 14  right compared to 0.5 08 05 SKIP IF X>0 if "over", then jump 00 02 2 else, add two to the "under" counter 02 01 STO+ 01 00 01 1 update the loop counter 03 00 STO 00 08 04 SKIP If X=0 if not null, then go on looping. 15 05 GOTO 14 13 19 07 01 RCL 01 compute the frequency 06 14 STO right 07 02 RCL 02 05 14 ÷= right 09 15 RETURN 
. This is done with this recurrent formula . Then, the probability that is the same as the probability that . This way, after several tests, the frequency of the squared numbers under one half is close to square root of two over two. This frequency is the value returned, with this little difference that "2" is added for each value "under", so the frequency is This program doesn't work well as the random generator is not well balanced. Instead of the expected value of 1.41, it returns values close to 1.38 or 1.39. Usage:

It takes 8 bytes and is stored in scientific notation with 13 digits. The signs nibble only uses the two lower bits.
45 20 00 00 00 00 00 02 
There are two additionnal codes presented now:

For the first 16 registers, they are useless and inefficient as they require two steps. But, they give access to additional registers that are mapped to the program memory.

First, write this little program to ease STORE and RECALL operations.
You'll use function 00 to recall the register and function 01 to store into it. Note: if you have a 320 steps version, replace every occurence of step 0056 by step 0312. 
0000 0900 1000 LABEL f(x) 00 0002 0801 0100 RECALL 16 0004 0915 RETURN 0005 0900 1001 LABEL f(x) 01 0007 0901 0100 STORE 16 0009 0915 RETURN 
Now try this : 3 1/x f(x)01to store 0.33333... into register 16. Then let's edit steps 56 through 63: 0303 0303 0303 0303 0303 0303 0302 0001This means 3.333333333333 × 10^1. What happens if I put something else than digits into register 16? Edit step 0056 and put those codes: 1011 1213 1415 1011 1213 1415 1011 1213And then f(x) 00 to recall this register, see image on the right ! 
Values from 10 to 15 display this:
