Ganja.js is a Geometric Algebra code generator for javascript. It generates
Clifford algebras and sub-algebras of any signature and implements operator
overloading and algebraic constants.
(**Mathematically**, an algebra generated by ganja.js is a graded exterior (Grassmann) algebra
(or one of its subalgebras) with a non-metric outer product, extended (Clifford) with geometric and contraction inner products, a Poincare duality operator and the main
involutions and morphisms.)
(**Technically**, ganja.js is a code generator producing classes that reificate algebraic literals
and expressions by using reflection, a built-in tokenizer and a simple AST translator to
rewrite functions containing algebraic constructs to their procedural counterparts.)
(**Practically**, ganja.js enables real math syntax inside javascript, with element, vector and matrix
operations over **reals**, **complex numbers**, **dual numbers**, **hyperbolic numbers**, **vectors**, **spacetime events**, **quaternions**, **dual quaternions**, **biquaternions** or **any other Clifford Algebra**.)
(**Seriously**, look at the [examples](https://enkimute.github.io/ganja.js/examples/coffeeshop.html),
run some quick numbers using the [GAlculator](https://enkimute.github.io/ganja.js/examples/galculator.html)
or play [the wedge game](https://enkimute.github.io/ganja.js/examples/example_game_wedge.html) first.)
## Contents
[1. Reasons to use ganja](#Features)|
complex mandelbrot
|
complex least squares
|
|
dual differentiation
|
dual backpropagation
|
|
quaternion hue
|
quaternion mandelbrot
|
|
timespace lorentz
|
pga2d points and lines
|
|
pga2d distances and angles
|
pga2d project and reject
|
|
pga2d rotors and translators
|
pga2d isometries
|
|
pga2d inverse kinematics
|
pga2d separating axis
|
|
pga2d pose estimation
|
pga2d euler line
|
|
pga2d desargues theorem
|
pga2d differentiation
|
|
pga2d physics moon
|
pga2d origami
|
|
pga2d poncelet
|
pga3d points and lines
|
|
pga3d distances and angles
|
pga3d rotors and translators
|
|
pga3d icosahedron
|
pga3d sampling
|
|
pga3d slicing
|
pga3d differentiation
|
|
pga3d skinning
|
pga3d physics planets
|
|
pga3d origami
|
pga3d physics symmetric top
|
|
pga3d physics free top
|
pga3d objects
|
|
cga2d points and circles
|
cga2d project and reject
|
|
cga2d rotors and translators
|
cga2d euler line
|
|
cga3d points circles lines
|
cga3d points spheres planes
|
|
cga3d dual spheres planes
|
cga3d intersections
|
|
cga3d project reject
|
cga3d opns visualizer
|
|
cga3d opns line circle
|
cga3d json
|
|
mga3d points and lines
|
ccga3d points quadrics
|
|
qcga3d points and more
|
game wedge
|
Or - get some hands on experience with euclidian plane PGA by playing the [wedge game](https://enkimute.github.io/ganja.js/examples/example_game_wedge.html).
## Ganja for experienced users.
Ganja.js allows you to further customise the algebra class it
generates, allowing you to generate subalgebras (who's elements use
less storage), or algebra's where you decide on the order and name
of the basis blades. (the name should always be exyz but
you can pick e.g. e20 instead of the default e02
and expect ganja.js to make appropriate sign changes)
The advanced options are available by passing in an options object as
the first parameter to the *Algebra* call.
### Custom subalgebra's
```javascript
// The complex numbers as the even subalgebra of R2
C = Algebra({p:2,basis:['1','e12']});
// The Quaternions as the even subalgebra of R3
var H = Algebra({p:3,basis:['1','e12','e13','e23']});
```
### Custom basis names.
When not specified, ganja.js will generate basis names that are
grouped by rank and numerically sorted. By default, a single zero
dimension will get generator name e0. Zero dimensions come
first.
|signature|default basis names
|---|---
|2,0,0 and 1,1,0|1,e1,e2,e12
|1,0,1|1,e0,e1,e01
|3,0,0 and 2,1,0|1,e1,e2,e3,e12,e13,e23,e123
|2,0,1|1,e0,e1,e2,e01,e02,e12,e012
|4,0,0 and 3,1,0|1,e1,e2,e3,e4,e12,e13,e14,e23,e24,e34,e123,e124,e134,e234,e1234
|3,0,1|1,e0,e1,e2,e3,e01,e02,e03,e12,e13,e23,e012,e013,e023,e123,e0123
*note* the scalar part of a multivector **"mv"** can be addressed with **"mv.s"**, other basis
blades follow the expected pattern. e.g. **"mv.e12"** or **"mv.e012"**.
By default, your algebra elements will inherit from Float32Array.
You can change the underlying datatype used by ganja.js to any of the
typed array basis types :
```javascript
var R3_32 = Algebra(3);
var R3_64 = Algebra({p:3,baseType:Float64Array});
```
### Custom Cayley Table
Or take things a bit further and simply specify a Cayley table to your liking. The example below shows
automatic numerical differentiation and calculates the value, 1st, 2nd and 3rd derivative of any polynomial.
```javascript
var basis=['1','e1','e2','e3'];
var Cayley=[['1', 'e1','e2','e3'],
['e1','e2','e3', '0'],
['e2','e3', '0', '0'],
['e3', '0', '0', '0']];
Algebra({basis,Cayley},()=>{
var f = (x)=>0.25*x*x*x*x-0.5;
for (var i=-5; i<5; i++) console.log( i, f(i+1e1) );
});
```
outputs : x [f(x),f'(x),f''(x)/2!,f'''(x)/3!]
```
-5 [155.75, -125, 37.5, -5]
-4 [ 63.5, -64, 24, -4]
-3 [ 19.75, -27, 13.5, -3]
-2 [ 3.5, -8, 6, -2]
-1 [ -0.25, -1, 1.5, -1]
0 [ -0.5, 0, 0, 0]
1 [ -0.25, 1, 1.5, 1]
2 [ 3.5, 8, 6, 2]
3 [ 19.75, 27, 13.5, 3]
4 [ 63.5, 64, 24, 4]
```
### Mixed mode.
For storage and performance reasons it can be interesting to combine elements of various sub-algebras of
a given Algebra. Ganja.js supports this by setting options.mix to true when you create your algebra.
```javascript
// Create R2 - Clifford algebra of 2D vectors - indicate you want mix mode.
var R2 = Algebra({p:2,q:0,r:0,mix:true});
// Create the complex numbers as the even subalgebra of R2.
var C = Algebra({p:2,q:0,r:0,basis:['1','e12'],mix:true});
// Elements of R2 have four components.
// Create the complex number 1+4i
var a=new R2([1,0,0,4])
// Elements of C have two components.
// Create the complex number 3+2i
var b=new C([3,2]);
// They inter-operate ..
a.Mul(b); // returns an element of R2 : [-5,0,0,14]
b.Mul(a); // returns an element of C : [-5,14]
```
With the **mix** mode enabled, all operations generated by ganja.js will use basis name access
instead of array indexing. (and all operations are protected to substitute missing blades with 0).
The Inline syntax can still be used, keep in mind that in most cases you would want that to be
the inline function of the 'parent' algebra. (In the example above, use R2.Inline and not C.Inline
as the latter will reduce all your operations to the field of C).
## Ganja ingredients and syntax.
Here's a list of the supported operators in all syntax flavors :
Please note that operator precedence is as always in javaScript, except
for Wedge, Vee, Dot and Sandwich which have higher precedence than * and /,
resulting in less brackets in many common GA expressions.
|Precedence |Inline JS | AsciiMath | Object Oriented | Functional
|-----------|----------|-----------|-----------------|------------
|5 | x.Involute| tilde(x) | x.Involute | A.Involute(x)
|5 | x.Reverse| ddot(x) | x.Reverse | A.Reverse(x)
|5 | ~x | hat(x) | x.Conjugate | A.Conjugate(x)
|5 | !x | bar(x) | x.Dual | A.Dual(x)
|4 rtl | x**-1 | x^-1 | x.Inverse | A.Inverse(x)
|4 rtl | x**y | x^y | x.Pow(y) | A.Pow(x,y)
|3 | x^y | x^^y | x.Wedge(y) | A.Wedge(x,y)
|3 | x<