uom-types 3.1.0 → 4.0.0

package/dist/{units-converters.cjs → index.cjs}

@@ -1,170 +1,419 @@
 'use strict';
 
-var functions = require('./functions.cjs');
+function add(...args) {
+    return args.length === 1 ? (a) => a + args[0] : args[0] + args[1];
+}
+function sub(...args) {
+    return args.length === 1 ? (a) => a - args[0] : args[0] - args[1];
+}
+function mul(...args) {
+    return args.length === 1 ? (a) => a * args[0] : args[0] * args[1];
+}
+function div(...args) {
+    return args.length === 1 ? (a) => a / args[0] : args[0] / args[1];
+}
+function mod(...args) {
+    return args.length === 1 ? (a) => a % args[0] : args[0] % args[1];
+}
+function modSafe(...args) {
+    return args.length === 1
+        ? (a) => ((a % args[0]) + args[0]) % args[0]
+        : ((args[0] % args[1]) + args[1]) % args[1];
+}
+function pow(...args) {
+    return args.length === 1 ? (b) => b ** args[0] : args[0] ** args[1];
+}
+function root(...args) {
+    return args.length === 1 ? (b) => b ** (1 / args[0]) : args[0] ** (1 / args[1]);
+}
+/**
+ * Take the square root of the given value.
+ *
+ * @category Math
+ * @returns `value ** (1/2)`
+ */
+function sqrt(value) {
+    return root(value, 2);
+}
+/**
+ * Inverse the given value.
+ *
+ * @category Math
+ * @returns `value ** -1`
+ */
+function inverse(value) {
+    return pow(value, -1);
+}
+/**
+ * Returns the negative of the given value.
+ *
+ * @category Math
+ * @returns `-value`
+ */
+function negate(value) {
+    return -value;
+}
+/**
+ * Returns the absolute value of the given value.
+ *
+ * @category Math
+ * @returns `Math.abs(value)`
+ */
+function abs(value) {
+    return Math.abs(value);
+}
+/**
+ * Returns the greatest integer less than or equal to the given value.
+ *
+ * @category Math
+ * @returns `Math.floor(value)`
+ */
+function floor(value) {
+    return Math.floor(value);
+}
+/**
+ * Returns the smallest integer greater than or equal the given value.
+ *
+ * @category Math
+ * @returns `Math.ceil(value)`
+ */
+function ceil(value) {
+    return Math.ceil(value);
+}
+/**
+ * Returns the given value rounded to the nearest integer.
+ *
+ * @category Math
+ * @returns `Math.round(value)`
+ */
+function round(value) {
+    return Math.round(value);
+}
+/**
+ * Returns the larger value in the given collection.
+ *
+ * @category Math
+ * @returns `Math.max(values)`
+ */
+function max(values) {
+    return Math.max(...values);
+}
+/**
+ * Returns the smallest value in the given collection.
+ *
+ * @category Math
+ * @returns `Math.min(values)`
+ */
+function min(values) {
+    return Math.min(...values);
+}
+/**
+ * Takes the sum of all the values in the given collection.
+ *
+ * @category Math
+ * @returns `Math.sum(values)`
+ */
+function sum(values) {
+    return [...values].reduce(add, 0);
+}
+function eq(...args) {
+    return args.length === 1 ? (a) => a === args[0] : args[0] === args[1];
+}
+function gt(...args) {
+    return args.length === 1 ? (a) => a > args[0] : args[0] > args[1];
+}
+function gte(...args) {
+    return args.length === 1 ? (a) => a >= args[0] : args[0] >= args[1];
+}
+function lt(...args) {
+    return args.length === 1 ? (a) => a < args[0] : args[0] < args[1];
+}
+function lte(...args) {
+    return args.length === 1 ? (a) => a <= args[0] : args[0] <= args[1];
+}
+/**
+ * Returns the sine of a number.
+ *
+ * @category Math
+ * @returns `Math.sin(angle)`
+ */
+function sin(angle) {
+    return Math.sin(angle);
+}
+/**
+ * Returns the cosine of a number.
+ *
+ * @category Math
+ * @returns `Math.cos(angle)`
+ */
+function cos(angle) {
+    return Math.cos(angle);
+}
+/**
+ * Returns the tangent of a number.
+ *
+ * @category Math
+ * @returns `Math.tan(angle)`
+ */
+function tan(angle) {
+    return Math.tan(angle);
+}
+/**
+ * Returns the arcsine of a number.
+ *
+ * @category Math
+ * @returns `Math.asin(value)`
+ */
+function asin(value) {
+    return Math.asin(value);
+}
+/**
+ * Returns the arc cosine (or inverse cosine) of a number.
+ *
+ * @category Math
+ * @returns `Math.acos(value)`
+ */
+function acos(value) {
+    return Math.acos(value);
+}
+/**
+ * Returns the arctangent of a number.
+ *
+ * @category Math
+ * @returns `Math.atan(value)`
+ */
+function atan(value) {
+    return Math.atan(value);
+}
+/**
+ * Returns the angle (in radians) from the X axis to a point.
+ *
+ * @category Math
+ * @param x - A number representing the cartesian x-coordinate.
+ * @param y - A number representing the cartesian y-coordinate.
+ * @returns `Math.atan2(x, y)`
+ */
+function atan2(x, y) {
+    return Math.atan2(x, y);
+}
+/**
+ * Returns the hyperbolic sine of a number.
+ *
+ * @category Math
+ * @returns `Math.sinh(angle)`
+ */
+function sinh(angle) {
+    return Math.sinh(angle);
+}
+/**
+ * Returns the hyperbolic cosine of a number.
+ *
+ * @category Math
+ * @returns `Math.cosh(angle)`
+ */
+function cosh(angle) {
+    return Math.cosh(angle);
+}
+/**
+ * Returns the hyperbolic tangent of a number.
+ *
+ * @category Math
+ * @returns `Math.tanh(angle)`
+ */
+function tanh(angle) {
+    return Math.tanh(angle);
+}
+/**
+ * Returns the inverse hyperbolic sine of a number.
+ *
+ * @category Math
+ * @returns `Math.asinh(value)`
+ */
+function asinh(value) {
+    return Math.asinh(value);
+}
+/**
+ * Returns the inverse hyperbolic cosine of a number.
+ *
+ * @category Math
+ * @returns `Math.acosh(value)`
+ */
+function acosh(value) {
+    return Math.acosh(value);
+}
+/**
+ * Returns the inverse hyperbolic tangent of a number.
+ *
+ * @category Math
+ * @returns `Math.atanh(value)`
+ */
+function atanh(value) {
+    return Math.atanh(value);
+}
 
 /**
  * Convert {@link Radian} to {@link Degree}.
  */
 function radiansToDegrees(angle) {
-    return functions.mul(angle, (180 / Math.PI));
+    return mul(angle, (180 / Math.PI));
 }
 /**
  * Convert {@link Radian} to {@link Gradian}.
  */
 function radiansToGradians(angle) {
-    return functions.mul(angle, (200 / Math.PI));
+    return mul(angle, (200 / Math.PI));
 }
 /**
  * Convert {@link Radian} to {@link Turn}.
  */
 function radiansToTurns(angle) {
-    return functions.div(angle, Math.PI);
+    return div(angle, Math.PI);
 }
 /**
  * Convert {@link Degree} to {@link Radian}.
  */
 function degreesToRadians(angle) {
-    return functions.mul(angle, (Math.PI / 180));
+    return mul(angle, (Math.PI / 180));
 }
 /**
  * Convert {@link Degree} to {@link Gradian}.
  */
 function degreesToGradians(angle) {
-    return functions.mul(angle, (10 / 9));
+    return mul(angle, (10 / 9));
 }
 /**
  * Convert {@link Degree} to {@link Turn}.
  */
 function degreesToTurns(angle) {
-    return functions.div(angle, 360);
+    return div(angle, 360);
 }
 /**
  * Convert {@link Gradian} to {@link Radian}.
  */
 function gradiansToRadians(angle) {
-    return functions.mul(angle, (Math.PI / 400));
+    return mul(angle, (Math.PI / 400));
 }
 /**
  * Convert {@link Gradian} to {@link Degree}.
  */
 function gradiansToDegrees(angle) {
-    return functions.mul(angle, (9 / 10));
+    return mul(angle, (9 / 10));
 }
 /**
  * Convert {@link Gradian} to {@link Turn}.
  */
 function gradiansToTurns(angle) {
-    return functions.div(angle, 400);
+    return div(angle, 400);
 }
 /**
  * Convert {@link Turn} to {@link Radian}.
  */
 function turnsToRadians(angle) {
-    return functions.mul(angle, (2 * Math.PI));
+    return mul(angle, (2 * Math.PI));
 }
 /**
  * Convert {@link Turn} to {@link Degree}.
  */
 function turnsToDegrees(angle) {
-    return functions.mul(angle, 360);
+    return mul(angle, 360);
 }
 /**
  * Convert {@link Turn} to {@link Gradian}.
  */
 function turnsToGradians(angle) {
-    return functions.mul(angle, 400);
+    return mul(angle, 400);
 }
 
 /**
- * Convert {@link Square}<{@link Metre}> to {@link Are}.
+ * Convert {@link Square}<{@link Meter}> to {@link Are}.
  */
-function squareMetresToAres(area) {
-    return functions.div(area, 100);
+function squareMetersToAres(area) {
+    return div(area, 100);
 }
 /**
- * Convert {@link Square}<{@link Metre}> to {@link Hectare}.
+ * Convert {@link Square}<{@link Meter}> to {@link Hectare}.
  */
-function squareMetresToHectares(area) {
-    return functions.div(area, 10_000);
+function squareMetersToHectares(area) {
+    return div(area, 10_000);
 }
 /**
- * Convert {@link Are} to {@link Square}<{@link Metre}>.
+ * Convert {@link Are} to {@link Square}<{@link Meter}>.
  */
-function aresToSquareMetres(area) {
-    return functions.mul(area, 100);
+function aresToSquareMeters(area) {
+    return mul(area, 100);
 }
 /**
  * Convert {@link Are} to {@link Hectare}.
  */
 function aresToHectares(area) {
-    return functions.div(area, 100);
+    return div(area, 100);
 }
 /**
- * Convert {@link Hectare} to {@link Square}<{@link Metre}>.
+ * Convert {@link Hectare} to {@link Square}<{@link Meter}>.
  */
-function hectaresToSquareMetres(area) {
-    return functions.mul(area, 10_000);
+function hectaresToSquareMeters(area) {
+    return mul(area, 10_000);
 }
 /**
  * Convert {@link Hectare} to {@link Are}.
  */
 function hectaresToAres(area) {
-    return functions.mul(area, 100);
+    return mul(area, 100);
 }
 
 /**
  * Convert {@link Second} to {@link Minute}.
  */
 function secondsToMinutes(duration) {
-    return functions.div(duration, 60);
+    return div(duration, 60);
 }
 /**
  * Convert {@link Second} to {@link Hour}.
  */
 function secondsToHours(duration) {
-    return functions.div(duration, 3600);
+    return div(duration, 3600);
 }
 /**
  * Convert {@link Minute} to {@link Second}.
  */
 function minutesToSeconds(duration) {
-    return functions.mul(duration, 60);
+    return mul(duration, 60);
 }
 /**
  * Convert {@link Minute} to {@link Hour}.
  */
 function minutesToHours(duration) {
-    return functions.div(duration, 60);
+    return div(duration, 60);
 }
 /**
  * Convert {@link Hour} to {@link Second}.
  */
 function hoursToSeconds(duration) {
-    return functions.mul(duration, 3600);
+    return mul(duration, 3600);
 }
 /**
  * Convert {@link Hour} to {@link Minute}.
  */
 function hoursToMinutes(duration) {
-    return functions.mul(duration, 60);
+    return mul(duration, 60);
 }
 /**
  * Convert {@link Hour} to {@link Day}.
  */
 function hoursToDays(duration) {
-    return functions.div(duration, 24);
+    return div(duration, 24);
 }
 /**
  * Convert {@link Day} to {@link Hour}.
  */
 function daysToHours(duration) {
-    return functions.mul(duration, 24);
+    return mul(duration, 24);
 }
 /**
  * Convert {@link Day} to {@link Week}.
  */
 function daysToWeeks(duration) {
-    return functions.div(duration, 7);
+    return div(duration, 7);
 }
 /**
  * Convert {@link Day} to {@link Year}.
@@ -173,13 +422,13 @@ function daysToWeeks(duration) {
  * Use an actual date/time library if you need more control.
  */
 function daysToYears(duration) {
-    return functions.div(duration, 365.25);
+    return div(duration, 365.25);
 }
 /**
  * Convert {@link Week} to {@link Day}.
  */
 function weeksToDays(duration) {
-    return functions.mul(duration, 7);
+    return mul(duration, 7);
 }
 /**
  * Convert {@link Week} to {@link Year}.
@@ -194,7 +443,7 @@ function weeksToYears(duration) {
  * Use an actual date/time library if you need more control.
  */
 function yearsToDays(duration) {
-    return functions.mul(duration, 365.25);
+    return mul(duration, 365.25);
 }
 /**
  * Convert {@link Year} to {@link Week}.
@@ -207,80 +456,80 @@ function yearsToWeeks(duration) {
  * Convert {@link Joule} to {@link WattMinute}.
  */
 function joulesToWattMinutes(energy) {
-    return functions.div(energy, 60);
+    return div(energy, 60);
 }
 /**
  * Convert {@link Joule} to {@link WattHour}.
  */
 function joulesToWattHours(energy) {
-    return functions.div(energy, 3600);
+    return div(energy, 3600);
 }
 /**
  * Convert {@link WattMinute} to {@link Joule}.
  */
 function wattMinutesToJoules(energy) {
-    return functions.mul(energy, 60);
+    return mul(energy, 60);
 }
 /**
  * Convert {@link WattHour} to {@link Joule}.
  */
 function wattHoursToJoules(energy) {
-    return functions.mul(energy, 3600);
+    return mul(energy, 3600);
 }
 
 /**
  * Convert {@link Hertz} to {@link PerMinute}.
  */
 function hertzToPerMinute(frequency) {
-    return functions.mul(frequency, 60);
+    return mul(frequency, 60);
 }
 /**
  * Convert {@link Hertz} to {@link PerHour}.
  */
 function hertzToPerHour(frequency) {
-    return functions.mul(frequency, 3600);
+    return mul(frequency, 3600);
 }
 /**
  * Convert {@link PerMinute} to {@link Hertz}.
  */
 function perMinuteToHertz(frequency) {
-    return functions.div(frequency, 60);
+    return div(frequency, 60);
 }
 /**
  * Convert {@link PerMinute} to {@link PerHour}.
  */
 function perMinuteToPerHour(frequency) {
-    return functions.mul(frequency, 60);
+    return mul(frequency, 60);
 }
 /**
  * Convert {@link PerHour} to {@link Hertz}.
  */
 function perHourToHertz(frequency) {
-    return functions.div(frequency, 3600);
+    return div(frequency, 3600);
 }
 /**
  * Convert {@link PerHour} to {@link PerMinute}.
  */
 function perHourToPerMinute(frequency) {
-    return functions.div(frequency, 60);
+    return div(frequency, 60);
 }
 /**
  * Convert {@link PerHour} to {@link PerDay}.
  */
 function perHourToPerDay(frequency) {
-    return functions.mul(frequency, 24);
+    return mul(frequency, 24);
 }
 /**
  * Convert {@link PerDay} to {@link PerHour}.
  */
 function perDayToPerHour(frequency) {
-    return functions.div(frequency, 24);
+    return div(frequency, 24);
 }
 /**
  * Convert {@link PerDay} to {@link PerWeek}.
  */
 function perDayToPerWeek(frequency) {
-    return functions.mul(frequency, 7);
+    return mul(frequency, 7);
 }
 /**
  * Convert {@link PerDay} to {@link PerYear}.
@@ -289,13 +538,13 @@ function perDayToPerWeek(frequency) {
  * Use an actual date/time library if you need more control.
  */
 function perDayToPerYear(frequency) {
-    return functions.mul(frequency, 365.25);
+    return mul(frequency, 365.25);
 }
 /**
  * Convert {@link PerWeek} to {@link PerDay}.
  */
 function perWeekToPerDay(frequency) {
-    return functions.div(frequency, 7);
+    return div(frequency, 7);
 }
 /**
  * Convert {@link PerWeek} to {@link PerYear}.
@@ -310,7 +559,7 @@ function perWeekToPerYear(frequency) {
  * Use an actual date/time library if you need more control.
  */
 function perYearToPerDay(frequency) {
-    return functions.div(frequency, 365.25);
+    return div(frequency, 365.25);
 }
 /**
  * Convert {@link PerYear} to {@link PerWeek}.
@@ -323,13 +572,13 @@ function perYearToPerWeek(frequency) {
  * Convert {@link Gram} to {@link Tonne}.
  */
 function gramsToTonnes(mass) {
-    return functions.div(mass, 1_000_000);
+    return div(mass, 1_000_000);
 }
 /**
  * Convert {@link Tonne} to {@link Gram}.
  */
 function tonnesToGrams(mass) {
-    return functions.mul(mass, 1_000_000);
+    return mul(mass, 1_000_000);
 }
 
 /**
@@ -339,7 +588,7 @@ function tonnesToGrams(mass) {
  * Convert `X` to `dekaX`.
  */
 function toDeka(value) {
-    return functions.mul(value, 10);
+    return mul(value, 10);
 }
 /**
  * Convert `dekaX` to `X`.
@@ -349,7 +598,7 @@ const fromDeka = toDeci;
  * Convert `X` to `deciX`.
  */
 function toDeci(value) {
-    return functions.div(value, 10);
+    return div(value, 10);
 }
 /**
  * Convert `deciX` to `X`.
@@ -359,7 +608,7 @@ const fromDeci = toDeka;
  * Convert `X` to `hectoX`.
  */
 function toHecto(value) {
-    return functions.mul(value, 100);
+    return mul(value, 100);
 }
 /**
  * Convert `hectoX` to `X`.
@@ -369,7 +618,7 @@ const fromHecto = toCenti;
  * Convert `X` to `centiX`.
  */
 function toCenti(value) {
-    return functions.div(value, 100);
+    return div(value, 100);
 }
 /**
  * Convert `centiX` to `X`.
@@ -379,7 +628,7 @@ const fromCenti = toHecto;
  * Convert `X` to `kiloX`.
  */
 function toKilo(value) {
-    return functions.mul(value, 1000);
+    return mul(value, 1000);
 }
 /**
  * Convert `kiloX` to `X`.
@@ -389,7 +638,7 @@ const fromKilo = toMilli;
  * Convert `X` to `milliX`.
  */
 function toMilli(value) {
-    return functions.div(value, 1000);
+    return div(value, 1000);
 }
 /**
  * Convert `milliX` to `X`.
@@ -399,7 +648,7 @@ const fromMilli = toKilo;
  * Convert `X` to `megaX`.
  */
 function toMega(value) {
-    return functions.mul(value, 1000000);
+    return mul(value, 1000000);
 }
 /**
  * Convert `megaX` to `X`.
@@ -409,7 +658,7 @@ const fromMega = toMicro;
  * Convert `X` to `microX`.
  */
 function toMicro(value) {
-    return functions.div(value, 1000000);
+    return div(value, 1000000);
 }
 /**
  * Convert `microX` to `X`.
@@ -419,7 +668,7 @@ const fromMicro = toMega;
  * Convert `X` to `gigaX`.
  */
 function toGiga(value) {
-    return functions.mul(value, 1000000000);
+    return mul(value, 1000000000);
 }
 /**
  * Convert `gigaX` to `X`.
@@ -429,7 +678,7 @@ const fromGiga = toNano;
  * Convert `X` to `nanoX`.
  */
 function toNano(value) {
-    return functions.div(value, 1000000000);
+    return div(value, 1000000000);
 }
 /**
  * Convert `nanoX` to `X`.
@@ -439,7 +688,7 @@ const fromNano = toGiga;
  * Convert `X` to `teraX`.
  */
 function toTera(value) {
-    return functions.mul(value, 1000000000000);
+    return mul(value, 1000000000000);
 }
 /**
  * Convert `teraX` to `X`.
@@ -449,7 +698,7 @@ const fromTera = toPico;
  * Convert `X` to `picoX`.
  */
 function toPico(value) {
-    return functions.div(value, 1000000000000);
+    return div(value, 1000000000000);
 }
 /**
  * Convert `picoX` to `X`.
@@ -470,28 +719,43 @@ function kelvinToCelsius(temperature) {
 }
 
 /**
- * Convert {@link Cubic}<{@link Metre}> to {@link Litre}.
+ * Convert {@link Cubic}<{@link Meter}> to {@link Liter}.
  */
-function cubicMetresToLitres(volume) {
-    return functions.mul(volume, 1000);
+function cubicMetersToLiters(volume) {
+    return mul(volume, 1000);
 }
 /**
- * Convert {@link Litre} to {@link Cubic}<{@link Metre}>.
+ * Convert {@link Liter} to {@link Cubic}<{@link Meter}>.
  */
-function litresToCubicMetres(volume) {
-    return functions.div(volume, 1000);
+function litersToCubicMeters(volume) {
+    return div(volume, 1000);
 }
 
+exports.abs = abs;
+exports.acos = acos;
+exports.acosh = acosh;
+exports.add = add;
 exports.aresToHectares = aresToHectares;
-exports.aresToSquareMetres = aresToSquareMetres;
+exports.aresToSquareMeters = aresToSquareMeters;
+exports.asin = asin;
+exports.asinh = asinh;
+exports.atan = atan;
+exports.atan2 = atan2;
+exports.atanh = atanh;
+exports.ceil = ceil;
 exports.celsiusToKelvin = celsiusToKelvin;
-exports.cubicMetresToLitres = cubicMetresToLitres;
+exports.cos = cos;
+exports.cosh = cosh;
+exports.cubicMetersToLiters = cubicMetersToLiters;
 exports.daysToHours = daysToHours;
 exports.daysToWeeks = daysToWeeks;
 exports.daysToYears = daysToYears;
 exports.degreesToGradians = degreesToGradians;
 exports.degreesToRadians = degreesToRadians;
 exports.degreesToTurns = degreesToTurns;
+exports.div = div;
+exports.eq = eq;
+exports.floor = floor;
 exports.fromCenti = fromCenti;
 exports.fromDeci = fromDeci;
 exports.fromDeka = fromDeka;
@@ -508,19 +772,30 @@ exports.gradiansToDegrees = gradiansToDegrees;
 exports.gradiansToRadians = gradiansToRadians;
 exports.gradiansToTurns = gradiansToTurns;
 exports.gramsToTonnes = gramsToTonnes;
+exports.gt = gt;
+exports.gte = gte;
 exports.hectaresToAres = hectaresToAres;
-exports.hectaresToSquareMetres = hectaresToSquareMetres;
+exports.hectaresToSquareMeters = hectaresToSquareMeters;
 exports.hertzToPerHour = hertzToPerHour;
 exports.hertzToPerMinute = hertzToPerMinute;
 exports.hoursToDays = hoursToDays;
 exports.hoursToMinutes = hoursToMinutes;
 exports.hoursToSeconds = hoursToSeconds;
+exports.inverse = inverse;
 exports.joulesToWattHours = joulesToWattHours;
 exports.joulesToWattMinutes = joulesToWattMinutes;
 exports.kelvinToCelsius = kelvinToCelsius;
-exports.litresToCubicMetres = litresToCubicMetres;
+exports.litersToCubicMeters = litersToCubicMeters;
+exports.lt = lt;
+exports.lte = lte;
+exports.max = max;
+exports.min = min;
 exports.minutesToHours = minutesToHours;
 exports.minutesToSeconds = minutesToSeconds;
+exports.mod = mod;
+exports.modSafe = modSafe;
+exports.mul = mul;
+exports.negate = negate;
 exports.perDayToPerHour = perDayToPerHour;
 exports.perDayToPerWeek = perDayToPerWeek;
 exports.perDayToPerYear = perDayToPerYear;
@@ -533,13 +808,23 @@ exports.perWeekToPerDay = perWeekToPerDay;
 exports.perWeekToPerYear = perWeekToPerYear;
 exports.perYearToPerDay = perYearToPerDay;
 exports.perYearToPerWeek = perYearToPerWeek;
+exports.pow = pow;
 exports.radiansToDegrees = radiansToDegrees;
 exports.radiansToGradians = radiansToGradians;
 exports.radiansToTurns = radiansToTurns;
+exports.root = root;
+exports.round = round;
 exports.secondsToHours = secondsToHours;
 exports.secondsToMinutes = secondsToMinutes;
-exports.squareMetresToAres = squareMetresToAres;
-exports.squareMetresToHectares = squareMetresToHectares;
+exports.sin = sin;
+exports.sinh = sinh;
+exports.sqrt = sqrt;
+exports.squareMetersToAres = squareMetersToAres;
+exports.squareMetersToHectares = squareMetersToHectares;
+exports.sub = sub;
+exports.sum = sum;
+exports.tan = tan;
+exports.tanh = tanh;
 exports.toCenti = toCenti;
 exports.toDeci = toDeci;
 exports.toDeka = toDeka;