Ops.clifford {clifford} | R Documentation |

`clifford`

objectsAllows arithmetic operators to be used for multivariate polynomials such as addition, multiplication, integer powers, etc.

```
## S3 method for class 'clifford'
Ops(e1, e2)
clifford_negative(C)
geoprod(C1,C2)
clifford_times_scalar(C,x)
clifford_plus_clifford(C1,C2)
clifford_eq_clifford(C1,C2)
clifford_inverse(C)
cliffdotprod(C1,C2)
fatdot(C1,C2)
lefttick(C1,C2)
righttick(C1,C2)
wedge(C1,C2)
scalprod(C1,C2=rev(C1),drop=TRUE)
eucprod(C1,C2=C1,drop=TRUE)
maxyterm(C1,C2=as.clifford(0))
C1 %.% C2
C1 %dot% C2
C1 %^% C2
C1 %X% C2
C1 %star% C2
C1 % % C2
C1 %euc% C2
C1 %o% C2
C1 %_|% C2
C1 %|_% C2
```

`e1` , `e2` , `C` , `C1` , `C2` |
Objects of class |

`x` |
Scalar, length one numeric vector |

`drop` |
Boolean, with default |

The function `Ops.clifford()`

passes unary and binary arithmetic
operators “`+`

”, “`-`

”, “`*`

”,
“`/`

” and “`^`

” to the appropriate specialist
function. Function `maxyterm()`

returns the maximum index in the
terms of its arguments.

The package has several binary operators:

Geometric product | `A*B = geoprod(A,B)` | \(\displaystyle AB=\sum_{r,s}\left\langle A\right\rangle_r\left\langle B\right\rangle_s\) |

Inner product | `A %.% B = cliffdotprod(A,B)` | \(\displaystyle A\cdot B=\sum_{r\neq 0\atop s\ne 0}^{\vphantom{s\neq 0}}\left\langle\left\langle A\right\rangle_r\left\langle B\right\rangle_s\right\rangle_{\left|s-r\right|}\) |

Outer product | `A %^% B = wedge(A,B)` | \(\displaystyle A\wedge B=\sum_{r,s}\left\langle\left\langle A\right\rangle_r\left\langle B\right\rangle_s\right\rangle_{s+r}\) |

Fat dot product | `A %o% B = fatdot(A,B)` | \(\displaystyle A\bullet B=\sum_{r,s}\left\langle\left\langle A\right\rangle_r\left\langle B\right\rangle_s\right\rangle_{\left|s-r\right|}\) |

Left contraction | `A %_|% B = lefttick(A,B)` | \(\displaystyle A\rfloor B=\sum_{r,s}\left\langle\left\langle A\right\rangle_r\left\langle B\right\rangle_s\right\rangle_{s-r}\) |

Right contraction | `A %|_% B = righttick(A,B)` | \(\displaystyle A\lfloor B=\sum_{r,s}\left\langle\left\langle A\right\rangle_r\left\langle B\right\rangle_s\right\rangle_{r-s}\) |

Cross product | `A %X% B = cross(A,B)` | \(\displaystyle A\times B=\frac{1}{2_{\vphantom{j}}}\left(AB-BA\right)\) |

Scalar product | `A %star% B = star(A,B)` | \(\displaystyle A\ast B=\sum_{r,s}\left\langle\left\langle A\right\rangle_r\left\langle B\right\rangle_s\right\rangle_0\) |

Euclidean product | `A %euc% B = eucprod(A,B)` | \(\displaystyle A\star B= A\ast B^\dagger\) |

In R idiom, the geometric product `geoprod(.,.)`

has to be
indicated with a “`*`

” (as in `A*B`

) and so the
binary operator must be `%*%`

: we need a different idiom for
scalar product, which is why `%star%`

is used.

Because geometric product is often denoted by juxtaposition, package
idiom includes `a % % b`

for geometric product.

Binary operator `%dot%`

is a synonym for `%.%`

, which
causes problems for rmarkdown.

Function `clifford_inverse()`

returns an inverse for nonnull
Clifford objects \(Cl(p,q)\) for \(p+q\leq 5\), and
a few other special cases. The functionality is problematic as
nonnull blades always have an inverse; but function `is.blade()`

is not yet implemented. Blades (including null blades) have a
pseudoinverse, but this is not implemented yet either.

The scalar product of two clifford objects is defined as the zero-grade component of their geometric product:

\[ A\ast B=\left\langle AB\right\rangle_0\qquad{\mbox{NB: notation used by both Perwass and Hestenes}} \]In package idiom the scalar product is given by `A %star% B`

or
`scalprod(A,B)`

. Hestenes and Perwass both use an asterisk for
scalar product as in “\(A*B\)”, but in package idiom, the
asterisk is reserved for geometric product.

**Note: in the package, A*B is the geometric product**.

The Euclidean product (or Euclidean scalar product) of two clifford objects is defined as

\[ A\star B= A\ast B^\dagger= \left\langle AB^\dagger\right\rangle_0\qquad{\mbox{Perwass}} \]where \(B^\dagger\) denotes Conjugate [as in `Conj(a)`

]. In
package idiom the Euclidean scalar product is given by
`eucprod(A,B)`

or `A %euc% B`

, both of which return
`A * Conj(B)`

.

Note that the scalar product \(A\ast A\) can be positive or
negative [that is, `A %star% A`

may be any sign], but the
Euclidean product is guaranteed to be non-negative [that is, ```
A
%euc% A
```

is always positive or zero].

Dorst defines the left and right contraction (Chisholm calls these the left and right inner product) as \(A\rfloor B\) and \(A\lfloor B\). See the vignette for more details.

Division, as in idiom `x/y`

, is defined as
`x*clifford_inverse(y)`

. Function `clifford_inverse()`

uses
the method set out by Hitzer and Sangwine but is limited to
\(p+q\leq 5\).

Many of the functions documented here use low-level helper functions
that wrap C code. For example, `fatdot()`

uses
`c_fatdotprod()`

. These are documented at `lowlevel.Rd`

.

The high-level functions documented here return a `clifford`

object. The low-level functions are not really intended for the
end-user.

In the clifford package the caret “`^`

” is reserved
for multiplicative powers, as in `A^3=A*A*A`

. All the different
Clifford products have binary operators for convenience including the
wedge product `%^%`

. Compare the stokes package, where
multiplicative powers do not really make sense and `A^B`

is
interpreted as a wedge product of differential forms \(A\) and
\(B\). In stokes, the wedge product is the *sine qua
non* for the whole package and needs a terse idiomatic representation
(although there `A%^%B`

returns the wedge product too).

Robin K. S. Hankin

E. Hitzer and S. Sangwine 2017. “Multivector and multivector
matrix inverses in real Clifford algebras”. *Applied Mathematics
and Computation* 311:375-389

```
u <- rcliff(5)
v <- rcliff(5)
w <- rcliff(5)
u
v
u*v
u+(v+w) == (u+v)+w # should be TRUE by associativity of "+"
u*(v*w) == (u*v)*w # should be TRUE by associativity of "*"
u*(v+w) == u*v + u*w # should be TRUE by distributivity
# Now if x,y are _vectors_ we have:
x <- as.1vector(sample(5))
y <- as.1vector(sample(5))
x*y == x%.%y + x%^%y
x %^% y == x %^% (y + 3*x)
x %^% y == (x*y-x*y)/2 # should be TRUE
# above are TRUE for x,y vectors (but not for multivectors, in general)
## Inner product "%.%" is not associative:
x <- rcliff(5,g=2)
y <- rcliff(5,g=2)
z <- rcliff(5,g=2)
x %.% (y %.% z) == (x %.% y) %.% z
## Other products should work as expected:
x %|_% y ## left contraction
x %_|% y ## right contraction
x %o% y ## fat dot product
```

[Package *clifford* version 1.0-8 Index]