Connecting advanced functions to real life
Mark Mekhail
scroll down to begin
Rational Functions & Asymptotes
In plain termsAt a basic level, a rational function is one polynomial divided by another. The key features are the asymptotes, which are lines the graph approaches but never touches. A vertical asymptote happens at an input the function can't take, because the denominator becomes zero there. A horizontal asymptote is a value the output gets closer and closer to as $x$ goes toward infinity, without ever reaching it. Comparing degrees tells me which case I'm in: bottom-heavy means the asymptote is $y = 0$, equal degrees means it's the ratio of the leading coefficients, and a heavier top means there's no horizontal asymptote at all. And if the top degree is exactly one higher than the bottom, there's a slant asymptote instead, a slanted line I can find with polynomial long division.
Why it was meaningfulThese were the first graphs where I could figure out everything before drawing anything. The zeros of the denominator tell me where the function breaks, comparing the degrees gives me the horizontal asymptote, and a sign chart tells me where each branch sits. Once I had all of that worked out, the sketch was basically already done before I started graphing anything.
In the worldThis shows up wherever something gets close to a limit it can't pass. The effective speed of a download climbs toward your connection's top speed as files get bigger, but the fixed startup cost keeps it just under. Average cost works the same way. Spreading a fixed cost over more units pushes the price per unit down toward the cost of the materials alone, and never below it. In each case the horizontal asymptote is that limit, the value it keeps getting near but never hits.
My Example
Downloading a file takes a fixed bit of latency to get started, plus the time to actually move the data. On a 100 Mbps connection, with a fixed startup latency of 50 ms (0.05 s) before any data moves, the total time for a file of size $s$ (in megabits) is the latency plus the transfer time, $0.05 + \frac{s}{100}$ seconds. Effective speed is the data over that total time, so $e(s) = \dfrac{s}{0.05 + s/100} = \dfrac{100s}{s + 5}$ once I multiply the top and bottom by 100. That leftover 5 is just the latency written as data, since at 100 Mbps a 50 ms delay is worth 5 Mb, so it acts like a fixed startup cost added onto every file.
Since the degrees of the numerator and denominator are equal, the horizontal asymptote is the ratio of the leading coefficients, which gives $\frac{100}{1} = 100$. So the effective speed climbs toward the full 100 Mbps as files get bigger, but never quite reaches it, because the startup latency always costs a little.
At $s = 5$, $e(5) = \frac{500}{10} = 50$ Mbps, only half the line speed, which is why a small file can feel slow even on a fast connection. Bigger files spread that fixed latency over more data, so they get closer to the full 100. The overhead matters less the more there is to download.
∴ effective speed approaches 100 Mbps but never reaches it, so small files pay most for latencyLogarithms
In plain termsBasically, a logarithm is the inverse of an exponent. Instead of asking what $10^{4.7}$ is, it asks what power 10 needs to be raised to in order to get a certain number. Since $b^x = a$ is the same statement as $\log_b(a) = x$, I can convert between the two forms depending on which one is easier to work with. It also tells me where logs break: an exponential with a positive base is always positive, so no exponent produces 0 or a negative number, which is why $\log 0$ and logs of negatives are undefined.
Why it was meaningfulWhen I was starting out with logarithms, they felt a bit confusing, and I felt like I'd have a hard time memorizing their structure. But once I understood that a log is just the inverse of an exponent, it connected back to the inverse functions I had already learned, and it made a lot more sense. It also became one of my main tools, because whenever a variable is stuck in an exponent, I can take the log of both sides and bring it down to where I can actually solve for it.
In the worldLogarithms show up anywhere growth is exponential and the question is how long, or how many steps. In finance, savings grow quickly once interest starts compounding, and debt can pile up just as fast, so figuring out how long money takes to double means undoing an exponent with a log. Games do the same thing with their levelling systems, and I've played games where the XP curve scales exactly like this.
My Example
A binary search finds a name in a sorted list of 1,024 entries by checking the middle entry and discarding half the list each time, so after $k$ checks there are $\frac{1024}{2^k}$ entries left. The search is done when one remains:
So 1,024 entries take at most 10 checks. A shorter list of 32 entries needs only $k = \log_2 32 = 5$. Going from 32 up to 1,024 makes the list 32 times longer, but it only adds 5 checks, since every time the list doubles the count goes up by just one. And that's what makes logarithms very useful. The list can get way bigger, but the number of checks barely changes.
∴ 1,024 entries need just 10 checks, and each doubling adds only oneSinusoidal Modeling
In plain termsA sinusoidal function is a sine or cosine wave that repeats forever. Four values control its shape: the amplitude (how tall the wave is), the period (how long one full cycle takes), the phase shift (where it starts), and the vertical shift (the midline it varies around). The constant $b = \frac{2\pi}{P}$ that sets the period comes straight from the unit circle: one full cycle is one full rotation, or $2\pi$ radians, so dividing by the period $P$ stretches that rotation to the right length. With those four values, I can model anything that rises and falls on a regular cycle.
Why it was meaningfulWhat made this click was seeing that a wave is just the unit circle unrolled over time. The sine value is the same $y$-coordinate I was tracking around the circle for the whole unit, and once the angle keeps going past $2\pi$, that coordinate traces out a wave. From there, the graph wasn't really something new, and the transformations were essentially the same rules I already knew from earlier units.
In the worldAnything that repeats on a regular cycle can be modeled with a sine or cosine. Tides rise and fall on a roughly twelve-hour cycle, and the hours of daylight swing up and down across the year. In computing, daily traffic to a website follows the same shape, peaking in the afternoon and dropping off overnight, which is exactly what you'd model to plan things like server capacity or even autoscaling.
My Example
A website's traffic peaks at 900 requests per second at 2 PM and bottoms out at 100 req/s at 2 AM, with $t$ in hours after midnight. The amplitude is $A = \frac{900-100}{2} = 400$, the midline is $D = \frac{900+100}{2} = 500$, and a period of 24 hours gives $b = \frac{2\pi}{24} = \frac{\pi}{12}$. Since the peak happens at t=14, and cosine naturally starts at its maximum point, it makes sense to center a cosine there instead of shifting a sine function.
The servers need to autoscale once traffic passes 700 req/s, so I set $R(t) = 700$ and solve: $\cos\!\left(\tfrac{\pi}{12}(t-14)\right) = 0.5$, which gives $\tfrac{\pi}{12}(t-14) = \pm\tfrac{\pi}{3}$, so $t - 14 = \pm 4$ and $t = 14 \pm 4$.
∴ the autoscale window is open from 10 AM to 6 PM when traffic exceeds 700 req/sComposite Functions
In plain termsA composite function feeds one function into another. In $f(g(x))$, I work from the inside out: evaluate $g$ at $x$ first, take what it returns, and use that as the input for $f$. The order matters, since $f(g(x))$ usually isn't the same as $g(f(x))$. The domain of the composition is also restricted to $x$-values where $g(x)$ falls within $f$'s domain. If $f$ can't accept what $g$ outputs, those inputs are excluded entirely.
Why it was meaningfulThis is the concept that connected most directly to programming for me. $f(g(x))$ works the same way as a nested function call in code, where the inner function runs first, returns a value, and that value gets passed into the outer function. The notation is different, but the idea is the same, and it felt like something I had already seen through programming in the past.
In the worldCompositions show up any time one quantity depends on another that depends on a third. Uploading a photo can be broken into a chain like that. The compressed file size depends on the compression setting, and the upload time depends on the file size, so upload time as a function of the compression setting is a composition of the two. Change the setting and you get a new size, which gives a new upload time.
My Example
A phone stores photos at about 4 MB each. If $g(n) = 4n$ gives the total size of $n$ photos, and $f(s) = \frac{s}{8}$ gives the upload time in seconds for $s$ MB on an 8 MB/s connection, then working from the inside out:
To check it, 20 photos come to $g(20) = 80$ MB, and $f(80) = \frac{80}{8} = 10$ seconds, which matches $f(g(20)) = 0.5(20) = 10$. The domain makes sense too: a photo count can't be negative, so the composition is restricted to $n \ge 0$, and since every size $g$ returns is non-negative, it always stays inside the domain of $f$.
∴ the composition converts a photo count directly into an upload timeLooking Back
How has my understanding of functions evolved?
At the start of this course, a function was basically a formula that I plugged numbers into. Now I see a function as a relationship between an input and an output, where the equation is just one way of writing that relationship down. The bigger change was in how I learned. Instead of memorizing rules, I started trying to derive them, like building the special triangles from the Pythagorean theorem or pulling the trig identities off the unit circle. The trig unit was where that clicked most for me. I kept mixing up the special-triangle values until I started drawing the 30-60-90 triangle each time instead of trying to recall them, and after that they stuck. When I build something myself, I can actually see where it comes from, and if I forget it, I can rebuild it instead of being stuck.
Which concept will be most useful beyond school?
Composite functions, because they map directly onto how I write code. Programming is basically functions feeding into other functions, where one returns a value and the next one uses it. $f(g(x))$ is the same pattern written mathematically, so going into Computer Science, this is the concept I'll be using constantly without even thinking about it. And I think Logarithms are a close second, since $\log n$ is a big part of how algorithm efficiency gets measured.
How do the units connect?
The units within the course started feeling more connected once I realized that these were the exact same concepts and tools being applied. For instance, the same shifts and stretches that move a parabola around are what set the amplitude and period of a sine wave, or slide a rational graph left and right. It felt more like an extension or continuation than four separate topics.