non contracting tensor product

Compute (R * v) * ~R Only retain the grade-preserving part of the sandwich, which is usually what we are interested in, since proper motors compo

Enforce symmetry on the given input axes [a, b] That is the output op will have the property op(a, b) = op(b, a) We may choose to apply this t

Reduce one input axis by summation

Construct a list of all canonical basis subspaces, as they appear in the 1-vector

Grade of each blade; number of basis vectors present in each blade Returns ------- np.ndarray, [n_blades], uint8 grade of each blade

Turn even-odd parity of ints to a sign value [0, 1, 2, 3] -> [+1, -1, +1, -1]

Construct geometric product between elements of a and b Parameters ---------- a: np.ndarray, [a], blade_dtype basis blades encoded as intege

Drop known zero terms from output subspace

Union of elements in both subspaces

Inverse of x such that x * x.inverse() == 1 == x.inverse() * x

Returns the inverted multivector `X^-1` such that `X * X^-1 = 1`. Using Shirokov's inverse algorithm that works in arbitrary dimensions, see ht

x * ~x

A subspace is n-simple if it maps to a scalar under n self-involution products

Represent elements array in unpacked bit format, [n_elements, dimensions]

Nice place to nest and cache all our operator related stuff

not-quite-motor, not too far from unity

Reverse the order of all basis blades

Compute *op(l*, v*); wrap the operator in left/right dualizatiom

Cayley table of the geometric product a * b Parameters ---------- a: np.ndarray, [...], blade_dtype basis blades encoded as integer bitpatte

Diagonal scaling operator

Build einsum expression for (partial) application of input arguments Parameters ---------- axes : Tuple[int, ...] sequence of integers denot

Remap to new output space; dropping outputs or adding implicit zeros

Upcast general objects to scalar multivectors

Dot-product between bit-blades; counting their shared high bits

Hodge dual inverse

Embed a Euclidian point in CGA space

Construct unary operator, that maps rates to momenta, for the point in self. P v (P x B)

Product with selected grades. Grade selection is not a regular linear operation so we need to apply it before binding any other operators

Reshape axis such as to broadcast to whole kernel

Select degenerate subspace

Difference of elements in both subspaces

Grade of each blade; number of basis vectors present in each blade Parameters ---------- a: np.ndarray, [...], blade_dtype basis blades enco

Get the grade of the subspace; raises if no single grade exists, and this is a mixed-grade subspace

Normalization of a motor, via numerical solution of the inverse-sandwich of the norm-squared of the motor In dimensions < 6, convergence should be

Encode sandwich operation as linear map over the subspace v This can be used to map a quaternion to the equivalent rotation matrix, Or a motor to