fn('a', 'b').should.equal('a*b')
fn(A.lone, A.S).should.equal('*a')
fn(A.lone, A.V).should.deep.equal(['*1', '*2', '*3'])
fn(A.lone, A.M).should.deep.equal([
['*1', '*2'],
['*3', '*4'],
['*5', '*6']
])
fn(A.pair, A.V, A.S).should.deep.equal(['1*a', '2*a', '3*a'])
fn(A.pair, A.M, A.S).should.deep.equal([
['1*a', '2*a'],
['3*a', '4*a'],
['5*a', '6*a']
])
fn(A.pair, A.S, A.V).should.deep.equal(['a*1', 'a*2', 'a*3'])
fn(A.pair, A.S, A.M).should.deep.equal([
['a*1', 'a*2'],
['a*3', 'a*4'],
['a*5', 'a*6']
])
fn(A.pair, A.U, A.R).should.deep.equal(['a*3', 'b*2', 'c*1'])
fn(A.pair, A.U, A.M).should.deep.equal([
['a*1', 'a*2'],
['b*3', 'b*4'],
['c*5', 'c*6']
])
fn(A.pair, A.L, A.M).should.deep.equal([
['a*1', 'b*2'],
['c*3', 'd*4'],
['e*5', 'f*6']
])
fn(A.pair, A.U, A.R).should.not.deep.equal(fn(A.pair, A.R, A.U))
fn(A.pair, A.U, A.VV).should.deep.equal(['a*1', 'b*2', 'c*3', 'a*4', 'b*5', 'c*6'])
(function() {
return fn(A.pair, A.V, [1, 2])
}).should.throw(/different dimensions/)
fn(A.pair, A.UU, A.M).should.deep.equal([
['a*1', 'a*2'],
['b*3', 'b*4'],
['c*5', 'c*6'],
['d*1', 'd*2'],
['e*3', 'e*4'],
['f*5', 'f*6']
])
fn(A.pair, A.S, A.T).should.deep.equal('a*0')
fn(A.pair, A.S, A.V).should.deep.equal(['a*1', 'a*2', 'a*3'])
fn(A.pair, A.S, A.M).should.deep.equal([
['a*1', 'a*2'],
['a*3', 'a*4'],
['a*5', 'a*6']
])
fn(A.pair, A.U, A.R).should.deep.equal(['a*3', 'b*2', 'c*1'])
fn(A.pair, A.U, A.M).should.deep.equal([
['a*1', 'a*2'],
['b*3', 'b*4'],
['c*5', 'c*6']
])
fn(A.pair, A.L, A.M).should.deep.equal([
['a*1', 'b*2'],
['c*3', 'd*4'],
['e*5', 'f*6']
])
fn(A.pair, A.U, A.R).should.not.deep.equal(fn(A.pair, A.R, A.U))
fn(A.pair, A.U, A.VV).should.deep.equal(['a*1', 'b*2', 'c*3', 'a*4', 'b*5', 'c*6'])
fn(A.pair, A.UU, A.M).should.deep.equal([
['a*1', 'a*2'],
['b*3', 'b*4'],
['c*5', 'c*6'],
['d*1', 'd*2'],
['e*3', 'e*4'],
['f*5', 'f*6']
])
wrapfn('a', 'b', 'c').should.equal('a*b*c');
fn(A.pair, ['a', 'b', 'c']).should.equal('a*b*c');
wrapfn('a', A.V, 'b').should.deep.equal(['a*1*b', 'a*2*b', 'a*3*b']);
fn('a', 'b', 'c').should.deep.equal(['a', 'b', 'c'])
fn(A.V).should.deep.equal(A.V)
fn(A.M).should.deep.equal([1, 2, 3, 4, 5, 6])
fn(A.S, A.V, A.U, A.M).should.deep.equal(['a', 1, 2, 3, 'a', 'b', 'c', 1, 2, 3, 4, 5, 6])
fn(A.M).should.equal(1 + 2 + 3 + 4 + 5 + 6)
fn(A.T, A.V, A.M).should.equal(0 + 1 + 2 + 3 + 1 + 2 + 3 + 4 + 5 + 6)
fn([1, 1, 1], function(T, i) {
return T[i] * i
}).should.equal(3)
fn(A.M).should.equal(1 * 2 * 3 * 4 * 5 * 6)
fn(A.T, A.V, A.M).should.equal(0 * 1 * 2 * 3 * 1 * 2 * 3 * 4 * 5 * 6)
fn(1, 2).should.equal(1 + 2)
fn(1, 2, 3).should.equal(1 + 2 + 3)
fn(A.T, A.V).should.deep.equal(A.V)
fn(A.T, A.M).should.deep.equal(A.M)
fn(A.V, A.N).should.deep.equal([0, 0, 0])
fn(A.V, A.M).should.deep.equal([
[1 + 1, 1 + 2],
[2 + 3, 2 + 4],
[3 + 5, 3 + 6]
])
fn(A.K, A.M).should.deep.equal([
[0, 0],
[0, 0],
[0, 0]
])
fn(A.V, A.VV).should.deep.equal([1 + 1, 2 + 2, 3 + 3, 1 + 4, 2 + 5, 3 + 6])
fn(A.VV, A.M).should.deep.equal([
[1 + 1, 1 + 2],
[2 + 3, 2 + 4],
[3 + 5, 3 + 6],
[4 + 1, 4 + 2],
[5 + 3, 5 + 4],
[6 + 5, 6 + 6]
])
fn(A.V, A.M, A.R).should.deep.equal([
[1 + 1 + 3, 1 + 2 + 3],
[2 + 3 + 2, 2 + 4 + 2],
[3 + 5 + 1, 3 + 6 + 1]
])
fn(1, 2).should.equal(1 - 2)
fn(1, 2, 3).should.equal(1 - 2 - 3)
fn(A.T, A.V).should.deep.equal(A.N)
fn(A.T, A.M).should.deep.equal(A.K)
fn(A.V, A.V).should.deep.equal([0, 0, 0])
fn(A.V, A.M).should.deep.equal([
[1 - 1, 1 - 2],
[2 - 3, 2 - 4],
[3 - 5, 3 - 6]
])
fn(A.M, A.M).should.deep.equal([
[0, 0],
[0, 0],
[0, 0]
])
fn(A.V, A.VV).should.deep.equal([1 - 1, 2 - 2, 3 - 3, 1 - 4, 2 - 5, 3 - 6])
fn(A.VV, A.M).should.deep.equal([
[1 - 1, 1 - 2],
[2 - 3, 2 - 4],
[3 - 5, 3 - 6],
[4 - 1, 4 - 2],
[5 - 3, 5 - 4],
[6 - 5, 6 - 6]
])
fn(A.V, A.M, A.R).should.deep.equal([
[1 - 1 - 3, 1 - 2 - 3],
[2 - 3 - 2, 2 - 4 - 2],
[3 - 5 - 1, 3 - 6 - 1]
])
fn(1, 2).should.equal(1 * 2)
fn(1, 2, 3).should.equal(1 * 2 * 3)
fn(A.T, A.V).should.deep.equal([0, 0, 0])
fn(A.T, A.M).should.deep.equal([
[0, 0],
[0, 0],
[0, 0]
])
fn(A.V, A.V).should.deep.equal([1 * 1, 2 * 2, 3 * 3])
fn(A.V, A.M).should.deep.equal([
[1 * 1, 1 * 2],
[2 * 3, 2 * 4],
[3 * 5, 3 * 6]
])
fn(A.M, A.M).should.deep.equal([
[1 * 1, 2 * 2],
[3 * 3, 4 * 4],
[5 * 5, 6 * 6]
])
fn(A.V, A.VV).should.deep.equal([1 * 1, 2 * 2, 3 * 3, 1 * 4, 2 * 5, 3 * 6])
fn(A.VV, A.M).should.deep.equal([
[1 * 1, 1 * 2],
[2 * 3, 2 * 4],
[3 * 5, 3 * 6],
[4 * 1, 4 * 2],
[5 * 3, 5 * 4],
[6 * 5, 6 * 6]
])
fn(A.V, A.M, A.R).should.deep.equal([
[1 * 1 * 3, 1 * 2 * 3],
[2 * 3 * 2, 2 * 4 * 2],
[3 * 5 * 1, 3 * 6 * 1]
])
fn(1, 2).should.equal(1 / 2)
fn(1, 2, 3).should.equal(1 / 2 / 3)
fn(A.T, A.V).should.deep.equal([0, 0, 0])
fn(A.T, A.M).should.deep.equal([
[0, 0],
[0, 0],
[0, 0]
])
fn(A.V, A.V).should.deep.equal([1 / 1, 2 / 2, 3 / 3])
fn(A.V, A.M).should.deep.equal([
[1 / 1, 1 / 2],
[2 / 3, 2 / 4],
[3 / 5, 3 / 6]
])
fn(A.M, A.M).should.deep.equal([
[1 / 1, 2 / 2],
[3 / 3, 4 / 4],
[5 / 5, 6 / 6]
])
fn(A.V, A.VV).should.deep.equal([1 / 1, 2 / 2, 3 / 3, 1 / 4, 2 / 5, 3 / 6])
fn(A.VV, A.M).should.deep.equal([
[1 / 1, 1 / 2],
[2 / 3, 2 / 4],
[3 / 5, 3 / 6],
[4 / 1, 4 / 2],
[5 / 3, 5 / 4],
[6 / 5, 6 / 6]
])
fn(A.V, A.M, A.R).should.deep.equal([
[1 / 1 / 3, 1 / 2 / 3],
[2 / 3 / 2, 2 / 4 / 2],
[3 / 5 / 1, 3 / 6 / 1]
])
fn(Math.E).should.equal(1);
fn(8, 2).should.equal(3);
fn(0).should.equal(-Infinity);
fn(-1).should.deep.equal(NaN);
fn(A.V).should.deep.equal([_.a_log(1), _.a_log(2), _.a_log(3)])
fn(2).should.equal(4)
fn(A.V).should.deep.equal([_.a_square(1), _.a_square(2), _.a_square(3)])
fn(4).should.equal(2);
fn(8, 3).should.equal(2);
fn(-4, 2).should.deep.equal(NaN);
fn(-8, 3).should.equal(-2);
fn(4, 0).should.deep.equal(Infinity);
fn(A.V).should.deep.equal([_.a_root(1), _.a_root(2), _.a_root(3)])
fn(0).should.equal(0.5);
fn([0, 0]).should.deep.equal([0.5, 0.5]);
fn(0, 3, 2).should.be.true
fn(0, 3, -2).should.be.false
fn(0, 3, 0).should.be.true
fn(0, 3, 3).should.be.true
fn(A.V, _.isInteger).should.be.true
fn([0.1, 0.2], _.isDouble).should.be.true
fn(A.V, _.isPositive).should.be.true
fn([0, -1, -2], _.nonPositive).should.be.true
fn(A.N, _.isNegative).should.be.true
fn([0, 1, 2], _.nonNegative).should.be.true
fn([0, 0, 0], _.isZero).should.be.true
fn(A.V, _.nonZero).should.be.true
_.parity(1).should.equal(-1)
_.parity(2).should.equal(1)
fn(A.V, A.V).should.be.true
fn(A.M, A.M).should.be.true
fn(A.U, A.UU).should.be.false
fn(A.U, A.M).should.be.false
fn(A.lone, A.S).should.equal('*a')
_.abs(-1).should.equal(Math.abs(-1))
_.acos(1).should.equal(Math.acos(1))
_.acosh(1).should.equal(Math.acosh(1))
_.asin(1).should.equal(Math.asin(1))
_.asinh(1).should.equal(Math.asinh(1))
_.atan(1).should.equal(Math.atan(1))
_.atanh(1).should.equal(Math.atanh(1))
_.ceil(1).should.equal(Math.ceil(1))
_.cos(1).should.equal(Math.cos(1))
_.cosh(1).should.equal(Math.cosh(1))
_.exp(1).should.equal(Math.exp(1))
_.floor(1).should.equal(Math.floor(1))
_.log10(2).should.equal(Math.log10(2))
_.log1p(2).should.equal(Math.log1p(2))
_.log2(2).should.equal(Math.log2(2))
_.round(1).should.equal(Math.round(1))
_.pow(1, 1).should.equal(Math.pow(1, 1))
_.sign(1).should.equal(Math.sign(1))
_.sin(1).should.equal(Math.sin(1))
_.sinh(1).should.equal(Math.sinh(1))
_.sqrt(1).should.equal(Math.sqrt(1))
_.tan(1).should.equal(Math.tan(1))
_.tanh(1).should.equal(Math.tanh(1))
_.trunc(1).should.equal(Math.trunc(1))
_.reMatch(A.reWord)(A.strWord).should.be.true
_.reMatch(A.reWord)(A.strNum).should.be.false
_.reMatch(A.reNum)(A.strNum).should.be.true
_.reMatch(A.reNum)(A.strWord).should.be.false
_.reNotMatch(A.reWord)(A.strWord).should.be.false
_.reNotMatch(A.reWord)(A.strNum).should.be.true
_.reNotMatch(A.reNum)(A.strNum).should.be.false
_.reNotMatch(A.reNum)(A.strWord).should.be.true
_.reGet(A.reWord)(A.str).should.equal(A.strWord)
_.reGet(A.reNum)(A.str).should.equal(A.strNum)
expect(_.reGet(A.reWord)(A.strNum)).to.be.null
_.reWrap(A.reWord).should.be.a('string')
_.reWrap(A.reWord).should.equal('(?:[a-zA-Z]+)')
_.reAnd(A.reWord, A.reNum).should.be.an.instanceof(RegExp)
_.reAnd(A.reWord, A.reNum).should.deep.equal(/(?:[a-zA-Z]+)(?:[0-9]+)/)
_.reAndMatch(A.reWord, A.reNum)(A.str).should.be.true
_.reAndMatch(A.reWord, A.reNum)(A.strWord).should.be.false
_.reAndMatch(A.reWord, A.reNum)(A.strNum).should.be.false
_.reOr(A.reWord, A.reNum).should.be.an.instanceof(RegExp)
_.reOr(A.reWord, A.reNum).should.deep.equal(/(?:[a-zA-Z]+)|(?:[0-9]+)/)
_.reOrMatch(A.reWord, A.reNum)(A.str).should.be.true
_.reOrMatch(A.reWord, A.reNum)(A.strWord).should.be.true
_.reOrMatch(A.reWord, A.reNum)(A.strNum).should.be.true
_.reString(A.reWord).should.equal(A.reWord.toString().replace(/^\/|\/.*$/g, ''))
fn(3).should.deep.equal([1, 2, 3])
fn(0, 2).should.deep.equal([0, 1, 2])
fn(-2, 2).should.deep.equal([-2, -1, 0, 1, 2])
fn(-4, 4, 2).should.deep.equal([-4, -2, 0, 2, 4])
fn(3).should.deep.equal([0, 0, 0])
fn(3, 'a').should.deep.equal(['a', 'a', 'a'])
fn(A.T).should.equal(0)
fn(A.B).should.equal(3)
fn(A.T).should.equal(0)
fn(A.B).should.equal(4 * 3 * 2)
fn(A.T).should.deep.equal([])
fn(A.B).should.deep.equal([2, 3, 4])
fn(A.S).should.be.true
fn(A.V).should.be.true
fn(A.M).should.be.false
fn(A.T).should.equal(0)
fn(A.V).should.equal(3)
fn(A.M).should.equal(2)
fn(v, 0, 2).should.deep.equal(A.R)
v.should.deep.equal(A.R)
fn(A.VZ).should.deep.equal([5, 4, 3, 2, 1, 0])
fn(A.VZ, 2).should.deep.equal([0, 1, 5, 4, 3, 2])
fn(A.VZ, null, 2).should.deep.equal([2, 1, 0, 3, 4, 5])
fn(A.VZ, 2, 4).should.deep.equal([0, 1, 4, 3, 2, 5])
fn(v, 6).should.deep.equal([1, 2, 3, 0, 0, 0])
fn(v, 6, 'a').should.deep.equal([1, 2, 3, 'a', 'a', 'a'])
(function() {
return fn(v, 0)
}).should.throw(/Array longer/)
fn(A.UU, [1, 2, 3]).should.deep.equal([-1, -1, -1])
fn(A.UU, [1, 'a', 3]).should.deep.equal([-1, 0, -1])
fn(A.UU, A.U).should.deep.equal([0, 1, 2])
fn(A.UU, ['c', 'b', 'a']).should.deep.equal([2, 1, 0])
fn(A.UU, ['a', 'a', 'a']).should.deep.equal([0, 0, 0])
fn([-2, -1], 2).should.deep.equal([])
fn([-2, 0, 2, 4], 2).should.deep.equal([0, 2])
fn([-2, 4, 2, 0], 2).should.deep.equal([2, 0])
fn([-2, 4, 0, 2, 0], 2).should.deep.equal([0, 2, 0])
fn(A.C, [-1, -2, 100]).should.deep.equal([])
fn(A.C, [-1, 0, 1]).should.deep.equal([
[1, 2, 3],
[4, 5, 6]
])
fn(A.C, [0, 1]).should.deep.equal([
[1, 2, 3],
[4, 5, 6]
])
fn(A.C, [1, 0]).should.deep.equal([
[4, 5, 6],
[1, 2, 3]
])
fn(A.C, [1, 1]).should.deep.equal([
[4, 5, 6],
[4, 5, 6]
])
fn(A.D, [-1, -2, 100]).should.deep.equal([])
fn(A.D, [-1, 0, 100]).should.deep.equal([
['a'],
[1],
[-1]
])
fn(A.D, [0, 2]).should.deep.equal([
['a', 'c'],
[1, 3],
[-1, -3]
])
fn(A.D, [2, 1, 0]).should.deep.equal([
['c', 'b', 'a'],
[3, 2, 1],
[-3, -2, -1]
])
fn(A.D, [0, 0]).should.deep.equal([
['a', 'a'],
[1, 1],
[-1, -1]
])
fn(A.D, [1, 2, 3]).should.deep.equal([])
fn(A.D, [1, 'a', 3]).should.deep.equal([
['a'],
[1],
[-1]
])
fn(A.D, ['a', 'c']).should.deep.equal([
['a', 'c'],
[1, 3],
[-1, -3]
])
fn(A.D, ['c', 'b', 'a']).should.deep.equal([
['c', 'b', 'a'],
[3, 2, 1],
[-3, -2, -1]
])
fn(A.D, ['a', 'a']).should.deep.equal([
['a', 'a'],
[1, 1],
[-1, -1]
])
fn(Q).should.deep.equal([
[1, 2, 3],
[4, 0, 0]
])
fn(Q, -1).should.deep.equal([
[1, 2, 3],
[4, -1, -1]
])
fn(R).should.deep.equal([
[1, 2, 3],
[4, 5, 6]
])
fn(_.c(A.B), _.dim(A.B)).should.deep.equal(A.B)
fn(R, [2, 3, 4]).should.deep.equal(A.B)
fn(Q, [2, 3, 4]).should.deep.equal([
[
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3]
],
[
[4, 4, 4, 4],
[5, 5, 5, 5],
[6, 6]
]
])
fn(R).should.deep.equal({
"level1.level2.level3": 0,
"level1.level2.level3b": {},
"level1.level2b.level3.0": 2,
"level1.level2b.level3.1": 3,
"level1.level2b.level3.2": 4,
"level1.level2b.level3b.0.level4": 5,
"level1.level2b.level3b.0.level4b": 6,
"level1.level2b.level3b.0.level4c": 7
})
fn(R, '_').should.deep.equal({
"level1_level2_level3": 0,
"level1_level2_level3b": {},
"level1_level2b_level3_0": 2,
"level1_level2b_level3_1": 3,
"level1_level2b_level3_2": 4,
"level1_level2b_level3b_0_level4": 5,
"level1_level2b_level3b_0_level4b": 6,
"level1_level2b_level3b_0_level4c": 7
})
fn(_.flattenJSON(R)).should.deep.equal(R)
fn(_.flattenJSON(R, '_'), '_').should.deep.equal(R)
fn(A.C).should.deep.equal([
[1, 4, 7],
[2, 5, 8],
[3, 6, 9]
])
fn(A.M).should.deep.equal([
[1, 3, 5],
[2, 4, 6]
])
fn(A.C).should.equal(15)
fn([
[1, 2],
[3, 4]
], [
[1, 2],
[3, 4]
]).should.deep.equal([
[7, 10],
[15, 22]
])
fn(A.C).should.deep.equal([
[5, 6],
[8, 9]
])
fn(A.C, 0, 1).should.deep.equal([
[4, 6],
[7, 9]
])
fn(mat).should.deep.equal([
[7, -2, -3],
[5, -16, 9],
[-3, 6, -3]
])
fn(mat).should.deep.equal([
[7, 5, -3],
[-2, -16, 6],
[-3, 9, -3]
])
fn(mat, 0).should.equal(7)
fn(2).should.equal(2)
fn([2]).should.equal(2)
fn([
[2]
]).should.equal(2)
fn([
[1, 2],
[3, 4]
]).should.equal(-2)
fn(mat).should.equal(-6)
fn(mat).should.deep.equal([
[5.625, -2.375, -2.5],
[4.75, -2.25, -2],
[-3.375, 1.625, 1.5]
])
expect(fn([
[1, 1],
[1, 1]
])).to.be.null
fn(1, 2).should.deep.equal(['0', '1'])
fn(2, 2).should.deep.equal(['00', '01', '10', '11'])
fn(3, 2).should.deep.equal(
['000', '001', '010', '011', '100', '101', '110', '111']
)
fn(2, 3).should.deep.equal(['00', '01', '02', '10', '11', '12', '20', '21', '22'])
fn(['00', '01', '10', '11']).should.deep.equal([
[0, 0],
[0, 1],
[1, 0],
[1, 1]
])
fn(0).should.deep.equal([
[]
])
fn(3).should.deep.equal([
['0', '1', '2'],
['01', '02', '10', '12', '20', '21'],
['012', '021', '102', '120', '201', '210']
])
fn(0).should.deep.equal([
[]
])
fn(3).should.deep.equal([
['0', '1', '2'],
['01', '02', '12'],
['012']
])
fn(3, 1).should.deep.equal(_.toNumArr(['0', '1', '2']))
fn(3, 2).should.deep.equal(_.toNumArr(['01', '02', '10', '12', '20', '21']))
fn(3, 3).should.deep.equal(_.toNumArr(['012', '021', '102', '120', '201', '210']))
fn(3, 1).should.deep.equal(_.toNumArr(['0', '1', '2']))
fn(3, 2).should.deep.equal(_.toNumArr(['01', '02', '12']))
fn(3, 3).should.deep.equal(_.toNumArr(['012']))
fn(2).should.deep.equal(_.permList(2, 2))
fn(3).should.deep.equal(_.permList(3, 3))
fn(4).should.deep.equal(_.permList(4, 4))
fn(5).should.equal(120)
fn(0).should.equal(1)
(function() {
return fn(-1)
}).should.throw(/Negative factorial not defined/)
fn(1000).should.deep.equal(Infinity)
fn(5, 1).should.deep.equal(5)
fn(5, 5).should.deep.equal(120)
fn(1000, 1).should.deep.equal(1000)
fn(5, 0).should.deep.equal(1)
(function() {
return fn(5, -1)
}).should.throw(/Negative permutation not defined/)
fn(1000, 1000).should.deep.equal(Infinity)
fn(5, 1).should.deep.equal(5)
fn(5, 5).should.deep.equal(1)
fn(1000, 1).should.deep.equal(1000)
fn(1000, 1000).should.deep.equal(1)
fn(5, 0).should.deep.equal(1)
(function() {
return fn(5, -1)
}).should.throw(/Negative combination not defined/)
fn(1000, 500).should.deep.equal(NaN)
fn(A.V, A.V).should.deep.equal(1 + 4 + 9)
fn(A.V, A.VV).should.deep.equal(fn(_.c(A.V, A.V), A.VV))
fn(A.V).should.deep.equal(1 + 4 + 9)
fn(A.V, 3).should.deep.equal(1 + 8 + 27)
fn(A.M).should.deep.equal(1 + 4 + 9 + 16 + 25 + 36)
fn([3, 4]).should.deep.equal(5)
fn([3, 4], 1).should.deep.equal(7)
fn([3, 4]).should.deep.equal([3 / 5, 4 / 5])
fn([3, 4], 1).should.deep.equal([3 / 7, 4 / 7])
fn([3, 4]).should.deep.equal([3 / 7, 4 / 7])
fn(A.V).length.should.equal(A.V.length - 1)
fn([1, 2, 3, 5, 8]).should.deep.equal([1, 1, 2, 3])
fn(A.V, _.isPositive).should.be.true
_.increasing(A.V).should.be.true
_.nonDecreasing([1, 1, 2, 3]).should.be.true
_.decreasing(A.R).should.be.true
_.nonIncreasing([3, 2, 1, 1]).should.be.true
fn([-2, -1, 0, 1, 2]).should.equal(0)
fn(vv).should.equal((-1) * 0.1 + 0 + 1 * 0.3 + 2 * 0.4)
fn(v, p).should.equal((-1) * 0.1 + 0 + 1 * 0.3 + 2 * 0.4)
fn(vv, _.a_square).should.equal(1 * 0.1 + 0 + 1 * 0.3 + 4 * 0.4)
fn(v, p, _.a_square).should.equal(1 * 0.1 + 0 + 1 * 0.3 + 4 * 0.4)
fn(vv).should.equal(
(1 * 0.1 + 0 + 1 * 0.3 + 4 * 0.4) -
_.a_square((-1) * 0.1 + 0 + 1 * 0.3 + 2 * 0.4)
)
fn(v, p).should.equal(
(1 * 0.1 + 0 + 1 * 0.3 + 4 * 0.4) -
_.a_square((-1) * 0.1 + 0 + 1 * 0.3 + 2 * 0.4)
)
fn(vv, _.a_square).should.be.closeTo(
(1 * 0.1 + 0 + 1 * 0.3 + 16 * 0.4) -
_.a_square(1 * 0.1 + 0 + 1 * 0.3 + 4 * 0.4), 0.0001)
fn(v, p, _.a_square).should.be.closeTo(
(1 * 0.1 + 0 + 1 * 0.3 + 16 * 0.4) -
_.a_square(1 * 0.1 + 0 + 1 * 0.3 + 4 * 0.4), 0.0001)
_.stdev(v, p).should.equal(
Math.sqrt(
(1 * 0.1 + 0 + 1 * 0.3 + 4 * 0.4) -
_.a_square((-1) * 0.1 + 0 + 1 * 0.3 + 2 * 0.4)
)
)
var hist = fn(['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd'])
hist.value.should.deep.equal(['a', 'b', 'c', 'd'])
hist.freq.should.deep.equal([1, 2, 3, 4])
hist.prob.should.deep.equal([0.1, 0.2, 0.3, 0.4])
var hist = fn(['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd'], _.identity)
hist.value.should.deep.equal(['a', 'b', 'c', 'd'])
hist.freq.should.deep.equal([1, 2, 3, 4])
hist.prob.should.deep.equal([0.1, 0.2, 0.3, 0.4])
var hist = fn(['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd'], _.identity, true)
hist.should.be.an.instanceof(Array)
hist.should.deep.equal([
['a', 1],
['b', 2],
['c', 3],
['d', 4]
])
var hist = fn(['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd'], true)
hist.should.be.an.instanceof(Array)
hist.should.deep.equal([
['a', 1],
['b', 2],
['c', 3],
['d', 4]
])
fn(8, 2, 2).should.equal(100)
fn(v, 1).should.equal(100)
fn(v, 2).should.equal(100)
fn(v, 3).should.equal(100)
_.hc().should.not.equal(0)
_.plot().should.equal(0)
_.advPlot().should.equal(0)
_.render().should.equal(0)
_.tick().should.be.a('number')
_.tock().should.be.a('number')
_.p("Testing printer")