@danielsimonjr/mathts-core 0.5.0 → 0.6.0

package/dist/index.js

@@ -27,18 +27,324 @@ import {
   addScalar,
   divideScalar,
   equal,
+  factory,
   fix,
+  format,
+  isBigInt,
   isBigNumber,
+  isBigNumber2,
   isComplex,
-  isFraction,
+  isFraction2 as isFraction,
   isNumeric,
   isUnit,
   multiplyScalar,
+  nearlyEqual,
   number,
   pow,
   round,
+  sign,
   subtractScalar
-} from "./chunk-BDNTTHO4.js";
+} from "./chunk-AMOHH5MP.js";
+
+// src/types/matrix/Range.ts
+var name = "Range";
+var dependencies = [];
+var createRangeClass = /* @__PURE__ */ factory(
+  name,
+  dependencies,
+  () => {
+    class Range2 {
+      /**
+       * Type identifier
+       */
+      type = "Range";
+      /**
+       * Range type flag
+       */
+      isRange = true;
+      /**
+       * Start value of the range (inclusive)
+       */
+      start;
+      /**
+       * End value of the range (exclusive)
+       */
+      end;
+      /**
+       * Step size for the range
+       */
+      step;
+      /**
+       * Cached primitive array representation
+       */
+      #cache = null;
+      #cacheStart;
+      #cacheEnd;
+      #cacheStep;
+      constructor(start, end, step) {
+        if (!(this instanceof Range2)) {
+          throw new SyntaxError("Constructor must be called with the new operator");
+        }
+        const hasStart = start !== null && start !== void 0;
+        const hasEnd = end !== null && end !== void 0;
+        const hasStep = step !== null && step !== void 0;
+        let startValue = 0;
+        let endValue = 0;
+        let stepValue = 1;
+        if (hasStart) {
+          if (isBigNumber(start)) {
+            startValue = start.toNumber();
+          } else if (typeof start !== "number" && !isBigInt(start)) {
+            throw new TypeError("Parameter start must be a number or bigint");
+          } else {
+            startValue = start;
+          }
+        }
+        if (hasEnd) {
+          if (isBigNumber(end)) {
+            endValue = end.toNumber();
+          } else if (typeof end !== "number" && !isBigInt(end)) {
+            throw new TypeError("Parameter end must be a number or bigint");
+          } else {
+            endValue = end;
+          }
+        }
+        if (hasStep) {
+          if (isBigNumber(step)) {
+            stepValue = step.toNumber();
+          } else if (typeof step !== "number" && !isBigInt(step)) {
+            throw new TypeError("Parameter step must be a number or bigint");
+          } else {
+            stepValue = step;
+          }
+        }
+        this.start = hasStart ? parseFloat(startValue.toString()) : 0;
+        this.end = hasEnd ? parseFloat(endValue.toString()) : 0;
+        this.step = hasStep ? parseFloat(stepValue.toString()) : 1;
+        if (hasStep && nearlyEqual(this.step, 0)) {
+          throw new Error("Step must not be zero");
+        }
+      }
+      /**
+       * Parse a string into a range,
+       * The string contains the start, optional step, and end, separated by a colon.
+       * If the string does not contain a valid range, null is returned.
+       * For example str='0:2:11'.
+       * @memberof Range
+       * @param {string} str
+       * @return {Range | null} range
+       */
+      static parse(str) {
+        if (typeof str !== "string") {
+          return null;
+        }
+        const args = str.split(":");
+        const nums = args.map(function(arg) {
+          return parseFloat(arg);
+        });
+        const invalid = nums.some(function(num) {
+          return isNaN(num);
+        });
+        if (invalid) {
+          return null;
+        }
+        switch (nums.length) {
+          case 2:
+            return new Range2(nums[0], nums[1]);
+          case 3:
+            return new Range2(nums[0], nums[2], nums[1]);
+          default:
+            return null;
+        }
+      }
+      /**
+       * Create a clone of the range
+       * @return {Range} clone
+       */
+      clone() {
+        return new Range2(this.start, this.end, this.step);
+      }
+      /**
+       * Retrieve the size of the range.
+       * Returns an array containing one number, the number of elements in the range.
+       * @memberof Range
+       * @returns {number[]} size
+       */
+      size() {
+        let len = 0;
+        const start = this.start;
+        const step = this.step;
+        const end = this.end;
+        const diff = end - start;
+        if (sign(step) === sign(diff)) {
+          len = Math.ceil(diff / step);
+        } else if (diff === 0) {
+          len = 0;
+        }
+        if (isNaN(len)) {
+          len = 0;
+        }
+        return [len];
+      }
+      /**
+       * Calculate the minimum value in the range
+       * @memberof Range
+       * @return {number | undefined} min
+       */
+      min() {
+        const size = this.size()[0];
+        if (size > 0) {
+          if (this.step > 0) {
+            return this.start;
+          } else {
+            return this.start + (size - 1) * this.step;
+          }
+        } else {
+          return void 0;
+        }
+      }
+      /**
+       * Calculate the maximum value in the range
+       * @memberof Range
+       * @return {number | undefined} max
+       */
+      max() {
+        const size = this.size()[0];
+        if (size > 0) {
+          if (this.step > 0) {
+            return this.start + (size - 1) * this.step;
+          } else {
+            return this.start;
+          }
+        } else {
+          return void 0;
+        }
+      }
+      /**
+       * Execute a callback function for each value in the range.
+       * @memberof Range
+       * @param {function} callback The callback method is invoked with three
+       *                            parameters: the value of the element, the index
+       *                            of the element, and the Range being traversed.
+       */
+      forEach(callback) {
+        let x = this.start;
+        const step = this.step;
+        const end = this.end;
+        let i = 0;
+        if (step > 0) {
+          while (x < end) {
+            callback(x, [i], this);
+            x += step;
+            i++;
+          }
+        } else if (step < 0) {
+          while (x > end) {
+            callback(x, [i], this);
+            x += step;
+            i++;
+          }
+        }
+      }
+      /**
+       * Execute a callback function for each value in the Range, and return the
+       * results as an array
+       * @memberof Range
+       * @param {function} callback The callback method is invoked with three
+       *                            parameters: the value of the element, the index
+       *                            of the element, and the Matrix being traversed.
+       * @returns {Array} array
+       */
+      map(callback) {
+        const array = [];
+        this.forEach((value, index) => {
+          array[index[0]] = callback(value, index, this);
+        });
+        return array;
+      }
+      /**
+       * Create an Array with a copy of the Ranges data
+       * @memberof Range
+       * @returns {Array} array
+       */
+      toArray() {
+        const array = [];
+        this.forEach(function(value, index) {
+          array[index[0]] = value;
+        });
+        return array;
+      }
+      /**
+       * Get the primitive value of the Range, a one dimensional array
+       * @memberof Range
+       * @returns {Array} array
+       */
+      valueOf() {
+        if (this.#cache !== null && this.start === this.#cacheStart && this.end === this.#cacheEnd && this.step === this.#cacheStep) {
+          return this.#cache;
+        }
+        this.#cache = this.toArray();
+        this.#cacheStart = this.start;
+        this.#cacheEnd = this.end;
+        this.#cacheStep = this.step;
+        return this.#cache;
+      }
+      /**
+       * Get a string representation of the range, with optional formatting options.
+       * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+       * @memberof Range
+       * @param {Object | number | function} [options] Formatting options. See
+       *                                               lib/utils/number:format for a
+       *                                               description of the available
+       *                                               options.
+       * @returns {string} str
+       */
+      format(options) {
+        let str = format(this.start, options);
+        if (this.step !== 1) {
+          str += ":" + format(this.step, options);
+        }
+        str += ":" + format(this.end, options);
+        return str;
+      }
+      /**
+       * Get a string representation of the range.
+       * @memberof Range
+       * @returns {string}
+       */
+      toString() {
+        return this.format();
+      }
+      /**
+       * Get a JSON representation of the range
+       * @memberof Range
+       * @returns {Object} Returns a JSON object structured as:
+       *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+       */
+      toJSON() {
+        return {
+          mathjs: "Range",
+          start: this.start,
+          end: this.end,
+          step: this.step
+        };
+      }
+      /**
+       * Instantiate a Range from a JSON object
+       * @memberof Range
+       * @param {Object} json A JSON object structured as:
+       *                      `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+       * @return {Range}
+       */
+      static fromJSON(json) {
+        return new Range2(json.start, json.end, json.step);
+      }
+    }
+    return Range2;
+  },
+  { isClass: true }
+);
+var Range = createRangeClass({});
 
 // src/types/dual-rules.ts
 var DUAL_UNARY_RULES = {
@@ -325,8 +631,8 @@ var UNIT_ALIASES = {
   "\xB0": "deg"
   // The Unicode micro sign is handled in prefixes; °K is non-standard.
 };
-function getUnitDef(name) {
-  return ALL_UNITS[name];
+function getUnitDef(name2) {
+  return ALL_UNITS[name2];
 }
 
 // src/types/unit-prefixes.ts
@@ -395,8 +701,8 @@ var BEST_PREFIXES = [
   "z",
   "y"
 ];
-function getPrefix(name) {
-  return SI_PREFIXES[name];
+function getPrefix(name2) {
+  return SI_PREFIXES[name2];
 }
 
 // src/typed/mathts-typed.ts
@@ -422,7 +728,7 @@ function isTypedWasmAvailable() {
 var isNumber = (x) => typeof x === "number";
 var isBoolean = (x) => typeof x === "boolean";
 var isString = (x) => typeof x === "string";
-var isBigInt = (x) => typeof x === "bigint";
+var isBigInt2 = (x) => typeof x === "bigint";
 var isArray = (x) => Array.isArray(x);
 var isFunction = (x) => typeof x === "function";
 var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
@@ -435,7 +741,7 @@ var isUint32Array = (x) => x instanceof Uint32Array;
 var isUint8Array = (x) => x instanceof Uint8Array;
 var isComplex2 = (x) => isComplex(x);
 var isFraction2 = (x) => isFraction(x);
-var isBigNumber2 = (x) => isBigNumber(x);
+var isBigNumber3 = (x) => isBigNumber2(x);
 var isMatrix = (x) => isObject(x) && "rows" in x && "cols" in x && "get" in x && typeof x.type === "string";
 var isDenseMatrix = (x) => isMatrix(x) && x.type === "DenseMatrix";
 var isSparseMatrix = (x) => isMatrix(x) && x.type === "SparseMatrix";
@@ -449,12 +755,12 @@ var isUnit2 = (x) => {
 };
 var MATHTS_TYPES = [
   // bigint is not built into typed-function
-  { name: "bigint", test: isBigInt },
+  { name: "bigint", test: isBigInt2 },
   // MathTS numeric types (ordered by specificity for conversion priority)
   // WASM masks use typed.masks.OBJECT | typed.masks.custom(N) pattern
   { name: "Complex", test: isComplex2 },
   { name: "Fraction", test: isFraction2 },
-  { name: "BigNumber", test: isBigNumber2 },
+  { name: "BigNumber", test: isBigNumber3 },
   // TypedArrays (for parallel-first WASM operations)
   { name: "Float64Array", test: isFloat64Array },
   { name: "Float32Array", test: isFloat32Array },
@@ -649,8 +955,8 @@ var TypeRegistry = class {
   /**
    * Register a new type
    */
-  registerType(name, test) {
-    this.types.set(name, { name, test });
+  registerType(name2, test) {
+    this.types.set(name2, { name: name2, test });
     this.instance = null;
     return this;
   }
@@ -670,8 +976,8 @@ var TypeRegistry = class {
   /**
    * Check if a type is registered
    */
-  hasType(name) {
-    return this.types.has(name);
+  hasType(name2) {
+    return this.types.has(name2);
   }
   /**
    * Check if a conversion is registered
@@ -706,8 +1012,8 @@ var TypeRegistry = class {
     this.instance = null;
   }
 };
-function createTypedFunction(name, signatures, typedInstance = mathTyped) {
-  return typedInstance(name, signatures);
+function createTypedFunction(name2, signatures, typedInstance = mathTyped) {
+  return typedInstance(name2, signatures);
 }
 
 // src/typed/type-bridge.ts
@@ -792,50 +1098,50 @@ var FunctionRegistry = class {
   /**
    * Register a factory function
    */
-  register(factory) {
-    this.factories.set(factory.name, factory);
+  register(factory2) {
+    this.factories.set(factory2.name, factory2);
   }
   /**
    * Register multiple factory functions
    */
   registerAll(factories) {
-    for (const factory of factories) {
-      this.register(factory);
+    for (const factory2 of factories) {
+      this.register(factory2);
     }
   }
   /**
    * Get or create a function by name
    */
-  get(name) {
-    const existing = this.instances.get(name);
+  get(name2) {
+    const existing = this.instances.get(name2);
     if (existing) return existing;
-    if (this.creating.has(name)) {
-      throw new Error(`Circular dependency detected: ${name}`);
+    if (this.creating.has(name2)) {
+      throw new Error(`Circular dependency detected: ${name2}`);
     }
-    const factory = this.factories.get(name);
-    if (!factory) {
-      throw new Error(`Unknown function: ${name}`);
+    const factory2 = this.factories.get(name2);
+    if (!factory2) {
+      throw new Error(`Unknown function: ${name2}`);
     }
-    this.creating.add(name);
+    this.creating.add(name2);
     try {
       const deps = { ...this.dependencies };
-      for (const depName of factory.dependencies) {
+      for (const depName of factory2.dependencies) {
         if (depName === "config" || depName === "typed") continue;
         deps[depName] = this.get(depName);
       }
-      const fn = factory.factory(deps);
-      this.instances.set(name, fn);
-      this.dependencies[name] = fn;
+      const fn = factory2.factory(deps);
+      this.instances.set(name2, fn);
+      this.dependencies[name2] = fn;
       return fn;
     } finally {
-      this.creating.delete(name);
+      this.creating.delete(name2);
     }
   }
   /**
    * Check if a function is registered
    */
-  has(name) {
-    return this.factories.has(name);
+  has(name2) {
+    return this.factories.has(name2);
   }
   /**
    * Get all registered function names
@@ -857,19 +1163,19 @@ var FunctionRegistry = class {
     return { ...this.dependencies.config };
   }
 };
-function createFactory(name, dependencies, factory) {
-  return { name, dependencies, factory };
+function createFactory(name2, dependencies2, factory2) {
+  return { name: name2, dependencies: dependencies2, factory: factory2 };
 }
 var registry = new FunctionRegistry();
 var math = {
   /**
    * Get a registered function
    */
-  get: (name) => registry.get(name),
+  get: (name2) => registry.get(name2),
   /**
    * Register a factory function
    */
-  register: (factory) => registry.register(factory),
+  register: (factory2) => registry.register(factory2),
   /**
    * Get configuration
    */
@@ -923,6 +1229,7 @@ export {
   MATHTS_TYPES,
   PHI,
   PI,
+  Range,
   SI_PREFIXES,
   SQRT1_2,
   SQRT2,
@@ -937,6 +1244,7 @@ export {
   create,
   createFactory,
   createMathTSTyped,
+  createRangeClass,
   createTypedFunction,
   dim,
   divideScalar,
@@ -946,8 +1254,8 @@ export {
   getUnitDef,
   initTypedWasm,
   isArray,
-  isBigInt,
-  isBigNumber,
+  isBigInt2 as isBigInt,
+  isBigNumber2 as isBigNumber,
   isBoolean,
   isComplex,
   isDenseMatrix,

package/dist/internal.d.ts

@@ -1,33 +1,5 @@
-import { b as UnitConstructor, c as UnitDependencies } from './index-DpOizJsa.js';
-export { B as BaseUnitDef, d as BigNumber, e as BigNumberConstructor, f as BigNumberValue, C as Complex, g as ComplexConstructor, h as ComplexValue, j as ConverterFn, U as CoreUnit, k as CreateUnitDefObject, l as CreateUnitOptions, D as DenseMatrix, F as Fraction, m as FractionConstructor, n as FractionValue, I as Index, o as IndexDimension, M as Matrix, N as Numeric, P as ParseOptions, p as PrefixDef, q as PrefixTable, R as Range, S as ScalarBinaryOp, r as ScalarUnaryOp, s as SparseMatrix, t as SubtractScalar, T as TypeConverters, u as Unit, v as UnitComponent, w as UnitConfig, x as UnitDef, y as UnitFormatOptions, a as UnitInstance, z as UnitJSON, A as UnitSystem, E as UnitSystemEntry, G as isArray, H as isBigInt, J as isBigNumber, K as isBoolean, L as isCollection, O as isComplex, Q as isDate, V as isDenseMatrix, W as isFraction, X as isFunction, Y as isIndex, Z as isMap, _ as isMatrix, $ as isNull, a0 as isNumber, a1 as isObject, a2 as isRange, a3 as isRegExp, a4 as isSparseMatrix, a5 as isString, a6 as isUndefined, i as isUnit, a7 as typeOf } from './index-DpOizJsa.js';
-
-/**
- * Type for a factory function that creates instances
- */
-interface FactoryFunction<TResult = unknown> {
-    (scope: Record<string, unknown>): TResult;
-    isFactory: true;
-    fn: string;
-    dependencies: string[];
-    meta?: FactoryMeta;
-}
-/**
- * Meta information that can be attached to a factory
- */
-interface FactoryMeta {
-    /**
-     * If true, the factory will be recreated when config changes
-     */
-    recreateOnConfigChange?: boolean;
-    /**
-     * If true, this is a lazy factory that should only be created when needed
-     */
-    lazy?: boolean;
-    /**
-     * Additional custom metadata
-     */
-    [key: string]: unknown;
-}
+import { F as FactoryFunction, b as UnitConstructor, c as UnitDependencies } from './index-zKEDY9aj.js';
+export { B as BaseUnitDef, d as BigNumber, e as BigNumberConstructor, f as BigNumberValue, C as Complex, g as ComplexConstructor, h as ComplexValue, j as ConverterFn, U as CoreUnit, k as CreateUnitDefObject, l as CreateUnitOptions, D as DenseMatrix, m as Fraction, n as FractionConstructor, o as FractionValue, I as Index, p as IndexDimension, M as Matrix, N as Numeric, P as ParseOptions, q as PrefixDef, r as PrefixTable, R as Range, S as ScalarBinaryOp, s as ScalarUnaryOp, t as SparseMatrix, u as SubtractScalar, T as TypeConverters, v as Unit, w as UnitComponent, x as UnitConfig, y as UnitDef, z as UnitFormatOptions, a as UnitInstance, A as UnitJSON, E as UnitSystem, G as UnitSystemEntry, H as isArray, J as isBigInt, K as isBigNumber, L as isBoolean, O as isCollection, Q as isComplex, V as isDate, W as isDenseMatrix, X as isFraction, Y as isFunction, Z as isIndex, _ as isMap, $ as isMatrix, a0 as isNull, a1 as isNumber, a2 as isObject, a3 as isRange, a4 as isRegExp, a5 as isSparseMatrix, a6 as isString, a7 as isUndefined, i as isUnit, a8 as typeOf } from './index-zKEDY9aj.js';
 
 declare const createUnitClass: FactoryFunction<UnitConstructor>;
 

package/dist/internal.js

@@ -21,13 +21,13 @@ import {
   hasOwnProperty,
   isArray,
   isBigInt,
-  isBigNumber2 as isBigNumber,
+  isBigNumber,
   isBoolean,
   isCollection,
   isComplex2 as isComplex,
   isDate,
   isDenseMatrix,
-  isFraction2 as isFraction,
+  isFraction,
   isFunction,
   isIndex,
   isInteger,
@@ -69,7 +69,7 @@ import {
   typeOf,
   unitDependencies,
   warnOnce
-} from "./chunk-BDNTTHO4.js";
+} from "./chunk-AMOHH5MP.js";
 export {
   Unit as CoreUnit,
   acosh,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-core",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Core types, utilities, and configuration for MathTS",
   "author": "Daniel Simon Jr.",
   "license": "MIT",