The grid method (also known as the box method) of multiplication is an introductory approach to multi-digit multiplication calculations that involve numbers larger than ten. Because it is often taught in mathematics education at the level of primary school or elementary school, this algorithm is sometimes called the grammar school method.[1]
Compared to traditional long multiplication, the grid method differs in clearly breaking the multiplication and addition into two steps, and in being less dependent on place value.
Whilst less efficient than the traditional method, grid multiplication is considered to be more reliable, in that children are less likely to make mistakes. Most pupils will go on to learn the traditional method, once they are comfortable with the grid method; but knowledge of the grid method remains a useful "fall back", in the event of confusion. It is also argued that since anyone doing a lot of multiplication would nowadays use a pocket calculator, efficiency for its own sake is less important; equally, since this means that most children will use the multiplication algorithm less often, it is useful for them to become familiar with a more explicit (and hence more memorable) method.
Use of the grid method has been standard in mathematics education in primary schools in England and Wales since the introduction of a National Numeracy Strategy with its "numeracy hour" in the 1990s. It can also be found included in various curricula elsewhere. Essentially the same calculation approach, but not with the explicit grid arrangement, is also known as the partial products algorithm or partial products method.
The grid method can be introduced by thinking about how to add up the number of points in a regular array, for example the number of squares of chocolate in a chocolate bar. As the size of the calculation becomes larger, it becomes easier to start counting in tens; and to represent the calculation as a box which can be sub-divided, rather than drawing a multitude of dots.[2][3]
At the simplest level, pupils might be asked to apply the method to a calculation like 3 × 17. Breaking up ("partitioning") the 17 as (10 + 7), this unfamiliar multiplication can be worked out as the sum of two simple multiplications:
| × | 10 | 7 |
|---|---|---|
| 3 | 30 | 21 |
so 3 × 17 = 30 + 21 = 51.
This is the "grid" or "boxes" structure which gives the multiplication method its name.
Faced with a slightly larger multiplication, such as 34 × 13, pupils may initially be encouraged to also break this into tens. So, expanding 34 as 10 + 10 + 10 + 4 and 13 as 10 + 3, the product 34 × 13 might be represented:
| × | 10 | 10 | 10 | 4 |
|---|---|---|---|---|
| 10 | 100 | 100 | 100 | 40 |
| 3 | 30 | 30 | 30 | 12 |
Totalling the contents of each row, it is apparent that the final result of the calculation is (100 + 100 + 100 + 40) + (30 + 30 + 30 + 12) = 340 + 102 = 442.
Once pupils have become comfortable with the idea of splitting the whole product into contributions from separate boxes, it is a natural step to group the tens together, so that the calculation 34 × 13 becomes
| × | 30 | 4 |
|---|---|---|
| 10 | 300 | 40 |
| 3 | 90 | 12 |
giving the addition
300 40 90 + 12 ———— 442 |
so 34 × 13 = 442.
This is the most usual form for a grid calculation. In countries such as the UK where teaching of the grid method is usual, pupils may spend a considerable period of time regularly setting out calculations like the above, until the method is entirely comfortable and familiar.
The grid method extends straightforwardly to calculations involving larger numbers.
For example, to calculate 345 × 28, the student could construct the grid with six easy multiplications
| × | 300 | 40 | 5 |
|---|---|---|---|
| 20 | 6000 | 800 | 100 |
| 8 | 2400 | 320 | 40 |
to find the answer 6900 + 2760 = 9660.
However, by this stage (at least in standard current UK teaching practice) pupils may be starting to be encouraged to set out such a calculation using the traditional long multiplication form without having to draw up a grid.
Traditional long multiplication can be related to a grid multiplication in which only one of the numbers is broken into tens and units parts to be multiplied separately:
| × | 345 |
|---|---|
| 20 | 6900 |
| 8 | 2760 |
The traditional method is ultimately faster and much more compact; but it requires two significantly more difficult multiplications which pupils may at first struggle with[citation needed]. Compared to the grid method, traditional long multiplication may also be more abstract[citation needed]and less manifestly clear[citation needed], so some pupils find it harder to remember what is to be done at each stage and why[citation needed]. Pupils may therefore be encouraged for quite a period to use the simpler grid method alongside the more efficient traditional long multiplication method, as a check and a fall-back.
While not normally taught as a standard method for multiplying fractions, the grid method can readily be applied to simple cases where it is easier to find a product by breaking it down.
For example, the calculation 21/2 × 11/2 can be set out using the grid method
| × | 2 | 1/2 |
|---|---|---|
| 1 | 2 | 1/2 |
| 1/2 | 1 | 1/4 |
to find that the resulting product is 2 + 1/2 + 1 + 1/4 = 33/4
The grid method can also be used to illustrate the multiplying out of a product of binomials, such as (a + 3)(b + 2), a standard topic in elementary algebra (although one not usually met until secondary school):
| × | a | 3 |
|---|---|---|
| b | ab | 3b |
| 2 | 2a | 6 |
Thus (a + 3)(b + 2) = ab + 3b + 2a + 6.
32-bit CPUs usually lack an instruction to multiply two 64-bit integers. However, most CPUs support a "multiply with overflow" instruction, which takes two 32-bit operands, multiplies them, and puts the 32-bit result in one register and the overflow in another, resulting in a carry. For example, these include the umull instruction added in the ARMv4t instruction set or the pmuludq instruction added in SSE2 which operates on the lower 32 bits of an SIMD register containing two 64-bit lanes.
On platforms that support these instructions, a slightly modified version of the grid method is used. The differences are:
0x100000000. This is usually done by either shifting to the left by 32 or putting the value into a specific register that represents the higher 32 bits.| × | b | a |
|---|---|---|
| d | - | ad |
| c | bc | ac |
This would be the routine in C:
#include <stdint.h>
uint64_t multiply(uint64_t ab, uint64_t cd)
{
/* These shifts and masks are usually implicit, as 64-bit integers
* are often passed as 2 32-bit registers. */
uint32_t b = ab >> 32, a = ab & 0xFFFFFFFF;
uint32_t d = cd >> 32, c = cd & 0xFFFFFFFF;
/* multiply with overflow */
uint64_t ac = (uint64_t)a * (uint64_t)c;
uint32_t high = ac >> 32; /* overflow */
uint32_t low = ac & 0xFFFFFFFF;
/* 32-bit multiply and add to high bits */
high += (a * d); /* add ad */
high += (b * c); /* add bc */
/* multiply by 0x100000000 (via left shift) and add to the low bits with a binary or. */
return ((uint64_t)high << 32) | low;
}
This would be the routine in ARM assembly:
multiply:
@ a = r0
@ b = r1
@ c = r2
@ d = r3
push {r4, lr} @ backup r4 and lr to the stack
umull r12, lr, r2, r0 @ multiply r2 and r0, store the result in r12 and the overflow in lr
mla r4, r2, r1, lr @ multiply r2 and r1, add lr, and store in r4
mla r1, r3, r0, r4 @ multiply r3 and r0, add r4, and store in r1
@ The value is shifted left implicitly because the
@ high bits of a 64-bit integer are returned in r1.
mov r0, r12 @ Set the low bits of the return value to r12 (ac)
pop {r4, lr} @ restore r4 and lr from the stack
bx lr @ return the low and high bits in r0 and r1 respectively
Mathematically, the ability to break up a multiplication in this way is known as the distributive law, which can be expressed in algebra as the property that a(b+c) = ab + ac. The grid method uses the distributive property twice to expand the product, once for the horizontal factor, and once for the vertical factor.
Historically the grid calculation (tweaked slightly) was the basis of a method called lattice multiplication, which was the standard method of multiple-digit multiplication developed in medieval Arabic and Hindu mathematics. Lattice multiplication was introduced into Europe by Fibonacci at the start of the thirteenth century along with Arabic numerals themselves; although, like the numerals also, the ways he suggested to calculate with them were initially slow to catch on. Napier's bones were a calculating help introduced by the Scot John Napier in 1617 to assist lattice-method calculations.