mathjs
Version:
Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with dif
3,846 lines • 100 kB
JavaScript
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _extends from "@babel/runtime/helpers/extends";
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
import { isComplex, isUnit, typeOf } from '../../utils/is.js';
import { factory } from '../../utils/factory.js';
import { memoize } from '../../utils/function.js';
import { endsWith } from '../../utils/string.js';
import { clone, hasOwnProperty } from '../../utils/object.js';
import { createBigNumberPi as createPi } from '../../utils/bignumber/constants.js';
var name = 'Unit';
var dependencies = ['?on', 'config', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref => {
var {
on,
config,
addScalar,
subtract,
multiplyScalar,
divideScalar,
pow,
abs,
fix,
round,
equal,
isNumeric,
format,
number,
Complex,
BigNumber: _BigNumber,
Fraction: _Fraction
} = _ref;
var toNumber = number;
/**
* A unit can be constructed in the following ways:
*
* const a = new Unit(value, valuelessUnit)
* const b = new Unit(null, valuelessUnit)
* const c = Unit.parse(str)
*
* Example usage:
*
* const a = new Unit(5, 'cm') // 50 mm
* const b = Unit.parse('23 kg') // 23 kg
* const c = math.in(a, new Unit(null, 'm') // 0.05 m
* const d = new Unit(9.81, "m/s^2") // 9.81 m/s^2
*
* @class Unit
* @constructor Unit
* @param {number | BigNumber | Fraction | Complex | boolean} [value] A value like 5.2
* @param {string | Unit} valuelessUnit A unit without value. Can have prefix, like "cm"
*/
function Unit(value, valuelessUnit) {
if (!(this instanceof Unit)) {
throw new Error('Constructor must be called with the new operator');
}
if (!(value === null || value === undefined || isNumeric(value) || isComplex(value))) {
throw new TypeError('First parameter in Unit constructor must be number, BigNumber, Fraction, Complex, or undefined');
}
this.fixPrefix = false; // if true, function format will not search for the
// best prefix but leave it as initially provided.
// fixPrefix is set true by the method Unit.to
// The justification behind this is that if the constructor is explicitly called,
// the caller wishes the units to be returned exactly as supplied.
this.skipAutomaticSimplification = true;
if (valuelessUnit === undefined) {
this.units = [];
this.dimensions = BASE_DIMENSIONS.map(x => 0);
} else if (typeof valuelessUnit === 'string') {
var u = Unit.parse(valuelessUnit);
this.units = u.units;
this.dimensions = u.dimensions;
} else if (isUnit(valuelessUnit) && valuelessUnit.value === null) {
// clone from valuelessUnit
this.fixPrefix = valuelessUnit.fixPrefix;
this.skipAutomaticSimplification = valuelessUnit.skipAutomaticSimplification;
this.dimensions = valuelessUnit.dimensions.slice(0);
this.units = valuelessUnit.units.map(u => _extends({}, u));
} else {
throw new TypeError('Second parameter in Unit constructor must be a string or valueless Unit');
}
this.value = this._normalize(value);
}
/**
* Attach type information
*/
Object.defineProperty(Unit, 'name', {
value: 'Unit'
});
Unit.prototype.constructor = Unit;
Unit.prototype.type = 'Unit';
Unit.prototype.isUnit = true;
// private variables and functions for the Unit parser
var text, index, c;
function skipWhitespace() {
while (c === ' ' || c === '\t') {
next();
}
}
function isDigitDot(c) {
return c >= '0' && c <= '9' || c === '.';
}
function isDigit(c) {
return c >= '0' && c <= '9';
}
function next() {
index++;
c = text.charAt(index);
}
function revert(oldIndex) {
index = oldIndex;
c = text.charAt(index);
}
function parseNumber() {
var number = '';
var oldIndex = index;
if (c === '+') {
next();
} else if (c === '-') {
number += c;
next();
}
if (!isDigitDot(c)) {
// a + or - must be followed by a digit
revert(oldIndex);
return null;
}
// get number, can have a single dot
if (c === '.') {
number += c;
next();
if (!isDigit(c)) {
// this is no legal number, it is just a dot
revert(oldIndex);
return null;
}
} else {
while (isDigit(c)) {
number += c;
next();
}
if (c === '.') {
number += c;
next();
}
}
while (isDigit(c)) {
number += c;
next();
}
// check for exponential notation like "2.3e-4" or "1.23e50"
if (c === 'E' || c === 'e') {
// The grammar branches here. This could either be part of an exponent or the start of a unit that begins with the letter e, such as "4exabytes"
var tentativeNumber = '';
var tentativeIndex = index;
tentativeNumber += c;
next();
if (c === '+' || c === '-') {
tentativeNumber += c;
next();
}
// Scientific notation MUST be followed by an exponent (otherwise we assume it is not scientific notation)
if (!isDigit(c)) {
// The e or E must belong to something else, so return the number without the e or E.
revert(tentativeIndex);
return number;
}
// We can now safely say that this is scientific notation.
number = number + tentativeNumber;
while (isDigit(c)) {
number += c;
next();
}
}
return number;
}
function parseUnit() {
var unitName = '';
// Alphanumeric characters only; matches [a-zA-Z0-9]
while (isDigit(c) || Unit.isValidAlpha(c)) {
unitName += c;
next();
}
// Must begin with [a-zA-Z]
var firstC = unitName.charAt(0);
if (Unit.isValidAlpha(firstC)) {
return unitName;
} else {
return null;
}
}
function parseCharacter(toFind) {
if (c === toFind) {
next();
return toFind;
} else {
return null;
}
}
/**
* Parse a string into a unit. The value of the unit is parsed as number,
* BigNumber, or Fraction depending on the math.js config setting `number`.
*
* Throws an exception if the provided string does not contain a valid unit or
* cannot be parsed.
* @memberof Unit
* @param {string} str A string like "5.2 inch", "4e2 cm/s^2"
* @return {Unit} unit
*/
Unit.parse = function (str, options) {
options = options || {};
text = str;
index = -1;
c = '';
if (typeof text !== 'string') {
throw new TypeError('Invalid argument in Unit.parse, string expected');
}
var unit = new Unit();
unit.units = [];
var powerMultiplierCurrent = 1;
var expectingUnit = false;
// A unit should follow this pattern:
// [number] ...[ [*/] unit[^number] ]
// unit[^number] ... [ [*/] unit[^number] ]
// Rules:
// number is any floating point number.
// unit is any alphanumeric string beginning with an alpha. Units with names like e3 should be avoided because they look like the exponent of a floating point number!
// The string may optionally begin with a number.
// Each unit may optionally be followed by ^number.
// Whitespace or a forward slash is recommended between consecutive units, although the following technically is parseable:
// 2m^2kg/s^2
// it is not good form. If a unit starts with e, then it could be confused as a floating point number:
// 4erg
next();
skipWhitespace();
// Optional number at the start of the string
var valueStr = parseNumber();
var value = null;
if (valueStr) {
if (config.number === 'BigNumber') {
value = new _BigNumber(valueStr);
} else if (config.number === 'Fraction') {
try {
// not all numbers can be turned in Fractions, for example very small numbers not
value = new _Fraction(valueStr);
} catch (err) {
value = parseFloat(valueStr);
}
} else {
// number
value = parseFloat(valueStr);
}
skipWhitespace(); // Whitespace is not required here
// handle multiplication or division right after the value, like '1/s'
if (parseCharacter('*')) {
powerMultiplierCurrent = 1;
expectingUnit = true;
} else if (parseCharacter('/')) {
powerMultiplierCurrent = -1;
expectingUnit = true;
}
}
// Stack to keep track of powerMultipliers applied to each parentheses group
var powerMultiplierStack = [];
// Running product of all elements in powerMultiplierStack
var powerMultiplierStackProduct = 1;
while (true) {
skipWhitespace();
// Check for and consume opening parentheses, pushing powerMultiplierCurrent to the stack
// A '(' will always appear directly before a unit.
while (c === '(') {
powerMultiplierStack.push(powerMultiplierCurrent);
powerMultiplierStackProduct *= powerMultiplierCurrent;
powerMultiplierCurrent = 1;
next();
skipWhitespace();
}
// Is there something here?
var uStr = void 0;
if (c) {
var oldC = c;
uStr = parseUnit();
if (uStr === null) {
throw new SyntaxError('Unexpected "' + oldC + '" in "' + text + '" at index ' + index.toString());
}
} else {
// End of input.
break;
}
// Verify the unit exists and get the prefix (if any)
var res = _findUnit(uStr);
if (res === null) {
// Unit not found.
throw new SyntaxError('Unit "' + uStr + '" not found.');
}
var power = powerMultiplierCurrent * powerMultiplierStackProduct;
// Is there a "^ number"?
skipWhitespace();
if (parseCharacter('^')) {
skipWhitespace();
var p = parseNumber();
if (p === null) {
// No valid number found for the power!
throw new SyntaxError('In "' + str + '", "^" must be followed by a floating-point number');
}
power *= p;
}
// Add the unit to the list
unit.units.push({
unit: res.unit,
prefix: res.prefix,
power
});
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
unit.dimensions[i] += (res.unit.dimensions[i] || 0) * power;
}
// Check for and consume closing parentheses, popping from the stack.
// A ')' will always follow a unit.
skipWhitespace();
while (c === ')') {
if (powerMultiplierStack.length === 0) {
throw new SyntaxError('Unmatched ")" in "' + text + '" at index ' + index.toString());
}
powerMultiplierStackProduct /= powerMultiplierStack.pop();
next();
skipWhitespace();
}
// "*" and "/" should mean we are expecting something to come next.
// Is there a forward slash? If so, negate powerMultiplierCurrent. The next unit or paren group is in the denominator.
expectingUnit = false;
if (parseCharacter('*')) {
// explicit multiplication
powerMultiplierCurrent = 1;
expectingUnit = true;
} else if (parseCharacter('/')) {
// division
powerMultiplierCurrent = -1;
expectingUnit = true;
} else {
// implicit multiplication
powerMultiplierCurrent = 1;
}
// Replace the unit into the auto unit system
if (res.unit.base) {
var baseDim = res.unit.base.key;
UNIT_SYSTEMS.auto[baseDim] = {
unit: res.unit,
prefix: res.prefix
};
}
}
// Has the string been entirely consumed?
skipWhitespace();
if (c) {
throw new SyntaxError('Could not parse: "' + str + '"');
}
// Is there a trailing slash?
if (expectingUnit) {
throw new SyntaxError('Trailing characters: "' + str + '"');
}
// Is the parentheses stack empty?
if (powerMultiplierStack.length !== 0) {
throw new SyntaxError('Unmatched "(" in "' + text + '"');
}
// Are there any units at all?
if (unit.units.length === 0 && !options.allowNoUnits) {
throw new SyntaxError('"' + str + '" contains no units');
}
unit.value = value !== undefined ? unit._normalize(value) : null;
return unit;
};
/**
* create a copy of this unit
* @memberof Unit
* @return {Unit} Returns a cloned version of the unit
*/
Unit.prototype.clone = function () {
var unit = new Unit();
unit.fixPrefix = this.fixPrefix;
unit.skipAutomaticSimplification = this.skipAutomaticSimplification;
unit.value = clone(this.value);
unit.dimensions = this.dimensions.slice(0);
unit.units = [];
for (var i = 0; i < this.units.length; i++) {
unit.units[i] = {};
for (var p in this.units[i]) {
if (hasOwnProperty(this.units[i], p)) {
unit.units[i][p] = this.units[i][p];
}
}
}
return unit;
};
/**
* Return the type of the value of this unit
*
* @memberof Unit
* @ return {string} type of the value of the unit
*/
Unit.prototype.valueType = function () {
return typeOf(this.value);
};
/**
* Return whether the unit is derived (such as m/s, or cm^2, but not N)
* @memberof Unit
* @return {boolean} True if the unit is derived
*/
Unit.prototype._isDerived = function () {
if (this.units.length === 0) {
return false;
}
return this.units.length > 1 || Math.abs(this.units[0].power - 1.0) > 1e-15;
};
/**
* Normalize a value, based on its currently set unit(s)
* @memberof Unit
* @param {number | BigNumber | Fraction | boolean} value
* @return {number | BigNumber | Fraction | boolean} normalized value
* @private
*/
Unit.prototype._normalize = function (value) {
if (value === null || value === undefined || this.units.length === 0) {
return value;
}
var res = value;
var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
for (var i = 0; i < this.units.length; i++) {
var unitValue = convert(this.units[i].unit.value);
var unitPrefixValue = convert(this.units[i].prefix.value);
var unitPower = convert(this.units[i].power);
res = multiplyScalar(res, pow(multiplyScalar(unitValue, unitPrefixValue), unitPower));
}
return res;
};
/**
* Denormalize a value, based on its currently set unit(s)
* @memberof Unit
* @param {number} value
* @param {number} [prefixValue] Optional prefix value to be used (ignored if this is a derived unit)
* @return {number} denormalized value
* @private
*/
Unit.prototype._denormalize = function (value, prefixValue) {
if (value === null || value === undefined || this.units.length === 0) {
return value;
}
var res = value;
var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
for (var i = 0; i < this.units.length; i++) {
var unitValue = convert(this.units[i].unit.value);
var unitPrefixValue = convert(this.units[i].prefix.value);
var unitPower = convert(this.units[i].power);
res = divideScalar(res, pow(multiplyScalar(unitValue, unitPrefixValue), unitPower));
}
return res;
};
/**
* Find a unit from a string
* @memberof Unit
* @param {string} str A string like 'cm' or 'inch'
* @returns {Object | null} result When found, an object with fields unit and
* prefix is returned. Else, null is returned.
* @private
*/
var _findUnit = memoize(str => {
// First, match units names exactly. For example, a user could define 'mm' as 10^-4 m, which is silly, but then we would want 'mm' to match the user-defined unit.
if (hasOwnProperty(UNITS, str)) {
var unit = UNITS[str];
var prefix = unit.prefixes[''];
return {
unit,
prefix
};
}
for (var _name in UNITS) {
if (hasOwnProperty(UNITS, _name)) {
if (endsWith(str, _name)) {
var _unit = UNITS[_name];
var prefixLen = str.length - _name.length;
var prefixName = str.substring(0, prefixLen);
var _prefix = hasOwnProperty(_unit.prefixes, prefixName) ? _unit.prefixes[prefixName] : undefined;
if (_prefix !== undefined) {
// store unit, prefix, and value
return {
unit: _unit,
prefix: _prefix
};
}
}
}
}
return null;
}, {
hasher: args => args[0],
limit: 100
});
/**
* Test if the given expression is a unit.
* The unit can have a prefix but cannot have a value.
* @memberof Unit
* @param {string} name A string to be tested whether it is a value less unit.
* The unit can have prefix, like "cm"
* @return {boolean} true if the given string is a unit
*/
Unit.isValuelessUnit = function (name) {
return _findUnit(name) !== null;
};
/**
* check if this unit has given base unit
* If this unit is a derived unit, this will ALWAYS return false, since by definition base units are not derived.
* @memberof Unit
* @param {BASE_UNITS | string | undefined} base
*/
Unit.prototype.hasBase = function (base) {
if (typeof base === 'string') {
base = BASE_UNITS[base];
}
if (!base) {
return false;
}
// All dimensions must be the same
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
if (Math.abs((this.dimensions[i] || 0) - (base.dimensions[i] || 0)) > 1e-12) {
return false;
}
}
return true;
};
/**
* Check if this unit has a base or bases equal to another base or bases
* For derived units, the exponent on each base also must match
* @memberof Unit
* @param {Unit} other
* @return {boolean} true if equal base
*/
Unit.prototype.equalBase = function (other) {
// All dimensions must be the same
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
if (Math.abs((this.dimensions[i] || 0) - (other.dimensions[i] || 0)) > 1e-12) {
return false;
}
}
return true;
};
/**
* Check if this unit equals another unit
* @memberof Unit
* @param {Unit} other
* @return {boolean} true if both units are equal
*/
Unit.prototype.equals = function (other) {
return this.equalBase(other) && equal(this.value, other.value);
};
/**
* Multiply this unit with another one or with a scalar
* @memberof Unit
* @param {Unit} other
* @return {Unit} product of this unit and the other unit
*/
Unit.prototype.multiply = function (_other) {
var res = this.clone();
var other = isUnit(_other) ? _other : new Unit(_other);
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
// Dimensions arrays may be of different lengths. Default to 0.
res.dimensions[i] = (this.dimensions[i] || 0) + (other.dimensions[i] || 0);
}
// Append other's units list onto res
for (var _i = 0; _i < other.units.length; _i++) {
// Make a shallow copy of every unit
var inverted = _objectSpread({}, other.units[_i]);
res.units.push(inverted);
}
// If at least one operand has a value, then the result should also have a value
if (this.value !== null || other.value !== null) {
var valThis = this.value === null ? this._normalize(1) : this.value;
var valOther = other.value === null ? other._normalize(1) : other.value;
res.value = multiplyScalar(valThis, valOther);
} else {
res.value = null;
}
if (isUnit(_other)) {
res.skipAutomaticSimplification = false;
}
return getNumericIfUnitless(res);
};
/**
* Divide a number by this unit
*
* @memberof Unit
* @param {numeric} numerator
* @param {unit} result of dividing numerator by this unit
*/
Unit.prototype.divideInto = function (numerator) {
return new Unit(numerator).divide(this);
};
/**
* Divide this unit by another one
* @memberof Unit
* @param {Unit | numeric} other
* @return {Unit} result of dividing this unit by the other unit
*/
Unit.prototype.divide = function (_other) {
var res = this.clone();
var other = isUnit(_other) ? _other : new Unit(_other);
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
// Dimensions arrays may be of different lengths. Default to 0.
res.dimensions[i] = (this.dimensions[i] || 0) - (other.dimensions[i] || 0);
}
// Invert and append other's units list onto res
for (var _i2 = 0; _i2 < other.units.length; _i2++) {
// Make a shallow copy of every unit
var inverted = _objectSpread(_objectSpread({}, other.units[_i2]), {}, {
power: -other.units[_i2].power
});
res.units.push(inverted);
}
// If at least one operand has a value, the result should have a value
if (this.value !== null || other.value !== null) {
var valThis = this.value === null ? this._normalize(1) : this.value;
var valOther = other.value === null ? other._normalize(1) : other.value;
res.value = divideScalar(valThis, valOther);
} else {
res.value = null;
}
if (isUnit(_other)) {
res.skipAutomaticSimplification = false;
}
return getNumericIfUnitless(res);
};
/**
* Calculate the power of a unit
* @memberof Unit
* @param {number | Fraction | BigNumber} p
* @returns {Unit} The result: this^p
*/
Unit.prototype.pow = function (p) {
var res = this.clone();
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
// Dimensions arrays may be of different lengths. Default to 0.
res.dimensions[i] = (this.dimensions[i] || 0) * p;
}
// Adjust the power of each unit in the list
for (var _i3 = 0; _i3 < res.units.length; _i3++) {
res.units[_i3].power *= p;
}
if (res.value !== null) {
res.value = pow(res.value, p);
// only allow numeric output, we don't want to return a Complex number
// if (!isNumeric(res.value)) {
// res.value = NaN
// }
// Update: Complex supported now
} else {
res.value = null;
}
res.skipAutomaticSimplification = false;
return getNumericIfUnitless(res);
};
/**
* Return the numeric value of this unit if it is dimensionless, has a value, and config.predictable == false; or the original unit otherwise
* @param {Unit} unit
* @returns {number | Fraction | BigNumber | Unit} The numeric value of the unit if conditions are met, or the original unit otherwise
*/
function getNumericIfUnitless(unit) {
if (unit.equalBase(BASE_UNITS.NONE) && unit.value !== null && !config.predictable) {
return unit.value;
} else {
return unit;
}
}
/**
* Calculate the absolute value of a unit
* @memberof Unit
* @param {number | Fraction | BigNumber} x
* @returns {Unit} The result: |x|, absolute value of x
*/
Unit.prototype.abs = function () {
var ret = this.clone();
if (ret.value !== null) {
if (ret._isDerived() || ret.units[0].unit.offset === 0) {
ret.value = abs(ret.value);
} else {
// To give the correct, but unexpected, results for units with an offset.
// For example, abs(-283.15 degC) = -263.15 degC !!!
// We must take the offset into consideration here
var convert = ret._numberConverter(); // convert to Fraction or BigNumber if needed
var unitValue = convert(ret.units[0].unit.value);
var nominalOffset = convert(ret.units[0].unit.offset);
var unitOffset = multiplyScalar(unitValue, nominalOffset);
ret.value = subtract(abs(addScalar(ret.value, unitOffset)), unitOffset);
}
}
for (var i in ret.units) {
if (ret.units[i].unit.name === 'VA' || ret.units[i].unit.name === 'VAR') {
ret.units[i].unit = UNITS.W;
}
}
return ret;
};
/**
* Convert the unit to a specific unit name.
* @memberof Unit
* @param {string | Unit} valuelessUnit A unit without value. Can have prefix, like "cm"
* @returns {Unit} Returns a clone of the unit with a fixed prefix and unit.
*/
Unit.prototype.to = function (valuelessUnit) {
var value = this.value === null ? this._normalize(1) : this.value;
var other;
if (typeof valuelessUnit === 'string') {
other = Unit.parse(valuelessUnit);
} else if (isUnit(valuelessUnit)) {
other = valuelessUnit.clone();
} else {
throw new Error('String or Unit expected as parameter');
}
if (!this.equalBase(other)) {
throw new Error("Units do not match ('".concat(other.toString(), "' != '").concat(this.toString(), "')"));
}
if (other.value !== null) {
throw new Error('Cannot convert to a unit with a value');
}
if (this.value === null || this._isDerived() || this.units[0].unit.offset === other.units[0].unit.offset) {
other.value = clone(value);
} else {
/* Need to adjust value by difference in offset to convert */
var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
var thisUnitValue = convert(this.units[0].unit.value);
var thisNominalOffset = convert(this.units[0].unit.offset);
var thisUnitOffset = multiplyScalar(thisUnitValue, thisNominalOffset);
var otherUnitValue = convert(other.units[0].unit.value);
var otherNominalOffset = convert(other.units[0].unit.offset);
var otherUnitOffset = multiplyScalar(otherUnitValue, otherNominalOffset);
other.value = subtract(addScalar(value, thisUnitOffset), otherUnitOffset);
}
other.fixPrefix = true;
other.skipAutomaticSimplification = true;
return other;
};
/**
* Return the value of the unit when represented with given valueless unit
* @memberof Unit
* @param {string | Unit} valuelessUnit For example 'cm' or 'inch'
* @return {number} Returns the unit value as number.
*/
// TODO: deprecate Unit.toNumber? It's always better to use toNumeric
Unit.prototype.toNumber = function (valuelessUnit) {
return toNumber(this.toNumeric(valuelessUnit));
};
/**
* Return the value of the unit in the original numeric type
* @memberof Unit
* @param {string | Unit} valuelessUnit For example 'cm' or 'inch'
* @return {number | BigNumber | Fraction} Returns the unit value
*/
Unit.prototype.toNumeric = function (valuelessUnit) {
var other;
if (valuelessUnit) {
// Allow getting the numeric value without converting to a different unit
other = this.to(valuelessUnit);
} else {
other = this.clone();
}
if (other._isDerived() || other.units.length === 0) {
return other._denormalize(other.value);
} else {
return other._denormalize(other.value, other.units[0].prefix.value);
}
};
/**
* Get a string representation of the unit.
* @memberof Unit
* @return {string}
*/
Unit.prototype.toString = function () {
return this.format();
};
/**
* Get a JSON representation of the unit
* @memberof Unit
* @returns {Object} Returns a JSON object structured as:
* `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
*/
Unit.prototype.toJSON = function () {
return {
mathjs: 'Unit',
value: this._denormalize(this.value),
unit: this.formatUnits(),
fixPrefix: this.fixPrefix
};
};
/**
* Instantiate a Unit from a JSON object
* @memberof Unit
* @param {Object} json A JSON object structured as:
* `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
* @return {Unit}
*/
Unit.fromJSON = function (json) {
var unit = new Unit(json.value, json.unit);
unit.fixPrefix = json.fixPrefix || false;
return unit;
};
/**
* Returns the string representation of the unit.
* @memberof Unit
* @return {string}
*/
Unit.prototype.valueOf = Unit.prototype.toString;
/**
* Simplify this Unit's unit list and return a new Unit with the simplified list.
* The returned Unit will contain a list of the "best" units for formatting.
*/
Unit.prototype.simplify = function () {
var ret = this.clone();
var proposedUnitList = [];
// Search for a matching base
var matchingBase;
for (var key in currentUnitSystem) {
if (hasOwnProperty(currentUnitSystem, key)) {
if (ret.hasBase(BASE_UNITS[key])) {
matchingBase = key;
break;
}
}
}
if (matchingBase === 'NONE') {
ret.units = [];
} else {
var matchingUnit;
if (matchingBase) {
// Does the unit system have a matching unit?
if (hasOwnProperty(currentUnitSystem, matchingBase)) {
matchingUnit = currentUnitSystem[matchingBase];
}
}
if (matchingUnit) {
ret.units = [{
unit: matchingUnit.unit,
prefix: matchingUnit.prefix,
power: 1.0
}];
} else {
// Multiple units or units with powers are formatted like this:
// 5 (kg m^2) / (s^3 mol)
// Build an representation from the base units of the current unit system
var missingBaseDim = false;
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
var baseDim = BASE_DIMENSIONS[i];
if (Math.abs(ret.dimensions[i] || 0) > 1e-12) {
if (hasOwnProperty(currentUnitSystem, baseDim)) {
proposedUnitList.push({
unit: currentUnitSystem[baseDim].unit,
prefix: currentUnitSystem[baseDim].prefix,
power: ret.dimensions[i] || 0
});
} else {
missingBaseDim = true;
}
}
}
// Is the proposed unit list "simpler" than the existing one?
if (proposedUnitList.length < ret.units.length && !missingBaseDim) {
// Replace this unit list with the proposed list
ret.units = proposedUnitList;
}
}
}
return ret;
};
/**
* Returns a new Unit in the SI system with the same value as this one
*/
Unit.prototype.toSI = function () {
var ret = this.clone();
var proposedUnitList = [];
// Multiple units or units with powers are formatted like this:
// 5 (kg m^2) / (s^3 mol)
// Build an representation from the base units of the SI unit system
for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
var baseDim = BASE_DIMENSIONS[i];
if (Math.abs(ret.dimensions[i] || 0) > 1e-12) {
if (hasOwnProperty(UNIT_SYSTEMS.si, baseDim)) {
proposedUnitList.push({
unit: UNIT_SYSTEMS.si[baseDim].unit,
prefix: UNIT_SYSTEMS.si[baseDim].prefix,
power: ret.dimensions[i] || 0
});
} else {
throw new Error('Cannot express custom unit ' + baseDim + ' in SI units');
}
}
}
// Replace this unit list with the proposed list
ret.units = proposedUnitList;
ret.fixPrefix = true;
ret.skipAutomaticSimplification = true;
return ret;
};
/**
* Get a string representation of the units of this Unit, without the value. The unit list is formatted as-is without first being simplified.
* @memberof Unit
* @return {string}
*/
Unit.prototype.formatUnits = function () {
var strNum = '';
var strDen = '';
var nNum = 0;
var nDen = 0;
for (var i = 0; i < this.units.length; i++) {
if (this.units[i].power > 0) {
nNum++;
strNum += ' ' + this.units[i].prefix.name + this.units[i].unit.name;
if (Math.abs(this.units[i].power - 1.0) > 1e-15) {
strNum += '^' + this.units[i].power;
}
} else if (this.units[i].power < 0) {
nDen++;
}
}
if (nDen > 0) {
for (var _i4 = 0; _i4 < this.units.length; _i4++) {
if (this.units[_i4].power < 0) {
if (nNum > 0) {
strDen += ' ' + this.units[_i4].prefix.name + this.units[_i4].unit.name;
if (Math.abs(this.units[_i4].power + 1.0) > 1e-15) {
strDen += '^' + -this.units[_i4].power;
}
} else {
strDen += ' ' + this.units[_i4].prefix.name + this.units[_i4].unit.name;
strDen += '^' + this.units[_i4].power;
}
}
}
}
// Remove leading " "
strNum = strNum.substr(1);
strDen = strDen.substr(1);
// Add parans for better copy/paste back into evaluate, for example, or for better pretty print formatting
if (nNum > 1 && nDen > 0) {
strNum = '(' + strNum + ')';
}
if (nDen > 1 && nNum > 0) {
strDen = '(' + strDen + ')';
}
var str = strNum;
if (nNum > 0 && nDen > 0) {
str += ' / ';
}
str += strDen;
return str;
};
/**
* Get a string representation of the Unit, with optional formatting options.
* @memberof Unit
* @param {Object | number | Function} [options] Formatting options. See
* lib/utils/number:format for a
* description of the available
* options.
* @return {string}
*/
Unit.prototype.format = function (options) {
// Simplfy the unit list, unless it is valueless or was created directly in the
// constructor or as the result of to or toSI
var simp = this.skipAutomaticSimplification || this.value === null ? this.clone() : this.simplify();
// Apply some custom logic for handling VA and VAR. The goal is to express the value of the unit as a real value, if possible. Otherwise, use a real-valued unit instead of a complex-valued one.
var isImaginary = false;
if (typeof simp.value !== 'undefined' && simp.value !== null && isComplex(simp.value)) {
// TODO: Make this better, for example, use relative magnitude of re and im rather than absolute
isImaginary = Math.abs(simp.value.re) < 1e-14;
}
for (var i in simp.units) {
if (hasOwnProperty(simp.units, i)) {
if (simp.units[i].unit) {
if (simp.units[i].unit.name === 'VA' && isImaginary) {
simp.units[i].unit = UNITS.VAR;
} else if (simp.units[i].unit.name === 'VAR' && !isImaginary) {
simp.units[i].unit = UNITS.VA;
}
}
}
}
// Now apply the best prefix
// Units must have only one unit and not have the fixPrefix flag set
if (simp.units.length === 1 && !simp.fixPrefix) {
// Units must have integer powers, otherwise the prefix will change the
// outputted value by not-an-integer-power-of-ten
if (Math.abs(simp.units[0].power - Math.round(simp.units[0].power)) < 1e-14) {
// Apply the best prefix
simp.units[0].prefix = simp._bestPrefix();
}
}
var value = simp._denormalize(simp.value);
var str = simp.value !== null ? format(value, options || {}) : '';
var unitStr = simp.formatUnits();
if (simp.value && isComplex(simp.value)) {
str = '(' + str + ')'; // Surround complex values with ( ) to enable better parsing
}
if (unitStr.length > 0 && str.length > 0) {
str += ' ';
}
str += unitStr;
return str;
};
/**
* Calculate the best prefix using current value.
* @memberof Unit
* @returns {Object} prefix
* @private
*/
Unit.prototype._bestPrefix = function () {
if (this.units.length !== 1) {
throw new Error('Can only compute the best prefix for single units with integer powers, like kg, s^2, N^-1, and so forth!');
}
if (Math.abs(this.units[0].power - Math.round(this.units[0].power)) >= 1e-14) {
throw new Error('Can only compute the best prefix for single units with integer powers, like kg, s^2, N^-1, and so forth!');
}
// find the best prefix value (resulting in the value of which
// the absolute value of the log10 is closest to zero,
// though with a little offset of 1.2 for nicer values: you get a
// sequence 1mm 100mm 500mm 0.6m 1m 10m 100m 500m 0.6km 1km ...
// Note: the units value can be any numeric type, but to find the best
// prefix it's enough to work with limited precision of a regular number
// Update: using mathjs abs since we also allow complex numbers
var absValue = this.value !== null ? abs(this.value) : 0;
var absUnitValue = abs(this.units[0].unit.value);
var bestPrefix = this.units[0].prefix;
if (absValue === 0) {
return bestPrefix;
}
var power = this.units[0].power;
var bestDiff = Math.log(absValue / Math.pow(bestPrefix.value * absUnitValue, power)) / Math.LN10 - 1.2;
if (bestDiff > -2.200001 && bestDiff < 1.800001) return bestPrefix; // Allow the original prefix
bestDiff = Math.abs(bestDiff);
var prefixes = this.units[0].unit.prefixes;
for (var p in prefixes) {
if (hasOwnProperty(prefixes, p)) {
var prefix = prefixes[p];
if (prefix.scientific) {
var diff = Math.abs(Math.log(absValue / Math.pow(prefix.value * absUnitValue, power)) / Math.LN10 - 1.2);
if (diff < bestDiff || diff === bestDiff && prefix.name.length < bestPrefix.name.length) {
// choose the prefix with the smallest diff, or if equal, choose the one
// with the shortest name (can happen with SHORTLONG for example)
bestPrefix = prefix;
bestDiff = diff;
}
}
}
}
return bestPrefix;
};
/**
* Returns an array of units whose sum is equal to this unit
* @memberof Unit
* @param {Array} [parts] An array of strings or valueless units.
*
* Example:
*
* const u = new Unit(1, 'm')
* u.splitUnit(['feet', 'inch'])
* [ 3 feet, 3.3700787401575 inch ]
*
* @return {Array} An array of units.
*/
Unit.prototype.splitUnit = function (parts) {
var x = this.clone();
var ret = [];
for (var i = 0; i < parts.length; i++) {
// Convert x to the requested unit
x = x.to(parts[i]);
if (i === parts.length - 1) break;
// Get the numeric value of this unit
var xNumeric = x.toNumeric();
// Check to see if xNumeric is nearly equal to an integer,
// since fix can incorrectly round down if there is round-off error
var xRounded = round(xNumeric);
var xFixed = void 0;
var isNearlyEqual = equal(xRounded, xNumeric);
if (isNearlyEqual) {
xFixed = xRounded;
} else {
xFixed = fix(x.toNumeric());
}
var y = new Unit(xFixed, parts[i].toString());
ret.push(y);
x = subtract(x, y);
}
// This little bit fixes a bug where the remainder should be 0 but is a little bit off.
// But instead of comparing x, the remainder, with zero--we will compare the sum of
// all the parts so far with the original value. If they are nearly equal,
// we set the remainder to 0.
var testSum = 0;
for (var _i5 = 0; _i5 < ret.length; _i5++) {
testSum = addScalar(testSum, ret[_i5].value);
}
if (equal(testSum, this.value)) {
x.value = 0;
}
ret.push(x);
return ret;
};
var PREFIXES = {
NONE: {
'': {
name: '',
value: 1,
scientific: true
}
},
SHORT: {
'': {
name: '',
value: 1,
scientific: true
},
da: {
name: 'da',
value: 1e1,
scientific: false
},
h: {
name: 'h',
value: 1e2,
scientific: false
},
k: {
name: 'k',
value: 1e3,
scientific: true
},
M: {
name: 'M',
value: 1e6,
scientific: true
},
G: {
name: 'G',
value: 1e9,
scientific: true
},
T: {
name: 'T',
value: 1e12,
scientific: true
},
P: {
name: 'P',
value: 1e15,
scientific: true
},
E: {
name: 'E',
value: 1e18,
scientific: true
},
Z: {
name: 'Z',
value: 1e21,
scientific: true
},
Y: {
name: 'Y',
value: 1e24,
scientific: true
},
d: {
name: 'd',
value: 1e-1,
scientific: false
},
c: {
name: 'c',
value: 1e-2,
scientific: false
},
m: {
name: 'm',
value: 1e-3,
scientific: true
},
u: {
name: 'u',
value: 1e-6,
scientific: true
},
n: {
name: 'n',
value: 1e-9,
scientific: true
},
p: {
name: 'p',
value: 1e-12,
scientific: true
},
f: {
name: 'f',
value: 1e-15,
scientific: true
},
a: {
name: 'a',
value: 1e-18,
scientific: true
},
z: {
name: 'z',
value: 1e-21,
scientific: true
},
y: {
name: 'y',
value: 1e-24,
scientific: true
}
},
LONG: {
'': {
name: '',
value: 1,
scientific: true
},
deca: {
name: 'deca',
value: 1e1,
scientific: false
},
hecto: {
name: 'hecto',
value: 1e2,
scientific: false
},
kilo: {
name: 'kilo',
value: 1e3,
scientific: true
},
mega: {
name: 'mega',
value: 1e6,
scientific: true
},
giga: {
name: 'giga',
value: 1e9,
scientific: true
},
tera: {
name: 'tera',
value: 1e12,
scientific: true
},
peta: {
name: 'peta',
value: 1e15,
scientific: true
},
exa: {
name: 'exa',
value: 1e18,
scientific: true
},
zetta: {
name: 'zetta',
value: 1e21,
scientific: true
},
yotta: {
name: 'yotta',
value: 1e24,
scientific: true
},
deci: {
name: 'deci',
value: 1e-1,
scientific: false
},
centi: {
name: 'centi',
value: 1e-2,
scientific: false
},
milli: {
name: 'milli',
value: 1e-3,
scientific: true
},
micro: {
name: 'micro',
value: 1e-6,
scientific: true
},
nano: {
name: 'nano',
value: 1e-9,
scientific: true
},
pico: {
name: 'pico',
value: 1e-12,
scientific: true
},
femto: {
name: 'femto',
value: 1e-15,
scientific: true
},
atto: {
name: 'atto',
value: 1e-18,
scientific: true
},
zepto: {
name: 'zepto',
value: 1e-21,
scientific: true
},
yocto: {
name: 'yocto',
value: 1e-24,
scientific: true
}
},
SQUARED: {
'': {
name: '',
value: 1,
scientific: true
},
da: {
name: 'da',
value: 1e2,
scientific: false
},
h: {
name: 'h',
value: 1e4,
scientific: false
},
k: {
name: 'k',
value: 1e6,
scientific: true
},
M: {
name: 'M',
value: 1e12,
scientific: true
},
G: {
name: 'G',
value: 1e18,
scientific: true
},
T: {
name: 'T',
value: 1e24,
scientific: true
},
P: {
name: 'P',
value: 1e30,
scientific: true
},
E: {
name: 'E',
value: 1e36,
scientific: true
},
Z: {
name: 'Z',
value: 1e42,
scientific: true
},
Y: {
name: 'Y',
value: 1e48,
scientific: true
},
d: {
name: 'd',
value: 1e-2,
scientific: false
},
c: {
name: 'c',
value: 1e-4,
scientific: false
},
m: {
name: 'm',
value: 1e-6,
scientific: true
},
u: {
name: 'u',
value: 1e-12,
scientific: true
},
n: {
name: 'n',
value: 1e-18,
scientific: true
},
p: {
name: 'p',
value: 1e-24,
scientific: true
},
f: {
name: 'f',
value: 1e-30,
scientific: true
},
a: {
name: 'a',
value: 1e-36,
scientific: true
},
z: {
name: 'z',
value: 1e-42,
scientific: true
},
y: {
name: 'y',
value: 1e-48,
scientific: true
}
},
CUBIC: {
'': {
name: '',
value: 1,
scientific: true
},
da: {
name: 'da',
value: 1e3,
scientific: false
},
h: {
name: 'h',
value: 1e6,
scientific: false
},
k: {
name: 'k',
value: 1e9,
scientific: true
},
M: {
name: 'M',
value: 1e18,
scientific: true
},
G: {
name: 'G',
value: 1e27,
scientific: true
},
T: {
name: 'T',
value: 1e36,
scientific: true
},
P: {
name: 'P',
value: 1e45,
scientific: true
},
E: {
name: 'E',
value: 1e54,
scientific: true
},
Z: {
name: 'Z',
value: 1e63,
scientific: true
},
Y: {
name: 'Y',
value: 1e72,
scientific: true
},
d: {
name: 'd',
value: 1e-3,
scientific: false
},
c: {
name: 'c',
value: 1e-6,
scientific: false
},
m: {
name: 'm',
value: 1e-9,
scientific: true
},
u: {
name: 'u',
value: 1e-18,
scientific: true
},
n: {
name: 'n',
value: 1e-27,
scientific: true
},
p: {
name: 'p',
value: 1e-36,
scientific: true
},
f: {
name: 'f',
value: 1e-45,
scientific: true
},
a: {
name: 'a',
value: 1e-54,
scientific: true
},
z: {
name: 'z',
value: 1e-63,
scientific: true
},
y: {
name: 'y',
value: 1e-72,
scientific: true
}
},
BINARY_SHORT_SI: {
'': {
name: '',
value: 1,
scientific: true
},
k: {
name: 'k',
value: 1e3,
scientific: true
},
M: {
name: 'M',
value: 1e6,
scientific: true
},
G: {
name: 'G',
value: 1e9,
scientific: true
},
T: {
name: 'T',
value: 1e12,
scientific: true
},
P: {
name: 'P',
value: 1e15,
scientific: true
},
E: {
name: 'E',
value: 1e18,
scientific: true
},
Z: {
name: 'Z',
value: 1e21,
scientific: true
},
Y: {
name: 'Y',
value: 1e24,
scientific: true
}
},
BINARY_SHORT_IEC: {
'': {
name: '',
value: 1,
scientific: true
},
Ki: {
name: 'Ki',
value: 1024,
scientific: true
},
Mi: {
name: 'Mi',
value: Math.pow(1024, 2),
scientific: true
},
Gi: {
name: 'Gi',
value: Math.pow(1024, 3),
scientific: true
},
Ti: {
name: 'Ti',
value: Math.pow(1024, 4),
scientific: true
},
Pi: {
name: 'Pi',
value: Math.pow(1024, 5),
scientific: true
},
Ei: {
name: 'Ei',
value: Math.pow(1024, 6),
scientific: true
},
Zi: {
name: 'Zi',
value: Math.pow(1024, 7),
scientific: true
},
Yi: {
name: 'Yi',
value: Math.pow(1024, 8),
scientific: true
}
},
BINARY_LONG_SI: {
'': {
name: '',
value: 1,
scientific: true
},
kilo: {
name: 'kilo',
value: 1e3,
scientific: true
},
mega: {
name: 'mega',
value: 1e6,
scientific: true
},
giga: {
name: 'giga',
value: 1e9,
scientific: true
},
tera: {
name: 'tera',
value: 1e12,
scientific: true
},
peta: {
name: 'peta',
value: 1e15,
scientific: true
},
exa: {
name: 'exa',
value: 1e18,
scientific: true
},
zetta: {
name: 'zetta',
value: 1e21,
scientific: true
},
yotta: {
name: 'yotta',
value: 1e24,
scientific: true
}
},
BINARY_LONG_IEC: {
'': {
name: '',
value: 1,
scientific: true
},
kibi: {
name: 'kibi',
value: 1024,
scientific: true
},
mebi: {
name: 'mebi',
value: Math.pow(1024, 2),
scientific: true
},
gibi: {
name: 'gibi',
value: Math.pow(1024, 3),
scientific: true
},
tebi: {
name: 'tebi',
value: Math.pow(1024, 4),
scientific: true
},
pebi: {
name: 'pebi',
value: Math.pow(1024, 5),
scientific: true
},
exi: {
name: 'exi',
value: Math.pow(1024, 6),
scientific: true
},
zebi: {
name: 'zebi',
value: Math.pow(1024, 7),
scientific: true
},
yobi: {
name: 'yobi',
value: Math.pow(1024, 8),
scientific: true
}
},
BTU: {
'': {
name: '',
value: 1,
scientific: true
},
MM: {
name: 'MM',
value: 1e6,
scientific: true
}
}
};
PREFIXES.SHORTLONG = _extends({}, PREFIXES.SHORT, PREFIXES.LONG);
PREFIXES.BINARY_SHORT = _extends({}, PREFIXES.BINARY_SHORT_SI, PREFIXES.BINARY_SHORT_IEC);
PREFIXES.BINARY_LONG = _extends({}, PREFIXES.BINARY_LONG_SI, PREFIXES.BINARY_LONG_IEC);
/* Internally, each unit is represented by a value and a dimension array. The elements of the dimensions array have the following meaning:
* Index Dimension
* ----- ---------
* 0 Length
* 1 Mass
* 2 Time
* 3 Current
* 4 Temperature
* 5 Luminous intensity
* 6 Amount of substance
* 7 Angle
* 8 Bit (digital)
* For example, the unit "298.15 K" is a pure temperature and would have a value of 298.15 and a dimension array of [0, 0, 0, 0, 1, 0, 0, 0, 0]. The unit "1 cal / (gm °C)" can be written in terms of the 9 fundamental dimensions as [length^2] / ([time^2] * [temperature]), and would a value of (after conversion to SI) 4184.0 and a dimensions array of [2, 0, -2, 0, -1, 0, 0, 0, 0].
*
*/
var BASE_DIMENSIONS = ['MASS', 'LENGTH', 'TIME', 'CURRENT', 'TEMPERATURE', 'LUMINOUS_INTENSITY', 'AMOUNT_OF_SUBSTANCE', 'ANGLE', 'BIT'];
var BASE_UNITS = {
NONE: {
dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 0]
},
MASS: {
dimensions: [1, 0, 0, 0, 0, 0, 0, 0, 0]
},
LENGTH: {
dimensions: [0, 1, 0, 0, 0, 0, 0, 0, 0]
},
TIME: {
dimensions: [0, 0, 1, 0, 0, 0, 0, 0, 0]
},
CURRENT: {
dimensions: [0, 0, 0, 1, 0, 0, 0, 0, 0]
},
TEMPERATURE: {
dimensions: [0, 0, 0, 0, 1, 0, 0, 0, 0]
},
LUMINOUS_INTENSITY: {
dimensions: [0, 0, 0, 0, 0, 1, 0, 0, 0]
},
AMOUNT_OF_SUBSTANCE: {
dimensions: [0, 0, 0, 0, 0, 0, 1, 0, 0]
},
FORCE: {
dimensions: [1, 1, -2, 0, 0, 0, 0, 0, 0]
},
SURFACE: {
dimensions: [0, 2, 0, 0, 0, 0, 0, 0, 0]
},
VOLUME: {
dimensions: [0, 3, 0, 0, 0, 0, 0, 0, 0]
},
ENERGY: {
dimensions: [1, 2, -2, 0, 0, 0, 0, 0, 0]
},
POWER: {
dimensions: [1, 2, -3, 0, 0, 0, 0, 0, 0]
},
PRESSURE: {
dimensions: [1, -1, -2, 0, 0, 0, 0, 0, 0]
},
ELECTRIC_CHARGE: {
dimensions: [0, 0, 1, 1, 0, 0, 0, 0, 0]
},
ELECTRIC_CAPACITANCE: {
dimensions: [-1, -2, 4, 2, 0, 0, 0, 0, 0]
},
ELECTRIC_POTENTIAL: {
dimensions: [1, 2, -3, -1, 0, 0, 0, 0, 0]
},
ELECTRIC_RESISTANCE: {
dimensions: [1, 2, -3, -2, 0, 0, 0, 0, 0]
},
ELECTRIC_INDUCTANCE: {
dimensions: [1, 2, -2, -2, 0, 0, 0, 0, 0]
},
ELECTRIC_CONDUCTANCE: {
dimensions: [-1, -2, 3, 2, 0, 0, 0, 0, 0]
},
MAGNETIC_FLUX: {
dimensions: [1, 2, -2, -1, 0, 0, 0, 0, 0]
},
MAGNETIC_FLUX_DENSITY: {
dimensions: [1, 0, -2, -1, 0, 0, 0, 0, 0]
},
FREQUENCY: {
dimensions: [0, 0, -1, 0, 0, 0, 0, 0, 0]
},
ANGLE: {
dimensions: [0, 0, 0, 0, 0, 0, 0, 1, 0]
},
BIT: {
dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 1]
}
};
for (var key in BASE_UNITS) {
if (hasOwnProperty(BASE_UNITS, key)) {
BASE_UNITS[key].key = key;
}
}
var BASE_UNIT_NONE = {};
var UNIT_NONE = {
name: '',
base: BASE_UNIT_NONE,
value: 1,
offset: 0,
dimensions: BASE_DIMENSIONS.map(x => 0)
};
var UNITS = {
// length
meter: {
name: 'meter',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
inch: {
name: 'inch',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.0254,
offset: 0
},
foot: {
name: 'foot',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.3048,
offset: 0
},
yard: {
name: 'yard',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.9144,
offset: 0
},
mile: {
name: 'mile',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 1609.344,
offset: 0
},
link: {
name: 'link',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.201168,
offset: 0
},
rod: {
name: 'rod',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 5.0292,
offset: 0
},
chain: {
name: 'chain',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 20.1168,
offset: 0
},
angstrom: {
name: 'angstrom',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 1e-10,
offset: 0
},
m: {
name: 'm',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
in: {
name: 'in',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.0254,
offset: 0
},
ft: {
name: 'ft',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.3048,
offset: 0
},
yd: {
name: 'yd',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.9144,
offset: 0
},
mi: {
name: 'mi',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 1609.344,
offset: 0
},
li: {
name: 'li',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.201168,
offset: 0
},
rd: {
name: 'rd',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 5.029210,
offset: 0
},
ch: {
name: 'ch',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 20.1168,
offset: 0
},
mil: {
name: 'mil',
base: BASE_UNITS.LENGTH,
prefixes: PREFIXES.NONE,
value: 0.0000254,
offset: 0
},
// 1/1000 inch
// Surface
m2: {
name: 'm2',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.SQUARED,
value: 1,
offset: 0
},
sqin: {
name: 'sqin',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 0.00064516,
offset: 0
},
// 645.16 mm2
sqft: {
name: 'sqft',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 0.09290304,
offset: 0
},
// 0.09290304 m2
sqyd: {
name: 'sqyd',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 0.83612736,
offset: 0
},
// 0.83612736 m2
sqmi: {
name: 'sqmi',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 2589988.110336,
offset: 0
},
// 2.589988110336 km2
sqrd: {
name: 'sqrd',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 25.29295,
offset: 0
},
// 25.29295 m2
sqch: {
name: 'sqch',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 404.6873,
offset: 0
},
// 404.6873 m2
sqmil: {
name: 'sqmil',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 6.4516e-10,
offset: 0
},
// 6.4516 * 10^-10 m2
acre: {
name: 'acre',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 4046.86,
offset: 0
},
// 4046.86 m2
hectare: {
name: 'hectare',
base: BASE_UNITS.SURFACE,
prefixes: PREFIXES.NONE,
value: 10000,
offset: 0
},
// 10000 m2
// Volume
m3: {
name: 'm3',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.CUBIC,
value: 1,
offset: 0
},
L: {
name: 'L',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.SHORT,
value: 0.001,
offset: 0
},
// litre
l: {
name: 'l',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.SHORT,
value: 0.001,
offset: 0
},
// litre
litre: {
name: 'litre',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.LONG,
value: 0.001,
offset: 0
},
cuin: {
name: 'cuin',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 1.6387064e-5,
offset: 0
},
// 1.6387064e-5 m3
cuft: {
name: 'cuft',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.028316846592,
offset: 0
},
// 28.316 846 592 L
cuyd: {
name: 'cuyd',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.764554857984,
offset: 0
},
// 764.554 857 984 L
teaspoon: {
name: 'teaspoon',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.000005,
offset: 0
},
// 5 mL
tablespoon: {
name: 'tablespoon',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.000015,
offset: 0
},
// 15 mL
// {name: 'cup', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.000240, offset: 0}, // 240 mL // not possible, we have already another cup
drop: {
name: 'drop',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 5e-8,
offset: 0
},
// 0.05 mL = 5e-8 m3
gtt: {
name: 'gtt',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 5e-8,
offset: 0
},
// 0.05 mL = 5e-8 m3
// Liquid volume
minim: {
name: 'minim',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.00000006161152,
offset: 0
},
// 0.06161152 mL
fluiddram: {
name: 'fluiddram',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0000036966911,
offset: 0
},
// 3.696691 mL
fluidounce: {
name: 'fluidounce',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.00002957353,
offset: 0
},
// 29.57353 mL
gill: {
name: 'gill',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0001182941,
offset: 0
},
// 118.2941 mL
cc: {
name: 'cc',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 1e-6,
offset: 0
},
// 1e-6 L
cup: {
name: 'cup',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0002365882,
offset: 0
},
// 236.5882 mL
pint: {
name: 'pint',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0004731765,
offset: 0
},
// 473.1765 mL
quart: {
name: 'quart',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0009463529,
offset: 0
},
// 946.3529 mL
gallon: {
name: 'gallon',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.003785412,
offset: 0
},
// 3.785412 L
beerbarrel: {
name: 'beerbarrel',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.1173478,
offset: 0
},
// 117.3478 L
oilbarrel: {
name: 'oilbarrel',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.1589873,
offset: 0
},
// 158.9873 L
hogshead: {
name: 'hogshead',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.2384810,
offset: 0
},
// 238.4810 L
// {name: 'min', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.00000006161152, offset: 0}, // 0.06161152 mL // min is already in use as minute
fldr: {
name: 'fldr',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0000036966911,
offset: 0
},
// 3.696691 mL
floz: {
name: 'floz',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.00002957353,
offset: 0
},
// 29.57353 mL
gi: {
name: 'gi',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0001182941,
offset: 0
},
// 118.2941 mL
cp: {
name: 'cp',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0002365882,
offset: 0
},
// 236.5882 mL
pt: {
name: 'pt',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0004731765,
offset: 0
},
// 473.1765 mL
qt: {
name: 'qt',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.0009463529,
offset: 0
},
// 946.3529 mL
gal: {
name: 'gal',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.003785412,
offset: 0
},
// 3.785412 L
bbl: {
name: 'bbl',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.1173478,
offset: 0
},
// 117.3478 L
obl: {
name: 'obl',
base: BASE_UNITS.VOLUME,
prefixes: PREFIXES.NONE,
value: 0.1589873,
offset: 0
},
// 158.9873 L
// {name: 'hogshead', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.2384810, offset: 0}, // 238.4810 L // TODO: hh?
// Mass
g: {
name: 'g',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.SHORT,
value: 0.001,
offset: 0
},
gram: {
name: 'gram',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.LONG,
value: 0.001,
offset: 0
},
ton: {
name: 'ton',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.SHORT,
value: 907.18474,
offset: 0
},
t: {
name: 't',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.SHORT,
value: 1000,
offset: 0
},
tonne: {
name: 'tonne',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.LONG,
value: 1000,
offset: 0
},
grain: {
name: 'grain',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 64.79891e-6,
offset: 0
},
dram: {
name: 'dram',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 1.7718451953125e-3,
offset: 0
},
ounce: {
name: 'ounce',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 28.349523125e-3,
offset: 0
},
poundmass: {
name: 'poundmass',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 453.59237e-3,
offset: 0
},
hundredweight: {
name: 'hundredweight',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 45.359237,
offset: 0
},
stick: {
name: 'stick',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 115e-3,
offset: 0
},
stone: {
name: 'stone',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 6.35029318,
offset: 0
},
gr: {
name: 'gr',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 64.79891e-6,
offset: 0
},
dr: {
name: 'dr',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 1.7718451953125e-3,
offset: 0
},
oz: {
name: 'oz',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 28.349523125e-3,
offset: 0
},
lbm: {
name: 'lbm',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 453.59237e-3,
offset: 0
},
cwt: {
name: 'cwt',
base: BASE_UNITS.MASS,
prefixes: PREFIXES.NONE,
value: 45.359237,
offset: 0
},
// Time
s: {
name: 's',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
min: {
name: 'min',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 60,
offset: 0
},
h: {
name: 'h',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 3600,
offset: 0
},
second: {
name: 'second',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
sec: {
name: 'sec',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
minute: {
name: 'minute',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 60,
offset: 0
},
hour: {
name: 'hour',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 3600,
offset: 0
},
day: {
name: 'day',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 86400,
offset: 0
},
week: {
name: 'week',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 7 * 86400,
offset: 0
},
month: {
name: 'month',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 2629800,
// 1/12th of Julian year
offset: 0
},
year: {
name: 'year',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 31557600,
// Julian year
offset: 0
},
decade: {
name: 'decade',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 315576000,
// Julian decade
offset: 0
},
century: {
name: 'century',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 3155760000,
// Julian century
offset: 0
},
millennium: {
name: 'millennium',
base: BASE_UNITS.TIME,
prefixes: PREFIXES.NONE,
value: 31557600000,
// Julian millennium
offset: 0
},
// Frequency
hertz: {
name: 'Hertz',
base: BASE_UNITS.FREQUENCY,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0,
reciprocal: true
},
Hz: {
name: 'Hz',
base: BASE_UNITS.FREQUENCY,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0,
reciprocal: true
},
// Angle
rad: {
name: 'rad',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
radian: {
name: 'radian',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
// deg = rad / (2*pi) * 360 = rad / 0.017453292519943295769236907684888
deg: {
name: 'deg',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.SHORT,
value: null,
// will be filled in by calculateAngleValues()
offset: 0
},
degree: {
name: 'degree',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.LONG,
value: null,
// will be filled in by calculateAngleValues()
offset: 0
},
// grad = rad / (2*pi) * 400 = rad / 0.015707963267948966192313216916399
grad: {
name: 'grad',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.SHORT,
value: null,
// will be filled in by calculateAngleValues()
offset: 0
},
gradian: {
name: 'gradian',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.LONG,
value: null,
// will be filled in by calculateAngleValues()
offset: 0
},
// cycle = rad / (2*pi) = rad / 6.2831853071795864769252867665793
cycle: {
name: 'cycle',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.NONE,
value: null,
// will be filled in by calculateAngleValues()
offset: 0
},
// arcsec = rad / (3600 * (360 / 2 * pi)) = rad / 0.0000048481368110953599358991410235795
arcsec: {
name: 'arcsec',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.NONE,
value: null,
// will be filled in by calculateAngleValues()
offset: 0
},
// arcmin = rad / (60 * (360 / 2 * pi)) = rad / 0.00029088820866572159615394846141477
arcmin: {
name: 'arcmin',
base: BASE_UNITS.ANGLE,
prefixes: PREFIXES.NONE,
value: null,
// will be filled in by calculateAngleValues()
offset: 0
},
// Electric current
A: {
name: 'A',
base: BASE_UNITS.CURRENT,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
ampere: {
name: 'ampere',
base: BASE_UNITS.CURRENT,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
// Temperature
// K(C) = °C + 273.15
// K(F) = (°F + 459.67) / 1.8
// K(R) = °R / 1.8
K: {
name: 'K',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
degC: {
name: 'degC',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 273.15
},
degF: {
name: 'degF',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.SHORT,
value: 1 / 1.8,
offset: 459.67
},
degR: {
name: 'degR',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.SHORT,
value: 1 / 1.8,
offset: 0
},
kelvin: {
name: 'kelvin',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
celsius: {
name: 'celsius',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 273.15
},
fahrenheit: {
name: 'fahrenheit',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.LONG,
value: 1 / 1.8,
offset: 459.67
},
rankine: {
name: 'rankine',
base: BASE_UNITS.TEMPERATURE,
prefixes: PREFIXES.LONG,
value: 1 / 1.8,
offset: 0
},
// amount of substance
mol: {
name: 'mol',
base: BASE_UNITS.AMOUNT_OF_SUBSTANCE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
mole: {
name: 'mole',
base: BASE_UNITS.AMOUNT_OF_SUBSTANCE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
// luminous intensity
cd: {
name: 'cd',
base: BASE_UNITS.LUMINOUS_INTENSITY,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
candela: {
name: 'candela',
base: BASE_UNITS.LUMINOUS_INTENSITY,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
// TODO: units STERADIAN
// {name: 'sr', base: BASE_UNITS.STERADIAN, prefixes: PREFIXES.NONE, value: 1, offset: 0},
// {name: 'steradian', base: BASE_UNITS.STERADIAN, prefixes: PREFIXES.NONE, value: 1, offset: 0},
// Force
N: {
name: 'N',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
newton: {
name: 'newton',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
dyn: {
name: 'dyn',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.SHORT,
value: 0.00001,
offset: 0
},
dyne: {
name: 'dyne',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.LONG,
value: 0.00001,
offset: 0
},
lbf: {
name: 'lbf',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.NONE,
value: 4.4482216152605,
offset: 0
},
poundforce: {
name: 'poundforce',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.NONE,
value: 4.4482216152605,
offset: 0
},
kip: {
name: 'kip',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.LONG,
value: 4448.2216,
offset: 0
},
kilogramforce: {
name: 'kilogramforce',
base: BASE_UNITS.FORCE,
prefixes: PREFIXES.NONE,
value: 9.80665,
offset: 0
},
// Energy
J: {
name: 'J',
base: BASE_UNITS.ENERGY,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
joule: {
name: 'joule',
base: BASE_UNITS.ENERGY,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
erg: {
name: 'erg',
base: BASE_UNITS.ENERGY,
prefixes: PREFIXES.NONE,
value: 1e-7,
offset: 0
},
Wh: {
name: 'Wh',
base: BASE_UNITS.ENERGY,
prefixes: PREFIXES.SHORT,
value: 3600,
offset: 0
},
BTU: {
name: 'BTU',
base: BASE_UNITS.ENERGY,
prefixes: PREFIXES.BTU,
value: 1055.05585262,
offset: 0
},
eV: {
name: 'eV',
base: BASE_UNITS.ENERGY,
prefixes: PREFIXES.SHORT,
value: 1.602176565e-19,
offset: 0
},
electronvolt: {
name: 'electronvolt',
base: BASE_UNITS.ENERGY,
prefixes: PREFIXES.LONG,
value: 1.602176565e-19,
offset: 0
},
// Power
W: {
name: 'W',
base: BASE_UNITS.POWER,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
watt: {
name: 'watt',
base: BASE_UNITS.POWER,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
hp: {
name: 'hp',
base: BASE_UNITS.POWER,
prefixes: PREFIXES.NONE,
value: 745.6998715386,
offset: 0
},
// Electrical power units
VAR: {
name: 'VAR',
base: BASE_UNITS.POWER,
prefixes: PREFIXES.SHORT,
value: Complex.I,
offset: 0
},
VA: {
name: 'VA',
base: BASE_UNITS.POWER,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Pressure
Pa: {
name: 'Pa',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
psi: {
name: 'psi',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.NONE,
value: 6894.75729276459,
offset: 0
},
atm: {
name: 'atm',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.NONE,
value: 101325,
offset: 0
},
bar: {
name: 'bar',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.SHORTLONG,
value: 100000,
offset: 0
},
torr: {
name: 'torr',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.NONE,
value: 133.322,
offset: 0
},
mmHg: {
name: 'mmHg',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.NONE,
value: 133.322,
offset: 0
},
mmH2O: {
name: 'mmH2O',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.NONE,
value: 9.80665,
offset: 0
},
cmH2O: {
name: 'cmH2O',
base: BASE_UNITS.PRESSURE,
prefixes: PREFIXES.NONE,
value: 98.0665,
offset: 0
},
// Electric charge
coulomb: {
name: 'coulomb',
base: BASE_UNITS.ELECTRIC_CHARGE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
C: {
name: 'C',
base: BASE_UNITS.ELECTRIC_CHARGE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Electric capacitance
farad: {
name: 'farad',
base: BASE_UNITS.ELECTRIC_CAPACITANCE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
F: {
name: 'F',
base: BASE_UNITS.ELECTRIC_CAPACITANCE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Electric potential
volt: {
name: 'volt',
base: BASE_UNITS.ELECTRIC_POTENTIAL,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
V: {
name: 'V',
base: BASE_UNITS.ELECTRIC_POTENTIAL,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Electric resistance
ohm: {
name: 'ohm',
base: BASE_UNITS.ELECTRIC_RESISTANCE,
prefixes: PREFIXES.SHORTLONG,
// Both Mohm and megaohm are acceptable
value: 1,
offset: 0
},
/*
* Unicode breaks in browsers if charset is not specified
Ω: {
name: 'Ω',
base: BASE_UNITS.ELECTRIC_RESISTANCE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
*/
// Electric inductance
henry: {
name: 'henry',
base: BASE_UNITS.ELECTRIC_INDUCTANCE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
H: {
name: 'H',
base: BASE_UNITS.ELECTRIC_INDUCTANCE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Electric conductance
siemens: {
name: 'siemens',
base: BASE_UNITS.ELECTRIC_CONDUCTANCE,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
S: {
name: 'S',
base: BASE_UNITS.ELECTRIC_CONDUCTANCE,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Magnetic flux
weber: {
name: 'weber',
base: BASE_UNITS.MAGNETIC_FLUX,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
Wb: {
name: 'Wb',
base: BASE_UNITS.MAGNETIC_FLUX,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Magnetic flux density
tesla: {
name: 'tesla',
base: BASE_UNITS.MAGNETIC_FLUX_DENSITY,
prefixes: PREFIXES.LONG,
value: 1,
offset: 0
},
T: {
name: 'T',
base: BASE_UNITS.MAGNETIC_FLUX_DENSITY,
prefixes: PREFIXES.SHORT,
value: 1,
offset: 0
},
// Binary
b: {
name: 'b',
base: BASE_UNITS.BIT,
prefixes: PREFIXES.BINARY_SHORT,
value: 1,
offset: 0
},
bits: {
name: 'bits',
base: BASE_UNITS.BIT,
prefixes: PREFIXES.BINARY_LONG,
value: 1,
offset: 0
},
B: {
name: 'B',
base: BASE_UNITS.BIT,
prefixes: PREFIXES.BINARY_SHORT,
value: 8,
offset: 0
},
bytes: {
name: 'bytes',
base: BASE_UNITS.BIT,
prefixes: PREFIXES.BINARY_LONG,
value: 8,
offset: 0
}
};
// aliases (formerly plurals)
var ALIASES = {
meters: 'meter',
inches: 'inch',
feet: 'foot',
yards: 'yard',
miles: 'mile',
links: 'link',
rods: 'rod',
chains: 'chain',
angstroms: 'angstrom',
lt: 'l',
litres: 'litre',
liter: 'litre',
liters: 'litre',
teaspoons: 'teaspoon',
tablespoons: 'tablespoon',
minims: 'minim',
fluiddrams: 'fluiddram',
fluidounces: 'fluidounce',
gills: 'gill',
cups: 'cup',
pints: 'pint',
quarts: 'quart',
gallons: 'gallon',
beerbarrels: 'beerbarrel',
oilbarrels: 'oilbarrel',
hogsheads: 'hogshead',
gtts: 'gtt',
grams: 'gram',
tons: 'ton',
tonnes: 'tonne',
grains: 'grain',
drams: 'dram',
ounces: 'ounce',
poundmasses: 'poundmass',
hundredweights: 'hundredweight',
sticks: 'stick',
lb: 'lbm',
lbs: 'lbm',
kips: 'kip',
kgf: 'kilogramforce',
acres: 'acre',
hectares: 'hectare',
sqfeet: 'sqft',
sqyard: 'sqyd',
sqmile: 'sqmi',
sqmiles: 'sqmi',
mmhg: 'mmHg',
mmh2o: 'mmH2O',
cmh2o: 'cmH2O',
seconds: 'second',
secs: 'second',
minutes: 'minute',
mins: 'minute',
hours: 'hour',
hr: 'hour',
hrs: 'hour',
days: 'day',
weeks: 'week',
months: 'month',
years: 'year',
decades: 'decade',
centuries: 'century',
millennia: 'millennium',
hertz: 'hertz',
radians: 'radian',
degrees: 'degree',
gradians: 'gradian',
cycles: 'cycle',
arcsecond: 'arcsec',
arcseconds: 'arcsec',
arcminute: 'arcmin',
arcminutes: 'arcmin',
BTUs: 'BTU',
watts: 'watt',
joules: 'joule',
amperes: 'ampere',
coulombs: 'coulomb',
volts: 'volt',
ohms: 'ohm',
farads: 'farad',
webers: 'weber',
teslas: 'tesla',
electronvolts: 'electronvolt',
moles: 'mole',
bit: 'bits',
byte: 'bytes'
};
/**
* Calculate the values for the angle units.
* Value is calculated as number or BigNumber depending on the configuration
* @param {{number: 'number' | 'BigNumber'}} config
*/
function calculateAngleValues(config) {
if (config.number === 'BigNumber') {
var pi = createPi(_BigNumber);
UNITS.rad.value = new _BigNumber(1);
UNITS.deg.value = pi.div(180); // 2 * pi / 360
UNITS.grad.value = pi.div(200); // 2 * pi / 400
UNITS.cycle.value = pi.times(2); // 2 * pi
UNITS.arcsec.value = pi.div(648000); // 2 * pi / 360 / 3600
UNITS.arcmin.value = pi.div(10800); // 2 * pi / 360 / 60
} else {
// number
UNITS.rad.value = 1;
UNITS.deg.value = Math.PI / 180; // 2 * pi / 360
UNITS.grad.value = Math.PI / 200; // 2 * pi / 400
UNITS.cycle.value = Math.PI * 2; // 2 * pi
UNITS.arcsec.value = Math.PI / 648000; // 2 * pi / 360 / 3600
UNITS.arcmin.value = Math.PI / 10800; // 2 * pi / 360 / 60
}
// copy to the full names of the angles
UNITS.radian.value = UNITS.rad.value;
UNITS.degree.value = UNITS.deg.value;
UNITS.gradian.value = UNITS.grad.value;
}
// apply the angle values now
calculateAngleValues(config);
if (on) {
// recalculate the values on change of configuration
on('config', function (curr, prev) {
if (curr.number !== prev.number) {
calculateAngleValues(curr);
}
});
}
/**
* A unit system is a set of dimensionally independent base units plus a set of derived units, formed by multiplication and division of the base units, that are by convention used with the unit system.
* A user perhaps could issue a command to select a preferred unit system, or use the default (see below).
* Auto unit system: The default unit system is updated on the fly anytime a unit is parsed. The corresponding unit in the default unit system is updated, so that answers are given in the same units the user supplies.
*/
var UNIT_SYSTEMS = {
si: {
// Base units
NONE: {
unit: UNIT_NONE,
prefix: PREFIXES.NONE['']
},
LENGTH: {
unit: UNITS.m,
prefix: PREFIXES.SHORT['']
},
MASS: {
unit: UNITS.g,
prefix: PREFIXES.SHORT.k
},
TIME: {
unit: UNITS.s,
prefix: PREFIXES.SHORT['']
},
CURRENT: {
unit: UNITS.A,
prefix: PREFIXES.SHORT['']
},
TEMPERATURE: {
unit: UNITS.K,
prefix: PREFIXES.SHORT['']
},
LUMINOUS_INTENSITY: {
unit: UNITS.cd,
prefix: PREFIXES.SHORT['']
},
AMOUNT_OF_SUBSTANCE: {
unit: UNITS.mol,
prefix: PREFIXES.SHORT['']
},
ANGLE: {
unit: UNITS.rad,
prefix: PREFIXES.SHORT['']
},
BIT: {
unit: UNITS.bits,
prefix: PREFIXES.SHORT['']
},
// Derived units
FORCE: {
unit: UNITS.N,
prefix: PREFIXES.SHORT['']
},
ENERGY: {
unit: UNITS.J,
prefix: PREFIXES.SHORT['']
},
POWER: {
unit: UNITS.W,
prefix: PREFIXES.SHORT['']
},
PRESSURE: {
unit: UNITS.Pa,
prefix: PREFIXES.SHORT['']
},
ELECTRIC_CHARGE: {
unit: UNITS.C,
prefix: PREFIXES.SHORT['']
},
ELECTRIC_CAPACITANCE: {
unit: UNITS.F,
prefix: PREFIXES.SHORT['']
},
ELECTRIC_POTENTIAL: {
unit: UNITS.V,
prefix: PREFIXES.SHORT['']
},
ELECTRIC_RESISTANCE: {
unit: UNITS.ohm,
prefix: PREFIXES.SHORT['']
},
ELECTRIC_INDUCTANCE: {
unit: UNITS.H,
prefix: PREFIXES.SHORT['']
},
ELECTRIC_CONDUCTANCE: {
unit: UNITS.S,
prefix: PREFIXES.SHORT['']
},
MAGNETIC_FLUX: {
unit: UNITS.Wb,
prefix: PREFIXES.SHORT['']
},
MAGNETIC_FLUX_DENSITY: {
unit: UNITS.T,
prefix: PREFIXES.SHORT['']
},
FREQUENCY: {
unit: UNITS.Hz,
prefix: PREFIXES.SHORT['']
}
}
};
// Clone to create the other unit systems
UNIT_SYSTEMS.cgs = JSON.parse(JSON.stringify(UNIT_SYSTEMS.si));
UNIT_SYSTEMS.cgs.LENGTH = {
unit: UNITS.m,
prefix: PREFIXES.SHORT.c
};
UNIT_SYSTEMS.cgs.MASS = {
unit: UNITS.g,
prefix: PREFIXES.SHORT['']
};
UNIT_SYSTEMS.cgs.FORCE = {
unit: UNITS.dyn,
prefix: PREFIXES.SHORT['']
};
UNIT_SYSTEMS.cgs.ENERGY = {
unit: UNITS.erg,
prefix: PREFIXES.NONE['']
};
// there are wholly 4 unique cgs systems for electricity and magnetism,
// so let's not worry about it unless somebody complains
UNIT_SYSTEMS.us = JSON.parse(JSON.stringify(UNIT_SYSTEMS.si));
UNIT_SYSTEMS.us.LENGTH = {
unit: UNITS.ft,
prefix: PREFIXES.NONE['']
};
UNIT_SYSTEMS.us.MASS = {
unit: UNITS.lbm,
prefix: PREFIXES.NONE['']
};
UNIT_SYSTEMS.us.TEMPERATURE = {
unit: UNITS.degF,
prefix: PREFIXES.NONE['']
};
UNIT_SYSTEMS.us.FORCE = {
unit: UNITS.lbf,
prefix: PREFIXES.NONE['']
};
UNIT_SYSTEMS.us.ENERGY = {
unit: UNITS.BTU,
prefix: PREFIXES.BTU['']
};
UNIT_SYSTEMS.us.POWER = {
unit: UNITS.hp,
prefix: PREFIXES.NONE['']
};
UNIT_SYSTEMS.us.PRESSURE = {
unit: UNITS.psi,
prefix: PREFIXES.NONE['']
};
// Add additional unit systems here.
// Choose a unit system to seed the auto unit system.
UNIT_SYSTEMS.auto = JSON.parse(JSON.stringify(UNIT_SYSTEMS.si));
// Set the current unit system
var currentUnitSystem = UNIT_SYSTEMS.auto;
/**
* Set a unit system for formatting derived units.
* @param {string} [name] The name of the unit system.
*/
Unit.setUnitSystem = function (name) {
if (hasOwnProperty(UNIT_SYSTEMS, name)) {
currentUnitSystem = UNIT_SYSTEMS[name];
} else {
throw new Error('Unit system ' + name + ' does not exist. Choices are: ' + Object.keys(UNIT_SYSTEMS).join(', '));
}
};
/**
* Return the current unit system.
* @return {string} The current unit system.
*/
Unit.getUnitSystem = function () {
for (var _key in UNIT_SYSTEMS) {
if (hasOwnProperty(UNIT_SYSTEMS, _key)) {
if (UNIT_SYSTEMS[_key] === currentUnitSystem) {
return _key;
}
}
}
};
/**
* Converters to convert from number to an other numeric type like BigNumber
* or Fraction
*/
Unit.typeConverters = {
BigNumber: function BigNumber(x) {
return new _BigNumber(x + ''); // stringify to prevent constructor error
},
Fraction: function Fraction(x) {
return new _Fraction(x);
},
Complex: function Complex(x) {
return x;
},
number: function number(x) {
return x;
}
};
/**
* Retrieve the right converter function corresponding with this unit's
* value
*
* @memberof Unit
* @return {Function}
*/
Unit.prototype._numberConverter = function () {
var convert = Unit.typeConverters[this.valueType()];
if (convert) {
return convert;
}
throw new TypeError('Unsupported Unit value type "' + this.valueType() + '"');
};
/**
* Retrieve the right convertor function corresponding with the type
* of provided exampleValue.
*
* @param {string} type A string 'number', 'BigNumber', or 'Fraction'
* In case of an unknown type,
* @return {Function}
*/
Unit._getNumberConverter = function (type) {
if (!Unit.typeConverters[type]) {
throw new TypeError('Unsupported type "' + type + '"');
}
return Unit.typeConverters[type];
};
// Add dimensions to each built-in unit
for (var _key2 in UNITS) {
if (hasOwnProperty(UNITS, _key2)) {
var unit = UNITS[_key2];
unit.dimensions = unit.base.dimensions;
}
}
// Create aliases
for (var _name2 in ALIASES) {
if (hasOwnProperty(ALIASES, _name2)) {
var _unit2 = UNITS[ALIASES[_name2]];
var alias = {};
for (var _key3 in _unit2) {
if (hasOwnProperty(_unit2, _key3)) {
alias[_key3] = _unit2[_key3];
}
}
alias.name = _name2;
UNITS[_name2] = alias;
}
}
/**
* Checks if a character is a valid latin letter (upper or lower case).
* Note that this function can be overridden, for example to allow support of other alphabets.
* @param {string} c Tested character
*/
Unit.isValidAlpha = function isValidAlpha(c) {
return /^[a-zA-Z]$/.test(c);
};
function assertUnitNameIsValid(name) {
for (var i = 0; i < name.length; i++) {
c = name.charAt(i);
if (i === 0 && !Unit.isValidAlpha(c)) {
throw new Error('Invalid unit name (must begin with alpha character): "' + name + '"');
}
if (i > 0 && !(Unit.isValidAlpha(c) || isDigit(c))) {
throw new Error('Invalid unit name (only alphanumeric characters are allowed): "' + name + '"');
}
}
}
/**
* Wrapper around createUnitSingle.
* Example:
* createUnit({
* foo: { },
* bar: {
* definition: 'kg/foo',
* aliases: ['ba', 'barr', 'bars'],
* offset: 200
* },
* baz: '4 bar'
* },
* {
* override: true
* })
* @param {object} obj Object map. Each key becomes a unit which is defined by its value.
* @param {object} options
*/
Unit.createUnit = function (obj, options) {
if (typeof obj !== 'object') {
throw new TypeError("createUnit expects first parameter to be of type 'Object'");
}
// Remove all units and aliases we are overriding
if (options && options.override) {
for (var _key4 in obj) {
if (hasOwnProperty(obj, _key4)) {
Unit.deleteUnit(_key4);
}
if (obj[_key4].aliases) {
for (var i = 0; i < obj[_key4].aliases.length; i++) {
Unit.deleteUnit(obj[_key4].aliases[i]);
}
}
}
}
// TODO: traverse multiple times until all units have been added
var lastUnit;
for (var _key5 in obj) {
if (hasOwnProperty(obj, _key5)) {
lastUnit = Unit.createUnitSingle(_key5, obj[_key5]);
}
}
return lastUnit;
};
/**
* Create a user-defined unit and register it with the Unit type.
* Example:
* createUnitSingle('knot', '0.514444444 m/s')
* createUnitSingle('acre', new Unit(43560, 'ft^2'))
*
* @param {string} name The name of the new unit. Must be unique. Example: 'knot'
* @param {string, Unit, Object} definition Definition of the unit in terms
* of existing units. For example, '0.514444444 m / s'. Can be a Unit, a string,
* or an Object. If an Object, may have the following properties:
* - definition {string|Unit} The definition of this unit.
* - prefixes {string} "none", "short", "long", "binary_short", or "binary_long".
* The default is "none".
* - aliases {Array} Array of strings. Example: ['knots', 'kt', 'kts']
* - offset {Numeric} An offset to apply when converting from the unit. For
* example, the offset for celsius is 273.15 and the offset for farhenheit
* is 459.67. Default is 0.
* - baseName {string} If the unit's dimension does not match that of any other
* base unit, the name of the newly create base unit. Otherwise, this property
* has no effect.
*
* @return {Unit}
*/
Unit.createUnitSingle = function (name, obj) {
if (typeof obj === 'undefined' || obj === null) {
obj = {};
}
if (typeof name !== 'string') {
throw new TypeError("createUnitSingle expects first parameter to be of type 'string'");
}
// Check collisions with existing units
if (hasOwnProperty(UNITS, name)) {
throw new Error('Cannot create unit "' + name + '": a unit with that name already exists');
}
// TODO: Validate name for collisions with other built-in functions (like abs or cos, for example), and for acceptable variable names. For example, '42' is probably not a valid unit. Nor is '%', since it is also an operator.
assertUnitNameIsValid(name);
var defUnit = null; // The Unit from which the new unit will be created.
var aliases = [];
var offset = 0;
var definition;
var prefixes;
var baseName;
if (obj && obj.type === 'Unit') {
defUnit = obj.clone();
} else if (typeof obj === 'string') {
if (obj !== '') {
definition = obj;
}
} else if (typeof obj === 'object') {
definition = obj.definition;
prefixes = obj.prefixes;
offset = obj.offset;
baseName = obj.baseName;
if (obj.aliases) {
aliases = obj.aliases.valueOf(); // aliases could be a Matrix, so convert to Array
}
} else {
throw new TypeError('Cannot create unit "' + name + '" from "' + obj.toString() + '": expecting "string" or "Unit" or "Object"');
}
if (aliases) {
for (var i = 0; i < aliases.length; i++) {
if (hasOwnProperty(UNITS, aliases[i])) {
throw new Error('Cannot create alias "' + aliases[i] + '": a unit with that name already exists');
}
}
}
if (definition && typeof definition === 'string' && !defUnit) {
try {
defUnit = Unit.parse(definition, {
allowNoUnits: true
});
} catch (ex) {
ex.message = 'Could not create unit "' + name + '" from "' + definition + '": ' + ex.message;
throw ex;
}
} else if (definition && definition.type === 'Unit') {
defUnit = definition.clone();
}
aliases = aliases || [];
offset = offset || 0;
if (prefixes && prefixes.toUpperCase) {
prefixes = PREFIXES[prefixes.toUpperCase()] || PREFIXES.NONE;
} else {
prefixes = PREFIXES.NONE;
}
// If defUnit is null, it is because the user did not
// specify a defintion. So create a new base dimension.
var newUnit = {};
if (!defUnit) {
// Add a new base dimension
baseName = baseName || name + '_STUFF'; // foo --> foo_STUFF, or the essence of foo
if (BASE_DIMENSIONS.indexOf(baseName) >= 0) {
throw new Error('Cannot create new base unit "' + name + '": a base unit with that name already exists (and cannot be overridden)');
}
BASE_DIMENSIONS.push(baseName);
// Push 0 onto existing base units
for (var b in BASE_UNITS) {
if (hasOwnProperty(BASE_UNITS, b)) {
BASE_UNITS[b].dimensions[BASE_DIMENSIONS.length - 1] = 0;
}
}
// Add the new base unit
var newBaseUnit = {
dimensions: []
};
for (var _i6 = 0; _i6 < BASE_DIMENSIONS.length; _i6++) {
newBaseUnit.dimensions[_i6] = 0;
}
newBaseUnit.dimensions[BASE_DIMENSIONS.length - 1] = 1;
newBaseUnit.key = baseName;
BASE_UNITS[baseName] = newBaseUnit;
newUnit = {
name,
value: 1,
dimensions: BASE_UNITS[baseName].dimensions.slice(0),
prefixes,
offset,
base: BASE_UNITS[baseName]
};
currentUnitSystem[baseName] = {
unit: newUnit,
prefix: PREFIXES.NONE['']
};
} else {
newUnit = {
name,
value: defUnit.value,
dimensions: defUnit.dimensions.slice(0),
prefixes,
offset
};
// Create a new base if no matching base exists
var anyMatch = false;
for (var _i7 in BASE_UNITS) {
if (hasOwnProperty(BASE_UNITS, _i7)) {
var match = true;
for (var j = 0; j < BASE_DIMENSIONS.length; j++) {
if (Math.abs((newUnit.dimensions[j] || 0) - (BASE_UNITS[_i7].dimensions[j] || 0)) > 1e-12) {
match = false;
break;
}
}
if (match) {
anyMatch = true;
newUnit.base = BASE_UNITS[_i7];
break;
}
}
}
if (!anyMatch) {
baseName = baseName || name + '_STUFF'; // foo --> foo_STUFF, or the essence of foo
// Add the new base unit
var _newBaseUnit = {
dimensions: defUnit.dimensions.slice(0)
};
_newBaseUnit.key = baseName;
BASE_UNITS[baseName] = _newBaseUnit;
currentUnitSystem[baseName] = {
unit: newUnit,
prefix: PREFIXES.NONE['']
};
newUnit.base = BASE_UNITS[baseName];
}
}
Unit.UNITS[name] = newUnit;
for (var _i8 = 0; _i8 < aliases.length; _i8++) {
var aliasName = aliases[_i8];
var _alias = {};
for (var _key6 in newUnit) {
if (hasOwnProperty(newUnit, _key6)) {
_alias[_key6] = newUnit[_key6];
}
}
_alias.name = aliasName;
Unit.UNITS[aliasName] = _alias;
}
// delete the memoization cache, since adding a new unit to the array
// invalidates all old results
delete _findUnit.cache;
return new Unit(null, name);
};
Unit.deleteUnit = function (name) {
delete Unit.UNITS[name];
};
// expose arrays with prefixes, dimensions, units, systems
Unit.PREFIXES = PREFIXES;
Unit.BASE_DIMENSIONS = BASE_DIMENSIONS;
Unit.BASE_UNITS = BASE_UNITS;
Unit.UNIT_SYSTEMS = UNIT_SYSTEMS;
Unit.UNITS = UNITS;
return Unit;
}, {
isClass: true
});