manufacturing.takt-time

pub fn takt_time(available_seconds: i64, demand: i64, mode: &str) -> TaktTime

/// The exact takt as a fraction of seconds, and the same rounded to whole seconds.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TaktTime {
    /// seconds per unit, reduced
    pub exact: Rational,
    /// seconds per unit, rounded by mode
    pub seconds: i64,
}

fune!(manufacturing.takt-time@^1);  // then call takt_time(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::math_rational::{rational, rational_to_integer, rational_to_value};  ← from math.rational ^1.0.0 · built alongside by fune

const MAX_SAFE: i64 = (1i64 << 53) - 1;

/// Takt time, available time / demand, as an exact fraction and in whole
/// seconds. The whole seconds are rounded once from the exact fraction, so a
/// caller balancing a line on `exact` never inherits a rounding step.
///
/// # Panics
/// Panics on negative available time, demand that is not positive, or an
/// unknown rounding mode.
pub fn takt_time(available_seconds: i64, demand: i64, mode: &str) -> TaktTime {
    if !(0..=MAX_SAFE).contains(&available_seconds) {
        panic!(
            "availableSeconds must be a whole number of seconds, not negative, received {}",
            available_seconds
        );
    }
    if !(1..=MAX_SAFE).contains(&demand) {
        panic!("demand must be a whole number of units greater than zero, received {}", demand);
    }
    let exact = rational(available_seconds, demand);
    let seconds = rational_to_integer(&exact, mode);
    TaktTime { exact, seconds }
}

pub fn takt_time_to_value(result: &TaktTime) -> Value {
    Value::obj(vec![
        ("exact", rational_to_value(&result.exact)),
        ("seconds", Value::Int(result.seconds)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    if let Value::Float(f) = &args[0] {
        panic!("availableSeconds must be a whole number of seconds, not negative, received {}", f);
    }
    if let Value::Float(f) = &args[1] {
        panic!("demand must be a whole number of units greater than zero, received {}", f);
    }
    takt_time_to_value(&takt_time(args[0].as_i64(), args[1].as_i64(), args[2].as_str()))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and its 2 dependencies, pins them in fune.lock, downloads only the Rust 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. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add manufacturing.takt-time

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./manufacturing.takt-time-1.0.0-rust.fune, or fetch it from a terminal with fune pull manufacturing.takt-time@1.0.0:rust.

The whole function, every language, is one file too: manufacturing.takt-time-1.0.0.fune, 9,998 bytes, sha256 fd7d347610f0d78c840a26ef782ce2053b081d4bf02cd41df8ded064c3afccb7. It installs into a project of any language.

// fune: before manufacturing.takt-time

// fune: after manufacturing.takt-time

// fune: replace math.rational in manufacturing.takt-time
// fune: replace math.round-div in manufacturing.takt-time

// fune: step manufacturing.takt-time after <n|label>

More from the author

An 8-hour shift less two 15-minute breaks is 27,000 seconds; with a demand of 450 units that is one unit every 60 seconds.

**Exact first, then rounded once.** The answer is returned twice: `exact`, the reduced fraction of seconds (27,000 / 400 is `135/2`), and `seconds`, that fraction rounded to whole seconds by the mode you choose. Keep `exact` for line balancing (dividing takt among stations or comparing it with cycle times) so no rounding compounds; use `seconds` for the board on the shop floor.

**Which mode.** `down` is the safe choice for a pace: a takt rounded up (67.5 s to 68 s) makes 397 units in the shift, not 400. `half-up` and `half-even` give the nearest second; `up` is there for completeness.

**Available time is the caller's.** Pass the time the line is actually planned to run in the period (shift length less breaks, meetings and planned maintenance), in seconds, and demand for the same period. The function does no calendar arithmetic, so a week or a month works the same as a shift.

Zero available time gives a takt of 0. Demand must be more than zero (no demand means no pace to keep), and neither may be negative.

Files