The Disc's Rim Speaks Only in Integers

The four numbers moulded into a disc’s rim — speed, glide, turn, fade — are all integers. Innova never stamps a 3.5. That stuck with me on the walk out of the park, because it means you can guess roughly where a disc will finish without ever typing a decimal point.

Fixed-point arithmetic is the whole trick: pick a scale — say everything is measured in tenths — and then a turn rating of −3.0 becomes the plain integer −30. Add, subtract, multiply; the decimal place lives in your head, not in the silicon. In the 1980s this was survival rather than nostalgia. A 6502 or a Z80 had no floating-point unit, so a single float meant a library call costing hundreds of cycles. Forth made the opposite bet and shipped an operator built precisely for this: */, which multiplies two integers into a double-width intermediate and then divides back down, letting you scale by 30/10 without overflowing partway through.

Here is the S-curve boiled down to its two competing pulls. High-speed turn drags the disc right (for a right-handed backhand); low-speed fade hauls it back left as it slows.

\ Lateral drift of an S-curve in millimetres, fixed-point, no floats.
\ Inputs: turn and fade in tenths of a disc unit; +mm = right of aim (RHBH).
: drift ( turn fade -- mm )
  + negate          \ net pull: high-speed turn (right) minus low-speed fade (left)
  30 10 */ ;        \ 30.0 mm per unit -- scale the tenths back down

-30 20 drift . ."  mm  (understable driver)" cr
  0 30 drift . ."  mm  (overstable putter)" cr

Same idea in Kotlin, three decades later, and the only real change is that I get named functions and a println instead of a data stack:

// Same integers, same scale. Everything stays in millimetres.
fun drift(turnTenths: Int, fadeTenths: Int): Int {
    val netTenths = -(turnTenths + fadeTenths)  // turn pulls right, fade pulls left
    return netTenths * 30 / 10                   // 30.0 mm per unit
}

fun main() {
    println("${drift(-30, 20)} mm  (understable driver)")
    println("${drift(0, 30)} mm  (overstable putter)")
}

Both print 30 mm right for the understable driver and -90 mm — nine centimetres left — for the overstable putter. Neither touched a Double. That * 30 / 10 looks like it is begging to become * 3.0, but the order carries the whole thing: multiply first, divide second, and the truncation lands somewhere you can predict. Reverse it and 30/10 collapses to an integer before it has done any work.

It is a coarse model. Real flight is gyroscopic precession, and the true drift bends with spin, wind, and the nose angle I keep getting wrong. But the arithmetic a 1983 flight computer used to fake a trajectory on a chip with no decimals is the same arithmetic that reads four stamped integers off a rim and tells me, honestly enough, which side of the basket to aim at.