This is an alternative site for discovering Elm packages.
You may be looking for the
official Elm package site
instead.

Vector and matrix library for 3D and 2D math

version | 1.0.6 |

license | BSD3 |

native-modules | False |

elm-version | 0.18.0 <= v < 0.19.0 |

Tag | 1.0.6 |

Committed At | 2018-04-08 14:02:58 UTC |

elm-lang/core | 5.0.0 <= v < 6.0.0 | 5.1.1 |

This library provides functions for working with 2D and 3D vectors. It includes standard vector and matrix math operations, transformations and camera projections.

Despite being named webgl-math, you can't directly use the types from this library with webgl. If you want to use this library with webgl, you need to convert these types with this library (not published yet, as it is a native library).

The library is organised in `VectorN`

and `MatrixN`

modules.

Each module contains a more general type (`VecN a or MatN a`

) with a limited set of functions to work with them and a specialized type (`FloatN or FloatNxN`

) that only works with `Float`

s with many functions to work with them.
All these types are just type aliases for tuples.

All modules and types:

```
import Vector2 as V2 exposing (Vec2, Float2)
import Vector3 as V3 exposing (Vec3, Float3)
import Vector4 as V4 exposing (Vec4, Float4)
import Matrix2 as M2 exposing (Mat2, Float2x2)
import Matrix3 as M3 exposing (Mat3, Float3x3)
import Matrix4 as M4 exposing (Mat4, Float4x4)
```

```
aVector : Float4
aVector =
(12, 2, 4, 1)
aMatrix : Float4x4
aMatrix =
( (2, 0, 0, 2)
, (0, 2, 0, 1)
, (0, 0, 2, 3)
, (0, 0, 0, 1)
)
transformedVector : Float4
transformedVector =
M4.mulVector aMatrix aVector -- result: (26, 5, 11, 1)
--
-- The same, but much easier:
--
transformedVector2 =
let
transform =
M4.makeTranslate ( 2, 1, 3 )
|> M4.scale ( 2, 2, 2 )
in
( 12, 2, 4 )
|> M4.transform transform -- result: (26, 5, 11)
```

In the documentation, instead of code samples I sometimes use ascii math notation, as it is more compact.

```
|a b| |x|
A = |c d|*|y|
```

Would be

```
ma = mulVector ((a,b),(c,d)) (x,y)
```

in Elm.

Generally, `a, b, c, ...`

and `x, y, z`

are usually **scalar** values.

`v, w`

are usually **vectors**.

`A, B, C, ..`

are usually **matrices**, `S, T, R`

are **scale**, **translate** and **rotation** matrices.

This is meant as a replacement for **elm-community/elm-linear-algebra**.

- It's not written in elm.
`Vec`

/`Mat`

are opaque types:- A vector type shouldn't be opaque, as it doesn't hide any complexity. A vector/matrix type should be as fundamental as a list. That's why I made my types to just be aliases for tuples.
- It should be possible to create vector/matrix literals. Tuples allow for that.
- It should be possible to easily extract elements from a vector/matrix. With
*elm-community/elm-linear-algebra*s implementation you have to make use of`toTuple`

/`fromTuple`

very often.

- Missing functions from elm-community:
- There is no
`Mat2`

/`Mat3`

type.`Mat3`

is very useful for 2d games. - There is no way to construct a matrix by specifying each element.
- Matrix addition, element wise multiplication and matrix-vector multiplication is missing.

- There is no

This needs to be explored more, but first results look very promising.
Matrix multiplication is just as fast as in *elm-community/elm-linear-algebra* and some more complicated examples are much faster because we can directly construct matrices.

Run the benchmark for yourself!

Here/src

My library seems to be slightly faster on Chrome, much faster on Firefox, faster on Edge, and slightly slower on Safari. If your results are completely different, please post them here.