Module solve 

Solving the state a program’s Constraints are on: the program’s side of the constraint systems of geop_core_math::solvers::system, which solve, check, enclose and measure them — the same algorithms a sketch’s numbers are solved by.

The values of the state a solve may move are the caller’s to say (Problem::free), each a block of the system, stepped along its own steps (geop_core_math::solvers::system::Variable::retract: a pose by the exponential map of a twist). The constraints are those the program defines, run once at the state a solve starts from: at every state it tries, only the constraints it asks are made again, each by its step’s generator, of the part as built and the state tried (crate::constraint::Remade) — no program is run, and the work of a solve step is that of the constraints it asks. What a solve should prefer among the states the constraints allow is the caller’s too: Preferences pull — a drag — and every value nothing pulls stays as near where it was as the constraints let it.

What steps let a solve move is said in the program itself: a step declares a value of the state (crate::unknown::Unknown), how a solve may move it, and where one starts from — so a solve of any program is set up from the part alone (crate::unknown::Unknowns).

Every solve comes with an enclosure of a true solution near where it ended (Solved::enclosure), each value in its own step coordinates around the state found — or with why none is proven: a configuration singular there, or constraints that conflict, by name.

Structs

Enclosure

An enclosure of a true solution of the constraints: every value it could have, by name — or, for the values whose groups none is proven for, why not.

Freedom

How free the values of the state are, where they are now (see freedom).

Problem

What a solve may move, and towards what.

Report

How a solve went.

Run

A program, with its inputs, and the part it builds: run once, at its own state, for a solve to make its constraints again of at every state it tries. A solve leaves the part so; a caller keeping the state found runs the program there.

Solved

Where a solve put the state, how it went, and the enclosure of a true solution near there of every group it solved — if it was asked to prove it.

Enums

Mobility

What a solve may do with a value.

Traits

Preference

What a solve should prefer among the states where the constraints hold: residuals it wants small — not zero at any price — where the part is as reader reads it, each a length, and their derivatives by the state. A drag, pulling a point of a placed part towards the pointer.

Functions

conflicting

A smallest set of the constraints of the program run runs that cannot all hold together — none, where they all hold after a solve from state (see System::conflicting), by name.

enclose

An enclosure of a true solution of the constraints of the program run runs near where state has the values problem frees — a solution to the solver’s tolerance (see System::enclose).

freedom

How free the values problem frees are where state has them: the directions in which every constraint that must vanish stays put to first order, and of those, how many move each value — decided over the box an enclosure of the solution proves (see System::freedom). A limit leaves free the motion away from it.

runs

How many times this thread has run a program for a question about its constraints — a solve, an enclosure, how free its values are — ever. Each run costs what the program’s steps do, so a test can bound the work a question takes by the runs it makes, rather than time it.

solve

Where the values problem frees have to be — from where state has them — for every constraint the program run runs defines to hold, as near where they are as the constraints allow, pulled as its preferences ask (see System::solve), and an enclosure of a true solution near there. The part is left as the program builds it at its own state.