The Reference Shelf

ANOVA takes the total scatter in your test data and books it against the factors that could have caused it — so you can say whether the difference between three fixtures is real or just the noise wearing a costume.

The bathtub curve is the observation that a population of hardware fails fast when it's new, settles into a long stretch of rare random failures, and then starts failing fast again when it's old — and that each of those three regions calls for a different engineering response.

The math that turns "the test lit up" into "the odds the unit is actually broken" — by folding in how often units are broken in the first place.

The math for "I ran n independent pass/fail trials, each with the same success chance p — how many passes should I expect, and how surprised should I be by the count I got?"

Add up enough independent random contributions and the total comes out bell-shaped, no matter what the individual contributions look like — which is why averages behave even when raw data doesn't.

The distribution you get when you square a bunch of independent bell-curve numbers and add them up — which is exactly what a variance is made of, so it's the ruler behind every "how sure are we about the spread" question.

A way to check whether the counts you actually observed are far enough from the counts a model predicts that the gap can't be blamed on random luck.

The math for "given that this already happened, what are the odds of that" — and the separate question of whether the two events actually have anything to do with each other.

A confidence interval is the honest version of your measurement: not "the mean is 4.02," but "the mean is 4.02, and given how much this data scatters, the procedure that produced this range captures the true value 95% of the time."

A pair of numbers that tell you whether two measured things move together, and a scaled version of the first that tells you how tightly — not why.

The handful of numbers that stand in for a whole data set so you can talk about it without reading every row.

DOE is how you plan a test matrix so that every run earns its keep — you vary several factors at once, on purpose, in a pattern that lets the math untangle which factor did what.

Two numbers that summarize a noisy quantity: expected value is where it sits on average, variance is how far it wanders around that center.

Look at the data with your eyes and a few simple plots before you fit a single model to it.

The reference curve that tells you whether a ratio of two variances is bigger than random luck would produce, which is exactly the question every ANOVA table asks.

A factorial design runs every combination of every factor setting, so the data itself can tell you which knobs matter — and which knobs only matter together.

Start from the one event you cannot allow — inadvertent launch, motor ignition, loss of vehicle — and work backward through AND/OR logic to every combination of component failures that produces it, then put numbers on each combination.

Hypothesis testing is the formal way to answer one question: is the difference I measured a real effect, or just the scatter my setup produces on any given Tuesday?

The bell curve you get when you take the logarithm — the right model whenever a quantity can't go negative and the random effects multiply instead of add, like fatigue life or repair time.

Before you blame the process for the scatter in your data, run the same parts through the same gage with different operators and find out how much of that scatter is the gage.

The standard bookkeeping behind every "± what?" on a cal certificate: list every error source, express each one as a standard deviation, root-sum-square them, multiply by 2.

Instead of deriving how uncertainty propagates through your model, you run the model ten thousand times with randomly drawn inputs and read the answer off the histogram.

MTBF is the average operating time between failures of a repairable system during its useful life — a failure-rate statement, not a lifetime, and the difference is where programs get hurt.

Fit one straight-line-style model that predicts a measured response from several inputs at once, so you can see what each input does with the others held still.

The bell-shaped curve that random measurement error, thermal noise, and stacked tolerances almost always follow — two numbers, mean and sigma, tell you the whole story.

Outlier detection is the arithmetic that lets you exclude one wild test point from a report and defend the exclusion when the review board asks.

The distribution of "how many" when events land randomly and independently at a steady average rate — defects per board, failures per operating year, hits per antenna scan — with one number, the average count, controlling everything.

The PDF is the shape of the scatter; the CDF is the running total under it — and the CDF is the one that actually answers "what fraction of my units fail the spec."

Rank your failure times, assign each one a percentile, and plot them on a scale rigged so the right distribution comes out as a straight line — if it's straight, the model fits, and the slope and intercept are your parameters.

One number that says whether your process actually fits inside the customer's spec limits — and by how much margin.

Propagation of uncertainty is the bookkeeping that turns the error bars on your inputs into the error bar on your answer: weight each input's uncertainty by how hard the output leans on it, square, add, take the root.

A percentile is the value that a stated fraction of the data falls at or below — the number you quote when the mean would hide exactly the behavior you care about.

A random variable is the honest way to write down a quantity you can measure but not predict — a rule that assigns a number to every way the experiment can come out.

The reliability function is the fraction of units still alive at time t; the hazard rate is how fast the survivors are dying right now.

The average of N readings is itself a measurement with its own scatter, and that scatter shrinks by the square root of N — which is why averaging works, and why it stops paying off faster than anyone wants.

A running plot of a process measurement with limits set three standard deviations off the center line, so you know whether a wiggle is just the process being itself or something you need to go find.

Fit the one straight line that misses your data points by the least total squared amount, and get the slope, the offset, and an honest number for how much scatter is left over.

Power is the probability your test actually catches the difference you built it to catch — and the sample-size equation is what that probability costs in units on the stand.

A framework for running a process off its own data: characterize the noise the process makes when nothing is wrong, then only stop the line when a point says something actually changed.

The bell curve you actually earned: when the standard deviation in your error bar came from the same handful of readings as the mean, the correct multiplier isn't 1.96 — it's this distribution, and at small n it is a lot bigger.

Multiply component reliabilities along every path the system needs to survive, and the diagram tells you whether the box meets the number the program promised.

The standard way to decide whether a difference in averages is real or just the noise in your sample — built specifically for the small-n world engineers actually live in.

The rules that let you break the sine or cosine of two angles added or subtracted into pieces you can compute from each angle separately.

If you take a time derivative while sitting on something that spins, you have to add correction terms — and those terms are where centrifugal, Coriolis, and Euler forces come from.

The true distance you'd travel walking along a curve, not the straight shot from end to end.

Any 3D rotation, no matter how you got there, is just one spin of a certain angle about one fixed axis — and axis-angle is the pair of numbers that says which axis and how far.

The math that lets a CAD kernel describe any smooth curve or freeform surface exactly, from a straight edge to a fillet to a circle, using a handful of control points and a list of weights.

A smooth curve you steer with a handful of control points instead of writing an equation — drag the points, the curve follows, and it never wanders outside the box you drew.

A grid of straight, perpendicular axes that pins down any point in a plane or in space with a short list of signed distances — x, y, and if you need it, z.

The one point where a shape or an object balances — where you could hold it, hang it, or pick it up and it would not want to tip.

Conic sections are the four curves you get by slicing a cone — circle, ellipse, parabola, hyperbola — and one number, eccentricity, tells you which one you're holding, whether it's an orbit, a dish, or a cam lobe.

The bookkeeping that lets you take a load, a measurement, or an orientation described in one frame and restate it correctly in another.

The operation that takes two vectors in 3-D space and hands you a third vector perpendicular to both, with a length equal to the area of the parallelogram they span.

Curvilinear coordinates are any grid that bends to fit the hardware — polar, cylindrical, spherical — and the scale factors are the exchange rate between a change in coordinate and actual distance moved.

Polar coordinates with a z-axis bolted on — you locate a point by how far out from the axis it sits, how far around, and how far along, which is exactly how pipes, shafts, and coax want to be described.

The family of formulas that turn "how far apart are these two things" into a number you can compare against a tolerance — point to point, point to line, point to plane, line to line.

An ellipse is a stretched circle with two focus points instead of one center, and eccentricity is the single number that says how far it is from being round.

The flat-surface geometry of points, lines, angles, triangles, and circles — the rulebook every drawing, layout, and tolerance stack silently assumes.

Three angles — yaw, pitch, roll — that tell you which way a rigid body is pointing, in the one format a human can actually read off a display.

The rules for moving, spinning, mirroring, and resizing geometry without lying about it — every CAD mirror, pattern, and scale command is one of these, and they compose by matrix multiplication.

Any sum of same-frequency sinusoids — no matter how many, no matter their phases — is just one sinusoid at that frequency, and this theorem hands you its amplitude and phase.

The exponential function split into its even and odd halves — cosh and sinh — which is why they show up anywhere physics hands you `y'' = +k²·y` instead of `y'' = −k²·y`.

The functions that turn a measured ratio back into an angle — and atan2 is the only one of the family that hands the angle back without losing the quadrant.

Pythagoras for triangles that don't have a right angle — one cosine term pays for the missing 90°.

In any triangle, each side divided by the sine of its opposite angle gives the same number — so two angles and one side, or two sides and one angle, hand you the rest of the triangle.

The two equations that let you tell a machine exactly where a straight edge or a flat surface sits in 3D — a point plus a direction for the line, a point plus a normal for the plane.

Mohr's circle is the graph that shows every normal-and-shear stress pair you can get at one point in a part just by tilting the plane you cut it on — the whole stress state, one circle, read with a ruler.

Flatten a 3D part onto a drawing plane by dropping every point straight down onto it — no perspective, no vanishing points, so every dimension parallel to the paper reads true.

A parametric curve is a path described by where you are at each value of a single knob — usually time — instead of by an equation the coordinates have to satisfy, which is why every toolpath, trajectory, and cam profile is written this way.

Polar coordinates locate a point by how far out it is and which direction it's in — range and bearing — instead of how far east and how far north, which is why anything that radiates or rotates gets described this way.

Principal axes are the orientations where a symmetric tensor — stress, strain, inertia — drops its cross terms and acts as pure push, pull, or spin, and the principal values are the numbers it acts with.

Four numbers that store a 3D orientation with no singularities — the reason your IMU can point straight up without the math falling apart.

One 4×4 matrix that carries both where a part sits and which way it faces, so chaining frames through a robot arm or a CAD assembly is just matrix multiplication.

A 3×3 grid of direction cosines that carries a vector from one coordinate frame to another — the piece of math that every attitude estimate, robot arm, and sensor alignment in the building ultimately runs through.

The working rules for volume, surface area, and angle on the shapes a machinist can actually make — prisms, cylinders, pyramids, cones, spheres, and the flat-faced solids in between.

Spherical coordinates locate a point by range and two angles — how far away, how far off the vertical axis, and which way around — which is exactly the language of anything that radiates from a point or gets measured off a gimbal.

Two triangles with the same angles are the same triangle at different sizes — which means one measurement you can make buys you the measurement you can't.

Measure any three of a triangle's six parts — as long as one of them is a side — and you can compute the other three; triangulation is that fact scaled up, turning one taped baseline and a stack of angle readings into positions nobody had to walk to.

Sine, cosine, and tangent turn an angle into a ratio — which is how every force gets split into components, every waveform gets written down, and every phase gets measured.

The small set of exact equalities between sines and cosines that lets you turn a product of signals into a sum of frequencies, a messy two-term waveform into one amplitude and one phase, and a page of algebra into a line — before you touch a computer.

The arithmetic of quantities that carry a direction as well as a size — forces, velocities, moments, fields — where adding two of them means adding components, not magnitudes.

Projection answers "how much of this force acts along that member," and direction cosines are the three numbers that define which way the member points.

A shorthand for how the cost of an algorithm grows as the input gets big, ignoring the constants that stop mattering once the input is large enough.

A recipe for expanding `(a + b)ⁿ` into a sum of terms, where the coefficient on each term is the same number that tells you how many ways k things can happen out of n.

The two-value algebra — everything is 0 or 1 — that every relay, logic gate, PLC rung, and `if` statement obeys, whether the person who wrote it knows the rules or not.

The hard ceiling on how many bits per second a link can carry error-free, set entirely by its bandwidth and its signal-to-noise ratio — no modulation scheme, no amount of engineering, gets past it.

Combinational logic decides its outputs from the current inputs alone; sequential logic remembers, so its outputs depend on the inputs plus whatever state it stored.

Finding the single best choice out of a finite but astronomically large pile of options — the best schedule, the best route, the best assignment — when the answers have to come out as whole units, not fractions.

An error-correction scheme that smears each data bit across several transmitted bits using a small shift register, then reconstructs the original stream at the receiver by finding the most likely path through a trellis.

The graph algorithm that finds the longest chain of dependent tasks through a project, because that chain is the one that sets your delivery date.

A one-way meat grinder for data: feed in a file of any size, get back a fixed-length fingerprint that changes completely if a single bit changed, and that nobody can run backward.

A CRC is the remainder left over when you divide your message by an agreed-on polynomial — the receiver runs the same division, and if the remainder doesn't match, the frame is bad.

A way to line up tasks that depend on each other so nothing runs before the thing it needs — and a built-in alarm that goes off when the dependencies loop back on themselves.

Squeezing the redundancy out of a data stream so it takes fewer bits to store or send, without losing anything you need back.

The rules you pick for how data sits in memory, which decide what's cheap to do with it and what's expensive.

Adding structured redundancy to data so a receiver can notice when bits got flipped in transit — and, if you spent enough redundancy, fix them without asking for a resend.

A model where a system sits in exactly one of a finite set of named states, and inputs move it from state to state along defined transitions — nothing else about its history matters.

Doing real-number math with plain integers by agreeing, ahead of time, where the binary point sits — the number in the register is always the real value times a fixed power of two.

A graph is the stripped-down model of anything made of things and connections — nodes and the links between them, with every irrelevant detail thrown away on purpose.

A systematic way to walk every node a network can reach from a starting point — so "is A connected to B" becomes a procedure instead of an argument.

A way of counting in binary where each step changes exactly one bit, so a sensor caught mid-transition can only ever be off by one count instead of half the scale.

A Hamming code adds a few parity bits to a block of data so that when one bit flips — cosmic ray, noisy bus, dying DRAM cell — the hardware can not only notice the error but compute exactly which bit it was and flip it back.

A hash function turns any key — a channel name, a message ID, a whole file — into a number you can use as an array index, and a hash table is the array built around that trick so lookup takes the same time whether it holds forty entries or forty million.

Taking a truth table and finding the fewest gates that still tell the same truth — by eye on a Karnaugh map when the function is small, by algorithm when it isn't.

The minimum spanning tree is the cheapest set of cable runs that gets every node on the network — no loops, no spares, nothing you didn't pay for.

Arithmetic on a number line bent into a circle of size `n` — the reason a 16-bit counter rolls from 65535 to 0, and the reason your uptime math broke on day 50 of the soak test.

A number base is the agreement about what each digit position is worth — the same quantity is 500, 0x1F4, or 0b111110100 depending on whether the positions count by tens, sixteens, or twos.

A parity bit or checksum is a small number computed from your data and sent along with it, so the receiver can recompute it and find out — cheaply, but not certainly — whether the data survived the trip.

Permutations count the ways to arrange things when order matters; combinations count the ways to pick things when it doesn't — and the difference between the two is a factor of k! that quietly wrecks probability calculations when you grab the wrong one.

The math of whole true-or-false statements — take sentences like "door closed" and "pressure OK," glue them together with AND, OR, NOT, and IF-THEN, and a truth table tells you exactly what the compound statement does in every case.

A pseudorandom number generator is a deterministic recipe that turns one seed into a long stream of numbers that pass every statistical test for randomness — until you exceed its period or hit its hidden structure.

A recurrence relation defines each value of a sequence from the values before it — the discrete world's differential equation, and the update law running inside every digital filter, control loop, and recursive algorithm you own.

Recursion is defining a thing in terms of a smaller copy of itself, plus a base case that stops the copying — the pattern behind every tree walk, parser, and divide-and-conquer routine you'll ever debug.

A Reed-Solomon code appends parity symbols to a block of data so the receiver can reconstruct the original exactly, even after a noise burst wipes out a run of it — which is why a scratched disc still plays and a scuffed QR code still scans.

A compact pattern language for finding and pulling text out of files — you describe the shape of the string you want, and a small state machine walks the file and finds every match.

A set is a collection of distinct things treated as one object, and set theory is the bookkeeping for combining, comparing, and counting those collections — the grammar underneath requirements matrices, database queries, and probability.

The average number of bits a source actually produces per symbol — which makes it the floor under every lossless compressor and the honest starting point of every data-rate budget.

The family of procedures — Dijkstra, Bellman–Ford, A* — that finds the cheapest route through a weighted network, whether the cost is miles, milliseconds, hops, or dB of loss.

Sorting is paying an up-front cost of about `n·log₂ n` comparisons to put data in order; searching that ordered data then costs `log₂ n` instead of `n` — and that trade is the reason your million-row telemetry script finishes before lunch or doesn't.

A tree is a network with no loops — every node reaches every other node by exactly one path — which is why anything genuinely hierarchical, from a fault tree to a file system, ends up drawn as one.

The convention every processor uses to store negative integers — the top bit counts as negative instead of positive — which is why one adder circuit handles signed and unsigned math alike, and why every counter eventually wraps.

If you know two x-values that straddle the answer — one where your equation comes out too high, one where it comes out too low — bisection keeps cutting the gap in half until it pins the root.

Split a symmetric positive-definite matrix into a lower-triangular factor times its own transpose, so you can solve the system in half the work of ordinary Gaussian elimination.

A single number that tells you how many digits of accuracy your matrix solve is going to throw away before you even run it.

Drawing the best line or curve through scattered measurements so you get one equation you can actually plug numbers into.

One number computed from a square matrix that tells you whether the matrix is invertible and how much it stretches or shrinks volume.

An eigenvector is a direction a matrix doesn't rotate — it only stretches it — and the eigenvalue is the stretch factor.

Take the slope where you are, step forward by that slope times a little time, and repeat — it's the crudest way to march a differential equation through time, and it's the shape of every simulation loop you've ever written.

Chop the domain into a grid, and approximate every derivative in your equation by subtracting neighboring grid values and dividing by the spacing.

Chop a complicated part into thousands of simple little pieces, write down the stiffness of each one, add them all up, and solve one big matrix equation for how the whole thing deflects.

The scheme every computer uses to squeeze a real number into a fixed number of bits — which means most numbers you type in aren't the numbers it actually stores.

The bookkeeping trick for solving a set of simultaneous linear equations: add scaled copies of one equation to the others until every unknown drops out but one, then back out the rest.

A way to compute an integral by sampling the function at a handful of oddly-placed points — placed so well that n samples buy you the accuracy of a polynomial of degree 2n−1.

The matrix equation behind every modal run: given a structure's stiffness matrix and mass matrix, find the frequencies it wants to vibrate at and the shapes it takes when it does.

Multiply two vectors component by component and add it up — the single number that comes out tells you how much the two point the same way.

Pick the model coefficients that make the sum of the squared misses between your model and your data as small as it can get.

Split a square matrix into a lower-triangular factor times an upper-triangular factor — Gaussian elimination with the receipts kept — so you pay for elimination once and solve every new right-hand side almost for free.

A matrix is a rectangular block of numbers that stands in for a whole linear system at once, with an arithmetic that lets you stack, chain, and solve those systems the way you'd add and multiply ordinary numbers — mostly.

The inverse of a matrix is the matrix that undoes it — apply `A`, then `A⁻¹`, and you're back where you started — and it exists only when `A` hasn't destroyed any information along the way.

The pseudoinverse is the matrix you use when `A⁻¹` doesn't exist — it hands back the least-squares answer when you have too many equations and the smallest consistent answer when you have too few, and it does both from the same formula.

Guess a root, slide down the tangent line to where it crosses zero, and call that your new guess — repeat until the answer stops moving.

Fit a curve whose parameters live inside an exponential, a resonance peak, or some other nonlinear expression — by guessing, linearizing, and correcting until the squared misses stop shrinking.

Estimating a derivative from sampled values by dividing a difference in the function by a difference in the input — cheap, universal, and a noise amplifier if you use it carelessly.

Numerical stability is the property that separates a formula that survives floating-point arithmetic from one that quietly hands you garbage — two expressions that are equal on paper are not equal in code.

A matrix that rotates or reflects without stretching anything — lengths in, lengths out — which is why it's the one matrix you can multiply by a million times and still trust the answer.

The math behind reading between table entries: given n+1 data points with distinct x-values, exactly one polynomial of degree n or less passes through all of them, and its error formula tells you how much to trust the space between your calibration points.

A symmetric matrix that behaves like a physical spring — load it in any direction and it stores positive energy — which is why stiffness and covariance matrices earn the fastest solvers and the strongest guarantees in numerical work.

Split a data matrix into an orthonormal factor times a triangle — a rotation and a ledger — so you can fit noisy test data by least squares without squaring the condition number first.

Every floating-point number carries a tiny error from being rounded to finite bits, and subtracting two nearly equal numbers can promote that tiny error into the whole answer.

A family of recipes for marching a differential equation forward in time by sampling the slope at several trial points inside each step and taking a weighted average — RK4 and ode45 are the two members every engineer has actually used.

Integrate evenly sampled data by fitting a parabola through every three points instead of a straight line through every two — same samples, roughly two extra digits of accuracy.

The factorization that takes any matrix apart into a rotation, a stretch, and another rotation — and in doing so hands you its rank, its condition number, and its best low-rank approximation all at once.

A matrix with so many zeros that you store and compute on only the nonzeros — the trick that lets a million-DOF FEA model solve on a workstation instead of not solving at all.

Instead of forcing one high-degree polynomial through all your data points, lay a modest cubic on each span and stitch the pieces together so smoothly that position, slope, and curvature all match at the joints.

A stiff ODE is one where the solver's step size is dictated by stability instead of accuracy — the fix is an implicit method that computes each step from where the system is going, not where it's been.

The two big matrices your FEA model boils down to — K says how hard the structure pushes back when you deflect it, M says how much inertia fights you when you shake it — and everything the solver does is arithmetic on those two objects.

A matrix that equals its own transpose (or, for complex entries, its own conjugate transpose) — the shape that stiffness, mass, covariance, and inertia matrices always take, and the single property numerical solvers exploit hardest.

A stack of equations where every unknown shows up to the first power only — write them as `A·x = b`, and if the matrix cooperates, one set of values satisfies all of them at once.

Estimate the area under sampled data by connecting the dots with straight lines — average each pair of neighboring samples, multiply by the time between them, and add it all up.

A norm is the single number you agree to call the "size" of a vector or matrix — and the norm you pick decides whether a residual counts as small, whether an error budget closes, and what "gain" means.

The sines and cosines of anything round — the wave shapes that show up whenever a problem lives on a circle, a cylinder, or a sphere instead of a straight line.

A family of polynomials that wiggle between +1 and -1 as evenly as possible, which turns out to be exactly what you want when you need a filter's ripple spread out flat or a curve fit that doesn't blow up at the edges.

Convolution slides one function backward across another and integrates the overlap at every position — it is the operation that turns an impulse response and an input into a system's output.

The derivative is how fast one thing changes when another thing changes — the instantaneous slope of a curve, read off at a single point.

The step is a switch that flips on at t = 0 and stays on; the delta is an infinitely short, infinitely hard hit with a total punch of exactly one — the two idealized inputs every impulse response and step response is defined against.

The DFT takes N samples of a signal and tells you how much of each of N evenly spaced frequencies is in it — and the FFT is the trick that makes computing it fast enough to be useful.

Whatever a vector field is doing inside a closed volume, you can measure it by watching what crosses the surface — the books have to balance.

The error function is the running area under a bell curve — hand it a distance from center in the right units and it hands back the probability of landing inside that distance.

A Fourier series takes any repeating waveform and rewrites it as a DC level plus a stack of sine waves at integer multiples of the repetition rate — so every question about the waveform becomes a question about its harmonics.

The Fourier transform takes a one-shot signal — a pulse, a transient, an edge — and tells you exactly how much of every frequency it contains, turning time-domain questions about shape into frequency-domain questions about bandwidth.

Adding up a rate over time and finding the total change are the same operation run in opposite directions — which is why an odometer and a speedometer are wired to the same wheel.

Three ways to take a derivative of a field: gradient tells you which way uphill, divergence tells you where stuff is being created or drained, and curl tells you how much the field spins.

The Helmholtz equation is what the wave equation turns into when you commit to a single frequency — one PDE that decides where a cavity resonates, where a waveguide cuts off, and what an antenna radiates.

A filter that shifts every frequency in a signal by 90 degrees, so you can pair the original with its shifted twin and read off amplitude and phase directly.

The trip back from the s-domain to time: you have a transfer function or an s-domain response, and you want the actual voltage, position, or temperature versus t.

The Jacobian is the matrix of partial derivatives that tells you how a coordinate change stretches, rotates, and skews space right at a point — and its determinant is the local scale factor you multiply by so the numbers still mean the same thing.

The standard way to optimize one quantity while a constraint pins down another: instead of eliminating variables, you add an unknown multiplier per constraint and solve for everything at once.

The Laplace transform turns a linear differential equation in time into an algebraic equation in the complex variable `s`, so you solve a circuit or a control loop with division and partial fractions instead of calculus.

Laplace's equation is what a field looks like after it has finished settling — no sources, no sinks, no time left in the problem — so every point sits exactly at the average of its neighbors.

The value a function is heading toward as its input closes in on a point — and whether the function actually gets there without a jump, gap, or blow-up.

Adding up a field as you march along a path or spread across a surface — that sum is the work, the EMF, or the flux you actually care about.

Adding up a quantity that's spread out over an area or a volume, one tiny piece at a time, instead of along a single line.

Sample faster than twice the highest frequency in the signal and the samples hold everything; sample slower and the high frequencies don't disappear — they come back wearing a lower frequency's name.

The total energy in a signal comes out the same whether you add it up sample-by-sample in time or bin-by-bin in frequency — the transform moves the energy around but never creates or destroys any of it.

How much the output moves when you nudge one input and hold everything else still.

An equation that ties a quantity's rate of change in one direction to its rates of change in the others — the language every field problem in temperature, stress, flow, and fields is written in.

A way to read whether a system will settle down, oscillate forever, or run away — by looking at the shape of its motion instead of solving for the motion.

The handful of points in the complex plane where a system's transfer function blows up (poles) or drops to zero (zeros), and where they sit tells you whether the thing is stable, how it rings, and how fast it responds.

A way to rebuild a function out of an infinite polynomial, valid only inside a circle whose radius tells you where the model quits.

A closed-loop integral in the complex plane equals nothing but the sum of the pole contributions inside the loop, so you replace a hard integral with a short list of algebraic residues.

A trick for solving a partial differential equation by guessing that the answer is a product of one-variable functions, which splits the hard equation into a set of easy ones you already know how to solve.

The sin(x)/x hump that shows up every time you sample a signal, filter it sharply, or point a flat antenna at something.

The circulation of a field around the edge of a surface equals the total swirl (curl) poking through that surface — so you can measure a loop's worth of behavior by looking only at what happens on the rim.

When more than one thing changes at once and each rate depends on the others, you stack them into a vector and let one matrix run the whole show.

Rebuild any smooth function as a polynomial using only its derivatives at one point — then keep just the terms you need, which near that point is usually one or two.

The handful of algebra tricks that turn an integral you can't do into one you already know.

The Laplace transform for sampled signals — it turns a difference equation running at your loop rate into algebra, so you can read stability and frequency response off pole locations instead of stepping code.

A set of bookkeeping rules for collapsing a wiring diagram of transfer-function blocks — controller, plant, sensor — into one input-to-output transfer function you can actually analyze.

A Bode plot is the pair of graphs — gain in dB and phase in degrees, both against log frequency — that shows what a system does to a sine wave at every frequency you care about.

If your problem has a pile of physical variables, count the fundamental dimensions among them, subtract, and that's how many dimensionless knobs actually control the answer — the rest is just units.

Correlation slides one signal past another and scores how well they line up at each offset — and if the second signal is a delayed copy of the first, the score peaks at exactly the delay.

Taking a control law that works on paper in continuous time and making it still work when a microcontroller runs it once every sample tick.

An FIR filter is a weighted average of the last N input samples — no feedback, always stable, and if you make the weights symmetric it delays every frequency by exactly the same amount, which is why it's the default filter in DAQ and comms firmware.

Gain margin and phase margin are the two numbers that tell you how much extra gain or extra phase lag your feedback loop can absorb before it turns into an oscillator.

Walk downhill on an error surface by repeatedly stepping in the direction that drops the number fastest, until you can't do any better.

An IIR filter feeds its own past outputs back into the calculation, which buys you an analog-grade frequency response for a handful of multiplies per sample — at the price of nonlinear phase and a stability problem you have to manage yourself.

A recursive algorithm that blends a model's prediction with a noisy measurement, weighting each by how much you trust it, to produce the best running estimate of a system's state.

The math for squeezing the best number out of a decision when your goal and all your limits are straight-line relationships.

If a system responds the same way to a kick no matter when you kick it, and twice the kick gives twice the response, then one measurement — the impulse response — tells you its output for every input it will ever see.

Four coupled field equations that say charge makes electric field, current and changing electric field make magnetic field, changing magnetic field makes electric field — and everything RF descends from them.

The math that tells you a structure's natural frequencies and the shapes it prefers to wiggle in, so you can keep your drive frequencies off them.

Plot your open-loop frequency response as one curve in the complex plane, count how many times it wraps around the -1 point, and you know whether the closed loop will be stable — without ever solving for the closed-loop poles.

The control law that turns three questions — how far off am I, how long have I been off, and which way is it heading — into one actuator command, plus the tuning math that keeps the answer from oscillating.

A PSD tells you how a random signal's mean-square power is spread across frequency — the g²/Hz curve on a vibration spec is literally how much squared acceleration lives in each one-hertz slice.

Taking a shaker environment described as a power spectral density and predicting how hard a part actually shakes — its RMS acceleration, its 3-sigma peak, and whether it survives.

A picture of where a feedback loop's closed-loop poles slide in the complex plane as you crank one gain knob from zero to infinity, so you can see stability and ringing before you ever touch the hardware.

A pencil-and-paper bookkeeping table that tells you whether a control loop's characteristic polynomial has any roots in the right-half plane — i.e. whether the loop is stable — without ever solving for the roots.

The ratios of reflected and transmitted waves to incident waves at each port of an RF device — the numbers a network analyzer actually measures.

A plot of how hard a shock would ring a whole family of simple spring-mass oscillators, one dot per natural frequency, so you can specify and pass a shock test without arguing over the exact shape of the time history.

A way to write a system's dynamics as one first-order matrix equation for how its internal state changes, plus a second one for what you actually measure.

How small wiggles in several inputs add up into one wiggle in the output — each input scaled by how much the output cares about it.

A window is the taper you multiply onto a signal record before the FFT so the chopped-off ends don't smear energy across the whole spectrum — and every window trades amplitude accuracy against frequency resolution.