Posted 2002-04-07 01:11:00 by
This web page documents Charles Babbage's Analytical engine, a mechanical computer that was designed in the mid 1800s but never actually built. There's plenty of interesting information there, but what I was mostly interested in finding out was how sophisticated it was... my findings: I don't think it's Turing-complete.
But it's still very cool. Here I have written a page summarizing its capabilities, with an intended audience of other programmers.
The word (“cell”) size is 50 decimal digits plus a sign bit.
Memory (“the store”) consists of 1000 cells.
The ALU (“the mill”), has two input registers (“ingress axes”) and an output register (“egress axis”). The output and one of the inputs consist of two memory cells, the second cell of each being called the “prime ingress/egress axis.” There is also a “run-up” flag which is tripped under various conditions.
The instruction set:
Addition and subtraction take constant time (est. 1 second). Multiplication and division take, I believe, linear time by the number of digits in the second ingress axis (est. up to 1 minute).
- Add/subtract: set the run-up flag on overflow or if the sign of the result is different from that of the first
- Multiply: most significant 50 digits on the prime egress axis.
Divide: Dividend's most significant 50 digits on prime ingress axis. Quotient placed in prime egress axis, remainder placed in egress axis. Set run-up flag on divide by zero or if quotient has more than 50 digits.
Left/right shift (decimal) value in first/primed ingress axes.
- Instructions to move values between the store and mill. Constant indexing only.
- Instructions to place constants into store.
- Instructions to jump forward or back N instructions, unconditionally or depending whether the run-up flag is set.
Output is unclear, but presumably there would be instructions to make a hard copy of a value in the egress axis, to halt the machine, and to call the attention of the operator. I know that instructions for drawing vector graphics were considered.
In the design there were three different instruction streams of cards to accomodate the difference in representation between the types of operations. I'm not sure how these streams interacted, but the programmers of the time wrote code in a linear fashion, so presumably separating them was a clerical task.
Conclusion: It would've been fantastically useful at the time, but it doesn't look Turing-complete to me. I think it would need an indirect indexing instruction. A stack would also be nice.