Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
785 lines (607 sloc) 13.1 KB

TOC

geom

vec

make

make().

vec.make().should.eql([0,0])
vec.make().should.be.length(2)

make({x:5,y:5}).

vec.make({x:5,y:5}).should.eql([5,5])

make([5,5]).

vec.make([5,5]).should.eql([5,5])

make(5,5).

vec.make(5,5).should.eql([5,5])

v(5,5).

v(5,5).should.eql([5,5])

alloc

alloc().

var v = vec.alloc()
v.should.eql([0,0])

alloc() * 10000.

var a = vec._allocated.length - vec._unallocated.length;
for(var i=0; i<10000; i++){
  var v = vec.alloc()
  v.should.eql([0,0])
  allocated.push(v);
}
var b = vec._allocated.length - vec._unallocated.length;
(b-a).should.equal(allocated.length)

for(var i=0; i < vec._unallocated.length; i++)
  vec._unallocated.should.have.property(i).eql([0,0]);

free

free(allocated).

var a = vec._allocated.length - vec._unallocated.length;
var l = allocated.length;
while(allocated.length)
  vec.free(allocated.pop())
var b = vec._allocated.length - vec._unallocated.length;
(b-a).should.equal(-l)

for(var i=0; i < vec._unallocated.length; i++)
  vec._unallocated.should.have.property(i).eql([0,0]);

free(v).

var v = vec.alloc();
v.should.eql([0,0])
vec.free(v);

copy

copy(v).

vec.copy(v).should.not.equal(v)
vec.copy(v).should.eql([1,2])

copy(v,m).

vec.copy(v,m).should.not.equal(v)
vec.copy(v,m).should.equal(m)
vec.copy(v,m).should.eql([1,2])

copy(v,v).

vec.copy(v,v).should.equal(v)
vec.copy(v,v).should.eql([1,2])

sub

sub(a,b).

vec.sub(a,b).should.not.equal(a)
vec.sub(a,b).should.not.equal(b)
vec.sub(a,b).should.eql([-2,-2])

sub(a,b,m).

vec.sub(a,b,m).should.not.equal(a)
vec.sub(a,b,m).should.not.equal(b)
vec.sub(a,b,m).should.equal(m)
vec.sub(a,b,m).should.eql([-2,-2])

sub(a,a,m).

vec.sub(a,a,m).should.equal(m)
vec.sub(a,a,m).should.not.equal(a)
vec.sub(a,a,m).should.eql([0,0])

sub(a,a).

vec.sub(a,a).should.not.equal(a)
vec.sub(a,a).should.not.equal(b)
vec.sub(a,a).should.not.equal(m)
vec.sub(a,a).should.eql([0,0])

sub(a,b,a).

vec.sub(a,b,a).should.equal(a)       // [-2,-2]
vec.sub(a,b,a).should.not.equal(b)   // [-5,-6]
vec.sub(a,b,a).should.not.equal(m)   // [-8,-10]
vec.sub(a,b,a).should.eql([-11,-14])

add

add(a,b).

vec.add(a,b).should.not.equal(a)
vec.add(a,b).should.not.equal(b)
vec.add(a,b).should.eql([4,6])

add(a,b,m).

vec.add(a,b,m).should.not.equal(a)
vec.add(a,b,m).should.not.equal(b)
vec.add(a,b,m).should.equal(m)
vec.add(a,b,m).should.eql([4,6])

add(a,a,m).

vec.add(a,a,m).should.equal(m)
vec.add(a,a,m).should.not.equal(a)
vec.add(a,a,m).should.eql([2,4])

add(a,a).

vec.add(a,a).should.not.equal(a)
vec.add(a,a).should.not.equal(b)
vec.add(a,a).should.not.equal(m)
vec.add(a,a).should.eql([2,4])

add(a,b,a).

vec.add(a,b,a).should.equal(a)       // [ 4, 6]
vec.add(a,b,a).should.not.equal(b)   // [ 7,10]
vec.add(a,b,a).should.not.equal(m)   // [10,14]
vec.add(a,b,a).should.eql([13,18])

mul

mul(a,b).

vec.mul(a,b).should.not.equal(a)
vec.mul(a,b).should.not.equal(b)
vec.mul(a,b).should.eql([3,8])

mul(a,b,m).

vec.mul(a,b,m).should.not.equal(a)
vec.mul(a,b,m).should.not.equal(b)
vec.mul(a,b,m).should.equal(m)
vec.mul(a,b,m).should.eql([3,8])

mul(a,a,m).

vec.mul(a,a,m).should.equal(m)
vec.mul(a,a,m).should.not.equal(a)
vec.mul(a,a,m).should.eql([1,4])

mul(a,a).

vec.mul(a,a).should.not.equal(a)
vec.mul(a,a).should.not.equal(b)
vec.mul(a,a).should.not.equal(m)
vec.mul(a,a).should.eql([1,4])

mul(a,b,a).

vec.mul(a,b,a).should.equal(a)       // [ 3,  8]
vec.mul(a,b,a).should.not.equal(b)   // [ 9, 32]
vec.mul(a,b,a).should.not.equal(m)   // [27,128]
vec.mul(a,b,a).should.eql([81,512])

div

div(a,b).

vec.div(a,b).should.not.equal(a)
vec.div(a,b).should.not.equal(b)
vec.div(a,b).should.eql([1/3,2/4])

div(a,b,m).

vec.div(a,b,m).should.not.equal(a)
vec.div(a,b,m).should.not.equal(b)
vec.div(a,b,m).should.equal(m)
vec.div(a,b,m).should.eql([1/3,2/4])

div(a,a,m).

vec.div(a,a,m).should.equal(m)
vec.div(a,a,m).should.not.equal(a)
vec.div(a,a,m).should.eql([1,1])

div(a,a).

vec.div(a,a).should.not.equal(a)
vec.div(a,a).should.not.equal(b)
vec.div(a,a).should.not.equal(m)
vec.div(a,a).should.eql([1,1])

div(a,b,a).

vec.div(a,b,a).should.equal(a)       // [    1/3,     2/4]
vec.div(a,b,a).should.not.equal(b)   // [  1/3/3,   2/4/4]
vec.div(a,b,a).should.not.equal(m)   // [1/3/3/3, 2/4/4/4]
vec.div(a,b,a).should.eql([1/3/3/3/3,2/4/4/4/4])

abs

abs(a).

vec.abs(a).should.not.equal(a)
vec.abs(a).should.not.equal(m)
vec.abs(a).should.eql([1,2])

abs(a,m).

vec.abs(a,m).should.not.equal(a)
vec.abs(a,m).should.equal(m)
vec.abs(a,m).should.eql([1,2])

abs(a,a).

vec.abs(a,a).should.not.equal(m)
vec.abs(a,a).should.equal(a)
vec.abs(a,a).should.eql([1,2])

min

min(a,b).

vec.min(a,b).should.not.equal(a)
vec.min(a,b).should.not.equal(b)
vec.min(a,b).should.eql([-3,2])

min(a,b,m).

vec.min(a,b,m).should.not.equal(a)
vec.min(a,b,m).should.not.equal(b)
vec.min(a,b,m).should.equal(m)
vec.min(a,b,m).should.eql([-3,2])

min(a,a,m).

vec.min(a,a,m).should.equal(m)
vec.min(a,a,m).should.not.equal(a)
vec.min(a,a,m).should.eql([1,2])

min(a,a).

vec.min(a,a).should.not.equal(a)
vec.min(a,a).should.not.equal(b)
vec.min(a,a).should.not.equal(m)
vec.min(a,a).should.eql([1,2])

min(a,b,a).

vec.min(a,b,a).should.equal(a)       // [-3,2]
vec.min(a,b,a).should.not.equal(b)   // [-3,2]
vec.min(a,b,a).should.not.equal(m)   // [-3,2]
vec.min(a,b,a).should.eql([-3,2])

max

max(a,b).

vec.max(a,b).should.not.equal(a)
vec.max(a,b).should.not.equal(b)
vec.max(a,b).should.eql([1,4])

max(a,b,m).

vec.max(a,b,m).should.not.equal(a)
vec.max(a,b,m).should.not.equal(b)
vec.max(a,b,m).should.equal(m)
vec.max(a,b,m).should.eql([1,4])

max(a,a,m).

vec.max(a,a,m).should.equal(m)
vec.max(a,a,m).should.not.equal(a)
vec.max(a,a,m).should.eql([1,2])

max(a,a).

vec.max(a,a).should.not.equal(a)
vec.max(a,a).should.not.equal(b)
vec.max(a,a).should.not.equal(m)
vec.max(a,a).should.eql([1,2])

max(a,b,a).

vec.max(a,b,a).should.equal(a)       // [1,4]
vec.max(a,b,a).should.not.equal(b)   // [1,4]
vec.max(a,b,a).should.not.equal(m)   // [1,4]
vec.max(a,b,a).should.eql([1,4])

neg

neg(a).

vec.neg(a).should.not.equal(a)
vec.neg(a).should.not.equal(m)
vec.neg(a).should.eql([-1,2])

neg(a,m).

vec.neg(a,m).should.not.equal(a)
vec.neg(a,m).should.equal(m)
vec.neg(a,m).should.eql([-1,2])

neg(a,a).

vec.neg(a,a).should.not.equal(m) // [-1, 2]
vec.neg(a,a).should.equal(a)     // [1, -2]
vec.neg(a,a).should.eql([-1,2])

clamp

clamp(min,a,max).

vec.clamp(min,a,max).should.not.equal(a)
vec.clamp(min,a,max).should.not.equal(b)
vec.clamp(min,a,max).should.not.equal(m)
vec.clamp(min,a,max).should.not.equal(min)
vec.clamp(min,a,max).should.not.equal(max)
vec.clamp(min,a,max).should.eql([5,-5])

clamp(min,b,max).

vec.clamp(min,b,max).should.not.equal(a)
vec.clamp(min,b,max).should.not.equal(b)
vec.clamp(min,b,max).should.not.equal(m)
vec.clamp(min,b,max).should.not.equal(min)
vec.clamp(min,b,max).should.not.equal(max)
vec.clamp(min,b,max).should.eql([1,-2])

clamp(min,a,max,m).

vec.clamp(min,a,max,m).should.not.equal(a)
vec.clamp(min,a,max,m).should.not.equal(b)
vec.clamp(min,a,max,m).should.not.equal(min)
vec.clamp(min,a,max,m).should.not.equal(max)
vec.clamp(min,a,max,m).should.equal(m)
vec.clamp(min,a,max,m).should.eql([5,-5])

clamp(min,a,max,a).

vec.clamp(min,a,max,a).should.equal(a)
vec.clamp(min,a,max,a).should.not.equal(b)
vec.clamp(min,a,max,a).should.not.equal(m)
vec.clamp(min,a,max,a).should.not.equal(min)
vec.clamp(min,a,max,a).should.not.equal(max)
vec.clamp(min,a,max,a).should.eql([5,-5])

perp

perp(a).

vec.perp(a).should.not.equal(a)
vec.perp(a).should.not.equal(m)
vec.perp(a).should.eql([2,1])

perp(a,m).

vec.perp(a,m).should.not.equal(a)
vec.perp(a,m).should.equal(m)
vec.perp(a,m).should.eql([2,1])

perp(a,a).

vec.perp(a,a).should.not.equal(m) // [ 2,1]
vec.perp(a,a).should.equal(a)     // [-1,2]
vec.perp(a,a).should.eql([-2,-1])

cross

cross(a,b).

vec.cross(a,b).should.equal(-5)

cross(a,a).

vec.cross(a,a).should.equal(0)

dot

dot(a,b).

vec.dot(a,b).should.equal(3)

dot(a,a).

vec.dot(a,a).should.equal(1)

dot(perp(a),b) == cross(a,b).

vec.dot(vec.perp(a),b).should.eql(vec.cross(a,b))

len

len(a).

vec.len(a).should.equal(1)

len(b).

vec.len(b).should.equal(5.830951894845301)

len(c).

vec.len(c).should.equal(0)

lenSq

lenSq(a).

vec.lenSq(a).should.equal(1)

lenSq(b).

vec.lenSq(b).should.equal(34)

lenSq(c).

vec.lenSq(c).should.equal(0)

dist

dist(a,b).

vec.dist(a,b).should.equal(5.385164807134504)

dist(b,b).

vec.dist(b,b).should.equal(0)

distSq

distSq(a,b).

vec.distSq(a,b).should.equal(29)

distSq(b,b).

vec.distSq(b,b).should.equal(0)

norm

norm(a).

vec.norm(a).should.not.equal(a)
vec.norm(a).should.not.equal(m)
vec.norm(a).should.eql([1,0])

norm(b).

var l = vec.len(b);
vec.norm(b).should.not.equal(a)
vec.norm(b).should.not.equal(b)
vec.norm(b).should.not.equal(m)
vec.norm(b).should.eql([3/l,-5/l])

norm(a,m).

vec.norm(a,m).should.not.equal(a)
vec.norm(a,m).should.equal(m)
vec.norm(a,m).should.eql([1,0])

norm(a,a).

vec.norm(a,a).should.not.equal(m) // [1,0]
vec.norm(a,a).should.equal(a)     // [1,0]
vec.norm(a,a).should.eql([1,0])

lerp

lerp(a,b,0).

vec.lerp(a,b,0).should.not.equal(a)
vec.lerp(a,b,0).should.not.equal(b)
vec.lerp(a,b,0).should.eql(a)
vec.lerp(a,b,0).should.not.eql(b)

lerp(a,b,1).

vec.lerp(a,b,1).should.eql(b)
vec.lerp(a,b,1).should.not.eql(a)

lerp(a,b,.5).

vec.lerp(a,b,.5).should.not.eql(a)
vec.lerp(a,b,.5).should.not.eql(b)
vec.lerp(a,b,.5).should.eql([2,-2.5])

lerp(a,b,-1).

vec.lerp(a,b,-1).should.not.eql(a)
vec.lerp(a,b,-1).should.not.eql(b)
vec.lerp(a,b,-1).should.eql([-1,5])

lerp(a,b,2).

vec.lerp(a,b,2).should.not.eql(a)
vec.lerp(a,b,2).should.not.eql(b)
vec.lerp(a,b,2).should.eql([5,-10])

rot

rot(a,Math.PI*2).

vec.rot(a,Math.PI*2).should.not.equal(a)
vec.rot(a,Math.PI*2).should.eql(a) // 360!

rot(a,Math.PI).

vec.rot(a,Math.PI).should.not.equal(a)
vec.rot(a,Math.PI).should.eql([-5,-5])

rot(a,-Math.PI,m).

vec.rot(a,-Math.PI,m).should.not.equal(a)
vec.rot(a,-Math.PI,m).should.equal(m)
vec.rot(a,-Math.PI,m).should.eql([-5,-5])

rot(a,Math.PI/2,a).

vec.rot(a,Math.PI/2,a).should.equal(a)
vec.rot(a,Math.PI/2,a).should.not.equal(m)
vec.rot(a,Math.PI/2,a).should.eql([-5,-5])

rot(a,Math.PI) (around origin).

var a = vec.make(5,5)
var o = vec.make(10,10);
var t = vec.sub(a,o)
vec.rot(t,Math.PI,t)
vec.add(o,t).should.not.equal(a)
vec.add(o,t).should.not.equal(t)
vec.add(o,t).should.not.equal(o)
vec.add(o,t).should.not.eql(o)
vec.add(o,t).should.not.eql(t)
vec.add(o,t).should.not.eql(a)
vec.add(o,t).should.eql([15,15])

transform

transform(a,mat.rotate(Math.PI)).

vec.transform(a,mat.rotate(Math.PI)).should.eql(vec.rot(a,Math.PI))

transform(a,mat.scale(5,0)).

vec.transform(a,mat.scale(5,0)).should.eql(vec.mul(a,[5,0]))

transform(a,mat.translate(0,5)).

vec.transform(a,mat.translate(-5,10)).should.eql(vec.add(a,[-5,10]))

reflect