The practical math behind tech and STEM work: numbers, algebra, functions, geometry, logic and counting, with short code exercises.

Math for Tech & STEM

## Why this matters

A function is a rule that turns an input into exactly one output. That idea runs through all of technical work: a sensor turns temperature into voltage, a pricing rule turns usage into cost, and a program function turns arguments into a return value. Learning to read functions as rules, tables and graphs lets you move between a formula, a spreadsheet and a chart without losing the meaning.

## The core idea

A **function** takes an input, applies a rule, and gives **one** output for each input.

- The input is often called x (the *independent* variable).
- The output is often called y or f(x) (the *dependent* variable), because it depends on the input.

**Function notation** names the rule. `f(x) = 2x + 3` reads "f of x equals 2x plus 3". Then `f(4)` means "the output when the input is 4":

f(4) = 2(4) + 3 = 11

The parentheses here do **not** mean multiply. f(4) is "f applied to 4", just like calling a function in code.

## Three views of the same function

**1. The rule:** f(x) = 2x + 3

**2. The table:**

| x | f(x) |
|---|---|
| 0 | 3 |
| 1 | 5 |
| 2 | 7 |
| 3 | 9 |

**3. The graph:** plot each (x, f(x)) pair as a point. For this rule the points lie on a straight line that crosses the vertical axis at 3 and rises 2 for every 1 step to the right.

Reading the graph: to find f(2), go to x = 2 on the horizontal axis, move up to the line, then read across to the vertical axis: 7. To answer "which input gives 9?", go the other way: find 9 on the vertical axis, across to the line, down to x = 3.

## Is it a function?

The rule is "one output per input". A table where x = 2 appears twice with outputs 7 and 8 is **not** a function, because the input 2 does not determine a single output. On a graph, the **vertical line test** checks this: if any vertical line crosses the graph more than once, it is not a function.

Different inputs may share an output, though. g(x) = x² gives g(3) = 9 and g(−3) = 9, and g is still a function.

## Domain and range

The **domain** is the set of inputs that make sense; the **range** is the set of outputs you can get. For a phone plan cost(m) = 10 + 0.25m, minutes m cannot be negative, so the domain is m ≥ 0 and the range is cost ≥ 10. Real-world functions almost always have limited domains.

## Worked example: a pricing function

A phone plan charges a $10 base fee plus $0.25 per minute.

- Rule: cost(m) = 10 + 0.25m
- cost(0) = 10, cost(40) = 20, cost(100) = 35
- Which m gives a $30 bill? Solve 10 + 0.25m = 30, so m = 80.

## Functions in code

A JavaScript function is the same idea: inputs in, one output back.

```javascript
function f(x) {
  return 2 * x + 3;
}

console.log(f(4));        // 11

// Build a table of inputs and outputs
const table = [0, 1, 2, 3].map(x => [x, f(x)]);
console.log(table);       // [[0,3],[1,5],[2,7],[3,9]]
```

Code functions can do things maths functions do not (print, save files, change variables). A function with no side effects that always returns the same output for the same input is called *pure*, and it behaves exactly like a maths function.

## Common mistakes

- **Reading f(4) as f × 4.** It means "evaluate f at 4".
- **Swapping axes on a graph.** Inputs go along the horizontal axis; outputs go up the vertical axis.
- **Forgetting the domain.** A formula may give an output for x = −5 minutes, but that input is meaningless.
- **Thinking two inputs cannot share an output.** They can; it is one input with two outputs that breaks the rule.

## Quick recap

- A function gives exactly one output for each input.
- f(x) notation names the rule; f(4) means "the output for input 4".
- The rule, table and graph are three views of the same function.
- Domain = sensible inputs, range = possible outputs.

## Try it

In the **Do** tab, write the rule for the phone plan as a JavaScript function. A helper that builds an input/output table is already written.


Read inputs and outputs from a function rule, table and graph, and use function notation.

What a function is

Algebra Basics: What Are Functions? - Math Antics

Evaluating Functions (Intro to Function Notation)

## Why this matters

Linear relationships are the workhorse model of science and engineering. Cost grows by a fixed amount per unit, a spring stretches a fixed amount per newton, and a sensor's output rises a fixed number of millivolts per degree. When a relationship is linear, two numbers describe it completely: the **slope** (how fast it changes) and the **intercept** (where it starts).

## The core idea: y = mx + b

A linear function has the form

**y = mx + b**

- **m, the slope**, is the change in y for each 1-unit increase in x.
- **b, the y-intercept**, is the value of y when x = 0.

The graph is a straight line. A positive slope rises left to right, a negative slope falls, and a slope of 0 is flat.

## Finding slope from two points

Slope is "rise over run":

m = (y₂ − y₁) / (x₂ − x₁)

For the points (1, 10) and (3, 4):

m = (4 − 10) / (3 − 1) = −6 / 2 = **−3**

y falls by 3 for every 1 step in x. The order of the points does not matter as long as you are consistent: (10 − 4) / (1 − 3) = 6 / −2 = −3 as well.

## Finding the intercept

Once you have m, substitute either point into y = mx + b and solve for b:

b = y₁ − m × x₁ = 10 − (−3)(1) = 13

So the line is **y = −3x + 13**. Check the other point: −3(3) + 13 = 4. Correct.

## Worked example 1: a data table

A delivery company records cost against distance:

| distance (km) | cost ($) |
|---|---|
| 0 | 4.00 |
| 5 | 7.50 |
| 10 | 11.00 |
| 15 | 14.50 |

Each 5 km adds $3.50, a constant change, so the relationship is linear.

- Slope: 3.50 / 5 = **$0.70 per km**
- Intercept: at 0 km the cost is **$4.00** (a fixed booking fee)
- Model: cost = 0.70 × distance + 4.00

Predict a 22 km trip: 0.70 × 22 + 4.00 = $19.40.

The **units of the slope** are "y units per x unit", here dollars per kilometre. Stating units turns a number into an interpretation.

## Worked example 2: is it linear?

| x | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| y | 1 | 3 | 7 | 13 |

The differences are 2, 4, 6. They are not constant, so this is **not** linear. A constant difference for equal steps in x is the quick test.

## Real data is noisy

Measured data rarely sits exactly on a line. Engineers fit a **line of best fit** (usually by least squares, which you will meet in statistics) that passes as close as possible to all points. The slope and intercept of that line are read the same way. Python's standard library can fit one:

```python
import statistics

distance = [0, 5, 10, 15]
cost = [4.0, 7.5, 11.0, 14.5]
fit = statistics.linear_regression(distance, cost)
print(fit.slope, fit.intercept)   # 0.7 4.0 (up to rounding)
```

## Interpolation and extrapolation

Using the line **between** measured points (interpolation) is usually safe. Using it far **beyond** your data (extrapolation) is risky: a delivery price may jump for long distances, and a spring stops being linear when it is overstretched.

## Common mistakes

- **Mixing the order of points**: (y₂ − y₁) / (x₁ − x₂) gives the wrong sign.
- **Putting x-change on top.** Slope is change in y over change in x.
- **Reading b as the first table value** when the table does not start at x = 0.
- **Dropping units** on the slope, so it cannot be interpreted.
- **Extrapolating too far** beyond the data.

## Quick recap

- y = mx + b: m is the rate of change, b is the value at x = 0.
- m = (y₂ − y₁) / (x₂ − x₁); then b = y₁ − m × x₁.
- Equal steps in x with equal changes in y means linear.
- Give slopes units, and be cautious outside your data.

## Try it

In the **Do** tab, write the slope formula. The intercept and prediction functions are already built on top of it.


Find the slope and intercept of a line from two points or a data table, and interpret them.

Linear relationships and slope

Graphing Lines in Algebra: Understanding Slopes and Y-Intercepts

Slope Intercept Form Y=mx+b | Algebra

## Why this matters

Some quantities do not grow by a fixed amount; they grow by a fixed **percentage**. Savings earning interest, a bacterial culture, users of a popular app and the number of transistors on a chip have all been described this way. Radioactive material and a cooling cup of coffee *decay* the same way. Logarithms are the tool that answers the reverse question: "how long until it doubles?" or "how many times bigger is this?"

## Linear versus exponential

- **Linear:** add the same amount each step. 100, 110, 120, 130 (+10 each time).
- **Exponential:** multiply by the same factor each step. 100, 110, 121, 133.1 (×1.1 each time).

Early on they look similar. Over time the exponential one pulls away dramatically, because each step's growth is based on a bigger amount.

## The growth formula

Starting from an amount P, growing at rate r per period, for t periods:

**A = P × (1 + r)^t**

- r is a decimal: 5% is 0.05.
- (1 + r) is the **growth factor**.
- For decay, use a negative rate: losing 20% per period means a factor of 0.8.

## Worked example 1: compound interest

$1,000 at 5% per year for 10 years:

A = 1000 × 1.05^10 ≈ 1000 × 1.6289 = **$1,628.89**

With simple (linear) interest the same deposit would reach only $1,500.

## Worked example 2: decay

A server's request queue drains 20% per minute. Starting at 5,000 requests, after 3 minutes:

A = 5000 × 0.8³ = 5000 × 0.512 = **2,560 requests**

## Logarithms: the reverse of exponents

A logarithm answers "what exponent do I need?"

**log_b(x) = y means b^y = x**

- log₁₀(1000) = 3, because 10³ = 1000
- log₂(8) = 3, because 2³ = 8
- log₁₀(1) = 0, because 10⁰ = 1

Two bases appear constantly: base 10 (common log) and base e ≈ 2.718 (the natural log, written ln). Computer science also uses base 2: log₂(n) is roughly how many times you can halve n, which is why binary search over a million items needs only about 20 steps.

## Worked example 3: doubling time

How long does money take to double at 7% per year? Solve 2 = 1.07^t. Take logarithms of both sides:

t = log(2) / log(1.07) ≈ 0.6931 / 0.0677 ≈ **10.2 years**

Any base works as long as you use the same one top and bottom. A handy shortcut, the **rule of 72**, estimates doubling time as 72 ÷ (rate in percent): 72 ÷ 7 ≈ 10.3 years.

```python
import math

print(1000 * 1.05 ** 10)               # about 1628.89
print(math.log(2) / math.log(1.07))    # about 10.24
print(math.log10(1000), math.log2(8))  # 3.0 3.0
```

## Log scales

When data spans many orders of magnitude, a chart with a **log scale** spaces 1, 10, 100, 1000 evenly. Exponential growth then appears as a straight line, which makes the growth rate easy to compare. Familiar log scales include decibels for sound and pH for acidity: each step of 1 in pH is a 10× change in hydrogen-ion concentration.

## Common mistakes

- **Using the percent instead of the decimal**: 1 + 5 instead of 1 + 0.05.
- **Treating percentage growth as linear**: 5% per year for 10 years is not 50%; it is about 62.9%.
- **Mixing log bases** inside one calculation.
- **Expecting exponential trends to continue forever.** Real growth hits limits (market size, food supply), so models need checking against data.

## Quick recap

- Exponential change multiplies by the same factor each period: A = P(1 + r)^t.
- Decay uses a factor below 1.
- log_b(x) asks which power of b gives x; it undoes exponentiation.
- Doubling time = log(2) / log(1 + r), roughly 72 ÷ rate%.

## Try it

In the **Do** tab, write the growth formula. A doubling-time function that uses logarithms is already written so you can compare the two.


Model repeated percentage growth and decay, and use logarithms to answer how long and how many times.

Exponential growth and logarithms

Logarithms, Explained - Steve Kelly

Exponential Growth and Decay Word Problems & Functions - Algebra & Precalculus

Functions as rules, tables and graphs; slope and intercept; exponential growth and logarithms.