Construct an operator that maps the subspace/operator to a complementary set of blades

fused-multiply-add on multivectors of arbitrary subspaces

Hodge dual

compute indices for reduceat expression, assuming rows idx are in sorted order

Verlet style integrator

Return unique value in sequence, if it exists

Negatives signs picked up by dotting these blades with themselves

wrap newton solve of a multivector function

Select non-degenerate subspace

Render a 3d scene, as embedded in a 4d elliptical or euclidian space currently it specializes to pga only would it be hard to revive elliptical? no

Inertia map of a uniform density simplex described by N corner points, described as antivectors as norm 1

slice out part of subspace using indices relative to the indices of the subspace

Return operator for solving x * y = rhs, for unknown y

Count the bits in each element of array b Parameters ---------- b: ndarray, [...] Returns ------- ndarray, [...], uint8 bitcounts of each el

Packs a sequence of booleans as a singleton integer array

Slice an array of elements into an iterable of its constituent bits

Overridable behavior for specifying broadcasting in einsum expression

Complement of a set of blades

Reverse the signs and order of all basis blades

A place to provide subtype specific type coercions and so on

construct a diagonal matrix from a vector

Intersection of elements in both subspaces

Fusing with scalar negation gives different reduction possibilities

True if all blades of other are contained in self Contains a shortcircuit to optimize the common case of identical subspaces being tested

Scalar multiplication

normalize a CGA object o such that o.dot(ni) == -1

Bind a subset of inputs

Binary geometric product between self and other of given symmetry

Random vector from normal distribution with a norm >= 0

Sum over sequence, starting from first element, rather than zero

~ operator, or blade-reversal

selection output subspace. think of better name?

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

Some really ugly code to initialize an nd chain of linked rigid bodies

Set up perspective camera rays Returns ------- camera_motor: Motor defines world-to-camera space camera_motor >> local = world the origin of

inertia map given [N x n] barycentric weights and n corner points

generate cube of sampling points; and pick sum(C) < 1

Register inversion rules based on simplifying the expression by self-involutions We register the simplest paths first and only go 3 levels of recursi

x * x

Sum over sequence, starting from first element, rather than zero

convert blades to indices that index the subspace self.blades[indices] = blades anti-slice, if you will

write an animation based on a set of states

bool for each blade in the subspace, if it contains a degenerate basis vector

Construct a list of canonical basis 1-blades

Bind input operators to operator `self` If inputs is a Dict[int, Operator], it is used as a partial apply Example ------- Given kernels with

Allocation for a set of inputs, with multivector components as last axis, and broadcasting axes on the left

Compute (l ^ r)*

Degenerate subspace

inverse of slice; blow up the kernel with zeros

Divide an anti-bivector impulse forque line in body local space, to two momentum-conserving bivector steps in body local space, which will move ou

Initialize a body from a point cloud Parameters ---------- points: [..., n_points], Point Returns ------- [...], Body

Construct algebra using interleaved basis names and signatures syntax Examples -------- 'x+y+z+w0' constructs the algebra corresponding to 3d P

Compute (R * v) * ~R, the full sandwich product The output subspace of the sandwich product contains both the input subspace grades, as well as t

Fuse to operators; feed output of `self` into nth input argument of `other`

Geometric product

Apply a grade selection formula