Grassmann algebra, Clifford algebra, and conformal geometric algebra are powerful algebraic tools
To help bring conformal geometric algebra to julia, the Grassmann
library now provides most of the basic tools needed to begin working with a fully generalized MultiVector
algebra.
This package is a work in progress providing the necessary tools to work with arbitrary dual MultiVector
elements with optional origin. Due to the parametric type system for the generating VectorSpace
, the Julia compiler can fully preallocate and often cache values efficiently. Both static and mutable vector types are supported.
It is currently possible to do both high-performance numerical computations with Grassmann
and it is also currently possible to use symbolic scalar coefficients when the Reduce
package is also loaded.
Fully general products available for high-performance and sparse computation include ∧,∨,⋅,*
(exterior, regressive, interior, geometric). Some unary operations include complementleft
, complementright
, reverse
, involve
, conj
, and adjoint
.
Notable features
What’s particularly special about Grassmann
is its ability to handle caching and code generation in a tiered multi-stage setup and the ability to easily handle the creation of extra specialized methods to replace composite or dynamic dispatch scenarios with more efficient code.
This can work up to N=62
indices in the VectorSpace
, reaching a 4,611,686,018,427,387,904
dimensional TensorAlgebra
space, which is much beyond what Julia arrays can handle natively.
julia> using Grassmann
julia> i,j,k = complementright.((-Λ(3).v1,-Λ(3).v2,-Λ(3).v3))
(-1v₂₃, 1v₁₃, -1v₁₂)
julia> @btime i^2, j^2, k^2, i*j*k
158.925 ns (5 allocations: 112 bytes)
(-1v, -1v, -1v, -1v)
julia> @btime -(j+k) * (j+k)
176.233 ns (8 allocations: 240 bytes)
2
julia> @btime -(j+k) * i
111.394 ns (6 allocations: 192 bytes)
0 - 1v₁₂ - 1v₁₃
The Grassmann
package is fully general, and includes number systems such as quaternions 1,i,j,k
.
Design, code generation
Due to the abstract generality of the product algebra code generation, it is possible to extend the Grassmann
library to include additional high performance products with few extra definitions. Operations on ultra-sparse representations for very high dimensional algebras will be gaining further performance enhancements in future updates, while the standard lower dimensional algebras already are highly performant and optimized. Thanks to the design of the product algebra code generation, any additional optimizations to the type stability will automatically enhance all the different products simultaneously. Likewise, any new product formulas will be able to quickly gain from the setup of all of the existing optimizations.
Calculating some bivectors
There are are a variety of resources online which help with the introduction to the subject. One notable video useful for just about anybody interested in geometric algebra was posted by @waldyrious
Some of the examples in that video can be verified using Reduce, Grassmann
in julia
julia> using Reduce,Grassmann; basis"4"
Reduce (Free CSL version, revision 4590), 11-May-18 ...
(⟨++++⟩, v, v₁, v₂, v₃, v₄, v₁₂, v₁₃, v₁₄, v₂₃, v₂₄, v₃₄, v₁₂₃, v₁₂₄, v₁₃₄, v₂₃₄, v₁₂₃₄)
julia> P,Q = :px*v1 + :py*v2 + :pz* v3 + v4, :qx*v1 + :qy*v2 + :qz*v3 + v4
(pxv₁ + pyv₂ + pzv₃ + 1.0v₄, qxv₁ + qyv₂ + qzv₃ + 1.0v₄)
julia> P∧Q
0.0 + (px * qy - py * qx)v₁₂ + (px * qz - pz * qx)v₁₃ + (px - qx)v₁₄ + (py * qz - pz * qy)v₂₃ + (py - qy)v₂₄ + (pz - qz)v₃₄
julia> R = :rx*v1 + :ry*v2 + :rz*v3 + v4
rxv₁ + ryv₂ + rzv₃ + 1.0v₄
julia> P∧Q∧R
0.0 + ((px * qy - py * qx) * rz - ((px * qz - pz * qx) * ry - (py * qz - pz * qy) * rx))v₁₂₃ + (((px * qy - py * qx) + (py - qy) * rx) - (px - qx) * ry)v₁₂₄ + (((px * qz - pz * qx) + (pz - qz) * rx) - (px - qx) * rz)v₁₃₄ + (((py * qz - pz * qy) + (pz - qz) * ry) - (py - qy) * rz)v₂₃₄
In this example, the exterior product of points is inspected and compared with inner,cross products.
It is my hope to use absorb of the feedback from the geomtric algebra community when making ongoing improvements to help refine the package’s source code generation and sparse specialization.