mirror of
https://github.com/josdejong/mathjs.git
synced 2026-01-18 14:59:29 +00:00
Merge branch 'develop' of https://github.com/josdejong/mathjs into gamma_factorial
This commit is contained in:
Favian Contreras
commit
8d8e46e07b
@ -1,6 +1,13 @@
|
||||
# History
|
||||
|
||||
|
||||
## not yet released, version 1.1.2
|
||||
|
||||
- Converting a unit without value will now result in a unit *with* value,
|
||||
i.e. `inch in cm` will return `2.54 cm` instead of `cm`.
|
||||
- Improved accuracy of `sinh` and complex `cos` and `sin`. Thanks @pavpanchekha.
|
||||
|
||||
|
||||
## 2014-11-22, version 1.1.1
|
||||
|
||||
- Fixed Unit divided by Number returning zero.
|
||||
|
||||
@ -11,7 +11,7 @@ Base | Unit
|
||||
Length | meter (m), inch (in), foot (ft), yard (yd), mile (mi), link (li), rod (rd), chain (ch), angstrom, mil
|
||||
Surface | m2, sqin, sqft, sqyd, sqmi, sqrd, sqch, sqmil
|
||||
Volume | m3, litre (l, L, lt, liter), cc, cuin, cuft, cuyd, teaspoon, tablespoon
|
||||
Liquid | volume minim (min), fluiddram (fldr), fluidounce (fldz), gill (gi), cup (cp), pint (pt), quart (qt), gallon (gal), beerbarrel (bbl), oilbarrel (obl), hogshead, drop (gtt)
|
||||
Liquid | volume minim (min), fluiddram (fldr), fluidounce (floz), gill (gi), cup (cp), pint (pt), quart (qt), gallon (gal), beerbarrel (bbl), oilbarrel (obl), hogshead, drop (gtt)
|
||||
Angles | rad, deg, grad, cycle
|
||||
Time | second (s), seconds, minute, minutes, hour (h), hours, day, days
|
||||
Mass | gram(g), tonne, ton, grain (gr), dram(dr), ounce (oz), poundmass (lbm, lb, lbs), hundredweight (cwt), stick
|
||||
|
||||
@ -116,6 +116,7 @@ var DELIMITERS = {
|
||||
'%': true,
|
||||
'^': true,
|
||||
'.^': true,
|
||||
'~': true,
|
||||
'!': true,
|
||||
'\'': true,
|
||||
'=': true,
|
||||
@ -810,10 +811,15 @@ function parseMultiplyDivide () {
|
||||
*/
|
||||
function parseUnary () {
|
||||
var name, fn, params;
|
||||
var unaryTokens = {
|
||||
'-': 'unaryMinus',
|
||||
'+': 'unaryPlus',
|
||||
'~': 'bitNot'
|
||||
};
|
||||
|
||||
if (token == '-' || token == '+') {
|
||||
fn = unaryTokens[token];
|
||||
if (fn) {
|
||||
name = token;
|
||||
fn = name == '+' ? 'unaryPlus' : 'unaryMinus';
|
||||
|
||||
getTokenSkipNewline();
|
||||
params = [parseUnary()];
|
||||
|
||||
@ -3,15 +3,18 @@
|
||||
module.exports = function (math, config) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
//BigNumber = math.type.BigNumber,
|
||||
BigNumber = math.type.BigNumber,
|
||||
Matrix = require('../../type/Matrix'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isBoolean = util['boolean'].isBoolean,
|
||||
isInteger = util.number.isInteger,
|
||||
isNumber = util.number.isNumber,
|
||||
isString = util.string.isString,
|
||||
isCollection = collection.isCollection;
|
||||
isCollection = collection.isCollection,
|
||||
|
||||
bigBitAnd = util.bignumber.and;
|
||||
|
||||
/**
|
||||
* Bitwise AND two values, `x & y`.
|
||||
@ -33,7 +36,7 @@ module.exports = function (math, config) {
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x First value to and
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} y Second value to and
|
||||
* @return {Integer | BigNumber | Array | Matrix} AND of `x` and `y`
|
||||
* @return {Number | BigNumber | Array | Matrix} AND of `x` and `y`
|
||||
*/
|
||||
math.bitAnd = function bitAnd(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
@ -41,20 +44,43 @@ module.exports = function (math, config) {
|
||||
}
|
||||
|
||||
if (isNumber(x) && isNumber(y)) {
|
||||
if (!isInteger(x) || !isInteger(y)) {
|
||||
throw new Error('Parameters in function bitAnd must be integer numbers');
|
||||
}
|
||||
|
||||
return x & y;
|
||||
}
|
||||
|
||||
/*if (x instanceof BigNumber) {
|
||||
if (isCollection(x) || isCollection(y)) {
|
||||
return collection.deepMap2(x, y, bitAnd);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return bitAnd((config.number === 'bignumber')
|
||||
? BigNumber.convert(x)
|
||||
: +x, y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return bitAnd(x, (config.number === 'bignumber')
|
||||
? BigNumber.convert(y)
|
||||
: +y);
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
return bitAnd(+x, y);
|
||||
}
|
||||
if (isBoolean(y) || y === null) {
|
||||
return bitAnd(x, +y);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
// try to convert to big number
|
||||
if (isNumber(y)) {
|
||||
y = BigNumber.convert(y);
|
||||
}
|
||||
else if (isBoolean(y) || y === null) {
|
||||
y = new BigNumber(y ? 1 : 0);
|
||||
}
|
||||
|
||||
if (y instanceof BigNumber) {
|
||||
return x.and(y);
|
||||
return bigBitAnd(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
@ -65,38 +91,13 @@ module.exports = function (math, config) {
|
||||
if (isNumber(x)) {
|
||||
x = BigNumber.convert(x);
|
||||
}
|
||||
else if (isBoolean(x) || x === null) {
|
||||
x = new BigNumber(x ? 1 : 0);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
return x.and(y)
|
||||
return bigBitAnd(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return bitAnd(x, y.toNumber());
|
||||
}*/
|
||||
|
||||
if (isCollection(x) || isCollection(y)) {
|
||||
return collection.deepMap2(x, y, bitAnd);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return bitAnd((config.number == 'bignumber')
|
||||
? new BigNumber(x)
|
||||
: parseInt(x), y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return bitAnd(x, (config.number == 'bignumber')
|
||||
? new BigNumber(y)
|
||||
: parseInt(y));
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
return bitAnd(+x, y);
|
||||
}
|
||||
if (isBoolean(y) || y === null) {
|
||||
return bitAnd(x, +y);
|
||||
}
|
||||
|
||||
throw new math.error.UnsupportedTypeError('bitAnd', math['typeof'](x), math['typeof'](y));
|
||||
|
||||
@ -3,15 +3,18 @@
|
||||
module.exports = function (math, config) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
//BigNumber = math.type.BigNumber,
|
||||
BigNumber = math.type.BigNumber,
|
||||
Matrix = require('../../type/Matrix'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isBoolean = util['boolean'].isBoolean,
|
||||
isInteger = util.number.isInteger,
|
||||
isNumber = util.number.isNumber,
|
||||
isString = util.string.isString,
|
||||
isCollection = collection.isCollection;
|
||||
isCollection = collection.isCollection,
|
||||
|
||||
bigBitNot = util.bignumber.not;
|
||||
|
||||
/**
|
||||
* Bitwise NOT value, `~x`.
|
||||
@ -33,7 +36,7 @@ module.exports = function (math, config) {
|
||||
* bitAnd, bitOr, bitXor, leftShift, rightArithShift, rightLogShift
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x Value to not
|
||||
* @return {Integer | BigNumber | Array | Matrix} NOT of `x`
|
||||
* @return {Number | BigNumber | Array | Matrix} NOT of `x`
|
||||
*/
|
||||
math.bitNot = function bitNot(x) {
|
||||
if (arguments.length != 1) {
|
||||
@ -41,21 +44,25 @@ module.exports = function (math, config) {
|
||||
}
|
||||
|
||||
if (isNumber(x)) {
|
||||
if (!isInteger(x)) {
|
||||
throw new Error('Parameter in function bitNot must be integer numbers');
|
||||
}
|
||||
|
||||
return ~x;
|
||||
}
|
||||
|
||||
/*if (x instanceof BigNumber) {
|
||||
return x.not();
|
||||
}*/
|
||||
if (x instanceof BigNumber) {
|
||||
return bigBitNot(x);
|
||||
}
|
||||
|
||||
if (isCollection(x)) {
|
||||
return collection.deepMap(x, bitNot);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return bitNot((config.number == 'bignumber')
|
||||
? new BigNumber(x)
|
||||
: parseInt(x));
|
||||
return bitNot((config.number === 'bignumber')
|
||||
? BigNumber.convert(x)
|
||||
: +x);
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
|
||||
@ -3,15 +3,18 @@
|
||||
module.exports = function (math, config) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
//BigNumber = math.type.BigNumber,
|
||||
BigNumber = math.type.BigNumber,
|
||||
Matrix = require('../../type/Matrix'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isBoolean = util['boolean'].isBoolean,
|
||||
isInteger = util.number.isInteger,
|
||||
isNumber = util.number.isNumber,
|
||||
isString = util.string.isString,
|
||||
isCollection = collection.isCollection;
|
||||
isCollection = collection.isCollection,
|
||||
|
||||
bigBitOr = util.bignumber.or;
|
||||
|
||||
/**
|
||||
* Bitwise OR two values, `x | y`.
|
||||
@ -34,7 +37,7 @@ module.exports = function (math, config) {
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x First value to or
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} y Second value to or
|
||||
* @return {Integer | BigNumber | Array | Matrix} OR of `x` and `y`
|
||||
* @return {Number | BigNumber | Array | Matrix} OR of `x` and `y`
|
||||
*/
|
||||
math.bitOr = function bitOr(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
@ -42,20 +45,43 @@ module.exports = function (math, config) {
|
||||
}
|
||||
|
||||
if (isNumber(x) && isNumber(y)) {
|
||||
if (!isInteger(x) || !isInteger(y)) {
|
||||
throw new Error('Parameters in function bitOr must be integer numbers');
|
||||
}
|
||||
|
||||
return x | y;
|
||||
}
|
||||
|
||||
/*if (x instanceof BigNumber) {
|
||||
if (isCollection(x) || isCollection(y)) {
|
||||
return collection.deepMap2(x, y, bitOr);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return bitOr((config.number === 'bignumber')
|
||||
? BigNumber.convert(x)
|
||||
: +x, y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return bitOr(x, (config.number === 'bignumber')
|
||||
? BigNumber.convert(y)
|
||||
: +y);
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
return bitOr(+x, y);
|
||||
}
|
||||
if (isBoolean(y) || y === null) {
|
||||
return bitOr(x, +y);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
// try to convert to big number
|
||||
if (isNumber(y)) {
|
||||
y = BigNumber.convert(y);
|
||||
}
|
||||
else if (isBoolean(y) || y === null) {
|
||||
y = new BigNumber(y ? 1 : 0);
|
||||
}
|
||||
|
||||
if (y instanceof BigNumber) {
|
||||
return x.or(y);
|
||||
return bigBitOr(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
@ -66,38 +92,13 @@ module.exports = function (math, config) {
|
||||
if (isNumber(x)) {
|
||||
x = BigNumber.convert(x);
|
||||
}
|
||||
else if (isBoolean(x) || x === null) {
|
||||
x = new BigNumber(x ? 1 : 0);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
return x.or(y)
|
||||
return bigBitOr(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return bitOr(x, y.toNumber());
|
||||
}*/
|
||||
|
||||
if (isCollection(x) || isCollection(y)) {
|
||||
return collection.deepMap2(x, y, bitOr);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return bitOr((config.number == 'bignumber')
|
||||
? new BigNumber(x)
|
||||
: parseInt(x), y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return bitOr(x, (config.number == 'bignumber')
|
||||
? new BigNumber(y)
|
||||
: parseInt(y));
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
return bitOr(+x, y);
|
||||
}
|
||||
if (isBoolean(y) || y === null) {
|
||||
return bitOr(x, +y);
|
||||
}
|
||||
|
||||
throw new math.error.UnsupportedTypeError('bitOr', math['typeof'](x), math['typeof'](y));
|
||||
|
||||
@ -3,16 +3,19 @@
|
||||
module.exports = function (math, config) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
//BigNumber = math.type.BigNumber,
|
||||
BigNumber = math.type.BigNumber,
|
||||
Matrix = require('../../type/Matrix'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isBoolean = util['boolean'].isBoolean,
|
||||
isInteger = util.number.isInteger,
|
||||
isNumber = util.number.isNumber,
|
||||
isString = util.string.isString,
|
||||
isUnit = Unit.isUnit,
|
||||
isCollection = collection.isCollection;
|
||||
isCollection = collection.isCollection,
|
||||
|
||||
bigBitXor = util.bignumber.xor;
|
||||
|
||||
/**
|
||||
* Bitwise XOR two values, `x ^ y`.
|
||||
@ -34,7 +37,7 @@ module.exports = function (math, config) {
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x First value to xor
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} y Second value to xor
|
||||
* @return {Integer | BigNumber | Array | Matrix} XOR of `x` and `y`
|
||||
* @return {Number | BigNumber | Array | Matrix} XOR of `x` and `y`
|
||||
*/
|
||||
math.bitXor = function bitXor(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
@ -42,20 +45,43 @@ module.exports = function (math, config) {
|
||||
}
|
||||
|
||||
if (isNumber(x) && isNumber(y)) {
|
||||
if (!isInteger(x) || !isInteger(y)) {
|
||||
throw new Error('Parameters in function bitXor must be integer numbers');
|
||||
}
|
||||
|
||||
return x ^ y;
|
||||
}
|
||||
|
||||
/*if (x instanceof BigNumber) {
|
||||
if (isCollection(x) || isCollection(y)) {
|
||||
return collection.deepMap2(x, y, bitXor);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return bitXor((config.number === 'bignumber')
|
||||
? BigNumber.convert(x)
|
||||
: +x, y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return bitXor(x, (config.number === 'bignumber')
|
||||
? BigNumber.convert(y)
|
||||
: +y);
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
return bitXor(+x, y);
|
||||
}
|
||||
if (isBoolean(y) || y === null) {
|
||||
return bitXor(x, +y);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
// try to convert to big number
|
||||
if (isNumber(y)) {
|
||||
y = BigNumber.convert(y);
|
||||
}
|
||||
else if (isBoolean(y) || y === null) {
|
||||
y = new BigNumber(y ? 1 : 0);
|
||||
}
|
||||
|
||||
if (y instanceof BigNumber) {
|
||||
return x.xor(y);
|
||||
return bigBitXor(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
@ -66,38 +92,13 @@ module.exports = function (math, config) {
|
||||
if (isNumber(x)) {
|
||||
x = BigNumber.convert(x);
|
||||
}
|
||||
else if (isBoolean(x) || x === null) {
|
||||
x = new BigNumber(x ? 1 : 0);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
return x.xor(y)
|
||||
return bigBitXor(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return bitXor(x, y.toNumber());
|
||||
}*/
|
||||
|
||||
if (isCollection(x) || isCollection(y)) {
|
||||
return collection.deepMap2(x, y, bitXor);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return bitXor((config.number == 'bignumber')
|
||||
? new BigNumber(x)
|
||||
: parseInt(x), y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return bitXor(x, (config.number == 'bignumber')
|
||||
? new BigNumber(y)
|
||||
: parseInt(y));
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
return bitXor(+x, y);
|
||||
}
|
||||
if (isBoolean(y) || y === null) {
|
||||
return bitXor(x, +y);
|
||||
}
|
||||
|
||||
throw new math.error.UnsupportedTypeError('bitXor', math['typeof'](x), math['typeof'](y));
|
||||
|
||||
@ -3,15 +3,18 @@
|
||||
module.exports = function (math, config) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
//BigNumber = math.type.BigNumber,
|
||||
BigNumber = math.type.BigNumber,
|
||||
Matrix = require('../../type/Matrix'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isBoolean = util['boolean'].isBoolean,
|
||||
isInteger = util.number.isInteger,
|
||||
isNumber = util.number.isNumber,
|
||||
isString = util.string.isString,
|
||||
isCollection = collection.isCollection;
|
||||
isCollection = collection.isCollection,
|
||||
|
||||
bigLeftShift = util.bignumber.leftShift;
|
||||
|
||||
/**
|
||||
* Bitwise left logical shift one value by another values, `x << y`.
|
||||
@ -34,60 +37,70 @@ module.exports = function (math, config) {
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x Value to be shifted
|
||||
* @param {Number | BigNumber | Boolean | String | null} y Amount of shifts
|
||||
* @return {Integer | BigNumber | Array | Matrix} `x` shifted left `y` times
|
||||
* @return {Number | BigNumber | Array | Matrix} `x` shifted left `y` times
|
||||
*/
|
||||
math.leftShift = function leftShift(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
throw new math.error.ArgumentsError('leftShift', arguments.length, 2);
|
||||
}
|
||||
|
||||
if (isNumber(x) && isNumber(y)) {
|
||||
return x << y;
|
||||
}
|
||||
|
||||
/*if (x instanceof BigNumber) {
|
||||
// try to convert to big number
|
||||
if (isNumber(x)) {
|
||||
if (isNumber(y)) {
|
||||
y = BigNumber.convert(y);
|
||||
}
|
||||
else if (y === null) {
|
||||
y = new BigNumber(0);
|
||||
if (!isInteger(x) || !isInteger(y)) {
|
||||
throw new Error('Parameters in function leftShift must be integer numbers');
|
||||
}
|
||||
|
||||
return x << y;
|
||||
}
|
||||
|
||||
if (y instanceof BigNumber) {
|
||||
return x.leftShift(y);
|
||||
return bigLeftShift(BigNumber.convert(x), y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return leftShift(x.toNumber(), y);
|
||||
}
|
||||
if (y instanceof BigNumber) {
|
||||
// try to convert to big number
|
||||
if (isNumber(x)) {
|
||||
x = BigNumber.convert(x);
|
||||
if (isNumber(y)) {
|
||||
if (isFinite(y) && !isInteger(y)) {
|
||||
throw new Error('Parameters in function leftShift must be integer numbers');
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
return x.leftShift(y);
|
||||
}
|
||||
if (x.isFinite() && !x.isInteger()) {
|
||||
throw new Error('Parameters in function leftShift must be integer numbers');
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return leftShift(x, y.toNumber());
|
||||
}*/
|
||||
if (x.isNaN() || isNaN(y) || y < 0) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
|
||||
if (y == 0 || x.isZero()) {
|
||||
return x;
|
||||
}
|
||||
if (y == Infinity && !x.isFinite()) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
|
||||
// Math.pow(2, y) is fully precise for y < 55, and fast
|
||||
if (y < 55) {
|
||||
return x.times(Math.pow(2, y) + '');
|
||||
}
|
||||
|
||||
y = BigNumber.convert(y);
|
||||
return bigLeftShift(x, y);
|
||||
}
|
||||
}
|
||||
|
||||
if (isCollection(x) && isNumber(y)) {
|
||||
return collection.deepMap2(x, y, leftShift);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return leftShift((config.number == 'bignumber')
|
||||
? new BigNumber(x)
|
||||
: parseInt(x), y);
|
||||
return leftShift((config.number === 'bignumber')
|
||||
? BigNumber.convert(x)
|
||||
: +x, y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return leftShift(x, (config.number == 'bignumber')
|
||||
? new BigNumber(y)
|
||||
: parseInt(y));
|
||||
return leftShift(x, (config.number === 'bignumber')
|
||||
? BigNumber.convert(y)
|
||||
: +y);
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
@ -97,6 +110,19 @@ module.exports = function (math, config) {
|
||||
return leftShift(x, +y);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
if (y instanceof BigNumber) {
|
||||
return bigLeftShift(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return leftShift(x.toNumber(), y);
|
||||
}
|
||||
if (y instanceof BigNumber) {
|
||||
// x is probably incompatible with BigNumber
|
||||
return leftShift(x, y.toNumber());
|
||||
}
|
||||
|
||||
throw new math.error.UnsupportedTypeError('leftShift', math['typeof'](x), math['typeof'](y));
|
||||
};
|
||||
};
|
||||
|
||||
@ -3,15 +3,18 @@
|
||||
module.exports = function (math, config) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
//BigNumber = math.type.BigNumber,
|
||||
BigNumber = math.type.BigNumber,
|
||||
Matrix = require('../../type/Matrix'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isBoolean = util['boolean'].isBoolean,
|
||||
isInteger = util.number.isInteger,
|
||||
isNumber = util.number.isNumber,
|
||||
isString = util.string.isString,
|
||||
isCollection = collection.isCollection;
|
||||
isCollection = collection.isCollection,
|
||||
|
||||
bigRightShift = util.bignumber.rightShift;
|
||||
|
||||
/**
|
||||
* Bitwise right arithmetic shift one value by another values, `x >> y`.
|
||||
@ -34,60 +37,72 @@ module.exports = function (math, config) {
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x Value to be shifted
|
||||
* @param {Number | BigNumber | Boolean | String | null} y Amount of shifts
|
||||
* @return {Integer | BigNumber | Array | Matrix} `x` sign-filled shifted right `y` times
|
||||
* @return {Number | BigNumber | Array | Matrix} `x` sign-filled shifted right `y` times
|
||||
*/
|
||||
math.rightArithShift = function rightArithShift(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
throw new math.error.ArgumentsError('rightArithShift', arguments.length, 2);
|
||||
}
|
||||
|
||||
if (isNumber(x) && isNumber(y)) {
|
||||
return x >> y;
|
||||
}
|
||||
|
||||
/*if (x instanceof BigNumber) {
|
||||
// try to convert to big number
|
||||
if (isNumber(x)) {
|
||||
if (isNumber(y)) {
|
||||
y = BigNumber.convert(y);
|
||||
}
|
||||
else if (y === null) {
|
||||
y = new BigNumber(0);
|
||||
if (!isInteger(x) || !isInteger(y)) {
|
||||
throw new Error('Parameters in function rightArithShift must be integer numbers');
|
||||
}
|
||||
|
||||
return x >> y;
|
||||
}
|
||||
|
||||
if (y instanceof BigNumber) {
|
||||
return x.rightShift(y);
|
||||
return bigRightShift(BigNumber.convert(x), y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return rightArithShift(x.toNumber(), y);
|
||||
}
|
||||
if (y instanceof BigNumber) {
|
||||
// try to convert to big number
|
||||
if (isNumber(x)) {
|
||||
x = BigNumber.convert(x);
|
||||
if (isNumber(y)) {
|
||||
if (isFinite(y) && !isInteger(y)) {
|
||||
throw new Error('Parameters in function rightArithShift must be integer numbers');
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
return x.rightShift(y);
|
||||
}
|
||||
if (x.isFinite() && !x.isInteger()) {
|
||||
throw new Error('Parameters in function rightArithShift must be integer numbers');
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return rightArithShift(x, y.toNumber());
|
||||
}*/
|
||||
if (x.isNaN() || isNaN(y) || y < 0) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
if (y == Infinity) {
|
||||
if (x.isNegative()) {
|
||||
return new BigNumber(-1);
|
||||
}
|
||||
if (!x.isFinite()) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
return new BigNumber(0);
|
||||
}
|
||||
|
||||
// Math.pow(2, y) is fully precise for y < 55, and fast
|
||||
if (y < 55) {
|
||||
return x.div(Math.pow(2, y) + '').floor();
|
||||
}
|
||||
|
||||
y = BigNumber.convert(y);
|
||||
return bigRightShift(x, y);
|
||||
}
|
||||
}
|
||||
|
||||
if (isCollection(x) && isNumber(y)) {
|
||||
return collection.deepMap2(x, y, rightArithShift);
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return rightArithShift((config.number == 'bignumber')
|
||||
? new BigNumber(x)
|
||||
: parseInt(x), y);
|
||||
return rightArithShift((config.number === 'bignumber')
|
||||
? BigNumber.convert(x)
|
||||
: +x, y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return rightArithShift(x, (config.number == 'bignumber')
|
||||
? new BigNumber(y)
|
||||
: parseInt(y));
|
||||
return rightArithShift(x, (config.number === 'bignumber')
|
||||
? BigNumber.convert(y)
|
||||
: +y);
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
@ -97,6 +112,19 @@ module.exports = function (math, config) {
|
||||
return rightArithShift(x, +y);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
if (y instanceof BigNumber) {
|
||||
return bigRightShift(x, y);
|
||||
}
|
||||
|
||||
// downgrade to Number
|
||||
return rightArithShift(x.toNumber(), y);
|
||||
}
|
||||
if (y instanceof BigNumber) {
|
||||
// x is probably incompatible with BigNumber
|
||||
return rightArithShift(x, y.toNumber());
|
||||
}
|
||||
|
||||
throw new math.error.UnsupportedTypeError('rightArithShift', math['typeof'](x), math['typeof'](y));
|
||||
};
|
||||
};
|
||||
|
||||
@ -8,6 +8,7 @@ module.exports = function (math, config) {
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isBoolean = util['boolean'].isBoolean,
|
||||
isInteger = util.number.isInteger,
|
||||
isNumber = util.number.isNumber,
|
||||
isString = util.string.isString,
|
||||
isCollection = collection.isCollection;
|
||||
@ -33,7 +34,7 @@ module.exports = function (math, config) {
|
||||
*
|
||||
* @param {Number | Boolean | String | Array | Matrix | null} x Value to be shifted
|
||||
* @param {Number | Boolean | String | null} y Amount of shifts
|
||||
* @return {Integer | BigNumber | Array | Matrix} `x` zero-filled shifted right `y` times
|
||||
* @return {Number | Array | Matrix} `x` zero-filled shifted right `y` times
|
||||
*/
|
||||
math.rightLogShift = function rightLogShift(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
@ -41,6 +42,10 @@ module.exports = function (math, config) {
|
||||
}
|
||||
|
||||
if (isNumber(x) && isNumber(y)) {
|
||||
if (!isInteger(x) || !isInteger(y)) {
|
||||
throw new Error('Parameters in function rightLogShift must be integer numbers');
|
||||
}
|
||||
|
||||
return x >>> y;
|
||||
}
|
||||
|
||||
@ -49,14 +54,14 @@ module.exports = function (math, config) {
|
||||
}
|
||||
|
||||
if (isString(x)) {
|
||||
return rightLogShift((config.number == 'bignumber')
|
||||
? new BigNumber(x)
|
||||
: parseInt(x), y);
|
||||
return rightLogShift((config.number === 'bignumber')
|
||||
? BigNumber.convert(x)
|
||||
: +x, y);
|
||||
}
|
||||
if (isString(y)) {
|
||||
return rightLogShift(x, (config.number == 'bignumber')
|
||||
? new BigNumber(y)
|
||||
: parseInt(y));
|
||||
return rightLogShift(x, (config.number === 'bignumber')
|
||||
? BigNumber.convert(y)
|
||||
: +y);
|
||||
}
|
||||
|
||||
if (isBoolean(x) || x === null) {
|
||||
|
||||
109
lib/function/boolean/and.js
Normal file
109
lib/function/boolean/and.js
Normal file
@ -0,0 +1,109 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (math) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
BigNumber = math.type.BigNumber,
|
||||
Complex = require('../../type/Complex'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isComplex = Complex.isComplex,
|
||||
isUnit = Unit.isUnit,
|
||||
isCollection = collection.isCollection;
|
||||
|
||||
/**
|
||||
* Test whether two values are both defined with a nonzero/nonempty value.
|
||||
*
|
||||
* Syntax:
|
||||
*
|
||||
* math.and(x, y)
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* math.and(2, 4); // returns true
|
||||
*
|
||||
* a = [2, 5, 1];
|
||||
* b = [2, 7, 1];
|
||||
* c = 0;
|
||||
*
|
||||
* math.and(a, b); // returns true
|
||||
* math.and(a, c); // returns false
|
||||
*
|
||||
* See also:
|
||||
*
|
||||
* not, or
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} x First value to check
|
||||
* @param {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} y Second value to check
|
||||
* @return {Boolean}
|
||||
* Returns true when both inputs are defined with a nonzero/nonempty value.
|
||||
*/
|
||||
math.and = function and(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
throw new math.error.ArgumentsError('and', arguments.length, 2);
|
||||
}
|
||||
|
||||
if (isComplex(x)) {
|
||||
if (x.re == 0 && x.im == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(true, y);
|
||||
}
|
||||
if (isComplex(y)) {
|
||||
if (y.re == 0 && y.im == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(x, true);
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
if (x.isZero() || x.isNaN()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(true, y);
|
||||
}
|
||||
if (y instanceof BigNumber) {
|
||||
if (y.isZero() || y.isNaN()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(x, true);
|
||||
}
|
||||
|
||||
if (isUnit(x)) {
|
||||
if (x.value === null || x.value == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(true, y);
|
||||
}
|
||||
if (isUnit(y)) {
|
||||
if (y.value === null || y.value == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(x, true);
|
||||
}
|
||||
|
||||
if (isCollection(x)) {
|
||||
if (x.length == 0 || (x.size && x.size() == 0)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(true, y);
|
||||
}
|
||||
if (isCollection(y)) {
|
||||
if (y.length == 0 || (y.size && y.size() == 0)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return and(x, true);
|
||||
}
|
||||
|
||||
return !!(x && y);
|
||||
};
|
||||
};
|
||||
65
lib/function/boolean/not.js
Normal file
65
lib/function/boolean/not.js
Normal file
@ -0,0 +1,65 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (math) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
BigNumber = math.type.BigNumber,
|
||||
Complex = require('../../type/Complex'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isComplex = Complex.isComplex,
|
||||
isUnit = Unit.isUnit,
|
||||
isCollection = collection.isCollection;
|
||||
|
||||
/**
|
||||
* Flips boolean value of a given parameter.
|
||||
*
|
||||
* Syntax:
|
||||
*
|
||||
* math.not(x)
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* math.not(2); // returns false
|
||||
* math.not(0); // returns true
|
||||
* math.not(true); // returns false
|
||||
*
|
||||
* a = [];
|
||||
* b = [2, 7, 1];
|
||||
*
|
||||
* math.and(a); // returns true
|
||||
* math.and(b); // returns false
|
||||
*
|
||||
* See also:
|
||||
*
|
||||
* and, or
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} x First value to check
|
||||
* @return {Boolean}
|
||||
* Returns true when input is a zero or empty value.
|
||||
*/
|
||||
math.not = function not(x) {
|
||||
if (arguments.length != 1) {
|
||||
throw new math.error.ArgumentsError('not', arguments.length, 1);
|
||||
}
|
||||
|
||||
if (isComplex(x)) {
|
||||
return x.re == 0 && x.im == 0;
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
return x.isZero() || x.isNaN();
|
||||
}
|
||||
|
||||
if (isUnit(x)) {
|
||||
return x.value === null || x.value == 0;
|
||||
}
|
||||
|
||||
if (isCollection(x)) {
|
||||
return !!(x.length == 0 || (x.size && x.size() == 0));
|
||||
}
|
||||
|
||||
return !x;
|
||||
};
|
||||
};
|
||||
101
lib/function/boolean/or.js
Normal file
101
lib/function/boolean/or.js
Normal file
@ -0,0 +1,101 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (math) {
|
||||
var util = require('../../util/index'),
|
||||
|
||||
BigNumber = math.type.BigNumber,
|
||||
Complex = require('../../type/Complex'),
|
||||
Unit = require('../../type/Unit'),
|
||||
collection = require('../../type/collection'),
|
||||
|
||||
isComplex = Complex.isComplex,
|
||||
isUnit = Unit.isUnit,
|
||||
isCollection = collection.isCollection;
|
||||
|
||||
/**
|
||||
* Test if at least one value is defined with a nonzero/nonempty value.
|
||||
*
|
||||
* Syntax:
|
||||
*
|
||||
* math.or(x, y)
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* math.or(2, 4); // returns true
|
||||
*
|
||||
* a = [2, 5, 1];
|
||||
* b = [];
|
||||
* c = 0;
|
||||
*
|
||||
* math.or(a, b); // returns true
|
||||
* math.or(b, c); // returns false
|
||||
*
|
||||
* See also:
|
||||
*
|
||||
* and, not
|
||||
*
|
||||
* @param {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} x First value to check
|
||||
* @param {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} y Second value to check
|
||||
* @return {Boolean}
|
||||
* Returns true when one of the inputs is defined with a nonzero/nonempty value.
|
||||
*/
|
||||
math.or = function or(x, y) {
|
||||
if (arguments.length != 2) {
|
||||
throw new math.error.ArgumentsError('or', arguments.length, 2);
|
||||
}
|
||||
|
||||
if (isComplex(x)) {
|
||||
if (x.re == 0 && x.im == 0) {
|
||||
return or(false, y);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (isComplex(y)) {
|
||||
if (y.re == 0 && y.im == 0) {
|
||||
return or(x, false);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if (x instanceof BigNumber) {
|
||||
if (x.isZero() || x.isNaN()) {
|
||||
return or(false, y);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (y instanceof BigNumber) {
|
||||
if (y.isZero() || y.isNaN()) {
|
||||
return or(x, false);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if (isUnit(x)) {
|
||||
if (x.value === null || x.value == 0) {
|
||||
return or(false, y);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (isUnit(y)) {
|
||||
if (y.value === null || y.value == 0) {
|
||||
return or(x, false);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if (isCollection(x)) {
|
||||
if (x.length == 0 || (x.size && x.size() == 0)) {
|
||||
return or(false, y);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (isCollection(y)) {
|
||||
if (y.length == 0 || (y.size && y.size() == 0)) {
|
||||
return or(x, false);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
return !!(x || y);
|
||||
};
|
||||
};
|
||||
@ -52,8 +52,8 @@ module.exports = function (math) {
|
||||
if (isComplex(x)) {
|
||||
// cos(z) = (exp(iz) + exp(-iz)) / 2
|
||||
return new Complex(
|
||||
0.5 * Math.cos(x.re) * (Math.exp(-x.im) + Math.exp(x.im)),
|
||||
0.5 * Math.sin(x.re) * (Math.exp(-x.im) - Math.exp(x.im))
|
||||
Math.cos(x.re) * math.cosh(-x.im),
|
||||
Math.sin(x.re) * math.sinh(-x.im)
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@ -51,8 +51,8 @@ module.exports = function (math) {
|
||||
|
||||
if (isComplex(x)) {
|
||||
return new Complex(
|
||||
0.5 * Math.sin(x.re) * (Math.exp(-x.im) + Math.exp( x.im)),
|
||||
0.5 * Math.cos(x.re) * (Math.exp( x.im) - Math.exp(-x.im))
|
||||
Math.sin(x.re) * math.cosh(-x.im),
|
||||
Math.cos(x.re) * math.sinh(x.im)
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@ -41,7 +41,11 @@ module.exports = function (math) {
|
||||
}
|
||||
|
||||
if (isNumber(x)) {
|
||||
return (Math.exp(x) - Math.exp(-x)) / 2;
|
||||
if (Math.abs(x) < 1) {
|
||||
return x + (x * x * x) / 6 + (x * x * x * x * x) / 120;
|
||||
} else {
|
||||
return (Math.exp(x) - Math.exp(-x)) / 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (isComplex(x)) {
|
||||
|
||||
@ -216,6 +216,11 @@ function create (config) {
|
||||
require('./function/bitwise/rightArithShift')(math, _config);
|
||||
require('./function/bitwise/rightLogShift')(math, _config);
|
||||
|
||||
// functions - boolean
|
||||
require('./function/boolean/and')(math, _config);
|
||||
require('./function/boolean/not')(math, _config);
|
||||
require('./function/boolean/or')(math, _config);
|
||||
|
||||
// functions - relational
|
||||
require('./function/relational/compare')(math, _config);
|
||||
require('./function/relational/deepEqual')(math, _config);
|
||||
|
||||
@ -347,6 +347,7 @@ Unit.prototype.equals = function(other) {
|
||||
*/
|
||||
Unit.prototype.to = function (valuelessUnit) {
|
||||
var other;
|
||||
var value = this.value == null ? this._normalize(1) : this.value;
|
||||
if (isString(valuelessUnit)) {
|
||||
other = new Unit(null, valuelessUnit);
|
||||
|
||||
@ -354,7 +355,7 @@ Unit.prototype.to = function (valuelessUnit) {
|
||||
throw new Error('Units do not match');
|
||||
}
|
||||
|
||||
other.value = this.value;
|
||||
other.value = value;
|
||||
other.fixPrefix = true;
|
||||
return other;
|
||||
}
|
||||
@ -367,7 +368,7 @@ Unit.prototype.to = function (valuelessUnit) {
|
||||
}
|
||||
|
||||
other = valuelessUnit.clone();
|
||||
other.value = this.value;
|
||||
other.value = value;
|
||||
other.fixPrefix = true;
|
||||
return other;
|
||||
}
|
||||
|
||||
@ -13,6 +13,10 @@ exports.isBigNumber = function (value) {
|
||||
return (value instanceof BigNumber);
|
||||
};
|
||||
|
||||
|
||||
/* BigNumber constants. */
|
||||
|
||||
|
||||
/**
|
||||
* Calculate BigNumber e
|
||||
* @param {Number} precision
|
||||
@ -98,6 +102,290 @@ exports.tau = function (precision) {
|
||||
return new Big(2).times(pi);
|
||||
};
|
||||
|
||||
|
||||
/* BigNumber functions. */
|
||||
|
||||
|
||||
/*
|
||||
* Special Cases:
|
||||
* N & n = N
|
||||
* n & 0 = 0
|
||||
* n & -1 = n
|
||||
* n & n = n
|
||||
* I & I = I
|
||||
* -I & -I = -I
|
||||
* I & -I = 0
|
||||
* I & n = n
|
||||
* I & -n = I
|
||||
* -I & n = 0
|
||||
* -I & -n = -I
|
||||
*
|
||||
* @param {BigNumber} value
|
||||
* @param {BigNumber} value
|
||||
* @return {BigNumber} Result of `x` & `y`, is fully precise
|
||||
*
|
||||
*/
|
||||
exports.and = function(x, y) {
|
||||
if ((x.isFinite() && !x.isInteger()) || (y.isFinite() && !y.isInteger())) {
|
||||
throw new Error('Parameters in function bitAnd must be integer numbers');
|
||||
}
|
||||
|
||||
var BigNumber = x['constructor'];
|
||||
if (x.isNaN() || y.isNaN()) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
|
||||
if (x.isZero() || y.eq(-1) || x.eq(y)) {
|
||||
return x;
|
||||
}
|
||||
if (y.isZero() || x.eq(-1)) {
|
||||
return y;
|
||||
}
|
||||
|
||||
if (!x.isFinite() || !y.isFinite()) {
|
||||
if (!x.isFinite() && !y.isFinite()) {
|
||||
if (x.isNegative() == y.isNegtive()) {
|
||||
return x;
|
||||
}
|
||||
return new BigNumber(0);
|
||||
}
|
||||
if (!x.isFinite()) {
|
||||
if (y.isNegative()) {
|
||||
return x;
|
||||
}
|
||||
if (x.isNegative()) {
|
||||
return new BigNumber(0);
|
||||
}
|
||||
return y;
|
||||
}
|
||||
if (!y.isFinite()) {
|
||||
if (x.isNegative()) {
|
||||
return y;
|
||||
}
|
||||
if (y.isNegative()) {
|
||||
return new BigNumber(0);
|
||||
}
|
||||
return x;
|
||||
}
|
||||
}
|
||||
return bitwise(x, y, function (a, b) { return a & b });
|
||||
};
|
||||
|
||||
/*
|
||||
* Special Cases:
|
||||
* n << -n = N
|
||||
* n << N = N
|
||||
* N << n = N
|
||||
* n << 0 = n
|
||||
* 0 << n = 0
|
||||
* I << I = N
|
||||
* I << n = I
|
||||
* n << I = I
|
||||
*
|
||||
* @param {BigNumber} value
|
||||
* @param {BigNumber} value
|
||||
* @return {BigNumber} Result of `x` << `y`
|
||||
*
|
||||
*/
|
||||
exports.leftShift = function (x, y) {
|
||||
if ((x.isFinite() && !x.isInteger()) || (y.isFinite() && !y.isInteger())) {
|
||||
throw new Error('Parameters in function leftShift must be integer numbers');
|
||||
}
|
||||
|
||||
var BigNumber = x['constructor'];
|
||||
if (x.isNaN() || y.isNaN() || (y.isNegative() && !y.isZero())) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
if (x.isZero() || y.isZero()) {
|
||||
return x;
|
||||
}
|
||||
if (!x.isFinite() && !y.isFinite()) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
|
||||
// Math.pow(2, y) is fully precise for y < 55, and fast
|
||||
if (y.lt(55)) {
|
||||
return x.times(Math.pow(2, y.toNumber()) + '');
|
||||
}
|
||||
return x.times(new BigNumber(2).pow(y));
|
||||
};
|
||||
|
||||
/*
|
||||
* @param {BigNumber} value
|
||||
* @return {BigNumber} Result of ~`x`, fully precise
|
||||
*
|
||||
*/
|
||||
exports.not = function (x) {
|
||||
if (x.isFinite() && !x.isInteger()) {
|
||||
throw new Error('Parameter in function bitNot must be integer numbers');
|
||||
}
|
||||
|
||||
var BigNumber = x['constructor'];
|
||||
var prevPrec = BigNumber['precision'];
|
||||
BigNumber['precision'] = 1E9;
|
||||
|
||||
var x = x.plus(BigNumber['ONE']);
|
||||
x['s'] = -x['s'] || null;
|
||||
|
||||
BigNumber['precision'] = prevPrec;
|
||||
return x;
|
||||
};
|
||||
|
||||
/*
|
||||
* Special Cases:
|
||||
* N | n = N
|
||||
* n | 0 = n
|
||||
* n | -1 = -1
|
||||
* n | n = n
|
||||
* I | I = I
|
||||
* -I | -I = -I
|
||||
* I | -n = -1
|
||||
* I | -I = -1
|
||||
* I | n = I
|
||||
* -I | n = -I
|
||||
* -I | -n = -n
|
||||
*
|
||||
* @param {BigNumber} value
|
||||
* @param {BigNumber} value
|
||||
* @return {BigNumber} Result of `x` | `y`, fully precise
|
||||
*
|
||||
*/
|
||||
exports.or = function (x, y) {
|
||||
if ((x.isFinite() && !x.isInteger()) || (y.isFinite() && !y.isInteger())) {
|
||||
throw new Error('Parameters in function bitOr must be integer numbers');
|
||||
}
|
||||
|
||||
var BigNumber = x['constructor'];
|
||||
if (x.isNaN() || y.isNaN()) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
|
||||
var negOne = new BigNumber(-1);
|
||||
if (x.isZero() || y.eq(negOne) || x.eq(y)) {
|
||||
return y;
|
||||
}
|
||||
if (y.isZero() || x.eq(negOne)) {
|
||||
return x;
|
||||
}
|
||||
|
||||
if (!x.isFinite() || !y.isFinite()) {
|
||||
if ((!x.isFinite() && !x.isNegative() && y.isNegative()) ||
|
||||
(x.isNegative() && !y.isNegative() && !y.isFinite())) {
|
||||
return negOne;
|
||||
}
|
||||
if (x.isNegative() && y.isNegative()) {
|
||||
return x.isFinite() ? x : y;
|
||||
}
|
||||
return x.isFinite() ? y : x;
|
||||
}
|
||||
return bitwise(x, y, function (a, b) { return a | b });
|
||||
};
|
||||
|
||||
/*
|
||||
* Special Cases:
|
||||
* n >> -n = N
|
||||
* n >> N = N
|
||||
* N >> n = N
|
||||
* I >> I = N
|
||||
* n >> 0 = n
|
||||
* I >> n = I
|
||||
* -I >> n = -I
|
||||
* -I >> I = -I
|
||||
* n >> I = I
|
||||
* -n >> I = -1
|
||||
* 0 >> n = 0
|
||||
*
|
||||
* @param {BigNumber} value
|
||||
* @param {BigNumber} value
|
||||
* @return {BigNumber} Result of `x` >> `y`
|
||||
*
|
||||
*/
|
||||
exports.rightShift = function (x, y) {
|
||||
if ((x.isFinite() && !x.isInteger()) || (y.isFinite() && !y.isInteger())) {
|
||||
throw new Error('Parameters in function rightArithShift must be integer numbers');
|
||||
}
|
||||
|
||||
var BigNumber = x['constructor'];
|
||||
if (x.isNaN() || y.isNaN() || (y.isNegative() && !y.isZero())) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
if (x.isZero() || y.isZero()) {
|
||||
return x;
|
||||
}
|
||||
if (!y.isFinite()) {
|
||||
if (x.isNegative()) {
|
||||
return new BigNumber(-1);
|
||||
}
|
||||
if (!x.isFinite()) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
return new BigNumber(0);
|
||||
}
|
||||
|
||||
// Math.pow(2, y) is fully precise for y < 55, and fast
|
||||
if (y.lt(55)) {
|
||||
return x.div(Math.pow(2, y.toNumber()) + '').floor();
|
||||
}
|
||||
return x.div(new BigNumber(2).pow(y)).floor();
|
||||
};
|
||||
|
||||
/*
|
||||
* Special Cases:
|
||||
* N ^ n = N
|
||||
* n ^ 0 = n
|
||||
* n ^ n = 0
|
||||
* n ^ -1 = ~n
|
||||
* I ^ n = I
|
||||
* I ^ -n = -I
|
||||
* I ^ -I = -1
|
||||
* -I ^ n = -I
|
||||
* -I ^ -n = I
|
||||
*
|
||||
* @param {BigNumber} value
|
||||
* @param {BigNumber} value
|
||||
* @return {BigNumber} Result of `x` ^ `y`, fully precise
|
||||
*
|
||||
*/
|
||||
exports.xor = function (x, y) {
|
||||
if ((x.isFinite() && !x.isInteger()) || (y.isFinite() && !y.isInteger())) {
|
||||
throw new Error('Parameters in function bitXor must be integer numbers');
|
||||
}
|
||||
|
||||
var BigNumber = x['constructor'];
|
||||
if (x.isNaN() || y.isNaN()) {
|
||||
return new BigNumber(NaN);
|
||||
}
|
||||
if (x.isZero()) {
|
||||
return y;
|
||||
}
|
||||
if (y.isZero()) {
|
||||
return x;
|
||||
}
|
||||
|
||||
if (x.eq(y)) {
|
||||
return new BigNumber(0);
|
||||
}
|
||||
|
||||
var negOne = new BigNumber(-1);
|
||||
if (x.eq(negOne)) {
|
||||
return exports.not(y);
|
||||
}
|
||||
if (y.eq(negOne)) {
|
||||
return exports.not(x);
|
||||
}
|
||||
|
||||
if (!x.isFinite() || !y.isFinite()) {
|
||||
if (!x.isFinite() && !y.isFinite()) {
|
||||
return negOne;
|
||||
}
|
||||
return new BigNumber(x.isNegative() == y.isNegative()
|
||||
? Infinity
|
||||
: -Infinity);
|
||||
}
|
||||
return bitwise(x, y, function (a, b) { return a ^ b });
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Convert a number to a formatted string representation.
|
||||
*
|
||||
@ -281,3 +569,127 @@ exports.toFixed = function(value, precision) {
|
||||
// Note: the (precision || 0) is needed as the toFixed of BigNumber has an
|
||||
// undefined default precision instead of 0.
|
||||
};
|
||||
|
||||
|
||||
/* Private functions. */
|
||||
|
||||
|
||||
function bitwise(x, y, func) {
|
||||
var BigNumber = x['constructor'];
|
||||
|
||||
var xBits, yBits;
|
||||
var xSign = +(x['s'] < 0);
|
||||
var ySign = +(y['s'] < 0);
|
||||
if (xSign) {
|
||||
xBits = decToBinary(coefficientToString(exports.not(x)));
|
||||
for (var i = 0; i < xBits.length; ++i) {
|
||||
xBits[i] ^= 1;
|
||||
}
|
||||
} else {
|
||||
xBits = decToBinary(coefficientToString(x));
|
||||
}
|
||||
if (ySign) {
|
||||
yBits = decToBinary(coefficientToString(exports.not(y)));
|
||||
for (var i = 0; i < yBits.length; ++i) {
|
||||
yBits[i] ^= 1;
|
||||
}
|
||||
} else {
|
||||
yBits = decToBinary(coefficientToString(y));
|
||||
}
|
||||
|
||||
var minBits, maxBits, minSign;
|
||||
if (xBits.length <= yBits.length) {
|
||||
minBits = xBits;
|
||||
maxBits = yBits;
|
||||
minSign = xSign;
|
||||
} else {
|
||||
minBits = yBits;
|
||||
maxBits = xBits;
|
||||
minSign = ySign;
|
||||
}
|
||||
|
||||
var shortLen = minBits.length;
|
||||
var longLen = maxBits.length;
|
||||
var expFuncVal = func(xSign, ySign) ^ 1;
|
||||
var outVal = new BigNumber(expFuncVal ^ 1);
|
||||
var twoPower = BigNumber['ONE'];
|
||||
var two = new BigNumber(2);
|
||||
|
||||
var prevPrec = BigNumber['precision'];
|
||||
BigNumber['precision'] = 1E9;
|
||||
|
||||
while (shortLen > 0) {
|
||||
if (func(minBits[--shortLen], maxBits[--longLen]) == expFuncVal) {
|
||||
outVal = outVal.plus(twoPower);
|
||||
}
|
||||
twoPower = twoPower.times(two);
|
||||
}
|
||||
while (longLen > 0) {
|
||||
if (func(minSign, maxBits[--longLen]) == expFuncVal) {
|
||||
outVal = outVal.plus(twoPower);
|
||||
}
|
||||
twoPower = twoPower.times(two);
|
||||
}
|
||||
|
||||
BigNumber['precision'] = prevPrec;
|
||||
|
||||
if (expFuncVal == 0) {
|
||||
outVal['s'] = -outVal['s'];
|
||||
}
|
||||
return outVal;
|
||||
}
|
||||
|
||||
|
||||
/* Private functions extracted from decimal.js, and edited to specialize. */
|
||||
|
||||
|
||||
function coefficientToString(x) {
|
||||
var a = x['c'];
|
||||
var r = a[0] + '';
|
||||
|
||||
for (var i = 1; i < a.length; ++i) {
|
||||
var s = a[i] + '';
|
||||
for (var z = 7 - s.length; z--; ) {
|
||||
s = '0' + s;
|
||||
}
|
||||
|
||||
r += s;
|
||||
}
|
||||
|
||||
var j;
|
||||
for (j = r.length - 1; r.charAt(j) == '0'; --j);
|
||||
|
||||
var xe = x['e'];
|
||||
var str = r.slice(0, j + 1 || 1);
|
||||
var strL = str.length;
|
||||
if (xe > 0) {
|
||||
if (++xe > strL) {
|
||||
// Append zeros.
|
||||
for (xe -= strL; xe--; str += '0');
|
||||
} else if (xe < strL) {
|
||||
str = str.slice(0, xe) + '.' + str.slice(xe);
|
||||
}
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
function decToBinary(str) {
|
||||
var arr = [0];
|
||||
for (var i = 0; i < str.length; ) {
|
||||
for (var arrL = arr.length; arrL--; arr[arrL] *= 10);
|
||||
|
||||
arr[0] += str.charAt(i++) << 0; // convert to int
|
||||
for (var j = 0; j < arr.length; ++j) {
|
||||
if (arr[j] > 1) {
|
||||
if (arr[j + 1] == null) {
|
||||
arr[j + 1] = 0;
|
||||
}
|
||||
|
||||
arr[j + 1] += arr[j] >> 1;
|
||||
arr[j] &= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return arr.reverse();
|
||||
}
|
||||
|
||||
@ -123,7 +123,6 @@ describe('parse', function() {
|
||||
|
||||
it('should give informative syntax errors', function() {
|
||||
assert.throws(function () {parse('2 +')}, /Unexpected end of expression \(char 4\)/);
|
||||
assert.throws(function () {parse('2 ~ 3')}, /Syntax error in part "~ 3" \(char 3\)/);
|
||||
assert.throws(function () {parse('2 + 3 + *')}, /Value expected \(char 9\)/);
|
||||
});
|
||||
|
||||
@ -858,13 +857,47 @@ describe('parse', function() {
|
||||
assert.equal(parseAndEval('5++3'), 8);
|
||||
});
|
||||
|
||||
it('should parse unary ~', function() {
|
||||
assert.equal(parseAndEval('~2'), -3);
|
||||
assert.equal(parseAndEval('~~2'), 2);
|
||||
assert.equal(parseAndEval('~~~2'), -3);
|
||||
assert.equal(parseAndEval('~true'), -2);
|
||||
|
||||
assert.equal(parseAndEval('4*~2'), -12);
|
||||
assert.equal(parseAndEval('4 * ~2'), -12);
|
||||
assert.equal(parseAndEval('4-~2'), 7);
|
||||
assert.equal(parseAndEval('4 - ~2'), 7);
|
||||
assert.equal(parseAndEval('4+~2'), 1);
|
||||
assert.equal(parseAndEval('4 + ~2'), 1);
|
||||
|
||||
assert.equal(parseAndEval('10+~3'), 6);
|
||||
});
|
||||
|
||||
it('should parse unary plus and minus +, -', function() {
|
||||
assert.equal(parseAndEval('-+2'), -2);
|
||||
assert.equal(parseAndEval('-+-2'), 2);
|
||||
assert.equal(parseAndEval('+-+-2'), 2);
|
||||
assert.equal(parseAndEval('+-2'), -2);
|
||||
assert.equal(parseAndEval('+-+2'), -2);
|
||||
assert.equal(parseAndEval('+-+-2'), 2);
|
||||
assert.equal(parseAndEval('-+-+2'), 2);
|
||||
});
|
||||
|
||||
it('should parse unary plus and bitwise not +, ~', function() {
|
||||
assert.equal(parseAndEval('~+2'), -3);
|
||||
assert.equal(parseAndEval('~+~2'), 2);
|
||||
assert.equal(parseAndEval('+~+~2'), 2);
|
||||
assert.equal(parseAndEval('+~2'), -3);
|
||||
assert.equal(parseAndEval('+~+2'), -3);
|
||||
assert.equal(parseAndEval('~+~+2'), 2);
|
||||
});
|
||||
|
||||
it('should parse unary minus and bitwise not -, ~', function() {
|
||||
assert.equal(parseAndEval('~-2'), 1);
|
||||
assert.equal(parseAndEval('~-~2'), -4);
|
||||
assert.equal(parseAndEval('-~-~2'), 4);
|
||||
assert.equal(parseAndEval('-~2'), 3);
|
||||
assert.equal(parseAndEval('-~-2'), -1);
|
||||
assert.equal(parseAndEval('~-~-2'), 0);
|
||||
});
|
||||
|
||||
it('should parse unequal !=', function() {
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
// test bitAnd
|
||||
var assert = require('assert'),
|
||||
approx = require('../../../tools/approx'),
|
||||
error = require('../../../lib/error/index'),
|
||||
math = require('../../../index'),
|
||||
//bignumber = math.bignumber,
|
||||
bignumber = math.bignumber,
|
||||
bitAnd = math.bitAnd;
|
||||
|
||||
describe('bitAnd', function () {
|
||||
@ -36,12 +35,13 @@ describe('bitAnd', function () {
|
||||
assert.equal(bitAnd(false, 1), 0);
|
||||
});
|
||||
|
||||
/*it('should bitwise and bignumbers', function () {
|
||||
it('should bitwise and bignumbers', function () {
|
||||
assert.deepEqual(bitAnd(bignumber(1), bignumber(2)), bignumber(0));
|
||||
assert.deepEqual(bitAnd(bignumber('-1.0e+31'), bignumber('-1.0e+32')), bignumber('-1.0127339798528531708e+32'));
|
||||
assert.deepEqual(bitAnd(bignumber('1.0e+31'), bignumber('1.0e+32')), bignumber('8.726602014714682918e+30'));
|
||||
assert.deepEqual(bitAnd(bignumber('-1.0e+31'), bignumber('1.0e+32')), bignumber('9.1273397985285317082e+31'));
|
||||
assert.deepEqual(bitAnd(bignumber('1.0e+31'), bignumber('-1.0e+32')), bignumber('1.273397985285317082e+30'));
|
||||
assert.deepEqual(bitAnd(bignumber('-1.0e+31'), bignumber('-1.0e+32')), bignumber('-101273397985285317082036849082368'));
|
||||
assert.deepEqual(bitAnd(bignumber('1.0e+31'), bignumber('1.0e+32')), bignumber('8726602014714682917961003433984'));
|
||||
assert.deepEqual(bitAnd(bignumber('-1.0e+31'), bignumber('1.0e+32')), bignumber('91273397985285317082038996566016'));
|
||||
assert.deepEqual(bitAnd(bignumber('1.0e+31'), bignumber('-1.0e+32')), bignumber('1273397985285317082036849082368'));
|
||||
assert.deepEqual(bitAnd(bignumber('2.1877409333271352879E+75'), bignumber('-3.220131224058161211554E+42')), bignumber('2187740933327135287899999999999996863578490213829130431270426161710498840576'));
|
||||
});
|
||||
|
||||
it('should bitwise and mixed numbers and bignumbers', function () {
|
||||
@ -56,7 +56,12 @@ describe('bitAnd', function () {
|
||||
assert.deepEqual(bitAnd(bignumber(1), false), bignumber(0));
|
||||
assert.deepEqual(bitAnd(false, bignumber(3)), bignumber(0));
|
||||
assert.deepEqual(bitAnd(true, bignumber(3)), bignumber(1));
|
||||
});*/
|
||||
});
|
||||
|
||||
it('should bitwise and mixed strings and bignumbers', function () {
|
||||
assert.deepEqual(bitAnd(bignumber('-1.0e+31'), '-1.0e+32'), bignumber('-101273397985285317082036849082368'));
|
||||
assert.deepEqual(bitAnd('1.0e+32', bignumber('1.0e+31')), bignumber('8726602014714682917961003433984'));
|
||||
});
|
||||
|
||||
it('should throw an error if used with a unit', function() {
|
||||
assert.throws(function () {bitAnd(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
|
||||
@ -69,6 +74,37 @@ describe('bitAnd', function () {
|
||||
assert.equal(bitAnd('86', 120), 80);
|
||||
assert.equal(bitAnd('-120', '-86'), -120);
|
||||
assert.equal(bitAnd(-120, '-86'), -120);
|
||||
assert.equal(bitAnd(-120, '-86e2'), -8696);
|
||||
});
|
||||
|
||||
it('should throw an error if the parameters are not integers', function () {
|
||||
assert.throws(function () {
|
||||
bitAnd(1.1, 1);
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd(1, 1.1);
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd(1.1, 1.1);
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd('1.1', 1);
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd(1, '1.1');
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd(bignumber(1.1), 1);
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd(1, bignumber(1.1));
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd(bignumber(1.1), bignumber(1));
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitAnd(bignumber(1), bignumber(1.1));
|
||||
}, /Parameters in function bitAnd must be integer numbers/);
|
||||
});
|
||||
|
||||
it('should bitwise and strings and matrices element wise', function () {
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
var assert = require('assert'),
|
||||
math = require('../../../index'),
|
||||
error = require('../../../lib/error/index'),
|
||||
// bignumber = math.bignumber,
|
||||
bignumber = math.bignumber,
|
||||
bitNot = math.bitNot;
|
||||
|
||||
describe('bitNot', function () {
|
||||
@ -11,12 +11,6 @@ describe('bitNot', function () {
|
||||
assert.equal(bitNot(false), -1);
|
||||
});
|
||||
|
||||
/*it('should return bignumber bitwise not of a boolean', function () {
|
||||
var bigmath = math.create({number: 'bignumber'});
|
||||
assert.deepEqual(bigmath.bitNot(true), bigmath.bignumber(-2));
|
||||
assert.deepEqual(bigmath.bitNot(false), bigmath.bignumber(-1));
|
||||
});*/
|
||||
|
||||
it('should return bitwise not of null', function () {
|
||||
assert.equal(bitNot(null), -1);
|
||||
});
|
||||
@ -24,24 +18,32 @@ describe('bitNot', function () {
|
||||
it('should return bitwise not of a string', function () {
|
||||
assert.equal(bitNot('2'), -3);
|
||||
assert.equal(bitNot('-2'), 1);
|
||||
assert.equal(bitNot('-86e2'), 8599);
|
||||
});
|
||||
|
||||
/*it('should return bignumber bitwise not on a string', function() {
|
||||
var bigmath = math.create({number: 'bignumber'});
|
||||
assert.deepEqual(bigmath.bitNot('2'), bigmath.bignumber(-3));
|
||||
assert.deepEqual(bigmath.bitNot('-2'), bigmath.bignumber(1));
|
||||
});*/
|
||||
|
||||
it('should perform bitwise not of a number', function () {
|
||||
assert.deepEqual(bitNot(2), -3);
|
||||
assert.deepEqual(bitNot(-2), 1);
|
||||
assert.deepEqual(bitNot(0), -1);
|
||||
});
|
||||
|
||||
/*it('should perform bitwise not of a big number', function() {
|
||||
it('should perform bitwise not of a bignumber', function() {
|
||||
assert.deepEqual(bitNot(bignumber(2)), bignumber(-3));
|
||||
assert.deepEqual(bitNot(bignumber(-2)), bignumber(1));
|
||||
});*/
|
||||
assert.deepEqual(bitNot(bignumber('1.2345e30')), bignumber('-1234500000000000000000000000001'));
|
||||
});
|
||||
|
||||
it('should throw an error if the parameters are not integers', function () {
|
||||
assert.throws(function () {
|
||||
bitNot(1.1);
|
||||
}, /Parameter in function bitNot must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitNot('1.1');
|
||||
}, /Parameter in function bitNot must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitNot(bignumber(1.1));
|
||||
}, /Parameter in function bitNot must be integer numbers/);
|
||||
});
|
||||
|
||||
it('should throw an error if used with a unit', function() {
|
||||
assert.throws(function () {bitNot(math.unit('5cm'))}, error.UnsupportedTypeError);
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
// test bitOr
|
||||
var assert = require('assert'),
|
||||
approx = require('../../../tools/approx'),
|
||||
error = require('../../../lib/error/index'),
|
||||
math = require('../../../index'),
|
||||
//bignumber = math.bignumber,
|
||||
bignumber = math.bignumber,
|
||||
bitOr = math.bitOr;
|
||||
|
||||
describe('bitOr', function () {
|
||||
@ -36,6 +35,33 @@ describe('bitOr', function () {
|
||||
assert.equal(bitOr(false, 0), 0);
|
||||
});
|
||||
|
||||
it('should bitwise or bignumbers', function () {
|
||||
assert.deepEqual(bitOr(bignumber(1), bignumber(2)), bignumber(3));
|
||||
assert.deepEqual(bitOr(bignumber('-1.0e+31'), bignumber('-1.0e+32')), bignumber('-8726602014714682917963150917632'));
|
||||
assert.deepEqual(bitOr(bignumber('1.0e+31'), bignumber('1.0e+32')), bignumber('101273397985285317082038996566016'));
|
||||
assert.deepEqual(bitOr(bignumber('-1.0e+31'), bignumber('1.0e+32')), bignumber('-1273397985285317082038996566016'));
|
||||
assert.deepEqual(bitOr(bignumber('1.0e+31'), bignumber('-1.0e+32')), bignumber('-91273397985285317082036849082368'));
|
||||
});
|
||||
|
||||
it('should bitwise or mixed numbers and bignumbers', function () {
|
||||
assert.deepEqual(bitOr(bignumber(1), 2), bignumber(3));
|
||||
assert.deepEqual(bitOr(1, bignumber(2)), bignumber(3));
|
||||
assert.deepEqual(bitOr(bignumber(7), 9), bignumber(15));
|
||||
assert.deepEqual(bitOr(7, bignumber(9)), bignumber(15));
|
||||
});
|
||||
|
||||
it('should bitwise or mixed booleans and bignumbers', function () {
|
||||
assert.deepEqual(bitOr(bignumber(1), false), bignumber(1));
|
||||
assert.deepEqual(bitOr(bignumber(2), true), bignumber(3));
|
||||
assert.deepEqual(bitOr(false, bignumber(1)), bignumber(1));
|
||||
assert.deepEqual(bitOr(true, bignumber(2)), bignumber(3));
|
||||
});
|
||||
|
||||
it('should bitwise or mixed strings and bignumbers', function () {
|
||||
assert.deepEqual(bitOr('-1.0e+31', bignumber('-1.0e+32')), bignumber('-8726602014714682917963150917632'));
|
||||
assert.deepEqual(bitOr(bignumber('1.0e+31'), '1.0e+32'), bignumber('101273397985285317082038996566016'));
|
||||
});
|
||||
|
||||
it('should throw an error if used with a unit', function() {
|
||||
assert.throws(function () {bitOr(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
|
||||
assert.throws(function () {bitOr(2, math.unit('5cm'))}, error.UnsupportedTypeError);
|
||||
@ -47,6 +73,37 @@ describe('bitOr', function () {
|
||||
assert.equal(bitOr('86', 120), 126);
|
||||
assert.equal(bitOr('-120', '-86'), -86);
|
||||
assert.equal(bitOr(-120, '-86'), -86);
|
||||
assert.equal(bitOr(-120, '-86e2'), -24);
|
||||
});
|
||||
|
||||
it('should throw an error if the parameters are not integers', function () {
|
||||
assert.throws(function () {
|
||||
bitOr(1.1, 1);
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr(1, 1.1);
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr(1.1, 1.1);
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr('1.1', 1);
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr(1, '1.1');
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr(bignumber(1.1), 1);
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr(1, bignumber(1.1));
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr(bignumber(1.1), bignumber(1));
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitOr(bignumber(1), bignumber(1.1));
|
||||
}, /Parameters in function bitOr must be integer numbers/);
|
||||
});
|
||||
|
||||
it('should bitwise or strings and matrices element wise', function () {
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
// test bitXor
|
||||
var assert = require('assert'),
|
||||
approx = require('../../../tools/approx'),
|
||||
error = require('../../../lib/error/index'),
|
||||
math = require('../../../index'),
|
||||
//bignumber = math.bignumber,
|
||||
bignumber = math.bignumber,
|
||||
bitXor = math.bitXor;
|
||||
|
||||
describe('bitXor', function () {
|
||||
@ -38,6 +37,33 @@ describe('bitXor', function () {
|
||||
assert.equal(bitXor(false, 1), 1);
|
||||
});
|
||||
|
||||
it('should bitwise xor bignumbers', function () {
|
||||
assert.deepEqual(bitXor(bignumber(1), bignumber(2)), bignumber(3));
|
||||
assert.deepEqual(bitXor(bignumber('-1.0e+31'), bignumber('-1.0e+32')), bignumber('92546795970570634164073698164736'));
|
||||
assert.deepEqual(bitXor(bignumber('1.0e+31'), bignumber('1.0e+32')), bignumber('92546795970570634164077993132032'));
|
||||
assert.deepEqual(bitXor(bignumber('-1.0e+31'), bignumber('1.0e+32')), bignumber('-92546795970570634164077993132032'));
|
||||
assert.deepEqual(bitXor(bignumber('1.0e+31'), bignumber('-1.0e+32')), bignumber('-92546795970570634164073698164736'));
|
||||
});
|
||||
|
||||
it('should bitwise xor mixed numbers and bignumbers', function () {
|
||||
assert.deepEqual(bitXor(bignumber(1), 2), bignumber(3));
|
||||
assert.deepEqual(bitXor(1, bignumber(2)), bignumber(3));
|
||||
assert.deepEqual(bitXor(bignumber(7), 9), bignumber(14));
|
||||
assert.deepEqual(bitXor(7, bignumber(9)), bignumber(14));
|
||||
});
|
||||
|
||||
it('should bitwise xor mixed booleans and bignumbers', function () {
|
||||
assert.deepEqual(bitXor(bignumber(1), true), bignumber(0));
|
||||
assert.deepEqual(bitXor(bignumber(1), false), bignumber(1));
|
||||
assert.deepEqual(bitXor(true, bignumber(3)), bignumber(2));
|
||||
assert.deepEqual(bitXor(false, bignumber(3)), bignumber(3));
|
||||
});
|
||||
|
||||
it('should bitwise and mixed strings and bignumbers', function () {
|
||||
assert.deepEqual(bitXor(bignumber('-1.0e+31'), '-1.0e+32'), bignumber('92546795970570634164073698164736'));
|
||||
assert.deepEqual(bitXor('1.0e+31', bignumber('1.0e+32')), bignumber('92546795970570634164077993132032'));
|
||||
});
|
||||
|
||||
it('should throw an error if used with a unit', function() {
|
||||
assert.throws(function () {bitXor(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
|
||||
assert.throws(function () {bitXor(2, math.unit('5cm'))}, error.UnsupportedTypeError);
|
||||
@ -49,6 +75,37 @@ describe('bitXor', function () {
|
||||
assert.equal(bitXor('86', 120), 46);
|
||||
assert.equal(bitXor('-120', '-86'), 34);
|
||||
assert.equal(bitXor(-120, '-86'), 34);
|
||||
assert.equal(bitXor(-120, '-86e2'), 8672);
|
||||
});
|
||||
|
||||
it('should throw an error if the parameters are not integers', function () {
|
||||
assert.throws(function () {
|
||||
bitXor(1.1, 1);
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor(1, 1.1);
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor(1.1, 1.1);
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor('1.1', 1);
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor(1, '1.1');
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor(bignumber(1.1), 1);
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor(1, bignumber(1.1));
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor(bignumber(1.1), bignumber(1));
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
bitXor(bignumber(1), bignumber(1.1));
|
||||
}, /Parameters in function bitXor must be integer numbers/);
|
||||
});
|
||||
|
||||
it('should xor strings and matrices element wise', function () {
|
||||
|
||||
@ -3,7 +3,7 @@ var assert = require('assert'),
|
||||
approx = require('../../../tools/approx'),
|
||||
error = require('../../../lib/error/index'),
|
||||
math = require('../../../index'),
|
||||
//bignumber = math.bignumber,
|
||||
bignumber = math.bignumber,
|
||||
leftShift = math.leftShift;
|
||||
|
||||
describe('leftShift', function () {
|
||||
@ -38,18 +38,23 @@ describe('leftShift', function () {
|
||||
assert.equal(leftShift(null, 1), 0);
|
||||
});
|
||||
|
||||
/*it('should left shift bignumbers', function () {
|
||||
it('should left shift bignumbers', function () {
|
||||
assert.deepEqual(leftShift(bignumber(2), bignumber(3)), bignumber(16));
|
||||
assert.deepEqual(leftShift(bignumber(500), bignumber(100)), bignumber('633825300114114700748351602688000'));
|
||||
assert.deepEqual(leftShift(bignumber(-1), bignumber(2)), bignumber('-1'));
|
||||
assert.deepEqual(leftShift(bignumber(-1), bignumber(2)), bignumber(-4));
|
||||
assert.deepEqual(leftShift(bignumber(0), bignumber(-2)).toString(), 'NaN');
|
||||
assert.deepEqual(leftShift(bignumber(Infinity), bignumber(2)), bignumber(Infinity));
|
||||
assert.deepEqual(leftShift(bignumber(Infinity), bignumber(Infinity)).toString(), 'NaN');
|
||||
});
|
||||
|
||||
it('should left shift mixed numbers and bignumbers', function () {
|
||||
assert.deepEqual(leftShift(bignumber(2), 3), bignumber(16));
|
||||
assert.deepEqual(leftShift(bignumber(500), 100), bignumber('633825300114114700748351602688000'));
|
||||
assert.deepEqual(leftShift(2, bignumber(3)), bignumber(16));
|
||||
|
||||
approx.equal(leftShift(-1, bignumber(2)), bignumber(-4));
|
||||
approx.equal(leftShift(bignumber(-1), 2), bignumber(-4));
|
||||
assert.deepEqual(leftShift(-1, bignumber(2)), bignumber(-4));
|
||||
assert.deepEqual(leftShift(bignumber(-1), 2), bignumber(-4));
|
||||
assert.deepEqual(leftShift(bignumber(0), -2).toString(), 'NaN');
|
||||
assert.deepEqual(leftShift(bignumber(Infinity), Infinity).toString(), 'NaN');
|
||||
});
|
||||
|
||||
it('should left shift mixed booleans and bignumbers', function () {
|
||||
@ -57,7 +62,14 @@ describe('leftShift', function () {
|
||||
assert.deepEqual(leftShift(false, bignumber(3)), bignumber(0));
|
||||
assert.deepEqual(leftShift(bignumber(3), false), bignumber(3));
|
||||
assert.deepEqual(leftShift(bignumber(3), true), bignumber(6));
|
||||
});*/
|
||||
});
|
||||
|
||||
it('should left shift mixed bignumbers and string', function () {
|
||||
assert.deepEqual(leftShift(bignumber(2), '3'), bignumber(16));
|
||||
assert.deepEqual(leftShift('2', bignumber(3)), bignumber(16));
|
||||
assert.deepEqual(leftShift(bignumber(-1), '2'), bignumber(-4));
|
||||
assert.deepEqual(leftShift('-2', bignumber(3)), bignumber(-16));
|
||||
});
|
||||
|
||||
it('should throw an error if used with a unit', function() {
|
||||
assert.throws(function () {leftShift(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
|
||||
@ -70,6 +82,37 @@ describe('leftShift', function () {
|
||||
assert.equal(leftShift('2', 0), 2);
|
||||
assert.equal(leftShift(2, '3'), 16);
|
||||
assert.equal(leftShift('-2', 2), -8);
|
||||
assert.equal(leftShift(-2, '1e2'), -32);
|
||||
});
|
||||
|
||||
it('should throw an error if the parameters are not integers', function () {
|
||||
assert.throws(function () {
|
||||
leftShift(1.1, 1);
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift(1, 1.1);
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift(1.1, 1.1);
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift('1.1', 1);
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift(1, '1.1');
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift(bignumber(1.1), 1);
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift(1, bignumber(1.1));
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift(bignumber(1.1), bignumber(1));
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
leftShift(bignumber(1), bignumber(1.1));
|
||||
}, /Parameters in function leftShift must be integer numbers/);
|
||||
});
|
||||
|
||||
it('should element-wise left shift a matrix', function () {
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
// test rightArithShift
|
||||
var assert = require('assert'),
|
||||
//approx = require('../../../tools/approx'),
|
||||
error = require('../../../lib/error/index'),
|
||||
math = require('../../../index'),
|
||||
//bignumber = math.bignumber,
|
||||
bignumber = math.bignumber,
|
||||
rightArithShift = math.rightArithShift;
|
||||
|
||||
describe('rightArithShift', function () {
|
||||
@ -45,8 +44,73 @@ describe('rightArithShift', function () {
|
||||
assert.equal(rightArithShift('2', 0), 2);
|
||||
assert.equal(rightArithShift(22, '3'), 2);
|
||||
assert.equal(rightArithShift('-256', 2), -64);
|
||||
assert.equal(rightArithShift('-256', '1e2'), -16);
|
||||
});
|
||||
|
||||
it('should right arithmetically shift bignumbers', function () {
|
||||
assert.deepEqual(rightArithShift(bignumber(17), bignumber(3)), bignumber(2));
|
||||
assert.deepEqual(rightArithShift(bignumber('633825300114114700748351602688000'), bignumber(100)), bignumber(500));
|
||||
assert.deepEqual(rightArithShift(bignumber(-17), bignumber(3)), bignumber(-3));
|
||||
assert.deepEqual(rightArithShift(bignumber(-17), bignumber(-3)).toString(), 'NaN');
|
||||
assert.deepEqual(rightArithShift(bignumber(Infinity), bignumber(Infinity)).toString(), 'NaN');
|
||||
assert.deepEqual(rightArithShift(bignumber(-Infinity), bignumber(Infinity)), bignumber(-1));
|
||||
});
|
||||
|
||||
it('should right arithmetically shift mixed numbers and bignumbers', function () {
|
||||
assert.deepEqual(rightArithShift(bignumber(17), 3), bignumber(2));
|
||||
assert.deepEqual(rightArithShift(bignumber('-633825300114114700748351602688000'), 100), bignumber(-500));
|
||||
assert.deepEqual(rightArithShift(bignumber(-17), -3).toString(), 'NaN');
|
||||
assert.deepEqual(rightArithShift(17, bignumber(3)), bignumber(2));
|
||||
assert.deepEqual(rightArithShift(-17, bignumber(3)), bignumber(-3));
|
||||
assert.deepEqual(rightArithShift(-3, bignumber(-17)).toString(), 'NaN');
|
||||
assert.deepEqual(rightArithShift(bignumber(-Infinity), Infinity), bignumber(-1));
|
||||
assert.deepEqual(rightArithShift(bignumber(Infinity), Infinity).toString(), 'NaN');
|
||||
assert.deepEqual(rightArithShift(Infinity, bignumber(Infinity)).toString(), 'NaN');
|
||||
});
|
||||
|
||||
it('should right arithmetically shift mixed booleans and bignumbers', function () {
|
||||
assert.deepEqual(rightArithShift(true, bignumber(0)), bignumber(1));
|
||||
assert.deepEqual(rightArithShift(false, bignumber('1000000')), bignumber(0));
|
||||
assert.deepEqual(rightArithShift(bignumber(3), false), bignumber(3));
|
||||
assert.deepEqual(rightArithShift(bignumber(3), true), bignumber(1));
|
||||
});
|
||||
|
||||
it('should right arithmetically shift mixed bignumbers and string', function () {
|
||||
assert.deepEqual(rightArithShift(bignumber(17), '3'), bignumber(2));
|
||||
assert.deepEqual(rightArithShift('17', bignumber(3)), bignumber(2));
|
||||
assert.deepEqual(rightArithShift(bignumber('-17'), '3'), bignumber(-3));
|
||||
assert.deepEqual(rightArithShift('-17', bignumber(3)), bignumber(-3));
|
||||
});
|
||||
|
||||
it('should throw an error if the parameters are not integers', function () {
|
||||
assert.throws(function () {
|
||||
rightArithShift(1.1, 1);
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift(1, 1.1);
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift(1.1, 1.1);
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift('1.1', 1);
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift(1, '1.1');
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift(bignumber(1.1), 1);
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift(1, bignumber(1.1));
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift(bignumber(1.1), bignumber(1));
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightArithShift(bignumber(1), bignumber(1.1));
|
||||
}, /Parameters in function rightArithShift must be integer numbers/);
|
||||
});
|
||||
|
||||
it('should throw an error if used with a unit', function() {
|
||||
assert.throws(function () {rightArithShift(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
|
||||
|
||||
@ -1,9 +1,7 @@
|
||||
// test rightLogShift
|
||||
var assert = require('assert'),
|
||||
//approx = require('../../../tools/approx'),
|
||||
error = require('../../../lib/error/index'),
|
||||
math = require('../../../index'),
|
||||
//bignumber = math.bignumber,
|
||||
rightLogShift = math.rightLogShift;
|
||||
|
||||
describe('rightLogShift', function () {
|
||||
@ -45,8 +43,29 @@ describe('rightLogShift', function () {
|
||||
assert.equal(rightLogShift('2', 0), 2);
|
||||
assert.equal(rightLogShift(22, '3'), 2);
|
||||
assert.equal(rightLogShift('-256', 2), 1073741760);
|
||||
assert.equal(rightLogShift('-256', '1e2'), 268435440);
|
||||
});
|
||||
|
||||
it('should throw an error if the parameters are not integers', function () {
|
||||
assert.throws(function () {
|
||||
rightLogShift(1.1, 1);
|
||||
}, /Parameters in function rightLogShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightLogShift(1, 1.1);
|
||||
}, /Parameters in function rightLogShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightLogShift(1.1, 1.1);
|
||||
}, /Parameters in function rightLogShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightLogShift('1.1', '1.1');
|
||||
}, /Parameters in function rightLogShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightLogShift('1.1', 1);
|
||||
}, /Parameters in function rightLogShift must be integer numbers/);
|
||||
assert.throws(function () {
|
||||
rightLogShift(1, '1.1');
|
||||
}, /Parameters in function rightLogShift must be integer numbers/);
|
||||
});
|
||||
|
||||
it('should throw an error if used with a unit', function() {
|
||||
assert.throws(function () {rightLogShift(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
|
||||
|
||||
190
test/function/boolean/and.test.js
Normal file
190
test/function/boolean/and.test.js
Normal file
@ -0,0 +1,190 @@
|
||||
// test and
|
||||
var assert = require('assert'),
|
||||
math = require('../../../index'),
|
||||
error = require('../../../lib/error/index'),
|
||||
bignumber = math.bignumber,
|
||||
complex = math.complex,
|
||||
matrix = math.matrix,
|
||||
unit = math.unit,
|
||||
and = math.and;
|
||||
|
||||
describe('and', function () {
|
||||
|
||||
it('should and two numbers correctly', function () {
|
||||
assert.equal(and(1, 1), true);
|
||||
assert.equal(and(-1, 1), true);
|
||||
assert.equal(and(-1, -1), true);
|
||||
assert.equal(and(0, -1), false);
|
||||
assert.equal(and(1, 0), false);
|
||||
assert.equal(and(1, NaN), false);
|
||||
assert.equal(and(NaN, 1), false);
|
||||
assert.equal(and(1e10, 0.019209), true);
|
||||
assert.equal(and(-1.0e-100, 1.0e-100), true);
|
||||
assert.equal(and(Infinity, -Infinity), true);
|
||||
});
|
||||
|
||||
it('should and two complex numbers', function () {
|
||||
assert.equal(and(complex(1, 1), complex(1, 1)), true);
|
||||
assert.equal(and(complex(0, 1), complex(1, 1)), true);
|
||||
assert.equal(and(complex(1, 0), complex(1, 1)), true);
|
||||
assert.equal(and(complex(1, 1), complex(0, 1)), true);
|
||||
assert.equal(and(complex(1, 1), complex(1, 0)), true);
|
||||
assert.equal(and(complex(1, 0), complex(1, 0)), true);
|
||||
assert.equal(and(complex(0, 1), complex(0, 1)), true);
|
||||
assert.equal(and(complex(0, 0), complex(1, 1)), false);
|
||||
assert.equal(and(complex(0, 0), complex(0, 1)), false);
|
||||
assert.equal(and(complex(0, 0), complex(1, 0)), false);
|
||||
assert.equal(and(complex(1, 1), complex(0, 0)), false);
|
||||
assert.equal(and(complex(0, 1), complex(0, 0)), false);
|
||||
assert.equal(and(complex(1, 0), complex(0, 0)), false);
|
||||
assert.equal(and(complex(), complex(1, 1)), false);
|
||||
assert.equal(and(complex(0), complex(1, 1)), false);
|
||||
assert.equal(and(complex(1), complex(1, 1)), true);
|
||||
assert.equal(and(complex(1, 1), complex()), false);
|
||||
assert.equal(and(complex(1, 1), complex(0)), false);
|
||||
assert.equal(and(complex(1, 1), complex(1)), true);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and complex numbers', function () {
|
||||
assert.equal(and(complex(1, 1), 1), true);
|
||||
assert.equal(and(complex(1, 1), 0), false);
|
||||
assert.equal(and(1, complex(1, 1)), true);
|
||||
assert.equal(and(0, complex(1, 1)), false);
|
||||
assert.equal(and(complex(0, 0), 1), false);
|
||||
assert.equal(and(1, complex(0, 0)), false);
|
||||
});
|
||||
|
||||
it('should and two booleans', function () {
|
||||
assert.equal(and(true, true), true);
|
||||
assert.equal(and(true, false), false);
|
||||
assert.equal(and(false, true), false);
|
||||
assert.equal(and(false, false), false);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and booleans', function () {
|
||||
assert.equal(and(2, true), true);
|
||||
assert.equal(and(2, false), false);
|
||||
assert.equal(and(0, true), false);
|
||||
assert.equal(and(true, 2), true);
|
||||
assert.equal(and(false, 2), false);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and null', function () {
|
||||
assert.equal(and(2, null), false);
|
||||
assert.equal(and(null, 2), false);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and undefined', function () {
|
||||
assert.equal(and(2, undefined), false);
|
||||
assert.equal(and(undefined, 2), false);
|
||||
});
|
||||
|
||||
it('should and bignumbers', function () {
|
||||
assert.equal(and(bignumber(1), bignumber(1)), true);
|
||||
assert.equal(and(bignumber(-1), bignumber(1)), true);
|
||||
assert.equal(and(bignumber(-1), bignumber(-1)), true);
|
||||
assert.equal(and(bignumber(0), bignumber(-1)), false);
|
||||
assert.equal(and(bignumber(1), bignumber(0)), false);
|
||||
assert.equal(and(bignumber(1), bignumber(NaN)), false);
|
||||
assert.equal(and(bignumber(NaN), bignumber(1)), false);
|
||||
assert.equal(and(bignumber('1e+10'), bignumber(0.19209)), true);
|
||||
assert.equal(and(bignumber('-1.0e-100'), bignumber('1.0e-100')), true);
|
||||
assert.equal(and(bignumber(Infinity), bignumber(-Infinity)), true);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and bignumbers', function () {
|
||||
assert.equal(and(bignumber(2), 3), true);
|
||||
assert.equal(and(2, bignumber(2)), true);
|
||||
assert.equal(and(0, bignumber(2)), false);
|
||||
assert.equal(and(2, bignumber(0)), false);
|
||||
assert.equal(and(bignumber(0), 2), false);
|
||||
assert.equal(and(bignumber(2), 0), false);
|
||||
});
|
||||
|
||||
it('should and two units', function () {
|
||||
assert.equal(and(unit('100cm'), unit('10inch')), true);
|
||||
assert.equal(and(unit('100cm'), unit('0 inch')), false);
|
||||
assert.equal(and(unit('0cm'), unit('1m')), false);
|
||||
assert.equal(and(unit('m'), unit('1m')), false);
|
||||
assert.equal(and(unit('1dm'), unit('m')), false);
|
||||
assert.equal(and(unit('-100cm'), unit('-10inch')), true);
|
||||
assert.equal(and(unit(5, 'km'), unit(100, 'gram')), true);
|
||||
assert.equal(and(unit(5, 'km'), unit(0, 'gram')), false);
|
||||
assert.equal(and(unit(0, 'km'), unit(100, 'gram')), false);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and units', function () {
|
||||
assert.equal(and(unit('2m'), 3), true);
|
||||
assert.equal(and(2, unit('3m')), true);
|
||||
assert.equal(and(0, unit('2m')), false);
|
||||
assert.equal(and(2, unit('0m')), false);
|
||||
assert.equal(and(unit('0in'), 2), false);
|
||||
assert.equal(and(unit('2in'), 0), false);
|
||||
});
|
||||
|
||||
it('should and two strings', function () {
|
||||
assert.equal(and('0', 'NaN'), true);
|
||||
|
||||
assert.equal(and('abd', ' '), true);
|
||||
assert.equal(and('abc', ''), false);
|
||||
assert.equal(and('', 'abd'), false);
|
||||
assert.equal(and('', ''), false);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and strings', function () {
|
||||
assert.equal(and(1, 'NaN'), true);
|
||||
assert.equal(and('abd', 1), true);
|
||||
assert.equal(and(1, ''), false);
|
||||
assert.equal(and('', 1), false);
|
||||
});
|
||||
|
||||
it('should and two arrays', function () {
|
||||
assert.equal(and([0], [0, 0, 0]), true);
|
||||
assert.equal(and([], [0, 0, 0]), false);
|
||||
assert.equal(and(['A', 'B', 'C'], []), false);
|
||||
assert.equal(and([], []), false);
|
||||
assert.equal(and([[]], [[]]), true);
|
||||
assert.equal(and([[[]]], [[]]), true);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and arrays', function () {
|
||||
assert.equal(and(1, [0, 0, 0]), true);
|
||||
assert.equal(and([0], 1), true);
|
||||
assert.equal(and(0, [0, 0, 0]), false);
|
||||
assert.equal(and(['A', 'B', 'C'], 0), false);
|
||||
assert.equal(and(1, []), false);
|
||||
assert.equal(and([[]], 1), true);
|
||||
assert.equal(and([[], []], 1), true);
|
||||
});
|
||||
|
||||
it('should and two matrices', function () {
|
||||
assert.equal(and(matrix([0]), matrix([0, 0, 0])), true);
|
||||
assert.equal(and(matrix([]), matrix([0, 0, 0])), false);
|
||||
assert.equal(and(matrix(['A', 'B', 'C']), matrix([])), false);
|
||||
assert.equal(and(matrix([]), matrix([])), false);
|
||||
assert.equal(and(matrix([]), matrix([[]])), false);
|
||||
assert.equal(and(matrix([[]]), matrix([[]])), true);
|
||||
assert.equal(and(matrix([[[]]]), matrix([[]])), true);
|
||||
});
|
||||
|
||||
it('should and mixed numbers and matrices', function () {
|
||||
assert.equal(and(1, matrix([0, 0, 0])), true);
|
||||
assert.equal(and(matrix([0]), 1), true);
|
||||
assert.equal(and(0, matrix([0, 0, 0])), false);
|
||||
assert.equal(and(matrix(['A', 'B', 'C']), 0), false);
|
||||
assert.equal(and(1, matrix([])), false);
|
||||
assert.equal(and(matrix([]), 1), false);
|
||||
assert.equal(and(matrix([[]]), 1), true);
|
||||
assert.equal(and(matrix([[], []]), 1), true);
|
||||
});
|
||||
|
||||
it('should and two objects', function () {
|
||||
assert.equal(and(new Date(), new Date()), true);
|
||||
});
|
||||
|
||||
it('should throw an error in case of invalid number of arguments', function () {
|
||||
assert.throws(function () {and(1)}, error.ArgumentsError);
|
||||
assert.throws(function () {and(1, 2, 3)}, error.ArgumentsError);
|
||||
});
|
||||
|
||||
});
|
||||
102
test/function/boolean/not.test.js
Normal file
102
test/function/boolean/not.test.js
Normal file
@ -0,0 +1,102 @@
|
||||
// test not
|
||||
var assert = require('assert'),
|
||||
math = require('../../../index'),
|
||||
error = require('../../../lib/error/index'),
|
||||
bignumber = math.bignumber,
|
||||
complex = math.complex,
|
||||
matrix = math.matrix,
|
||||
unit = math.unit,
|
||||
not = math.not;
|
||||
|
||||
describe('not', function () {
|
||||
|
||||
it('should not numbers correctly', function () {
|
||||
assert.equal(not(1), false);
|
||||
assert.equal(not(-1), false);
|
||||
assert.equal(not(1.23e+100), false);
|
||||
assert.equal(not(-1.0e-100), false);
|
||||
assert.equal(not(1.0e-100), false);
|
||||
assert.equal(not(Infinity), false);
|
||||
assert.equal(not(-Infinity), false);
|
||||
assert.equal(not(0), true);
|
||||
assert.equal(not(NaN), true);
|
||||
});
|
||||
|
||||
it('should not complex numbers', function () {
|
||||
assert.equal(not(complex(1, 1)), false);
|
||||
assert.equal(not(complex(0, 1)), false);
|
||||
assert.equal(not(complex(1, 0)), false);
|
||||
assert.equal(not(complex(0, 0)), true);
|
||||
assert.equal(not(complex()), true);
|
||||
assert.equal(not(complex(0)), true);
|
||||
assert.equal(not(complex(1)), false);
|
||||
});
|
||||
|
||||
it('should not booleans', function () {
|
||||
assert.equal(not(true), false);
|
||||
assert.equal(not(false), true);
|
||||
});
|
||||
|
||||
it('should not null/undefined values', function () {
|
||||
assert.equal(not(null), true);
|
||||
assert.equal(not(undefined), true);
|
||||
});
|
||||
|
||||
it('should not bignumbers', function () {
|
||||
assert.equal(not(bignumber(1)), false);
|
||||
assert.equal(not(bignumber(-1)), false);
|
||||
assert.equal(not(bignumber(0)), true);
|
||||
assert.equal(not(bignumber(NaN)), true);
|
||||
assert.equal(not(bignumber('1e+10')), false);
|
||||
assert.equal(not(bignumber('-1.0e-100')), false);
|
||||
assert.equal(not(bignumber('1.0e-100')), false);
|
||||
assert.equal(not(bignumber(Infinity)), false);
|
||||
assert.equal(not(bignumber(-Infinity)), false);
|
||||
});
|
||||
|
||||
it('should not units', function () {
|
||||
assert.equal(not(unit('100cm')), false);
|
||||
assert.equal(not(unit('0 inch')), true);
|
||||
assert.equal(not(unit('1m')), false);
|
||||
assert.equal(not(unit('m')), true);
|
||||
assert.equal(not(unit('-10inch')), false);
|
||||
});
|
||||
|
||||
it('should not strings', function () {
|
||||
assert.equal(not('0'), false);
|
||||
assert.equal(not('NaN'), false);
|
||||
|
||||
assert.equal(not('abd'), false);
|
||||
assert.equal(not(''), true);
|
||||
assert.equal(not('\0'), false);
|
||||
assert.equal(not(' '), false);
|
||||
});
|
||||
|
||||
it('should not arrays', function () {
|
||||
assert.equal(not([0]), false);
|
||||
assert.equal(not([0, 0, 0]), false);
|
||||
assert.equal(not(['A', ['B', 'C']]), false);
|
||||
assert.equal(not([]), true);
|
||||
assert.equal(not([[]]), false);
|
||||
assert.equal(not([[[]]]), false);
|
||||
});
|
||||
|
||||
it('should not matrices', function () {
|
||||
assert.equal(not(matrix([0])), false);
|
||||
assert.equal(not(matrix([0, 0, 0])), false);
|
||||
assert.equal(not(matrix(['A', 'B', 'C'])), false);
|
||||
assert.equal(not(matrix([])), true);
|
||||
assert.equal(not(matrix([[]])), false);
|
||||
assert.equal(not(matrix([[[]]])), false);
|
||||
});
|
||||
|
||||
it('should not object', function () {
|
||||
assert.equal(not(new Date()), false);
|
||||
});
|
||||
|
||||
it('should throw an error in case of invalid number of arguments', function () {
|
||||
assert.throws(function () {not()}, error.ArgumentsError);
|
||||
assert.throws(function () {not(1, 2)}, error.ArgumentsError);
|
||||
});
|
||||
|
||||
});
|
||||
218
test/function/boolean/or.test.js
Normal file
218
test/function/boolean/or.test.js
Normal file
@ -0,0 +1,218 @@
|
||||
// test or
|
||||
var assert = require('assert'),
|
||||
math = require('../../../index'),
|
||||
error = require('../../../lib/error/index'),
|
||||
bignumber = math.bignumber,
|
||||
complex = math.complex,
|
||||
matrix = math.matrix,
|
||||
unit = math.unit,
|
||||
or = math.or;
|
||||
|
||||
describe('or', function () {
|
||||
|
||||
it('should or two numbers correctly', function () {
|
||||
assert.equal(or(1, 1), true);
|
||||
assert.equal(or(-1, 1), true);
|
||||
assert.equal(or(-1, -1), true);
|
||||
assert.equal(or(0, -1), true);
|
||||
assert.equal(or(1, 0), true);
|
||||
assert.equal(or(1, NaN), true);
|
||||
assert.equal(or(NaN, 1), true);
|
||||
assert.equal(or(1e10, 0.019209), true);
|
||||
assert.equal(or(-1.0e-100, 1.0e-100), true);
|
||||
assert.equal(or(Infinity, -Infinity), true);
|
||||
assert.equal(or(NaN, NaN), false);
|
||||
assert.equal(or(NaN, 0), false);
|
||||
assert.equal(or(0, NaN), false);
|
||||
assert.equal(or(0, 0), false);
|
||||
});
|
||||
|
||||
it('should or two complex numbers', function () {
|
||||
assert.equal(or(complex(1, 1), complex(1, 1)), true);
|
||||
assert.equal(or(complex(0, 1), complex(1, 1)), true);
|
||||
assert.equal(or(complex(1, 0), complex(1, 1)), true);
|
||||
assert.equal(or(complex(1, 1), complex(0, 1)), true);
|
||||
assert.equal(or(complex(1, 1), complex(1, 0)), true);
|
||||
assert.equal(or(complex(1, 0), complex(1, 0)), true);
|
||||
assert.equal(or(complex(0, 1), complex(0, 1)), true);
|
||||
assert.equal(or(complex(0, 0), complex(1, 1)), true);
|
||||
assert.equal(or(complex(0, 0), complex(0, 1)), true);
|
||||
assert.equal(or(complex(0, 0), complex(1, 0)), true);
|
||||
assert.equal(or(complex(1, 1), complex(0, 0)), true);
|
||||
assert.equal(or(complex(0, 1), complex(0, 0)), true);
|
||||
assert.equal(or(complex(1, 0), complex(0, 0)), true);
|
||||
assert.equal(or(complex(), complex(1, 1)), true);
|
||||
assert.equal(or(complex(0), complex(1, 1)), true);
|
||||
assert.equal(or(complex(1), complex(1, 1)), true);
|
||||
assert.equal(or(complex(1, 1), complex()), true);
|
||||
assert.equal(or(complex(1, 1), complex(0)), true);
|
||||
assert.equal(or(complex(1, 1), complex(1)), true);
|
||||
assert.equal(or(complex(0, 0), complex(0, 0)), false);
|
||||
assert.equal(or(complex(), complex()), false);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and complex numbers', function () {
|
||||
assert.equal(or(complex(1, 1), 1), true);
|
||||
assert.equal(or(complex(1, 1), 0), true);
|
||||
assert.equal(or(1, complex(1, 1)), true);
|
||||
assert.equal(or(0, complex(1, 1)), true);
|
||||
assert.equal(or(complex(0, 0), 1), true);
|
||||
assert.equal(or(1, complex(0, 0)), true);
|
||||
assert.equal(or(0, complex(0, 0)), false);
|
||||
assert.equal(or(complex(0, 0), 0), false);
|
||||
});
|
||||
|
||||
it('should or two booleans', function () {
|
||||
assert.equal(or(true, true), true);
|
||||
assert.equal(or(true, false), true);
|
||||
assert.equal(or(false, true), true);
|
||||
assert.equal(or(false, false), false);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and booleans', function () {
|
||||
assert.equal(or(2, true), true);
|
||||
assert.equal(or(2, false), true);
|
||||
assert.equal(or(0, true), true);
|
||||
assert.equal(or(0, false), false);
|
||||
assert.equal(or(true, 2), true);
|
||||
assert.equal(or(false, 2), true);
|
||||
assert.equal(or(false, 0), false);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and null', function () {
|
||||
assert.equal(or(2, null), true);
|
||||
assert.equal(or(null, 2), true);
|
||||
assert.equal(or(null, null), false);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and undefined', function () {
|
||||
assert.equal(or(2, undefined), true);
|
||||
assert.equal(or(undefined, 2), true);
|
||||
assert.equal(or(undefined, undefined), false);
|
||||
});
|
||||
|
||||
it('should or bignumbers', function () {
|
||||
assert.equal(or(bignumber(1), bignumber(1)), true);
|
||||
assert.equal(or(bignumber(-1), bignumber(1)), true);
|
||||
assert.equal(or(bignumber(-1), bignumber(-1)), true);
|
||||
assert.equal(or(bignumber(0), bignumber(-1)), true);
|
||||
assert.equal(or(bignumber(1), bignumber(0)), true);
|
||||
assert.equal(or(bignumber(1), bignumber(NaN)), true);
|
||||
assert.equal(or(bignumber(NaN), bignumber(1)), true);
|
||||
assert.equal(or(bignumber('1e+10'), bignumber(0.19209)), true);
|
||||
assert.equal(or(bignumber('-1.0e-100'), bignumber('1.0e-100')), true);
|
||||
assert.equal(or(bignumber(Infinity), bignumber(-Infinity)), true);
|
||||
assert.equal(or(bignumber(NaN), bignumber(NaN)), false);
|
||||
assert.equal(or(bignumber(NaN), bignumber(0)), false);
|
||||
assert.equal(or(bignumber(0), bignumber(NaN)), false);
|
||||
assert.equal(or(bignumber(0), bignumber(0)), false);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and bignumbers', function () {
|
||||
assert.equal(or(bignumber(2), 3), true);
|
||||
assert.equal(or(2, bignumber(2)), true);
|
||||
assert.equal(or(0, bignumber(2)), true);
|
||||
assert.equal(or(2, bignumber(0)), true);
|
||||
assert.equal(or(bignumber(0), 2), true);
|
||||
assert.equal(or(bignumber(0), 0), false);
|
||||
assert.equal(or(bignumber(2), 0), true);
|
||||
assert.equal(or(bignumber(0), 0), false);
|
||||
});
|
||||
|
||||
it('should or two units', function () {
|
||||
assert.equal(or(unit('100cm'), unit('10inch')), true);
|
||||
assert.equal(or(unit('100cm'), unit('0 inch')), true);
|
||||
assert.equal(or(unit('0cm'), unit('1m')), true);
|
||||
assert.equal(or(unit('m'), unit('1m')), true);
|
||||
assert.equal(or(unit('1dm'), unit('m')), true);
|
||||
assert.equal(or(unit('dm'), unit('m')), false);
|
||||
assert.equal(or(unit('-100cm'), unit('-10inch')), true);
|
||||
assert.equal(or(unit(5, 'km'), unit(100, 'gram')), true);
|
||||
assert.equal(or(unit(5, 'km'), unit(0, 'gram')), true);
|
||||
assert.equal(or(unit(0, 'km'), unit(100, 'gram')), true);
|
||||
assert.equal(or(unit(0, 'km'), unit(0, 'gram')), false);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and units', function () {
|
||||
assert.equal(or(2, unit('3m')), true);
|
||||
assert.equal(or(0, unit('2m')), true);
|
||||
assert.equal(or(2, unit('0m')), true);
|
||||
assert.equal(or(0, unit('0m')), false);
|
||||
assert.equal(or(unit('0in'), 2), true);
|
||||
assert.equal(or(unit('2in'), 0), true);
|
||||
assert.equal(or(unit('0in'), 0), false);
|
||||
});
|
||||
|
||||
it('should or two strings', function () {
|
||||
assert.equal(or('0', 'NaN'), true);
|
||||
|
||||
assert.equal(or('abd', ' '), true);
|
||||
assert.equal(or('abc', ''), true);
|
||||
assert.equal(or('', 'abd'), true);
|
||||
assert.equal(or('', ''), false);
|
||||
assert.equal(or(' ', ''), true);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and strings', function () {
|
||||
assert.equal(or(1, 'NaN'), true);
|
||||
assert.equal(or('abd', 1), true);
|
||||
assert.equal(or(1, ''), true);
|
||||
assert.equal(or(0, ''), false);
|
||||
assert.equal(or('', 1), true);
|
||||
assert.equal(or('', 0), false);
|
||||
});
|
||||
|
||||
it('should or two arrays', function () {
|
||||
assert.equal(or([0], [0, 0, 0]), true);
|
||||
assert.equal(or([], [0, 0, 0]), true);
|
||||
assert.equal(or(['A', 'B', 'C'], []), true);
|
||||
assert.equal(or([], []), false);
|
||||
assert.equal(or([[]], [[]]), true);
|
||||
assert.equal(or([[[]]], [[]]), true);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and arrays', function () {
|
||||
assert.equal(or(1, [0, 0, 0]), true);
|
||||
assert.equal(or([0], 1), true);
|
||||
assert.equal(or(0, [0, 0, 0]), true);
|
||||
assert.equal(or(['A', 'B', 'C'], 0), true);
|
||||
assert.equal(or(1, []), true);
|
||||
assert.equal(or(0, []), false);
|
||||
assert.equal(or([], 0), false);
|
||||
assert.equal(or([[]], 1), true);
|
||||
assert.equal(or([[], []], 1), true);
|
||||
});
|
||||
|
||||
it('should or two matrices', function () {
|
||||
assert.equal(or(matrix([0]), matrix([0, 0, 0])), true);
|
||||
assert.equal(or(matrix([]), matrix([0, 0, 0])), true);
|
||||
assert.equal(or(matrix(['A', 'B', 'C']), matrix([])), true);
|
||||
assert.equal(or(matrix([]), matrix([])), false);
|
||||
assert.equal(or(matrix([]), matrix([[]])), true);
|
||||
assert.equal(or(matrix([[]]), matrix([[]])), true);
|
||||
assert.equal(or(matrix([[[]]]), matrix([[]])), true);
|
||||
});
|
||||
|
||||
it('should or mixed numbers and matrices', function () {
|
||||
assert.equal(or(1, matrix([0, 0, 0])), true);
|
||||
assert.equal(or(matrix([0]), 1), true);
|
||||
assert.equal(or(0, matrix([0, 0, 0])), true);
|
||||
assert.equal(or(matrix(['A', 'B', 'C']), 0), true);
|
||||
assert.equal(or(0, matrix([])), false);
|
||||
assert.equal(or(1, matrix([])), true);
|
||||
assert.equal(or(matrix([]), 0), false);
|
||||
assert.equal(or(matrix([]), 1), true);
|
||||
assert.equal(or(matrix([[]]), 1), true);
|
||||
assert.equal(or(matrix([[], []]), 1), true);
|
||||
});
|
||||
|
||||
it('should or two objects', function () {
|
||||
assert.equal(or(new Date(), new Date()), true);
|
||||
});
|
||||
|
||||
it('should throw an error in case of invalid number of arguments', function () {
|
||||
assert.throws(function () {or(1)}, error.ArgumentsError);
|
||||
assert.throws(function () {or(1, 2, 3)}, error.ArgumentsError);
|
||||
});
|
||||
|
||||
});
|
||||
@ -30,6 +30,7 @@ describe('cos', function() {
|
||||
approx.equal(cos(pi*7/4), 0.707106781186548);
|
||||
approx.equal(cos(pi*8/4), 1);
|
||||
approx.equal(cos(pi/4), math.sqrt(2)/2);
|
||||
assert.ok(cos(complex('1e-50+1e-50i')).im != 0);
|
||||
});
|
||||
|
||||
it('should return the cosine of a bignumber (downgrades to number)', function() {
|
||||
@ -76,4 +77,4 @@ describe('cos', function() {
|
||||
assert.throws(function () {cos(1, 2)}, error.ArgumentsError);
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
@ -46,6 +46,7 @@ describe('sin', function() {
|
||||
approx.deepEqual(sin(complex('i')), complex(0, 1.175201193643801));
|
||||
approx.deepEqual(sin(complex('1')), complex(0.841470984807897, 0));
|
||||
approx.deepEqual(sin(complex('1+i')), complex(1.298457581415977, 0.634963914784736));
|
||||
assert.deepEqual(sin(complex('1e-50i')), complex(0, 1e-50));
|
||||
});
|
||||
|
||||
it('should return the sine of an angle', function() {
|
||||
|
||||
@ -24,6 +24,12 @@ describe('sinh', function() {
|
||||
approx.equal(sinh(1), 1.1752011936438014);
|
||||
});
|
||||
|
||||
it('should return the sinh of very small numbers (avoid returning zero)', function() {
|
||||
// If sinh returns 0, that is bad, so we are using assert.equal, not approx.equal
|
||||
assert.equal(sinh(-1e-10), -1e-10);
|
||||
assert.equal(sinh(1e-50), 1e-50);
|
||||
})
|
||||
|
||||
it('should return the sinh of a bignumber (downgrades to number)', function() {
|
||||
approx.equal(sinh(math.bignumber(1)), 1.1752011936438014);
|
||||
});
|
||||
|
||||
@ -178,6 +178,21 @@ describe('unit', function() {
|
||||
assert.equal(u2.fixPrefix, true);
|
||||
});
|
||||
|
||||
it ('should convert a valueless unit', function () {
|
||||
var u1 = new Unit(null, 'm');
|
||||
assert.equal(u1.value, null);
|
||||
assert.equal(u1.unit.name, 'm');
|
||||
assert.equal(u1.prefix.name, '');
|
||||
assert.equal(u1.fixPrefix, false);
|
||||
|
||||
var u2 = u1.to(new Unit(null, 'cm'));
|
||||
assert.notStrictEqual(u1, u2); // u2 must be a clone
|
||||
assert.equal(u2.value, 1); // u2 must have a value
|
||||
assert.equal(u2.unit.name, 'm');
|
||||
assert.equal(u2.prefix.name, 'c');
|
||||
assert.equal(u2.fixPrefix, true);
|
||||
});
|
||||
|
||||
it ('should throw an error when converting to an incompatible unit', function () {
|
||||
var u1 = new Unit(5000, 'cm');
|
||||
assert.throws(function () {u1.to('kg')}, /Units do not match/);
|
||||
@ -243,8 +258,8 @@ describe('unit', function() {
|
||||
});
|
||||
|
||||
it('should format a unit with fixed prefix and without value', function() {
|
||||
assert.equal(new Unit(null, 'cm').to('km').format(), 'km');
|
||||
assert.equal(new Unit(null, 'cm').to('inch').format(), 'inch');
|
||||
assert.equal(new Unit(null, 'km').to('cm').format(), '1e+5 cm');
|
||||
assert.equal(new Unit(null, 'inch').to('cm').format(), '2.54 cm');
|
||||
});
|
||||
|
||||
it('should ignore properties in Object.prototype when finding the best prefix', function() {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user