Three Hard Problems, One Method: Chaining Math Calculators

A single calculator gives you one answer. But a real problem — where a ball lands, whether a score is an outlier — is never one answer. It is a chain of them. That is the oldest trick in mathematics: you do not solve the whole thing at once, you break it into sub-problems, hand each piece to a method that already solves it, and recombine the pieces into the final result. The LK Forge math calculators are exactly those "methods" — so below we take three genuinely multi-step problems and solve each one end to end, passing the output of one calculator straight into the next.

The method: decompose → solve → recombine

Every worked example below follows the same three moves. Decompose: name the sub-questions hiding inside the big one. Solve: for each sub-question, pick the single calculator built for it and feed it the numbers the previous step produced. Recombine: assemble the sub-answers into the thing you were actually asked. Each problem ends with its calculator chain — the exact tools, in order, that carried the solution.

A ball thrown off a ledge

1. Put the model in standard form — Polynomial Calculator

   Physics handed us 5 + 40t − 16t². Every algebra tool downstream expects the standard descending order −16t² + 40t + 5, so we tidy it first and read off the coefficients: a = −16, b = 40, c = 5. Those three numbers are the input to the next step.

2. Find the landing time — Quadratic Formula Calculator

   "Hits the ground" means h(t) = 0: solve −16t² + 40t + 5 = 0. The discriminant is b² − 4ac = 1600 − 4(−16)(5) = 1920, and √1920 = 8√30 ≈ 43.82. That gives t = (−40 ± 43.82) / (−32) → t ≈ −0.12 (before the throw, so we discard it) or t ≈ 2.62 s. The ball lands about 2.62 seconds later.

   Why not just factor it? Because 1920 is not a perfect square, the roots are irrational — the Factoring Calculator is the right tool when a quadratic has clean rational roots, but here the quadratic formula is what the numbers demand. Knowing which tool the numbers call for is half the method.

3. Get velocity, peak time and peak height — Derivative Calculator

   Velocity is the derivative of height: h′(t) = 40 − 32t. The ball is at its peak when velocity is zero, 40 − 32t = 0 → t = 1.25 s. Substitute back into the original height: h(1.25) = 5 + 50 − 25 = 30 ft. And impact speed is the velocity at landing: h′(2.62) = 40 − 32(2.62) ≈ −43.82 ft/s — about 43.8 ft/s downward. Notice that impact speed is exactly √1920 from step 2; the chain closes on its own arithmetic.

4. Total distance travelled — Integral Calculator

   Displacement is dull (it starts at 5 ft and ends at 0). Total distance is the area under the speed curve, ∫|h′(t)| dt, split at the peak. Going up: ∫₀^1.25 (40 − 32t) dt = [40t − 16t²]₀^1.25 = 25 ft. Coming down from the 30 ft peak to the ground adds 30 ft. Total path length ≈ 55 ft — and the 25 ft climb agrees with the 30 ft peak minus the 5 ft ledge, another internal cross-check.

Is that top score an outlier?

1. Find the center — Mean, Median & Mode Calculator

   The ten scores sum to 840, so the mean is 84. Sorted, the middle pair is 80 and 85, giving a median of 82.5, and 80 shows up three times for a mode of 80. The mean, 84, is the number every later step is measured against.

2. Measure the spread — Variance Calculator

   Square each score's distance from the mean of 84 and add them up: the squared deviations total 740. Dividing by n = 10 gives a population variance of 74. (If these ten scores were a sample of a larger class you would divide by n − 1 = 9 for a sample variance of ≈ 82.2 — the calculator reports both, so pick the one that matches your question.)

3. Back to score units — Standard Deviation Calculator

   Variance is in "points squared"; the standard deviation puts it back in points. √74 ≈ 8.60 (population), or ≈ 9.07 for the sample version. So a typical score sits about 8.6 points from the class average — that single number is the yardstick the last step needs.

4. Judge the 100 — Z-Score Calculator

   A z-score counts how many standard deviations a value is from the mean: z = (100 − 84) / 8.60 ≈ 1.86. The common rule of thumb flags a value as an outlier past |z| = 2. At 1.86, the top score is high but not a statistical outlier — a strong result inside the normal spread, not a data-entry error. The decision falls straight out of the number the previous three tools built.

Solve a system of three equations

First write the system as A·x = b, where A is the coefficient matrix and b is the right-hand side:

A = | 2   1  -1 |        b = |  8 |
    |-3  -1   2 |            |-11 |
    |-2   1   2 |            | -3 |

1. Is it even solvable? — Determinant Calculator

   A square system has one unique solution exactly when its coefficient matrix has a non-zero determinant. Here det(A) = −1. Non-zero, so A is invertible and the system has a single solution — worth knowing before you spend effort solving it. (A determinant of 0 would mean no unique solution, and a different approach.)

2. Build the solving tool — Matrix Inverse Calculator

   Because A·x = b, the solution is x = A⁻¹·b — so we need A⁻¹. With det(A) = −1 the inverse comes out in clean integers:

            |  4   3  -1 |
   A⁻¹ =    | -2  -2   1 |
            |  5   4  -1 |

3. Trust, but verify — Matrix Multiplication Calculator

   An inverse is only correct if A·A⁻¹ gives the identity matrix. Multiply the two and you get exactly I — ones on the diagonal, zeros everywhere else — which confirms the previous step before we rely on it:

   A · A⁻¹ = | 1  0  0 |
             | 0  1  0 |   ✓ identity
             | 0  0  1 |

4. Read off the answer — System of Equations / Matrix Solver

   Now compute x = A⁻¹·b with b = (8, −11, −3): x = 2, y = 3, z = −1. Substitute back into the first equation as a spot check: 2(2) + 3 − (−1) = 8 ✓. The matrix solver does this composition (inverse × vector) in one shot, but seeing the pieces is the point — every step is a calculator you can run on its own.

5. Sanity-check the shape — Matrix Rank Calculator

   One last guard: the rank of A is 3, equal to the number of unknowns. Full rank is the other side of the "non-zero determinant" coin — it confirms the three equations are genuinely independent and the unique solution we found is the whole story, not one of infinitely many.

The whole toolkit as one machine

None of the three problems needed a new, bigger calculator — each needed the small ones wired together in the right order. That is the point: a suite of focused, single-purpose tools is not a lesser thing than one giant solver. Compose them and you can walk a projectile from a raw physics model all the way to a landing speed, a pile of raw scores all the way to a defensible "not an outlier," or a system of equations from three lines of algebra all the way to a verified, unique solution. Pick the sub-problem, pick the tool, pass the result along.

Every calculator these three chains used: Polynomial, Quadratic Formula, Factoring, Derivative, Integral, Mean/Median/Mode, Variance, Standard Deviation, Z-Score, Determinant, Matrix Inverse, Matrix Multiply, Matrix Solve and Matrix Rank — fourteen of the math calculators, all free, all client-side, all showing their working.

Check every number yourself

None of the figures above are on faith. This self-contained script reproduces every result in both problems — no dependencies, node reproduce.mjs:

// Problem 1 — h(t) = -16t^2 + 40t + 5
const a = -16, b = 40, c = 5
const disc = b*b - 4*a*c                 // 1920
const root = (-b - Math.sqrt(disc)) / (2*a)   // landing time
const tPeak = -b / (2*a)                 // 1.25 s
const hPeak = a*tPeak**2 + b*tPeak + c   // 30 ft
const vLand = 2*a*root + b               // impact velocity
console.log({ disc, land: root.toFixed(2), tPeak, hPeak, vLand: vLand.toFixed(2) })
// { disc: 1920, land: '2.62', tPeak: 1.25, hPeak: 30, vLand: '-43.82' }

// Problem 2 — ten quiz scores
const d = [80,95,70,85,80,100,75,90,80,85]
const n = d.length
const mean = d.reduce((x,y)=>x+y,0) / n            // 84
const ssd  = d.reduce((s,v)=>s+(v-mean)**2, 0)     // 740
const popVar = ssd / n                             // 74
const popSD  = Math.sqrt(popVar)                   // 8.60
const z100   = (100 - mean) / popSD                // 1.86
console.log({ mean, popVar, popSD: popSD.toFixed(2), z100: z100.toFixed(2) })
// { mean: 84, popVar: 74, popSD: '8.60', z100: '1.86' }

// Problem 3 — system A x = b
const A = [[2,1,-1],[-3,-1,2],[-2,1,2]], bv = [8,-11,-3]
const det = A[0][0]*(A[1][1]*A[2][2]-A[1][2]*A[2][1])
          - A[0][1]*(A[1][0]*A[2][2]-A[1][2]*A[2][0])
          + A[0][2]*(A[1][0]*A[2][1]-A[1][1]*A[2][0])   // -1
const Ai = [[4,3,-1],[-2,-2,1],[5,4,-1]]                // A inverse (integer, det -1)
const x = Ai.map(row => row[0]*bv[0] + row[1]*bv[1] + row[2]*bv[2])
console.log({ det, solution: x })
// { det: -1, solution: [ 2, 3, -1 ] }

Where to go next

• All math calculators — the full suite, basic arithmetic through linear algebra.
• Quadratic Formula Calculator — the discriminant and both roots, step by step.
• Z-Score Calculator — standardise any value against a mean and standard deviation.