Usbrth

Several early computer designs regarded a 'word' as representing not an integer, with the bits having values 2^0, 2^1, 2^2, ..., but as representing a fixed-point fraction 2^-1, 2^-2, 2^-3, ...

(For the sake of simplicity in this question I'm ignoring the existence of the sign bit and talk only in terms of positive numbers)

Some examples of this convention are EDVAC, EDSAC, and the IAS machine.

Why was this? To me, having dealt with since the 1970s with machines that have "integers" at base, this seems a strange way to look at it.

Does it affect the machine operation in any way? Addition and subtraction are the same regardless of what you think the bits mean, but I suppose that for multiplication of two N-bit words giving an N-bit result, the choice of which N bits to keep depends on your interpretation. (Integer: you want the "right hand word"; fixed-point fraction, you want the "left hand word").

I'd think that it was mostly down to the preferences of John von Neumann at the time. He was a strong advocate of fixed point representations, and early computers were designed with long words to accommodate a large range of numbers that way. You certainly don't need 30-40 bits to cover the most useful integers, but that many were needed if you wanted plenty of digits before and after the decimal point.

By the 1970s though, the costs of integration were such that much smaller word sizes made sense. Minicomputers were commonly 16 bit architectures, and micros 8 bits or sometimes even 4. At that point you needed all the integers you can get, plus floating point had largely replaced fixed point for when you needed decimals.

Nowadays we'd think nothing of using 64 bit integers, of course, but it's a heck of a lot easier to integrate the number of logic gates required for that than it would have been back when they all had to be made out of fragile and expensive vacuum tubes.

This is not really a hardware issue at all, but just a different way of interpreting the bit patterns. A "fixed decimal point" representation for numbers is still used in some situations, where the full power and flexibility of floating point is unnecessary.

The IBM S/360 and S/370 hardware had decimal arithmetic as well as binary, and IBM's PL/I programming language had both "fixed decimal" and "fixed binary" data types, with an implied decimal point anywhere in the number, though fixed binary was mainly used for the special case of "integers". Fixed decimal was an obvious choice for handling financial calculations involving decimal currency such as dollars and cents, for example, because of the simple conversion to and from human-readable numbers.

Fixed point binary is still used in numerical applications like signal processing, where lightweight hardware (integer-only) and speed are critical and the generality of floating point is unnecessary.

In terms of the computer's instruction set, all that is needed is integer add, subtract, multiply, divide, and shift instructions. Keeping track of the position of the implied decimal point could be done by the compiler (as in PL/1) or left to the programmer to do manually. Used carefully, doing it manually could both minimize the number of shift operations and maximize the numerical precision of the calculations, compared with compiler-generated code.

There is a lot of similarity between this type of numerical processing and "multi-word integers" used for very high precision (up to billions of significant figures) in modern computing.

Some early computers did use integers.

Manchester University's ‘Baby’ computer calculated the highest factor of an integer on 21 June 1948. https://www.open.edu/openlearn/science-maths-technology/introduction-software-development/content-section-3.2

EDSAC 2 which entered service in 1958, could do integer addition. https://www.tcm.phy.cam.ac.uk/~mjr/courses/Hardware18/hardware.pdf

Computers came from calculators, and calculators are designed to solve numerical computations, and hence require the decimal point.

Babbage's difference engine ~1754 had 10 of 10-digit decimal numbers.  Its job was computing numerical tables — and printing them, since the copying of the day (by humans) made more mistakes than the mathematicians who made the original calculations.

EDVAC was part of the US Army's Ordnance Department, its job was ballistics computation.

The problems early computers were meant to solve used real numbers. Often these numbers were very large or very small, so you need a scale factor for the computer to handle them.

If the computer natively thinks in numbers from 0.0 to 1.0 (or -1.0 to 1.0), then the scale factor is simply the maximum value of the variable. This is easy for human minds to handle and not very error prone.

If the computer natively thinks in numbers from 0 to 16777215 (or whatever), the scale factor becomes something completely different. Getting the scale factor right becomes much harder and a source of errors.

Lets go with less errors, shall we?

As others have pointed out, the actual hardware is the same for the two schemes, it is just a matter of how humans interact with the machine. 0.0 to 1.0 is more human friendly.

At the time using fiction point fraction representation seemed like the best solution for handling floating point numbers, because it avoids many of the issues that are present with other formats such as not being able to precisely represent 0.5 and cumulative errors when performing relatively common operations repeatedly.

In time better ways to represent floating point numbers with binary were devised. General purpose hardware was able to process such formats and gave the programmer a free choice to select the one they wanted.