# symforce.jacobian_helpers module#

tangent_jacobians(expr, args)[source]#

Compute jacobians of expr, a Lie Group element which is a function of the Lie Group elements in args. Jacobians are derivatives in the tangent space of expr with respect to changes in the tangent space of the arg, as opposed to jacobians of the storage of either which could be trivially computed with `sf.Matrix.jacobian` or `sf.Expr.diff`.

This uses `tangent_jacobians_first_order()` internally.

Parameters:
• expr (Any) – The final expression that should be differentiated

• args (Sequence[Any]) – Sequence of variables (can be Lie Group elements) to differentiate with respect to

Returns:

The jacobian ``expr_D_arg`` for each arg in ``args``, where each ``expr_D_arg`` is of shape`MxN`, with `M` the tangent space dimension of `expr` and `N` the tangent space dimension of `arg`

Return type:
tangent_jacobians_first_order(expr, args)[source]#

An implementation of `tangent_jacobians()` using first-order simplifications of retract and local_coordinates.

The interface is the same as for `tangent_jacobians()`.

This is the method described in Section V.B.2 of the SymForce paper.

If `expr = f(arg)`, then the jacobian we want to return is the derivative of `local_coordinates(f(arg), f(retract(arg), t)` with respect to tangent vector t at `t = 0`.

`local_coordinates` and `retract`, however, are often complicated functions which are hard to symbolically differentiate when composed with f. To avoid this issue, we replace them with first order approximations. The result is something which we can easily symbolically differentiate.

This works because the approximations become exact in the limit as `t -> 0`.

While the output returned is different than that returned by `tangent_jacobians_chain_rule()`, they are the same when evaluated numerically. `tangent_jacobians_first_order` (almost?) always returns expressions which require fewer ops after cse.

Parameters:
Return type:
tangent_jacobians_chain_rule(expr, args)[source]#

An implementation of `tangent_jacobians()` using the symbolic chain rule with `tangent_D_storage` and `storage_D_tangent`.

The interface is the same as for `tangent_jacobians()`.

This is the method described in Section V.B.1 of the SymForce paper.

If `expr = f(arg)`, then the jacobian we want to return is the derivative of `local_coordinates(f(arg), f(retract(arg), t)` with respect to tangent vector t at `t = 0`.

`local_coordinates` and `retract`, however, are often complicated functions which are hard to symbolically differentiate. To avoid this issue, we compute their derivatives ahead of time, then use the chain rule.

While the output returned is different than that returned by `tangent_jacobians_first_order()`, they are the same when evaluated numerically. `tangent_jacobians_first_order()` (almost?) always returns expressions which require fewer ops after cse.

Parameters:
Return type: