@johnhenry/math 0.0.0

package/src/Permutation.ts

@@ -0,0 +1,148 @@
+import { Cycle } from "./Cycle.ts";
+import { NumberTheory } from "./NumberTheory.ts";
+
+/**
+ * Permutation — a bijection described by a domain array and the codomain array
+ * it maps onto (element-wise). Ported from Mallory's ActionScript `Permutation`.
+ *
+ * Bug fixes from the AS3 original:
+ *  - the constructor silently ignored mismatched-length inputs; it now throws.
+ *  - `order` wrapped cycle lengths in `ComplexNumber` then read `.value` off an
+ *    `int` (yielding `undefined`); it now takes the LCM of the plain lengths and
+ *    returns 1 for the identity.
+ *  - `cycles` no longer mutates any shared state (it works on local copies).
+ */
+export class Permutation<T = unknown> {
+  private readonly _domain: T[];
+  private readonly _coDomain: T[];
+  // Lazily-built domain -> codomain lookup, cached on first use. The instance is otherwise
+  // immutable (domain/coDomain are never mutated after construction), so this is safe to cache
+  // for the lifetime of the object.
+  private _lookup: Map<T, T> | null = null;
+
+  constructor(input: T[], output: T[]) {
+    if (input.length !== output.length) {
+      throw new Error("Permutation domain and codomain must have equal length.");
+    }
+    this._domain = [...input];
+    this._coDomain = [...output];
+  }
+
+  get domain(): T[] {
+    return [...this._domain];
+  }
+
+  get coDomain(): T[] {
+    return [...this._coDomain];
+  }
+
+  /** The domain -> codomain lookup map, built once (on first access) and reused thereafter. */
+  private get lookup(): Map<T, T> {
+    if (this._lookup === null) {
+      this._lookup = new Map(this._domain.map((d, i) => [d, this._coDomain[i] as T]));
+    }
+    return this._lookup;
+  }
+
+  /** Map an element through the permutation (identity outside the domain). */
+  apply(element: T): T {
+    const map = this.lookup;
+    return map.has(element) ? (map.get(element) as T) : element;
+  }
+
+  /** The inverse permutation (swap domain and codomain). */
+  inverse(): Permutation<T> {
+    return new Permutation(this.coDomain, this.domain);
+  }
+
+  /** Raise the permutation to an integer power, via binary exponentiation (`O(log p)` compositions). */
+  power(pow: number): Permutation<T> {
+    if (pow === 0) return Permutation.Identity as Permutation<T>;
+    if (pow === 1) return this;
+    if (pow === -1) return this.inverse();
+
+    let base: Permutation<T> = this;
+    let p = pow;
+    if (pow < -1) {
+      base = this.inverse();
+      p = -pow;
+    }
+
+    // Repeated squaring: result accumulates the product of base^(2^i) for each set bit of p.
+    let result: Permutation<T> | undefined;
+    while (p > 0) {
+      if (p % 2 === 1) result = result === undefined ? base : Permutation.compose(result, base);
+      p = Math.floor(p / 2);
+      if (p > 0) base = Permutation.compose(base, base);
+    }
+    return result as Permutation<T>;
+  }
+
+  toString(): string {
+    const parts = this._domain.map((d, i) => `${d} -> ${this._coDomain[i]}`);
+    return `(${parts.join(",")})`;
+  }
+
+  /** Decompose into disjoint cycles. */
+  cycles(): Array<Cycle<T>> {
+    const domain = [...this._domain];
+    const coDomain = [...this._coDomain];
+    const result: Array<Cycle<T>> = [];
+
+    while (domain.length > 0) {
+      const start = domain[0] as T;
+      let current = start;
+      const tempArray: T[] = [];
+      do {
+        tempArray.push(current);
+        current = this.apply(current);
+        for (let i = 0; i < coDomain.length; i++) {
+          if (current === coDomain[i]) {
+            domain.splice(i, 1);
+            coDomain.splice(i, 1);
+            break;
+          }
+        }
+      } while (current !== start);
+      result.push(new Cycle(tempArray));
+    }
+    return result;
+  }
+
+  /** The order of the permutation (LCM of its cycle lengths). */
+  order(): number {
+    const lengths = this.cycles().map((c) => c.length);
+    if (lengths.length === 0) return 1;
+    return Number(NumberTheory.lcmList(lengths));
+  }
+
+  static readonly Identity: Permutation<unknown> = new Permutation<unknown>([], []);
+
+  /** Compose two permutations: `(sigma ∘ tao)(x) = sigma(tao(x))`. */
+  static compose<T>(sigma: Permutation<T>, tao: Permutation<T>): Permutation<T> {
+    // Set preserves insertion order and dedupes in O(n), matching the old O(n^2)
+    // lastIndexOf/splice loop's "first occurrence wins" semantics exactly.
+    const newDomain = Array.from(new Set(sigma.domain.concat(tao.domain)));
+    const newCoDomain = newDomain.map((x) => sigma.apply(tao.apply(x)));
+    return new Permutation(newDomain, newCoDomain);
+  }
+
+  /** Compose a list of permutations left-to-right. */
+  static composeList<T>(list: Array<Permutation<T>>): Permutation<T> {
+    if (list.length === 0) return Permutation.Identity as Permutation<T>;
+    if (list.length === 1) return list[0] as Permutation<T>;
+    return list.reduce((acc, p) => Permutation.compose(acc, p));
+  }
+
+  /** Structural equality (same action on every domain element of either). */
+  static equal<T>(sigma: Permutation<T>, tao: Permutation<T>): boolean {
+    for (const d of sigma.domain) if (sigma.apply(d) !== tao.apply(d)) return false;
+    for (const d of tao.domain) if (tao.apply(d) !== sigma.apply(d)) return false;
+    return true;
+  }
+
+  /** Whether two permutations commute. */
+  static commute<T>(sigma: Permutation<T>, tao: Permutation<T>): boolean {
+    return Permutation.equal(Permutation.compose(sigma, tao), Permutation.compose(tao, sigma));
+  }
+}

package/src/Polygon.ts

@@ -0,0 +1,229 @@
+import { NumberTheory } from "./NumberTheory.ts";
+import { distanceVector } from "./RealMath.ts";
+import { Vector } from "./Vector.ts";
+
+/** A 2D point stored as a {@link Vector} `[x, y]`. */
+type Point = Vector<number>;
+
+/**
+ * Polygon — an ordered list of vertex points ({@link Vector} subclass). Ported
+ * from Mallory's ActionScript `Polygon`.
+ *
+ * Bug fixes from the AS3 original:
+ *  - `perimeter` accumulated into a `uint`, truncating the fractional length.
+ *  - `area` only summed two triangles, so it was wrong for pentagons and up; it
+ *    now uses the shoelace formula, correct for any simple polygon.
+ *  - `angle` was stubbed to `return 0` (with dead code calling classes that do
+ *    not exist); it now computes the interior angle via the law of cosines it
+ *    documented.
+ */
+export class Polygon extends Vector<Point> {
+  /** The vertex at `index`, wrapping around the polygon. */
+  vertex(index: number): Point {
+    return this[Number(NumberTheory.mod(index, this.length))] as Point;
+  }
+
+  get vertexCount(): number {
+    return this.length;
+  }
+
+  get edgeCount(): number {
+    if (this.vertexCount < 3) return this.length - 1;
+    return this.vertexCount;
+  }
+
+  /** The edge starting at `index` as a two-vertex polygon. */
+  edge(index: number): Polygon {
+    return new Polygon(this.vertex(index), this.vertex(index + 1));
+  }
+
+  /** Total perimeter length (bug fix: no longer truncated to an integer). */
+  perimeter(): number {
+    let per = 0;
+    for (let i = 0; i < this.edgeCount; i++) {
+      per += distanceVector(this.vertex(i), this.vertex(i + 1));
+    }
+    return per;
+  }
+
+  /** Heron's-formula area of the triangle on the first three vertices. */
+  private triArea(): number {
+    const a = distanceVector(this.vertex(0), this.vertex(1));
+    const b = distanceVector(this.vertex(1), this.vertex(2));
+    const c = distanceVector(this.vertex(2), this.vertex(0));
+    const s = (a + b + c) / 2;
+    return Math.sqrt(s * (s - a) * (s - b) * (s - c));
+  }
+
+  /**
+   * Area of the polygon via the shoelace formula (bug fix: the AS3 version only
+   * summed two triangles and was wrong for polygons with more than four sides).
+   */
+  area(): number {
+    if (this.vertexCount < 3) return 0;
+    if (this.vertexCount === 3) return this.triArea();
+    let sum = 0;
+    for (let i = 0; i < this.vertexCount; i++) {
+      const current = this.vertex(i);
+      const next = this.vertex(i + 1);
+      sum += (current.x as number) * (next.y as number) - (next.x as number) * (current.y as number);
+    }
+    return Math.abs(sum) / 2;
+  }
+
+  /**
+   * The area centroid (center of mass) as an `[x, y]` point. Complements
+   * {@link perimeter} and {@link area}. Falls back to the vertex average for a
+   * degenerate (zero-area) polygon.
+   */
+  centroid(): Point {
+    let signedArea = 0;
+    let cx = 0;
+    let cy = 0;
+    for (let i = 0; i < this.vertexCount; i++) {
+      const cur = this.vertex(i);
+      const next = this.vertex(i + 1);
+      const cross = (cur.x as number) * (next.y as number) - (next.x as number) * (cur.y as number);
+      signedArea += cross;
+      cx += ((cur.x as number) + (next.x as number)) * cross;
+      cy += ((cur.y as number) + (next.y as number)) * cross;
+    }
+    if (signedArea === 0) {
+      // Degenerate: average the vertices.
+      let sx = 0;
+      let sy = 0;
+      for (let i = 0; i < this.vertexCount; i++) {
+        sx += this.vertex(i).x as number;
+        sy += this.vertex(i).y as number;
+      }
+      const n = this.vertexCount || 1;
+      return Vector.fromArray([sx / n, sy / n]);
+    }
+    return Vector.fromArray([cx / (3 * signedArea), cy / (3 * signedArea)]);
+  }
+
+  /**
+   * Interior angle (radians) at vertex `i`, via the law of cosines
+   * (bug fix: the AS3 method always returned 0).
+   */
+  angle(i: number): number {
+    const ab = distanceVector(this.vertex(i), this.vertex(i + 1));
+    const bc = distanceVector(this.vertex(i), this.vertex(i - 1));
+    const ac = distanceVector(this.vertex(i + 1), this.vertex(i - 1));
+    return Math.acos((ab * ab + bc * bc - ac * ac) / (2 * ab * bc));
+  }
+
+  /** True when `point` lies inside the polygon (even-odd ray-casting rule). */
+  contains(point: Point): boolean {
+    const px = point.x as number;
+    const py = point.y as number;
+    let inside = false;
+    const n = this.vertexCount;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+      const vi = this.vertex(i);
+      const vj = this.vertex(j);
+      const xi = vi.x as number;
+      const yi = vi.y as number;
+      const xj = vj.x as number;
+      const yj = vj.y as number;
+      if (yi > py !== yj > py && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi) inside = !inside;
+    }
+    return inside;
+  }
+
+  /** True when the polygon is convex (all turns share the same orientation). */
+  isConvex(): boolean {
+    const n = this.vertexCount;
+    if (n < 3) return false;
+    let sign = 0;
+    for (let i = 0; i < n; i++) {
+      const a = this.vertex(i);
+      const b = this.vertex(i + 1);
+      const c = this.vertex(i + 2);
+      const cross =
+        ((b.x as number) - (a.x as number)) * ((c.y as number) - (b.y as number)) -
+        ((b.y as number) - (a.y as number)) * ((c.x as number) - (b.x as number));
+      if (cross !== 0) {
+        const s = Math.sign(cross);
+        if (sign === 0) sign = s;
+        else if (s !== sign) return false;
+      }
+    }
+    return true;
+  }
+
+  /** True when no two non-adjacent edges cross (the polygon is simple). */
+  isSimple(): boolean {
+    const n = this.vertexCount;
+    if (n < 3) return false;
+    for (let i = 0; i < n; i++) {
+      const a1 = this.vertex(i);
+      const a2 = this.vertex(i + 1);
+      for (let j = i + 1; j < n; j++) {
+        // Skip edges that share a vertex (adjacent, or the wrap-around pair).
+        if (j === i || j === i + 1 || (i === 0 && j === n - 1)) continue;
+        const b1 = this.vertex(j);
+        const b2 = this.vertex(j + 1);
+        if (Polygon.segmentsIntersect(a1, a2, b1, b2)) return false;
+      }
+    }
+    return true;
+  }
+
+  private static orient(a: Point, b: Point, c: Point): number {
+    return (
+      ((b.x as number) - (a.x as number)) * ((c.y as number) - (a.y as number)) -
+      ((b.y as number) - (a.y as number)) * ((c.x as number) - (a.x as number))
+    );
+  }
+
+  private static onSegment(a: Point, b: Point, p: Point): boolean {
+    return (
+      Math.min(a.x as number, b.x as number) <= (p.x as number) &&
+      (p.x as number) <= Math.max(a.x as number, b.x as number) &&
+      Math.min(a.y as number, b.y as number) <= (p.y as number) &&
+      (p.y as number) <= Math.max(a.y as number, b.y as number)
+    );
+  }
+
+  private static segmentsIntersect(p1: Point, p2: Point, p3: Point, p4: Point): boolean {
+    const d1 = Polygon.orient(p3, p4, p1);
+    const d2 = Polygon.orient(p3, p4, p2);
+    const d3 = Polygon.orient(p1, p2, p3);
+    const d4 = Polygon.orient(p1, p2, p4);
+    if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) return true;
+    if (d1 === 0 && Polygon.onSegment(p3, p4, p1)) return true;
+    if (d2 === 0 && Polygon.onSegment(p3, p4, p2)) return true;
+    if (d3 === 0 && Polygon.onSegment(p1, p2, p3)) return true;
+    if (d4 === 0 && Polygon.onSegment(p1, p2, p4)) return true;
+    return false;
+  }
+
+  /**
+   * A regular n-gon: `n` vertices evenly spaced on a circle of `radius`
+   * around `center`, starting at `startAngle` (default `-pi/2`, i.e. the
+   * first vertex points straight up — the conventional orientation for a
+   * polygon drawn on a screen y-down or math y-up axis alike) and
+   * proceeding counterclockwise in standard math convention.
+   */
+  static regular(n: number, radius = 1, center: Point = Vector.fromArray([0, 0]), startAngle = -Math.PI / 2): Polygon {
+    if (n < 3) throw new Error(`Polygon.regular: n must be at least 3, got ${n}`);
+    const cx = center.x as number;
+    const cy = center.y as number;
+    const vertices = Array.from({ length: n }, (_, i) => {
+      const theta = startAngle + (2 * Math.PI * i) / n;
+      return Vector.fromArray([cx + radius * Math.cos(theta), cy + radius * Math.sin(theta)]) as Point;
+    });
+    return new Polygon(...vertices);
+  }
+
+  /** A clone of the polygon (deep-clones nested vertex vectors by default). */
+  override clone(deep = true): Polygon {
+    const out = new Polygon(this.length);
+    for (let i = 0; i < out.length; i++) {
+      const el = this[i];
+      out[i] = deep && el instanceof Vector ? (el.clone() as Point) : (el as Point);
+    }
+    return out;
+  }
+}

package/src/PolynomialRing.ts

@@ -0,0 +1,242 @@
+import type { Structure } from "./Structure.ts";
+
+/**
+ * PolynomialRing — polynomials with coefficients in an arbitrary {@link Structure}
+ * (a finite field, the rationals, quaternions, whatever the structure supplies),
+ * following {@link GroupTheory}'s idiom of accepting the algebra as a constructor
+ * parameter rather than duplicating field logic. This generalizes long division,
+ * GCD, differentiation, and evaluation to any field — e.g. polynomials over
+ * `Structure.integersModulo(7)`, or plain real polynomials via
+ * `new PolynomialRing(Structure.realField())`.
+ *
+ * Coefficients are plain `T[]` arrays in ascending power (`p[i]` is the
+ * coefficient of `x^i`), trimmed of trailing zero coefficients. The zero
+ * polynomial is `[]`, with degree `-1`.
+ *
+ * {@link parsePolynomial}/{@link polynomialToString} below are real-number-only
+ * helpers for the common `"3*x^2-2*x+1"` string notation — parsing/formatting
+ * needs decimal syntax, which doesn't generalize to an arbitrary `Structure`.
+ */
+export class PolynomialRing<T> {
+  readonly structure: Structure<T>;
+
+  constructor(structure: Structure<T>) {
+    this.structure = structure;
+  }
+
+  /** Drop trailing coefficients equal to the structure's zero. */
+  private trim(p: T[]): T[] {
+    let n = p.length;
+    while (n > 0 && this.structure.equality(p[n - 1] as T, this.structure.zero)) n--;
+    return p.slice(0, n);
+  }
+
+  /** `-1` for the zero polynomial, else the index of the highest non-zero coefficient. */
+  degree(p: T[]): number {
+    return this.trim(p).length - 1;
+  }
+
+  zero(): T[] {
+    return [];
+  }
+
+  one(): T[] {
+    return [this.structure.one];
+  }
+
+  private pad(p: T[], length: number): T[] {
+    const result = p.slice();
+    while (result.length < length) result.push(this.structure.zero);
+    return result;
+  }
+
+  add(a: T[], b: T[]): T[] {
+    const length = Math.max(a.length, b.length);
+    const pa = this.pad(a, length);
+    const pb = this.pad(b, length);
+    return this.trim(pa.map((x, i) => this.structure.add(x, pb[i] as T)));
+  }
+
+  negate(p: T[]): T[] {
+    return p.map((x) => this.structure.negative(x));
+  }
+
+  subtract(a: T[], b: T[]): T[] {
+    return this.add(a, this.negate(b));
+  }
+
+  scale(p: T[], scalar: T): T[] {
+    return this.trim(p.map((x) => this.structure.multiply(scalar, x)));
+  }
+
+  multiply(a: T[], b: T[]): T[] {
+    if (a.length === 0 || b.length === 0) return [];
+    const result: T[] = new Array(a.length + b.length - 1).fill(this.structure.zero);
+    for (let i = 0; i < a.length; i++) {
+      for (let j = 0; j < b.length; j++) {
+        result[i + j] = this.structure.add(result[i + j] as T, this.structure.multiply(a[i] as T, b[j] as T));
+      }
+    }
+    return this.trim(result);
+  }
+
+  /** Polynomial long division over the structure's field operations. */
+  divmod(a: T[], b: T[]): { quotient: T[]; remainder: T[] } {
+    const bd = this.degree(b);
+    if (bd < 0) throw new Error("PolynomialRing: division by the zero polynomial");
+    let remainder = this.trim(a);
+    const leadInv = this.structure.reciprocal(b[bd] as T);
+    const quotient: T[] = new Array(Math.max(this.degree(remainder) - bd + 1, 0)).fill(this.structure.zero);
+    while (this.degree(remainder) >= bd) {
+      const rd = this.degree(remainder);
+      const shift = rd - bd;
+      const coeff = this.structure.multiply(remainder[rd] as T, leadInv);
+      quotient[shift] = coeff;
+      for (let i = 0; i <= bd; i++) {
+        remainder[i + shift] = this.structure.subtract(
+          remainder[i + shift] as T,
+          this.structure.multiply(coeff, b[i] as T),
+        );
+      }
+      remainder = this.trim(remainder);
+    }
+    return { quotient: this.trim(quotient), remainder };
+  }
+
+  divide(a: T[], b: T[]): T[] {
+    return this.divmod(a, b).quotient;
+  }
+
+  mod(a: T[], b: T[]): T[] {
+    return this.divmod(a, b).remainder;
+  }
+
+  /** Rescale so the leading coefficient is the structure's one. No-op on the zero polynomial. */
+  private makeMonic(p: T[]): T[] {
+    const d = this.degree(p);
+    if (d < 0) return p;
+    return this.scale(p, this.structure.reciprocal(p[d] as T));
+  }
+
+  /** Monic GCD via the Euclidean algorithm (repeated `divmod`). */
+  gcd(a: T[], b: T[]): T[] {
+    let x = this.trim(a);
+    let y = this.trim(b);
+    while (this.degree(y) >= 0) {
+      const { remainder } = this.divmod(x, y);
+      x = y;
+      y = remainder;
+    }
+    return this.makeMonic(x);
+  }
+
+  /**
+   * The derivative polynomial (`i·c_i`, well-defined over any ring: `i` is
+   * built up as a running "`n` copies of the structure's `one`, added
+   * together" accumulator rather than being reconstructed from scratch for
+   * each coefficient — that would cost O(i) additions per coefficient, i.e.
+   * O(n²) additions overall for a degree-n polynomial).
+   */
+  derivative(p: T[]): T[] {
+    const trimmed = this.trim(p);
+    const out: T[] = [];
+    let n = this.structure.zero; // accumulates to `i` as an element of the structure
+    for (let i = 1; i < trimmed.length; i++) {
+      n = this.structure.add(n, this.structure.one);
+      out.push(this.structure.multiply(n, trimmed[i] as T));
+    }
+    return this.trim(out);
+  }
+
+  /**
+   * An antiderivative with zero constant of integration (`c_i / (i+1)`, via the
+   * structure's `reciprocal`). `i+1` is built up as a running accumulator (see
+   * {@link derivative}) instead of being reconstructed from scratch per term.
+   */
+  antiderivative(p: T[]): T[] {
+    const trimmed = this.trim(p);
+    const out: T[] = [this.structure.zero];
+    let n = this.structure.zero; // accumulates to `i+1` as an element of the structure
+    for (let i = 0; i < trimmed.length; i++) {
+      n = this.structure.add(n, this.structure.one);
+      out.push(this.structure.multiply(trimmed[i] as T, this.structure.reciprocal(n)));
+    }
+    return this.trim(out);
+  }
+
+  /** Evaluate at `x` via Horner's method, using the structure's field operations. */
+  evaluate(p: T[], x: T): T {
+    let result = this.structure.zero;
+    for (let i = p.length - 1; i >= 0; i--) {
+      result = this.structure.add(this.structure.multiply(result, x), p[i] as T);
+    }
+    return result;
+  }
+
+  equal(a: T[], b: T[]): boolean {
+    const ta = this.trim(a);
+    const tb = this.trim(b);
+    return ta.length === tb.length && ta.every((x, i) => this.structure.equality(x, tb[i] as T));
+  }
+
+  toString(p: T[], variable = "x"): string {
+    const trimmed = this.trim(p);
+    if (trimmed.length === 0) return "0";
+    const terms: string[] = [];
+    for (let i = trimmed.length - 1; i >= 0; i--) {
+      const c = trimmed[i] as T;
+      if (this.structure.equality(c, this.structure.zero)) continue;
+      if (i === 0) terms.push(`${c}`);
+      else if (i === 1) terms.push(`${c}*${variable}`);
+      else terms.push(`${c}*${variable}^${i}`);
+    }
+    return terms.join("+");
+  }
+}
+
+/**
+ * Parse a real-coefficient polynomial string such as `"3*x^2-2*x+1"` into
+ * ascending-power coefficients (inverse of {@link polynomialToString}).
+ */
+export function parsePolynomial(str: string, variable = "x"): number[] {
+  const s = str.replace(/\s+/g, "");
+  if (s === "") return [0];
+  const terms = s
+    .replace(/-/g, "+-")
+    .split("+")
+    .filter((t) => t !== "");
+  const p: number[] = [];
+  for (const term of terms) {
+    let coef: number;
+    let exp: number;
+    const vi = term.indexOf(variable);
+    if (vi === -1) {
+      coef = Number(term);
+      exp = 0;
+    } else {
+      const coefPart = term.slice(0, vi).replace(/\*$/, "");
+      coef = coefPart === "" || coefPart === "+" ? 1 : coefPart === "-" ? -1 : Number(coefPart);
+      const rest = term.slice(vi + variable.length);
+      exp = rest.startsWith("^") ? Number(rest.slice(1)) : 1;
+    }
+    p[exp] = (p[exp] ?? 0) + coef;
+  }
+  for (let i = 0; i < p.length; i++) if (p[i] === undefined) p[i] = 0;
+  return p;
+}
+
+/**
+ * Render ascending-power real coefficients as a human-readable string such as
+ * `3*x^2+2*x+1` (inverse of {@link parsePolynomial}).
+ */
+export function polynomialToString(coeffs: number[], variable = "x", descending = true): string {
+  const term = (coef: number, i: number): string => {
+    if (i === 0) return String(coef);
+    if (i === 1) return `${coef}*${variable}`;
+    return `${coef}*${variable}^${i}`;
+  };
+  const indices = descending
+    ? Array.from({ length: coeffs.length }, (_, i) => coeffs.length - 1 - i)
+    : Array.from({ length: coeffs.length }, (_, i) => i);
+  return indices.map((i) => term(coeffs[i] as number, i)).join("+");
+}