Every public item

The eigenvalues and eigenvectors of a symmetric matrix.

values is ascending and vectors has the matching eigenvector in its matching column, so a * v[:, i] = values[i] * v[:, i].

The @debug.Debug representation of this value.

An LU factorisation with partial pivoting, perm * A = lower * upper, where lower is unit lower triangular and upper is upper triangular.

sign is the parity of the row swaps, so det = sign * product(upper). The factorisation is kept so that several right-hand sides can reuse it, which is what the estimators do inside a filter loop.

The determinant of the factorised matrix.

Solve a * x = b from a factorisation. b has one column per right-hand side; the result has the same width.

The @debug.Debug representation of this value.

A dense matrix of Double in row-major order.

Element (i, j) lives at data[i * cols + j]. The arithmetic methods return new matrices; set is the only writer.

The elementwise sum. Both matrices must have the same shape.

Add value to the entry at (i, j).

The product self * v.

The product v^T * self, a row vector times the matrix.

Whether self and other agree entry by entry within tolerance.

The entry at (i, j), or None when the index is outside the matrix.

self with right appended on the right, so the result is rows x (cols + right.cols).

The height x width block whose top-left corner is (row, col).

The j-th column, copied out.

A diagonal matrix with values on the diagonal.

A rows x cols matrix with every entry value.

A matrix that takes over data without copying it. data holds the entries row by row.

The entry at (i, j). An index outside the matrix aborts.

The n x n identity.

Whether every entry is finite.

The product self * other.

Every entry negated.

A matrix whose rows are values; every row must have the same length.

The i-th row, copied out.

Every entry multiplied by factor.

Overwrite the entry at (i, j).

Overwrite the j-th column with values.

Overwrite the i-th row with values.

self with below appended underneath, so the result is (rows + below.rows) x cols.

The elementwise difference. Both matrices must have the same shape.

The rows copied into growable arrays, for output and test expectations.

The @debug.Debug representation of this value.

One line per row, each formatted like a Vec.

The sum of the diagonal entries.

The transpose A^T.

An all-zero rows x cols matrix.

An economy QR factorisation, a = q * r, with q of orthonormal columns and r upper triangular.

q has the same shape as a and r is square, which is the form the least-squares step and the UKF's square root need.

The @debug.Debug representation of this value.

A dense vector of Double.

The storage is a fixed array, so a vector is cheap to pass around and a set writes through to it. Every arithmetic method returns a new vector; none of them mutate the receiver.

The elementwise sum. The two vectors must have the same length.

Whether self and other agree entry by entry within tolerance.

The entry at i, or None when i is outside the vector.

self + factor * other, the operation a matrix-vector product accumulates with.

An independent copy.

The inner product. The two vectors must have the same length.

A vector of len copies of value.

A vector that takes over data without copying it.

The entry at i. An index outside the vector aborts: it is a programming error, not input data.

The elementwise product. The two vectors must have the same length.

Whether the vector has no entries.

Whether every entry is finite.

The number of entries.

A vector of len samples evenly spaced from start to stop inclusive. A single sample is start.

The largest absolute entry, or zero for an empty vector.

Every entry negated.

The Euclidean length.

The sum of the squared entries.

The unit vector in the same direction; a zero vector is returned as it is.

A vector holding values.

Every entry multiplied by factor.

Overwrite the entry at i.

The elementwise difference. The two vectors must have the same length.

The sum of the entries.

The entries copied into a growable array.

The @debug.Debug representation of this value.

The entries in [ a, b, c ] form, for output and test expectations.

A vector of len zeros.

The lower Cholesky factor of a symmetric positive-definite matrix a, so that a = l * l^T.

The factor is what the Kalman gain is solved with: a Cholesky solve costs half an LU solve and never needs pivoting for a covariance.

Solve a * x = b given the lower Cholesky factor l of a. b has one column per right-hand side.

The determinant of a square matrix.

The symmetric eigendecomposition of a by cyclic Jacobi rotations.

The rotations are stable for the covariance-shaped matrices this library hands it, and they need no shift strategy. Only the symmetric part of a is used, so a small skew from rounding does not matter. Raises Refused::Dimension when a is not square and Refused::Exceeded when the sweep limit is reached.

The matrix exponential of a square matrix, by scaling and squaring followed by a truncated Taylor series.

This is what turns a continuous state matrix into a discrete one; the scaling keeps the series inside the range where twenty terms reach machine precision.

The inverse of a square matrix.

Factorise a, a square matrix, into perm * a = lower * upper.

Raises Refused::Singular at the first column whose pivot is zero; Refused::Dimension when a is not square.

The Frobenius norm of a matrix.

Factorise a as q * r with Householder reflections.

Raises Refused::Dimension when a has fewer rows than columns: an economy factorisation cannot represent that shape.

Solve a * x = b for a square a.

Solve a * x = b for a square a and a single right-hand side.

How long a planner may search.

The @debug.Debug representation of this value.

Which rule turns a continuous state matrix into a discrete one.

The @debug.Debug representation of this value.

A nonlinear plant given as a derivative and an output map, integrated with a named rule.

The derivative is f(x, u, dt), taking the period as well because a plant may be defined for a fixed control period; the rule treats it as the vector field at x.

A nonlinear plant from its derivative and its output map, integrated with RK4 unless told otherwise.

The @debug.Debug representation of this value.

How Dynamics integrates its derivative.

The @debug.Debug representation of this value.

One instant of a single-axis motion, with every derivative a drive may need.

The jerk is what separates a smooth profile from a trapezoid: a drive that bounds it never excites the resonance the way a step in acceleration does.

A sample from its four derivatives.

A sample that is not moving.

The @debug.Debug representation of this value.

A linear time-invariant plant, x' = a x + b u, y = c x + d u.

With dt set the record is already discrete and step applies a x + b u once; without it the record is continuous and step integrates over the period it is given. A discrete record is what the Kalman filter and the model-predictive controller want; a continuous one is what a plant model in physical units looks like.

A continuous plant.

A plant already discretised at dt seconds.

The same plant discretised at dt seconds.

A record that is already discrete is returned unchanged when the periods agree and refused when they do not: resampling would need the original continuous plant, which the record no longer carries.

Whether the record is already discrete.

The @debug.Debug representation of this value.

A feedback law: the input to apply for a reference and a measurement.

The combinators in control (cascade, saturation, rate limiting) take any &Controller, so a controller written outside this library composes the same way the ones here do.

A state estimator: propagate on the input, then fold in a measurement.

The two steps are separate because a sensor does not always deliver on every control period; a caller that has no measurement that cycle calls predict alone.

A mechanism: joint values to a task-space pose, and back.

Both spaces are plain Vecs so that one contract covers a two-wheel base and a six-axis arm; a model that has typed joint values offers them alongside.

A plant: how the state moves under an input, and what a sensor sees.

step and observe are the model. step_jacobian and observe_jacobian have default implementations built on them by central differences, so a plant that gives only the two functions works with the extended Kalman filter, the unscented Kalman filter and the particle filter as it is.

A planner: a start, a goal and a budget, out comes a path of states from the start to the goal.

A state space a planner can search: where to draw random states, how far apart two are, and how to walk between them.

A vehicle model implements this with its (x, y, heading) states and its own steering primitives, which is what lets a sampling planner plan a Dubins path without knowing what Dubins is.

A single-axis motion profile: a duration, and the state at any time in it.

Sampling outside [0, duration] is defined rather than refused: before the start the motion is held at its first sample and after the end at its last, so a caller can run a clock past the end without a branch.

Which states and motions a motion planner may use.

Collision checking lives here, so the planners stay free of geometry.

How a PID stops its integrator while the output is saturated.

The @debug.Debug representation of this value.

Controllers in series: the output of one stage is the reference of the next.

A cascade is how a current loop inside a velocity loop inside a position loop is written. The measurement vector carries one entry per stage, so stage i is handed measurement[i].

A cascade of the given stages, outermost first.

The knobs of the control-barrier-function filter.

iterations bounds the alternating projection. The filter is exact when it converges, and the bound is there so a pathological gradient cannot stall a control period.

The @debug.Debug representation of this value.

A computed-torque law: the inertia and gravity of the mechanism plus a proportional-derivative correction in joint space.

inertia and gravity are supplied by the caller because the mass matrix of a mechanism belongs to the mechanism, not to the controller; a model that has them can pass them straight in, and a model that does not can pass an identity and get plain joint-space feedback.

The effort that tracks the desired joint motion.

The inertia alone, for a caller that wants the model part without the loop.

A computed-torque law with the given gains.

The @debug.Debug representation of this value.

A velocity- and acceleration-feedforward term on the reference trajectory.

A feedforward does not close a loop: it removes the lag the feedback would otherwise have to work off by itself. On a servo that follows a planned trajectory the velocity gain dominates and the acceleration gain covers the inertia.

The command for a reference sample: the gains applied to its derivatives.

A feedforward from its two gains. A negative gain is refused.

The @debug.Debug representation of this value.

A feedforward driven by the reference sequence: the velocity and the acceleration are differenced from the references it is handed.

A runner for a feedforward.

The knobs of the iterative LQR.

state_weight and input_weight are the diagonal weights of the quadratic cost: every state deviation costs state_weight / 2 per unit squared and every input input_weight / 2. regularisation is added to the input Hessian so a direction the model cannot move stays solvable.

The @debug.Debug representation of this value.

An impedance controller: a mass-spring-damper between the tool and the target, with the contact force measured rather than modelled.

The rendered position follows the admittance m x'' = f_ext - d x' - k (x - x_d) and the effort returned is the spring-damper wrench at that position, so a tool pushed off its target yields and then returns.

The wrench to command for one period.

An impedance from its three parameters and the starting position.

The rendered position, which is where the tool actually is under a contact force.

The @debug.Debug representation of this value.

An LQR with an integral of the output error appended to the state.

The extra state is what removes a constant disturbance's offset: the proportional part of an LQR leaves a standing error when the plant is pushed by a bias, and the integrator integrates that error away. The integral acts on the output c x, not on the whole state, because integrating a state the input cannot reach independently would leave the augmented plant unstabilisable.

The gain matrix over [state; integral].

A linear-quadratic regulator: the infinite-horizon gain for a discrete plant and quadratic weights.

The control law is u = -k (x - reference), so a regulator that drives the plant to a setpoint is the same object as the one that drives it to zero.

The gain matrix, for a caller that applies it itself.

A receding-horizon controller for a discrete linear plant with box limits on the input and on its rate of change.

The prediction is condensed into one quadratic program over the stacked inputs, which is what makes the period predictable: the matrices are built and factorised once per call, and the solve is a fixed number of ADMM iterations rather than a search whose length depends on the active set.

The command for this period, after which the horizon shifts by one.

A model-predictive controller for model at the given weights.

The plant must be discrete: a continuous record would need the period it is to be discretised at, which the controller cannot guess.

The knobs of the model-predictive controller.

penalty is the ADMM step of the quadratic program, input the box on the command and rate the box on its change per second. iterations bounds the solve, so a period can never take longer than the budget says.

The @debug.Debug representation of this value.

An inclusive band [low, high] for one scalar.

The @debug.Debug representation of this value.

A proportional-integral-derivative controller.

The integrator, the previous derivative input and the filtered derivative are the only state; reset clears them so a loop can start from rest.

The output for one period of a scalar loop.

The integrator value, which is what an anti-windup scheme acts on and what a test asserts when the loop sits in saturation.

A PID from a configuration.

Every number a PID uses that is not one of its three gains.

weight_p and weight_d are the setpoint weights of the standard form: the proportional term acts on weight_p * reference - measurement and the derivative on weight_d * reference - measurement. A weight of zero takes the reference out of that term, which is what "derivative on measurement" means; derivative_on_measurement does exactly that for the derivative without the caller having to reason about the weight.

filter is the fraction of the raw derivative kept each period: 1 is no filtering, 0.1 smooths heavily. Values outside (0, 1] are read as 1.

The @debug.Debug representation of this value.

The steering a pure-pursuit follower asks for.

The follower looks a fixed distance ahead on the path, which is what makes it stable at speed: a short lookahead cuts corners and oscillates, a long one turns early. The returned angle is the one that puts the rear axle on an arc through the lookahead point.

The steering angle that puts the vehicle on the lookahead point.

The @debug.Debug representation of this value.

The knobs of the box-constrained quadratic program.

penalty is the ADMM step; too small and the dual converges slowly, too large and the primal oscillates. Twice the largest diagonal of h is the usual choice for a well-scaled problem.

The @debug.Debug representation of this value.

A controller whose output may not change faster than rate per second.

The limit applies to the first entry of the command, which is the one a single-drive loop carries; a higher-dimensional command passes through the slowest component.

A rate-limit wrapper. A rate that is not positive is refused.

The solution of a discrete algebraic Riccati equation: the stabilising gain and the cost-to-go matrix it came with.

The @debug.Debug representation of this value.

A controller whose output is clamped into a band.

A saturation wrapper.

The band, exposed so a caller can read back the limit it set.

The steering a Stanley follower asks for.

The law is the heading error plus a term that grows with the distance from the path: the first brings the vehicle parallel, the second brings it back on. soft stands in for the speed in the usual atan(k e / v), so the follower does not need a speed input.

The steering angle from the heading error and the cross-track error.

The @debug.Debug representation of this value.

The minimiser of 0.5 z' h z + f' z inside the box [lower, upper].

ADMM rather than an active-set method: the horizon of a predictive controller is re-solved every period with the same h, so a method whose cost per iteration is one triangular solve and one clamp keeps the period short, and there is no active set to warm start.

The safe input closest to the nominal one.

The barrier h is the one the caller computed for the current state; gradient is d h / d u, drift is d h / d t without the input, and alpha is the class-K gain that decides how hard the filter pushes towards a larger barrier. The result satisfies drift + gradient * u + alpha * barrier >= 0 inside the box, or the closest point to that set when the box and the half-space do not meet.

Dykstra's alternating projection rather than plain alternation: plain alternation lands on a point of the intersection but not on the nearest one, and the whole point of a safety filter is to change the command as little as possible.

Clamp into an inclusive band.

Solve the discrete algebraic Riccati equation for (a, b) at the weights (q, r) by iterating the Riccati recursion to a fixed point.

The recursion is monotone from p = q, so it converges to the stabilising solution without a Schur decomposition. A system that cannot be stabilised does not converge, and the iteration says so with Refused::Exceeded rather than returning a gain that would drive it further away.

The input sequence that drives start to goal over the horizon the initial guess fixes.

The initial guess gives the horizon, the control dimension and the region the solve starts in; the returned sequence has the same length. The backward pass uses the model's state Jacobian and a central difference for the input one, because a plant contract only promises the former.

The integral LQR for a discrete (a, b) pair with outputs c, accumulating the output error at dt seconds.

The infinite-horizon LQR for a discrete (a, b) pair. An element of r that is not positive is refused: it would let the input be free.

A PID configuration from the three gains. A negative gain is refused: a loop with a negative proportional gain is unstable by construction, and refusing it here names the mistake where it is made.

An alpha-beta-gamma tracker: position, velocity and acceleration of one axis from a position measurement.

The three gains trade noise against lag the way a Kalman filter does with a fixed model: alpha corrects the position, beta the velocity and gamma the acceleration. The preset is the critically damped set for a steady-state model of a constant acceleration.

A tracker with the given gains and starting position.

The @debug.Debug representation of this value.

The state after folding in one position measurement.

A complementary filter for one angle: the gyro is trusted for the fast motion, the measurement for the slow drift.

alpha is the fraction of the integrated rate kept each period. At 0.98 with a period of a hundredth of a second the time constant is about half a second, which is the usual balance for a hobby-grade inertial sensor.

The current angle.

A complementary filter with the given blend and starting angle.

The @debug.Debug representation of this value.

The corrected angle after one period.

An extended Kalman filter: the linear recursion with the Jacobians the model supplies, whether analytically or by the contract's default differences.

An extended Kalman filter for any plant that implements the model contract.

The @debug.Debug representation of this value.

A linear Kalman filter for a discrete state-space plant.

A Kalman filter for model with the given noise covariances and prior.

A particle filter over any plant that implements the model contract.

The particles are drawn around the prior at construction and then carried by the model itself, so the filter never assumes the state distribution stays Gaussian. Resampling is systematic and only runs when the effective sample size falls below half the cloud, which keeps the diversity a plain resample-every-step filter loses.

A particle filter with samples particles drawn around state.

The particles, for a caller that plots the cloud.

The @debug.Debug representation of this value.

The weight of each particle.

The spread of the sigma points in the unscented transform.

alpha sets how far the points sit from the mean, beta folds in the knowledge that the distribution is Gaussian, and kappa is the usual secondary scaling. The preset is the one the reference implementations use.

The @debug.Debug representation of this value.

An unscented Kalman filter.

An unscented Kalman filter for any plant that implements the model contract.

The @debug.Debug representation of this value.

The Rauch-Tung-Striebel smoother: the forward filter's estimates refined by a backward pass over the same record.

states and covariances are the filtered estimates, transitions the state matrices between consecutive steps, and process the process covariance. The result is the smoothed state and covariance at every step, whose covariances are never larger than the filtered ones.

A clamped uniform B-spline over a control polygon.

The curve is pulled towards the control points without passing through them, which is what makes it the profile for a path that only has to be smooth. The first and last control points are interpolated, so it starts and ends where the polygon does.

The @debug.Debug representation of this value.

A natural cubic spline through time-stamped positions, continuous in velocity and acceleration, with zero curvature at both ends.

The @debug.Debug representation of this value.

A polynomial in time, position = sum(coefficients[i] * t^i).

A polynomial is the profile to reach for when the boundary conditions are the whole requirement: it matches a position, a velocity and an acceleration at both ends exactly, and it does not care about a jerk limit on the way.

The @debug.Debug representation of this value.

A jerk-limited S-curve.

Several single-axis profiles run together.

Axes are slowed by sampling them on a stretched clock: axis i is sampled at t * duration_i / duration, and its velocity and acceleration are scaled by the same factor and its square. The path is preserved, the timing is not.

One axis sampled on the common clock, with its derivatives scaled back to the axis's own time.

A synchronised set from axes that already have a duration.

Every axis sampled at the same instant.

The @debug.Debug representation of this value.

A trapezoidal velocity profile: accelerate, cruise, decelerate.

It is the cheapest profile that respects a velocity and an acceleration limit, and the one that puts a step in the acceleration at each corner. The boundary velocities may be anything up to the peak the distance allows.

The @debug.Debug representation of this value.

A clamped B-spline of degree over control, running for duration seconds.

A cubic from one boundary state to another over duration.

A cubic matches the two positions and the two velocities exactly; its acceleration jumps at both ends, which is what a drive without a jerk limit does anyway.

A natural cubic spline through (time, position) knots, which must be ordered in time.

A quintic from one boundary state to another over duration.

A quintic also matches the two accelerations, so the acceleration is continuous with whatever profile came before and whatever comes after.

An S-curve over distance with the given limits and boundary conditions.

The start and end accelerations are folded into the first and last ramp, so a motion that is already accelerating keeps its acceleration instead of spending time on coming back to zero. A boundary acceleration outside the limit is refused, and so is a boundary velocity against the direction of travel or above the velocity limit: none of those has a jerk-limited profile that starts from it.

A trapezoid over distance with the given limits and boundary velocities.

The boundary velocities are read along the direction of travel: a negative distance with a start velocity of -0.5 means the axis is already moving the way it will go. A velocity against the direction of travel is refused, since the profile would have to reverse inside itself.

A Dubins car.

A Dubins car with the given radius. extent is the half width of the box the space samples from.

The shortest Dubins path between two (x, y, heading) poses.

Every word that joins the two poses, in word order.

A car whose words are all drawn is a car the reader can compare; the callers that only want to drive one take path.

The @debug.Debug representation of this value.

The Dubins path between two poses: the word and the length of each of its three pieces.

The pose at distance travelled along the path.

The @debug.Debug representation of this value.

One of the six Dubins words: three pieces, each a left arc, a right arc or a straight line.

The @debug.Debug representation of this value.

The dynamic window approach: sample the velocities the drives can reach in one period, roll each one forward, and keep the best by heading, clearance and speed.

The best velocity pair for the current pose towards goal, avoiding obstacles, which are points.

The @debug.Debug representation of this value.

Which search a grid query runs.

The @debug.Debug representation of this value.

A grid used as a planning space, so a sampling planner can search a lattice.

A space whose states are grid cells scaled by resolution.

An RRT* that only samples where a path shorter than the best one could still run: the ellipse whose foci are the start and the goal.

An informed RRT* seeded from the best path found so far.

An artificial potential field: attraction to the goal, repulsion from the obstacles.

The velocity command for this step, as a two-dimensional motion.

The @debug.Debug representation of this value.

A probabilistic roadmap.

A roadmap with the given sample count and connection radius.

A Reeds-Shepp car.

Every word that joins the two poses, shortest first.

A word that cannot reach the goal returns no parameters at all, so the list holds only the ones that do; the shortest of them shares its length with any other candidate of the same total.

A Reeds-Shepp car with the given radius. extent is the half width of the box the space samples from.

The shortest path between two (x, y, heading) poses, reversing as needed.

The @debug.Debug representation of this value.

A Reeds-Shepp path: the word it spells, its pieces, and the pose it starts from.

The pose at distance travelled along the path: an arc turns around its own centre, a straight runs along the heading, and backing up moves the car the other way without changing which way it faces.

How many times the path changes direction.

The @debug.Debug representation of this value.

One straight or curved piece of a Reeds-Shepp path.

The @debug.Debug representation of this value.

One of the forty-eight reversable-car path words.

The position of a word in the enumeration: family times four plus variant.

A family is one set of segment formulas and a variant is one of the four frames it is applied in, so the pair is all the table a word needs.

The word a code names, or None outside the forty-eight.

The @debug.Debug representation of this value.

A rapidly-exploring random tree.

step is the length of the edge a new sample is allowed to reach, and goal_bias the chance that a sample is the goal itself rather than a random state. The generator is seeded from the planner, so a run replays exactly.

An RRT that extends by step and steers to the goal once every 1 / goal_bias samples.

An RRT grown from both ends at once: the two trees take turns reaching for each other, which closes a narrow passage far faster than one tree alone.

A bidirectional RRT.

An RRT that rewires the tree as it grows, so the path converges on the shortest one inside the budget.

An RRT* with a rewiring radius.

The words of the family family, in variant order.

The shortest path between two grid cells, as node indices, from the grid package's own search.

An Ackermann steering base: the inner and outer front wheels turn by different angles about a common centre.

The inner and outer steering angles for a curvature: the wheel on the inside of the turn has to turn further, by the angle its shorter radius demands.

An Ackermann base with the given wheelbase and track.

The @debug.Debug representation of this value.

A bicycle model: the joint space is (speed, steering angle) and the task space the body twist (vx, vy, omega).

The curvature a steering angle gives.

A bicycle with the given wheelbase.

The steering angle a curvature needs.

The @debug.Debug representation of this value.

A delta robot: three parallel arms from a fixed base to a moving platform.

The joint space is the three upper-arm angles measured from horizontal and the task space the platform centre (x, y, z) under the base.

The three elbows, in the base frame, for the upper-arm angles q.

A drawing of the cell needs the elbows as well as the platform, and the cell already computes them to solve its own forward map.

A delta cell with the given geometry.

The @debug.Debug representation of this value.

A two-wheel differential drive.

track is the distance between the wheels and wheel_radius the radius of each. The joint space is (omega_left, omega_right) in radians per second and the task space (v, omega) in metres and radians per second.

The pose after driving twist for dt seconds.

The arc is integrated exactly: a straight chord would cut the corner of every turn, and the error grows with the square of the period.

A differential drive with the given wheel radius and track width.

The @debug.Debug representation of this value.

A gantry: two motors drive one gantry axis from either end, so the pair sets the position and the tilt of the beam.

The joint space is (x, y_left, y_right, z) and the task space (x, y, z, tilt), where y is the middle of the beam and tilt the angle the difference between its ends makes.

A gantry with the given beam length.

The @debug.Debug representation of this value.

A four-wheel mecanum base. The joint space is the four wheel speeds in the order front left, front right, rear left, rear right, and the task space the body twist (vx, vy, omega).

A mecanum base with the given wheel radius and half extents.

The @debug.Debug representation of this value.

An omnidirectional base with three or more driven wheels on a circle.

The wheels are mounted tangentially, so each one drives along theta and the map from twist to wheel speeds is one row per wheel. With three wheels it inverts exactly; with more the inverse is the least-squares one, which spreads the effort over the wheels that can help.

An omnidirectional base whose wheel i sits at angles[i] radians on a circle of radius.

The @debug.Debug representation of this value.

A planar chain of n links. The joint space is the joint angles and the task space the (x, y) of the tip.

The analytic Jacobian of the arm at the joint angles q: how far the tip moves for a small change in each joint.

Link k and everything outboard of it turn with joint k, so column k is that joint's direction rotated by the total angle up to k, scaled by the reach still in front of it. Kinematics::jacobian defaults to a central difference; this is the same matrix in closed form.

A planar arm with the given link lengths.

The joint angles that put the tip on target, by damped least squares.

The damping is what makes the solve usable near a singularity: without it the Jacobian's inverse blows up and the joint velocities with it, which on a real arm is a torque the drive cannot deliver. damping is the square of the smallest singular value the solve allows.

The @debug.Debug representation of this value.

A SCARA arm: two revolute joints about the vertical axis and one prismatic joint along it.

A SCARA with the two link lengths and the vertical stroke.

The @debug.Debug representation of this value.