Function quantityAdd

src/compute-engine/library/quantity-arithmetic.ts:60–123

(
  ce: ComputeEngine,
  ops: ReadonlyArray<Expression>
)

function unitSymbol(q: QuantityExpr): string | null {
  const u = q.op2;
  return isSymbol(u) ? u.symbol : null;
}

/**
 * Convert a (possibly `Measurement`) magnitude expression from its own unit to
 * the target unit, preserving/scaling a `Measurement` error.  Unit conversion
 * is affine (`x → f·x + c`); the linear factor `f = convert(1) − convert(0)`
 * removes any additive offset (so the error scales by `|f|` while the offset
 * shifts the nominal only).  Returns `undefined` if the units are incompatible.
 */
function convertMagnitude(
  ce: ComputeEngine,
  mag: Expression,
  opSymbol: string | null,
  opUE: ReturnType<typeof boxedToUnitExpression>,
  targetSymbol: string | null,
  targetUE: ReturnType<typeof boxedToUnitExpression>
): Expression | undefined {
  if (targetSymbol && opSymbol) {
    if (opSymbol === targetSymbol) return mag;
    const c0 = convertUnit(0, opSymbol, targetSymbol);
    const c1 = convertUnit(1, opSymbol, targetSymbol);
    if (c0 === null || c1 === null) return undefined;
    return measurementAffine(ce, mag, c1 - c0, c0);
  }
  if (!opUE || !targetUE) return undefined;
  const c0 = convertCompoundUnit(0, opUE, targetUE);
  const c1 = convertCompoundUnit(1, opUE, targetUE);
  if (c0 === null || c1 === null) return undefined;
  return measurementAffine(ce, mag, c1 - c0, c0);
}

// ---------------------------------------------------------------------------
// Quantity arithmetic
// ---------------------------------------------------------------------------

/**
 * Add Quantity expressions.  All operands must be Quantities with
 * compatible dimensions.  The result uses the unit with the largest
 * scale factor (e.g. `m` wins over `cm`, `km` wins over `m`).
 */
export function quantityAdd(
  ce: ComputeEngine,
  ops: ReadonlyArray<Expression>
): Expression | undefined {
  if (ops.length === 0) return undefined;

  // Collect all Quantity operands and cache their UnitExpressions
  const quantities: QuantityExpr[] = [];
  const unitExprs: ReturnType<typeof boxedToUnitExpression>[] = [];
  for (const op of ops) {
    if (!isQuantity(op)) return undefined; // non-Quantity mixed in
    const ue = boxedToUnitExpression(op.op2);
    if (!ue) return undefined;
    quantities.push(op);
    unitExprs.push(ue);
  }
  if (quantities.length === 0) return undefined;