manufacturing.tolerance-check

export function checkTolerance(measured: number, nominal: number, upperDeviation: number, lowerDeviation: number): ToleranceCheck

/** The verdict, where the limits are, and how far out a reject is. */
export interface ToleranceCheck {
  /** true when lowerLimit <= measured <= upperLimit; the limits are inside */
  readonly passed: boolean;
  readonly status: ToleranceStatus;
  /** measured minus nominal, signed */
  readonly deviation: number;
  readonly lowerLimit: number;
  readonly upperLimit: number;
  /** distance past the limit that was broken; 0 when passed */
  readonly outBy: number;
}

export type ToleranceStatus = "within" | "above" | "below";

import { checkTolerance } from "#fune/manufacturing.tolerance-check@^1";

import { type ToleranceCheck } from "./manufacturing_tolerance_check_types.ts";

const LIMIT = 1_000_000_000_000;

function micrometres(name: string, value: number): number {
  if (!Number.isInteger(value) || value > LIMIT || value < -LIMIT) {
    throw new RangeError(`${name} must be a whole number of micrometres within ±10^12, received ${value}`);
  }
  return value;
}

/**
 * Check a measurement against nominal plus its upper and lower deviations.
 *
 * The deviations are signed and independent, so a tolerance band that lies
 * wholly above or below nominal (an H7 hole, a g6 shaft) is checked correctly;
 * a symmetric band is just `+t, -t`.
 */
export function checkTolerance(measured: number, nominal: number, upperDeviation: number, lowerDeviation: number): ToleranceCheck {
  micrometres("measured", measured);
  micrometres("nominal", nominal);
  micrometres("upperDeviation", upperDeviation);
  micrometres("lowerDeviation", lowerDeviation);
  if (lowerDeviation > upperDeviation) {
    throw new RangeError(
      `lowerDeviation must not be greater than upperDeviation, received ${lowerDeviation} and ${upperDeviation}`,
    );
  }
  const lowerLimit = nominal + lowerDeviation;
  const upperLimit = nominal + upperDeviation;
  const deviation = measured - nominal;
  if (measured > upperLimit) {
    return { passed: false, status: "above", deviation, lowerLimit, upperLimit, outBy: measured - upperLimit };
  }
  if (measured < lowerLimit) {
    return { passed: false, status: "below", deviation, lowerLimit, upperLimit, outBy: lowerLimit - measured };
  }
  return { passed: true, status: "within", deviation, lowerLimit, upperLimit, outBy: 0 };
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the TypeScript package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add manufacturing.tolerance-check

The manifest, vectors and README with only the TypeScript implementation. Install it without the registry with fune add ./manufacturing.tolerance-check-1.0.0-typescript.fune, or fetch it from a terminal with fune pull manufacturing.tolerance-check@1.0.0:typescript.

The whole function, every language, is one file too: manufacturing.tolerance-check-1.0.0.fune, 14,651 bytes, sha256 02a3faf1c5fd1fc72dfdfa4fe659af7e86632dfe9b9993836204e86a78d84a43. It installs into a project of any language.

// fune: before manufacturing.tolerance-check

// fune: after manufacturing.tolerance-check

// fune: step manufacturing.tolerance-check after <n|label>

More from the author

**Deviations, not a ± number.** Tolerances are given as the upper and lower deviation from nominal, as ISO 286 writes them (`es`/`ei` for shafts, `ES`/`EI` for holes), so both kinds of limit are one call:

- symmetric, 25 mm ± 0.05: `checkTolerance(m, 25000, 50, -50)` - asymmetric, a 25 mm H7 hole (+0.021 / 0): `checkTolerance(m, 25000, 21, 0)` - one-sided, a 25 mm g6 shaft (-0.007 / -0.020): `checkTolerance(m, 25000, -7, -20)`

The last is the case a "within ±tolerance of nominal" check gets wrong: a g6 shaft measured at exactly 25.000 mm is **too big**, 7 µm above its upper limit, because both limits sit below nominal.

**Whole micrometres.** Every size is an integer number of micrometres (µm), so limits and deviations are exact and all three languages agree; a reading of 25.0125 mm is 25013 µm after the gauge's own rounding. Every value must lie within ±10^12 µm (1,000 km), which keeps every sum exact.

**Limits are inclusive.** A part measured exactly on a limit passes. `outBy` is how far past the broken limit a reject is (always positive for a reject, 0 for a pass), and `status` says which side: `above`, `below` or `within`.

The lower deviation may not be greater than the upper one. Negative sizes are allowed, for coordinates and offsets measured from a datum.

Source: ISO 286-1:2010, Geometrical product specifications (GPS) - ISO code system for tolerances on linear sizes, clause 3 (deviations and limits). The H7 and g6 values for 25 mm are from its tables (IT6 = 13 µm, IT7 = 21 µm, fundamental deviation g = -7 µm for sizes over 18 up to 30 mm).

Files