7 Integers and signed arithmetic

Moving in both directions

Your bank balance is $40 and you spend $60. You’re now at −$20.

It’s −3°C at night. By morning it’s dropped another 8 degrees. Where are you on the thermometer?

You’re on the ground floor of a car park. The exit is two floors up; the lower deck is three floors down. Which direction is floor −3?

All three questions use the same operation: addition on the integer number line. Negative numbers aren’t strange — they’re just the left side of zero.

7.1 What this chapter helps you do

Symbols to keep handy

These are the bits of notation you'll see a lot. If a line of symbols feels like a fence, read it out loud once, then keep going.

(+)(−) = −, (−)(+) = −: different signs multiply to give negative
(+)(+) = +, (−)(−) = +: same signs multiply to give positive
−(−a): the negative of a negative, which equals positive a
a + (−b): a plus negative b, which equals a minus b

Here is the main move this chapter is making, in plain terms. You do not need to be fast. You just need to keep the thread.

Coming in: You know where positive and negative numbers sit on the number line. You can add and subtract positive whole numbers.
Leaving with: Adding a negative is the same as subtracting a positive. Subtracting a negative is the same as adding a positive. The sign rules for multiplication and division follow from these two facts. Signed arithmetic is movement on the number line, and the rules describe how direction and distance combine.

7.2 What the notation is saying

Start with the number line from Chapter 1. Positive numbers point one way from zero, and negative numbers point the other way.

An integer is any whole number: …, −3, −2, −1, 0, 1, 2, 3, …

This means integers are whole-number positions on the number line.

The negative sign in front of a number means “opposite direction”: -5 is 5 units to the left of zero.

This means the sign tells you direction, while the number tells you size.

Adding a negative moves you left on the number line: 7 + (-3) = 7 - 3 = 4

This means “plus a negative” has the same effect as subtraction.

Subtracting a negative moves you right — you reverse direction twice: 5 - (-2) = 5 + 2 = 7

That second one trips people up. Think of it this way: if someone cancels a debt you owe, you end up better off. Taking away a negative is the same as adding a positive.

The double negative rule: -(-a) = a. Two negatives cancel out and you get the original positive back.

Here, a means any number. This means the opposite of an opposite brings you back to the starting direction.

Sign rules for multiplication and division:

Operation	Sign result
(+) \times (+)	+
(-) \times (-)	+
(+) \times (-)	-
(-) \times (+)	-

Same signs give positive. Different signs give negative. The same rules apply to division.

This means multiplication and division care about whether the directions match or oppose each other.

Interactive: Signed number line. Set a starting value and a change. The arrow shows the movement; the equation updates live.

Code

{
  const W = 560;
  const H = 130;
  const LINE_Y = 58;
  const TICK_H = 10;
  const PAD_L = 28;
  const PAD_R = 28;
  const MIN_VAL = -15;
  const MAX_VAL = 15;

  const start  = Number.isFinite(startVal)  ? Math.round(startVal)  : 3;
  const change = Number.isFinite(changeVal) ? Math.round(changeVal) : -5;
  const result = start + change;

  // Clamp result display — result can go outside visible range; still show equation
  const visibleResult = Math.max(MIN_VAL, Math.min(MAX_VAL, result));

  const usableW = W - PAD_L - PAD_R;
  const xScale = d3.scaleLinear()
    .domain([MIN_VAL, MAX_VAL])
    .range([PAD_L, PAD_L + usableW]);

  const svg = d3.create("svg")
    .attr("viewBox", `0 0 ${W} ${H}`)
    .attr("width", "100%")
    .attr("style", `max-width:${W}px; font-family: inherit;`);

  // Number line
  svg.append("line")
    .attr("x1", PAD_L - 8).attr("y1", LINE_Y)
    .attr("x2", PAD_L + usableW + 8).attr("y2", LINE_Y)
    .attr("stroke", "#9ca3af").attr("stroke-width", 1.5);

  // Arrowheads on line ends
  const arrowPath = (x, y, dir) =>
    `M${x},${y} L${x + dir * 7},${y - 5} L${x + dir * 7},${y + 5} Z`;
  svg.append("path").attr("d", arrowPath(PAD_L - 8, LINE_Y, -1)).attr("fill", "#9ca3af");
  svg.append("path").attr("d", arrowPath(PAD_L + usableW + 8, LINE_Y, 1)).attr("fill", "#9ca3af");

  // Tick marks and labels
  for (let v = MIN_VAL; v <= MAX_VAL; v++) {
    const x = xScale(v);
    const isMajor = v % 5 === 0;
    svg.append("line")
      .attr("x1", x).attr("y1", LINE_Y - (isMajor ? TICK_H : TICK_H * 0.6))
      .attr("x2", x).attr("y2", LINE_Y + (isMajor ? TICK_H : TICK_H * 0.6))
      .attr("stroke", isMajor ? "#6b7280" : "#d1d5db")
      .attr("stroke-width", isMajor ? 1.5 : 1);
    if (isMajor) {
      svg.append("text")
        .attr("x", x).attr("y", LINE_Y + TICK_H + 13)
        .attr("text-anchor", "middle")
        .attr("fill", "#6b7280").attr("font-size", "11px")
        .text(v);
    }
  }

  // Arrow showing movement (from start to result, clamped to visible range)
  const arrowStartX  = xScale(Math.max(MIN_VAL, Math.min(MAX_VAL, start)));
  const arrowEndX    = xScale(visibleResult);
  const ARROW_Y      = LINE_Y - 22;
  const isOutOfRange = result < MIN_VAL || result > MAX_VAL;

  if (change !== 0) {
    const colour = change > 0 ? "#0d9488" : "#d97706";
    svg.append("line")
      .attr("x1", arrowStartX).attr("y1", ARROW_Y)
      .attr("x2", arrowEndX).attr("y2", ARROW_Y)
      .attr("stroke", colour).attr("stroke-width", 2.5);

    // Arrowhead at end
    const dir = change > 0 ? 1 : -1;
    svg.append("path")
      .attr("d", `M${arrowEndX},${ARROW_Y} L${arrowEndX - dir * 8},${ARROW_Y - 5} L${arrowEndX - dir * 8},${ARROW_Y + 5} Z`)
      .attr("fill", colour);
  }

  // Start position dot
  svg.append("circle")
    .attr("cx", arrowStartX).attr("cy", LINE_Y)
    .attr("r", 7)
    .attr("fill", "#4b5563")
    .attr("stroke", "#fff").attr("stroke-width", 1.5);

  svg.append("text")
    .attr("x", arrowStartX).attr("cy", LINE_Y)
    .attr("y", LINE_Y - 12)
    .attr("text-anchor", "middle")
    .attr("fill", "#374151").attr("font-size", "11px").attr("font-weight", "600")
    .text(start);

  // Result position dot
  const resultColour = result > 0 ? "#0d9488" : result < 0 ? "#d97706" : "#4b5563";
  svg.append("circle")
    .attr("cx", xScale(visibleResult)).attr("cy", LINE_Y)
    .attr("r", 7)
    .attr("fill", resultColour)
    .attr("stroke", "#fff").attr("stroke-width", 1.5);

  svg.append("text")
    .attr("x", xScale(visibleResult))
    .attr("y", LINE_Y + TICK_H + 28)
    .attr("text-anchor", "middle")
    .attr("fill", resultColour).attr("font-size", "11px").attr("font-weight", "700")
    .text(isOutOfRange ? `${result} (off scale)` : result);

  // Equation label
  const changeSign = change >= 0 ? `+ ${change}` : `+ (${change})`;
  const eqLabel    = `${start}  ${changeSign}  =  ${result}`;
  svg.append("text")
    .attr("x", W / 2).attr("y", H - 6)
    .attr("text-anchor", "middle")
    .attr("fill", "#1f2937").attr("font-size", "13px").attr("font-weight", "700")
    .text(eqLabel);

  return svg.node();
}

7.3 The method

Addition and subtraction

Rewrite every subtraction as addition of the opposite: a - b = a + (-b).

Then use the number line: positive means move right, negative means move left. Your result is where you land.

Here, a and b are any numbers. This means one idea can handle both addition and subtraction.

Multiplication

Multiply the absolute values (ignore signs for now).
Count the number of negative factors.
- Even number of negatives → positive result.
- Odd number of negatives → negative result.

This means the size and the sign can be handled separately.

Division

Same rule: divide the absolute values, then apply the sign rule.

This means division follows the same sign pattern as multiplication.

Order of operations with signed numbers

Brackets first. Then signs attached to numbers. Then multiply/divide left to right. Then add/subtract left to right.

This means the sign belongs to the number it is attached to.

Why this works

Think of multiplication as repeated addition. 3 \times (-4) means “add -4 three times”: (-4) + (-4) + (-4) = -12. That gives (+) \times (-) = (-).

For (-) \times (-): -3 \times (-4) means “add -4 negative three times.” Adding a negative thing a negative number of times is removing it — which is positive. The algebraic proof uses the distributive law: 0 = (-3)(4 + (-4)) = (-3)(4) + (-3)(-4) = -12 + (-3)(-4), so (-3)(-4) = 12.

Interactive: Sign rules for multiplication. Click any cell in the table to see the calculation and the rule in action. All four combinations are visible at once.

Code

{
  // Fixed example magnitudes for each sign combination
  // Rows: sign of first number (+/-)
  // Cols: sign of second number (+/-)
  const COMBOS = [
    { aSign: +1, bSign: +1, aAbs: 3, bAbs: 4, row: 0, col: 0 },
    { aSign: +1, bSign: -1, aAbs: 3, bAbs: 4, row: 0, col: 1 },
    { aSign: -1, bSign: +1, aAbs: 3, bAbs: 4, row: 1, col: 0 },
    { aSign: -1, bSign: -1, aAbs: 3, bAbs: 4, row: 1, col: 1 },
  ];

  const W = 560;
  const H = 280;
  const CELL_W = 200;
  const CELL_H = 88;
  const GRID_X = 100;
  const GRID_Y = 50;
  const COL_HEADER_Y = 28;
  const ROW_HEADER_X = 52;

  const posColour  = "#0d9488";  // teal-600 — positive result
  const negColour  = "#d97706";  // amber-600 — negative result
  const selStroke  = "#1f2937";
  const dimFill    = "#f9fafb";

  const svg = d3.create("svg")
    .attr("viewBox", `0 0 ${W} ${H}`)
    .attr("width", "100%")
    .attr("style", `max-width:${W}px; font-family: inherit; cursor: pointer;`);

  // Column headers: sign of second number
  const colLabels = ["Second number: +", "Second number: −"];
  colLabels.forEach((label, ci) => {
    svg.append("text")
      .attr("x", GRID_X + ci * CELL_W + CELL_W / 2)
      .attr("y", COL_HEADER_Y)
      .attr("text-anchor", "middle")
      .attr("fill", "#374151")
      .attr("font-size", "12px")
      .attr("font-weight", "600")
      .text(label);
  });

  // Row headers: sign of first number
  const rowLabels = ["First: +", "First: −"];
  rowLabels.forEach((label, ri) => {
    svg.append("text")
      .attr("x", ROW_HEADER_X)
      .attr("y", GRID_Y + ri * CELL_H + CELL_H / 2 + 4)
      .attr("text-anchor", "middle")
      .attr("fill", "#374151")
      .attr("font-size", "12px")
      .attr("font-weight", "600")
      .text(label);
  });

  COMBOS.forEach(c => {
    const aVal   = c.aSign * c.aAbs;
    const bVal   = c.bSign * c.bAbs;
    const result = aVal * bVal;
    const isPos  = result > 0;
    const colour = isPos ? posColour : negColour;

    const sel = selectedCell;
    const isSelected = sel && sel.a === c.aSign && sel.b === c.bSign;

    const cellX = GRID_X + c.col * CELL_W;
    const cellY = GRID_Y + c.row * CELL_H;

    // Cell background
    const g = svg.append("g")
      .attr("transform", `translate(${cellX},${cellY})`)
      .style("cursor", "pointer")
      .on("click", () => {
        selectedCell.value = { a: c.aSign, b: c.bSign };
        selectedCell.dispatchEvent(new Event("input"));
      });

    g.append("rect")
      .attr("width", CELL_W - 4)
      .attr("height", CELL_H - 4)
      .attr("x", 2).attr("y", 2)
      .attr("rx", 6)
      .attr("fill", isSelected ? colour : dimFill)
      .attr("stroke", isSelected ? selStroke : "#d1d5db")
      .attr("stroke-width", isSelected ? 2 : 1);

    // Calculation line: e.g. "+3 × −4 = −12"
    const aStr = c.aSign > 0 ? `+${c.aAbs}` : `−${c.aAbs}`;
    const bStr = c.bSign > 0 ? `+${c.bAbs}` : `−${c.bAbs}`;
    const rStr = result > 0 ? `+${Math.abs(result)}` : `−${Math.abs(result)}`;

    g.append("text")
      .attr("x", (CELL_W - 4) / 2)
      .attr("y", 28)
      .attr("text-anchor", "middle")
      .attr("fill", isSelected ? "#fff" : "#1f2937")
      .attr("font-size", "16px")
      .attr("font-weight", "700")
      .text(`${aStr} × ${bStr} = ${rStr}`);

    // Sign rule label
    const aSignWord = c.aSign > 0 ? "positive" : "negative";
    const bSignWord = c.bSign > 0 ? "positive" : "negative";
    const rSignWord = isPos ? "positive" : "negative";
    const ruleLine1 = `${aSignWord} × ${bSignWord}`;
    const ruleLine2 = `= ${rSignWord}`;

    g.append("text")
      .attr("x", (CELL_W - 4) / 2)
      .attr("y", 50)
      .attr("text-anchor", "middle")
      .attr("fill", isSelected ? "#fff" : "#6b7280")
      .attr("font-size", "11px")
      .text(ruleLine1);

    g.append("text")
      .attr("x", (CELL_W - 4) / 2)
      .attr("y", 64)
      .attr("text-anchor", "middle")
      .attr("fill", isSelected ? "#fff" : colour)
      .attr("font-size", "11px")
      .attr("font-weight", "600")
      .text(ruleLine2);

    // Shape badge: circle = positive, diamond = negative (redundant encoding)
    const BADGE_X = (CELL_W - 4) / 2;
    const BADGE_Y = 78;
    if (isPos) {
      g.append("circle")
        .attr("cx", BADGE_X).attr("cy", BADGE_Y - 4)
        .attr("r", 5)
        .attr("fill", "none")
        .attr("stroke", isSelected ? "#fff" : colour)
        .attr("stroke-width", 1.5);
    } else {
      g.append("polygon")
        .attr("points", `${BADGE_X},${BADGE_Y - 9} ${BADGE_X + 6},${BADGE_Y - 4} ${BADGE_X},${BADGE_Y + 1} ${BADGE_X - 6},${BADGE_Y - 4}`)
        .attr("fill", "none")
        .attr("stroke", isSelected ? "#fff" : colour)
        .attr("stroke-width", 1.5);
    }
  });

  // Summary rule line at bottom
  svg.append("text")
    .attr("x", W / 2)
    .attr("y", H - 10)
    .attr("text-anchor", "middle")
    .attr("fill", "#374151")
    .attr("font-size", "12px")
    .text("Same signs → positive result   |   Different signs → negative result   |   Click any cell to highlight it");

  return svg.node();
}

7.4 Worked examples

Example 1 — Bank balance. You start the week with $50 in your account. You spend $30 on food, $25 on a game, and then get paid $60 from a part-time shift. What’s your balance at the end of the week?

Add up all the changes — spends are negative, income is positive: 50 + (-30) + (-25) + 60 = 50 - 30 - 25 + 60 = 55

End balance: $55.

This means the final balance is the starting amount plus every signed change.

Example 2 — Temperature change. The temperature at 6 am is −5°C. By midday it has risen 14°C. By midnight it has fallen 18°C from the midday high. What is the midnight temperature?

Work through the changes in order:

-5 + 14 = 9°\text{C} \quad \text{(midday)} 9 - 18 = -9°\text{C} \quad \text{(midnight)}

The midnight temperature is −9°C.

This means a rise is positive movement and a fall is negative movement.

Example 3 — Score in a game. A quiz game gives +5 for a correct answer and −3 for a wrong one. A player gets 4 right and 6 wrong. What is their score?

Correct answers: 4 \times 5 = 20. Wrong answers: 6 \times (-3) = -18 — six negatives, so the result is negative.

Total score: 20 + (-18) = 2.

This means a player’s total is the sum of positive and negative points.

Example 4 — Running total with negatives. Evaluate (-4) \times (-3) + 2 \times (-5) without a calculator.

Handle the multiplications first — left to right:

(-4) \times (-3) = 12 (same signs → positive), giving 12.

2 \times (-5) = -10 (different signs → negative), giving -10.

Now add: 12 + (-10) = 2.

This means we apply sign rules first in multiplication, then combine the results by addition.

7.5 Where this goes

This chapter takes the number line idea and turns it into a full set of rules for calculation.

Signed arithmetic is the prerequisite for linear equations (Volume 2, Chapter 1). When you solve 3x - 7 = -19, you need to add 7 to both sides and handle the resulting -12 correctly.

In physics, signed quantities appear everywhere: displacement, velocity, acceleration, force, work, charge, and potential are all signed. The sign carries physical meaning — it encodes direction or polarity. Getting the sign wrong is not just a numerical error; it is a physical error.

Where this shows up

A bank account or budget uses signed arithmetic every time money moves in or out — the balance is an integer sum.
A weather forecast compares signed temperatures to report how much warmer or colder one day was than another.
A physicist writing Newton’s second law includes sign: F = ma, where F < 0 means the force acts in the negative direction.
A programmer writing low-level code must track whether arithmetic will overflow a signed integer’s range.

The rules are short. The mistakes, when you forget them, are expensive.

7.6 Exercises

A lift starts at floor 0 (ground). It goes down 3 floors, then up 7 floors, then down 2 floors. What floor is it on?
A player’s scores across five rounds of a quiz game: −4, +7, −2, +9, −3. What is their total score?
Evaluate without a calculator:
1. (-8) \times (-6)
2. (-15) \div 3
3. 4 \times (-9) \times (-2)
4. (-3)^3
The temperature at midnight is −6°C. It rises by 11°C by noon, then drops 15°C by the following midnight. What is the temperature at the end?
The lowest temperature ever recorded in Canada is −63°C (Snag, Yukon). The highest is +45°C (Lytton, BC). What is the range — the difference between highest and lowest?
A student owes three friends $8 each. They earn $40 doing odd jobs. After paying back all three debts, how much money do they have?
A share price opens at $14.50. Changes over five days: −$0.80, +$1.20, −$2.40, +$0.35, −$0.90. What is the closing price on day 5?