@lakutata/math 0.0.0-stage → 3.1.5

package/dist/cjs/lib/Unit.js

@@ -0,0 +1,1027 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit = exports.UnitSystem = void 0;
+exports.unitFormulaOf = unitFormulaOf;
+exports.unitPartsOf = unitPartsOf;
+exports.unitOf = unitOf;
+exports.constantOf = constantOf;
+const MathArgumentException_js_1 = require("../exceptions/MathArgumentException.js");
+const MathDefinitionException_js_1 = require("../exceptions/MathDefinitionException.js");
+const MathException_js_1 = require("../exceptions/MathException.js");
+const MathSyntaxException_js_1 = require("../exceptions/MathSyntaxException.js");
+const MathUnitException_js_1 = require("../exceptions/MathUnitException.js");
+const Context_js_1 = require("./Context.js");
+const Expression_js_1 = require("./Expression.js");
+const Native_js_1 = require("./Native.js");
+const UnitTable_js_1 = require("./UnitTable.js");
+//The names of the dimensions (LUMINOUS_INTENSITY: luminousIntensity), in the order of the table
+const DIMENSION_NAMES = UnitTable_js_1.DIMENSIONS.map((name) => name.toLowerCase().replace(/_(\w)/g, (_, letter) => letter.toUpperCase()));
+//The functions of the formulas of units, the constants they know
+const FUNCTIONS = new Set(['sqrt', 'sin', 'cos', 'tan', 'exp', 'log', 'ln']);
+const NUMBERS = new Set(['pi', 'e', 'i']);
+//The sets of prefixes of the units of createMath()
+const PREFIX_SETS = { none: 'NONE', short: 'SHORT', long: 'LONG', binary: 'BINARY_SHORT' };
+const sameDimensions = (a, b) => a.every((value, index) => value === b[index]);
+const zeroDimensions = (a) => a.every((value) => value === 0);
+let internals;
+/**
+ * The units a context knows: those of the table, and those of `createMath()`. A name is a unit, or a prefix and a
+ * unit: the first unit of the table (then of `createMath()`) it ends with, of a set of prefixes having the rest. The
+ * values of the units are found when first used, exactly.
+ */
+class UnitSystem {
+    #custom = new Map();
+    #order = Object.keys(UnitTable_js_1.UNITS);
+    #resolved = new Map();
+    #resolving = new Set();
+    #prefixes = new Map();
+    #functions = new Map();
+    #factors = new Map();
+    #parsed = new Map();
+    #constants = new Map();
+    #one;
+    #templates;
+    /**
+     * The units of the table and the units of `createMath()`
+     * @param units The units of `createMath()`.
+     */
+    constructor(units = {}) {
+        if (typeof units !== 'object' || units === null || Array.isArray(units))
+            throw new MathArgumentException_js_1.MathArgumentException('The units are an object of definitions by name');
+        for (const [name, entry] of Object.entries(units)) {
+            const unit = typeof entry === 'string' ? { definition: entry } : entry;
+            if (typeof unit !== 'object' || unit === null || typeof unit.definition !== 'string')
+                throw new MathArgumentException_js_1.MathArgumentException(`The unit ${name}: its definition is a formula of units (a string), or an object of a definition`);
+            if (unit.aliases !== undefined && (!Array.isArray(unit.aliases) || unit.aliases.some((alias) => typeof alias !== 'string')))
+                throw new MathArgumentException_js_1.MathArgumentException(`The unit ${name}: its aliases are an array of names`);
+            const prefixes = PREFIX_SETS[unit.prefixes ?? 'none'];
+            if (!prefixes)
+                throw new MathArgumentException_js_1.MathArgumentException(`The unit ${name}: its prefixes are 'none', 'short', 'long' or 'binary'`);
+            for (const alias of [name, ...unit.aliases ?? []]) {
+                if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(alias))
+                    throw new MathDefinitionException_js_1.MathDefinitionException(`The unit ${alias}: a name is letters, digits and underscores, beginning with a letter`);
+                if (FUNCTIONS.has(alias) || NUMBERS.has(alias))
+                    throw new MathDefinitionException_js_1.MathDefinitionException(`The unit ${alias}: the name is used by the formulas of units`);
+                if (this.#custom.has(alias))
+                    throw new MathDefinitionException_js_1.MathDefinitionException(`The unit ${alias} is defined twice`);
+                const found = this.find(alias);
+                if (found)
+                    throw new MathDefinitionException_js_1.MathDefinitionException(`The name ${alias} is already a unit${found.prefix ? ` (${found.prefix} ${found.unit})` : ''}`);
+                this.#custom.set(alias, { definition: unit.definition, prefixes: prefixes, offset: unit.offset });
+                this.#order.push(alias);
+            }
+        }
+    }
+    /**
+     * The unit and the prefix of a name, if it is one
+     * @param name
+     */
+    find(name) {
+        if (Object.hasOwn(UnitTable_js_1.UNITS, name) || this.#custom.has(name))
+            return { unit: name, prefix: '' };
+        for (const unit of this.#order) {
+            if (name.length > unit.length && name.endsWith(unit)) {
+                const prefix = name.slice(0, name.length - unit.length);
+                if (Object.hasOwn(UnitTable_js_1.PREFIXES[this.#prefixSetOf(unit)], prefix))
+                    return { unit: unit, prefix: prefix };
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Check the units of `createMath()`: each definition found, of units known, without a cycle
+     * @param context
+     */
+    validate(context) {
+        for (const name of this.#custom.keys())
+            this.resolve(context, name);
+    }
+    /**
+     * A unit resolved: its dimensions, its value, its offset
+     * @param context
+     * @param name
+     */
+    resolve(context, name) {
+        const known = this.#resolved.get(name);
+        if (known)
+            return known;
+        const custom = this.#custom.get(name);
+        if (!custom && !Object.hasOwn(UnitTable_js_1.UNITS, name))
+            throw new MathUnitException_js_1.MathUnitException(`Unknown unit "${name}": a unit of another scope`);
+        const definition = custom ? custom.definition : UnitTable_js_1.UNITS[name].value;
+        if (this.#resolving.has(name))
+            throw new MathDefinitionException_js_1.MathDefinitionException(`The unit ${name} is defined in terms of itself`);
+        //The unit is being resolved until its value is found: the units of its definition are resolved meanwhile
+        this.#resolving.add(name);
+        try {
+            const resolved = this.#resolveDefinition(context, name, definition, custom);
+            this.#resolved.set(name, resolved);
+            return resolved;
+        }
+        catch (error) {
+            if (custom && error instanceof MathException_js_1.MathException && !(error instanceof MathDefinitionException_js_1.MathDefinitionException))
+                throw new MathDefinitionException_js_1.MathDefinitionException(`The unit ${name}: ${error.message}`);
+            throw error;
+        }
+        finally {
+            this.#resolving.delete(name);
+        }
+    }
+    /**
+     * The factor of a prefix of a unit
+     * @param context
+     * @param unit
+     * @param prefix
+     */
+    prefixFactor(context, unit, prefix) {
+        const set = this.#prefixSetOf(unit);
+        const key = `${set}:${prefix}`;
+        let factor = this.#prefixes.get(key);
+        if (!factor) {
+            factor = (0, Expression_js_1.expressionOf)(context, UnitTable_js_1.PREFIXES[set][prefix][0]);
+            this.#prefixes.set(key, factor);
+        }
+        return factor;
+    }
+    /**
+     * The number 1
+     * @param context
+     */
+    one(context) {
+        return this.#one ??= (0, Expression_js_1.expressionOf)(context, '1');
+    }
+    /**
+     * The value in SI units of a unit with its prefix, to its power
+     * @param context
+     * @param part
+     */
+    factor(context, part) {
+        const key = `${part.prefix} ${part.unit} ${part.power}`;
+        let factor = this.#factors.get(key);
+        if (!factor) {
+            factor = this.prefixFactor(context, part.unit, part.prefix).mul(this.resolve(context, part.unit).factor).pow(part.power);
+            this.#factors.set(key, factor);
+        }
+        return factor;
+    }
+    /**
+     * The units of a formula of units, as they were parsed before (at most 1000 formulas are kept)
+     * @param text
+     * @param parse
+     */
+    parsed(text, parse) {
+        let parts = this.#parsed.get(text);
+        if (!parts) {
+            parts = Object.freeze(parse().map((part) => Object.freeze({ ...part })));
+            if (this.#parsed.size >= 1000)
+                this.#parsed.clear();
+            this.#parsed.set(text, parts);
+        }
+        return parts;
+    }
+    /**
+     * The value of a physical constant, in its units
+     * @param context
+     * @param name
+     */
+    constant(context, name) {
+        let value = this.#constants.get(name);
+        if (!value) {
+            value = (0, Expression_js_1.expressionOf)(context, UnitTable_js_1.CONSTANTS[name][0]);
+            this.#constants.set(name, value);
+        }
+        return value;
+    }
+    /**
+     * The prefixes of a unit, powers of 1000 (those `toBest()` chooses)
+     * @param unit
+     */
+    scientificPrefixes(unit) {
+        return Object.entries(UnitTable_js_1.PREFIXES[this.#prefixSetOf(unit)]).filter(([, [, scientific]]) => scientific).map(([prefix]) => prefix);
+    }
+    /**
+     * A function of the formulas applied to an expression, exactly (its formula parsed without the definitions)
+     * @param context
+     * @param name
+     * @param argument
+     */
+    apply(context, name, argument) {
+        this.#templates ??= new Context_js_1.Context((0, Native_js_1.nativeCall)((native) => native.scope(null, [])), context.settings, context.tracker, this);
+        let template = this.#functions.get(name);
+        if (!template) {
+            template = (0, Expression_js_1.expressionOf)(this.#templates, `${name}(x)`);
+            this.#functions.set(name, template);
+        }
+        return new Expression_js_1.Expression(context, template.substitute({ x: argument }).handle);
+    }
+    #resolveDefinition(context, name, definition, custom) {
+        const value = unitFormulaOf(context, definition);
+        if (internals.isOffset(value))
+            throw new MathDefinitionException_js_1.MathDefinitionException(`The unit ${name}: a definition cannot be a temperature with an offset (${definition})`);
+        const dimensions = custom || !zeroDimensions(internals.dimensions(value)) ? internals.dimensions(value) : UnitTable_js_1.QUANTITIES[UnitTable_js_1.UNITS[name].quantity];
+        if (!custom && !sameDimensions(dimensions, UnitTable_js_1.QUANTITIES[UnitTable_js_1.UNITS[name].quantity]))
+            throw new MathUnitException_js_1.MathUnitException(`The unit ${name} is not of its quantity`);
+        const offset = custom ? new Expression_js_1.Expression(context, (0, Expression_js_1.handleOf)(context, custom.offset ?? 0)) : (0, Expression_js_1.expressionOf)(context, UnitTable_js_1.UNITS[name].offset);
+        return {
+            dimensions: dimensions,
+            factor: internals.siValue(value),
+            offset: offset,
+            hasOffset: offset.isZero() !== true,
+            prefixes: this.#prefixSetOf(name)
+        };
+    }
+    #prefixSetOf(unit) {
+        return this.#custom.get(unit)?.prefixes ?? UnitTable_js_1.UNITS[unit].prefixes;
+    }
+}
+exports.UnitSystem = UnitSystem;
+/**
+ * A value with units: immutable, each operation gives a new one. Its number is exact (an `Expression`), and so are
+ * the values of its units: `unit('1 inch').to('cm')` is exactly `2.54 cm`, `unit('90 deg').to('rad')` is
+ * `(pi/2) rad`. Values of dimensions that differ cannot be added or converted (`MathUnitException`). A temperature with
+ * an offset (`degC`, `degF`) is converted and compared, never added, multiplied or divided: convert it to `K` first.
+ * @example
+ * ```typescript
+ * import {constant, unit} from '@lakutata/math'
+ *
+ * console.log(unit('5 cm + 2 inch').toString())                  //10.08 cm
+ * console.log(unit('100 km/h').to('m/s').toString())             //(250/9) m / s
+ * console.log(unit('100 km/h').toNumber('m/s'))                  //27.77777777777778
+ * console.log(unit('20 degC').to('degF').toString())             //68 degF
+ * console.log(unit('5400 s').toBest(['h', 'min', 's']).toString()) //1.5 h
+ * console.log(unit('2 kg').mul(constant('speedOfLight').pow(2)).to('J').toDecimal(10)) //1.797510357e+17 J
+ * ```
+ */
+class Unit {
+    static {
+        internals = {
+            parts: (unit) => unit.parts,
+            isOffset: (unit) => unit.#isOffset(),
+            dimensions: (unit) => unit.#dimensionList(),
+            siValue: (unit) => unit.#siValue()
+        };
+    }
+    #dimensions;
+    /**
+     * A value with units. Made by `unit()`, `constant()` and by the operations.
+     * @param context The context of the formulas: its definitions, its settings, its units.
+     * @param magnitude The number, in the units.
+     * @param parts The units: each one, its prefix and its power.
+     */
+    constructor(context, magnitude, parts) {
+        this.context = context;
+        this.magnitude = magnitude;
+        this.parts = parts;
+    }
+    /**
+     * The number, in the units of the value (`5` of `5 cm`)
+     */
+    get value() {
+        //In the context of the value (its number may come from the numbers the units keep)
+        return new Expression_js_1.Expression(this.context, this.magnitude.handle);
+    }
+    /**
+     * The units, as `unit()` reads them: `cm`, `m / s^2`, `kg m^2 / (s^2 K)`; an empty string without units
+     */
+    get units() {
+        return unitsText(this.parts);
+    }
+    /**
+     * The dimensions: the power of each base quantity
+     */
+    get dimensions() {
+        const dimensions = this.#dimensionList();
+        return Object.fromEntries(DIMENSION_NAMES.map((name, index) => [name, dimensions[index]]));
+    }
+    /**
+     * Whether another value has the same dimensions (`unit('5 cm').hasDimensionsOf('inch')` is true).
+     * @param other A value with units, or a formula of units.
+     */
+    hasDimensionsOf(other) {
+        return sameDimensions(this.#dimensionList(), this.#unitOf(other).#dimensionList());
+    }
+    /**
+     * The value in other units of the same dimensions: `unit('5 cm').to('inch')`, `unit('20 degC').to('K')`.
+     * @param units The units: a formula of units without a number (`'m/s^2'`), or a value whose units are taken.
+     */
+    to(units) {
+        const parts = units instanceof _a ? units.parts : unitPartsOf(this.context, units);
+        const target = new _a(this.context, this.context.units.one(this.context), parts);
+        if (!sameDimensions(this.#dimensionList(), target.#dimensionList())) {
+            throw new MathUnitException_js_1.MathUnitException(`${this.units || 'A number'} cannot be converted to ${target.units || 'a number'}: their dimensions differ`);
+        }
+        let magnitude;
+        if (target.#isOffset()) {
+            //The number of a temperature with an offset, its prefix applied to it: 273.151 K is 1 mdegC
+            const part = parts[0], resolved = target.#resolved(part);
+            magnitude = this.#siValue().div(resolved.factor).sub(resolved.offset).div(this.context.units.prefixFactor(this.context, part.unit, part.prefix));
+        }
+        else {
+            magnitude = this.#siValue().div(target.#factor());
+        }
+        return new _a(this.context, magnitude, parts);
+    }
+    /**
+     * The value in SI units: the SI unit of its quantity when there is one (`N`, `J`, `Pa`…); otherwise each of its
+     * units in the SI unit of its quantity, or in base units (`kg`, `m`, `s`, `A`, `K`, `cd`, `mol`, `rad`, `bits`):
+     * `unit('1 BTU/(lb degF)').toSI()` is in `J / (kg K)`.
+     */
+    toSI() {
+        const dimensions = this.#dimensionList();
+        if (zeroDimensions(dimensions))
+            return new _a(this.context, this.#siValue(), []);
+        const named = (wanted) => Object.entries(UnitTable_js_1.SI).find(([quantity]) => sameDimensions(UnitTable_js_1.QUANTITIES[quantity], wanted))?.[1];
+        const whole = named(dimensions);
+        if (whole)
+            return this.to(whole);
+        let parts = [];
+        for (const part of this.parts) {
+            const own = this.#resolved(part).dimensions;
+            const si = zeroDimensions(own) ? [] : unitPartsOf(this.context, named(own) ?? baseUnitsText(own));
+            parts = mergeParts(parts, si.map((unit) => ({ ...unit, power: unit.power * part.power })));
+        }
+        return this.to(new _a(this.context, this.context.units.one(this.context), parts));
+    }
+    /**
+     * The value in the unit that reads best: the largest one in which its number is at least 1 in absolute value, the
+     * smallest one when there is none. Of the units given, or of the prefixes of its first unit that are powers of 1000
+     * (`unit('5000 m').toBest()` is `5 km`). A value of 0, a value without units and a temperature with an offset are
+     * given as they are.
+     * @param units The units to choose from (`['h', 'min', 's']`): of the dimensions of the value.
+     */
+    toBest(units) {
+        let candidates;
+        if (units !== undefined) {
+            if (!Array.isArray(units) || units.length === 0 || units.some((text) => typeof text !== 'string'))
+                throw new MathArgumentException_js_1.MathArgumentException('The units to choose from are an array of formulas of units');
+            candidates = units.map((text) => unitPartsOf(this.context, text));
+        }
+        else {
+            if (this.parts.length === 0 || this.#isOffset())
+                return this;
+            const first = this.parts[0];
+            candidates = this.context.units.scientificPrefixes(first.unit).map((prefix) => [{ ...first, prefix: prefix }, ...this.parts.slice(1)]);
+        }
+        if (this.magnitude.isZero() === true)
+            return units === undefined ? this : this.to(new _a(this.context, this.magnitude, candidates[0]));
+        const converted = candidates.map((parts) => {
+            const value = this.to(new _a(this.context, this.magnitude, parts));
+            return { value: value, factor: value.#factor() };
+        });
+        const order = (a, b) => {
+            const comparison = a.compare(b);
+            if (comparison === undefined)
+                throw new MathArgumentException_js_1.MathArgumentException('The units are not ordered: their values are not real');
+            return comparison;
+        };
+        converted.sort((a, b) => order(a.factor, b.factor));
+        const atLeastOne = (value) => {
+            const above = value.compare(1), below = value.compare(-1);
+            if (above === undefined || below === undefined)
+                throw new MathArgumentException_js_1.MathArgumentException('The best unit is chosen for a real number, without variables');
+            return above >= 0 || below <= 0;
+        };
+        for (let index = converted.length - 1; index >= 0; index--) {
+            if (atLeastOne(converted[index].value.magnitude))
+                return converted[index].value;
+        }
+        return converted[0].value;
+    }
+    /**
+     * The value split into units, from the largest: the integer part in each unit but the last, the rest in the last
+     * one (`unit('1.5 h').split(['h', 'min'])` is `1 h` and `30 min`); exact, toward 0 for a negative value.
+     * @param units The units: of the dimensions of the value.
+     */
+    split(units) {
+        if (!Array.isArray(units) || units.length === 0 || units.some((text) => typeof text !== 'string'))
+            throw new MathArgumentException_js_1.MathArgumentException('The units to split into are an array of formulas of units');
+        this.#noOffset('split');
+        const values = [];
+        let rest = this;
+        for (const [index, text] of units.entries()) {
+            const value = rest.to(text);
+            if (index === units.length - 1) {
+                values.push(value);
+                break;
+            }
+            const whole = this.context.units.apply(this.context, 'trunc', value.magnitude);
+            values.push(new _a(this.context, whole, value.parts));
+            rest = new _a(this.context, value.magnitude.sub(whole), value.parts);
+        }
+        return values;
+    }
+    /**
+     * The sum, in the units of this value.
+     * @param other A value of the same dimensions, or a formula of units.
+     */
+    add(other) {
+        return this.#sum(other, false);
+    }
+    /**
+     * The difference, in the units of this value.
+     * @param other A value of the same dimensions, or a formula of units.
+     */
+    sub(other) {
+        return this.#sum(other, true);
+    }
+    /**
+     * The product: the units multiplied (a unit of the other value is converted to the unit of the same quantity in
+     * this one: `unit('5 cm').mul('2 m')` is `1000 cm^2`); a number without dimensions when they cancel.
+     * @param other A value with units, a number, or a formula of units.
+     */
+    mul(other) {
+        return this.#product(this.#unitOf(other), 1);
+    }
+    /**
+     * The quotient: the units divided, as for `mul()` (`unit('3 m').div('2 cm')` is `150`).
+     * @param other A value with units, a number, or a formula of units.
+     */
+    div(other) {
+        return this.#product(this.#unitOf(other), -1);
+    }
+    /**
+     * The value to a power: any one without dimensions; a rational one where the powers of its dimensions stay
+     * integers (`unit('4 m^2').pow('1/2')` is `2 m`).
+     * @param exponent A number, an expression or a formula of `expression()`.
+     */
+    pow(exponent) {
+        //An integer: its power at once
+        if (typeof exponent === 'number' && Number.isInteger(exponent) && exponent !== 1 && !this.#isOffset() && !zeroDimensions(this.#dimensionList())) {
+            return new _a(this.context, this.magnitude.pow(exponent), this.parts.map((part) => ({ ...part, power: part.power * exponent })).filter((part) => part.power !== 0));
+        }
+        const power = new Expression_js_1.Expression(this.context, (0, Expression_js_1.handleOf)(this.context, exponent));
+        if (power.equals(1))
+            return this;
+        this.#noOffset('pow');
+        if (this.parts.length === 0)
+            return new _a(this.context, this.magnitude.pow(power), []);
+        //Units whose dimensions cancel (m/cm): a number
+        if (zeroDimensions(this.#dimensionList()))
+            return new _a(this.context, this.#siValue().pow(power), []);
+        if (power.isRational() !== true)
+            throw new MathUnitException_js_1.MathUnitException(`A value with units is raised to a rational number only, not to ${power.toString()}`);
+        const numerator = power.numerator().toNumber(), denominator = power.denominator().toNumber();
+        if (denominator === 1) {
+            return new _a(this.context, this.magnitude.pow(power), this.parts.map((part) => ({ ...part, power: part.power * numerator })).filter((part) => part.power !== 0));
+        }
+        //A root: in the base units, whose powers must stay integers
+        const dimensions = this.#dimensionList().map((value) => (value * numerator) / denominator);
+        if (!dimensions.every(Number.isInteger))
+            throw new MathUnitException_js_1.MathUnitException(`${this.units} to the power ${power.toString()}: its dimensions are not integers`);
+        const base = this.#toBase();
+        return new _a(this.context, base.magnitude.pow(power), base.parts.map((part) => ({ ...part, power: (part.power * numerator) / denominator })));
+    }
+    /**
+     * The square root (the powers of the dimensions even).
+     */
+    sqrt() {
+        return this.pow('1/2');
+    }
+    /**
+     * The opposite.
+     */
+    neg() {
+        return new _a(this.context, this.magnitude.neg(), this.parts);
+    }
+    /**
+     * The absolute value.
+     */
+    abs() {
+        this.#noOffset('abs');
+        return new _a(this.context, this.context.units.apply(this.context, 'abs', this.magnitude), this.parts);
+    }
+    /**
+     * Whether another value is the same quantity: the same dimensions and the same value in SI units, exactly
+     * (`unit('1 inch').equals('2.54 cm')` is true).
+     * @param other A value with units, or a formula of units.
+     */
+    equals(other) {
+        const value = this.#unitOf(other);
+        return sameDimensions(this.#dimensionList(), value.#dimensionList()) && this.#siValue().equals(value.#siValue());
+    }
+    /**
+     * The order of two values of the same dimensions: -1, 0 or 1; undefined when it is not known (values that are not
+     * real, or with variables).
+     * @param other A value of the same dimensions, or a formula of units.
+     */
+    compare(other) {
+        const value = this.#unitOf(other);
+        this.#sameDimensions(value, 'compared');
+        return this.#siValue().compare(value.#siValue());
+    }
+    /**
+     * The number as a JavaScript number: in the units of the value, or in other ones.
+     * @param units Units to convert to first.
+     */
+    toNumber(units) {
+        return (units === undefined ? this : this.to(units)).magnitude.toNumber();
+    }
+    /**
+     * The value with its number as decimals: `'0.3937007874015748031496062992126 inch'`.
+     * @param digits The significant digits: the precision of the scope by default.
+     */
+    toDecimal(digits) {
+        const decimals = this.magnitude.toDecimal(digits);
+        return this.parts.length ? `${decimals} ${this.units}` : decimals;
+    }
+    /**
+     * The value as `unit()` reads it: its number, as decimals when they are exact and short (`10.08 cm`), as its
+     * formula in parentheses otherwise (`(50/127) inch`, `(pi/2) rad`); then its units.
+     */
+    toString() {
+        const text = decimalText(this.magnitude);
+        if (!this.parts.length)
+            return text ?? this.magnitude.toString();
+        return `${text ?? `(${this.magnitude.toString()})`} ${this.units}`;
+    }
+    /**
+     * The text of `toString()`, for `JSON.stringify()`.
+     */
+    toJSON() {
+        return this.toString();
+    }
+    /**
+     * The value in LaTeX: `5\,\mathrm{cm}`, `9.8\,\frac{\mathrm{m}}{\mathrm{s}^{2}}`.
+     */
+    toTeX() {
+        const decimals = decimalText(this.magnitude);
+        const number = decimals === undefined ? this.magnitude.toTeX() : decimals.replace(/e([-+])(\d+)$/, (_, sign, digits) => `\\times 10^{${sign === '-' ? '-' : ''}${digits}}`);
+        if (!this.parts.length)
+            return number;
+        const tex = (parts, sign) => parts.map((part) => {
+            const power = part.power * sign;
+            return `\\mathrm{${part.prefix === 'u' ? '\\mu ' : part.prefix}${part.unit}}${power === 1 ? '' : `^{${power}}`}`;
+        }).join('\\,');
+        const numerator = this.parts.filter((part) => part.power > 0), denominator = this.parts.filter((part) => part.power < 0);
+        if (!numerator.length)
+            return `${number}\\,${tex(denominator, 1)}`;
+        return `${number}\\,${denominator.length ? `\\frac{${tex(numerator, 1)}}{${tex(denominator, -1)}}` : tex(numerator, 1)}`;
+    }
+    //Whether the value is a temperature with an offset: one unit with an offset (degC), to the power 1
+    #isOffset() {
+        return this.parts.length === 1 && this.parts[0].power === 1 && this.#resolved(this.parts[0]).hasOffset;
+    }
+    //The dimensions, in the order of the table
+    #dimensionList() {
+        if (!this.#dimensions) {
+            const dimensions = UnitTable_js_1.DIMENSIONS.map(() => 0);
+            for (const part of this.parts)
+                this.#resolved(part).dimensions.forEach((value, index) => {
+                    dimensions[index] += value * part.power;
+                });
+            this.#dimensions = dimensions;
+        }
+        return this.#dimensions;
+    }
+    //The value in SI units: of a temperature with an offset, its number with its prefix, plus the offset, times the
+    //value of its unit (1 mdegC is (0.001 + 273.15) K)
+    #siValue() {
+        if (this.#isOffset()) {
+            const part = this.parts[0], resolved = this.#resolved(part);
+            return this.magnitude.mul(this.context.units.prefixFactor(this.context, part.unit, part.prefix)).add(resolved.offset).mul(resolved.factor);
+        }
+        return this.parts.length ? this.magnitude.mul(this.#factor()) : this.magnitude;
+    }
+    #resolved(part) {
+        return this.context.units.resolve(this.context, part.unit);
+    }
+    //The value of the units in SI units
+    #factor() {
+        const units = this.context.units;
+        let factor;
+        for (const part of this.parts) {
+            const value = units.factor(this.context, part);
+            factor = factor ? factor.mul(value) : value;
+        }
+        return factor ?? units.one(this.context);
+    }
+    //The value in the base units of the SI
+    #toBase() {
+        return this.to(baseUnitsText(this.#dimensionList()));
+    }
+    #unitOf(value) {
+        return unitOf(this.context, value);
+    }
+    #noOffset(operation) {
+        if (this.#isOffset())
+            throw new MathUnitException_js_1.MathUnitException(`${this.units} is a temperature with an offset: ${operation}() does not take it, convert it to K first`);
+    }
+    #sameDimensions(other, operation) {
+        if (!sameDimensions(this.#dimensionList(), other.#dimensionList())) {
+            throw new MathUnitException_js_1.MathUnitException(`${this.units || 'A number'} and ${other.units || 'a number'} cannot be ${operation}: their dimensions differ`);
+        }
+    }
+    #sum(other, subtract) {
+        const value = this.#unitOf(other);
+        this.#sameDimensions(value, subtract ? 'subtracted' : 'added');
+        this.#noOffset(subtract ? 'sub' : 'add');
+        value.#noOffset(subtract ? 'sub' : 'add');
+        const converted = value.to(new _a(this.context, this.magnitude, this.parts)).magnitude;
+        return new _a(this.context, subtract ? this.magnitude.sub(converted) : this.magnitude.add(converted), this.parts);
+    }
+    #product(other, sign) {
+        this.#noOffset(sign === 1 ? 'mul' : 'div');
+        other.#noOffset(sign === 1 ? 'mul' : 'div');
+        const parts = this.parts.map((part) => ({ ...part }));
+        let magnitude = sign === 1 ? this.magnitude.mul(other.magnitude) : this.magnitude.div(other.magnitude);
+        for (const part of other.parts) {
+            const power = part.power * sign;
+            const same = parts.find((mine) => mine.unit === part.unit && mine.prefix === part.prefix);
+            if (same) {
+                same.power += power;
+                continue;
+            }
+            //A unit of a quantity of this value: converted to its unit
+            const quantity = parts.find((mine) => sameDimensions(this.#resolved(mine).dimensions, this.#resolved(part).dimensions));
+            if (quantity) {
+                const ratio = this.context.units.factor(this.context, { ...part, power: 1 }).div(this.context.units.factor(this.context, { ...quantity, power: 1 }));
+                magnitude = magnitude.mul(ratio.pow(power));
+                quantity.power += power;
+                continue;
+            }
+            parts.push({ ...part, power: power });
+        }
+        const product = new _a(this.context, magnitude, parts.filter((part) => part.power !== 0));
+        return zeroDimensions(product.#dimensionList()) && product.parts.length ? new _a(this.context, product.#siValue(), []) : product;
+    }
+}
+exports.Unit = Unit;
+_a = Unit;
+//The base units of the SI of dimensions (kg^1 m^2 s^-2)
+function baseUnitsText(dimensions) {
+    return UnitTable_js_1.DIMENSIONS.map((name, index) => (dimensions[index] ? `${UnitTable_js_1.SI[name]}^${dimensions[index]}` : '')).filter(Boolean).join(' ');
+}
+//The text of units: the numerator, then the denominator (in parentheses when it has several units)
+function unitsText(parts) {
+    const text = (part, power) => `${part.prefix}${part.unit}${power === 1 ? '' : `^${power}`}`;
+    const numerator = parts.filter((part) => part.power > 0), denominator = parts.filter((part) => part.power < 0);
+    if (!numerator.length)
+        return denominator.map((part) => text(part, part.power)).join(' ');
+    const top = numerator.map((part) => text(part, part.power)).join(' ');
+    if (!denominator.length)
+        return top;
+    const bottom = denominator.map((part) => text(part, -part.power)).join(' ');
+    return `${top} / ${denominator.length > 1 ? `(${bottom})` : bottom}`;
+}
+//The exact decimals of a rational number whose denominator divides a power of 10, of at most 30 digits: 2.54, 1.5e-19
+function decimalText(value) {
+    if (value.isRational() !== true)
+        return undefined;
+    const numerator = BigInt(value.numerator().toString()), denominator = BigInt(value.denominator().toString());
+    let rest = denominator, twos = 0, fives = 0;
+    while (rest % 2n === 0n) {
+        rest /= 2n;
+        twos++;
+    }
+    while (rest % 5n === 0n) {
+        rest /= 5n;
+        fives++;
+    }
+    if (rest !== 1n)
+        return undefined;
+    const scale = Math.max(twos, fives);
+    const scaled = numerator * (10n ** BigInt(scale) / denominator);
+    const sign = scaled < 0n ? '-' : '';
+    const digits = (scaled < 0n ? -scaled : scaled).toString();
+    if (digits === '0')
+        return '0';
+    const significant = digits.replace(/0+$/, '');
+    if (significant.length > 30)
+        return undefined;
+    //The power of 10 of the first digit
+    const exponent = digits.length - scale - 1;
+    if (exponent >= 21 || exponent <= -7)
+        return `${sign}${significant[0]}${significant.length > 1 ? `.${significant.slice(1)}` : ''}e${exponent >= 0 ? '+' : '-'}${Math.abs(exponent)}`;
+    if (scale === 0)
+        return `${sign}${digits}`;
+    const padded = digits.padStart(scale + 1, '0');
+    const fraction = padded.slice(padded.length - scale).replace(/0+$/, '');
+    return `${sign}${padded.slice(0, padded.length - scale)}${fraction ? `.${fraction}` : ''}`;
+}
+function tokensOf(text) {
+    const tokens = [];
+    const pattern = /\s+|(\d+\.?\d*(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?)|(\p{L}[\p{L}\p{N}_]*)|([-+*/^()])/uy;
+    while (pattern.lastIndex < text.length) {
+        const position = pattern.lastIndex;
+        const match = pattern.exec(text);
+        if (!match) {
+            const exception = new MathSyntaxException_js_1.MathSyntaxException(`Unexpected "${text[position]}" at ${position}: ${text}`);
+            exception.position = position;
+            throw exception;
+        }
+        if (match[1] !== undefined)
+            tokens.push({ kind: 'number', text: match[1], position: position });
+        else if (match[2] !== undefined)
+            tokens.push({ kind: 'name', text: match[2], position: position });
+        else if (match[3] !== undefined)
+            tokens.push({ kind: 'operator', text: match[3], position: position });
+    }
+    tokens.push({ kind: 'end', text: '', position: text.length });
+    return tokens;
+}
+/**
+ * The value of a formula of units: numbers (exact), units, `pi`, `e`, `i`; `+ - * / ^` and parentheses; a number
+ * followed by units is a value of them (`9.8 m/s^2`); names one after the other are multiplied (`kg m`); `sqrt`, `sin`,
+ * `cos`, `tan` (of angles or numbers), `exp`, `log` and `ln` (of numbers)
+ */
+class UnitFormula {
+    #tokens;
+    #units = new Map();
+    #index = 0;
+    constructor(context, text) {
+        this.context = context;
+        this.text = text;
+        this.#tokens = tokensOf(text);
+    }
+    /**
+     * The value of the formula, and whether it is of units only
+     */
+    parse() {
+        if (this.#peek().kind === 'end')
+            this.#fail('A formula of units is expected', this.#peek());
+        const result = this.#sum();
+        if (this.#peek().kind !== 'end')
+            this.#fail(`Unexpected "${this.#peek().text}"`, this.#peek());
+        return result;
+    }
+    #peek(offset = 0) {
+        return this.#tokens[Math.min(this.#index + offset, this.#tokens.length - 1)];
+    }
+    #next() {
+        return this.#tokens[this.#index++];
+    }
+    #is(text, offset = 0) {
+        const token = this.#peek(offset);
+        return token.kind === 'operator' && token.text === text;
+    }
+    #fail(message, token) {
+        const exception = new MathSyntaxException_js_1.MathSyntaxException(`${message} at ${token.position}: ${this.text}`);
+        exception.position = token.position;
+        throw exception;
+    }
+    #number(text) {
+        return new Unit(this.context, (0, Expression_js_1.expressionOf)(this.context, text), []);
+    }
+    #sum() {
+        let left = this.#product();
+        while (this.#is('+') || this.#is('-')) {
+            const operator = this.#next().text;
+            const right = this.#product().value;
+            left = { value: operator === '+' ? left.value.add(right) : left.value.sub(right), bare: false };
+        }
+        return left;
+    }
+    #product() {
+        let left = this.#unary();
+        for (;;) {
+            let operator;
+            if (this.#is('*') || this.#is('/'))
+                operator = this.#next().text;
+            else if (this.#startsPrimary())
+                operator = '*';
+            else
+                return left;
+            left = this.#combine(left, this.#unary(), operator);
+        }
+    }
+    //A number and units: the value of them (the offset of a temperature applied); units and units: their product;
+    //values: their arithmetic
+    #combine(left, right, operator) {
+        const invert = (parts) => parts.map((part) => ({ ...part, power: -part.power }));
+        if (right.bare && (left.bare || !internals.parts(left.value).length)) {
+            const parts = mergeParts(internals.parts(left.value), operator === '*' ? internals.parts(right.value) : invert(internals.parts(right.value)));
+            return { value: new Unit(this.context, left.value.value, parts), bare: left.bare };
+        }
+        return { value: operator === '*' ? left.value.mul(right.value) : left.value.div(right.value), bare: false };
+    }
+    #startsPrimary() {
+        const token = this.#peek();
+        return token.kind === 'number' || token.kind === 'name' || this.#is('(');
+    }
+    //An exponent: its numbers do not take units (2^3 m is 8 m)
+    #unary(exponent = false) {
+        if (this.#is('-')) {
+            this.#next();
+            return { value: this.#unary(exponent).value.neg(), bare: false };
+        }
+        if (this.#is('+')) {
+            this.#next();
+            return { value: this.#unary(exponent).value, bare: false };
+        }
+        return this.#power(exponent);
+    }
+    #power(exponent) {
+        const base = this.#primary(exponent);
+        if (!this.#is('^'))
+            return base;
+        const token = this.#next();
+        const power = this.#unary(true).value;
+        if (internals.parts(power).length)
+            this.#fail('An exponent is a number', token);
+        if (base.bare && power.value.isInteger() === true) {
+            const integer = power.value.toNumber();
+            return { value: new Unit(this.context, base.value.value, internals.parts(base.value).map((part) => ({ ...part, power: part.power * integer }))), bare: true };
+        }
+        return { value: base.value.pow(power.value), bare: false };
+    }
+    #primary(exponent) {
+        const token = this.#peek();
+        if (token.kind === 'number') {
+            this.#next();
+            const number = this.#number(token.text);
+            if (exponent || !this.#startsUnits())
+                return { value: number, bare: false };
+            return { value: new Unit(this.context, number.value, this.#unitParts()), bare: false };
+        }
+        if (token.kind === 'name') {
+            if (FUNCTIONS.has(token.text) && this.#is('(', 1)) {
+                this.#next();
+                return { value: this.#function(token, this.#parenthesized()), bare: false };
+            }
+            if (NUMBERS.has(token.text)) {
+                this.#next();
+                return { value: this.#number(token.text), bare: false };
+            }
+            return { value: new Unit(this.context, this.context.units.one(this.context), this.#unitParts()), bare: true };
+        }
+        if (this.#is('('))
+            return this.#parenthesized();
+        return this.#fail(token.kind === 'end' ? 'The formula ends too early' : `Unexpected "${token.text}"`, token);
+    }
+    #parenthesized() {
+        this.#next();
+        const value = this.#sum();
+        if (!this.#is(')'))
+            this.#fail('")" is expected', this.#peek());
+        this.#next();
+        return value;
+    }
+    #function(token, argument) {
+        const value = argument.value;
+        if (token.text === 'sqrt')
+            return value.sqrt();
+        const dimensions = value.dimensions;
+        const angle = Object.entries(dimensions).every(([name, power]) => power === (name === 'angle' ? 1 : 0));
+        const number = zeroDimensions(internals.dimensions(value));
+        if (!number && !(angle && ['sin', 'cos', 'tan'].includes(token.text))) {
+            const exception = new MathUnitException_js_1.MathUnitException(`${token.text}() takes ${['sin', 'cos', 'tan'].includes(token.text) ? 'an angle or a number' : 'a number'}, not ${value.units} at ${token.position}: ${this.text}`);
+            exception.position = token.position;
+            throw exception;
+        }
+        return new Unit(this.context, this.context.units.apply(this.context, token.text, internals.siValue(value)), []);
+    }
+    //Whether units follow: a name that is not a function or a number, or parentheses of units only (parsed, then given
+    //back; known by the position of the parenthesis once parsed)
+    #startsUnits(offset = 0) {
+        const token = this.#peek(offset);
+        if (token.kind === 'name')
+            return !NUMBERS.has(token.text) && !(FUNCTIONS.has(token.text) && this.#is('(', offset + 1));
+        if (!this.#is('(', offset))
+            return false;
+        const index = this.#index;
+        const start = index + offset;
+        let units = this.#units.get(start);
+        if (units === undefined) {
+            this.#index = start;
+            try {
+                this.#unitFactor();
+                units = true;
+            }
+            catch {
+                units = false;
+            }
+            finally {
+                this.#index = index;
+            }
+            this.#units.set(start, units);
+        }
+        return units;
+    }
+    //Units: names, powers, products and quotients of them
+    #unitParts() {
+        let parts = this.#unitFactor();
+        for (;;) {
+            if ((this.#is('*') || this.#is('/')) && this.#startsUnits(1)) {
+                const operator = this.#next().text;
+                const factor = this.#unitFactor();
+                parts = mergeParts(parts, operator === '*' ? factor : factor.map((part) => ({ ...part, power: -part.power })));
+            }
+            else if (this.#startsUnits()) {
+                parts = mergeParts(parts, this.#unitFactor());
+            }
+            else {
+                return parts;
+            }
+        }
+    }
+    #unitFactor() {
+        const token = this.#peek();
+        let parts;
+        if (this.#is('(')) {
+            this.#next();
+            parts = this.#unitParts();
+            if (!this.#is(')'))
+                this.#fail('")" is expected', this.#peek());
+            this.#next();
+        }
+        else {
+            if (token.kind !== 'name')
+                this.#fail('A unit is expected', token);
+            this.#next();
+            const found = this.context.units.find(token.text);
+            if (!found) {
+                const exception = new MathUnitException_js_1.MathUnitException(`Unknown unit "${token.text}" at ${token.position}: ${this.text}`);
+                exception.position = token.position;
+                throw exception;
+            }
+            parts = [{ unit: found.unit, prefix: found.prefix, power: 1 }];
+        }
+        if (this.#is('^')) {
+            this.#next();
+            const parenthesized = this.#is('(');
+            if (parenthesized)
+                this.#next();
+            let sign = 1;
+            if (this.#is('-') || this.#is('+'))
+                sign = this.#next().text === '-' ? -1 : 1;
+            const exponent = this.#next();
+            const power = sign * Number(exponent.text);
+            if (exponent.kind !== 'number' || !Number.isInteger(power))
+                this.#fail('The power of a unit is an integer', exponent);
+            if (parenthesized) {
+                if (!this.#is(')'))
+                    this.#fail('")" is expected', this.#peek());
+                this.#next();
+            }
+            parts = parts.map((part) => ({ ...part, power: part.power * power }));
+        }
+        return parts;
+    }
+}
+//The product of units: the powers of the same unit and prefix added, the units of power 0 removed
+function mergeParts(left, right) {
+    const parts = left.map((part) => ({ ...part }));
+    for (const part of right) {
+        const same = parts.find((mine) => mine.unit === part.unit && mine.prefix === part.prefix);
+        if (same)
+            same.power += part.power;
+        else
+            parts.push({ ...part });
+    }
+    return parts.filter((part) => part.power !== 0);
+}
+/**
+ * The value of a formula of units
+ * @param context
+ * @param text
+ */
+function unitFormulaOf(context, text) {
+    if (typeof text !== 'string')
+        throw new MathArgumentException_js_1.MathArgumentException('A formula of units is a string');
+    return new UnitFormula(context, text).parse().value;
+}
+/**
+ * The units of a formula of units without a number, or of the number 1 (`'m/s^2'`, `'1/s'`)
+ * @param context
+ * @param text
+ */
+function unitPartsOf(context, text) {
+    if (typeof text !== 'string')
+        throw new MathArgumentException_js_1.MathArgumentException('Units are a formula of units (a string) or a value with units');
+    return context.units.parsed(text, () => {
+        const { value, bare } = new UnitFormula(context, text).parse();
+        if (!bare && (!internals.parts(value).length || !value.value.equals(1)))
+            throw new MathArgumentException_js_1.MathArgumentException(`Units are expected, without a number: ${text}`);
+        return internals.parts(value);
+    });
+}
+/**
+ * A value with units in a context: a formula of units, a value and its units, a number without units
+ * @param context
+ * @param value
+ * @param units
+ */
+function unitOf(context, value, units) {
+    if (units !== undefined) {
+        if (value instanceof Unit)
+            throw new MathArgumentException_js_1.MathArgumentException('The units are given with a number, not with a value with units');
+        return new Unit(context, new Expression_js_1.Expression(context, (0, Expression_js_1.handleOf)(context, value)), unitPartsOf(context, units));
+    }
+    if (value instanceof Unit)
+        return value;
+    if (typeof value === 'string')
+        return unitFormulaOf(context, value);
+    return new Unit(context, new Expression_js_1.Expression(context, (0, Expression_js_1.handleOf)(context, value)), []);
+}
+/**
+ * A physical constant with its units, in a context
+ * @param context
+ * @param name
+ */
+function constantOf(context, name) {
+    if (typeof name !== 'string' || !Object.hasOwn(UnitTable_js_1.CONSTANTS, name))
+        throw new MathArgumentException_js_1.MathArgumentException(`Not a physical constant: ${String(name)}`);
+    const units = UnitTable_js_1.CONSTANTS[name][1];
+    return new Unit(context, context.units.constant(context, name), units ? unitPartsOf(context, units) : []);
+}