vectory v1.2.3

Yet another 2d vector implementation for basic motion

this.velocity.iadd(this.acceleration)
this.position.iadd(this.velocity)
this.acceleration.zero()

with rare methods such as lerp

var prev = new Vector(1, 2)
var next = new Vector(3, 4)
prev.lerp(next, 0.5) // Vector(2, 3)

and swizzling

var vector = new Vector(1 ,2)
vector.yx // Vector(2, 1)

with some ES6 support

var vector = new Vector(0, 0)
var vec3 = [...vector, 0] // [0, 0, 0]

and FP ability

// create vectors from raw data and scale them twice
var data = [[1, 2], [3, 4]/*,  ... */]
var vectors = data.map(Vector.from).map(Vector.mul.bind(null, 2))

Table of Contents

• Features
• Install
• Usage
• Support
• API
• Benchmark
• Development

Features

• Designed with performance in mind
• Simple - 371 LOC
• Lightweight - 4.5 Kb
• Well tested - 100% code coverage
• Rich api - 33 methods

Install

npm install --save vectory

import Vector from 'vectory'
var position = new Vector(0, 0)

or

<script src="https://rawgit.com/broadsw0rd/vectory/master/dist/vectory.min.js"></script>

var position = new Vector(0, 0)

Usage

Follow this link to read more about vectors' usage in the Daniel Shiffman's article

Support

• Latest Chrome, FF, Safari
• IE 9+
• Node 4+

API

Creation

• new Vector(x, y)
• Vector.from([x, y])
• Vector.fromAngle(angle, magnitude)
• Vector.parse(string)

Addition

• Vector.add(one, another)
• Vector.prototype.add(vector)
• Vector.iadd(one, another)
• Vector.prototype.iadd(vector)

Substraction

• Vector.sub(one, another)
• Vector.prototype.sub(vector)
• Vector.isub(one, another)
• Vector.prototype.isub(vector)

Multiplication

• Vector.mul(scalar, vector)
• Vector.prototype.mul(scalar)
• Vector.imul(scalar, vector)
• Vector.prototype.imul(scalar)

Division

• Vector.div(scalar, vector)
• Vector.prototype.div(scalar)
• Vector.idiv(scalar, vector)
• Vector.prototype.idiv(scalar)

Linear interpolation

• Vector.lerp(one, another, t)
• Vector.prototype.lerp(vector, t)

Normalization

• Vector.normalized(vector)
• Vector.prototype.normalized()
• Vector.normalize(vector)
• Vector.prototype.normalize()

Magnitude

• Vector.magnitude(vector)
• Vector.prototype.magnitude()

Dot product

• Vector.dot(one, another)
• Vector.prototype.dot(vector)

Distance

• Vector.distance(one, another)
• Vector.prototype.distance(vector)

Angle computing

• Vector.angleOf(vector)
• Vector.prototype.angleOf()
• Vector.angleTo(one, another)
• Vector.prototype.angleTo(vector)

Rotation

• Vector.rotate(theta, vector)
• Vector.prototype.rotate(theta)
• Vector.irotate(theta, vector)
• Vector.prototype.irotate(theta)

Resetting

• Vector.reset(one, another)
• Vector.prototype.reset(vector)
• Vector.zero(vector)
• Vector.prototype.zero()
• Vector.set(x, y, vector)
• Vector.prototype.set(x, y)

Copy

• Vector.copy(vector) (alias Vector.clone(vector))
• Vector.prototype.copy() (alias Vector.prototype.clone(vector))

Convertion

• Vector.toJSON(vector)
• Vector.prototype.toJSON()
• Vector.toString(vector)
• Vector.prototype.toString()
• Vector.prototype[Symbol.toStringTag] (Latest Chrome and FF or shim)
• Vector.toArray(vector)
• Vector.prototype.toArray()

Equality

• Vector.equals(one, another)
• Vector.protototype.equals(vector)
• Vector.compare(one, another)
• Vector.protototype.compare(vector)

Swizzling

• Vector.prototype.xx
• Vector.prototype.xy
• Vector.prototype.yx
• Vector.prototype.yy

Iterator

• Vector.prototype[Symbol.iterator]() (Latest Chrome and FF or shim)

Benchmark

Intel Core i7-7700HQ @ 2.8 GHz, DDR3 16 Gb, node v12.4.0

> vectory@1.2.3 bench D:\Projects\vectory
> node ./bench/index.js

i start benchmark, please wait a bit...

  Cteation
    √ Vector(x, y) x 861,542,389 ops/sec ±0.69% (94 runs sampled)
    √ Vector.from([x, y]) x 844,695,778 ops/sec ±1.22% (93 runs sampled)
    √ Vector.fromAngle(angle, magnitude) x 838,933,413 ops/sec ±1.43% (88 runs sampled)
    √ Vector.parse(string) x 1,510,940 ops/sec ±2.42% (86 runs sampled)

  Addition
    √ Vector.add(one, another) x 782,517,391 ops/sec ±1.27% (85 runs sampled)
    √ Vector#add(vector) x 781,789,927 ops/sec ±0.88% (87 runs sampled)
    √ Vector.iadd(one, another) x 353,879,756 ops/sec ±0.60% (89 runs sampled)
    √ Vector#iadd(vector) x 367,269,195 ops/sec ±0.64% (91 runs sampled)

  Substraction
    √ Vector.sub(one, another) x 822,718,592 ops/sec ±0.50% (95 runs sampled)
    √ Vector#sub(vector) x 808,219,928 ops/sec ±0.71% (91 runs sampled)
    √ Vector.isub(one, another) x 360,450,634 ops/sec ±0.60% (92 runs sampled)
    √ Vector#isub(vector) x 366,154,868 ops/sec ±0.43% (90 runs sampled)

  Multiplication
    √ Vector.mul(scalar, vector) x 817,965,124 ops/sec ±0.70% (91 runs sampled)
    √ Vector#mul(vector) x 808,311,011 ops/sec ±0.60% (94 runs sampled)
    √ Vector.imul(scalar, vector) x 361,688,702 ops/sec ±0.47% (90 runs sampled)
    √ Vector#imul(vector) x 357,685,548 ops/sec ±0.51% (92 runs sampled)

  Division
    √ Vector.div(scalar, vector) x 816,988,130 ops/sec ±0.43% (94 runs sampled)
    √ Vector#div(vector) x 615,974,995 ops/sec ±21.62% (69 runs sampled)
    √ Vector.idiv(scalar, vector) x 120,962,052 ops/sec ±2.20% (88 runs sampled)
    √ Vector#idiv(vector) x 118,041,377 ops/sec ±2.95% (86 runs sampled)

  Linear Interpolation
    √ Vector.lerp(one, another, t) x 776,561,727 ops/sec ±1.07% (90 runs sampled)
    √ Vector#lerp(vector, t) x 804,305,035 ops/sec ±0.92% (88 runs sampled)

  Normalization
    √ Vector.normalized(vector) x 177,230,218 ops/sec ±1.25% (93 runs sampled)
    √ Vector#normalized() x 175,674,151 ops/sec ±0.94% (89 runs sampled)
    √ Vector.normalize(vector) x 81,142,672 ops/sec ±0.45% (90 runs sampled)
    √ Vector#normalize() x 72,733,658 ops/sec ±0.81% (93 runs sampled)

  Magnitude
    √ Vector.magnitude(vector) x 862,343,311 ops/sec ±0.96% (95 runs sampled)
    √ Vector#magnitude() x 861,499,315 ops/sec ±0.88% (91 runs sampled)

  Dot Product
    √ Vector.dot(one, another) x 861,820,342 ops/sec ±0.83% (94 runs sampled)
    √ Vector#dot(vector) x 693,283,756 ops/sec ±19.13% (77 runs sampled)

  Distance
    √ Vector.distance(one, another) x 140,160,765 ops/sec ±2.67% (86 runs sampled)
    √ Vector#distance(vector) x 846,767,936 ops/sec ±0.95% (88 runs sampled)

  Angle computing
    √ Vector.angleOf(vector) x 861,986,566 ops/sec ±0.68% (89 runs sampled)
    √ Vector#angleOf() x 848,238,376 ops/sec ±0.77% (94 runs sampled)
    √ Vector.angleTo(one, another) x 768,939,821 ops/sec ±0.69% (90 runs sampled)
    √ Vector#angleTo(vector) x 796,718,879 ops/sec ±0.54% (89 runs sampled)

  Rotation
    √ Vector.rotate(theta, vector) x 831,731,143 ops/sec ±0.96% (91 runs sampled)
    √ Vector#rotate(theta) x 869,785,085 ops/sec ±0.42% (97 runs sampled)
    √ Vector.irotate(theta, vector) x 233,852,488 ops/sec ±6.66% (81 runs sampled)
    √ Vector#irotate(theta) x 118,719,502 ops/sec ±2.55% (89 runs sampled)

  Resetting
    √ Vector.reset(one, another) x 824,366,918 ops/sec ±1.40% (87 runs sampled)
    √ Vector#reset(vector) x 870,499,543 ops/sec ±0.74% (89 runs sampled)
    √ Vector.zero(vector) x 864,045,085 ops/sec ±0.91% (94 runs sampled)
    √ Vector#zero() x 872,766,394 ops/sec ±0.68% (89 runs sampled)
    √ Vector.set(x, y, vector) x 875,117,874 ops/sec ±0.45% (94 runs sampled)
    √ Vector#set(vector) x 879,133,310 ops/sec ±0.41% (95 runs sampled)

  Copy
    √ Vector.copy(vector) x 857,718,468 ops/sec ±0.59% (94 runs sampled)
    √ Vector#copy() x 860,378,542 ops/sec ±0.73% (94 runs sampled)

  Convertion
    √ Vector.toJSON(vector) x 474,395,813 ops/sec ±27.90% (55 runs sampled)
    √ Vector#toJSON() x 142,701,054 ops/sec ±2.75% (85 runs sampled)
    √ Vector.toString(vector) x 2,119,735 ops/sec ±0.49% (94 runs sampled)
    √ Vector#toString() x 2,194,938 ops/sec ±0.41% (96 runs sampled)
    √ Vector.toArray(vector) x 861,049,656 ops/sec ±0.72% (94 runs sampled)
    √ Vector#toArray() x 851,493,627 ops/sec ±0.57% (91 runs sampled)

  Equality
    √ Vector.equals(one, another) x 186,961,843 ops/sec ±0.23% (91 runs sampled)
    √ Vector#equals(vector) x 182,172,457 ops/sec ±0.58% (93 runs sampled)
    √ Vector.compare(one, another) x 857,370,215 ops/sec ±0.70% (94 runs sampled)
    √ Vector#compare(vector) x 879,521,174 ops/sec ±0.41% (95 runs sampled)

  Swizzling
    √ Vector#xx get x 872,462,026 ops/sec ±0.49% (95 runs sampled)
    √ Vector#xx set x 851,739,979 ops/sec ±0.82% (92 runs sampled)
    √ Vector#xy get x 796,653,570 ops/sec ±18.91% (89 runs sampled)
    √ Vector#xy set x 137,242,036 ops/sec ±2.91% (86 runs sampled)
    √ Vector#yx get x 869,334,030 ops/sec ±0.48% (94 runs sampled)
    √ Vector#yx set x 857,707,815 ops/sec ±0.62% (91 runs sampled)
    √ Vector#yy get x 871,330,173 ops/sec ±0.43% (93 runs sampled)
    √ Vector#yy set x 877,637,098 ops/sec ±0.40% (94 runs sampled)

  Iterator
    √ Spread operator x 7,353,650 ops/sec ±1.96% (90 runs sampled)
    √ for..of loop x 49,734,482 ops/sec ±0.63% (91 runs sampled)

Development