Module solvers 

Solvers: finding where functions vanish, and the constraint systems built on them.

• linear: dense linear algebra in honest enclosures — the linear solves, eliminations, null spaces and inverses every other solver builds on.
• iterate: fixed-point iteration from sharp seeds, keeping the honest answer beside the seed — the loop of every Newton-type method.
• bisect: bisection of a bracket, in plain numbers or sharp scalars, and the scan of samples for the brackets of a sign change.
• minimize: damped descent to a point that is a free choice.
• probe: a sequence of trial values — a step halved, a reach doubled — probed until one decides.
• refine: adaptive refinement, a resolution made finer until what is built at it is good enough.
• subdivide: subdivision search, the global method that finds every solution in a region within a node budget.
• repeat: a step repeated until it says it is done, within a budget — worklists rewritten until nothing is left to rewrite, marches stepped on until they arrive, passes until one changes nothing.
• walk: a chain followed node by node until it closes, ends or runs into itself, and a graph flooded from some nodes to all it reaches.
• newton: Newton refinement of a root a subdivision search has isolated, and Newton’s method on one unknown from a seed.
• least_squares: constrained Levenberg–Marquardt.
• system: constraint systems on blocks of variables — numbers, poses — solved by the driver, checked, measured for freedom and conflicts, and their solution enclosed: the engine behind sketches and the state of programs alike. A solve holds the constraints exactly, and prefers pulls and staying put among where they hold.

Modules

bisect

Bisection of a bracket on which side of a crossing its middle lies — in plain numbers, where where-exactly is a free choice found as far as f64 goes, or in sharp scalars, where the side is told by an interval test that may not decide — and the scan of samples that finds the brackets: every pair of neighbouring samples on different sides.

iterate

Fixed-point iteration from sharp seeds: the loop every Newton-type method of the kernel runs — foot points, a ball rolled between faces, a vertex moved onto offset surfaces, a traced curve’s corrector.

least_squares

Levenberg–Marquardt, constrained: minimizing a sum of squared residuals Σ r(x)² among the points where other residuals c(x) vanish, from their values and Jacobians.

linear

Dense linear algebra, in honest enclosures: a pivot counts as zero exactly when it could be zero. One implementation per algorithm, for every solver of the kernel:

minimize

Minimizing a merit over a point the caller is free to choose: the nearest point of a curve or a surface. The point found is a choice, not an enclosure of a true minimum — what it is chosen for is measured at it afterwards — so the merit is a plain number.

newton

Newton refinement of a root a subdivision search has isolated — shared by geop_core_geometry‘s NurbCurve::refine_parameter_at_point and the intersection searches’ refine_crossings — and Newton’s method on one unknown from a seed (newton_1d), for a point that is a free choice up to where a function vanishes.

probe

Probing a sequence of trial values until one decides: a step halved until a point stepped off a curve lands where it should, a reach doubled until it brackets a crossing, a point marched on until it passes one, a ray cast in one direction after another until one is clear of every vertex.

refine

Adaptive refinement: something built at a resolution — samples along a curve, cells across a face, stations along a blend — built again finer until what it measures of itself is good enough.

repeat

Repeating a step until it says it is done: the driver of every loop that runs until a condition holds — a worklist rewritten until nothing is left to rewrite (the next split, merge or imprint found and made, until none is found), a march stepped on until it arrives or leaves, passes over a list until one changes nothing.

subdivide

Subdivision search: the global method that finds every solution in a region by discarding the pieces that provably hold none and splitting the rest (see “Subdivide to isolate, then Newton to refine” in AGENTS.md).

system

Constraint systems: values a solve moves, in blocks (Variables — a number, a pose), and terms on them (Equations) — constraints that hold where their residuals vanish (or, for a limit, stay at most zero), and preferences a solve pulls towards among where the constraints hold. Written once, for every system of the kernel: a sketch’s numbers (geop_core_sketch) and a program’s state, where its parts are (geop_core_program::solve), are each only an Equations.

walk

Walking a chain: from a start, on to the one next node, and the one after that, until the chain closes, ends, or runs into itself — a loop of coedges followed round its face, a tangent chain of edges, the arcs of one circle, a sketch’s curves joined end to end, a pattern’s joints driving each other.

Functions

work

How much dense linear algebra this thread has done, ever: per factorisation of a matrix of rows rows over columns unknowns — a step of least_squares::minimize, an elimination of linear::eliminate — rows × columns², what it costs. A test bounds the work of a solve by it, rather than timing it: a dense system grows as the cube of its size.