Calc sheet units, functions and driven parameters

const SI = {
  kg: [1, dim(0, 1)], g: [1e-3, dim(0, 1)], mg: [1e-6, dim(0, 1)], t: [1000, dim(0, 1)], tonne: [1000, dim(0, 1)], lb: [0.45359237, dim(0, 1)], lbs: [0.45359237, dim(0, 1)], oz: [0.028349523125, dim(0, 1)],
  s: [1, dim(0, 0, 1)], ms: [1e-3, dim(0, 0, 1)], min: [60, dim(0, 0, 1)], h: [3600, dim(0, 0, 1)], hr: [3600, dim(0, 0, 1)], d: [86400, dim(0, 0, 1)], day: [86400, dim(0, 0, 1)], wk: [604800, dim(0, 0, 1)],
  N: [1, dim(1, 1, -2)], kN: [1e3, dim(1, 1, -2)], MN: [1e6, dim(1, 1, -2)], lbf: [4.4482216152605, dim(1, 1, -2)], kip: [4448.2216152605, dim(1, 1, -2)], kgf: [9.80665, dim(1, 1, -2)],
  Pa: [1, dim(-1, 1, -2)], kPa: [1e3, dim(-1, 1, -2)], MPa: [1e6, dim(-1, 1, -2)], GPa: [1e9, dim(-1, 1, -2)], bar: [1e5, dim(-1, 1, -2)], psi: [6894.757293168, dim(-1, 1, -2)], ksi: [6894757.293168, dim(-1, 1, -2)], psf: [47.88025898, dim(-1, 1, -2)],
  J: [1, dim(2, 1, -2)], kJ: [1e3, dim(2, 1, -2)], MJ: [1e6, dim(2, 1, -2)], Wh: [3600, dim(2, 1, -2)], kWh: [3.6e6, dim(2, 1, -2)], BTU: [1055.05585262, dim(2, 1, -2)],
  W: [1, dim(2, 1, -3)], kW: [1e3, dim(2, 1, -3)], MW: [1e6, dim(2, 1, -3)], hp: [745.69987158227, dim(2, 1, -3)],
  A: [1, dim(0, 0, 0, 1)], mA: [1e-3, dim(0, 0, 0, 1)], kA: [1e3, dim(0, 0, 0, 1)], V: [1, dim(2, 1, -3, -1)], kV: [1e3, dim(2, 1, -3, -1)], mV: [1e-3, dim(2, 1, -3, -1)],
  ohm: [1, dim(2, 1, -3, -2)], K: [1, dim(0, 0, 0, 0, 1)], L: [1e-3, dim(3)], lit: [1e-3, dim(3)], liter: [1e-3, dim(3)], litre: [1e-3, dim(3)], gal: [3.785411784e-3, dim(3)],
};

const CONST = { pi: [Math.PI, D0], e: [Math.E, D0], g0: [9.80665, dim(1, 0, -2)] };
// Length fallback when no units table is given.
const LEN = { m: 1, mm: 1e-3, cm: 1e-2, km: 1e3, in: 0.0254, ft: 0.3048, yd: 0.9144 };

function unitValue(id) {
  if (Object.prototype.hasOwnProperty.call(SI, id)) return { v: SI[id][0], d: SI[id][1] };
  if (lib) for (const [kind, d] of KINDS) { const u = lib.unitOfMark(id, kind); if (u) return { v: lib.factor(u), d, id: u }; }
  else if (Object.prototype.hasOwnProperty.call(LEN, id)) return { v: LEN[id], d: dim(1) };
  if (id === 'deg' || id === '°') return { v: Math.PI / 180, d: D0 };
  if (id === 'rad') return { v: 1, d: D0 };
  return null;
}

const same = (a, b) => a.every((x, i) => Math.abs(x - b[i]) < 1e-9);

case '^': {
  if (!isZero(b.d)) fail('unit_mismatch', 'An exponent cannot have a unit (' + describe(b.d) + ').', '');
  const r = Math.pow(a.v, b.v);
  if (!Number.isFinite(r)) fail('domain', 'That power is not a real number.', '');
  return { v: r, d: dpow(a.d, b.v) };
}

case 'to': {
  const a = evalTree(n.a, env), u = evalTree(n.u, env);
  if (!same(a.d, u.d)) fail('unit_mismatch', 'Cannot show ' + describe(a.d) + ' in ' + describe(u.d) + '.', 'Pick a unit of ' + describe(a.d) + '.');
  return { ...a, show: n.u, showFactor: u.v };
}

/** The text of a result in a unit expression ("kN m") or the natural unit. */
function show(val, unitText, tree) {
  const d = val.d;
  if (val.bool) return { text: val.v ? 'true' : 'false', unit: '' };
  let factor = 1, label = '';
  if (unitText) {
    const u = evalTree(parse(unitText, isUnit), { vars: {}, params: new Set(), get: () => null, sheetRef: () => null });
    if (!same(u.d, d)) fail('unit_mismatch', 'The answer is ' + describe(d) + ', which cannot be shown in "' + unitText + '" (' + describe(u.d) + ').', 'Use a unit of ' + describe(d) + ', or clear the unit.');
    factor = u.v; label = unitText;
  } else if (val.show) { factor = val.showFactor; label = unparse(val.show); }
  else if (lib && same(d, dim(1)) && lib.format) { return { text: sig(val.v) + ' m', unit: 'm', amount: val.v }; }
  else { label = DEFAULT_UNIT[NAME_OF(d)] || (isZero(d) ? '' : dimText(d)); }
  const amount = val.v / factor;
  return { text: sig(amount) + (label ? ' ' + label : ''), unit: label, amount };
}

case 'sqrt': need(1); if (a[0].v < 0) fail('domain', 'The square root of a negative number.', ''); return { v: Math.sqrt(a[0].v), d: dpow(a[0].d, 0.5) };
case 'abs': need(1); return { v: Math.abs(a[0].v), d: a[0].d };

case 'round': case 'floor': case 'ceil': {
  if (a.length < 1 || a.length > 2) fail('syntax', f + ' takes a value and, for round, an optional step.', '');
  if (a.length === 2) { alike(); const s = a[1].v; if (!s) fail('domain', 'The step cannot be zero.', ''); return { v: Math[f](a[0].v / s) * s, d: a[0].d }; }
  return { v: Math[f](a[0].v), d: a[0].d };
}

case 'min': case 'max': case 'sum': case 'avg': {
  if (!a.length) fail('syntax', f + ' needs at least one value.', ''); alike();
  const vs = a.map((x) => x.v);
  return { v: f === 'min' ? Math.min(...vs) : f === 'max' ? Math.max(...vs) : vs.reduce((s, x) => s + x, 0) / (f === 'avg' ? vs.length : 1), d: a[0].d };
}

case 'sin': case 'cos': case 'tan': need(1); plain(); return { v: Math[f](a[0].v), d: D0 };
case 'asin': case 'acos': case 'atan': need(1); plain(); if ((f !== 'atan') && Math.abs(a[0].v) > 1) fail('domain', f + ' needs a value between -1 and 1.', ''); return { v: Math[f](a[0].v), d: D0 };
case 'atan2': need(2); alike(); return { v: Math.atan2(a[0].v, a[1].v), d: D0 };
case 'ln': case 'log10': case 'exp': need(1); plain(); if (f !== 'exp' && a[0].v <= 0) fail('domain', 'The logarithm of a number that is not positive.', ''); return { v: Math[f === 'ln' ? 'log' : f](a[0].v), d: D0 };
case 'pow': need(2); if (!isZero(a[1].d)) fail('unit_mismatch', 'An exponent cannot have a unit.', ''); return { v: Math.pow(a[0].v, a[1].v), d: dpow(a[0].d, a[1].v) };

// ---- evaluation ----
function paramValue(name) {
  if (!params || typeof params.get !== 'function') fail('param_missing', 'This app has not handed its parameters over, so @' + name + ' cannot be read.', 'Use a number instead, or open a document that has parameters.');
  const g = params.get(name);
  if (g === null || g === undefined) fail('param_missing', 'There is no parameter "' + name + '" in this document.', 'Check the name' + (typeof params.list === 'function' ? ' (parameters: ' + params.list().slice(0, 12).join(', ') + ')' : '') + '.');
  if (typeof g === 'number') return { v: g, d: D0 };
  if (g && typeof g.value === 'number') {
    if (!g.unit) return { v: g.value, d: D0 };
    const u = unitValue(g.unit); if (!u) fail('unknown_unit', 'The parameter "' + name + '" is in a unit this sheet does not know: ' + g.unit + '.', '');
    return { v: g.value * u.v, d: u.d };
  }
  fail('param_missing', 'The parameter "' + name + '" has no number.', '');
}

/** What the drives would set now: [{ param, row, value, unit, current, change }] and the ones that cannot. */
function plan() {
  const res = evaluate(), set = [], skipped = [];
  for (const d of doc.drives) {
    const h = find(d.row), r = h && res.get(h.sheet.id + '.' + h.row.name);
    if (!r || !r.ok) { skipped.push({ param: d.param, row: d.row, why: r && r.error ? r.error.message : 'The row is gone.' }); continue; }
    let value = r.value, unit = d.unit || '';
    if (unit) { const u = evalTree(parse(unit, isUnit), { vars: {}, params: new Set(), get: () => null, sheetRef: () => null }); if (!same(u.d, r.dim)) { skipped.push({ param: d.param, row: d.row, why: 'The row is ' + describe(r.dim) + ' and the parameter is set in ' + unit + '.' }); continue; } value = r.value / u.v; }
    else if (!isZero(r.dim)) { const g = params && params.get ? params.get(d.param) : null; const gu = g && typeof g === 'object' && g.unit ? g.unit : ''; if (gu) { const u = unitValue(gu); if (u && same(u.d, r.dim)) { value = r.value / u.v; unit = gu; } } }
    const cur = params && params.get ? params.get(d.param) : null;
    const curNum = cur && typeof cur === 'object' ? cur.value : cur;
    set.push({ param: d.param, row: d.row, value, unit, current: typeof curNum === 'number' ? curNum : null, change: typeof curNum !== 'number' || Math.abs(curNum - value) > 1e-9 * Math.max(1, Math.abs(value)) });
  }
  return { set, skipped };
}