energy.degree-days

HDD = sum over days of max(0, base - mean)
CDD = sum over days of max(0, mean - base)

pub fn degree_days(daily_mean_temperatures: &[i64], base_temperature: i64) -> DegreeDays

/// Heating and cooling degree days over the same run of days.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DegreeDays {
    /// sum of how far each day's mean fell below the base, in tenths of a degree day
    pub heating: i64,
    /// sum of how far each day's mean rose above the base, in tenths of a degree day
    pub cooling: i64,
    /// how many daily means were counted
    pub days: i64,
}

fune!(energy.degree-days@^1);  // then call degree_days(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

const LIMIT: i64 = 1000; // 100.0 °C in tenths

fn check_temperature(what: &str, value: i64) {
    if value < -LIMIT || value > LIMIT {
        panic!("{} must be whole tenths of a degree from -1000 to 1000, received {}", what, value);
    }
}

/// Heating and cooling degree days in tenths: each day adds how far its mean
/// fell below (heating) or rose above (cooling) the base.
///
/// # Panics
/// Panics if a temperature is outside -100.0 to 100.0 °C.
pub fn degree_days(daily_mean_temperatures: &[i64], base_temperature: i64) -> DegreeDays {
    check_temperature("base temperature", base_temperature);
    let mut heating = 0;
    let mut cooling = 0;
    for &mean in daily_mean_temperatures {
        check_temperature("daily mean temperature", mean);
        if mean < base_temperature {
            heating += base_temperature - mean;
        } else if mean > base_temperature {
            cooling += mean - base_temperature;
        }
    }
    DegreeDays {
        heating,
        cooling,
        days: daily_mean_temperatures.len() as i64,
    }
}

pub fn degree_days_to_value(d: &DegreeDays) -> Value {
    Value::obj(vec![
        ("heating", Value::Int(d.heating)),
        ("cooling", Value::Int(d.cooling)),
        ("days", Value::Int(d.days)),
    ])
}

fn whole_tenths(what: &str, v: &Value) -> i64 {
    if let Value::Float(f) = v {
        panic!("{} must be whole tenths of a degree from -1000 to 1000, received {}", what, f);
    }
    v.as_i64()
}

pub fn fune_vector(args: &[Value]) -> Value {
    let temps: Vec<i64> = args[0]
        .as_arr()
        .iter()
        .map(|v| whole_tenths("daily mean temperature", v))
        .collect();
    let base = whole_tenths("base temperature", &args[1]);
    degree_days_to_value(&degree_days(&temps, base))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and nothing else, 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 energy.degree-days

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

The whole function, every language, is one file too: energy.degree-days-1.0.0.fune, 10,167 bytes, sha256 dadb9334811da41846ae4e0017ec98006bd554a04830a1c1dd1ed49719b483e0. It installs into a project of any language.

// fune: before energy.degree-days

// fune: after energy.degree-days

// fune: step energy.degree-days after <n|label>

More from the author

They are the standard way to normalise heating (or cooling) energy for the weather: kWh per degree day is comparable between a mild and a cold winter where raw kWh is not.

## Units

Temperatures and results are integers in **tenths of a degree**: 12.3 °C is `123`, and 45 degree days is `450`. Temperatures are recorded to a tenth of a degree, and with integer tenths every sum is exact, so the answer is exact to 0.1 of a degree day in all three languages rather than approximately so.

## Decisions

- **The base is an argument.** 15.5 °C (`155`) is the long-standing UK convention for heating degree days (CIBSE TM41, and the base of the published UK regional series); buildings with better insulation or higher internal gains are often analysed at a lower base, and cooling is often counted above 15.5 °C or 18 °C. The same base is used for both sums. - **Mean-temperature method only.** Each day contributes `base - mean` when positive. The Met Office / UKMO method that estimates degree days from a day's maximum and minimum (for days where the base falls between them) is a different formula and is not what this does; pass the true daily mean. - **A day at exactly the base counts for neither.** - An empty list gives zeros. A mean outside -100.0 to 100.0 °C is refused as a unit mistake (Fahrenheit, or whole degrees times 100).

## Source

CIBSE TM41, "Degree-days: theory and application" (Chartered Institution of Building Services Engineers), for the definition and the 15.5 °C UK base.

Files