construction.roof-pitch

export function roofPitch(span: number, rise: number, roofLength: number, roofType: RoofType): RoofPitch

export type RoofType = "duo" | "mono";

/** The pitch, one rafter and the whole roof's slope area. */
export interface RoofPitch {
  /** angle of the slope from horizontal, to 2 decimal places */
  readonly pitchDegrees: number;
  /** metres along the slope from plate to ridge, no overhang, to 3 decimal places (the nearest millimetre) */
  readonly rafterLength: number;
  /** square metres of slope, every slope together, no overhang, to 2 decimal places */
  readonly roofArea: number;
}

import { roofPitch } from "#fune/construction.roof-pitch@^1";

import { atan } from "./math_atan.ts";  ← from math.atan ^1.0.0 · built alongside by fune
import { roundFloat } from "./math_round_float.ts";  ← from math.round-float ^1.0.0 · built alongside by fune
import { type RoofPitch, type RoofType } from "./construction_roof_pitch_types.ts";

// 180 / pi as a double, written out so no language computes it differently.
const DEGREES_PER_RADIAN = 57.29577951308232;
const LIMIT = 10000;

function checkLength(name: string, value: number, allowZero: boolean): void {
  const ok = typeof value === "number" && Number.isFinite(value) && value <= LIMIT && (allowZero ? value >= 0 : value > 0);
  if (!ok) {
    const want = allowZero ? "zero or more" : "greater than zero";
    throw new RangeError(`${name} must be a finite number of metres, ${want} and at most ${LIMIT}, received ${String(value)}`);
  }
}

/**
 * Pitch, rafter length and slope area of a duo- or mono-pitch roof.
 *
 * The area is worked from the unrounded rafter, not the one rounded to a
 * millimetre for display: over a long roof the difference shows in the
 * second decimal place.
 */
export function roofPitch(span: number, rise: number, roofLength: number, roofType: RoofType): RoofPitch {
  checkLength("span", span, false);
  checkLength("rise", rise, true);
  checkLength("roofLength", roofLength, false);
  let run: number;
  let slopes: number;
  if (roofType === "duo") {
    run = span / 2;
    slopes = 2;
  } else if (roofType === "mono") {
    run = span;
    slopes = 1;
  } else {
    throw new RangeError(`unknown roof type "${String(roofType)}"`);
  }
  const radians = atan(rise / run);
  // sqrt is one of the operations IEEE 754 requires to be correctly rounded,
  // so Math.sqrt is the same double in every language.
  const rafter = Math.sqrt(run * run + rise * rise);
  return {
    pitchDegrees: roundFloat(radians * DEGREES_PER_RADIAN, 2),
    rafterLength: roundFloat(rafter, 3),
    roofArea: roundFloat(rafter * roofLength * slopes, 2),
  };
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and its 2 dependencies, 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 construction.roof-pitch

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

The whole function, every language, is one file too: construction.roof-pitch-1.0.0.fune, 13,927 bytes, sha256 a8a35da395a9273cd0e552f4eaf3ea782a8dc8357310c2c616bc80d54187f6f9. It installs into a project of any language.

// fune: before construction.roof-pitch

// fune: after construction.roof-pitch

// fune: replace math.atan in construction.roof-pitch
// fune: replace math.round-float in construction.roof-pitch

// fune: step construction.roof-pitch after <n|label>

More from the author

The pitch is `atan(rise / run)` in degrees, the rafter is `sqrt(run² + rise²)`, and the area is rafter × roof length × slopes.

## Rounding

The pitch is rounded to 2 decimal places, the rafter to 3 (the nearest millimetre) and the area to 2, each with `math.round-float`, half away from zero. The area is worked from the **unrounded** rafter: on a 7.2 m span with a 2.4 m rise and a 20 m ridge the rafter is 4.32666 m, so the area is 173.07 m², while 4.327 × 40 would give 173.08.

## Why every language agrees

The angle comes from `math.atan` (fdlibm's arctangent from + − × ÷ only), not `Math.atan`, whose last bit differs between platforms. The square root is the platform's own: IEEE 754 requires square root to be correctly rounded, like + − × ÷, so it is the same double everywhere (`geo.distance` relies on the same guarantee). Degrees are radians × 57.29577951308232, 180/π as a double, written out.

## What it does not do

- Overhangs (eaves and verges), ridge and fascia boards, and the rafter's plumb cuts: the rafter length is plate to ridge along the slope, and the area is the slope over the building's footprint. Add overhang to the run and roof length yourself for tiling or felt quantities, then add waste. - Hips, valleys and unequal pitches. A hipped roof's slope area does equal plan area ÷ cos(pitch) when every slope has the same pitch, but its rafters do not; that is a different calculation. - Pitch from a known angle (the reverse); rise = run × tan(pitch).

A rise of 0 is allowed (a flat roof: pitch 0, rafter equal to the run). Span and roof length must be above zero, and every dimension at most 10,000 m.

Files