Typed scale factors and shrinkage allowance

How the precision is kept

Factors are parsed from text with Number and combined with one division or addition in 64-bit numbers. The shrinkage factor has two stated modes.

2 calculations in 1 source file. The code is read from the released app when this page loads. It is the calculation people run, not a copy kept for this page.

/** A factor from text: a plain number, "101.5%" (of the size), or "+1.5%" / "-2%" (change). */
export function parseFactor(text) {
  const s = String(text ?? '').trim().replace(',', '.').replace(/\s+/g, '');
  if (!s) return null;
  const m = /^([+-]?)(\d*\.?\d+(?:e[+-]?\d+)?)(%?)$/i.exec(s);
  if (!m) return null;
  const n = Number(m[2]);
  if (!Number.isFinite(n)) return null;
  let f;
  if (m[3]) f = m[1] ? 1 + (m[1] === '-' ? -n : n) / 100 : n / 100;
  else f = m[1] === '-' ? -n : n;
  return f > 1e-6 && f < 1e6 ? f : null;
}

/** The pattern factor for a shrinkage of pct percent (0 ≤ pct < 50). */
export function shrinkFactor(pct, mode = 'add') {
  if (!(pct >= 0 && pct < 50)) return null;
  return mode === 'exact' ? 1 / (1 - pct / 100) : 1 + pct / 100;
}

In detail

Method

Percent forms: 101.5% is 1.015; +1.5% is 1 + 1.5/100. Shrinkage 'add' mode: 1 + s/100; 'exact' mode: 1 ÷ (1 − s/100).

Number types

64-bit numbers.

Tolerances

A factor must be between 1e-6 and 1e6 (exclusive); shrinkage must be at least 0 and under 50 percent.

Limits

The default mode is 'add', which is the rule of adding the shrinkage percent; 'exact' gives a slightly larger factor.

Approach: Exact values

Constants and factors are held as exact fractions from their definitions. The arithmetic is ordered so that no rounded factor is ever used.

Every policy that takes this approach