# What is the instruction set of the Z4?

I am able to find a few instructions, such as:

• `Fin` (presumably "Fine", as in the end of a musical score, ends a program),
• `Fin'`, (a conditional `Fin`),
• `St` (possibly "Start" -- the need for this is unclear),
• `Up` (My guess is "Unterprogramm" which means subroutine, since it apparently invokes subroutine At1,
• `x =?` (Apparently checks the subroutine's return value, which is stored in location 63),

But I cannot find a complete reference to the Z4 instruction set, nor does anyone seem to have implemented any emulator. I hope this information has not been lost to obscurity!

What is the complete instruction set of the Z4?

• Bonus points if you can comment on whether the instructions were the same or different from the other computers built by Konrad Zuse. Commented Oct 10, 2018 at 14:32
• For 'Fin' I guess it's rather just that, French for End. 'Fine' woud be Italian and less likely, considering that French was still the major foreign language teached in Germany at that time. Commented Oct 25, 2018 at 9:26

Horst Zuse (Konrad Zuse's son, a computer science professor by trade) has a homepage where he supplies (and sells) various pieces of information, booklets and CDs and DVDs about his father's work.

The Z4 had two floating point registers, `R1` and `R2`, that were used for calculations. Monadic operations operated on `R1` only, dyadic operations on `R1` and `R2`. Results always went to `R1` while `R2` was deleted.

The "Instruction set" of the Z4 was as follows:

• Ablesebefehl, `A n` (e.g. `A 17`) - reads a memory cell into `R1`, or `R2` if `R1` is in use (though it is a bit blurry for me what "is in use" is supposed to mean here. It could mean there is a sort of flip-flop in here that switches between target registers on every A operation and is reset by any of the calculation instructions)).
• Speicherbefehl, `S n` (e.g. `S 18`) - stores `R1` in to a memory cell.
• Dyadic operations, such as `+`, `-`, `x`, `/`, `MAJ` (Maximum) and `Min`.
• Monadic operations, such as `x^2`, `SQR(x)`, `1/x`, `IxI`, `sgn(x)`, `x*½`, `x*2`, `x*(-1)`, `x*10`, `x*3`, `x*1/3`, `x*1/5`, `x*1/7`, `x*pi` and `x*1/pi`, performed the equivalent operations.
• Comparison operations with zero, positive, or infinite (i.e. `NaN`) test the number in `R1` and return `+1` if the condition matches, `-1` if not. Note there is apparently no comparison against arbitrary constants beyond these.
• The conditional jump `SPR` was a later addition and included on specific request of the Zürich University (ETH), the first commercial customer. It allows to jump forward over code sequences when `R1` is `+1`, the jump will not be executed when `R1` is `-1`. Instructions up to the instruction `ST` will be skipped if the jump is taken. `SPR` was normally combined with the comparison operations above.
• `UP` (change punch reader, Unterplan) is something that might look like an I/O operation, but actually is much more. The next instructions after `UP` are read from the secondary punch tape reader, until a `FIN` instruction is encountered there (which switches back to the primary reader). As the Z4 didn't have loop or backwards jump instructions, this could be used to program subroutines on the secondary reader, or even loops by glueing the secondary punch tape into a (physical) loop and run it around.
• Output instructions (`D` and `L`) transfer register contents into human-readable form and emit them to the "display" (a set of lamps), secondary punch tape (external storage), or typewriter.

The Z4, like the Z3, handled floating point exceptions in a pretty "modern" way. Numbers that exceed the supported floating point range (`1E-20`-`1E20`) were stored as overflow ("sehr groß") or underflow ("unbestimmt"). Once a number is stored as that, any follow-up calculation with that number was guaranteed to never reach a valid value again (just like the `NaN`s in modern FPUs do).

Some fun-facts:

• The ETH Zürich, the first commercial customer, leased out the machine to third parties at one Swiss Rappen per instruction.
• During its whole lifetime at ETH Zürich, the Z4 executed about 100,000 operations (although that seems highly unlikely for a total time over 5 years, but that is what the Zuse page says).
• If you want to visit the machine, it's still there in the "Deutsches Museum München" (in Munich).
• Operating frequency in today's measures was about 40Hz.
• The machine operated on 32-bit words and registers.
• "the Z4 executed about 100,000 operations" like in only about 100 hours of operation within 5 years? Somehow this sounds rather implausible. Commented Oct 25, 2018 at 9:08
• @Raffzahn I was thinking the same. But that is what Horst Zuse's page says (Von 1950-1955 bearbeitete die Z4 etwas 100 verschiedene Problemstellungen. Es wurden 100.000 Befehle ausgeführt. Für externe Auftraggeber wurde pro Befehl ein Rappen verlangt.) Commented Oct 25, 2018 at 9:14
• I did notice early on what page you took (some of) the information from :)) And yes, that's wht's written there. Maybe that refers only to external sold instructions? I guess I'll ask him next time . Commented Oct 25, 2018 at 9:21
• Mind to link the page you're refering to? Commented Oct 25, 2018 at 9:31
• @raffzahn The original page I have the instruction set from was irb.cs.tu-berlin.de/~zuse/Konrad_Zuse/en/Rechner_Z4.html - But that seems to be down atm. archive.org has it here: web.archive.org/web/20090405211537/http://… Commented Oct 25, 2018 at 9:39

The Z4 made use of a unit called a Planfertigungsteil (program construction unit),which was used to produce punch tapes, containing instructions for the Z4 in a very easy way. For this reason, it was possible to learn the programming of the Z4 in as little as three hours. The Z4 had a large instruction set in order to calculate complicated scientific programs. The arithmetic processor was a powerful binary floating processor. The set of instructions is as follows:

1. Instructions for Input: <-, At1, etc.: These allow numbers to be read from the punch tape.

2. Instructions for Output: ->, D, L, etc.: These instructions cause binary numbers to be converted into their decimal equivalents and the results to be displayed with lamps, on the MERCEDES typewriter as floating or fixed point numbers, or on the punch tape.

3. Instruction for reading from memory: A n. For example A 17. This reads the contents of memory cell 17 into the Register R1. If Register R1 is occupied, then the contents are loaded into Register R2.

4. Instruction for writing to memory: S n. For example S 18. This writes the contents of Register R1 into the memory cell 18.

5. Dyadic operations: +, -, x, /, MAX, and MIN.

6. Monadic operations: x2, SQR(x), 1/x, | x | , sign(x), x*1/2, x*2, x*(-1), x*10, x*3, x*1/3, x*1/5, x*1/7, x*Pi, x*1/Pi.

7. Instructions for comparison: x = 0, x >= 0, | x | = infinity test the value in Register R1 and set Register R1 to +1 if the condition is fulfilled, if not, then the contents of Register R1 are set to –1.

8. A conditional branch instruction: SPR. The instruction SPR skips the punch tape to the instruction ST, if Register R1 contains +1 (if Register R1 contains –1 then there is no impact).

• What if `Up` is called from the Unterprogramm? Commented Oct 10, 2018 at 15:23