This is a `playground`

to test code. It runs a full `Node.js`

environment and already has all of `npm`

’s 400,000 packages pre-installed, including `@nphyx/vectrix`

with all `npm`

packages installed. **Try it out**:

var vectrix = require("@nphyx/vectrix")

- all documents on RunKit are public
`require()`

any package directly from npm- use arrow functions, classes, template strings, and most of ES6
`await`

any promise instead of using callbacks (example)- create your own embedded
**node.js**snippets

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

Vectrix is a matrix math library for javascript aimed at allowing the developer to make conscious tradeoffs between performance, flexibility, and expressiveness. Compared to alternatives, it is:

- more expressive and generalized than gl-matrix, but around 1.25 to 10x slower depending on operation and usage
- less general and less powerful than Math.js but easier to use and up to 30x faster

Vectrix is still a work in progress and is not recommended for production.

Vectrix supports commonjs modules:

```
const matrices = require("dist/vectrix.js").matrices;
const vectors = require("dist/vectrix.js").vectors;
const quaternions = require("dist/vectrix.js").quaternions;
```

It also supports ES6 modules, via the babel preprocessor

```
import {matrices, vectors, quaternions} from "src/vectrix";
```

Create vectors:

```
let xy = vectors.create.vec2(0,1); // 2d vector
let xyz = vectors.create.vec3(1,0,1); // 3d vector
let xyzw = vectors.create.vec4(1,0,0,1); // 4d vector
```

Create matrices:

```
let xyz = vectors.create.vec3(4,3,11);
let trans = matrices.create.translation(xyz); // a translation matrix
let rotX = matrices.create.rotateX(3.24); // a rotation matrix (angle in radians)
```

Create quaternions:

```
let q = quaternions.create.identity(); // quaternion(1.0,1.0,1.0,0.0);
```

Vectrix uses a functional style:

```
// add something to xy
vectors.plus(xy, [7,3]); // vec2(7,4)
// find the dot product of two vectors
vectors.dot(xy, [6,3]); // 3
// do a linear interpolation
vectors.lerp(xy, [4,5], 0.3); // vec2(1.2000000476837158, 2.200000047683716)
// multiply a vector by a rotation matrix to rotate it
vectors.dot(rotX, xyz); // vec3(-3.6859018802642822,-3.3784799575805664,11)
```

It doesn't mutate its operands:

```
vectors.plus(xy, [7,3]); // vec2(7,4)
xy; // vec2(0,1)
```

... except when you ask it to:

```
vectors.mut_plus(xy, [7,3]);
xy; // vec2(7,4)
```

... and it supports optional out parameters if you need to save on memory and garbage collection:

```
let out = vectors.create.vec2();
vectors.plus(xy, [7,3], out); // vec2(7,4)
out; // vec2(7,4)
vectors.plus(xy, [7,3], out) === out; // true
```

In fact, if you use out parameters wherever they're supported vectrix will almost *never* allocate memory, because it pre-allocates everything it needs during library initialization (and don't worry, it's a really small footprint).

Vectors, matrices, and quaternions can be wrapped as objects for more expressive usage, at the cost of performance:

```
// alternatively,
xy = vectors.wrap(xy);
xy.plus([7,3]).toArray(); // [7,4]
// wrapped objects also support GLSL-style aliases:
xy.yx; // vec2(1,0);
```

When performance really matters, use the functional style with out parameters. When you need it to be easier to reason about and manipulate, the object oriented wrappers are helpful.

See the wiki for complete documentation*

**currently out of date, sorry*

```
npm install --only=production
```

```
gulp
```

```
npm install --only=dev .
gulp test # test all modules
gulp test:vectors # only test vectors
gulp test:matrices # only test matrices
gulp test:quaterions # only test quaternions
gulp test:coverage # run a coverage test with istanbul, lcov reports go in /coverage
```

MIT

- package on npmhttps://npmjs.com/package/@nphyx/vectrix
- licenseMIT

RunKit is a free, in-browser JavaScript dev environment for prototyping **Node.js** code, with every **npm** package installed. Sign up to share your code.

Sign Up for Free