141 lines
3.9 KiB
JavaScript
141 lines
3.9 KiB
JavaScript
import { expect } from 'chai';
|
|
import { Vector } from '../src';
|
|
import { asDiagram } from './_as-diagram';
|
|
|
|
describe('vector', () => {
|
|
const x = new Vector([3, 4]);
|
|
|
|
asDiagram('Vector.magnitude').it(expectCall => {
|
|
expectCall(x).magnitude().to.equal(5);
|
|
});
|
|
|
|
asDiagram('Vector.e').it(expectCall => {
|
|
expectCall(x).e(0).to.be.null;
|
|
expectCall(x).e(1).to.equal(3);
|
|
expectCall(x).e(3).to.be.null;
|
|
});
|
|
|
|
asDiagram('Vector.toUnitVector').it(expectCall => {
|
|
expectCall(x).toUnitVector().to.vector.equal([0.6, 0.8]);
|
|
expectCall(new Vector([0, 0])).toUnitVector().to.vector.equal([0, 0]);
|
|
});
|
|
|
|
asDiagram('Vector.dimensions').it(expectCall => {
|
|
expectCall(x).dimensions().to.deep.equal({ rows: 1, cols: 2 });
|
|
});
|
|
|
|
asDiagram('Vector.rows').it(expectCall => {
|
|
expectCall(x).rows().to.equal(1);
|
|
});
|
|
|
|
asDiagram('Vector.cols').it(expectCall => {
|
|
expectCall(x).cols().to.equal(2);
|
|
});
|
|
|
|
asDiagram('Vector.product').it(expectCall => {
|
|
expectCall(x).product().to.equal(12);
|
|
});
|
|
|
|
asDiagram('Vector.eql').it(expectCall => {
|
|
expectCall(x).eql([3, 4]).to.be.true;
|
|
expectCall(x).eql([5, 6]).to.be.false;
|
|
});
|
|
|
|
asDiagram('Vector.angleFrom').it(expectCall => {
|
|
expectCall(new Vector([1, 1]))
|
|
.angleFrom(new Vector([1, 0]))
|
|
.to.approx.equal(Math.PI / 4);
|
|
});
|
|
|
|
it('Vector.map', () => {
|
|
expect(x.map(y => y * 2)).to.vector.equal([6, 8]);
|
|
expect(x.map((y, i) => i)).to.vector.equal([1, 2]);
|
|
});
|
|
|
|
it('Vector.each', () => {
|
|
let sum = 0;
|
|
x.each(y => {
|
|
sum += y;
|
|
});
|
|
expect(sum).to.equal(7);
|
|
});
|
|
|
|
asDiagram('Vector.isParallelTo').it(expectCall => {
|
|
expectCall(x).isParallelTo(new Vector([6, 8])).to.be.true;
|
|
expectCall(x).isParallelTo(new Vector([1, 1])).to.be.false;
|
|
});
|
|
|
|
asDiagram('Vector.isAntiparallelTo').it(expectCall => {
|
|
expectCall(x).isAntiparallelTo(new Vector([-3, -4])).to.be.true;
|
|
expectCall(x).isAntiparallelTo(x).to.be.false;
|
|
});
|
|
|
|
asDiagram('Vector.isPerpendicularTo').it(expectCall => {
|
|
expectCall(x).isPerpendicularTo(new Vector([-4, 3])).to.be.true;
|
|
expectCall(x).isPerpendicularTo(x).to.be.false;
|
|
});
|
|
|
|
asDiagram('Vector.dot').it(expectCall => {
|
|
expectCall(x).dot(new Vector([2, 3])).to.equal(18);
|
|
});
|
|
|
|
asDiagram('Vector.add').it(expectCall => {
|
|
expectCall(x).add(2).to.vector.equal([5, 6]);
|
|
expectCall(x).add([3, 2]).to.vector.equal([6, 6]);
|
|
});
|
|
|
|
asDiagram('Vector.subtract').it(expectCall => {
|
|
expectCall(x).subtract(2).to.vector.equal([1, 2]);
|
|
expectCall(x).subtract([3, 2]).to.vector.equal([0, 2]);
|
|
});
|
|
|
|
asDiagram('Vector.multiply').it(expectCall => {
|
|
expectCall(x).multiply(2).to.vector.equal([6, 8]);
|
|
expectCall(x).multiply([3, 2]).to.vector.equal([9, 8]);
|
|
});
|
|
|
|
asDiagram('Vector.sum').it(expectCall => {
|
|
expectCall(x).sum().to.equal(7);
|
|
});
|
|
|
|
asDiagram('Vector.chomp').it(expectCall => {
|
|
expectCall(x).chomp(1).to.vector.equal([4]);
|
|
});
|
|
|
|
asDiagram('Vector.top').it(expectCall => {
|
|
expectCall(x).top(1).to.vector.equal([3]);
|
|
});
|
|
|
|
asDiagram('Vector.augment').it(expectCall => {
|
|
expectCall(x).augment(new Vector([5])).to.vector.equal([3, 4, 5]);
|
|
});
|
|
|
|
it('should log', () => {
|
|
expect(x.log()).to.vector.equal([1.0986122886681098, 1.386294361119890]);
|
|
});
|
|
|
|
it('should support removal of head positions', () => {
|
|
expect(x.chomp(1)).to.vector.equal([4]);
|
|
});
|
|
|
|
it('should sum', () => {
|
|
expect(x.sum()).to.equal(7);
|
|
});
|
|
|
|
it('should support addition of elements on the right side', () => {
|
|
// expect(x.augment([4, 5])).to.vector.equal([1, 2, 3, 4, 5]);
|
|
});
|
|
|
|
it('show allow for scalar addition', () => {
|
|
const a = new Vector([2, 3, 4]);
|
|
const b = a.add(1);
|
|
expect(b).to.vector.equal([3, 4, 5]);
|
|
});
|
|
|
|
it('show add', () => {
|
|
const a = new Vector([2, 3, 4]);
|
|
const b = a.add(new Vector([2, 4, 8]));
|
|
expect(b).to.vector.equal([undefined, 7, 12]);
|
|
});
|
|
});
|