manufacturing.tolerance-check

def check_tolerance(measured: int, nominal: int, upper_deviation: int, lower_deviation: int) -> ToleranceCheck

@dataclass(frozen=True)
class ToleranceCheck:
    """The verdict, where the limits are, and how far out a reject is."""

    #: true when lowerLimit <= measured <= upperLimit; the limits are inside
    passed: bool
    status: ToleranceStatus
    #: measured minus nominal, signed
    deviation: int
    lower_limit: int
    upper_limit: int
    #: distance past the limit that was broken; 0 when passed
    out_by: int

ToleranceStatus = Literal["within", "above", "below"]

from fune.manufacturing.tolerance_check import check_tolerance  # manufacturing.tolerance-check@^1

from .manufacturing_tolerance_check_types import ToleranceCheck

LIMIT = 10**12


def _micrometres(name: str, value: int) -> int:
    if isinstance(value, bool) or not isinstance(value, int) or value > LIMIT or value < -LIMIT:
        raise ValueError("%s must be a whole number of micrometres within ±10^12, received %r" % (name, value))
    return value


def check_tolerance(measured: int, nominal: int, upper_deviation: int, lower_deviation: int) -> ToleranceCheck:
    """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``.
    """
    _micrometres("measured", measured)
    _micrometres("nominal", nominal)
    _micrometres("upperDeviation", upper_deviation)
    _micrometres("lowerDeviation", lower_deviation)
    if lower_deviation > upper_deviation:
        raise ValueError(
            "lowerDeviation must not be greater than upperDeviation, received %d and %d"
            % (lower_deviation, upper_deviation)
        )
    lower_limit = nominal + lower_deviation
    upper_limit = nominal + upper_deviation
    deviation = measured - nominal
    if measured > upper_limit:
        return ToleranceCheck(
            passed=False, status="above", deviation=deviation,
            lower_limit=lower_limit, upper_limit=upper_limit, out_by=measured - upper_limit,
        )
    if measured < lower_limit:
        return ToleranceCheck(
            passed=False, status="below", deviation=deviation,
            lower_limit=lower_limit, upper_limit=upper_limit, out_by=lower_limit - measured,
        )
    return ToleranceCheck(
        passed=True, status="within", deviation=deviation,
        lower_limit=lower_limit, upper_limit=upper_limit, out_by=0,
    )

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Python 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 Python implementation. Install it without the registry with fune add ./manufacturing.tolerance-check-1.0.0-python.fune, or fetch it from a terminal with fune pull manufacturing.tolerance-check@1.0.0:python.

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