Integer

Created by Masashi Satoh | 12/09/2025

Introduction

This article serves to reinforce the learning of “Learning Data Models.”

Numerical range

To introduce integer types, it’s best to start by discussing ranges with students. Focus on the maximum value that can be handled for each number of bits. The way the upper limit of numbers expressible with a specific number of bits increases exponentially as the bit count grows evokes a sense of wonder. The clarity of binary further enhances the fascination of this learning experience.

• 1bit : 1
• 2bit : 3
• 3bit : 7
• 4bit : 15
• 5bit : 31
• 6bit : 63
• 7bit : 127
• 8bit : 255
• 9bit : 511
• 10bit : 1023
• 11bit : 2047
• 12bit : 4095
• 13bit : 8191
• 14bit : 16383
• 15bit : 32767
• 16bit : 65535（65 thousand）
• 17bit : 131071
• 18bit : 262143
• 19bit : 524287
• 20bit : 1048575
• 21bit : 2097151
• 22bit : 4194303
• 23bit : 8388607
• 24bit : 16777215（16.8 million）
• 25bit : 33554431
• 26bit : 67108863
• 27bit : 134217727
• 28bit : 268435455
• 29bit : 536870911
• 30bit : 1073741823
• 31bit : 2147483647
• 32bit : 4294967295（4.3 billion）
• 33bit : 8589934591
• 34bit : 17179869183
• 35bit : 34359738367
• 36bit : 68719476735
• 37bit : 137438953471
• 38bit : 274877906943
• 39bit : 549755813887
• 40bit : 1099511627775（1 trillion）
• 41bit : 2199023255551
• 42bit : 4398046511103
• 43bit : 8796093022207
• 44bit : 17592186044415
• 45bit : 35184372088831
• 46bit : 70368744177663
• 47bit : 140737488355327
• 48bit : 281474976710655（280 trillion）

Just seeing how the range of numbers they can handle increases exponentially with each doubling of bits, as the term “doubling game” suggests, is an exciting experience for students. It’s also a good idea to try the game of folding a large piece of paper in half multiple times.

Additionally, I mention to students the importance of anticipating the expected range of information to be handled and reserving memory space accordingly. Since memory is finite, we should avoid unnecessarily occupying large amounts of space.

If you understand memory as a grid with no margins, you should naturally wonder what happens when a calculation result exceeds the prepared range.

Overflow

Considering overflow errors that occur when the result of addition or multiplication exceeds the range is a valuable learning experience. Understanding error handling clarifies the relationship between computers and humans.

The first step is to clearly distinguish between calculations performed on paper and those performed in memory (registers).

On paper, you can simply write the additional digits of the result in the margins. But when performing calculations on memory—a strictly partitioned medium—it doesn’t work the same way. It’s crucial to visualize this.

As shown in the figure below, assume each _ represents 1 bit of memory. If 3 bits are allocated to the addend, operand, and result respectively, performing the calculation directly would result in the loss of 1 bit.

　110
＋010
＝___ ⇒ 1000

On paper, you can simply keep adding calculations in the margins. But in computers, which handle numbers by storing them in fixed-length containers, designers must plan in advance how to handle such cases. Since computers cannot resolve unexpected processing on their own, human intervention becomes necessary.

There are various ways to handle this, but a typical approach is to generate an error and require human intervention. You could demonstrate how an error occurs to students using some kind of interpreter language.

This is a fascinating experience. For it is precisely at the moment when a computer’s predictable operation halts due to an error that the identity of its creator is revealed (which, of course, is human spiritual activity).

The execution process of a computer itself is a closed system governed by determinism. Once the initial state is determined, it can only proceed toward a predetermined outcome. A computer cannot roll dice.

As proof, many programming languages include functions that generate random numbers, capable of producing patterns that appear random at first glance. However, unless the seed of randomness is provided from outside the system, these functions can only generate the same pattern no matter how many times they are repeated.

The computer’s execution process itself is a closed system governed by determinism. Once the initial state is determined, all that remains is to race toward the predetermined outcome. Computers cannot roll dice.

The computer’s seemingly living-like behavior stems from external inputs of real-world information into this closed system, or interrupts occurring in sync with real-world time.

The reason AI behaves like humans is simply because the vast amount of information it accumulates and organizes possesses a system of “human-like qualities.” This is the decisive difference that distinguishes humans — who possess their own intentions and contain an infinitely open spiritual world — from computers.

Thinking this way, it becomes clear that errors are like cracks in the computer’s closed system, presenting an opportunity for the computer’s true nature to be revealed before humans.

Representation of Negative Integers and Arithmetic Operations

Now, let’s move on to the next step.

I ask the students directly: “So far, we’ve been thinking about how to handle positive numbers. How should we handle negative integers in a computer?”

In our study of “Details on Building an Adder Circuit Using Relays,” we briefly touched on two’s complement, but we didn’t delve into its use for representing negative numbers. Therefore, students will likely come up with various ideas.

Having separate information for positive and negative values, like “-1” and “-250,” is actually a good idea. In fact, it’s worth exploring this model with students. It’s certainly clear and works well.

However, this method is rarely used in actual computers. The reason lies in the early days of computing, when available memory was severely limited, making compact information handling an absolute priority. Minimizing the cost of computing hardware was also a critical consideration.

This led to the concept of representing negative numbers using two’s complement.

Negative Number Representation Using Two’s Complement

There are numerous explanations of two’s complement, which is defined as the complement of a number in base 2. It is described as the smallest additive that causes a carry when added to the original number. Some explanations also touch on its relationship with congruence equations. How deeply to delve into this should be considered in conjunction with the broader mathematics curriculum, so consulting with a math teacher is advisable.

Here, it should suffice to cover at least the following points:

1. A representation format for negative numbers characterized by the fact that, after fixing the number of significant digits, the result of subtraction is obtained by truncating the bits that overflow when added to the addend.
2. The most significant bit is set to 1, making it easy to distinguish between positive and negative values.
3. Compared to handling only positive numbers, the number of values that can be represented with the same number of bits is reduced by about half.
4. The two’s complement can be obtained through a simple operation: invert all bits of the number, add 1 after fixing the number of significant digits, and discard any overflowed bits.

If you have the time, discussing the following points will be helpful when learning programming.

5. Explaining the existence of Boolean values and their nature as integer values.

Most programming systems treat 1 as true and 0 as false, but some treat all bits set as true and all bits unset as false. Some students might find it interesting that the latter’s true value, when converted to a number, becomes -1 in two’s complement representation.

It’s also worthwhile to have students consider why each system’s designer chose that particular specification. How would you approach it? Some students might even suggest that consuming one entire word to store binary information is wasteful, arguing that managing each bit individually is more efficient.

Indeed, in low-level interfaces, it’s common to see examples where multiple Boolean values are stored within a single word as flag information. Have students consider what procedure is needed to determine the truth value of a specific bit within such flag information.

ABCDEXYZ

To check whether a flag is set, you prepare a mask pattern corresponding to that specific bit, perform an AND operation, and determine whether the result is 0.

ABCDEXYZ
00000100 AND
00000X00

Writing to a flag requires an even more complicated procedure. If the value of the flag to be written is 0, you prepare a pattern where only the corresponding flag bit is 0 and all other bits are 1. You then perform an AND operation with the current flag set and write the result.

ABCDEXYZ
11111011 AND
ABCDE0YZ

If the value is 1, you prepare a pattern where only the corresponding flag bit is 1 and perform an OR operation instead.

ABCDEXYZ
00000100 OR
ABCDE1YZ

Discussing how to consider this cost is also worthwhile.

Regarding the four methods above, I briefly explained them in the “Computer System Overview” section of “Details on Constructing an Adder Circuit Using Relays.” I could explain them again in detail here.

Using the property described in point 1 above, subtraction becomes possible through the mechanism of addition. Or rather, it is precisely because of this property that the two’s complement representation has become established as the standard for representing negative integers. Rather than getting bogged down in the finer points of two’s complement, it should suffice if this nuance comes across.

Also, regarding division, be sure to tell students that they need to implement error handling for division by zero.

a=True
debug.Print a
True
debug.Print CInt(a)
-1 
debug.Print Hex(a)
FFFF
a=False
debug.Print CInt(a)
0

Arithmetic operations, comparison and conditional processing

Once you understand the mechanism of subtraction, all four arithmetic operations become possible. At this point, it’s worth touching on shift operations. Shifting all information one bit to the left (toward the higher-order digits) and filling the least significant digit with zeros yields the same result as multiplying by 2 in the binary world. The opposite effect is achieved by shifting in the opposite direction.

These are called left shift and right shift, and they are used to perform multiplication and division. It also plays a major role in the normalization procedure for floating-point types. Students who have previously played with a sequencer connected to an adder should be able to visualize the shift operation realistically.

Depending on the time available, review the steps for multiplication and division.

In division operations, a process occurs to check whether the result of subtraction becomes negative. We carefully explain that this comparison can be performed by performing a subtraction operation as a placeholder. Whether the result is zero can be determined by taking the OR of all bits in the result. For determining positive or negative, simply check whether the most significant bit of the result is 1 or 0. If it is 1, the result is negative.

Also mention that a mechanism exists to switch the next processing step based on the result, which is the basis for conditional processing.

By carefully tracing these low-level operations and learning the mechanisms of comparison and conditional processing, you can visualize the hidden workings of a computer while learning programming. This is crucial to avoid treating the computer as a black box. It especially serves as a safeguard against understanding conditional processing solely through the concept of “judgment.”

The only events occurring during the comparison process are whether the result of the subtraction is zero, or whether it is positive or negative. The mechanism that switches subsequent procedures based on this result is no different from the mechanism that switches a train’s track points. The meaning of subsequent procedures resulting from that conditional processing belongs to the intent of the person who created the program; the running train itself has no involvement whatsoever in that matter.

The judgment belongs solely to the programmer who is testing the program through thought experiments.

I know I’m repeating myself, but this position is the solid ground that keeps us sane in the face of the tsunami of advanced ICT technologies.

Reference Materials

There are many explanations of two’s complement representation, including its mathematical background, but I found the following resource extremely helpful (apologies, it’s in Japanese).

高等学校情報/情報の科学/負数と小数のデジタル表現 - Wikibooks

ja.wikibooks.org

An integer used as IDs

Integers are frequently used as identifiers.

However, it is crucial to understand that its essence lies in being used as a unique pattern without duplication, not as a numerical value.

Computers cannot directly manipulate concepts. Humans associate specific concepts with IDs. Programs, built on the relationship between concepts and IDs, process the ID pattern. Humans then associate the resulting pattern back with concepts for utilization.

In that sense, integer types themselves are essentially IDs. By assigning the concept of integers to patterns aligned with binary numbers, those patterns were subsequently endowed with ordinal characteristics. This is an intriguing discovery.

In other words, humans entrust all concepts to symbols called IDs, input those IDs into a computer, prepare procedures to process those IDs according to the interrelationships of concepts in the human world, and have the computer execute them.

However, the computer has no means of knowing what concepts those IDs are linked to. The computer simply processes those IDs according to the provided procedures. It has no involvement in what the results signify. It merely returns the results to humans without question.

No matter how advanced the AI, it is no exception to this.

The most useful application of the mathematical properties of integers is likely when handling IDs in an ordinal style and creating a mechanism to add new IDs while ensuring uniqueness (auto-increment).

The ordinal nature of IDs also holds significance in applications that standardize by linking various concepts to fixed IDs. A classic example is character encoding. Character encoding will be covered in detail in a separate section.

Additionally, pointer types can be viewed as a kind of ID. While they have the unique characteristics of being variable values that represent specific addresses, they function as IDs in the sense that the pattern points to a specific target.

IDs use unique symbols to manipulate real-world concepts, while pointer types use symbols representing address information to manipulate blocks of information in memory. These roles are very similar.

Following the floating-point types in the next section, the subsequent section will cover character types and string types. Since string manipulation using pointers will be covered in the string type section, it is necessary to briefly introduce pointer types here as a preview.