JOVANA
Library Glossary Getting Started Three Levels Fields How it works Mission
Join the mission
All guides

Functions: What Calculus Acts On

Before calculus can study change, you need to be comfortable with the thing that changes: the [[function-calculus|function]]. This rung makes functions feel concrete — input-and-output machines, the inputs they accept, the everyday families you will meet, and two moves (composing and inverting) that show up again and again later.

A function is a machine

A function is a rule that takes something in and gives exactly one thing back. Think of a vending machine: press the button for a quantity, and out comes the price. The everyday version is everywhere — your phone bill is a function of how much data you used, the height of a thrown ball is a function of how much time has passed since you let go. In each case one input lands on one definite output, never two answers at once.

We name a function (usually f) and write f(x), read 'f of x', for the output when the input is x. The whole point of calculus is to ask how that output moves as you slide the input around — that is exactly what a rate of change measures. So getting comfortable with functions now is not a detour; it is the ground everything else stands on.

What goes in, what comes out: domain and range

Every machine has rules about what you may feed it. The domain is the set of inputs a function is allowed to accept; the range is the set of outputs it actually produces. These are not fussy bookkeeping — they matter because some operations are simply forbidden. You cannot divide by zero, and you cannot take the square root of a negative number (within the real numbers), so the domain quietly excludes any input that would force one of those.

Everyday meaning often shrinks the domain even further than the algebra does. The formula for the cost of n apples might make sense for any number, but only whole numbers from 0 upward are real-world inputs — you do not buy -3 apples. Reading a graph helps you see both sets at a glance: the domain is the shadow the curve casts on the horizontal axis, and the range is the shadow it casts on the vertical axis.

f(x) = 1 / (x - 2)      domain: all x except x = 2
g(x) = sqrt(x)          domain: x >= 0,  range: y >= 0
h(t) = -5*t^2 + 20*t    height of a ball; sensible domain 0 <= t <= 4
Three quick reads: where each rule is allowed to live, and what it gives back.

Families you will keep meeting

You do not need to master each family yet — just recognise their shapes, because calculus will ask how each one changes. A few you will meet on almost every page:

  1. Linear — f(x) = m*x + b, a straight line with constant slope m. Steady change: $3 per item, no surprises.
  2. Polynomial — sums of powers like f(x) = x^2 - 4 or x^3; smooth curves that bend. The height-of-a-ball rule above is one.
  3. Exponential — f(x) = 2^x or e^x; quantities that multiply, like compound interest or a spreading rumour. They grow stunningly fast.
  4. Trigonometric — sin(x), cos(x); waves that repeat forever. Anything that cycles — tides, sound, a swing — speaks this language.

Two moves: composing and inverting

Functions are most powerful when you chain them. A composite function feeds one machine's output straight into another: (f o g)(x) means 'do g first, then hand the result to f', written f(g(x)). Order matters — putting on socks then shoes is not the same as shoes then socks. This nesting is so common that calculus has a dedicated tool for differentiating it (the chain rule), which is exactly why we make friends with composition now.

The other move is undoing. An inverse function, written f^{-1}, runs the machine backward: if f turns degrees Celsius into Fahrenheit, f^{-1} turns Fahrenheit back into Celsius, so that f^{-1}(f(x)) = x. An inverse exists only when the original never reuses an output — each output must trace back to exactly one input. On a graph, an inverse is the mirror image across the line y = x.

g(x) = x + 1        f(u) = u^2
(f o g)(x) = f(g(x)) = (x + 1)^2      # compose: do g, then f

C_to_F(c) = (9/5)*c + 32
F_to_C(f) = (5/9)*(f - 32)            # the inverse undoes it
Composing nests one rule inside another; inverting runs a rule backward.