calling the toString() method and keeping full number without any exponent notation

[rohanpatil20]

so i have the following expressions that i call parse with:

f = math.parse("a * 0 + (c/c) b * 0.05 + e ((d/e) * 0.1 + 12500) + g ((f/g) * 0.15 + 37500) + i ((h/i) * 0.2 + 75000) + k * 1 (j * 0.25 + 125000) + l ((n/m) * 0.3 + 187500)")

and basically what i want to do is for any scenario where the parser encounters A(B/C) i want to output A*(B/C) and get a new string.

const implicitMultiplicationFormatter = (n,o) => {

        if (n.fn && n.fn.type && n.fn.type == "SymbolNode") {
            return `${n.fn} * (${n.args.toString(o)})`;
        }
 }
 const formatOptions = {
        "implicit":"show",
        "notation": "fixed",
        "handler": implicitMultiplicationFormatter
      }
 string = f.toString(formatOptions);

but now the string has exponent notation in the output which is causing issues with the backend expression solver that i'm using.
a * 0 + (c / c) * b * 0.05 + e * ((d / e) * 0.1 + 12500) + g * ((f / g) * 0.15 + 37500) + i * ((h / i) * 0.2 + 75000) + k * (j * 0.25 + 1.25e+5) + l * ((n / m) * 0.3 + 1.875e+5)

so the 125000 and 187500 get converted to the exponent notation. but i have a variable e that i'm already using and the backend evalator that i'm using assumes that the e in the exponent notation is the same as the variable e which results in an incorrect value. I've temporarily resolved the issue by simply multiplying the expression that contain these numbers by 1 and that seems to give me the proper output:
f = math.parse("k * 1 *(j * 0.25 + 125000) + l * 1 * ((n / m) * 0.3 + 187500)") => k * 1 * (j * 0.25 + 125000) + l * 1 * ((n / m) * 0.3 + 187500)

i was wondering if there was some formatting option which would make sure that the exponent notation is disabled. that would be better to use since i dont want to ahve to multiply by 1 everytime i create a new expression.

[josdejong]

Using the format option {"notation": "fixed"} like you do already makes sure that the output values are not 1.25e5 and 1.875e+5 but 125000, and 187500.

You can effectively disable exponent notation by specifying lowerExp and upperExp:

const formatOptions = {
  "implicit":"show",
  "lowerExp": -Infinity,
  "upperExp": Infinity, 
  "handler": implicitMultiplicationFormatter
}

Docs describing the formatting options: https://mathjs.org/docs/reference/functions/format.html

[rohanpatil20]

i tried adding the formatOptions for disabling the exponent notations as you suggested but it didn't work. I did some debugging and found that the implicitMultiplicationFormatter i'm using to edit the string where it takes an instance of A(B/C) and converts it to A*(B/C) is causing the issue. When i disabled that handler option, i was getting the full number again. so i tried adding the format options to the handler code

const implicitMultiplicationFormatter = (n,o) => {
        if (n.fn && n.fn.type && n.fn.type == "SymbolNode") {
            return `${n.fn} * (${n.args.toString({"lowerExp": -Infinity, "upperExp": Infinity})})`;
        }
      }

but that didn't do anything either

[josdejong]

In your code example, n.args is a JavaScript Array, and the .toString() of an Array doesn't know about these options. I think you have to change it to something like:

n.args.map(arg => arg.toString(formatOptions)).join(', ')