curvy 1.0.9 → 2.0.0-alpha.2

package/dist/shared/cubic-CpHAx8cC.mjs

@@ -0,0 +1,479 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { clampToZero, epsEquals } from "../number.mjs";
+import { i as make$4 } from "./vector2-CL1HDdPr.mjs";
+import { a as filter, c as make$5, d as toOpen, l as scaleShift, n as contains, o as fromMinMax, t as biunit, u as size } from "./interval-05CR6eBf.mjs";
+import { a as match, l as two, n as fromArray, o as none, r as isNone, s as one } from "./solution-CrtLfqEq.mjs";
+//#region src/polynomial/quadratic.internal.circular.ts
+const QuadraticPolynomialTypeId = Symbol.for("curvy/polynomial/quadratic");
+var QuadraticPolynomialImpl = class extends Pipeable {
+	[QuadraticPolynomialTypeId] = QuadraticPolynomialTypeId;
+	c0;
+	c1;
+	c2;
+	constructor(c0 = 0, c1 = 0, c2 = 0) {
+		super();
+		this.c0 = c0;
+		this.c1 = c1;
+		this.c2 = c2;
+	}
+};
+//#endregion
+//#region src/polynomial/linear.internal.ts
+const LinearPolynomialTypeId = Symbol.for("curvy/linear");
+var LinearPolynomialImpl = class extends Pipeable {
+	[LinearPolynomialTypeId] = LinearPolynomialTypeId;
+	c0;
+	c1;
+	constructor(c0 = 0, c1 = 0) {
+		super();
+		this.c0 = c0;
+		this.c1 = c1;
+	}
+};
+const isLinearPolynomial = (v) => typeof v === "object" && v !== null && LinearPolynomialTypeId in v;
+const equals$3 = dual(2, (a, b) => epsEquals(a.c0, b.c0) && epsEquals(a.c1, b.c1));
+const make$3 = (c0 = 0, c1 = 0) => new LinearPolynomialImpl(c0, c1);
+const fromVector$3 = (v) => new LinearPolynomialImpl(v.x, v.y);
+const fromPointSlope = (p, slope) => new LinearPolynomialImpl(p.y - slope * p.x, slope);
+const fromPoints$3 = (p1, p2) => fromPointSlope(p1, (p2.y - p1.y) / (p2.x - p1.x));
+const solve$3 = dual(2, (p, x) => p.c0 + x * p.c1);
+const toSolver$3 = (p) => (x) => solve$3(p, x);
+const solveInverse$3 = dual(2, (p, y) => {
+	if (p.c1 === 0) return none;
+	return one((y - p.c0) / p.c1);
+});
+const toInverseSolver$3 = (p) => (y) => solveInverse$3(p, y);
+const monotonicity$3 = (p) => p.c1 === 0 ? "constant" : p.c1 > 0 ? "increasing" : "decreasing";
+const isMonotonic$3 = (p) => p.c1 !== 0;
+const isIncreasing$3 = (p) => p.c1 > 0;
+const isDecreasing$3 = (p) => p.c1 < 0;
+const asMonotonic$3 = (p) => {
+	invariant(isMonotonic$3(p), "linear polynomial is not monotonic");
+	return p;
+};
+const asIncreasing$3 = (p) => {
+	invariant(isIncreasing$3(p), "linear polynomial is not increasing");
+	return p;
+};
+const asDecreasing$3 = (p) => {
+	invariant(isDecreasing$3(p), "linear polynomial is not decreasing");
+	return p;
+};
+const derivative$3 = (p) => p.c1;
+const antiderivative$1 = dual((args) => isLinearPolynomial(args[0]), (p, integrationConstant = 0) => new QuadraticPolynomialImpl(integrationConstant, p.c0, p.c1 / 2));
+const domain$3 = dual(2, (p, r) => {
+	if (p.c1 === 0) {
+		if (r.start === p.c0 && r.end === p.c0) return one(make$5(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY));
+		return none;
+	}
+	const start = solveInverse$3(p, r.start);
+	const end = solveInverse$3(p, r.end);
+	if (isNone(start) || isNone(end)) return none;
+	return one(make$5(start.value, end.value));
+});
+const range$3 = dual(2, (p, d) => fromMinMax(solve$3(p, d.start), solve$3(p, d.end)));
+const length$3 = dual(2, (p, d) => {
+	if (size(d) === 0) return 0;
+	if (p.c1 === 0) return size(d);
+	return Math.sqrt(1 + p.c1 ** 2) * size(d);
+});
+//#endregion
+//#region src/polynomial/cubic.internal.circular.ts
+const CubicPolynomialTypeId = Symbol.for("curvy/polynomial/cubic");
+var CubicPolynomialImpl = class extends Pipeable {
+	[CubicPolynomialTypeId] = CubicPolynomialTypeId;
+	c0;
+	c1;
+	c2;
+	c3;
+	constructor(c0 = 0, c1 = 0, c2 = 0, c3 = 0) {
+		super();
+		this.c0 = c0;
+		this.c1 = c1;
+		this.c2 = c2;
+		this.c3 = c3;
+	}
+};
+//#endregion
+//#region src/polynomial/monotonicity.ts
+function guaranteedMonotonicityFromComparison(s0, s1) {
+	if (s0 < s1) return "increasing";
+	if (s0 > s1) return "decreasing";
+	return "constant";
+}
+//#endregion
+//#region src/polynomial/quadratic.internal.ts
+const fromPoints$2 = (p0, p1, p2) => {
+	const f01 = (p1.y - p0.y) / (p1.x - p0.x);
+	const f012 = ((p2.y - p1.y) / (p2.x - p1.x) - f01) / (p2.x - p0.x);
+	return new QuadraticPolynomialImpl(p0.y - f01 * p0.x + f012 * p0.x * p1.x, f01 - f012 * (p0.x + p1.x), f012);
+};
+const make$2 = (c0 = 0, c1 = 0, c2 = 0) => new QuadraticPolynomialImpl(c0, c1, c2);
+const isQuadraticPolynomial = (v) => typeof v === "object" && v !== null && QuadraticPolynomialTypeId in v;
+const equals$2 = dual(2, (a, b) => epsEquals(a.c0, b.c0) && epsEquals(a.c1, b.c1) && epsEquals(a.c2, b.c2));
+const fromVector$2 = (v) => new QuadraticPolynomialImpl(v.x, v.y, v.z);
+const solve$2 = dual(2, (p, x) => p.c0 + x * p.c1 + x ** 2 * p.c2);
+const toSolver$2 = (p) => (x) => solve$2(p, x);
+const solveInverse$2 = dual(2, (p, y) => {
+	if (p.c2 === 0) return solveInverse$3(make$3(p.c0, p.c1), y);
+	const discriminant = p.c1 ** 2 - 4 * p.c2 * (p.c0 - y);
+	if (discriminant < 0) return none;
+	if (discriminant === 0) return one(-p.c1 / (2 * p.c2));
+	const sqrtDiscriminant = Math.sqrt(discriminant);
+	const a = (-p.c1 + sqrtDiscriminant) / (2 * p.c2);
+	const b = (-p.c1 - sqrtDiscriminant) / (2 * p.c2);
+	return a < b ? two(a, b) : two(b, a);
+});
+const toInverseSolver$2 = (p) => (y) => solveInverse$2(p, y);
+const derivative$2 = (p) => make$3(p.c1, p.c2 * 2);
+const roots$2 = (p) => solveInverse$2(p, 0);
+const extreme = (p) => derivative$2(p).pipe(solveInverse$3(0), match({
+	onNone: () => null,
+	onSome: ({ value: t }) => make$4(t, solve$2(p, t))
+}));
+const monotonicity$2 = dual((args) => isQuadraticPolynomial(args[0]), (p, i) => {
+	invariant(i === void 0 || size(i) > 0, "monotonicity is undefined over a zero-width interval");
+	if (p.c2 === 0 && p.c1 === 0) return "constant";
+	if (p.c2 === 0) return monotonicity$3(make$3(p.c0, p.c1));
+	const e = extreme(p);
+	if (i === void 0 || contains(toOpen(i), e.x)) return "none";
+	return guaranteedMonotonicityFromComparison(solve$2(p, i.start), solve$2(p, i.end));
+});
+const isMonotonic$2 = dual((args) => isQuadraticPolynomial(args[0]), ((p, i) => {
+	const m = monotonicity$2(p, i);
+	return m === "increasing" || m === "decreasing";
+}));
+const isIncreasing$2 = dual((args) => isQuadraticPolynomial(args[0]), ((p, i) => monotonicity$2(p, i) === "increasing"));
+const isDecreasing$2 = dual((args) => isQuadraticPolynomial(args[0]), ((p, i) => monotonicity$2(p, i) === "decreasing"));
+const asMonotonic$2 = (p, i) => {
+	invariant(isMonotonic$2(p, i), "quadratic polynomial is not monotonic");
+	return p;
+};
+const asIncreasing$2 = (p, i) => {
+	invariant(isIncreasing$2(p, i), "quadratic polynomial is not increasing");
+	return p;
+};
+const asDecreasing$2 = (p, i) => {
+	invariant(isDecreasing$2(p, i), "quadratic polynomial is not decreasing");
+	return p;
+};
+const antiderivative = dual(2, (p, integrationConstant = 0) => new CubicPolynomialImpl(integrationConstant, p.c0, p.c1 / 2, p.c2 / 3));
+const domain$2 = dual(2, (p, r) => {
+	const start = solveInverse$2(p, r.start);
+	const end = solveInverse$2(p, r.end);
+	if (start.length === 0 && end.length === 0) return none;
+	return one(fromMinMax(...start, ...end));
+});
+const range$2 = dual(2, (p, d) => {
+	if (p.c2 === 0) return range$3(make$3(p.c0, p.c1), d);
+	const e = extreme(p);
+	return e !== null && contains(d, e.x) ? fromMinMax(solve$2(p, d.start), solve$2(p, d.end), e.y) : fromMinMax(solve$2(p, d.start), solve$2(p, d.end));
+});
+const length$2 = dual(2, (p, dom) => {
+	if (size(dom) === 0) return 0;
+	if (p.c2 === 0) return length$3(make$3(p.c0, p.c1), dom);
+	const dp = derivative$2(p);
+	const derivativeStart = solve$3(dp, dom.start);
+	const sqrtStart = Math.sqrt(1 + derivativeStart ** 2);
+	const evalStart = (derivativeStart * sqrtStart + Math.log(Math.abs(derivativeStart + sqrtStart))) / (4 * p.c2);
+	const derivativeEnd = solve$3(dp, dom.end);
+	const sqrtEnd = Math.sqrt(1 + derivativeEnd ** 2);
+	return (derivativeEnd * sqrtEnd + Math.log(Math.abs(derivativeEnd + sqrtEnd))) / (4 * p.c2) - evalStart;
+});
+const curvature$2 = dual(2, (p, x) => Math.abs(2 * p.c2) / (1 + (solve$3(derivative$2(p), x) ** 2) ** 1.5));
+//#endregion
+//#region src/length.ts
+const GL32_X0 = .9972638618494816;
+const GL32_X1 = .9856115115452684;
+const GL32_X2 = .9647622555875064;
+const GL32_X3 = .9349060759377397;
+const GL32_X4 = .8963211557660521;
+const GL32_X5 = .84936761373257;
+const GL32_X6 = .7944837959679424;
+const GL32_X7 = .7321821187402897;
+const GL32_X8 = .6630442669302152;
+const GL32_X9 = .5877157572407623;
+const GL32_X10 = .5068999089322294;
+const GL32_X11 = .42135127613063533;
+const GL32_X12 = .33186860228212767;
+const GL32_X13 = .23928736225213706;
+const GL32_X14 = .1444719615827965;
+const GL32_X15 = .04830766568773831;
+const GL32_W0 = .007018610009470136;
+const GL32_W1 = .01627439473090571;
+const GL32_W2 = .02539206530926214;
+const GL32_W3 = .03427386291302141;
+const GL32_W4 = .042835898022226704;
+const GL32_W5 = .050998059262376154;
+const GL32_W6 = .05868409347853558;
+const GL32_W7 = .06582222277636195;
+const GL32_W8 = .07234579410884862;
+const GL32_W9 = .07819389578707044;
+const GL32_W10 = .08331192422694672;
+const GL32_W11 = .08765209300440374;
+const GL32_W12 = .0911738786957639;
+const GL32_W13 = .09384439908080454;
+const GL32_W14 = .09563872007927485;
+const GL32_W15 = .09654008851472785;
+//#endregion
+//#region src/polynomial/cubic.internal.ts
+const make$1 = (c0 = 0, c1 = 0, c2 = 0, c3 = 0) => new CubicPolynomialImpl(c0, c1, c2, c3);
+const isCubicPolynomial$1 = (v) => typeof v === "object" && v !== null && CubicPolynomialTypeId in v;
+const equals$1 = dual(2, (a, b) => epsEquals(a.c0, b.c0) && epsEquals(a.c1, b.c1) && epsEquals(a.c2, b.c2) && epsEquals(a.c3, b.c3));
+const fromVector$1 = (v) => new CubicPolynomialImpl(v.x, v.y, v.z, v.w);
+const fromPoints$1 = (p0, p1, p2, p3) => {
+	const f01 = (p1.y - p0.y) / (p1.x - p0.x);
+	const f12 = (p2.y - p1.y) / (p2.x - p1.x);
+	const f23 = (p3.y - p2.y) / (p3.x - p2.x);
+	const f012 = (f12 - f01) / (p2.x - p0.x);
+	const f0123 = ((f23 - f12) / (p3.x - p1.x) - f012) / (p3.x - p0.x);
+	return new CubicPolynomialImpl(p0.y - f01 * p0.x + f012 * p0.x * p1.x - f0123 * p0.x * p1.x * p2.x, f01 - f012 * (p0.x + p1.x) + f0123 * (p0.x * p1.x + p0.x * p2.x + p1.x * p2.x), f012 - f0123 * (p0.x + p1.x + p2.x), f0123);
+};
+const solve$1 = dual(2, (p, x) => p.c0 + x * p.c1 + x ** 2 * p.c2 + x ** 3 * p.c3);
+const toSolver$1 = (p) => (x) => solve$1(p, x);
+const solveInverse$1 = dual(2, (self, y) => {
+	if (self.c3 === 0) return solveInverse$2(make$2(self.c0, self.c1, self.c2), y);
+	const shift = self.c2 / (3 * self.c3);
+	const d0 = self.c2 ** 2 - 3 * self.c3 * self.c1;
+	const d1 = 2 * self.c2 ** 3 - 9 * self.c3 * self.c2 * self.c1 + 27 * self.c3 ** 2 * (self.c0 - y);
+	const p = -d0 / (3 * self.c3 ** 2);
+	const q = d1 / (27 * self.c3 ** 3);
+	const discriminant = clampToZero(-(4 * p ** 3 + 27 * q ** 2), 1e-12);
+	const roots = /* @__PURE__ */ new Set();
+	if (discriminant > 0) {
+		const r = 2 * Math.sqrt(-p / 3);
+		const theta = Math.acos(3 * q / (2 * p) * Math.sqrt(-3 / p)) / 3;
+		const offset = 2 * Math.PI / 3;
+		roots.add(r * Math.cos(theta + offset) - shift);
+		roots.add(r * Math.cos(theta) - shift);
+		roots.add(r * Math.cos(theta - offset) - shift);
+	} else if (discriminant < 0) {
+		const u = Math.sqrt(q ** 2 / 4 + p ** 3 / 27);
+		const u1 = Math.cbrt(-q / 2 + u);
+		const u2 = Math.cbrt(-q / 2 - u);
+		roots.add(u1 + u2 - shift);
+	} else if (d0 === 0) roots.add(-shift);
+	else {
+		roots.add((9 * self.c3 * (self.c0 - y) - self.c2 * self.c1) / (2 * d0));
+		roots.add((4 * self.c3 * self.c2 * self.c1 - 9 * self.c3 ** 2 * (self.c0 - y) - self.c2 ** 3) / (self.c3 * d0));
+	}
+	return fromArray(Array.from(roots).toSorted((a, b) => a - b));
+});
+const toInverseSolver$1 = (p) => (y) => solveInverse$1(p, y);
+const derivative$1 = (p) => make$2(p.c1, p.c2 * 2, p.c3 * 3);
+const subdivide$1 = dual(2, (p, t) => {
+	invariant(t > 0 && t < 1, "subdivide parameter t must be in the open interval (0, 1)");
+	const r = 1 - t;
+	return [make$1(p.c0, p.c1 * t, p.c2 * t * t, p.c3 * t * t * t), make$1(p.c0 + p.c1 * t + p.c2 * t * t + p.c3 * t * t * t, p.c1 * r + 2 * p.c2 * t * r + 3 * p.c3 * t * t * r, p.c2 * r * r + 3 * p.c3 * t * r * r, p.c3 * r * r * r)];
+});
+const roots$1 = (p) => solveInverse$1(p, 0);
+const extrema$1 = (p) => roots$2(derivative$1(p));
+const monotonicity$1 = dual((args) => isCubicPolynomial$1(args[0]), (p, i) => {
+	invariant(i === void 0 || size(i) > 0, "monotonicity is undefined over a zero-width interval");
+	if (p.c3 === 0 && p.c2 === 0 && p.c1 === 0) return "constant";
+	if (p.c3 === 0 && p.c2 === 0) return monotonicity$3(make$3(p.c0, p.c1));
+	if (i === void 0) return "none";
+	if (p.c3 === 0) return monotonicity$2(make$2(p.c0, p.c1, p.c2), i);
+	if (filter(toOpen(i), [...extrema$1(p)]).length > 0) return "none";
+	return guaranteedMonotonicityFromComparison(solve$1(p, i.start), solve$1(p, i.end));
+});
+const isMonotonic$1 = dual((args) => isCubicPolynomial$1(args[0]), ((p, i) => {
+	const m = monotonicity$1(p, i);
+	return m === "increasing" || m === "decreasing";
+}));
+const isIncreasing$1 = dual((args) => isCubicPolynomial$1(args[0]), ((p, i) => monotonicity$1(p, i) === "increasing"));
+const isDecreasing$1 = dual((args) => isCubicPolynomial$1(args[0]), ((p, i) => monotonicity$1(p, i) === "decreasing"));
+const asMonotonic$1 = (p, i) => {
+	invariant(isMonotonic$1(p, i), "cubic polynomial is not monotonic");
+	return p;
+};
+const asIncreasing$1 = (p, i) => {
+	invariant(isIncreasing$1(p, i), "cubic polynomial is not increasing");
+	return p;
+};
+const asDecreasing$1 = (p, i) => {
+	invariant(isDecreasing$1(p, i), "cubic polynomial is not decreasing");
+	return p;
+};
+const domain$1 = dual(2, (p, r) => fromMinMax(...solveInverse$1(p, r.start), ...solveInverse$1(p, r.end)));
+const range$1 = dual(2, (p, d) => fromMinMax(solve$1(p, d.start), solve$1(p, d.end), ...filter(d, [...extrema$1(p)]).map((e) => solve$1(p, e))));
+const length$1 = dual(2, (p, dom) => {
+	if (size(dom) === 0) return 0;
+	if (p.c3 === 0) {
+		if (p.c2 === 0) return length$3(make$3(p.c0, p.c1), dom);
+		return length$2(make$2(p.c0, p.c1, p.c2), dom);
+	}
+	const d = derivative$1(p);
+	const { scale, shift } = scaleShift(biunit, dom);
+	return (GL32_W0 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X0) ** 2) + GL32_W0 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X0) ** 2) + GL32_W1 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X1) ** 2) + GL32_W1 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X1) ** 2) + GL32_W2 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X2) ** 2) + GL32_W2 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X2) ** 2) + GL32_W3 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X3) ** 2) + GL32_W3 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X3) ** 2) + GL32_W4 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X4) ** 2) + GL32_W4 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X4) ** 2) + GL32_W5 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X5) ** 2) + GL32_W5 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X5) ** 2) + GL32_W6 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X6) ** 2) + GL32_W6 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X6) ** 2) + GL32_W7 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X7) ** 2) + GL32_W7 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X7) ** 2) + GL32_W8 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X8) ** 2) + GL32_W8 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X8) ** 2) + GL32_W9 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X9) ** 2) + GL32_W9 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X9) ** 2) + GL32_W10 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X10) ** 2) + GL32_W10 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X10) ** 2) + GL32_W11 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X11) ** 2) + GL32_W11 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X11) ** 2) + GL32_W12 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X12) ** 2) + GL32_W12 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X12) ** 2) + GL32_W13 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X13) ** 2) + GL32_W13 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X13) ** 2) + GL32_W14 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X14) ** 2) + GL32_W14 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X14) ** 2) + GL32_W15 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X15) ** 2) + GL32_W15 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X15) ** 2)) * scale;
+});
+const curvature$1 = dual(2, (p, x) => {
+	const d = derivative$1(p);
+	const dd = derivative$2(d);
+	return Math.abs(solve$3(dd, x)) / (1 + solve$2(d, x) ** 2) ** 1.5;
+});
+//#endregion
+//#region src/polynomial/cubic.ts
+var cubic_exports = /* @__PURE__ */ __exportAll({
+	asDecreasing: () => asDecreasing,
+	asIncreasing: () => asIncreasing,
+	asMonotonic: () => asMonotonic,
+	curvature: () => curvature,
+	derivative: () => derivative,
+	domain: () => domain,
+	equals: () => equals,
+	extrema: () => extrema,
+	fromPoints: () => fromPoints,
+	fromVector: () => fromVector,
+	isCubicPolynomial: () => isCubicPolynomial,
+	isDecreasing: () => isDecreasing,
+	isIncreasing: () => isIncreasing,
+	isMonotonic: () => isMonotonic,
+	length: () => length,
+	make: () => make,
+	monotonicity: () => monotonicity,
+	range: () => range,
+	roots: () => roots,
+	solve: () => solve,
+	solveInverse: () => solveInverse,
+	subdivide: () => subdivide,
+	toInverseSolver: () => toInverseSolver,
+	toSolver: () => toSolver
+});
+/**
+* Checks if a value is a `CubicPolynomial`.
+*
+* @param value - The value to check.
+* @returns `true` if the value is a `CubicPolynomial`, `false` otherwise.
+* @since 1.0.0
+*/
+const isCubicPolynomial = isCubicPolynomial$1;
+const equals = equals$1;
+/**
+* Creates a new `CubicPolynomial` instance.
+*
+* @param c0 - The coefficient of the x^0 term.
+* @param c1 - The coefficient of the x^1 term.
+* @param c2 - The coefficient of the x^2 term.
+* @param c3 - The coefficient of the x^3 term.
+*/
+const make = make$1;
+/**
+* Creates a new `CubicPolynomial` instance from a vector.
+*
+* @param v - The vector to convert.
+* @returns A new `CubicPolynomial` instance.
+* @since 1.0.0
+*/
+const fromVector = fromVector$1;
+/**
+* Creates a new `CubicPolynomial` that interpolates the four given points,
+* treating each `Vector2` as an `(x, y)` pair. The four input `x` values must
+* be distinct.
+*
+* @param p0 - The first point.
+* @param p1 - The second point.
+* @param p2 - The third point.
+* @param p3 - The fourth point.
+* @returns The unique cubic polynomial passing through the four points.
+* @since 2.0.0
+*/
+const fromPoints = fromPoints$1;
+const solve = solve$1;
+/**
+* Converts a cubic polynomial to a solver function.
+*
+* @param p - The cubic polynomial to convert.
+* @returns A function that takes a value of x and returns the result of the polynomial evaluation at x.
+* @since 1.0.0
+*/
+const toSolver = toSolver$1;
+const solveInverse = solveInverse$1;
+/**
+* Converts a cubic polynomial to an inverse solver function.
+*
+* @param p - The cubic polynomial to convert.
+* @returns A function that takes a value of y and returns the roots of the polynomial equation p(x) = y.
+* @since 1.0.0
+*/
+const toInverseSolver = toInverseSolver$1;
+/**
+* Calculates the derivative of a cubic polynomial.
+*
+* @param p - The cubic polynomial to differentiate.
+* @returns The derivative of the cubic polynomial.
+* @since 1.0.0
+*/
+const derivative = derivative$1;
+const subdivide = subdivide$1;
+/**
+* Calculates the roots of a cubic polynomial.
+*
+* @param p - The cubic polynomial to find the roots of.
+* @returns The roots of the cubic polynomial.
+* @since 1.0.0
+*/
+const roots = roots$1;
+/**
+* Calculates the extrema of a cubic polynomial.
+*
+* @param p - The cubic polynomial to find the extrema of.
+* @returns The extrema of the cubic polynomial.
+* @since 1.0.0
+*/
+const extrema = extrema$1;
+const monotonicity = monotonicity$1;
+/**
+* Type-narrowing predicate: refines a `CubicPolynomial<T>` to
+* `CubicPolynomial<T & Monotonic>` when the polynomial is strictly monotonic
+* over the given interval (or globally, when no interval is given).
+*
+* @param p - The cubic polynomial to check.
+* @param i - Optional interval over which to check monotonicity.
+* @returns `true` when monotonicity is `'increasing'` or `'decreasing'`.
+* @since 2.0.0
+*/
+const isMonotonic = isMonotonic$1;
+/**
+* Type-narrowing predicate: refines to `CubicPolynomial<T & Increasing>`.
+*
+* @since 2.0.0
+*/
+const isIncreasing = isIncreasing$1;
+/**
+* Type-narrowing predicate: refines to `CubicPolynomial<T & Decreasing>`.
+*
+* @since 2.0.0
+*/
+const isDecreasing = isDecreasing$1;
+/**
+* Asserts that the cubic polynomial is monotonic, throwing on failure.
+*
+* @param p - The cubic polynomial to assert against.
+* @param i - Optional interval over which to check monotonicity.
+* @returns The same polynomial, typed with the `Monotonic` brand.
+* @throws When the polynomial is not monotonic over the given (or global) interval.
+* @since 2.0.0
+*/
+const asMonotonic = asMonotonic$1;
+/**
+* Asserts that the cubic polynomial is increasing, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asIncreasing = asIncreasing$1;
+/**
+* Asserts that the cubic polynomial is decreasing, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asDecreasing = asDecreasing$1;
+const domain = domain$1;
+const range = range$1;
+const length = length$1;
+const curvature = curvature$1;
+//#endregion
+export { extreme as $, GL32_X1 as A, make$3 as At, GL32_X5 as B, GL32_W4 as C, fromPoints$3 as Ct, GL32_W8 as D, isLinearPolynomial as Dt, GL32_W7 as E, isIncreasing$3 as Et, GL32_X14 as F, toInverseSolver$3 as Ft, antiderivative as G, GL32_X7 as H, GL32_X15 as I, toSolver$3 as It, asMonotonic$2 as J, asDecreasing$2 as K, GL32_X2 as L, GL32_X11 as M, range$3 as Mt, GL32_X12 as N, solve$3 as Nt, GL32_W9 as O, isMonotonic$3 as Ot, GL32_X13 as P, solveInverse$3 as Pt, equals$2 as Q, GL32_X3 as R, GL32_W3 as S, fromPointSlope as St, GL32_W6 as T, isDecreasing$3 as Tt, GL32_X8 as U, GL32_X6 as V, GL32_X9 as W, derivative$2 as X, curvature$2 as Y, domain$2 as Z, GL32_W12 as _, asIncreasing$3 as _t, isIncreasing as a, isQuadraticPolynomial as at, GL32_W15 as b, domain$3 as bt, range as c, monotonicity$2 as ct, solveInverse as d, solve$2 as dt, fromPoints$2 as et, subdivide as f, solveInverse$2 as ft, GL32_W11 as g, asDecreasing$3 as gt, GL32_W10 as h, antiderivative$1 as ht, isDecreasing as i, isMonotonic$2 as it, GL32_X10 as j, monotonicity$3 as jt, GL32_X0 as k, length$3 as kt, roots as l, range$2 as lt, GL32_W1 as m, toSolver$2 as mt, derivative as n, isDecreasing$2 as nt, isMonotonic as o, length$2 as ot, GL32_W0 as p, toInverseSolver$2 as pt, asIncreasing$2 as q, fromVector as r, isIncreasing$2 as rt, make as s, make$2 as st, cubic_exports as t, fromVector$2 as tt, solve as u, roots$2 as ut, GL32_W13 as v, asMonotonic$3 as vt, GL32_W5 as w, fromVector$3 as wt, GL32_W2 as x, equals$3 as xt, GL32_W14 as y, derivative$3 as yt, GL32_X4 as z };
+
+//# sourceMappingURL=cubic-CpHAx8cC.mjs.map

package/dist/shared/cubic-CpHAx8cC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cubic-CpHAx8cC.mjs","names":["equals","make","fromVector","fromPoints","solve","toSolver","solveInverse","Solution.none","Solution.one","toInverseSolver","monotonicity","isMonotonic","isIncreasing","isDecreasing","asMonotonic","asIncreasing","asDecreasing","derivative","antiderivative","domain","Interval.make","Solution.isNone","range","Interval.fromMinMax","length","Interval.size","fromPoints","make","equals","fromVector","solve","toSolver","solveInverse","Linear.solveInverse","Linear.make","Solution.none","Solution.one","Solution.two","toInverseSolver","derivative","roots","Solution.match","Vector2.make","monotonicity","Interval.size","Linear.monotonicity","Interval.contains","Interval.toOpen","isMonotonic","isIncreasing","isDecreasing","asMonotonic","asIncreasing","asDecreasing","domain","Interval.fromMinMax","range","Linear.range","length","Linear.length","Linear.solve","curvature","make","isCubicPolynomial","equals","fromVector","fromPoints","solve","toSolver","solveInverse","Quadratic.solveInverse","Quadratic.make","Solution.fromArray","toInverseSolver","derivative","subdivide","roots","extrema","Quadratic.roots","monotonicity","Interval.size","Linear.monotonicity","Linear.make","Quadratic.monotonicity","Interval.filter","Interval.toOpen","isMonotonic","isIncreasing","isDecreasing","asMonotonic","asIncreasing","asDecreasing","domain","Interval.fromMinMax","range","length","Linear.length","Quadratic.length","Interval.scaleShift","Interval.biunit","Quadratic.solve","curvature","Quadratic.derivative","Linear.solve","internal.isCubicPolynomial","internal.equals","internal.make","internal.fromVector","internal.fromPoints","internal.solve","internal.toSolver","internal.solveInverse","internal.toInverseSolver","internal.derivative","internal.subdivide","internal.roots","internal.extrema","internal.monotonicity","internal.isMonotonic","internal.isIncreasing","internal.isDecreasing","internal.asMonotonic","internal.asIncreasing","internal.asDecreasing","internal.domain","internal.range","internal.length","internal.curvature"],"sources":["../../src/polynomial/quadratic.internal.circular.ts","../../src/polynomial/linear.internal.ts","../../src/polynomial/cubic.internal.circular.ts","../../src/polynomial/monotonicity.ts","../../src/polynomial/quadratic.internal.ts","../../src/length.ts","../../src/polynomial/cubic.internal.ts","../../src/polynomial/cubic.ts"],"sourcesContent":["import { Pipeable } from '../utils'\nimport type { QuadraticPolynomial } from './quadratic'\nimport { PolynomialTraits } from './traits'\n\nexport const QuadraticPolynomialTypeId: unique symbol = Symbol.for('curvy/polynomial/quadratic')\nexport type QuadraticPolynomialTypeId = typeof QuadraticPolynomialTypeId\n\nexport class QuadraticPolynomialImpl extends Pipeable implements QuadraticPolynomial<unknown> {\n  readonly [QuadraticPolynomialTypeId]: QuadraticPolynomialTypeId = QuadraticPolynomialTypeId\n  declare readonly [PolynomialTraits]: unknown\n\n  readonly c0: number\n  readonly c1: number\n  readonly c2: number\n\n  constructor(c0 = 0, c1 = 0, c2 = 0) {\n    super()\n\n    this.c0 = c0\n    this.c1 = c1\n    this.c2 = c2\n  }\n}\n","import * as Interval from '../interval/interval'\nimport { dual, Pipeable } from '../utils'\nimport * as Solution from '../solution/solution'\nimport { invariant } from '../utils'\nimport { epsEquals } from '../number'\nimport type { Vector2 } from '../vector/vector2'\nimport type { LinearPolynomial } from './linear'\nimport type { Decreasing, Increasing, Monotonic } from './traits'\nimport { PolynomialTraits } from './traits'\nimport type { QuadraticPolynomial } from './quadratic'\nimport { QuadraticPolynomialImpl } from './quadratic.internal.circular'\n\nexport const LinearPolynomialTypeId: unique symbol = Symbol.for('curvy/linear')\nexport type LinearPolynomialTypeId = typeof LinearPolynomialTypeId\n\nclass LinearPolynomialImpl extends Pipeable implements LinearPolynomial<unknown> {\n  readonly [LinearPolynomialTypeId]: LinearPolynomialTypeId = LinearPolynomialTypeId\n  declare readonly [PolynomialTraits]: unknown\n\n  readonly c0: number\n  readonly c1: number\n\n  constructor(c0 = 0, c1 = 0) {\n    super()\n\n    this.c0 = c0\n    this.c1 = c1\n  }\n}\n\nexport const isLinearPolynomial = (v: unknown): v is LinearPolynomial =>\n  typeof v === 'object' && v !== null && LinearPolynomialTypeId in v\n\nexport const equals = dual<\n  (b: LinearPolynomial) => (a: LinearPolynomial) => boolean,\n  (a: LinearPolynomial, b: LinearPolynomial) => boolean\n>(2, (a: LinearPolynomial, b: LinearPolynomial) => epsEquals(a.c0, b.c0) && epsEquals(a.c1, b.c1))\n\nexport const make = (c0 = 0, c1 = 0): LinearPolynomial => new LinearPolynomialImpl(c0, c1)\n\nexport const fromVector = (v: Vector2) => new LinearPolynomialImpl(v.x, v.y)\n\nexport const fromPointSlope = (p: Vector2, slope: number) =>\n  new LinearPolynomialImpl(p.y - slope * p.x, slope)\n\nexport const fromPoints = (p1: Vector2, p2: Vector2) =>\n  fromPointSlope(p1, (p2.y - p1.y) / (p2.x - p1.x))\n\nexport const solve = dual<\n  (x: number) => (p: LinearPolynomial) => number,\n  (p: LinearPolynomial, x: number) => number\n>(2, (p: LinearPolynomial, x: number) => p.c0 + x * p.c1)\n\nexport const toSolver = (p: LinearPolynomial) => (x: number) => solve(p, x)\n\nexport const solveInverse = dual<\n  (y: number) => (p: LinearPolynomial) => Solution.AtMostOne<number>,\n  (p: LinearPolynomial, y: number) => Solution.AtMostOne<number>\n>(2, (p: LinearPolynomial, y: number) => {\n  if (p.c1 === 0) {\n    return Solution.none\n  }\n  return Solution.one((y - p.c0) / p.c1)\n})\n\nexport const toInverseSolver = (p: LinearPolynomial) => (y: number) => solveInverse(p, y)\n\nexport const monotonicity = (p: LinearPolynomial) =>\n  p.c1 === 0 ? 'constant' : p.c1 > 0 ? 'increasing' : 'decreasing'\n\nexport const isMonotonic = <T>(p: LinearPolynomial<T>): p is LinearPolynomial<T & Monotonic> =>\n  p.c1 !== 0\n\nexport const isIncreasing = <T>(p: LinearPolynomial<T>): p is LinearPolynomial<T & Increasing> =>\n  p.c1 > 0\n\nexport const isDecreasing = <T>(p: LinearPolynomial<T>): p is LinearPolynomial<T & Decreasing> =>\n  p.c1 < 0\n\nexport const asMonotonic = <T>(p: LinearPolynomial<T>): LinearPolynomial<T & Monotonic> => {\n  invariant(isMonotonic(p), 'linear polynomial is not monotonic')\n  return p\n}\n\nexport const asIncreasing = <T>(p: LinearPolynomial<T>): LinearPolynomial<T & Increasing> => {\n  invariant(isIncreasing(p), 'linear polynomial is not increasing')\n  return p\n}\n\nexport const asDecreasing = <T>(p: LinearPolynomial<T>): LinearPolynomial<T & Decreasing> => {\n  invariant(isDecreasing(p), 'linear polynomial is not decreasing')\n  return p\n}\n\nexport const derivative = (p: LinearPolynomial) => p.c1\n\nexport const antiderivative = dual<\n  (integrationConstant: number) => (p: LinearPolynomial) => QuadraticPolynomial,\n  (p: LinearPolynomial, integrationConstant?: number) => QuadraticPolynomial\n>(\n  (args) => isLinearPolynomial(args[0]),\n  (p: LinearPolynomial, integrationConstant = 0) =>\n    new QuadraticPolynomialImpl(integrationConstant, p.c0, p.c1 / 2),\n)\n\nexport const domain = dual<\n  (range: Interval.Interval) => (p: LinearPolynomial) => Solution.AtMostOne<Interval.Interval>,\n  (p: LinearPolynomial, range: Interval.Interval) => Solution.AtMostOne<Interval.Interval>\n>(2, (p: LinearPolynomial, r: Interval.Interval) => {\n  if (p.c1 === 0) {\n    if (r.start === p.c0 && r.end === p.c0) {\n      return Solution.one(Interval.make(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY))\n    }\n    return Solution.none\n  }\n\n  const start = solveInverse(p, r.start)\n  const end = solveInverse(p, r.end)\n\n  if (Solution.isNone(start) || Solution.isNone(end)) {\n    return Solution.none\n  }\n\n  return Solution.one(Interval.make(start.value, end.value))\n})\n\nexport const range = dual<\n  (domain: Interval.Interval) => (p: LinearPolynomial) => Interval.Closed,\n  (p: LinearPolynomial, domain: Interval.Interval) => Interval.Closed\n>(2, (p: LinearPolynomial, d: Interval.Interval) =>\n  Interval.fromMinMax(solve(p, d.start), solve(p, d.end)),\n)\n\nexport const length = dual<\n  (domain: Interval.Interval) => (p: LinearPolynomial) => number,\n  (p: LinearPolynomial, domain: Interval.Interval) => number\n>(2, (p: LinearPolynomial, d: Interval.Interval) => {\n  if (Interval.size(d) === 0) {\n    return 0\n  }\n\n  if (p.c1 === 0) {\n    return Interval.size(d)\n  }\n\n  return Math.sqrt(1 + p.c1 ** 2) * Interval.size(d)\n})\n","import { Pipeable } from '../utils'\nimport type { CubicPolynomial } from './cubic'\nimport { PolynomialTraits } from './traits'\n\nexport const CubicPolynomialTypeId: unique symbol = Symbol.for('curvy/polynomial/cubic')\nexport type CubicPolynomialTypeId = typeof CubicPolynomialTypeId\n\nexport class CubicPolynomialImpl extends Pipeable implements CubicPolynomial<unknown> {\n  readonly [CubicPolynomialTypeId]: CubicPolynomialTypeId = CubicPolynomialTypeId\n  declare readonly [PolynomialTraits]: unknown\n\n  readonly c0: number\n  readonly c1: number\n  readonly c2: number\n  readonly c3: number\n\n  constructor(c0 = 0, c1 = 0, c2 = 0, c3 = 0) {\n    super()\n\n    this.c0 = c0\n    this.c1 = c1\n    this.c2 = c2\n    this.c3 = c3\n  }\n}\n","export type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant'\nexport type GuaranteedMonotonicity = 'increasing' | 'decreasing' | 'constant'\n\nexport function guaranteedMonotonicityFromComparison(\n  s0: number,\n  s1: number,\n): GuaranteedMonotonicity {\n  if (s0 < s1) {\n    return 'increasing'\n  }\n\n  if (s0 > s1) {\n    return 'decreasing'\n  }\n\n  return 'constant'\n}\n","import * as Interval from '../interval/interval'\nimport { dual } from '../utils'\nimport * as Solution from '../solution/solution'\nimport { invariant } from '../utils'\nimport { epsEquals } from '../number'\nimport * as Vector2 from '../vector/vector2'\nimport type { Vector3 } from '../vector/vector3'\nimport type { CubicPolynomial } from './cubic'\nimport { CubicPolynomialImpl } from './cubic.internal.circular'\nimport * as Linear from './linear.internal'\nimport { guaranteedMonotonicityFromComparison, type Monotonicity } from './monotonicity'\nimport type { QuadraticPolynomial } from './quadratic'\nimport { QuadraticPolynomialImpl, QuadraticPolynomialTypeId } from './quadratic.internal.circular'\nimport type { Decreasing, Increasing, Monotonic } from './traits'\n\nexport const fromPoints = (\n  p0: Vector2.Vector2,\n  p1: Vector2.Vector2,\n  p2: Vector2.Vector2,\n): QuadraticPolynomial => {\n  // Newton's divided differences, then collected to monomial form.\n  const f01 = (p1.y - p0.y) / (p1.x - p0.x)\n  const f12 = (p2.y - p1.y) / (p2.x - p1.x)\n  const f012 = (f12 - f01) / (p2.x - p0.x)\n\n  return new QuadraticPolynomialImpl(\n    p0.y - f01 * p0.x + f012 * p0.x * p1.x,\n    f01 - f012 * (p0.x + p1.x),\n    f012,\n  )\n}\n\nexport const make = (c0 = 0, c1 = 0, c2 = 0): QuadraticPolynomial =>\n  new QuadraticPolynomialImpl(c0, c1, c2)\n\nexport const isQuadraticPolynomial = (v: unknown): v is QuadraticPolynomial =>\n  typeof v === 'object' && v !== null && QuadraticPolynomialTypeId in v\n\nexport const equals = dual<\n  (b: QuadraticPolynomial) => (a: QuadraticPolynomial) => boolean,\n  (a: QuadraticPolynomial, b: QuadraticPolynomial) => boolean\n>(\n  2,\n  (a: QuadraticPolynomial, b: QuadraticPolynomial) =>\n    epsEquals(a.c0, b.c0) && epsEquals(a.c1, b.c1) && epsEquals(a.c2, b.c2),\n)\n\nexport const fromVector = (v: Vector3) => new QuadraticPolynomialImpl(v.x, v.y, v.z)\n\nexport const solve = dual<\n  (x: number) => (p: QuadraticPolynomial) => number,\n  (p: QuadraticPolynomial, x: number) => number\n>(2, (p: QuadraticPolynomial, x: number) => p.c0 + x * p.c1 + x ** 2 * p.c2)\n\nexport const toSolver = (p: QuadraticPolynomial) => (x: number) => solve(p, x)\n\nexport const solveInverse: {\n  (p: QuadraticPolynomial, y: number): Solution.AtMostTwo<number>\n  (y: number): (p: QuadraticPolynomial) => Solution.AtMostTwo<number>\n} = dual<\n  (y: number) => (p: QuadraticPolynomial) => Solution.AtMostTwo<number>,\n  (p: QuadraticPolynomial, y: number) => Solution.AtMostTwo<number>\n>(2, (p: QuadraticPolynomial, y: number) => {\n  // c2 = 0: the polynomial is actually linear in disguise. Defer rather than\n  // dividing by zero in the quadratic formula.\n  if (p.c2 === 0) {\n    return Linear.solveInverse(Linear.make(p.c0, p.c1), y)\n  }\n\n  const discriminant = p.c1 ** 2 - 4 * p.c2 * (p.c0 - y)\n\n  if (discriminant < 0) {\n    return Solution.none\n  }\n\n  if (discriminant === 0) {\n    return Solution.one(-p.c1 / (2 * p.c2))\n  }\n\n  const sqrtDiscriminant = Math.sqrt(discriminant)\n  const a = (-p.c1 + sqrtDiscriminant) / (2 * p.c2)\n  const b = (-p.c1 - sqrtDiscriminant) / (2 * p.c2)\n  return a < b ? Solution.two(a, b) : Solution.two(b, a)\n})\n\nexport const toInverseSolver =\n  (p: QuadraticPolynomial) =>\n  (y: number): Solution.AtMostTwo<number> =>\n    solveInverse(p, y)\n\nexport const derivative = (p: QuadraticPolynomial) => Linear.make(p.c1, p.c2 * 2)\n\nexport const roots = (p: QuadraticPolynomial) => solveInverse(p, 0)\n\nexport const extreme = (p: QuadraticPolynomial) =>\n  derivative(p).pipe(\n    Linear.solveInverse(0),\n    Solution.match({\n      onNone: () => null,\n      onSome: ({ value: t }) => Vector2.make(t, solve(p, t)),\n    }),\n  )\n\nexport const monotonicity = dual<\n  (i: Interval.Interval) => (p: QuadraticPolynomial) => Monotonicity,\n  (p: QuadraticPolynomial, i?: Interval.Interval) => Monotonicity\n>(\n  (args) => isQuadraticPolynomial(args[0]),\n  (p: QuadraticPolynomial, i?: Interval.Interval) => {\n    invariant(\n      i === undefined || Interval.size(i) > 0,\n      'monotonicity is undefined over a zero-width interval',\n    )\n\n    if (p.c2 === 0 && p.c1 === 0) {\n      return 'constant'\n    }\n\n    if (p.c2 === 0) {\n      return Linear.monotonicity(Linear.make(p.c0, p.c1))\n    }\n\n    // c2 is non-zero, so the extreme is guaranteed to be non-null\n    const e = extreme(p) as Vector2.Vector2\n\n    // if there is no interval, or the extreme is within the interval,\n    // the monotonicity is none\n    if (i === undefined || Interval.contains(Interval.toOpen(i), e.x)) {\n      return 'none'\n    }\n\n    return guaranteedMonotonicityFromComparison(solve(p, i.start), solve(p, i.end))\n  },\n)\n\nexport const isMonotonic = dual<\n  (\n    i: Interval.Interval,\n  ) => <T>(p: QuadraticPolynomial<T>) => p is QuadraticPolynomial<T & Monotonic>,\n  <T>(p: QuadraticPolynomial<T>, i?: Interval.Interval) => p is QuadraticPolynomial<T & Monotonic>\n>((args) => isQuadraticPolynomial(args[0]), ((p: QuadraticPolynomial, i?: Interval.Interval) => {\n  const m = monotonicity(p, i as Interval.Interval)\n  return m === 'increasing' || m === 'decreasing'\n}) as never)\n\nexport const isIncreasing = dual<\n  (\n    i: Interval.Interval,\n  ) => <T>(p: QuadraticPolynomial<T>) => p is QuadraticPolynomial<T & Increasing>,\n  <T>(p: QuadraticPolynomial<T>, i?: Interval.Interval) => p is QuadraticPolynomial<T & Increasing>\n>(\n  (args) => isQuadraticPolynomial(args[0]),\n  ((p: QuadraticPolynomial, i?: Interval.Interval) =>\n    monotonicity(p, i as Interval.Interval) === 'increasing') as never,\n)\n\nexport const isDecreasing = dual<\n  (\n    i: Interval.Interval,\n  ) => <T>(p: QuadraticPolynomial<T>) => p is QuadraticPolynomial<T & Decreasing>,\n  <T>(p: QuadraticPolynomial<T>, i?: Interval.Interval) => p is QuadraticPolynomial<T & Decreasing>\n>(\n  (args) => isQuadraticPolynomial(args[0]),\n  ((p: QuadraticPolynomial, i?: Interval.Interval) =>\n    monotonicity(p, i as Interval.Interval) === 'decreasing') as never,\n)\n\nexport const asMonotonic = <T>(\n  p: QuadraticPolynomial<T>,\n  i?: Interval.Interval,\n): QuadraticPolynomial<T & Monotonic> => {\n  invariant(isMonotonic(p, i as Interval.Interval), 'quadratic polynomial is not monotonic')\n  return p\n}\n\nexport const asIncreasing = <T>(\n  p: QuadraticPolynomial<T>,\n  i?: Interval.Interval,\n): QuadraticPolynomial<T & Increasing> => {\n  invariant(isIncreasing(p, i as Interval.Interval), 'quadratic polynomial is not increasing')\n  return p\n}\n\nexport const asDecreasing = <T>(\n  p: QuadraticPolynomial<T>,\n  i?: Interval.Interval,\n): QuadraticPolynomial<T & Decreasing> => {\n  invariant(isDecreasing(p, i as Interval.Interval), 'quadratic polynomial is not decreasing')\n  return p\n}\n\nexport const antiderivative = dual<\n  (integrationConstant: number) => (p: QuadraticPolynomial) => CubicPolynomial,\n  (p: QuadraticPolynomial, integrationConstant?: number) => CubicPolynomial\n>(\n  2,\n  (p: QuadraticPolynomial, integrationConstant = 0) =>\n    new CubicPolynomialImpl(integrationConstant, p.c0, p.c1 / 2, p.c2 / 3),\n)\n\nexport const domain = dual<\n  (range: Interval.Interval) => (p: QuadraticPolynomial) => Solution.AtMostOne<Interval.Interval>,\n  (p: QuadraticPolynomial, range: Interval.Interval) => Solution.AtMostOne<Interval.Interval>\n>(2, (p: QuadraticPolynomial, r: Interval.Interval) => {\n  const start = solveInverse(p, r.start)\n  const end = solveInverse(p, r.end)\n\n  if (start.length === 0 && end.length === 0) {\n    return Solution.none\n  }\n\n  return Solution.one(Interval.fromMinMax(...start, ...end))\n})\n\nexport const range = dual<\n  (domain: Interval.Interval) => (p: QuadraticPolynomial) => Interval.Closed,\n  (p: QuadraticPolynomial, domain: Interval.Interval) => Interval.Closed\n>(2, (p: QuadraticPolynomial, d: Interval.Interval) => {\n  if (p.c2 === 0) {\n    return Linear.range(Linear.make(p.c0, p.c1), d)\n  }\n\n  const e = extreme(p)\n\n  return e !== null && Interval.contains(d, e.x)\n    ? Interval.fromMinMax(solve(p, d.start), solve(p, d.end), e.y)\n    : Interval.fromMinMax(solve(p, d.start), solve(p, d.end))\n})\n\nexport const length = dual<\n  (domain: Interval.Interval) => (p: QuadraticPolynomial) => number,\n  (p: QuadraticPolynomial, domain: Interval.Interval) => number\n>(2, (p: QuadraticPolynomial, dom: Interval.Interval) => {\n  if (Interval.size(dom) === 0) {\n    return 0\n  }\n\n  if (p.c2 === 0) {\n    return Linear.length(Linear.make(p.c0, p.c1), dom)\n  }\n\n  const dp = derivative(p)\n\n  const derivativeStart = Linear.solve(dp, dom.start)\n  const sqrtStart = Math.sqrt(1 + derivativeStart ** 2)\n  const evalStart =\n    (derivativeStart * sqrtStart + Math.log(Math.abs(derivativeStart + sqrtStart))) / (4 * p.c2)\n\n  const derivativeEnd = Linear.solve(dp, dom.end)\n  const sqrtEnd = Math.sqrt(1 + derivativeEnd ** 2)\n  const evalEnd =\n    (derivativeEnd * sqrtEnd + Math.log(Math.abs(derivativeEnd + sqrtEnd))) / (4 * p.c2)\n\n  return evalEnd - evalStart\n})\n\nexport const curvature = dual<\n  (x: number) => (p: QuadraticPolynomial) => number,\n  (p: QuadraticPolynomial, x: number) => number\n>(\n  2,\n  (p: QuadraticPolynomial, x: number) =>\n    Math.abs(2 * p.c2) / (1 + (Linear.solve(derivative(p), x) ** 2) ** 1.5),\n)\n","export const GL32_X0 = 0.9972638618494816\nexport const GL32_X1 = 0.9856115115452684\nexport const GL32_X2 = 0.9647622555875064\nexport const GL32_X3 = 0.9349060759377397\nexport const GL32_X4 = 0.8963211557660521\nexport const GL32_X5 = 0.84936761373257\nexport const GL32_X6 = 0.7944837959679424\nexport const GL32_X7 = 0.7321821187402897\nexport const GL32_X8 = 0.6630442669302152\nexport const GL32_X9 = 0.5877157572407623\nexport const GL32_X10 = 0.5068999089322294\nexport const GL32_X11 = 0.42135127613063533\nexport const GL32_X12 = 0.33186860228212767\nexport const GL32_X13 = 0.23928736225213706\nexport const GL32_X14 = 0.1444719615827965\nexport const GL32_X15 = 0.04830766568773831\nexport const GL32_W0 = 0.007018610009470136\nexport const GL32_W1 = 0.01627439473090571\nexport const GL32_W2 = 0.02539206530926214\nexport const GL32_W3 = 0.03427386291302141\nexport const GL32_W4 = 0.042835898022226704\nexport const GL32_W5 = 0.050998059262376154\nexport const GL32_W6 = 0.05868409347853558\nexport const GL32_W7 = 0.06582222277636195\nexport const GL32_W8 = 0.07234579410884862\nexport const GL32_W9 = 0.07819389578707044\nexport const GL32_W10 = 0.08331192422694672\nexport const GL32_W11 = 0.08765209300440374\nexport const GL32_W12 = 0.0911738786957639\nexport const GL32_W13 = 0.09384439908080454\nexport const GL32_W14 = 0.09563872007927485\nexport const GL32_W15 = 0.09654008851472785\n","import * as Interval from '../interval/interval'\nimport {\n  GL32_W0,\n  GL32_W1,\n  GL32_W2,\n  GL32_W3,\n  GL32_W4,\n  GL32_W5,\n  GL32_W6,\n  GL32_W7,\n  GL32_W8,\n  GL32_W9,\n  GL32_W10,\n  GL32_W11,\n  GL32_W12,\n  GL32_W13,\n  GL32_W14,\n  GL32_W15,\n  GL32_X0,\n  GL32_X1,\n  GL32_X2,\n  GL32_X3,\n  GL32_X4,\n  GL32_X5,\n  GL32_X6,\n  GL32_X7,\n  GL32_X8,\n  GL32_X9,\n  GL32_X10,\n  GL32_X11,\n  GL32_X12,\n  GL32_X13,\n  GL32_X14,\n  GL32_X15,\n} from '../length'\nimport { dual } from '../utils'\nimport * as Solution from '../solution/solution'\nimport { invariant } from '../utils'\nimport { clampToZero, epsEquals } from '../number'\nimport type * as Vector2 from '../vector/vector2'\nimport type { Vector4 } from '../vector/vector4'\nimport type { CubicPolynomial } from './cubic'\nimport { CubicPolynomialImpl, CubicPolynomialTypeId } from './cubic.internal.circular'\nimport type { Decreasing, Increasing, Monotonic } from './traits'\nimport * as Linear from './linear.internal'\nimport { guaranteedMonotonicityFromComparison, type Monotonicity } from './monotonicity'\nimport * as Quadratic from './quadratic.internal'\n\nexport const make = (c0 = 0, c1 = 0, c2 = 0, c3 = 0): CubicPolynomial =>\n  new CubicPolynomialImpl(c0, c1, c2, c3)\n\nexport const isCubicPolynomial = (v: unknown): v is CubicPolynomial =>\n  typeof v === 'object' && v !== null && CubicPolynomialTypeId in v\n\nexport const equals = dual<\n  (b: CubicPolynomial) => (a: CubicPolynomial) => boolean,\n  (a: CubicPolynomial, b: CubicPolynomial) => boolean\n>(\n  2,\n  (a: CubicPolynomial, b: CubicPolynomial) =>\n    epsEquals(a.c0, b.c0) &&\n    epsEquals(a.c1, b.c1) &&\n    epsEquals(a.c2, b.c2) &&\n    epsEquals(a.c3, b.c3),\n)\n\nexport const fromVector = (v: Vector4) => new CubicPolynomialImpl(v.x, v.y, v.z, v.w)\n\nexport const fromPoints = (\n  p0: Vector2.Vector2,\n  p1: Vector2.Vector2,\n  p2: Vector2.Vector2,\n  p3: Vector2.Vector2,\n): CubicPolynomial => {\n  // Newton's divided differences, then collected to monomial form.\n  const f01 = (p1.y - p0.y) / (p1.x - p0.x)\n  const f12 = (p2.y - p1.y) / (p2.x - p1.x)\n  const f23 = (p3.y - p2.y) / (p3.x - p2.x)\n  const f012 = (f12 - f01) / (p2.x - p0.x)\n  const f123 = (f23 - f12) / (p3.x - p1.x)\n  const f0123 = (f123 - f012) / (p3.x - p0.x)\n\n  return new CubicPolynomialImpl(\n    p0.y - f01 * p0.x + f012 * p0.x * p1.x - f0123 * p0.x * p1.x * p2.x,\n    f01 - f012 * (p0.x + p1.x) + f0123 * (p0.x * p1.x + p0.x * p2.x + p1.x * p2.x),\n    f012 - f0123 * (p0.x + p1.x + p2.x),\n    f0123,\n  )\n}\n\nexport const solve = dual<\n  (x: number) => (p: CubicPolynomial) => number,\n  (p: CubicPolynomial, x: number) => number\n>(2, (p: CubicPolynomial, x: number) => p.c0 + x * p.c1 + x ** 2 * p.c2 + x ** 3 * p.c3)\n\nexport const toSolver = (p: CubicPolynomial) => (x: number) => solve(p, x)\n\nexport const solveInverse = dual<\n  (y: number) => (p: CubicPolynomial) => Solution.AtMostThree<number>,\n  (p: CubicPolynomial, y: number) => Solution.AtMostThree<number>\n>(2, (self: CubicPolynomial, y: number) => {\n  // c3 = 0: the polynomial is actually quadratic-or-less in disguise. Defer to\n  // the quadratic solver (which itself handles c2 = 0 by deferring to linear).\n  if (self.c3 === 0) {\n    return Quadratic.solveInverse(Quadratic.make(self.c0, self.c1, self.c2), y)\n  }\n\n  const shift = self.c2 / (3 * self.c3)\n\n  const d0 = self.c2 ** 2 - 3 * self.c3 * self.c1\n  const d1 = 2 * self.c2 ** 3 - 9 * self.c3 * self.c2 * self.c1 + 27 * self.c3 ** 2 * (self.c0 - y)\n\n  const p = -d0 / (3 * self.c3 ** 2)\n  const q = d1 / (27 * self.c3 ** 3)\n\n  const discriminant = clampToZero(-(4 * p ** 3 + 27 * q ** 2), 1e-12)\n\n  const roots = new Set<number>()\n\n  if (discriminant > 0) {\n    const r = 2 * Math.sqrt(-p / 3)\n    const theta = Math.acos(((3 * q) / (2 * p)) * Math.sqrt(-3 / p)) / 3\n    const offset = (2 * Math.PI) / 3\n\n    roots.add(r * Math.cos(theta + offset) - shift)\n    roots.add(r * Math.cos(theta) - shift)\n    roots.add(r * Math.cos(theta - offset) - shift)\n  } else if (discriminant < 0) {\n    const u = Math.sqrt(q ** 2 / 4 + p ** 3 / 27)\n\n    const u1 = Math.cbrt(-q / 2 + u)\n    const u2 = Math.cbrt(-q / 2 - u)\n\n    roots.add(u1 + u2 - shift)\n  } else if (d0 === 0) {\n    roots.add(-shift)\n  } else {\n    roots.add((9 * self.c3 * (self.c0 - y) - self.c2 * self.c1) / (2 * d0))\n    roots.add(\n      (4 * self.c3 * self.c2 * self.c1 - 9 * self.c3 ** 2 * (self.c0 - y) - self.c2 ** 3) /\n        (self.c3 * d0),\n    )\n  }\n\n  return Solution.fromArray(Array.from(roots).toSorted((a, b) => a - b))\n})\n\nexport const toInverseSolver = (p: CubicPolynomial) => (y: number) => solveInverse(p, y)\n\nexport const derivative = (p: CubicPolynomial) => Quadratic.make(p.c1, p.c2 * 2, p.c3 * 3)\n\n// Subdivides a cubic polynomial at parameter `t ∈ (0, 1)` into two new cubic\n// polynomials. The first polynomial's evaluation on `[0, 1]` matches the\n// original's evaluation on `[0, t]`; the second matches the original's\n// evaluation on `[t, 1]`. Concretely: `left(u) = p(t·u)` and\n// `right(u) = p(t + (1-t)·u)`. The left half is a uniform scale of the input\n// parameter by powers of `t`; the right half is a binomial expansion in\n// `(s + r·u)` with `s = t` and `r = 1 - t`.\nexport const subdivide = dual<\n  (t: number) => (p: CubicPolynomial) => [CubicPolynomial, CubicPolynomial],\n  (p: CubicPolynomial, t: number) => [CubicPolynomial, CubicPolynomial]\n>(2, (p: CubicPolynomial, t: number): [CubicPolynomial, CubicPolynomial] => {\n  invariant(t > 0 && t < 1, 'subdivide parameter t must be in the open interval (0, 1)')\n\n  const r = 1 - t\n  const left = make(p.c0, p.c1 * t, p.c2 * t * t, p.c3 * t * t * t)\n  const right = make(\n    p.c0 + p.c1 * t + p.c2 * t * t + p.c3 * t * t * t,\n    p.c1 * r + 2 * p.c2 * t * r + 3 * p.c3 * t * t * r,\n    p.c2 * r * r + 3 * p.c3 * t * r * r,\n    p.c3 * r * r * r,\n  )\n  return [left, right]\n})\n\nexport const roots = (p: CubicPolynomial): Solution.AtMostThree<number> => solveInverse(p, 0)\n\nexport const extrema = (p: CubicPolynomial): Solution.AtMostTwo<number> =>\n  Quadratic.roots(derivative(p))\n\nexport const monotonicity = dual<\n  (i: Interval.Interval) => (p: CubicPolynomial) => Monotonicity,\n  (p: CubicPolynomial, i?: Interval.Interval) => Monotonicity\n>(\n  (args) => isCubicPolynomial(args[0]),\n  (p: CubicPolynomial, i?: Interval.Interval) => {\n    invariant(\n      i === undefined || Interval.size(i) > 0,\n      'monotonicity is undefined over a zero-width interval',\n    )\n\n    // shortcut to check for a horizontal line\n    if (p.c3 === 0 && p.c2 === 0 && p.c1 === 0) {\n      return 'constant'\n    }\n\n    // shortcut to check for a non-horizontal line\n    if (p.c3 === 0 && p.c2 === 0) {\n      return Linear.monotonicity(Linear.make(p.c0, p.c1))\n    }\n\n    // without an interval, the monotonicity will be none if c3 or c2 are nonzero\n    if (i === undefined) {\n      return 'none'\n    }\n\n    if (p.c3 === 0) {\n      return Quadratic.monotonicity(Quadratic.make(p.c0, p.c1, p.c2), i)\n    }\n\n    const e = Interval.filter(Interval.toOpen(i), [...extrema(p)])\n\n    if (e.length > 0) {\n      return 'none'\n    }\n\n    return guaranteedMonotonicityFromComparison(solve(p, i.start), solve(p, i.end))\n  },\n)\n\nexport const isMonotonic = dual<\n  (i: Interval.Interval) => <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Monotonic>,\n  <T>(p: CubicPolynomial<T>, i?: Interval.Interval) => p is CubicPolynomial<T & Monotonic>\n>((args) => isCubicPolynomial(args[0]), ((p: CubicPolynomial, i?: Interval.Interval) => {\n  const m = monotonicity(p, i as Interval.Interval)\n  return m === 'increasing' || m === 'decreasing'\n}) as never)\n\nexport const isIncreasing = dual<\n  (i: Interval.Interval) => <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Increasing>,\n  <T>(p: CubicPolynomial<T>, i?: Interval.Interval) => p is CubicPolynomial<T & Increasing>\n>(\n  (args) => isCubicPolynomial(args[0]),\n  ((p: CubicPolynomial, i?: Interval.Interval) =>\n    monotonicity(p, i as Interval.Interval) === 'increasing') as never,\n)\n\nexport const isDecreasing = dual<\n  (i: Interval.Interval) => <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Decreasing>,\n  <T>(p: CubicPolynomial<T>, i?: Interval.Interval) => p is CubicPolynomial<T & Decreasing>\n>(\n  (args) => isCubicPolynomial(args[0]),\n  ((p: CubicPolynomial, i?: Interval.Interval) =>\n    monotonicity(p, i as Interval.Interval) === 'decreasing') as never,\n)\n\nexport const asMonotonic = <T>(\n  p: CubicPolynomial<T>,\n  i?: Interval.Interval,\n): CubicPolynomial<T & Monotonic> => {\n  invariant(isMonotonic(p, i as Interval.Interval), 'cubic polynomial is not monotonic')\n  return p\n}\n\nexport const asIncreasing = <T>(\n  p: CubicPolynomial<T>,\n  i?: Interval.Interval,\n): CubicPolynomial<T & Increasing> => {\n  invariant(isIncreasing(p, i as Interval.Interval), 'cubic polynomial is not increasing')\n  return p\n}\n\nexport const asDecreasing = <T>(\n  p: CubicPolynomial<T>,\n  i?: Interval.Interval,\n): CubicPolynomial<T & Decreasing> => {\n  invariant(isDecreasing(p, i as Interval.Interval), 'cubic polynomial is not decreasing')\n  return p\n}\n\nexport const domain = dual<\n  (range: Interval.Interval) => (p: CubicPolynomial) => Interval.Interval,\n  (p: CubicPolynomial, range: Interval.Interval) => Interval.Interval\n>(2, (p: CubicPolynomial, r: Interval.Interval) =>\n  Interval.fromMinMax(...solveInverse(p, r.start), ...solveInverse(p, r.end)),\n)\n\nexport const range = dual<\n  (domain: Interval.Interval) => (p: CubicPolynomial) => Interval.Closed,\n  (p: CubicPolynomial, domain: Interval.Interval) => Interval.Closed\n>(2, (p: CubicPolynomial, d: Interval.Interval) =>\n  Interval.fromMinMax(\n    solve(p, d.start),\n    solve(p, d.end),\n    ...Interval.filter(d, [...extrema(p)]).map((e) => solve(p, e)),\n  ),\n)\n\nexport const length = dual<\n  (domain: Interval.Interval) => (p: CubicPolynomial) => number,\n  (p: CubicPolynomial, domain: Interval.Interval) => number\n>(2, (p: CubicPolynomial, dom: Interval.Interval) => {\n  if (Interval.size(dom) === 0) {\n    return 0\n  }\n\n  if (p.c3 === 0) {\n    if (p.c2 === 0) {\n      return Linear.length(Linear.make(p.c0, p.c1), dom)\n    }\n\n    return Quadratic.length(Quadratic.make(p.c0, p.c1, p.c2), dom)\n  }\n\n  const d = derivative(p)\n\n  const { scale, shift } = Interval.scaleShift(Interval.biunit, dom)\n\n  return (\n    (GL32_W0 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X0) ** 2) +\n      GL32_W0 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X0) ** 2) +\n      GL32_W1 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X1) ** 2) +\n      GL32_W1 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X1) ** 2) +\n      GL32_W2 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X2) ** 2) +\n      GL32_W2 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X2) ** 2) +\n      GL32_W3 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X3) ** 2) +\n      GL32_W3 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X3) ** 2) +\n      GL32_W4 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X4) ** 2) +\n      GL32_W4 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X4) ** 2) +\n      GL32_W5 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X5) ** 2) +\n      GL32_W5 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X5) ** 2) +\n      GL32_W6 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X6) ** 2) +\n      GL32_W6 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X6) ** 2) +\n      GL32_W7 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X7) ** 2) +\n      GL32_W7 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X7) ** 2) +\n      GL32_W8 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X8) ** 2) +\n      GL32_W8 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X8) ** 2) +\n      GL32_W9 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X9) ** 2) +\n      GL32_W9 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X9) ** 2) +\n      GL32_W10 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X10) ** 2) +\n      GL32_W10 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X10) ** 2) +\n      GL32_W11 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X11) ** 2) +\n      GL32_W11 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X11) ** 2) +\n      GL32_W12 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X12) ** 2) +\n      GL32_W12 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X12) ** 2) +\n      GL32_W13 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X13) ** 2) +\n      GL32_W13 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X13) ** 2) +\n      GL32_W14 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X14) ** 2) +\n      GL32_W14 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X14) ** 2) +\n      GL32_W15 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * -GL32_X15) ** 2) +\n      GL32_W15 * Math.sqrt(1 + Quadratic.solve(d, shift + scale * GL32_X15) ** 2)) *\n    scale\n  )\n})\n\nexport const curvature = dual(2, (p: CubicPolynomial, x: number) => {\n  const d = derivative(p)\n  const dd = Quadratic.derivative(d)\n\n  return Math.abs(Linear.solve(dd, x)) / (1 + Quadratic.solve(d, x) ** 2) ** 1.5\n})\n","import type { Closed, Interval } from '../interval/interval'\nimport type { Pipeable } from '../utils'\nimport type * as Solution from '../solution/solution'\nimport type { Vector2 } from '../vector/vector2'\nimport type { Vector4 } from '../vector/vector4'\nimport * as internal from './cubic.internal'\nimport type { CubicPolynomialTypeId } from './cubic.internal.circular'\nimport type { Monotonicity } from './monotonicity'\nimport type { QuadraticPolynomial } from './quadratic'\nimport type { Decreasing, Increasing, Monotonic, PolynomialTraits } from './traits'\n\nexport type { Monotonic, Increasing, Decreasing } from './traits'\n\n/**\n * A cubic polynomial.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * The `Traits` type parameter is a phantom marker that accumulates trait\n * brands as the polynomial is refined via `isMonotonic` / `asMonotonic` and\n * friends. A cubic is monotonic only over an interval that avoids both of its\n * extrema (or globally, when c2 = c3 = 0 and c1 ≠ 0).\n *\n * @since 1.0.0\n */\nexport interface CubicPolynomial<out Traits = unknown> extends Pipeable {\n  readonly [CubicPolynomialTypeId]: CubicPolynomialTypeId\n  readonly [PolynomialTraits]: Traits\n\n  /**\n   * The coefficient of the x^0 term.\n   */\n  readonly c0: number\n  /**\n   * The coefficient of the x^1 term.\n   */\n  readonly c1: number\n  /**\n   * The coefficient of the x^2 term.\n   */\n  readonly c2: number\n  /**\n   * The coefficient of the x^3 term.\n   */\n  readonly c3: number\n}\n\n/**\n * Checks if a value is a `CubicPolynomial`.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a `CubicPolynomial`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isCubicPolynomial: (value: unknown) => value is CubicPolynomial =\n  internal.isCubicPolynomial\n\nexport const equals: {\n  /**\n   * Checks if two `CubicPolynomial` instances are approximately equal within\n   * the default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first polynomial.\n   * @param b - The second polynomial.\n   * @returns `true` when each pair of coefficients is within tolerance.\n   * @since 1.1.0\n   */\n  (a: CubicPolynomial, b: CubicPolynomial): boolean\n  /**\n   * Checks if two `CubicPolynomial` instances are approximately equal within\n   * the default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second polynomial.\n   * @returns A function that takes the first polynomial and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: CubicPolynomial): (a: CubicPolynomial) => boolean\n} = internal.equals\n\n/**\n * Creates a new `CubicPolynomial` instance.\n *\n * @param c0 - The coefficient of the x^0 term.\n * @param c1 - The coefficient of the x^1 term.\n * @param c2 - The coefficient of the x^2 term.\n * @param c3 - The coefficient of the x^3 term.\n */\nexport const make: (c0: number, c1: number, c2: number, c3: number) => CubicPolynomial =\n  internal.make\n\n/**\n * Creates a new `CubicPolynomial` instance from a vector.\n *\n * @param v - The vector to convert.\n * @returns A new `CubicPolynomial` instance.\n * @since 1.0.0\n */\nexport const fromVector: (v: Vector4) => CubicPolynomial = internal.fromVector\n\n/**\n * Creates a new `CubicPolynomial` that interpolates the four given points,\n * treating each `Vector2` as an `(x, y)` pair. The four input `x` values must\n * be distinct.\n *\n * @param p0 - The first point.\n * @param p1 - The second point.\n * @param p2 - The third point.\n * @param p3 - The fourth point.\n * @returns The unique cubic polynomial passing through the four points.\n * @since 2.0.0\n */\nexport const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicPolynomial =\n  internal.fromPoints\n\nexport const solve: {\n  /**\n   * Solves a cubic polynomial for a given value of x.\n   *\n   * @param p - The cubic polynomial to solve.\n   * @param x - The value of x to solve for.\n   * @returns The result of the polynomial evaluation at x.\n   * @since 1.0.0\n   */\n  (p: CubicPolynomial, x: number): number\n  /**\n   * Solves a cubic polynomial for a given value of x.\n   *\n   * @param x - The value of x to solve for.\n   * @returns A function that takes a cubic polynomial and returns the result of the polynomial evaluation at x.\n   * @since 1.0.0\n   */\n  (x: number): (p: CubicPolynomial) => number\n} = internal.solve\n\n/**\n * Converts a cubic polynomial to a solver function.\n *\n * @param p - The cubic polynomial to convert.\n * @returns A function that takes a value of x and returns the result of the polynomial evaluation at x.\n * @since 1.0.0\n */\nexport const toSolver: (p: CubicPolynomial) => (x: number) => number = internal.toSolver\n\nexport const solveInverse: {\n  /**\n   * Solves a monotonic cubic polynomial for a given value of y. Because the\n   * polynomial is strictly monotonic, the inverse has at most one solution.\n   *\n   * @param p - The monotonic cubic polynomial.\n   * @param y - The value of y to solve for.\n   * @returns Zero or one solutions.\n   * @since 2.0.0\n   */\n  <T extends Monotonic>(p: CubicPolynomial<T>, y: number): Solution.AtMostOne<number>\n  /**\n   * Solves a cubic polynomial for a given value of y.\n   *\n   * @param p - The cubic polynomial to solve.\n   * @param y - The value of y to solve for.\n   * @returns The roots of the polynomial equation p(x) = y.\n   * @since 1.0.0\n   */\n  <T>(p: CubicPolynomial<T>, y: number): Solution.AtMostThree<number>\n  /**\n   * Solves a cubic polynomial for a given value of y.\n   *\n   * @param y - The value of y to solve for.\n   * @returns A function that takes a cubic polynomial and returns the roots\n   *   of the polynomial equation p(x) = y. Tightens to `Solution.AtMostOne<number>` for\n   *   monotonic inputs.\n   * @since 1.0.0\n   */\n  (y: number): {\n    <T extends Monotonic>(p: CubicPolynomial<T>): Solution.AtMostOne<number>\n    <T>(p: CubicPolynomial<T>): Solution.AtMostThree<number>\n  }\n} = internal.solveInverse as never\n\n/**\n * Converts a cubic polynomial to an inverse solver function.\n *\n * @param p - The cubic polynomial to convert.\n * @returns A function that takes a value of y and returns the roots of the polynomial equation p(x) = y.\n * @since 1.0.0\n */\nexport const toInverseSolver: (p: CubicPolynomial) => (y: number) => Solution.AtMostThree<number> =\n  internal.toInverseSolver\n\n/**\n * Calculates the derivative of a cubic polynomial.\n *\n * @param p - The cubic polynomial to differentiate.\n * @returns The derivative of the cubic polynomial.\n * @since 1.0.0\n */\nexport const derivative: (p: CubicPolynomial) => QuadraticPolynomial = internal.derivative\n\nexport const subdivide: {\n  /**\n   * Subdivides a cubic polynomial at parameter `t ∈ (0, 1)` into two new\n   * cubic polynomials. The first polynomial's evaluation on `[0, 1]` matches\n   * the original's on `[0, t]`; the second matches the original's on\n   * `[t, 1]`. Equivalent to de Casteljau subdivision in Bernstein form,\n   * performed directly in monomial form.\n   *\n   * @param p - The cubic polynomial to subdivide.\n   * @param t - The split parameter; must be in the open interval `(0, 1)`.\n   * @returns A `[left, right]` tuple of cubic polynomials.\n   * @since 2.1.0\n   */\n  (p: CubicPolynomial, t: number): [CubicPolynomial, CubicPolynomial]\n  /**\n   * Subdivides a cubic polynomial at parameter `t ∈ (0, 1)`.\n   *\n   * @param t - The split parameter; must be in the open interval `(0, 1)`.\n   * @returns A function that takes a polynomial and returns its `[left, right]` halves.\n   * @since 2.1.0\n   */\n  (t: number): (p: CubicPolynomial) => [CubicPolynomial, CubicPolynomial]\n} = internal.subdivide\n\n/**\n * Calculates the roots of a cubic polynomial.\n *\n * @param p - The cubic polynomial to find the roots of.\n * @returns The roots of the cubic polynomial.\n * @since 1.0.0\n */\nexport const roots: (p: CubicPolynomial) => Solution.AtMostThree<number> = internal.roots\n\n/**\n * Calculates the extrema of a cubic polynomial.\n *\n * @param p - The cubic polynomial to find the extrema of.\n * @returns The extrema of the cubic polynomial.\n * @since 1.0.0\n */\nexport const extrema: (p: CubicPolynomial) => Solution.AtMostTwo<number> = internal.extrema\n\nexport const monotonicity: {\n  /**\n   * Calculates the monotonicity of a cubic polynomial. Throws when the\n   * interval has zero width — the question is undefined at a single point.\n   *\n   * @param p - The cubic polynomial to analyze.\n   * @param i - The interval to restrict the analysis to.\n   * @returns The monotonicity of the cubic polynomial in the specified interval.\n   * @since 1.0.0\n   */\n  (p: CubicPolynomial, i?: Interval): Monotonicity\n  /**\n   * Calculates the monotonicity of a cubic polynomial. Throws when the\n   * interval has zero width.\n   *\n   * @param i - The interval to restrict the analysis to.\n   * @returns A function that takes a cubic polynomial and returns the\n   *   monotonicity of the cubic polynomial in the specified interval.\n   * @since 1.0.0\n   */\n  (i: Interval): (p: CubicPolynomial) => Monotonicity\n} = internal.monotonicity\n\n/**\n * Type-narrowing predicate: refines a `CubicPolynomial<T>` to\n * `CubicPolynomial<T & Monotonic>` when the polynomial is strictly monotonic\n * over the given interval (or globally, when no interval is given).\n *\n * @param p - The cubic polynomial to check.\n * @param i - Optional interval over which to check monotonicity.\n * @returns `true` when monotonicity is `'increasing'` or `'decreasing'`.\n * @since 2.0.0\n */\nexport const isMonotonic: {\n  <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Monotonic>\n  (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Monotonic>\n} = internal.isMonotonic\n\n/**\n * Type-narrowing predicate: refines to `CubicPolynomial<T & Increasing>`.\n *\n * @since 2.0.0\n */\nexport const isIncreasing: {\n  <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Increasing>\n  (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Increasing>\n} = internal.isIncreasing\n\n/**\n * Type-narrowing predicate: refines to `CubicPolynomial<T & Decreasing>`.\n *\n * @since 2.0.0\n */\nexport const isDecreasing: {\n  <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Decreasing>\n  (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Decreasing>\n} = internal.isDecreasing\n\n/**\n * Asserts that the cubic polynomial is monotonic, throwing on failure.\n *\n * @param p - The cubic polynomial to assert against.\n * @param i - Optional interval over which to check monotonicity.\n * @returns The same polynomial, typed with the `Monotonic` brand.\n * @throws When the polynomial is not monotonic over the given (or global) interval.\n * @since 2.0.0\n */\nexport const asMonotonic: <T>(\n  p: CubicPolynomial<T>,\n  i?: Interval,\n) => CubicPolynomial<T & Monotonic> = internal.asMonotonic\n\n/**\n * Asserts that the cubic polynomial is increasing, throwing on failure.\n *\n * @since 2.0.0\n */\nexport const asIncreasing: <T>(\n  p: CubicPolynomial<T>,\n  i?: Interval,\n) => CubicPolynomial<T & Increasing> = internal.asIncreasing\n\n/**\n * Asserts that the cubic polynomial is decreasing, throwing on failure.\n *\n * @since 2.0.0\n */\nexport const asDecreasing: <T>(\n  p: CubicPolynomial<T>,\n  i?: Interval,\n) => CubicPolynomial<T & Decreasing> = internal.asDecreasing\n\nexport const domain: {\n  /**\n   * Calculates the domain of a cubic polynomial.\n   *\n   * @param p - The cubic polynomial to analyze.\n   * @param range - The range to restrict the analysis to.\n   * @returns The domain of the cubic polynomial in the specified range.\n   * @since 1.0.0\n   */\n  (p: CubicPolynomial, range: Interval): Interval\n  /**\n   * Calculates the domain of a cubic polynomial.\n   *\n   * @param range - The range to restrict the analysis to.\n   * @returns A function that takes a cubic polynomial and returns the domain of the cubic polynomial in the specified range.\n   * @since 1.0.0\n   */\n  (range: Interval): (p: CubicPolynomial) => Interval\n} = internal.domain\n\nexport const range: {\n  /**\n   * Calculates the range of a cubic polynomial.\n   *\n   * @param p - The cubic polynomial to analyze.\n   * @param domain - The domain to restrict the analysis to.\n   * @returns The range of the cubic polynomial in the specified domain.\n   * @since 1.0.0\n   */\n  (p: CubicPolynomial, domain: Interval): Closed\n  /**\n   * Calculates the range of a cubic polynomial.\n   *\n   * @param domain - The domain to restrict the analysis to.\n   * @returns A function that takes a cubic polynomial and returns the range of the cubic polynomial in the specified domain.\n   * @since 1.0.0\n   */\n  (domain: Interval): (p: CubicPolynomial) => Closed\n} = internal.range\n\nexport const length: {\n  /**\n   * Calculates the length of a cubic polynomial.\n   *\n   * @param p - The cubic polynomial to analyze.\n   * @param domain - The domain to restrict the analysis to.\n   * @returns The length of the cubic polynomial in the specified domain.\n   * @since 1.0.0\n   */\n  (p: CubicPolynomial, domain: Interval): number\n  /**\n   * Calculates the length of a cubic polynomial.\n   *\n   * @param domain - The domain to restrict the analysis to.\n   * @returns A function that takes a cubic polynomial and returns the length of the cubic polynomial in the specified domain.\n   * @since 1.0.0\n   */\n  (domain: Interval): (p: CubicPolynomial) => number\n} = internal.length\n\nexport const curvature: {\n  /**\n   * Calculates the curvature of a cubic polynomial.\n   *\n   * @param p - The cubic polynomial to analyze.\n   * @param x - The value of x to calculate the curvature at.\n   * @returns The curvature of the cubic polynomial at the specified value of x.\n   * @since 1.0.0\n   */\n  (p: CubicPolynomial, x: number): number\n  /**\n   * Calculates the curvature of a cubic polynomial.\n   *\n   * @param x - The value of x to calculate the curvature at.\n   * @returns A function that takes a cubic polynomial and returns the curvature of the cubic polynomial at the specified value of x.\n   * @since 1.0.0\n   */\n  (x: number): (p: CubicPolynomial) => number\n} = internal.curvature\n"],"mappings":"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"}