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 toTrue
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>
.
cmpflg
¶ Complement flag
Type: bool

terms
¶ Type: list of tuples


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 functionA
by applyinggrad
from the left,grad*A
, or the rightA*grad
for both the left and right derivatives. The operator between thegrad
and the ‘A’ can be any of the multivector product operators.If
f
is a scalar functiongrad*f
is the usual gradient of a function. IfA
is a vector functiongradf
is the divergence ofA
andI*(grad^A)
is the curl ofA
(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 positionalonly, normal, and keywordonly 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, incat_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>
.

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

collect
(deep=False)[source]¶ group coeffients of blades of multivector so there is only one coefficient per grade

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

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 ifA*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 usehint=''
. In a mixed signature space all bets are off for the norms of symbolic expressions.

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.


class
galgebra.mv.
Pdop
(_Pdop__arg, **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. When this is zero (i.e. when
pdiffs
is{}
) then this object is the identity operator, and returns its operand unchanged.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 functionGa.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: tuple of tuple
