Function rank

src/compute-engine/boxed-expression/order.ts:206–263

* Return the "rank", the order in which the expression should be * sorted.

(expr: Expression)

  'constant',
  'symbol',
  'multiply',
  'divide',
  'add',
  'trig',
  'fn',
  'power',
  'string',
  'object',
  'other',
] as const;
export type Rank = (typeof RANKS)[number];

/**
 * Total three-way comparison of two floats suitable for a comparator.
 *
 * Unlike `af - bf`, this is a *total* order: it never returns `NaN`. Any
 * `NaN` operand sorts after all real numbers (and two `NaN`s compare equal),
 * so canonical ordering stays deterministic and permutation-invariant even
 * when `NaN` is present.
 */
function compareFloat(a: number, b: number): number {
  const aNaN = Number.isNaN(a);
  const bNaN = Number.isNaN(b);
  if (aNaN || bNaN) {
    if (aNaN && bNaN) return 0;
    return aNaN ? +1 : -1;
  }
  if (a < b) return -1;
  if (a > b) return +1;
  return 0;
}

/**
 * Return the "rank", the order in which the expression should be
 * sorted.
 */
function rank(expr: Expression): Rank {
  if (isNumber(expr)) {
    if (typeof expr.numericValue === 'number') {
      if (Number.isNaN(expr.numericValue)) return 'nan';
      return Number.isInteger(expr.numericValue) ? 'integer' : 'real';
    }
    if (expr.numericValue.isNaN) return 'nan';
    const type = expr.numericValue.type;
    if (type === 'integer' || type === 'finite_integer') return 'integer';
    if (type === 'rational' || type === 'finite_rational') return 'rational';
    if (type === 'real' || type === 'finite_real') return 'real';
    if (type === 'complex' || type === 'finite_complex') return 'complex';
    if (type === 'imaginary') return 'complex';
    if (type === 'finite_number') return 'complex';
    if (type === 'non_finite_number') return 'constant';
    if (type === 'number') return 'real';
    return 'other';
  }

  // Complex numbers
  if (isSymbol(expr, 'ImaginaryUnit')) return 'complex';