galgebra.mv

Multivector and Linear Multivector Differential Operator

Members

class galgebra.mv.Dop(*args, **kwargs)[source]

Differential operator class for multivectors. The operators are of the form

\[D = D^{i_{1}...i_{n}}\partial_{i_{1}...i_{n}}\]

where the \(D^{i_{1}...i_{n}}\) are multivector functions of the coordinates \(x_{1},...,x_{n}\) and \(\partial_{i_{1}...i_{n}}\) are partial derivative operators

\[\partial_{i_{1}...i_{n}} = \frac{\partial^{i_{1}+...+i_{n}}}{\partial{x_{1}^{i_{1}}}...\partial{x_{n}^{i_{n}}}}.\]

If \(*\) is any multivector multiplicative operation then the operator D operates on the multivector function \(F\) by the following definitions

\[D*F = D^{i_{1}...i_{n}}*\partial_{i_{1}...i_{n}}F\]

returns a multivector and

\[F*D = F*D^{i_{1}...i_{n}}\partial_{i_{1}...i_{n}}\]

returns a differential operator. If the cmpflg in the operator is set to True the operation returns

\[F*D = (\partial_{i_{1}...i_{n}}F)*D^{i_{1}...i_{n}}\]

a multivector function. For example the representation of the grad operator in 3d would be:

\[\begin{split}D^{i_{1}...i_{n}} &= [e_x,e_y,e_z] \\ \partial_{i_{1}...i_{n}} &= [(1,0,0),(0,1,0),(0,0,1)].\end{split}\]

See LaTeX documentation for definitions of operator algebraic operations +, -, *, ^, |, <, and >.

ga

Associated geometric algebra

Type:Ga
cmpflg

Complement flag

Type:bool
terms
Type:list of tuples
consolidate_coefs()[source]

Remove zero coefs and consolidate coefs with repeated pdiffs.

simplify(modes=<function simplify>)[source]

Simplify each multivector coefficient of a partial derivative

class galgebra.mv.Mv(self, *args, ga, recp=None, **kwargs)[source]

Wrapper class for multivector objects (self.obj) so that it is easy to overload operators (*, ^, |, <, >) for the various multivector products and for printing.

Also provides a constructor to easily instantiate multivector objects.

Additionally, the functionality of the multivector derivative have been added via the special vector grad so that one can take the geometric derivative of a multivector function A by applying grad from the left, grad*A, or the right A*grad for both the left and right derivatives. The operator between the grad and the ‘A’ can be any of the multivector product operators.

If f is a scalar function grad*f is the usual gradient of a function. If A is a vector function grad|f is the divergence of A and -I*(grad^A) is the curl of A (I is the pseudo scalar for the geometric algebra)

obj

The underlying sympy expression for this multivector

Type:sympy.core.Expr

Note this constructor is overloaded, based on the type and number of positional arguments:

class Mv(*, ga, recp=None)

Create a zero multivector

class Mv(expr, /, *, ga, recp=None)

Create a multivector from an existing vector or sympy expression

class Mv(coeffs, grade, /, ga, recp=None)

Create a multivector constant with a given grade

class Mv(name, category, /, *cat_args, ga, recp=None, f=False)

Create a multivector constant with a given category

class Mv(name, grade, /, ga, recp=None, f=False)

Create a multivector variable or function of a given grade

class Mv(coeffs, category, /, *cat_args, ga, recp=None)

Create a multivector variable or function of a given category

* and / in the signatures above are python 3.8 syntax, and respectively indicate the boundaries between positional-only, normal, and keyword-only arguments.

Parameters:
  • ga (Ga) – Geometric algebra to be used with multivectors
  • recp (object, optional) – Normalization for reciprocal vector. Unused.
  • name (str) – Name of this multivector, if it is a variable or function
  • coeffs (sequence) – Sequence of coefficients for the given category. This is only meaningful
  • category (str) –

    One of:

    • "grade" - this takes an additional argument, the grade to create, in cat_args
    • "scalar"
    • "vector"
    • "bivector" / "grade2"
    • "pseudo"
    • "mv"
    • "even" / "spinor"
    • "odd"
  • f (bool, tuple) – True if function of coordinates, or a tuple of those coordinates. Only valid if a name is passed
  • coords

    This argument is always accepted but ignored.

    It is incorrectly described internally as the coordinates to be used with multivector functions.

Fmt(fmt=1, title=None)[source]

Set format for printing of multivectors

  • fmt=1 - One multivector per line
  • fmt=2 - One grade per line
  • fmt=3 - one base per line

Usage for multivector A example is:

A.Fmt('2','A')

output is:

'A = '+str(A)

with one grade per line. Works for both standard printing and for latex.

Grad(coords, mode='*', left=True)[source]

Returns various derivatives (*,^,|,<,>) of multivector functions with respect to arbitrary coordinates, ‘coords’. This would be used where you have a multivector function of both the basis coordinate set and and auxiliary coordinate set. Consider for example a linear transformation in which the matrix coefficients depend upon the manifold coordinates, but the vector being transformed does not and you wish to take the divergence of the linear transformation with respect to the linear argument.

static Mul(A, B, op)[source]

Function for all types of geometric multiplications called by overloaded operators for *, ^, |, <, and >.

base_rep()[source]

Express as a linear combination of geometric products

blade_coefs(blade_lst=None)[source]

For a multivector, A, and a list of basis blades, blade_lst return a list (sympy expressions) of the coefficients of each basis blade in blade_lst

blade_rep()[source]

Express as a linear combination of blades

collect(deep=False)[source]

group coeffients of blades of multivector so there is only one coefficient per grade

even()[source]

return even parts of multivector

exp(hint='-')[source]

Only works if square of multivector is a scalar. If square is a number we can determine if square is > or < zero and hence if one should use trig or hyperbolic functions in expansion. If square is not a number use ‘hint’ to determine which type of functions to use in expansion

get_grade(r)[source]

return r-th grade of multivector as a multivector

is_blade()[source]

True is self is blade, otherwise False sets self.blade_flg and returns value

is_versor()[source]

Test for versor (geometric product of vectors)

This follows Leo Dorst’s test for a versor. Leo Dorst, ‘Geometric Algebra for Computer Science,’ p.533 Sets self.versor_flg and returns value

norm(hint='+')[source]

If A is a multivector and A*A.rev() is a scalar then:

A.norm() == sqrt(Abs(A*A.rev()))

The problem in simplifying the norm is that if A is symbolic you don’t know if A*A.rev() is positive or negative. The use of the hint argument is as follows:

hint A.norm()
'+' sqrt(A*A.rev())
'-' sqrt(-A*A.rev())
'0' sqrt(Abs(A*A.rev()))

The default hint='+' is correct for vectors in a Euclidean vector space. For bivectors in a Euclidean vector space use hint='-'. In a mixed signature space all bets are off for the norms of symbolic expressions.

odd()[source]

return odd parts of multivector

proj(bases_lst)[source]

Project multivector onto a given list of bases. That is find the part of multivector with the same bases as in the bases_lst.

pure_grade()[source]

For pure grade return grade. If not pure grade return negative of maximum grade

scalar()[source]

return scalar part of multivector as sympy expression

static setup(ga)[source]

Set up constant multivectors required for multivector class for a given geometric algebra, ga.

class galgebra.mv.Pdop(*args, **kwargs)[source]

Partial derivative class for multivectors. The partial derivatives are of the form

\[\partial_{i_{1}...i_{n}} = \frac{\partial^{i_{1}+...+i_{n}}}{\partial{x_{1}^{i_{1}}}...\partial{x_{n}^{i_{n}}}}.\]

If \(i_{j} = 0\) then the partial derivative does not contain the \(x^{i_{j}}\) coordinate.

pdiffs

a dictionary where coordinates are keys and key value are the number of times one differentiates with respect to the key.

Type:dict
order

total number of differentiations

Type:int

The partial differential operator is a partial derivative with respect to a set of real symbols (variables). The allowed variables are in two lists. self.Ga.coords is a list of the coordinates associated with the geometric algebra. self.Ga.auxvars is a list of auxiallary symbols that have be added to the geometric algebra using the member function Ga.AddVars(self,auxvars).

factor()[source]

If partial derivative operator self.order > 1 factor out first order differential operator. Needed for application of partial derivative operator to product of sympy expression and partial differential operator. For example if D = Pdop({x:3}) then:

(Pdop({x:2}), Pdop({x:1})) = D.factor()
class galgebra.mv.Sdop(*args, **kwargs)[source]

Scalar differential operator is of the form (Einstein summation)

\[D = c_{i}*D_{i}\]

where the \(c_{i}\)’s are scalar coefficient (they could be functions) and the \(D_{i}\)’s are partial differential operators (Pdop).

terms

the structure \([(c_{1},D_{1}),(c_{2},D_{2}), ...]\)

Type:list of tuple
static consolidate_coefs(sdop)[source]

Remove zero coefs and consolidate coefs with repeated pdiffs.

galgebra.mv.compare(A, B)[source]

Determine if B = c*A where c is a scalar. If true return c otherwise return 0.