charts.scale

/**
 * Where `value` lands on the range, as a straight-line map from the domain.
 * Outside the domain the line carries on, unless `clamp` stops it at the
 * range's ends.
 */
export function linearScale(domain: readonly number[], range: readonly number[], value: number, clamp: boolean): number {
  const [d0, d1] = pair(domain, "domain");
  const [r0, r1] = pair(range, "range");
  let t = normalise(d0, d1, value, "domain");
  if (clamp) t = Math.max(0, Math.min(1, t));
  return round6(interpolate(r0, r1, t));
}

// The helpers below are exported for invertLinear, which is the same line
// read the other way; they are not part of the group's contract.

/** The two ends of a domain or range, or an error naming which one is wrong. */
export function pair(values: readonly number[], what: string): [number, number] {
  if (values.length !== 2) throw new Error(`${what} must have exactly 2 values, [from, to]; got ${values.length}`);
  return [values[0], values[1]];
}

/** How far along [from, to] the value is: 0 at from, 1 at to. */
export function normalise(from: number, to: number, value: number, what: string): number {
  // Equal ends would divide by zero and answer NaN or Infinity, which then
  // draws nothing without saying why.
  if (from === to) throw new Error(`${what} has no width: both ends are ${from}`);
  return (value - from) / (to - from);
}

export function interpolate(from: number, to: number, t: number): number {
  return from + t * (to - from);
}

/** Half up to 6 decimal places, the same way in every language. */
export function round6(x: number): number {
  return Math.floor(x * 1e6 + 0.5) / 1e6;
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { interpolate, normalise, pair, round6 } from "./charts_scale_linear_scale.ts";  ← linearScale, another function of this group · built into the same file, even by a slim install

/**
 * The domain value at a position in the range: linearScale read backwards,
 * for turning a pointer coordinate into the value under it. Never clamped; a
 * position past the end of the axis is a value past the end of the data.
 */
export function invertLinear(domain: readonly number[], range: readonly number[], value: number): number {
  const [d0, d1] = pair(domain, "domain");
  const [r0, r1] = pair(range, "range");
  return round6(interpolate(d0, d1, normalise(r0, r1, value, "range")));
}

import type { NiceDomain } from "./charts_scale_types.ts";

/**
 * Widen a domain to multiples of a round tick step (1, 2 or 5 times a power
 * of ten) chosen for about `count` ticks. Widening can change the best step,
 * so it repeats until the step settles, as d3's nice() does.
 */
export function niceDomain(domain: readonly number[], count: number): NiceDomain {
  if (domain.length !== 2) throw new Error(`domain must have exactly 2 values, [from, to]; got ${domain.length}`);
  if (!Number.isInteger(count) || count < 1) throw new Error(`count must be a whole number of at least 1, got ${count}`);
  const reversed = domain[1] < domain[0];
  let lo = reversed ? domain[1] : domain[0];
  let hi = reversed ? domain[0] : domain[1];
  if (lo === hi) return { domain: [domain[0], domain[1]], step: 0 };

  let step = 0;
  for (let i = 0; i < 10; i++) {
    const next = tickStep(lo, hi, count);
    if (next === step) break;
    step = next;
    if (step >= 1) {
      lo = Math.floor(lo / step) * step;
      hi = Math.ceil(hi / step) * step;
    } else {
      // A fractional step divides badly (0.3 / 0.1 is 2.9999999999999996), so
      // multiply by its whole-number inverse instead.
      const inverse = Math.floor(1 / step + 0.5);
      lo = Math.floor(lo * inverse) / inverse;
      hi = Math.ceil(hi * inverse) / inverse;
    }
  }
  const ends = reversed ? [round6(hi), round6(lo)] : [round6(lo), round6(hi)];
  return { domain: ends, step: round6(step) };
}

function tickStep(lo: number, hi: number, count: number): number {
  const raw = (hi - lo) / count;
  // Powers of ten by repeated multiplication rather than log10, whose last
  // digit is not guaranteed to agree between languages.
  let power = 1;
  while (power * 10 <= raw) power *= 10;
  while (power > raw) power /= 10;
  const error = raw / power;
  const factor = error >= Math.sqrt(50) ? 10 : error >= Math.sqrt(10) ? 5 : error >= Math.sqrt(2) ? 2 : 1;
  return factor * power;
}

function round6(x: number): number {
  return Math.floor(x * 1e6 + 0.5) / 1e6;
}