agri.seed-rate

pub fn seed_rate(target_plants_per_square_metre: i64, thousand_grain_weight_grams: f64, establishment_basis_points: i64) -> SeedRate

/// What to set the drill to.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SeedRate {
    /// plants x TGW / establishment %, to 0.1 kg, half up
    pub kg_per_hectare: f64,
    /// seeds to sow per m², to 0.1, half up
    pub seeds_per_square_metre: f64,
}

fune!(agri.seed-rate@^1);  // then call seed_rate(…)

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_round_div::round_div;  ← from math.round-div ^1.0.0 · built alongside by fune
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// Seed rate (kg/ha) = target plants/m² x TGW (g) / expected establishment (%).
///
/// The TGW is taken to the centigram and the establishment is in basis points,
/// so kg/ha is exactly plants x centigrams / basis points and is rounded once.
/// Doing it in floats gets 100 x 1.15 / 100 = 1.1499999999999999, which rounds
/// to 1.1 kg/ha instead of 1.2.
///
/// # Panics
/// Panics when an argument is out of range.
pub fn seed_rate(target_plants_per_square_metre: i64, thousand_grain_weight_grams: f64, establishment_basis_points: i64) -> SeedRate {
    let plants = target_plants_per_square_metre;
    if !(1..=100000).contains(&plants) {
        panic!("targetPlantsPerSquareMetre must be a whole number from 1 to 100000, received {}", plants);
    }
    let tgw = thousand_grain_weight_grams;
    if !tgw.is_finite() || tgw <= 0.0 || tgw > 1000.0 {
        panic!("thousandGrainWeightGrams must be a finite number greater than 0 and at most 1000, received {}", tgw);
    }
    let centigrams = (round_float(tgw, 2) * 100.0).round() as i64;
    if centigrams < 1 {
        panic!("thousandGrainWeightGrams must be at least 0.01 grams, received {}", tgw);
    }
    let bp = establishment_basis_points;
    if !(1..=10000).contains(&bp) {
        panic!("establishmentBasisPoints must be a whole number from 1 to 10000, received {}", bp);
    }
    SeedRate {
        kg_per_hectare: round_div(plants * centigrams * 10, bp, "half-up") as f64 / 10.0,
        seeds_per_square_metre: round_div(plants * 100000, bp, "half-up") as f64 / 10.0,
    }
}

pub fn seed_rate_to_value(s: &SeedRate) -> Value {
    Value::obj(vec![
        ("kgPerHectare", Value::Float(s.kg_per_hectare)),
        ("seedsPerSquareMetre", Value::Float(s.seeds_per_square_metre)),
    ])
}

fn whole(v: &Value, message: &str) -> i64 {
    match v {
        Value::Int(i) => *i,
        _ => panic!("{}, received {:?}", message, v),
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    let plants = whole(&args[0], "targetPlantsPerSquareMetre must be a whole number from 1 to 100000");
    let bp = whole(&args[2], "establishmentBasisPoints must be a whole number from 1 to 10000");
    seed_rate_to_value(&seed_rate(plants, args[1].as_f64(), bp))
}

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 agri.seed-rate

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

The whole function, every language, is one file too: agri.seed-rate-1.0.0.fune, 13,674 bytes, sha256 0cb3c657ec361c750a3bb5c33e092b800dbfa3b731ee943c781c2f8d4c3f0672. It installs into a project of any language.

// fune: before agri.seed-rate

// fune: after agri.seed-rate

// fune: replace math.round-div in agri.seed-rate
// fune: replace math.round-float in agri.seed-rate

// fune: step agri.seed-rate after <n|label>

More from the author

`seedRate(260, 48, 7000)` is 178.3 kg/ha and 371.4 seeds/m²: 260 plants at 70% establishment needs 371.4 seeds/m², and 1000 seeds weigh 48 g.

The formula follows from the units: seeds/m² = plants / establishment; one seed weighs TGW / 1000 g; and 1 g/m² is 10 kg/ha. It is the calculation behind AHDB's seed rate conversion tool (seeds/m² against TGW, read off as kg/ha) and the one UK agronomy guidance quotes.

## Establishment

`establishmentBasisPoints` is the share of seeds sown that become plants: germination and field losses (slugs, seedbed, sowing date) together. If you have a germination figure and a separate field-loss estimate, multiply them: 90% germination and 85% emergence is 76.5%, `7650`. AHDB's benchmarks are around 70% for well-timed winter wheat, falling as drilling gets later.

## Exactness

The thousand-grain weight is taken to the nearest 0.01 g (half away from zero, `math.round-float`), so the rate is exactly plants x centigrams / basis points and is rounded once, half up, to 0.1 kg/ha. A float calculation gets 1.15 g at 100 plants and 100% as 1.1499999999999999 and rounds it to 1.1; this gives 1.2.

It does not choose the target population, adjust for sowing date or soil, or round to what a drill can be set to.

## Limits

Plants 1 to 100,000 per m² (grass and small seeds are sown in thousands); TGW more than 0 and at most 1000 g, and at least 0.01 g after rounding; establishment 1 to 10,000 basis points.

## Sources

- AHDB, "Seed rate calculator – conversion tool", https://ahdb.org.uk/seed-rate-conversion-tool (seeds/m² to kg/ha by TGW). - AHDB, "Establishment in wheat: germination and emergence (GS0–GS2)", https://ahdb.org.uk/knowledge-library/establishment-in-wheat-germination-and-emergence-gs0-gs2 (the 70% establishment benchmark). - Foundation for Arable Research, "Seed rate calculation", https://www.far.org.nz/resources/seed-rate-calculation: sowing rate = target plants x TGW x 100 / (% germination x % emergence); its worked example (225 plants, TGW 40 g, 90% x 85%, about 118 kg/ha) is a vector.

Files