nerdamer 2.0.0-rc.1 → 2.0.0

package/output/core/classes/complex/Complex.d.ts

@@ -42,6 +42,8 @@ export declare class Complex {
      * @returns A new Decimal containing the nonnegative magnitude.
      */
     abs(): Decimal;
+    /** Returns the squared modulus `re^2 + im^2` without computing a square root. */
+    absSquared(): Decimal;
     /**
      * Adds another complex value component-wise.
      *
@@ -82,6 +84,14 @@ export declare class Complex {
      * @returns A new complex value with both components negated.
      */
     neg(): Complex;
+    /**
+     * Returns the multiplicative inverse of this complex value.
+     *
+     * @returns A new complex value equal to `1 / this`.
+     * @throws {@link core!DivisionByZeroError}
+     * Thrown when both components are exactly zero at the current Decimal value.
+     */
+    reciprocal(): Complex;
     /**
      * Multiplies both complex components by a real scalar.
      *

package/output/core/classes/complex/Complex.js

@@ -54,7 +54,11 @@ class Complex {
      * @returns A new Decimal containing the nonnegative magnitude.
      */
     abs() {
-        return this.re.mul(this.re).plus(this.im.mul(this.im)).sqrt();
+        return this.absSquared().sqrt();
+    }
+    /** Returns the squared modulus `re^2 + im^2` without computing a square root. */
+    absSquared() {
+        return this.re.mul(this.re).plus(this.im.mul(this.im));
     }
     /**
      * Adds another complex value component-wise.
@@ -112,6 +116,20 @@ class Complex {
     neg() {
         return new Complex(this.re.neg(), this.im.neg());
     }
+    /**
+     * Returns the multiplicative inverse of this complex value.
+     *
+     * @returns A new complex value equal to `1 / this`.
+     * @throws {@link core!DivisionByZeroError}
+     * Thrown when both components are exactly zero at the current Decimal value.
+     */
+    reciprocal() {
+        const denom = this.re.mul(this.re).plus(this.im.mul(this.im));
+        if (denom.isZero()) {
+            throw new errors_1.DivisionByZeroError((0, errors_1.message)('divisionByZero'));
+        }
+        return new Complex(this.re.div(denom), this.im.neg().div(denom));
+    }
     /**
      * Multiplies both complex components by a real scalar.
      *

package/output/core/classes/decimalSet/DecimalSet.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DecimalSet = void 0;
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const errors_1 = require("../../errors");
 /**
  * A high-performance set implementation for Decimal.js numbers.
  *
@@ -60,10 +61,10 @@ class DecimalSet {
         const endDec = new decimal_js_1.default(end);
         const stepDec = new decimal_js_1.default(step);
         if (!startDec.isFinite() || !endDec.isFinite() || !stepDec.isFinite()) {
-            throw new Error('Range values must be finite');
+            throw new Error((0, errors_1.message)('rangeValuesFinite'));
         }
         if (stepDec.isZero()) {
-            throw new Error('Step cannot be zero');
+            throw new Error((0, errors_1.message)('rangeStepNonzero'));
         }
         if (stepDec.isPositive()) {
             let current = startDec;
@@ -71,7 +72,7 @@ class DecimalSet {
                 result.add(current);
                 const next = current.plus(stepDec);
                 if (next.equals(current)) {
-                    throw new Error('Step does not advance range at current precision');
+                    throw new Error((0, errors_1.message)('rangeStepNoAdvance'));
                 }
                 current = next;
             }
@@ -82,7 +83,7 @@ class DecimalSet {
                 result.add(current);
                 const next = current.plus(stepDec);
                 if (next.equals(current)) {
-                    throw new Error('Step does not advance range at current precision');
+                    throw new Error((0, errors_1.message)('rangeStepNoAdvance'));
                 }
                 current = next;
             }

package/output/core/classes/dictionary/Dictionary.js

@@ -54,7 +54,10 @@ class Dictionary extends StructuredEntity_1.StructuredEntity {
         const key = typeof indices === 'string' ? indices : String(indices[0]);
         const value = this._entries.get(key);
         if (value === undefined) {
-            throw new errors_1.UnexpectedDataType(`Key "${key}" not found in Dictionary. Available keys: ${this.keys().join(', ')}`);
+            throw new errors_1.UnexpectedDataType((0, errors_1.message)('dictionaryKeyNotFound', {
+                key,
+                keys: this.keys().join(', '),
+            }));
         }
         return value;
     }

package/output/core/classes/expression/CoeffObject.d.ts

@@ -1,6 +1,6 @@
 import { Polynomial } from '../polynomial/Polynomial';
 import { Vector } from '../vector/Vector';
-import { Expression } from './Expression';
+import type { Expression } from './Expression';
 /**
  * Stores coefficients indexed by the power or multidegree collected from an expression.
  *

package/output/core/classes/expression/CoeffObject.js

@@ -5,7 +5,6 @@ const errors_1 = require("../../errors");
 const Polynomial_1 = require("../polynomial/Polynomial");
 const Term_1 = require("../polynomial/Term");
 const Vector_1 = require("../vector/Vector");
-const Expression_1 = require("./Expression");
 const shortcuts_1 = require("./shortcuts");
 /**
  * Stores coefficients indexed by the power or multidegree collected from an expression.
@@ -39,7 +38,7 @@ class CoeffObject {
     buildTerms() {
         const retval = [];
         for (const powers in this.coeffs) {
-            retval.push(new Term_1.Term(new Expression_1.Expression(this.coeffs[powers]), powers, this.variables));
+            retval.push(new Term_1.Term(this.coeffs[powers].copy(), powers, this.variables));
         }
         return retval;
     }

package/output/core/classes/expression/Expression.d.ts

@@ -21,9 +21,20 @@ export type ElementsSortType = (a: Expression, b: Expression) => number;
  * initialize and return internal objects. Use {@link Expression.copy} when an
  * independently mutable expression tree is required.
  *
- * {@link Expression.create} is the preferred construction API. In particular,
- * `Expression.create(existingExpression)` preserves object identity unless its
- * `copy` argument is set to `true`.
+ * {@link Expression.create} is the preferred construction API for ordinary
+ * expression construction and coercion. It centralizes supported input handling and
+ * normalization. When the input is already an `Expression`, it preserves object
+ * identity unless its `copy` argument is set to `true`.
+ *
+ * When the source is already known to be an `Expression` and an independent tree is
+ * required, use {@link Expression.copy}. When a caller accepts broader input but must
+ * guarantee a clone for an existing expression, use
+ * `Expression.create(input, undefined, true)`.
+ *
+ * Direct `new Expression(...)` construction is reserved for representation-level
+ * internals that require constructor semantics, such as the `plainConstruct` path and
+ * the implementation of {@link Expression.copy}. Ordinary callers should not use the
+ * constructor for coercion or cloning.
  *
  * The internal expression groups are organizational categories used by Nerdamer's
  * canonicalization logic. They should not be confused with general mathematical
@@ -111,6 +122,13 @@ export declare class Expression implements Base<Expression> {
         VEC: number;
         MAT: number;
     };
+    /**
+     * Cached ordinary lookup key for SUM and PRD nodes.
+     *
+     * Copies intentionally start without this cache. Aggregate reconstruction clears it
+     * through updateValue() before the node is used again.
+     */
+    private _keyValueCache?;
     /**
      * Arguments stored by a function node.
      *
@@ -162,6 +180,8 @@ export declare class Expression implements Base<Expression> {
      * If set, this is the maximum known precision of any of the intermediate operations
      */
     precision?: number;
+    /** Significant digits requested by the legacy scientific-formatting helper. */
+    scientific?: number;
     /**
      * The default type is a number for the expression since the default value
      * for an expression is "1". The assert flag is used because TypeScript
@@ -184,20 +204,12 @@ export declare class Expression implements Base<Expression> {
      * {@link Expression.create}, and JavaScript constructor return semantics therefore
      * allow that factory-created expression to become the result of `new Expression(...)`.
      *
-     * For ordinary user input, prefer {@link Expression.create}; it makes parsing and
-     * identity behavior explicit.
+     * Ordinary code should use {@link Expression.create} for construction/coercion and
+     * {@link Expression.copy} when an independent tree is required. Direct constructor
+     * calls are reserved for low-level representation code.
      *
      * @param x - The expression or Nerdamer input used to construct the value.
      * @param plainConstruct - Store a string as a raw internal value instead of parsing it.
-     *
-     * @example
-     * ```ts
-     * const expression = Expression.create('x + 1');
-     * const copy = new Expression(expression);
-     *
-     * copy === expression; // false
-     * copy.text();         // "1+x"
-     * ```
      */
     constructor(x: NerdamerInput, plainConstruct?: boolean);
     /**
@@ -262,14 +274,6 @@ export declare class Expression implements Base<Expression> {
      * ```
      */
     static fromRational(x: Rational): Expression;
-    /**
-     * Converts a structured entity carrying symbolic bracket access into the scalar
-     * Expression form used by ordinary algebra and function nodes.
-     *
-     * Structured entities without symbolic access are left unchanged by returning
-     * `undefined`; callers can then apply their normal conversion rules.
-     */
-    static fromSymbolicAccess(x: NerdamerInput): Expression | undefined;
     /**
      * Creates a symbolic function node with the given name.
      *
@@ -667,7 +671,8 @@ export declare class Expression implements Base<Expression> {
      * Re-evaluates this expression numerically, optionally substituting variable values.
      *
      * @remarks
-     * Evaluation serializes the current expression and sends it through
+     * Evaluation uses the ordinary serialization path. When scientific display metadata is
+     * present, a copy without that metadata is serialized so formatting cannot change the value sent through
      * {@link Parser.evaluate}. That parser path enables Nerdamer's evaluation mode, so
      * numeric constants and supported numeric functions are evaluated according to the
      * parser's current precision and settings. The original expression is not modified.
@@ -1485,7 +1490,7 @@ export declare class Expression implements Base<Expression> {
      */
     sptext(options?: TextOptions, asId?: boolean): string;
     /**
-     * Squares this Expression. Shorthand for `this.pow('2')`.
+     * Squares this Expression.
      *
      * @returns A new Expression representing `this²`.
      *
@@ -1547,7 +1552,7 @@ export declare class Expression implements Base<Expression> {
      * @remarks
      * Exact rational text is the default. Use `sort: true` to render terms in Nerdamer's
      * conventional display order without changing the stored expression. Decimal output,
-     * precision, and power wrapping can also be selected per call. The `asId` mode is used
+     * precision, scientific notation, and power wrapping can also be selected per call. The `asId` mode is used
      * by internal identity/canonicalization logic and should not be
      * treated as a stable interchange format.
      *
@@ -1561,6 +1566,7 @@ export declare class Expression implements Base<Expression> {
      * Expression.create('x^2 + 2*x + 1').text({ sort: true }); // "x^2+2*x+1"
      * Expression.create('1/3').text();                         // "1/3"
      * Expression.create('1/3').text({ decimal: true });        // decimal representation
+ * Expression.create('12345').text({ scientific: 3 });        // "1.23e4"
      * ```
      */
     text(options?: TextOptions, asId?: boolean): string;
@@ -1641,9 +1647,12 @@ export declare class Expression implements Base<Expression> {
      * nodes rebuild it from their current elements. Other node types are left unchanged.
      * This method mutates the receiver and returns the same object for chaining.
      *
+     * @param aggregateElements - Exact aggregate elements already available to a caller
+     * rebuilding a SUM/PRD node. When supplied, the generated value is also the ordinary
+     * lookup key and can seed the key cache without a second formatting pass.
      * @returns This expression after updating its stored value where applicable.
      */
-    updateValue(): this;
+    updateValue(aggregateElements?: Expression[]): this;
     /**
      * Provides the primitive value used by JavaScript coercion.
      *

package/output/core/classes/expression/Expression.js

@@ -51,9 +51,20 @@ const { NUM, VAR, EXP, FUN, GRP, PRD, SUM, INF } = constants_1.EXPRESSION_TYPES;
  * initialize and return internal objects. Use {@link Expression.copy} when an
  * independently mutable expression tree is required.
  *
- * {@link Expression.create} is the preferred construction API. In particular,
- * `Expression.create(existingExpression)` preserves object identity unless its
- * `copy` argument is set to `true`.
+ * {@link Expression.create} is the preferred construction API for ordinary
+ * expression construction and coercion. It centralizes supported input handling and
+ * normalization. When the input is already an `Expression`, it preserves object
+ * identity unless its `copy` argument is set to `true`.
+ *
+ * When the source is already known to be an `Expression` and an independent tree is
+ * required, use {@link Expression.copy}. When a caller accepts broader input but must
+ * guarantee a clone for an existing expression, use
+ * `Expression.create(input, undefined, true)`.
+ *
+ * Direct `new Expression(...)` construction is reserved for representation-level
+ * internals that require constructor semantics, such as the `plainConstruct` path and
+ * the implementation of {@link Expression.copy}. Ordinary callers should not use the
+ * constructor for coercion or cloning.
  *
  * The internal expression groups are organizational categories used by Nerdamer's
  * canonicalization logic. They should not be confused with general mathematical
@@ -152,6 +163,13 @@ class Expression {
     };
     /** Internal expression-type constants used by parser and algebra code. */
     static TYPES = constants_1.EXPRESSION_TYPES;
+    /**
+     * Cached ordinary lookup key for SUM and PRD nodes.
+     *
+     * Copies intentionally start without this cache. Aggregate reconstruction clears it
+     * through updateValue() before the node is used again.
+     */
+    _keyValueCache;
     /**
      * Arguments stored by a function node.
      *
@@ -203,6 +221,8 @@ class Expression {
      * If set, this is the maximum known precision of any of the intermediate operations
      */
     precision;
+    /** Significant digits requested by the legacy scientific-formatting helper. */
+    scientific;
     /**
      * The default type is a number for the expression since the default value
      * for an expression is "1". The assert flag is used because TypeScript
@@ -225,20 +245,12 @@ class Expression {
      * {@link Expression.create}, and JavaScript constructor return semantics therefore
      * allow that factory-created expression to become the result of `new Expression(...)`.
      *
-     * For ordinary user input, prefer {@link Expression.create}; it makes parsing and
-     * identity behavior explicit.
+     * Ordinary code should use {@link Expression.create} for construction/coercion and
+     * {@link Expression.copy} when an independent tree is required. Direct constructor
+     * calls are reserved for low-level representation code.
      *
      * @param x - The expression or Nerdamer input used to construct the value.
      * @param plainConstruct - Store a string as a raw internal value instead of parsing it.
-     *
-     * @example
-     * ```ts
-     * const expression = Expression.create('x + 1');
-     * const copy = new Expression(expression);
-     *
-     * copy === expression; // false
-     * copy.text();         // "1+x"
-     * ```
      */
     constructor(x, plainConstruct) {
         // Allow for hooking of the input. The user can override the hook to modify
@@ -342,28 +354,6 @@ class Expression {
         retval.getMultiplier().asDecimal = x.asDecimal;
         return retval;
     }
-    /**
-     * Converts a structured entity carrying symbolic bracket access into the scalar
-     * Expression form used by ordinary algebra and function nodes.
-     *
-     * Structured entities without symbolic access are left unchanged by returning
-     * `undefined`; callers can then apply their normal conversion rules.
-     */
-    static fromSymbolicAccess(x) {
-        let retval;
-        if (typeof x === 'object' && x !== null) {
-            const structured = x;
-            const target = structured.symbolicTarget;
-            const indices = structured.symbolicAccessor;
-            if (Expression.isExpression(target) &&
-                indices &&
-                indices.length > 0 &&
-                indices.every(index => Expression.isExpression(index))) {
-                retval = Expression.toAccessor(target, indices);
-            }
-        }
-        return retval;
-    }
     /**
      * Creates a symbolic function node with the given name.
      *
@@ -637,7 +627,7 @@ class Expression {
             .filter((x) => {
             return x !== undefined;
         })
-            .map(x => Expression.fromSymbolicAccess(x) ?? Expression.create(x));
+            .map(x => Expression.create(x));
         // Set the name
         f.name = name;
         // TODO: This needs to be generated the same way as in text.
@@ -764,7 +754,7 @@ class Expression {
      * ```
      */
     copy() {
-        return new Expression(this);
+        return (0, utils_1.cloneExpressionTree)(this);
     }
     /**
      * Legacy alias for {@link getDenominator}.
@@ -805,6 +795,7 @@ class Expression {
                     elements[x] = term.distributeMultiplier();
                 }
             }
+            retval.updateValue();
         }
         return retval;
     }
@@ -932,7 +923,8 @@ class Expression {
      * Re-evaluates this expression numerically, optionally substituting variable values.
      *
      * @remarks
-     * Evaluation serializes the current expression and sends it through
+     * Evaluation uses the ordinary serialization path. When scientific display metadata is
+     * present, a copy without that metadata is serialized so formatting cannot change the value sent through
      * {@link Parser.evaluate}. That parser path enables Nerdamer's evaluation mode, so
      * numeric constants and supported numeric functions are evaluated according to the
      * parser's current precision and settings. The original expression is not modified.
@@ -947,11 +939,24 @@ class Expression {
      * ```
      */
     evaluate(values) {
-        const source = this.hasFunction(constants_1.SYMBOLIC_ACCESSOR, true)
-            ? (0, format_1.toText)(this, { internalAccessor: true }, undefined, Expression.POW_OPR, Expression.sortFunction)
-            : this.text();
+        let source;
+        if (this.scientific !== undefined) {
+            const sourceExpression = this.copy();
+            delete sourceExpression.scientific;
+            source = sourceExpression.hasFunction(constants_1.SYMBOLIC_ACCESSOR, true)
+                ? (0, format_1.toText)(sourceExpression, { internalAccessor: true }, undefined, Expression.POW_OPR, Expression.sortFunction)
+                : sourceExpression.text();
+        }
+        else {
+            source = this.hasFunction(constants_1.SYMBOLIC_ACCESSOR, true)
+                ? (0, format_1.toText)(this, { internalAccessor: true }, undefined, Expression.POW_OPR, Expression.sortFunction)
+                : this.text();
+        }
         const evaluated = Parser_1.Parser.evaluate(source, values);
-        const retval = Expression.fromSymbolicAccess(evaluated) ?? Expression.create(evaluated);
+        const retval = Expression.create(evaluated);
+        if (this.scientific !== undefined) {
+            retval.scientific = this.scientific;
+        }
         return retval;
     }
     /**
@@ -1352,7 +1357,7 @@ class Expression {
             retval = (0, shortcuts_1.one)().div(this);
         }
         else {
-            retval = new Expression(this);
+            retval = this.copy();
             retval.power = retval.getPower().neg();
             retval.multiplier = retval.getMultiplier().invert();
         }
@@ -1783,6 +1788,10 @@ class Expression {
      * Thrown when no key-generation rule exists for the node's internal type.
      */
     keyValue(asSubExpression = false, isGroup = false) {
+        const cacheable = !asSubExpression && !isGroup && (this.type === SUM || this.type === PRD);
+        if (cacheable && this._keyValueCache !== undefined) {
+            return this._keyValueCache;
+        }
         let retval = '';
         // For GRP the key is always the power
         if (isGroup) {
@@ -1814,7 +1823,10 @@ class Expression {
             }
         }
         if (!retval) {
-            throw new Error(`The function 'keyValue' not yet implemented for type ${this.type}`);
+            throw new Error((0, errors_1.message)('expressionKeyValueUnsupported', { type: String(this.type) }));
+        }
+        if (cacheable) {
+            this._keyValueCache = retval;
         }
         return retval;
     }
@@ -2051,7 +2063,7 @@ class Expression {
         return txt;
     }
     /**
-     * Squares this Expression. Shorthand for `this.pow('2')`.
+     * Squares this Expression.
      *
      * @returns A new Expression representing `this²`.
      *
@@ -2062,7 +2074,7 @@ class Expression {
      * ```
      */
     sq() {
-        return this.pow('2');
+        return this.pow((0, shortcuts_1.two)());
     }
     /**
      * Tests Nerdamer equality while also requiring the same top-level internal type.
@@ -2134,7 +2146,7 @@ class Expression {
      * @remarks
      * Exact rational text is the default. Use `sort: true` to render terms in Nerdamer's
      * conventional display order without changing the stored expression. Decimal output,
-     * precision, and power wrapping can also be selected per call. The `asId` mode is used
+     * precision, scientific notation, and power wrapping can also be selected per call. The `asId` mode is used
      * by internal identity/canonicalization logic and should not be
      * treated as a stable interchange format.
      *
@@ -2148,9 +2160,16 @@ class Expression {
      * Expression.create('x^2 + 2*x + 1').text({ sort: true }); // "x^2+2*x+1"
      * Expression.create('1/3').text();                         // "1/3"
      * Expression.create('1/3').text({ decimal: true });        // decimal representation
+ * Expression.create('12345').text({ scientific: 3 });        // "1.23e4"
      * ```
      */
     text(options, asId) {
+        if (options === undefined &&
+            asId === undefined &&
+            this.precision === undefined &&
+            this.scientific === undefined) {
+            return (0, format_1.toDefaultText)(this, Expression.POW_OPR, Expression.sortFunction);
+        }
         return (0, format_1.toText)(this, options, asId, Expression.POW_OPR, Expression.sortFunction);
     }
     /**
@@ -2277,16 +2296,24 @@ class Expression {
      * nodes rebuild it from their current elements. Other node types are left unchanged.
      * This method mutates the receiver and returns the same object for chaining.
      *
+     * @param aggregateElements - Exact aggregate elements already available to a caller
+     * rebuilding a SUM/PRD node. When supplied, the generated value is also the ordinary
+     * lookup key and can seed the key cache without a second formatting pass.
      * @returns This expression after updating its stored value where applicable.
      */
-    updateValue() {
+    updateValue(aggregateElements) {
+        this._keyValueCache = undefined;
         if (this.isFunction()) {
             this.value = `${this.name}(${this.getArguments()
                 .map(x => x.text())
                 .join(', ')})`;
         }
         else if (this.isProduct() || this.isSum()) {
-            this.value = Expression.getValue(this.elementsArray(), 'text', this.type);
+            const elements = aggregateElements ?? this.elementsArray();
+            this.value = Expression.getValue(elements, 'text', this.type);
+            if (aggregateElements && (this.type === SUM || this.type === PRD)) {
+                this._keyValueCache = this.value;
+            }
         }
         return this;
     }

package/output/core/classes/expression/analysis.d.ts

@@ -13,7 +13,7 @@ export declare function separateVar(x: Expression, variables: (string | Expressi
  *
  * @param wrt
  */
-export declare function coeffs(x: Expression, variables: string[], coeffsObj?: CoeffObject): CoeffObject;
+export declare function coeffs(x: Expression, variables: string[], coeffsObj?: CoeffObject, expandExpression?: boolean): CoeffObject;
 export declare function getDenominator(x: Expression): Expression;
 export declare function getNumerator(x: Expression): Expression; /**
  * Returns true fo polynomial with coefficients in Z or Q.

package/output/core/classes/expression/analysis.js

@@ -63,15 +63,15 @@ function separateVar(x, variables) {
  *
  * @param wrt
  */
-function coeffs(x, variables, coeffsObj) {
+function coeffs(x, variables, coeffsObj, expandExpression = true) {
     const cObj = coeffsObj || new CoeffObject_1.CoeffObject(variables);
     // Complex sums are canonically stored as re + i*im. If the requested variables
     // are inside im, treating i*im as a single coefficient leaves those variables
     // buried inside the coefficient. Split the two components and collect them
     // independently, then restore i on the imaginary coefficients.
     if (x.isComplex() && !variables.includes(Expression_1.Expression.imaginary)) {
-        const realCoeffs = coeffs(x.realPart(), variables);
-        const imaginaryCoeffs = coeffs(x.imagPart(), variables);
+        const realCoeffs = coeffs(x.realPart(), variables, undefined, expandExpression);
+        const imaginaryCoeffs = coeffs(x.imagPart(), variables, undefined, expandExpression);
         realCoeffs.each((coeff, power) => cObj.add(power, coeff));
         imaginaryCoeffs.each((coeff, power) => cObj.add(power, coeff.times(Expression_1.Expression.Img())));
         return cObj;
@@ -95,7 +95,7 @@ function coeffs(x, variables, coeffsObj) {
             }
         }
         if (hasCoefficientFactor) {
-            const productCoeffs = coeffs(product, variables);
+            const productCoeffs = coeffs(product, variables, undefined, expandExpression);
             productCoeffs.each((value, power) => {
                 cObj.add(power, coefficient.times(value));
             });
@@ -103,12 +103,12 @@ function coeffs(x, variables, coeffsObj) {
         }
         x = product;
     }
-    // Expand the expression
-    const f = (0, expand_1.expand)(x);
+    // Expand only when the caller has not already supplied expanded structure.
+    const f = expandExpression ? (0, expand_1.expand)(x) : x;
     if (f.isSum()) {
         // Loop through the expression and get the coefficient for each
         f.each(e => {
-            coeffs(e, variables, cObj);
+            coeffs(e, variables, cObj, false);
         });
     }
     else {

package/output/core/classes/expression/format.d.ts

@@ -3,6 +3,7 @@ import type { Expression } from './Expression';
 type ExpressionSortFunction = (a: Expression, b: Expression) => number;
 type ExpressionTextOptions = TextOptions & {
     internalAccessor?: boolean;
+    exactScientific?: boolean;
 };
 /**
  * Formats the multiplier string for string output.
@@ -23,6 +24,14 @@ export declare function formatMultiplierString(x: Expression, options?: Expressi
  * @returns
  */
 export declare function formatPowerString(x: Expression, options: ExpressionTextOptions | undefined, powerOperator: string): string;
+/**
+ * Formats the ordinary no-options text form without creating formatting option objects
+ * while descending the expression tree.
+ *
+ * This routine follows the same default rendering rules as {@link toText}. Calls that
+ * request explicit formatting options continue through {@link toText}.
+ */
+export declare function toDefaultText(x: Expression, powerOperator: string, sortFunction: ExpressionSortFunction): string;
 /**
  * Formats an expression using the current formatting policy supplied by Expression.
  *