@danielsimonjr/mathts-functions 0.42.0 → 0.43.1

package/dist/wasm/integrity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrity.d.ts","sourceRoot":"","sources":["../../src/wasm/integrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,MAAM,WAAW,YAAY;IAC3B,kDAAkD;IAClD,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBtF;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAmBrF;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,WAAW,GAAG,UAAU,EAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACnE,OAAO,CAAC,IAAI,CAAC,CAmCf"}
+{"version":3,"file":"integrity.d.ts","sourceRoot":"","sources":["../../src/wasm/integrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,YAAY,EAAE,YAAY,EAAE,CAAC;AAI7B;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBtF;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAmBrF;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,WAAW,GAAG,UAAU,EAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACnE,OAAO,CAAC,IAAI,CAAC,CAmCf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.42.0",
+  "version": "0.43.1",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -34,11 +34,11 @@
     "build:prod": "tsup src/index.ts --format esm --clean --minify --treeshake"
   },
   "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.10.0",
-    "@danielsimonjr/mathts-expression": "^0.6.4",
+    "@danielsimonjr/mathts-core": "^0.12.0",
+    "@danielsimonjr/mathts-expression": "^0.6.6",
     "@danielsimonjr/mathts-gpu": "^0.2.0",
-    "@danielsimonjr/mathts-matrix": "^0.6.0",
-    "@danielsimonjr/mathts-parallel": "^0.6.0",
+    "@danielsimonjr/mathts-matrix": "^0.6.2",
+    "@danielsimonjr/mathts-parallel": "^0.6.2",
     "bignumber.js": "^9.1.2",
     "complex.js": "^2.2.5",
     "decimal.js": "^10.4.3",

package/dist/error/MathjsError.d.ts

@@ -1,13 +0,0 @@
-/**
- * Custom error type for Mathjs errors
- * @extends Error
- */
-export declare class MathjsError extends Error {
-    isMathjsError: true;
-    /**
-     * Create a MathjsError
-     * @param message  Error message
-     */
-    constructor(message: string);
-}
-//# sourceMappingURL=MathjsError.d.ts.map

package/dist/error/MathjsError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MathjsError.d.ts","sourceRoot":"","sources":["../../src/error/MathjsError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,aAAa,EAAG,IAAI,CAAU;IAE9B;;;OAGG;gBACS,OAAO,EAAE,MAAM;CAY5B"}

package/dist/utils/bignumber/formatter.d.ts

@@ -1,136 +0,0 @@
-/**
- * Structural contract for the BigNumber values handled by this formatter.
- * Captures exactly the methods/properties used here. The configured BigNumber
- * implementation (e.g. decimal.js) provides these; the project's `BigNumber`
- * type alias points at a minimal local Decimal that does not declare them all,
- * so we model the runtime contract explicitly.
- */
-interface BigNumberValue {
-    e: number;
-    constructor: new (value: number | string) => BigNumberValue;
-    isFinite(): boolean;
-    isNaN(): boolean;
-    isZero(): boolean;
-    isInteger(): boolean;
-    gt(other: number | BigNumberValue): boolean;
-    greaterThan(other: number | BigNumberValue): boolean;
-    lessThan(other: number | BigNumberValue): boolean;
-    add(other: number | BigNumberValue): BigNumberValue;
-    sub(other: number | BigNumberValue): BigNumberValue;
-    mul(other: number | BigNumberValue): BigNumberValue;
-    pow(exp: number | BigNumberValue): BigNumberValue;
-    toNumber(): number;
-    toFixed(places?: number): string;
-    toExponential(places?: number): string;
-    toPrecision(sd?: number): string;
-    toSignificantDigits(sd?: number): BigNumberValue;
-    toBinary(): string;
-    toOctal(): string;
-    toHexadecimal(): string;
-}
-/**
- * Convert a BigNumber to a formatted string representation.
- *
- * Syntax:
- *
- *    format(value)
- *    format(value, options)
- *    format(value, precision)
- *    format(value, fn)
- *
- * Where:
- *
- *    {number} value   The value to be formatted
- *    {Object} options An object with formatting options. Available options:
- *                     {string} notation
- *                         Number notation. Choose from:
- *                         'fixed'          Always use regular number notation.
- *                                          For example '123.40' and '14000000'
- *                         'exponential'    Always use exponential notation.
- *                                          For example '1.234e+2' and '1.4e+7'
- *                         'auto' (default) Regular number notation for numbers
- *                                          having an absolute value between
- *                                          `lower` and `upper` bounds, and uses
- *                                          exponential notation elsewhere.
- *                                          Lower bound is included, upper bound
- *                                          is excluded.
- *                                          For example '123.4' and '1.4e7'.
- *                         'bin', 'oct, or
- *                         'hex'            Format the number using binary, octal,
- *                                          or hexadecimal notation.
- *                                          For example '0b1101' and '0x10fe'.
- *                     {number} wordSize    The word size in bits to use for formatting
- *                                          in binary, octal, or hexadecimal notation.
- *                                          To be used only with 'bin', 'oct', or 'hex'
- *                                          values for 'notation' option. When this option
- *                                          is defined the value is formatted as a signed
- *                                          twos complement integer of the given word size
- *                                          and the size suffix is appended to the output.
- *                                          For example
- *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
- *                                          Default value is undefined.
- *                     {number} precision   A number between 0 and 16 to round
- *                                          the digits of the number.
- *                                          In case of notations 'exponential',
- *                                          'engineering', and 'auto',
- *                                          `precision` defines the total
- *                                          number of significant digits returned.
- *                                          In case of notation 'fixed',
- *                                          `precision` defines the number of
- *                                          significant digits after the decimal
- *                                          point.
- *                                          `precision` is undefined by default.
- *                     {number} lowerExp    Exponent determining the lower boundary
- *                                          for formatting a value with an exponent
- *                                          when `notation='auto`.
- *                                          Default value is `-3`.
- *                     {number} upperExp    Exponent determining the upper boundary
- *                                          for formatting a value with an exponent
- *                                          when `notation='auto`.
- *                                          Default value is `5`.
- *    {Function} fn    A custom formatting function. Can be used to override the
- *                     built-in notations. Function `fn` is called with `value` as
- *                     parameter and must return a string. Is useful for example to
- *                     format all values inside a matrix in a particular way.
- *
- * Examples:
- *
- *    format(6.4)                                        // '6.4'
- *    format(1240000)                                    // '1.24e6'
- *    format(1/3)                                        // '0.3333333333333333'
- *    format(1/3, 3)                                     // '0.333'
- *    format(21385, 2)                                   // '21000'
- *    format(12e8, {notation: 'fixed'})                  // returns '1200000000'
- *    format(2.3,    {notation: 'fixed', precision: 4})  // returns '2.3000'
- *    format(52.8,   {notation: 'exponential'})          // returns '5.28e+1'
- *    format(12400,  {notation: 'engineering'})          // returns '12.400e+3'
- *
- * @param {BigNumber} value
- * @param {Object | Function | number | BigNumber} [options]
- * @return {string} str The formatted value
- */
-export declare function format(value: unknown, options?: unknown): string;
-/**
- * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
- * @param {BigNumber} value
- * @param {number} [precision]        Optional number of significant figures to return.
- */
-export declare function toEngineering(value: BigNumberValue, precision?: number): string;
-/**
- * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
- * @param {BigNumber} value
- * @param {number} [precision]  Number of digits in formatted output.
- *                              If not provided, the maximum available digits
- *                              is used.
- * @returns {string} str
- */
-export declare function toExponential(value: BigNumberValue, precision?: number): string;
-/**
- * Format a number with fixed notation.
- * @param {BigNumber} value
- * @param {number} [precision=undefined] Optional number of decimals after the
- *                                       decimal point. Undefined by default.
- */
-export declare function toFixed(value: BigNumberValue, precision?: number): string;
-export {};
-//# sourceMappingURL=formatter.d.ts.map

package/dist/utils/bignumber/formatter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber/formatter.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,UAAU,cAAc;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,cAAc,CAAC;IAC5D,QAAQ,IAAI,OAAO,CAAC;IACpB,KAAK,IAAI,OAAO,CAAC;IACjB,MAAM,IAAI,OAAO,CAAC;IAClB,SAAS,IAAI,OAAO,CAAC;IACrB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAC5C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAClD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IAClD,QAAQ,IAAI,MAAM,CAAC;IACnB,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvC,WAAW,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,mBAAmB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;IACjD,QAAQ,IAAI,MAAM,CAAC;IACnB,OAAO,IAAI,MAAM,CAAC;IAClB,aAAa,IAAI,MAAM,CAAC;CACzB;AA2CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CA0EhE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAe/E;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAM/E;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzE"}