{"version":3,"file":"791.js","mappings":"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","sources":["webpack://WebComponents/./node_modules/btm-expressions/src/reductions.js","webpack://WebComponents/./node_modules/btm-expressions/src/expression.js","webpack://WebComponents/./node_modules/btm-expressions/src/real_number.js","webpack://WebComponents/./node_modules/btm-expressions/src/rational_number.js","webpack://WebComponents/./node_modules/btm-expressions/src/multiop_expr.js","webpack://WebComponents/./node_modules/btm-expressions/src/variable_expr.js","webpack://WebComponents/./node_modules/btm-expressions/src/function_expr.js","webpack://WebComponents/./node_modules/btm-expressions/src/binop_expr.js","webpack://WebComponents/./node_modules/btm-expressions/src/unop_expr.js","webpack://WebComponents/./node_modules/btm-expressions/src/scalar_expr.js","webpack://WebComponents/./node_modules/btm-expressions/src/deriv_expr.js","webpack://WebComponents/./node_modules/btm-expressions/src/random.js","webpack://WebComponents/./node_modules/btm-expressions/src/BTM_root.js"],"sourcesContent":["/*!\n * menv JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/menv\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* *********************************************************************************\n**  Dealing with identities and reductions.\n********************************************************************************* */\n\nimport {MENV, exprType, exprValue } from \"./BTM_root.js\";\n\nclass Identity {\n    constructor(refExpr, eqExpr, description, isValid, idNum) {\n        this.refExpr = refExpr;\n        this.eqExpr = eqExpr;\n        this.description = description;\n        this.isValid = isValid;\n        this.isActive = true;\n        this.idNum = idNum;\n    }\n}\n\nclass Match {\n    constructor(testRule, bindings) {\n        // Find unbound variables.\n        var allVars = testRule.eqExpr.dependencies(),\n            missVars = [];\n        for (var j in allVars) {\n            if (typeof bindings[allVars[j]] == 'undefined') {\n                missVars.push(allVars[j]);\n            }\n        }\n        for (var j in missVars) {\n            bindings[missVars[j]] = \"input\"+(+j+1)+\"\";\n        }\n        this.subExpr = testRule.eqExpr.compose(bindings);\n\n        this.subTeX = this.subExpr.toTeX();\n        this.subStr = this.subExpr.toString();\n        this.name = testRule.description;\n        if (this.subExpr.type == exprType.binop && this.subExpr.valueType == exprValue.bool) {\n            this.equation = testRule.refExpr.toTeX() + \" \\\\iff \" + testRule.eqExpr.toTeX();\n        } else {\n            this.equation = testRule.refExpr.toTeX() + \"=\" + testRule.eqExpr.toTeX();\n        }\n        this.bindings = bindings;\n        this.numInputs = missVars.length;\n        this.ruleID = testRule.idNum;\n    }\n}\n\n\n\nexport function newRule(menv, reductionList, equation, description, isValid, useOneWay, constraints) {\n    var exprFormulas = equation.split('==');\n    if (exprFormulas.length != 2) {\n        console.log(\"Invalid equation in identity list: \" + equation);\n    } else {\n        for (var refID=0; refID <= 1; refID++) {\n            if (refID == 1 && typeof useOneWay != 'undefined' && useOneWay) {\n                break;\n            }\n            var identity;\n\n            var refExpr = menv.parse(exprFormulas[refID],\"formula\");\n            var eqExpr = menv.parse(exprFormulas[1-refID],\"formula\");\n            var numVars = refExpr.dependencies().length;\n            var allRefExpr = [exprFormulas[refID]];\n            // this is a big slow down, so just make sure each rule is written in multiple ways.\n            //      var allRefExpr = refExpr.allStringEquivs();\n\n            var uniqueExpr = [];\n            for (var i in allRefExpr) {\n                var nextExpr = menv.parse(allRefExpr[i],\"formula\");\n                var isNew = true;\n                for (var j in uniqueExpr) {\n                    var bindings = uniqueExpr[j].match(nextExpr, {});\n                    if (bindings !== null) {\n                        isNew = false;\n                    }\n                }\n                if (isNew) {\n                    var ruleID = reductionList.length+1;\n                    identity = new Identity(nextExpr, eqExpr, description, isValid, ruleID);\n                    reductionList.push(identity);\n                    uniqueExpr.push(nextExpr);\n                }\n            }\n        }\n    }\n}\n\n// Disable a rule in the list.\nexport function disableRule(menv, reductionList, equation) {\n  // Match only on refExpr.\n  var exprFormulas = equation.split('==');\n  var refExpr, eqExpr;\n  if (exprFormulas.length > 2) {\n    console.log(\"Invalid equation in identity list: \" + equation);\n    return;\n  } else {\n    refExpr = menv.parse(exprFormulas[0],\"formula\");\n  }\n  for (var i in reductionList) {\n    var testRule = reductionList[i];\n    var bindings = testRule.refExpr.match(refExpr, {})\n    if (bindings !== null) {\n      reductionList[i].isActive = false;\n    }\n}\n}\n\n/* *******************\n** Given a list of reduction rules and a given expression,\n** test each reduction rule to see if it matches the structure.\n** Create an array of new objects with bindings stating what\n** substitutions are necessary to make the matches.\n******************* */\nexport function findMatchRules(reductionList, testExpr, doValidate) {\n    var matchList = [];\n    var i, testRule;\n    for (i in reductionList) {\n        testRule = reductionList[i];\n        var bindings = testRule.refExpr.match(testExpr, {})\n        if (testRule.isActive && bindings !== null) {\n            var match = new Match(testRule, bindings);\n            matchList.push(match);\n        }\n    }\n    return(matchList);\n}\n\n\nexport function defaultReductions(menv) {\n    var reduceRules = new Array();\n\n    newRule(menv, reduceRules, '0+x==x', 'Additive Identity', true, true);\n    newRule(menv, reduceRules, 'x+0==x', 'Additive Identity', true, true);\n    newRule(menv, reduceRules, '0-x==-x', 'Additive Inverse', true, true);\n    newRule(menv, reduceRules, 'x-0==x', 'Additive Identity', true, true);\n    newRule(menv, reduceRules, 'x+-(0)==x', 'Additive Identity', true, true);\n    newRule(menv, reduceRules, '0*x==0', 'Multiply by Zero', true, true);\n    newRule(menv, reduceRules, 'x*0==0', 'Multiply by Zero', true, true);\n    newRule(menv, reduceRules, '1*x==x', 'Multiplicative Identity', true, true);\n    newRule(menv, reduceRules, 'x*1==x', 'Multiplicative Identity', true, true);\n    newRule(menv, reduceRules, '0/x==0', 'Multiply by Zero', true, true);\n    newRule(menv, reduceRules, 'x/1==x', 'Divide by One', true, true);\n    newRule(menv, reduceRules, 'x^1==x', 'First Power', true, true);\n    newRule(menv, reduceRules, 'x^0==1', 'Zero Power', true, true);\n    newRule(menv, reduceRules, 'x^(-a)==1/(x^a)', 'Negative Power', true, true);\n    newRule(menv, reduceRules, '1^x==1', 'One to a Power', true, true);\n    newRule(menv, reduceRules, '-1*x==-x', 'Multiplicative Identity', true, true);\n    newRule(menv, reduceRules, 'x*-1==-x', 'Multiplicative Identity', true, true);\n    newRule(menv, reduceRules, 'x-x==0', 'Additive Inverses Cancel', true, true);\n    newRule(menv, reduceRules, 'x+-x==0', 'Additive Inverses Cancel', true, true);\n    newRule(menv, reduceRules, '-x+x==0', 'Additive Inverses Cancel', true, true);\n    newRule(menv, reduceRules, 'x+(-y)==x-y', \"Subtraction\", true, true);\n    newRule(menv, reduceRules, '(-x)+(-y)==-(x+y)', \"Factor Negation from Addition\", true, true);\n    newRule(menv, reduceRules, 'x-(-y)==x+y', \"Additive Inverse's Inverse\", true, true);\n    newRule(menv, reduceRules, 'x*(-y)==(-x)*y', \"Factor Negation from Multiplication\", true, true);\n    newRule(menv, reduceRules, '(-x)/y==-(x/y)', \"Factor Negation from Multiplication\", true, true);\n    newRule(menv, reduceRules, 'x/(-y)==-(x/y)', \"Factor Negation from Multiplication\", true, true);\n    newRule(menv, reduceRules, '-(-x)==x', \"Additive Inverse's Inverse\", true, true);\n    newRule(menv, reduceRules, '/(/x)==x', \"Multiplicative Inverse's Inverse\", true, true);\n\n    return(reduceRules);\n}\n\nexport function defaultSumReductions(menv) {\n    var sumReductions = new Array();\n\n    newRule(menv, sumReductions, 'a+0==a', 'Simplify Addition by Zero', true, true);\n    newRule(menv, sumReductions, '0+a==a', 'Simplify Addition by Zero', true, true);\n    newRule(menv, sumReductions, 'a-a==0', 'Cancel Additive Inverses', true, true);\n    newRule(menv, sumReductions, 'a+-a==0', 'Cancel Additive Inverses', true, true);\n    newRule(menv, sumReductions, '-a+a==0', 'Cancel Additive Inverses', true, true);\n    newRule(menv, sumReductions, 'a*b+-a*b==0', 'Cancel Additive Inverses', true, true);\n    newRule(menv, sumReductions, '-a*b+a*b==0', 'Cancel Additive Inverses', true, true);\n    newRule(menv, sumReductions, 'a*(b+c)==a*b+a*c', 'Expand Products by Distributing', true, true);\n    newRule(menv, sumReductions, '(a+b)*c==a*c+b*c', 'Expand Products by Distributing', true, true);\n    newRule(menv, sumReductions, 'a*(b-c)==a*b-a*c', 'Expand Products by Distributing', true, true);\n    newRule(menv, sumReductions, '(a-b)*c==a*c-b*c', 'Expand Products by Distributing', true, true);\n\n    return(sumReductions);\n}\n\nexport function defaultProductReductions(menv) {\n    var productReductions = new Array();\n\n    newRule(menv, productReductions, '0*a==0', 'Simplify Multiplication by Zero', true, true);\n    newRule(menv, productReductions, 'a*0==0', 'Simplify Multiplication by Zero', true, true);\n    newRule(menv, productReductions, '1*a==a', 'Simplify Multiplication by One', true, true);\n    newRule(menv, productReductions, 'a*1==a', 'Simplify Multiplication by One', true, true);\n    newRule(menv, productReductions, 'a/a==1', 'Cancel Multiplicative Inverses', true, true);\n    newRule(menv, productReductions, 'a*/a==1', 'Cancel Multiplicative Inverses', true, true);\n    newRule(menv, productReductions, '/a*a==1', 'Cancel Multiplicative Inverses', true, true);\n    newRule(menv, productReductions, '(a*b)/(a*c)==b/c', 'Cancel Common Factors', true,true);\n    newRule(menv, productReductions, 'a^m/a^n==a^(m-n)', 'Cancel Common Factors', true,true);\n    newRule(menv, productReductions, '(a^m*b)/(a^n*c)==(a^(m-n)*b)/c', 'Cancel Common Factors', true,true);\n    newRule(menv, productReductions, 'a*a==a^2', 'Write Products of Common Terms as Powers', true, true);\n    newRule(menv, productReductions, 'a*a^n==a^(n+1)', 'Write Products of Common Terms as Powers', true, true);\n    newRule(menv, productReductions, 'a^n*a==a^(n+1)', 'Write Products of Common Terms as Powers', true, true);\n    newRule(menv, productReductions, 'a^m*a^n==a^(m+n)', 'Write Products of Common Terms as Powers', true, true);\n    newRule(menv, productReductions, '(a^-m*b)/c==b/(a^m*c)', 'Rewrite Using Positive Powers', true,true);\n    newRule(menv, productReductions, '(b*a^-m)/c==b/(a^m*c)', 'Rewrite Using Positive Powers', true,true);\n    newRule(menv, productReductions, 'b/(a^-m*c)==(a^m*b)/c', 'Rewrite Using Positive Powers', true,true);\n    newRule(menv, productReductions, 'b/(c*a^-m)==(a^m*b)/c', 'Rewrite Using Positive Powers', true,true);\n\n    return (productReductions);\n  }","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\nimport { MENV, exprType, exprValue } from \"./BTM_root.js\"\nimport { findMatchRules } from \"./reductions.js\"\nimport { create_scalar } from \"./scalar_expr.js\"\n\nexport class MathObject {\n    constructor(menv) {\n        this.menv = menv;\n\n        this.select = false;\n        this.parent = null;\n        this.inputs = [];\n        this.valueType = exprValue.undef;\n        this.context = undefined;\n    }\n    \n    // Method to *evaluate* the object.\n    // - Return undefined\n    value(bindings) {\n    }\n    \n    // Update context setting\n    setContext(context) {\n        this.context = context;\n        // Update context on inputs.\n        for (var i in this.inputs) {\n            this.inputs[i].setContext(context);\n        }\n    }\n\n    // When the parser throws an error, need to record it.\n    setParsingError(errorString) {\n        this.parseError = errorString;\n    }\n\n    // Errors from parsing. Check all possible children (recursively)\n    hasParsingError() {\n        var retValue = false,\n            i = 0;\n        if (this.parseError) {\n            retValue = true;\n        }\n\n        while (!retValue && i < this.inputs.length) {\n            // Check for reductions on inputs.\n            retValue = this.inputs[i].hasParsingError();\n            i++;\n        }\n        return retValue;\n    }\n    \n    // Errors from parsing. Find the *first* error in the parsing process.\n    getParsingError() {\n        var errString = this.parseError;\n        var i=0;\n        while (!errString && i < this.inputs.length) {\n            errString = this.inputs[i].getParsingError();\n        }\n        return (errString);\n    }\n    \n    // Method to generate the expression as input-style string.\n    toString(elementOnly) {\n        if (typeof elementOnly == 'undefined') {\n            elementOnly = false;\n        }\n        var theStr = '';\n        return(theStr);\n    }\n    \n    // Method to generate the expression using presentation-style (LaTeX)\n    // - showSelect is so that part of the expression can be highlighted\n    toTeX(showSelect) {\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n        return(this.toString());\n    }\n\n    // Method to represent the expression using MathML\n    toMathML() {\n        return(\"<mi>\" + this.toString() + \"</mi>\");\n    }\n    \n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        return([]);\n    }\n    \n    // To convert binary tree structure to n-ary tree for supported operations (+ and *)\n    // Most things can't flatten. Return a copy.\n    flatten() {\n        return this.copy();\n    }\n    \n    // Test if the expression evaluates to a constant.\n    isConstant() {\n        var retValue = false;\n        return(retValue);\n    }\n    \n    // Test if the expression evaluates to a constant.\n    isExpression() {\n        var retValue = false;\n        return(retValue);\n    }\n\n}\n\nexport class expression extends MathObject {\n  constructor(menv) {\n        super(menv);\n        this.select = false;\n        this.parent = null;\n        this.inputs = [];\n        this.valueType = exprValue.numeric;\n    }\n\n    // Method to *evaluate* the value of the expression using given symbol bindings.\n    // - Return native Number value\n    value(bindings) {\n        return(this.evaluate(bindings));\n    }\n\n    // When the parser throws an error, need to record it.\n    setParsingError(errorString) {\n        this.parseError = errorString;\n    }\n\n    // Errors from parsing. Check all possible children (recursively)\n    hasParsingError() {\n        var retValue = false,\n            i = 0;\n        if (this.parseError) {\n            retValue = true;\n        }\n\n        while (!retValue && i < this.inputs.length) {\n            // Check for reductions on inputs.\n            retValue = this.inputs[i].hasParsingError();\n            i++;\n        }\n        return retValue;\n    }\n\n    // Errors from parsing. Find the *first* error in the parsing process.\n    getParsingError() {\n        var errString = this.parseError;\n        var i=0;\n        while (!errString && i < this.inputs.length) {\n            errString = this.inputs[i].getParsingError();\n        }\n        return (errString);\n    }\n\n    // Method to generate the expression as input-style string.\n    toString(elementOnly) {\n        if (typeof elementOnly == 'undefined') {\n            elementOnly = false;\n        }\n        var theStr = '';\n        return(theStr);\n    }\n\n    // Method to generate the expression using presentation-style (LaTeX)\n    // - showSelect is so that part of the expression can be highlighted\n    toTeX(showSelect) {\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n        return(this.toString());\n    }\n\n    // Method to represent the expression using MathML\n    toMathML() {\n        return(\"<mi>\" + this.toString() + \"</mi>\");\n    }\n\n    operateToTeX() {\n        return(this.toTeX());\n    }\n\n    treeToTeX(expand) {\n        var retStruct = {};\n        \n        retStruct.parent = (typeof this.parent === 'undefined' || this.parent === null) ? null : this.parent.operateToTeX();\n        if (typeof expand === 'undefined' || !expand) {\n            retStruct.current = this.toTeX();\n            retStruct.inputs = null;\n        } else {\n            retStruct.current = this.operateToTeX();\n            retStruct.inputs = [];\n            for (var i in this.inputs) {\n                retStruct.inputs[i] = this.inputs[i].toTeX();\n            }\n        }\n        return(retStruct);\n    }\n\n\n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        return([]);\n    }\n\n    // To convert binary tree structure to n-ary tree for supported operations (+ and *)\n    // Most things can't flatten. Return a copy.\n    flatten() {\n        return this.copy();\n    }\n\n    // Create a new expression that is a copy.\n    copy() {\n        var myCopy = new expression();\n        myCopy.valueType = this.valueType;\n        myCopy.context = this.context;\n        for (var i in this.inputs) {\n            myCopy.inputs[i] = myCopy.inputs[i].copy();\n            myCopy.inputs[i].parent = myCopy;\n        }\n        return myCopy;\n    }\n\n    // When subtree only involves constants, simplify the formula to a value.\n    // Default: Look at all descendants (inputs) and simplify there.\n    simplifyConstants() {\n        for (var i in this.inputs) {\n            this.inputs[i] = this.inputs[i].simplifyConstants();\n            this.inputs[i].parent = this;\n        }\n        return(this);\n    }\n\n    // Find all dependencies (symbols) required to evaluate expression.\n    dependencies(forced) {\n        var inDeps;\n        var i, j;\n        var depArray = new Array();\n\n        var master = {};\n        if (forced != undefined) {\n            for (var i=0; i<forced.length; i++) {\n                depArray.push(forced[i]);\n                master[forced[i]] = true;\n            }\n        }\n        for (i in this.inputs) {\n            inDeps = this.inputs[i].dependencies();\n            for (j in inDeps) {\n                if (typeof master[inDeps[j]] == \"undefined\") {\n                    depArray.push(inDeps[j]);\n                    master[inDeps[j]] = true;\n                }\n            }\n        }\n\n        return(depArray);\n    }\n\n    // Method to return input at given index.\n    getInput(whichInput) {\n        var inputExpr = null;\n        if (whichInput < 0 || whichInput >= this.inputs.length) {\n            throw 'Attempt to get an undefined input expression.';\n        } else {\n            inputExpr = this.inputs[whichInput];\n        }\n        return(inputExpr);\n    }\n\n    // Test if the expression evaluates to a constant.\n    isConstant() {\n        var retValue = true;\n        for (var i in this.inputs) {\n            retValue = retValue & this.inputs[i].isConstant();\n        }\n        return(retValue);\n    }\n\n    // Evaluate the expression given the bindings to symbols.\n    evaluate(bindings) {\n        return(0);\n    }\n\n    // Create a *new* expression where a symbol is *replaced* by a bound expression\n    compose(bindings) {\n        return(new expression());\n    }\n\n    // Compare *this* expression to a given *testExpr*.\n    // *options* gives options associated with testing (e.g., relative tolerance)\n    // but also supports fixing certain bindings.\n    // Supports abstract input matching against variables using *matchInputs*\n    compare(testExpr, options, matchInputs) {\n        var isEqual = true;\n        var i, n;\n\n        if (matchInputs == undefined) {\n            matchInputs = false;\n        }\n        if (options == undefined) {\n            options = this.menv.options;\n        }\n        var knownBindings = Object.keys(options);\n        var unknownBindings = [];\n\n        var rTol = 1e-8;\n        if (typeof options.rTol !== 'undefined') {\n            rTol = options.rTol;\n            i = knownBindings.indexOf('rTol');\n            knownBindings.splice(i, 1);\n        }\n\n        var dependA = this.dependencies();\n        var dependB = testExpr.dependencies();\n\n        for (i=0; i<dependA.length; i++) {\n            if (knownBindings.indexOf(dependA[i]) < 0\n                && unknownBindings.indexOf(dependA[i]) < 0)\n            {\n                unknownBindings.push(dependA[i]);\n            }\n        }\n        for (i=0; i<dependB.length; i++) {\n            if (knownBindings.indexOf(dependB[i]) < 0\n                && unknownBindings.indexOf(dependB[i]) < 0)\n            {\n                unknownBindings.push(dependB[i]);\n            }\n        }\n\n        // Create the arrays of test points.\n        var variableList = [];\n        var testPointList = [];\n        var x, xOpt, xMin, xMax, dx, n, testPoints;\n        n = 10;\n        for (i=0; i<knownBindings.length; i++) {\n            x = knownBindings[i];\n            xOpt = options[x];\n            xMin = xOpt.min;\n            xMax = xOpt.max;\n            dx = (xMax-xMin)/n;\n            testPoints = [];\n            for (var j=0; j<n; j++) {\n                testPoints[j] = xMin+j*dx;\n            }\n            testPoints[n] = xMax;\n\n            // Add this to the list of testing arrays.\n            variableList.push(x);\n            testPointList.push(testPoints);\n        }\n        for (i=0; i<unknownBindings.length; i++) {\n            x = unknownBindings[i];\n            xMin = -2;\n            xMax = 2;\n            dx = (xMax-xMin)/n;\n            testPoints = [];\n            for (var j=0; j<n; j++) {\n                testPoints[j] = xMin+j*dx;\n            }\n            testPoints[n] = xMax;\n\n            // Add this to the list of testing arrays.\n            variableList.push(x);\n            testPointList.push(testPoints);\n        }\n\n        // Now we will proceed through all possible points.\n        // Analogy: Each variable is like one \"digit\" on an odometer.\n        // Go through full cycle of a variable's options and then advance the next variable.\n        // Use an odometer-like array that references which point from\n        // each list is being used. When the last entry reaches the end,\n        // the odometer rolls over until all entries are done.\n        var odometer = [];\n        for (i=0; i<variableList.length; i++)\n            odometer[i]=0;\n        var done = false;\n        while (!done && isEqual) {\n            var y1, y2;\n            var bindings = {};\n            for (i=0; i<variableList.length; i++) {\n                x = variableList[i];\n                bindings[x] = testPointList[i][odometer[i]];\n            }\n            y1 = this.evaluate(bindings);\n            y2 = testExpr.evaluate(bindings);\n            // Both finite? Check for relative error.\n            if (isFinite(y1) && isFinite(y2)) {\n                if (!(Math.abs(y1)<1e-12 && Math.abs(y2)<1e-12)\n                    && Math.abs(y1-y2)/Math.abs(y1)>rTol) {\n                    isEqual = false;\n                }\n                // If one is finite, other must be NaN\n                } else if ( (isFinite(y1) && !isNaN(y2))\n                            || (isFinite(y2) && !isNaN(y1)) ) {\n                    isEqual = false;\n                }\n\n                // Advance the odometer.\n                var j=0;\n                done = true; // This will only persist when the odometer is done.\n                while (j < variableList.length) {\n                    odometer[j]++;\n                    if (odometer[j] >= testPointList[j].length) {\n                        odometer[j] = 0;\n                        j++;\n                    } else {\n                        done = false;\n                        break;\n                    }\n                }\n            }\n            if (matchInputs && isEqual) {\n                var matchOp;\n                if (this.op == '+' || this.op == '-') {\n                    matchOp = '+';\n                } else if (this.op == '*' || this.op == '/') {\n                    matchOp = '*';\n                }\n                if ((matchOp=='+' && testExpr.op != '+' && testExpr.op != '-')\n                    || (matchOp=='*' && testExpr.op != '*' && testExpr.op != '/')) {\n                    isEqual = false;\n                }\n                if (isEqual) {\n                    var flatA, flatB;\n                    flatA = this.flatten();\n                    flatB = testExpr.flatten();\n                    if (flatA.inputs.length == flatB.inputs.length) {\n                    var inputMatched = [];\n                    for (i=0; i<flatA.inputs.length; i++) {\n                        inputMatched[i] = false;\n                    }\n                    // Go through each input of testExpr and see if it matches on of this inputs.\n                    for (i=0; i<flatB.inputs.length && isEqual; i++) {\n                        var matchFound = false;\n                        for (j=0; j<flatA.inputs.length && !matchFound; j++) {\n                            if (!inputMatched[j] && flatA.inputs[j].compare(flatB.inputs[i], options)) {\n                                inputMatched[j] = true;\n                                matchFound = true;\n                            }\n                        }\n                        if (!matchFound) {\n                            isEqual = false;\n                        }\n                    }\n                } else {\n                    isEqual = false;\n                }\n            }\n        }\n        return(isEqual);\n    }\n\n    // Apply reduction rules to create a reduced expression\n    reduce() {\n        var workExpr = this.copy();\n        var matchRules;\n\n        // Check for reductions on inputs.\n        for (var i in workExpr.inputs) {\n            workExpr.inputs[i] = workExpr.inputs[i].reduce();\n        }\n        matchRules = findMatchRules(this.menv.reduceRules, workExpr, true);\n        while (matchRules.length > 0) {\n            workExpr = matchRules[0].subExpr;\n            matchRules = findMatchRules(this.menv.reduceRules, workExpr, true);\n        }\n        return workExpr;\n    }\n\n    \n    derivative(ivar, varList) {\n        return(create_scalar(0));\n    }\n\n    /*\n        The match method is designed to compare \"this\" expression\n        to the given \"expr\" expression and see if it is consistent with\n        the current bindings. The bindings will be an object where\n        variables in \"this\" are assigned to strings representing expressions.\n        If there is a mismatch, return \"null\" and the matching process should terminate.\n\n        Overrides:\n            - numbers, to deal with scalar formula that simplify\n            - variables, which can match arbitrary expressions.\n            - indexed expressions might need a special method.\n            - multiop, where should see if a variable can match a subcollection of inputs.\n    */\n    match(expr, bindings) {\n        var retValue = null;\n        if (this.type == expr.type && this.operateToTeX() == expr.operateToTeX()) {\n            retValue = bindings;\n            for (var i=0; i<this.inputs.length; i++) {\n                if (retValue !== null) {\n                    retValue = this.inputs[i].match(expr.inputs[i], retValue);\n                }\n            }\n        }\n        return(retValue);\n    }\n\n    inputSubst(origExpr, subExpr) {\n        var i = this.inputs.indexOf(origExpr);\n        if (i >= 0) {\n            this.inputs[i] = subExpr;\n            if (subExpr !== undefined) {\n                subExpr.parent = this;\n            }\n        }\n    }\n}\n\n// Special class that can't match or be evaluated.\nexport class undef_expr extends expression {\n    constructor(menv) {\n        super(menv);\n        this.type = exprType.undef;\n        this.valueType = exprValue.undef;\n    }\n    value(bindings) {\n        return Number.NaN;\n    }\n    compare(testExpr, options, matchInputs) {\n        return false;\n    }\n    copy() {\n        return(new undef_expr(this.menv));\n    }\n    compose(bindings) {\n        return(new undef_expr(this.menv));\n    }\n    derivative(ivar, varList) {\n        return(new undef_expr(this.menv));\n    }\n    match(expr, bindings) {\n        return null;\n    }\n}  \n  ","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* *******************************\n** Define a generic class to work numbers\n******************************* */\n\nexport class real_number {\n    constructor(a) {\n      if (typeof a === 'number' || a instanceof Number) {\n        this.number = a;\n      } else if (a instanceof real_number) {\n        this.number = a.number;\n      }\n    }\n\n    // Return a numerical value of the rational expression.\n    value() {\n        return this.number;\n    }\n    \n    // Real numbers have no natural simplification, but declaring the method.\n    simplify() {\n    }\n\n    equal(other) {\n      if (typeof other === 'number') {\n        other = new real_number(other);\n      }\n        return (this.value()==other.value());\n    }\n\n    // Add numbers.\n    add(other) {\n      if (typeof other === 'number') {\n        other = new real_number(other);\n      }\n        var sum = new real_number(this.number + other.value());\n        return(sum);\n    }\n\n    // Subtract this - other\n    subtract(other) {\n      if (typeof other === 'number') {\n        other = new real_number(other);\n      }\n        var sum = new real_number(this.number - other.value());\n        return(sum);\n    }\n\n    // Multiply this rational by another rational number and create new object.\n    multiply(other) {\n      if (typeof other === 'number') {\n        other = new real_number(other);\n      }\n        var product = new real_number(this.number * other.value());\n        return(product);\n    }\n\n    // Divide this rational by another rational number and create new object.\n    divide(other) {\n      if (typeof other === 'number') {\n        other = new real_number(other);\n      }\n        var product;\n        if (other.value != 0) {\n            product = new real_number(this.number / other.value());\n        } else {\n            product = new real_number(NaN);\n        }\n        return(product);\n    }\n\n    // Additive Inverse\n    addInverse() {\n        var inverse = new real_number(-this.number);\n        return(inverse);\n    }\n\n    // Multiplicative Inverse\n    multInverse() {\n        var inverse;\n        if (this.number != 0) {\n            inverse = new real_number(this.number);\n        } else {\n            inverse = new real_number(NaN);\n        }\n        return(inverse);\n    }\n\n    toString(leadSign) {\n        if (typeof leadSign == 'undefined') {\n            leadSign = false;\n        }\n        var str = (leadSign && this.number>0) ? '+' : '';\n        if (isNaN(this.number)) {\n            str = 'NaN';\n        } else {\n            str = str + Number(this.number.toFixed(10));\n        }\n  \n        return(str);\n    }\n  \n    // Format the rational number as TeX string.\n    toTeX(leadSign) {\n        if (typeof leadSign == 'undefined') {\n            leadSign = false;\n        }\n        var str = (leadSign && this.number>0) ? '+' : '';\n        if (isNaN(this.number)) {\n            str = '\\\\mathrm{NaN}';\n        } else {\n            str = str + Number(this.toString(leadSign));\n        }\n        return(str);\n    }\n\n    // Format as a root MathML element.\n    toMathML(leadSign) {\n        return(\"<cn>\" + this.toString() + \"</cn>\");\n    }\n}\n\n\n\n\n\n \n\n\n\n","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* *******************************\n** Define a class to work with rational numbers\n******************************* */\n\nimport { real_number } from \"./real_number.js\";\n\n/* Private utility commands. */\n  \nfunction isInt(x) {\n    var retValue = false;\n    if (Number.isInteger === undefined) {\n    retValue = (x == Math.floor(x));\n    } else {\n    retValue = Number.isInteger(x);\n    }\n    return retValue;\n}\n\n\n // Implement Euclid's algorithm.\n export function findGCD(a,b) {\n    var c;\n    a = Math.abs(a);\n    b = Math.abs(b);\n    if (a < b) {\n        c=a; a=b; b=c;\n    }\n\n    if (b == 0)\n        return 0;\n\n    // In this loop, we always have a > b.\n    while (b > 0) {\n        c = a % b;\n        a = b;\n        b = c;\n    }\n    return a;\n}\n\nexport class rational_number extends real_number {\n    constructor(p,q) {\n        if (q == undefined) {\n            super(p);\n            this.p = p;\n            this.q = 1;\n        } else {\n            super(p/q);\n            if (q == 0) {\n                this.p = Math.sqrt(-1);\n                this.q = 1;\n            } else if (p == 0) {\n                this.p = 0;\n                this.q = 1;\n            } else {\n                if (q < 0) {\n                  this.p = -p;\n                  this.q = -q;\n                } else {\n                  this.p = p;\n                  this.q = q;\n                }\n                this.simplify();\n            }\n        }\n    }\n\n    // Return a numerical value of the rational expression.\n    value() {\n        return (this.p/this.q);\n    }\n    \n    // Use Euclid's algorithm to find the gcd, then reduce\n    simplify() {\n        var a;\n\n        // Don't simplify if not ratio of integers.\n        if (this.p % 1 != 0 || this.q % 1 != 0) {\n        return;\n        }\n        a = findGCD(this.p, this.q);\n        this.p /= a;\n        this.q /= a;\n    }\n\n    equal(other) {\n        if (other instanceof rational_number) {\n            return (this.p.valueOf()==other.p.valueOf()\n                    && this.q.valueOf() == other.q.valueOf());\n        } else {\n            return (this.value()==other.value());\n        }\n    }\n\n    // Add to this rational another rational number and create new object.\n    add(other) {\n        var sum;\n        if (other instanceof rational_number) {\n        sum = new rational_number(this.p*other.q+other.p*this.q, this.q*other.q);\n        } else if (isInt(other)) {\n        sum = new rational_number(this.p+other*this.q, this.q);\n        } else {\n        sum = new real_number(this.value() + other);\n        }\n        return(sum);\n    }\n\n    // Subtract from this rational another rational number and create new object.\n    subtract(other) {\n        var sum;\n        if (other instanceof rational_number) {\n            sum = new rational_number(this.p*other.q-other.p*this.q, this.q*other.q);\n        } else if (isInt(other)) {\n            sum = new rational_number(this.p-other*this.q, this.q);\n        } else {\n            sum = new real_number(this.value() - other);\n        }\n        return(sum);\n    }\n\n    // Multiply this rational by another rational number and create new object.\n    multiply(other) {\n        var product;\n        if (other instanceof rational_number) {\n            product = new rational_number(this.p*other.p, this.q*other.q);\n        } else if (isInt(other)) {\n            product = new rational_number(this.p*other, this.q);\n        } else {\n            product = new real_number(this.value() * other);\n        }\n\n        return(product);\n    }\n\n    // Divide this rational by another rational number and create new object.\n    divide(other) {\n        var product;\n        if (other instanceof rational_number) {\n            product = new rational_number(this.p*other.q, this.q*other.p);\n        } else if (isInt(other)) {\n            product = new rational_number(this.p, this.q*other);\n        } else {\n            product = new real_number(this.value() / other);\n        }\n\n        return(product);\n    }\n\n    // Additive Inverse\n    addInverse() {\n        var inverse = new rational_number(-this.p, this.q);\n        return(inverse);\n    }\n\n    // Multiplicative Inverse\n    multInverse() {\n        var inverse;\n        if (this.p != 0) {\n            inverse = new rational_number(this.q, this.p);\n        } else {\n            inverse = new real_number(NaN);\n        }\n        return(inverse);\n    }\n\n    // Format the rational number as string.\n    toString(leadSign) {\n        if (typeof leadSign == 'undefined') {\n            leadSign = false;\n        }\n        var str = (leadSign && this.p>0) ? '+' : '';\n        if (isNaN(this.p)) {\n            str = 'NaN';\n        } else if (this.q == 1) {\n            str = str + this.p;\n        } else {\n            str = str + this.p + '/' + this.q;\n        }\n\n        return(str);\n    }\n\n    // Format the rational number as TeX string.\n    toTeX(leadSign) {\n        if (typeof leadSign == 'undefined') {\n            leadSign = false;\n        }\n        var str = (leadSign && this.p>0) ? '+' : '';\n        if (isNaN(this.p)) {\n            str = '\\\\mathrm{NaN}';\n        } else if (this.q == 1) {\n            str = str + this.p;\n        } else {\n            if (this.p < 0) {\n                str = '-\\\\frac{' + -this.p + '}{' + this.q + '}';\n            } else {\n                str = str + '\\\\frac{' + this.p + '}{' + this.q + '}';\n            }\n        }\n\n        return(str);\n    }\n\n    toMathML() {\n        if (typeof leadSign == 'undefined') {\n            leadSign = false;\n        }\n        var opAStr = \"<cn>\" + this.p + \"</cn>\",\n            opBStr = \"<cn>\" + this.q + \"</cn>\";\n\n        return(\"<cn>\" + this.toString() + \"</cn>\");\n\n        if (isNaN(this.p)) {\n            str = \"<cn>?</cn>\";\n        } else if (this.q == 1) {\n            str = opAStr;\n        } else {\n            str = \"<apply><divide/>\"+opAStr+opBStr+\"</apply>\";\n        }\n    }\n}\n\n\n\n\n\n \n\n\n\n","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***************************************************\n* Define the Multi-Operand Expression (for sum and product)\n* *************************************************** */\n\nimport { exprType, opPrec } from \"./BTM_root.js\"\nimport { expression } from \"./expression.js\"\nimport { create_scalar } from \"./scalar_expr.js\"\nimport { rational_number } from \"./rational_number.js\"\n\n// Do some preliminary testing to reduce the op if redundant inputs.\nexport function create_multiop(menv, op, inputs) {\n    var newInputs = [];\n    for (let i in inputs) {\n        if (inputs[i].type == exprType.multiop && inputs[i].op == op) {\n            newInputs.push(...inputs[i].inputs);\n        } else {\n            newInputs.push(inputs[i]);\n        }\n    }\n    return new multiop_expr(menv, op, newInputs);\n}\n\nexport class multiop_expr extends expression {\n    constructor(menv, op, inputs) {\n        super(menv);\n        this.type = exprType.multiop;\n        this.op = op;\n        this.inputs = inputs; // an array\n        for (var i in inputs) {\n            if (typeof inputs[i] == 'undefined')\n                inputs[i] = new expression(menv);\n            inputs[i].parent = this;\n        }\n        switch (op) {\n            case '+':\n                this.prec = opPrec.addsub;\n                break;\n            case '*':\n                this.prec = opPrec.multdiv;\n                break;\n            default:\n                alert(\"Unknown multi-operand operator: '\"+op+\"'.\");\n                break;\n        }\n    }\n\n    toString() {\n        var theStr,\n            opStr,\n            isError = false,\n            showOp;\n\n        theStr = '';\n        for (var i in this.inputs) {\n            showOp = true;\n            if (typeof this.inputs[i] == 'undefined') {\n                opStr = '?';\n                isError = true;\n            } else {\n                opStr = this.inputs[i].toString();\n                if ((this.inputs[i].type >= exprType.unop\n                        && this.inputs[i].prec <= this.prec)\n                    || (this.inputs[i].type == exprType.number\n                        && this.inputs[i].number.q != 1\n                        && opPrec.multdiv <= this.prec)\n                ) {\n                    opStr = '(' + opStr + ')';\n                }\n            }\n            theStr += ( i>0 ? this.op : '' ) + opStr;\n        }\n\n        return(theStr);\n    }\n\n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        var allInputsArrays = [];\n\n        var indexList = [];\n        for (var i in this.inputs) {\n            allInputsArrays[i] = this.inputs[i].allStringEquivs();\n            indexList.push(i);\n        }\n        var inputPerms = permutations(indexList);\n\n        var retValue = [];\n\n        var theOp = this.op;\n        if (theOp == '|') {\n            // Don't want \"or\" to be translated as absolute value\n            theOp = ' $ ';\n        }\n\n        function buildStringEquivs(indexList, leftStr) {\n            if (typeof leftStr == \"undefined\") {\n                leftStr = \"\";\n            } else if (indexList.length > 0) {\n                leftStr += theOp;\n            }\n            if (indexList.length > 0) {\n                var workInputs = allInputsArrays[indexList[0]];\n                for (var i in workInputs) {\n                    buildStringEquivs(indexList.slice(1), leftStr + \"(\" + workInputs[i] + \")\");\n                }\n            } else {\n                retValue.push(leftStr);\n            }\n        }\n\n        for (var i in inputPerms) {\n            buildStringEquivs(inputPerms[i]);\n        }\n\n        return(retValue);\n    }\n\n    toTeX(showSelect) {\n        var theStr;\n        var theOp;\n        var opStr;\n        var argStrL, argStrR, opStrL, opStrR;\n\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n\n        theOp = this.op;\n        if (this.op == '*') {\n            if (showSelect && this.select) {\n                theOp = '\\\\times';\n            } else {\n                theOp = ' ';\n            }\n        }\n\n        if (showSelect && this.select) {\n            argStrL = '{\\\\color{blue}';\n            argStrR = '}';\n            opStrL = '{\\\\color{red}';\n            opStrR = '}';\n        } else {\n            argStrL = '';\n            argStrR = '';\n            opStrL = '';\n            opStrR = '';\n        }\n\n        theStr = '';\n        var minPrec = this.prec;\n        for (var i in this.inputs) {\n            if (typeof this.inputs[i] == 'undefined') {\n                opStr = '?';\n                theStr += ( i>0 ? opStrL + theOp + opStrR : '' ) + opStr;\n            } else {\n                if (this.op == '*'\n                        && this.inputs[i].type == exprType.unop && this.inputs[i].op == '/'\n                        && !(showSelect && this.select))\n                {\n                    opStr = argStrL + this.inputs[i].inputs[0].toTeX(showSelect) + argStrR;\n                    if (this.inputs[i].inputs[0].type >= exprType.unop && this.inputs[i].inputs[0].prec < minPrec) {\n                        opStr = '\\\\left(' + opStr + '\\\\right)';\n                    }\n                    if (theStr == '') {\n                        theStr = '1'\n                    }\n                    theStr = '\\\\frac{' + theStr + '}{' + opStr + '}';\n\n                } else if (this.op == '+'\n                        && this.inputs[i].type == exprType.unop && this.inputs[i].op == '-'\n                        && !(showSelect && this.select))\n                {\n                    opStr = argStrL + this.inputs[i].toTeX(showSelect) + argStrR;\n                    theStr += opStr;\n                } else {\n                    opStr = argStrL + this.inputs[i].toTeX(showSelect) + argStrR;\n                    if ((this.inputs[i].type >= exprType.unop\n                            && this.inputs[i].prec <= minPrec)\n                        || (i>0 && this.op == '*' && this.inputs[i].type == exprType.number)) {\n                        opStr = '\\\\left(' + opStr + '\\\\right)';\n                    }\n                    theStr += ( i>0 ? opStrL + theOp + opStrR : '' ) + opStr;\n                }\n            }\n        }\n\n        return(theStr);\n    }\n\n    toMathML() {\n        var theStr;\n        var theOp;\n        var opStr;\n\n        switch (this.op) {\n            case '+':\n                theOp = \"<plus/>\"\n                break;\n            case '*':\n                theOp = \"<times/>\"\n                break;\n        }\n\n        theStr = \"<apply>\" + theOp;\n        for (var i in this.inputs) {\n            if (typeof this.inputs[i] == 'undefined') {\n                opStr = '?';\n            } else {\n                opStr = this.inputs[i].toMathML();\n            }\n            theStr += opStr;\n        }\n        theStr += \"</apply>\";\n\n        return(theStr);\n    }\n\n    operateToTeX() {\n        var opString = this.op;\n\n        switch (opString) {\n            case '*':\n                opString = '\\\\times';\n                break;\n        }\n\n        return(opString);\n    }\n\n    isCommutative() {\n        var commutes = false;\n        if (this.op === '+' || this.op === '*') {\n            commutes = true;\n        }\n        return(commutes);\n    }\n\n    evaluate(bindings) {\n        var inputVal;\n        var i;\n        var retVal;\n\n        switch (this.op) {\n            case '+':\n                retVal = 0;\n                for (i in this.inputs) {\n                    inputVal = this.inputs[i].evaluate(bindings);\n                    retVal += inputVal;\n                }\n                break;\n            case '*':\n                retVal = 1;\n                for (i in this.inputs) {\n                    inputVal = this.inputs[i].evaluate(bindings);\n                    retVal *= inputVal;\n                }\n                break;\n            default:\n                console.log(\"The binary operator '\" + this.op + \"' is not defined.\");\n                retVal = undefined;\n                break;\n        }\n        return(retVal);\n    }\n\n    // Flatten and also sort terms.\n    flatten() {\n        var newInputs = [];\n        for (var i in this.inputs) {\n            var nextInput = this.inputs[i].flatten();\n            if (nextInput.type == exprType.multiop && nextInput.op == this.op) {\n                for (var j in nextInput.inputs) {\n                    newInputs.push(nextInput.inputs[j]);\n                }\n            } else {\n                newInputs.push(nextInput);\n            }\n        }\n\n        var retValue;\n        if (newInputs.length == 0) {\n            // Adding no elements = 0\n            // Multiplying no elements = 1\n            retValue = create_scalar(this.menv, this.op == '+' ? 0 : 1);\n        } else if (newInputs.length == 1) {\n            retValue = newInputs[0];\n        } else {\n            // Sort the inputs by precedence for products\n            // Usually very small, so bubble sort is good enough\n            if (this.op=='*') {\n                var tmp;\n                for (var i=0; i<newInputs.length-1; i++) {\n                    for (var j=i+1; j<newInputs.length; j++) {\n                        if (newInputs[i].type > newInputs[j].type) {\n                            tmp = newInputs[i];\n                            newInputs[i] = newInputs[j];\n                            newInputs[j] = tmp;\n                        }\n                    }\n                }\n            }\n            retValue = create_multiop(this.menv, this.op, newInputs);\n        }\n        return(retValue);\n    }\n\n    // See if this operator is now redundant.\n    // Return the resulting expression.\n    reduce() {\n        var workExpr = super.reduce();\n        var newExpr = workExpr;\n        if (workExpr.type == exprType.multiop && workExpr.inputs.length <= 1) {\n            if (workExpr.inputs.length == 0) {\n                // Sum with no elements = 0\n                // Product with no elements = 1\n                newExpr = create_scalar(this.menv, workExpr.op == '+' ? 0 : 1);\n            } else {\n                // Sum or product with one element *is* that element.\n                newExpr = workExpr.inputs[0];\n            }\n            newExpr.parent = this.parent;\n            if (this.parent !== null) {\n                this.parent.inputSubst(this, newExpr);\n            }\n        }\n        return(newExpr);\n    }\n\n    simplifyConstants() {\n        var constIndex = [],\n            newInputs = [];\n        // Simplify all inputs\n        // Notice which inputs are themselves constant \n        for (let i in this.inputs) {\n            this.inputs[i] = this.inputs[i].simplifyConstants();\n            this.inputs[i].parent = this;\n            if (this.inputs[i].type == exprType.number ||\n                (this.inputs[i].type == exprType.unop && this.inputs[i].inputs[0].type == exprType.number)\n            ) {\n                constIndex.push(i);\n            } else {\n                newInputs.push(this.inputs[i]);\n            }\n        }\n\n        // For all inputs that are constants, group them together and simplify.\n        var newExpr = this;\n        if (constIndex.length > 1) {\n            var newConstant;\n            switch (this.op) {\n                case '+':\n                    newConstant = new rational_number(0);\n                    for (let i in constIndex) {\n                        if (this.inputs[constIndex[i]].type == exprType.number) {\n                            newConstant = newConstant.add(this.inputs[constIndex[i]].number);\n                        } else if (this.inputs[constIndex[i]].type == exprType.unop) {\n                            switch (this.inputs[constIndex[i]].op) {\n                                case '+':\n                                case '*':\n                                    newConstant = newConstant.add(this.inputs[constIndex[i]].inputs[0].number);\n                                    break;\n                                case '-':\n                                    newConstant = newConstant.subtract(this.inputs[constIndex[i]].inputs[0].number);\n                                    break;\n                                case '/':\n                                    newConstant = newConstant.add(this.inputs[constIndex[i]].inputs[0].number.multInverse());\n                                    break;\n                            }\n                        }\n                    }\n                    break;\n                case '*':\n                    newConstant = new rational_number(1);\n                    for (let i in constIndex) {\n                        if (this.inputs[constIndex[i]].type == exprType.number) {\n                            newConstant = newConstant.multiply(this.inputs[constIndex[i]].number);\n                        } else if (this.inputs[constIndex[i]].type == exprType.unop) {\n                            switch (this.inputs[constIndex[i]].op) {\n                                case '+':\n                                case '*':\n                                    newConstant = newConstant.multiply(this.inputs[constIndex[i]].inputs[0].number);\n                                    break;\n                                case '-':\n                                    newConstant = newConstant.multiply(this.inputs[constIndex[i]].inputs[0].number.addInverse());\n                                    break;\n                                case '/':\n                                    newConstant = newConstant.divide(this.inputs[constIndex[i]].inputs[0].number);\n                                    break;\n                            }\n                        }\n                    }\n                    break;\n            }\n\n            // For addition, the constant goes to the end.\n            // For multiplication, the constant goes to the beginning.\n            var newInput;\n            switch (this.op) {\n                case '+':\n                    newInputs.push(newInput = create_scalar(this.menv, newConstant));\n                    break;\n                case '*':\n                    newInputs.splice(0, 0, newInput = create_scalar(this.menv, newConstant));\n                    break;\n            }\n            if (newInputs.length == 1) {\n                newExpr = newInputs[0];\n            } else {\n                newInput.parent = this;\n                newExpr = create_multiop(this.menv, this.op, newInputs);\n            }\n        }\n        return(newExpr);\n    }\n\n    // This comparison routine needs to deal with two issues.\n    // (1) The passed expression has more inputs than this (in which case we group them)\n    // (2) Possibility of commuting makes the match work.\n    match(expr, bindings) {\n        function copyBindings(bindings)\n        {\n            var retValue = {};\n            for (var key in bindings) {\n                retValue[key] = bindings[key];\n            }\n            return(retValue);\n        }\n\n        var retValue = null,\n            n = this.inputs.length;\n        if ((expr.type == exprType.multiop || expr.type == exprType.binop)\n            && this.op == expr.op && n <= expr.inputs.length) {\n\n            // Match on first n-1 and group remainder at end.\n            var cmpExpr,\n                cmpInputs = [];\n\n            for (var i=0; i<n; i++) {\n                if (i<(n-1) || expr.inputs.length==n) {\n                    cmpInputs[i] = expr.inputs[i].copy();\n                } else {\n                    // Create copies of the inputs\n                    var newInputs = [];\n                    for (var j=0; j<=expr.inputs.length-n; j++) {\n                        newInputs[j] = expr.inputs[n+j-1].copy();\n                    }\n                    cmpInputs[i] = create_multiop(this.menv, expr.op, newInputs);\n                }\n            }\n            cmpExpr = create_multiop(this.menv, expr.op, cmpInputs);\n\n            // Now make the comparison.\n            retValue = copyBindings(bindings);\n            retValue = expression.prototype.match.call(this, cmpExpr, retValue);\n\n            // If still fail to match, try the reverse grouping: match on last n-1 and group beginning.\n            if (retValue == null && n < expr.inputs.length) {\n                var diff = expr.inputs.length - n;\n                cmpInputs = [];\n\n                for (var i=0; i<n; i++) {\n                    if (i==0) {\n                        // Create copies of the inputs\n                        var newInputs = [];\n                        for (var j=0; j<=diff; j++) {\n                            newInputs[j] = expr.inputs[j].copy();\n                        }\n                        cmpInputs[i] = create_multiop(this.menv, expr.op, newInputs);\n                    } else {\n                        cmpInputs[i] = expr.inputs[diff+i].copy();\n                    }\n                }\n                cmpExpr = create_multiop(this.menv, expr.op, cmpInputs);\n\n                // Now make the comparison.\n                retValue = copyBindings(bindings);\n                retValue = expression.prototype.match.call(this, cmpExpr, retValue);\n            }\n        }\n        return(retValue);\n    }\n\n    copy() {\n        var newInputs = new Array();\n        for (var i in this.inputs) {\n            newInputs.push(this.inputs[i].copy());\n        }\n        return (create_multiop(this.menv, this.op, newInputs));\n      }\n\n    compose(bindings) {\n        var newInputs = [];\n\n        for (var i in this.inputs) {\n            newInputs.push(this.inputs[i].compose(bindings));\n        }\n\n        var retValue;\n        if (newInputs.length == 0) {\n            retValue = create_scalar(this.menv, this.op == '+' ? 0 : 1);\n        } else if (newInputs.length == 1) {\n            retValue = newInputs[0];\n        } else {\n            retValue = create_multiop(this.menv, this.op, newInputs);\n        }\n        return(retValue);\n    }\n\n    derivative(ivar, varList) {\n        var dTerms = [];\n\n        var theDeriv;\n        var i, dudx;\n        for (i in this.inputs) {\n            if (!this.inputs[i].isConstant()) {\n                dudx = this.inputs[i].derivative(ivar, varList);\n                switch (this.op) {\n                    case '+':\n                        dTerms.push(dudx);\n                        break;\n                    case '*':\n                        var dProdTerms = [];\n                        for (let j in this.inputs) {\n                            if (i == j) {\n                                dProdTerms.push(dudx);\n                            } else {\n                                dProdTerms.push(this.inputs[j].compose({}));\n                            }\n                        }\n                        dTerms.push(create_multiop(this.menv, '*', dProdTerms));\n                        break;\n                }\n            }\n        }\n        if (dTerms.length == 0) {\n            theDeriv = create_scalar(this.menv, 0);\n        } else if (dTerms.length == 1) {\n            theDeriv = dTerms[0];\n        } else {\n            theDeriv = create_multiop(this.menv, '+', dTerms);\n        }\n        return(theDeriv);\n    }\n}","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***************************************************\n* Define the Variable Expression -- a value defined by a name\n* *************************************************** */\nimport { expression } from \"./expression.js\"\nimport { create_scalar } from \"./scalar_expr.js\"\nimport { exprType, exprValue } from \"./BTM_root.js\"\n\nexport class variable_expr extends expression {\n    constructor(menv, name) {\n        super(menv);\n        this.type = exprType.variable;\n        this.name = name;\n\n        // Count how many derivatives.\n        var primePos = name.indexOf(\"'\");\n        this.derivs = 0;\n        if (primePos > 0) {\n            this.derivs = name.slice(primePos).length;\n        }\n\n        this.isConst = false;\n        this.isSpecial = false;\n        switch(this.name) {\n            case 'e':\n            case 'pi':\n            case 'dne':\n            case 'inf':\n                this.isConst = true;\n                this.isSpecial = true;\n                break;\n        }\n    }\n\n    toString(elementOnly) {\n        if (typeof elementOnly == 'undefined') {\n            elementOnly = false;\n        }\n        return(this.name);\n    }\n\n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        return([this.toString()]);\n    }\n\n    toTeX(showSelect) {\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n        var str = this.toString();\n\n        switch (this.name) {\n            case 'alpha':\n            case 'beta':\n            case 'gamma':\n            case 'delta':\n            case 'epsilon':\n            case 'zeta':\n            case 'eta':\n            case 'theta':\n            case 'kappa':\n            case 'lambda':\n            case 'mu':\n            case 'nu':\n            case 'xi':\n            case 'pi':\n            case 'rho':\n            case 'sigma':\n            case 'tau':\n            case 'upsilon':\n            case 'phi':\n            case 'chi':\n            case 'psi':\n            case 'omega':\n            case 'Gamma':\n            case 'Delta':\n            case 'Theta':\n            case 'Lambda':\n            case 'Xi':\n            case 'Pi':\n            case 'Sigma':\n            case 'Upsilon':\n            case 'Phi':\n            case 'Psi':\n            case 'Omega':\n                str = '\\\\' + this.name;\n                break;\n            case 'inf':\n                str = '\\\\infty';\n                break;\n            default:\n                if (this.isSpecial) {\n                    str = '\\\\mathrm{' + this.name + '}';\n                }\n                break;\n        }\n        if (this.name.indexOf(\"input\")==0) {\n            str = \"\\\\boxed{\\\\dots?^{\" + this.name.slice(5) + \"}}\";\n        }\n\n        if (showSelect && this.select) {\n            str = \"{\\\\color{red}\" + str + \"}\";\n        }\n        return(str);\n    }\n\n    dependencies(forced) {\n        var depArray = new Array();\n        if (forced != undefined) {\n            for (var i=0; i<forced.length; i++) {\n                depArray.push(forced[i]);\n            }\n        }\n        if (!this.isConst && depArray.indexOf(this.name) < 0) {\n            depArray.push(this.name);\n        }\n        return(depArray);\n    }\n\n    /*\n        A variable is constant only if referring to mathematical constants (e, pi)\n    */\n    isConstant() {\n        return(this.isConst);\n    }\n\n    evaluate(bindings) {\n        var retVal;\n\n        if (bindings[this.name] == undefined) {\n            switch(this.name) {\n                case 'e':\n                    retVal = Math.E;\n                    break;\n                case 'pi':\n                    retVal = Math.PI;\n                    break;\n                case 'inf':\n                    retVal = Infinity;\n                    break;\n                case 'dne':\n                    retVal = Number.NaN;\n                    break;\n                default:\n                    console.log(\"Variable evaluated without binding.\")\n                    break;\n            }\n        } else {\n            if (typeof bindings[this.name].value === 'function') {\n                retVal = bindings[this.name].value();\n            } else {\n                retVal = bindings[this.name];\n            }\n        }\n\n        return(retVal);\n    }\n\n    copy() {\n        return(new variable_expr(this.menv, this.name));\n    }\n\n    compose(bindings) {\n        var retVal;\n\n        if (bindings[this.name] == undefined) {\n            retVal = new variable_expr(this.menv, this.name);\n        } else {\n            retVal = bindings[this.name];\n        }\n\n        return(retVal);\n    }\n\n    derivative(ivar, varList) {\n        var retVal;\n        var ivarName = (typeof ivar == 'string') ? ivar : ivar.name;\n\n        if (this.name === ivarName) {\n            retVal = create_scalar(this.menv, 1);\n\n        // If either a constant or another independent variable, deriv=0\n        } else if (this.isConst || varList && varList[this.name] != undefined) {\n            retVal = create_scalar(this.menv, 0);\n\n        // Presuming other variables are dependent variables.\n        } else  {\n            retVal = new variable_expr(this.menv, this.name+\"'\");\n        }\n        return(retVal);\n    }\n\n    /*\n        See expressions.prototype.match for explanation.\n\n        A variable can match any expression. But we need to check\n        if the variable has already matched an expression. If so,\n        it must be the same again.\n    */\n    match(expr, bindings) {\n        var retValue = null;\n\n        // Special named constants can not match expressions.\n        if (this.isConst) {\n            if (expr.toString() === this.name) {\n                retValue = bindings;\n            }\n\n        // If never previously assigned, can match any expression.\n        } else if (bindings != null && bindings[this.name] == undefined && expr.valueType == exprValue.numeric) {\n            retValue = bindings;\n            retValue[this.name] = expr.copy();\n        } else if (bindings != null && bindings[this.name].toString() === expr.toString()) {\n            retValue = bindings;\n        }\n\n        return(retValue);\n    }\n}\n\n    /* ***************************************************\n    * Define the Index Expression -- a reference into a list\n    * *************************************************** */\n\nexport class index_expr {\n    \n    constructor(name, index) {\n        this.type = exprType.variable;\n        this.name = name;\n        this.select = false;\n        this.boundName = \"[]\"+name;\n        this.parent = null;\n        this.index = index;\n        var depArray = index.dependencies();\n        if (depArray.length > 1) {\n            alert(\"An array reference can only have one index variable.\");\n        } else {\n            this.k = depArray[0];\n        }\n    }\n\n    toString(elementOnly) {\n        if (typeof elementOnly == 'undefined') {\n            elementOnly = false;\n        }\n        return(this.name + \"[\" + this.index.toString() + \"]\");\n    }\n\n    toTeX(showSelect) {\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n        word = this.name + \"_{\" + this.index.toString() + \"}\";\n        if (showSelect && this.select) {\n            word = \"{\\\\color{red}\" + word + \"}\";\n        }\n        return(word);\n    }\n\n    toMathML() {\n        return(\"<apply><selector/><ci type=\\\"vector\\\">\" + this.name + \"</ci>\" + this.index.toString() + \"</apply>\");\n    }\n\n    dependencies(forced) {\n        var depArray = new Array();\n        if (forced != undefined) {\n            for (var i=0; i<forced.length; i++) {\n                depArray.push(forced[i]);\n            }\n        }\n        switch(this.name) {\n            default:\n                depArray.push(\"row\");\n                depArray.push(this.boundName);\n                break;\n        }\n        return(depArray);\n    }\n\n    evaluate(bindings) {\n        var retVal;\n\n        if (bindings[this.boundName] == undefined) {\n            switch(this.name) {\n                default:\n                    retVal = undefined;\n                    break;\n            }\n        } else {\n            var tmpBind = {};\n            if (this.k != undefined) {\n                tmpBind[this.k] = bindings[\"row\"];\n            }\n            var i = this.index.evaluate(tmpBind)-1;\n            if (i >= 0 && i<bindings[this.boundName].length) {\n                retVal = bindings[this.boundName][i];\n            }\n        }\n\n        return(retVal);\n    }\n}","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***************************************************\n   * Define the Function Expression -- defined by a function name and input expression\n   * *************************************************** */\n\nimport { expression } from \"./expression.js\"\nimport { create_scalar } from \"./scalar_expr.js\"\nimport { variable_expr } from \"./variable_expr.js\"\nimport { unop_expr } from \"./unop_expr.js\"\nimport { binop_expr } from \"./binop_expr.js\"\nimport { exprType } from \"./BTM_root.js\"\n\nexport class function_expr extends expression {\n    constructor(menv, name, inputExpr, restrictDomain) {\n        super(menv);\n        this.type = exprType.fcn;\n        // Count how many derivatives.\n        var primePos = name.indexOf(\"'\");\n        this.derivs = 0;\n        if (primePos > 0) {\n            this.name = name.slice(0,primePos);\n            this.derivs = name.slice(primePos).length;\n        } else {\n            this.name = name;\n        }\n        if (typeof inputExpr == 'undefined')\n            inputExpr = new expression();\n        this.inputs = [inputExpr];\n        inputExpr.parent = this;\n        this.domain = restrictDomain;\n\n        this.alternate = null;\n        this.builtin = true;\n        switch(this.name) {\n            case 'asin':\n            case 'acos':\n            case 'atan':\n            case 'asec':\n            case 'acsc':\n            case 'acot':\n                this.name = 'arc'+this.name.slice(1,4);\n                break;\n            case 'log':\n                this.name = 'ln';\n                break;\n            case 'sin':\n            case 'cos':\n            case 'tan':\n            case 'csc':\n            case 'sec':\n            case 'cot':\n            case 'arcsin':\n            case 'arccos':\n            case 'arctan':\n            case 'arcsec':\n            case 'arccsc':\n            case 'arccot':\n            case 'sqrt':\n            case 'root':\n            case 'abs':\n            case 'exp':\n            case 'expb':\n            case 'ln':\n            case 'log10':\n                break;\n            default:\n                this.builtin = false;\n                break;\n        }\n        // If using a derivative of a known function, then we should compute that in advance.\n        if (this.builtin && this.derivs > 0) {\n            var xvar = new variable_expr(this.menv, \"x\");\n            var deriv = new function_expr(this.menv, this.name, xvar);\n            for (var i=0; i<this.derivs; i++) {\n                deriv = deriv.derivative(xvar, {\"x\":0});\n            }\n            var binding = {};\n            binding[\"x\"] = inputExpr;\n            this.alternate = deriv.compose(binding);\n        }\n    }\n\n    getName() {\n        return (this.name + \"'\".repeat(this.derivs));\n    }\n\n    toString(elementOnly) {\n        var fcnString, retString;\n        if (typeof elementOnly == 'undefined') {\n            elementOnly = false;\n        }\n        fcnString = this.getName();\n        if (elementOnly) {\n            retString = fcnString;\n        } else {\n            var argStrings = [];\n            if (this.inputs.length == 0 || typeof this.inputs[0] == 'undefined') {\n                argStrings.push('?');\n            } else {\n                for (var i in this.inputs) {\n                    argStrings.push(this.inputs[i].toString());\n                }\n            }\n            retString = fcnString + '(' + argStrings.join(',') + ')';\n        }\n        return(retString);\n    }\n\n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        var allInputs = [], inputOptions = [];\n        for (var i in this.inputs) {\n            inputOptions.push(this.inputs[i].allStringEquivs());\n        }\n        var retValue = [];\n        var fcnString = this.getName();\n        // Want to create a list of all possible input representations.\n        function generateArgs(left, rightOptions) {\n            if (rightOptions.length==0) {\n                allInputs.push(left);\n            } else {\n                var N = left.length;\n                var newLeft = [];\n                for (var k in left) {\n                    newLeft.push(left[k]);\n                }\n                for (var k in rightOptions[0]) {\n                    newLeft[N] = rightOptions[0][k];\n                    generateArgs(newLeft, rightOptions.slice(1));\n                }\n            }\n        }\n        generateArgs([], inputOptions);\n        for (var i in allInputs) {\n            retValue[i] = fcnString+'(' + allInputs[i].join('+') + ')';\n        }\n\n        return(retValue);\n    }\n\n    toTeX(showSelect) {\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n        var texString = '';\n        var fcnString;\n        var argStrings = [];\n        if (typeof this.inputs[0] == 'undefined') {\n            argStrings.push('?');\n        } else {\n            for (var i in this.inputs) {\n                argStrings.push(this.inputs[i].toTeX(showSelect));\n                if (showSelect && this.select) {\n                    argStrings[i] = \"{\\\\color{blue}\" + argStrings[i] + \"}\";\n                }\n            }\n        }\n\n        switch(this.name) {\n            case 'sin':\n                fcnString = '\\\\sin';\n                break;\n            case 'cos':\n                fcnString = '\\\\cos';\n                break;\n            case 'tan':\n                fcnString = '\\\\tan';\n                break;\n            case 'csc':\n                fcnString = '\\\\csc';\n                break;\n            case 'sec':\n                fcnString = '\\\\sec';\n                break;\n            case 'cot':\n                fcnString = '\\\\cot';\n                break;\n            case 'arcsin':\n                fcnString = '\\\\sin^{-1}';\n                break;\n            case 'arccos':\n                fcnString = '\\\\cos^{-1}';\n                break;\n            case 'arctan':\n                fcnString = '\\\\tan^{-1}';\n                break;\n            case 'arccsc':\n                fcnString = '\\\\csc^{-1}';\n                break;\n            case 'arcsec':\n                fcnString = '\\\\sec^{-1}';\n                break;\n            case 'arccot':\n                fcnString = '\\\\cot^{-1}';\n                break;\n            case 'sqrt':\n                fcnString = '\\\\mathrm{sqrt}';\n                texString = '\\\\sqrt{' + argStrings[0] + '}';\n                break;\n            case 'root':\n                fcnString = '\\\\mathrm{root}';\n                texString = '\\\\sqrt[' + argStrings[1] +']{' + argStrings[0] + '}';\n                break;\n            case 'abs':\n                fcnString = '\\\\abs';\n                texString = '\\\\left|' + argStrings[0] + '\\\\right|';\n                break;\n            case 'exp':\n                fcnString = 'e^';\n                texString = 'e^{' + argStrings[0] + '}';\n                break;\n            case 'expb':\n                fcnString = '\\\\exp';\n                break;\n            case 'ln':\n                fcnString = '\\\\ln'\n                break;\n            case 'log10':\n                fcnString = '\\\\log_{10}'\n                break;\n            default:\n                if (this.name.length > 1) {\n                    fcnString = '\\\\mathrm{' + this.name + '}';\n                } else {\n                    fcnString = this.name;\n                }\n                break;\n        }\n        if (this.derivs > 0) {\n            if (this.derivs <= 3) {\n                fcnString = fcnString + \"'\".repeat(this.derivs);\n            } else {\n                fcnString = fcnString + \"^{(\"+this.derivs+\")}\";\n            }\n        }\n\n        if (showSelect && this.select) {\n            fcnString = \"\\\\color{red}{\" + fcnString + \"}\";\n            texString = '';\n        }\n        if (texString == '') {\n            texString = fcnString + ' \\\\mathopen{}\\\\left(' + argStrings.join(',') + '\\\\right)\\\\mathclose{}';\n        }\n        return(texString);\n    }\n\n    toMathML() {\n        var texString;\n        var argString;\n        if (typeof this.inputs[0] == 'undefined') {\n            argString = '?';\n        } else {\n            argString = this.inputs[0].toMathML();\n        }\n        switch(this.name) {\n            case 'sin':\n            case 'cos':\n            case 'tan':\n            case 'csc':\n            case 'sec':\n            case 'cot':\n            case 'arcsin':\n            case 'arccos':\n            case 'arctan':\n            case 'exp':\n            case 'expb':\n            case 'ln':\n            case 'abs':\n                texString = '<apply><' + this.name + '/>' + argString + '</apply>';\n                break;\n            case 'sqrt':\n                texString = '<apply><root/>' + argString + '</apply>';\n                break;\n            case 'log10':\n                texString = '<apply><log/><logbase><cn>10</cn></logbase>' + argString + '</apply>';\n                break;\n            default:\n                texString = '<apply><ci>' + this.name + '</ci>' + argString + '</apply>';\n                break;\n        }\n        return(texString);\n    }\n\n    operateToTeX() {\n        var fcnString;\n        switch(this.name) {\n            case 'sin':\n                fcnString = '\\\\sin';\n                break;\n            case 'cos':\n                fcnString = '\\\\cos';\n                break;\n            case 'tan':\n                fcnString = '\\\\tan';\n                break;\n            case 'csc':\n                fcnString = '\\\\csc';\n                break;\n            case 'sec':\n                fcnString = '\\\\sec';\n                break;\n            case 'cot':\n                fcnString = '\\\\cot';\n                break;\n            case 'arcsin':\n                fcnString = '\\\\sin^{-1}';\n                break;\n            case 'arccos':\n                fcnString = '\\\\cos^{-1}';\n                break;\n            case 'arctan':\n                fcnString = '\\\\tan^{-1}';\n                break;\n            case 'arccsc':\n                fcnString = '\\\\csc^{-1}';\n                break;\n            case 'arcsec':\n                fcnString = '\\\\sec^{-1}';\n                break;\n            case 'arccot':\n                fcnString = '\\\\cot^{-1}';\n                break;\n            case 'sqrt':\n                fcnString = '\\\\mathrm{sqrt}';\n                break;\n            case 'abs':\n                fcnString = '\\\\abs';\n                break;\n            case 'exp':\n            case 'expb':\n                fcnString = '\\\\exp';\n                break;\n            case 'ln':\n                fcnString = '\\\\ln'\n                break;\n            case 'log10':\n                fcnString = '\\\\log_{10}'\n                break;\n            default:\n                if (this.name.length > 1) {\n                    fcnString = '\\\\mathrm{' + this.name + '}';\n                } else {\n                    fcnString = this.name;\n                }\n                break;\n        }\n        if (this.derivs > 0) {\n            if (this.derivs <= 3) {\n                fcnString = fcnString + \"'\".repeat(this.derivs);\n            } else {\n                fcnString = fcnString + \"^{(\"+this.derivs+\")}\";\n            }\n        }\n\n        return(fcnString+\"(\\\\Box)\");\n    }\n\n    evaluate(bindings) {\n        var inputVal = this.inputs[0].evaluate(bindings);\n        var retVal = undefined;\n\n        if (inputVal == undefined) {\n            return(undefined);\n        }\n\n        // Built-in functions with derivatives have computed derivative earlier.\n        if (this.builtin && this.derivs > 0) {\n            if (this.alternate != undefined) {\n                retVal = this.alternate.evaluate(bindings);\n            } else {\n                console.log(\"Error: Built-in function called with unspecified derivative formula.\");\n            }\n        } else {\n            if (bindings[this.name] == undefined) {\n                // Check the list of common mathematical functions.\n                switch(this.name) {\n                    case 'sin':\n                        retVal = Math.sin(inputVal);\n                        break;\n                    case 'cos':\n                        retVal = Math.cos(inputVal);\n                        break;\n                    case 'tan':\n                        retVal = Math.tan(inputVal);\n                        break;\n                    case 'csc':\n                        retVal = 1/Math.sin(inputVal);\n                        break;\n                    case 'sec':\n                        retVal = 1/Math.cos(inputVal);\n                        break;\n                    case 'cot':\n                        retVal = 1/Math.tan(inputVal);\n                        break;\n                    case 'arcsin':\n                        if (Math.abs(inputVal) <= 1) {\n                            retVal = Math.asin(inputVal);\n                        }\n                        break;\n                    case 'arccos':\n                        if (Math.abs(inputVal) <= 1) {\n                            retVal = Math.acos(inputVal);\n                        }\n                        break;\n                    case 'arctan':\n                        retVal = Math.atan(inputVal);\n                        break;\n                    case 'arccsc':\n                        if (Math.abs(inputVal) >= 1) {\n                            retVal = Math.asin(1/inputVal);\n                        }\n                        break;\n                    case 'arcsec':\n                        if (Math.abs(inputVal) >= 1) {\n                            retVal = Math.acos(1/inputVal);\n                        }\n                        break;\n                    case 'arccot':\n                        if (inputVal == 0) {\n                            retVal = Math.PI/2;\n                        } else {\n                            retVal = Math.PI/2 - Math.atan(1/inputVal);\n                        }\n                        break;\n                    case 'sqrt':\n                        if (inputVal >= 0) {\n                            retVal = Math.sqrt(inputVal);\n                        }\n                        break;\n                    case 'abs':\n                        retVal = Math.abs(inputVal);\n                        break;\n                    case 'exp':\n                    case 'expb':\n                        retVal = Math.exp(inputVal);\n                        break;\n                    case 'ln':\n                        if (inputVal > 0) {\n                            retVal = Math.log(inputVal);\n                        }\n                        break;\n                    case 'log10':\n                        if (inputVal > 0) {\n                            retVal = Math.LOG10E * Math.log(inputVal);\n                        }\n                        break;\n                    default:\n                        // See if we have already used this function.\n                        // For consistency, we should keep it the same.\n                        var functionEntry = this.menv.functions[this.name];\n                        // If never used previously, generate a random function.\n                        // This will allow valid comparisons to occur.\n                        if (functionEntry == undefined) {\n                            console.log(\"Error: A custom function never had a backend definition.\");\n                        }\n                        // Copy the bindings.\n                        var fBind = {};\n                        Object.keys(bindings).forEach(function(key) {\n                            fBind[ key ] = bindings[ key ];\n                        });\n                        // Now, use the variable of the function.\n                        var inVar = functionEntry[\"input\"];\n                        if (Array.isArray(inVar)) {\n                            console.log(\"Error: Function is defined to expect multiple inputs. Not yet implemented.\");\n                        }\n                        fBind[inVar] = inputVal;\n                        // See if we need additional derivatives in binding\n                        if (this.derivs >= functionEntry[\"value\"].length) {\n                            var ivar = new variable_expr(this.menv, inVar);\n                            var varBind = {};\n                            varBind[ivar] = 0;\n                            for (var i=functionEntry[\"value\"].length; i <= this.derivs; i++) {\n                                functionEntry[\"value\"][i] = functionEntry[\"value\"][i-1].derivative(ivar, varBind);\n                            }\n                        }\n                        retVal = functionEntry[\"value\"][this.derivs].evaluate(fBind);\n                        break;\n                }\n            } else {\n                var functionEntry = bindings[this.name];\n                // Copy the bindings.\n                var fBind = {};\n                Object.keys(bindings).forEach(function(key) {\n                    fBind[ key ] = bindings[ key ];\n                });\n                // Now, use the variable of the function.\n                var inVar = functionEntry[\"input\"];\n                if (Array.isArray(inVar)) {\n                    console.log(\"Error: Function is defined to expect multiple inputs. Not yet implemented.\");\n                }\n                fBind[inVar] = inputVal;\n                // See if we need additional derivatives in binding\n                if (this.derivs >= functionEntry[\"value\"].length) {\n                    var ivar = new variable_expr(this.menv, inVar);\n                    var varBind = {};\n                    varBind[ivar] = 0;\n                    for (var i=functionEntry[\"value\"].length; i <= this.derivs; i++) {\n                        functionEntry[\"value\"][i] = functionEntry[\"value\"][i-1].derivative(ivar, varBind);\n                    }\n                }\n                retVal = functionEntry[\"value\"][this.derivs].evaluate(fBind);\n            }\n        }\n        return(retVal);\n    }\n\n    flatten() {\n        return(new function_expr(this.menv, this.getName(), this.inputs[0].flatten()));\n    }\n\n    copy() {\n      return(new function_expr(this.menv, this.getName(), this.inputs[0].copy()));\n    }\n\n    compose(bindings) {\n        return(new function_expr(this.menv, this.getName(), this.inputs[0].compose(bindings)));\n    }\n\n    derivative(ivar, varList) {\n        var theDeriv;\n        var depArray = this.inputs[0].dependencies();\n        var uConst = true;\n        var ivarName = (typeof ivar == 'string') ? ivar : ivar.name;\n        for (var i=0; i<depArray.length; i++) {\n            if (depArray[i] == ivarName) {\n                uConst = false;\n            }\n        }\n\n        if (uConst) {\n            theDeriv = create_scalar(this.menv, 0);\n        } else {\n            var dydu;\n\n            switch(this.name) {\n                    case 'sin':\n                        dydu = new function_expr(this.menv, 'cos', this.inputs[0]);\n                        break;\n                    case 'cos':\n                        dydu = new unop_expr(this.menv, '-', new function_expr(this.menv, 'sin', this.inputs[0]));\n                        break;\n                    case 'tan':\n                        var theSec = new function_expr(this.menv, 'sec', this.inputs[0]);\n                        dydu = new binop_expr(this.menv, '^', theSec, create_scalar(this.menv, 2));\n                        break;\n                    case 'csc':\n                        var theCot = new function_expr(this.menv, 'cot', this.inputs[0]);\n                        dydu = new unop_expr(this.menv, '-', new binop_expr(this.menv, '*', this, theCot));\n                        break;\n                    case 'sec':\n                        var theTan = new function_expr(this.menv, 'tan', this.inputs[0]);\n                        dydu = new binop_expr(this.menv, '*', this, theTan);\n                        break;\n                    case 'cot':\n                        var theCsc = new function_expr(this.menv, 'csc', this.inputs[0]);\n                        dydu = new unop_expr(this.menv, '-', new binop_expr(this.menv, '^', theCsc, create_scalar(this.menv, 2)));\n                        break;\n                    case 'arcsin':\n                        var theCos = new binop_expr(this.menv, '-', create_scalar(this.menv, 1), new binop_expr(this.menv, '^', this.inputs[0], create_scalar(this.menv, 2)));\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, 1), new function_expr(this.menv, 'sqrt', theCos));\n                        break;\n                    case 'arccos':\n                        var theSin = new binop_expr(this.menv, '-', create_scalar(this.menv, 1), new binop_expr(this.menv, '^', this.inputs[0], create_scalar(this.menv, 2)));\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, -1), new function_expr(this.menv, 'sqrt', theSin));\n                        break;\n                    case 'arctan':\n                        var tanSq = new binop_expr(this.menv, '^', this.inputs[0], create_scalar(this.menv, 2));\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, 1), new binop_expr(this.menv, '+', create_scalar(this.menv, 1), tanSq));\n                        break;\n                    case 'arcsec':\n                        var theSq = new binop_expr(this.menv, '^', this.inputs[0], create_scalar(this.menv, 2));\n                        var theRad = new binop_expr(this.menv, '-', theSq, create_scalar(this.menv, 1));\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, 1), new binop_expr(this.menv, '*', new function_expr(this.menv, 'abs', this.inputs[0]), new function_expr(this.menv, 'sqrt', theRad)));\n                        break;\n                    case 'arccsc':\n                        var theSq = new binop_expr(this.menv, '^', this.inputs[0], create_scalar(this.menv, 2));\n                        var theRad = new binop_expr(this.menv, '-', theSq, create_scalar(this.menv, 1));\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, -1), new binop_expr(this.menv, '*', new function_expr(this.menv, 'abs', this.inputs[0]), new function_expr(this.menv, 'sqrt', theRad)));\n                        break;\n                    case 'arccot':\n                        var cotSq = new binop_expr(this.menv, '^', this.inputs[0], create_scalar(this.menv, 2));\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, -1), new binop_expr(this.menv, '+', create_scalar(this.menv, 1), cotSq));\n                        break;\n                    case 'sqrt':\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, 1), new binop_expr(this.menv, '*', create_scalar(this.menv, 2), this));\n                        break;\n                    case 'abs':\n                        dydu = new binop_expr(this.menv, '/', this, this.inputs[0]);\n                        break;\n                    case 'exp':\n                    case 'expb':\n                        dydu = new function_expr(this.menv, this.name, this.inputs[0]);\n                        break;\n                    case 'ln':\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, 1), this.inputs[0]);\n                        break;\n                    case 'log10':\n                        dydu = new binop_expr(this.menv, '/', create_scalar(this.menv, Math.LOG10E), this.inputs[0]);\n                        break;\n                    default:\n                        dydu = new function_expr(this.menv, this.getName()+\"'\", this.inputs[0]);\n                        break;\n            }\n            if (!uConst && this.inputs[0].type == exprType.variable) {\n                theDeriv = dydu;\n            } else {\n                var dudx = this.inputs[0].derivative(ivar, varList);\n\n                if (dudx == undefined) {\n                    theDeriv = undefined;\n                } else {\n                    theDeriv = new binop_expr(this.menv, '*', dydu, dudx);\n                }\n            }\n        }\n        return(theDeriv);\n    }\n}","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***************************************************\n* Define the Binary Expression -- defined by an operator and two inputs.\n* *************************************************** */\n\nimport { MENV, opPrec, exprType, exprValue } from \"./BTM_root.js\"\nimport { rational_number } from \"./rational_number.js\"\nimport { expression } from \"./expression.js\"\nimport { create_scalar } from \"./scalar_expr.js\"\nimport { unop_expr } from \"./unop_expr.js\"\nimport { create_multiop } from \"./multiop_expr.js\"\nimport { function_expr } from \"./function_expr.js\"\n\nexport class binop_expr extends expression {\n    constructor(menv, op, inputA, inputB) {\n        super(menv);\n        this.type = exprType.binop;\n        this.op = op;\n        if (typeof inputA == 'undefined')\n            inputA = new expression(this.menv);\n        if (typeof inputB == 'undefined')\n            inputB = new expression(this.menv);\n        this.inputs = [inputA, inputB];\n            inputA.parent = this;\n            inputB.parent = this;\n\n        switch (op) {\n            case '+':\n            case '-':\n                this.prec = opPrec.addsub;\n                break;\n            case '*':\n            case '/':\n                this.prec = opPrec.multdiv;\n                break;\n            case '^':\n                this.prec = opPrec.power;\n                break;\n            case '&':\n                this.prec = opPrec.conj;\n                this.valueType = exprValue.bool;\n                break;\n            case '$':\n                this.prec = opPrec.disj;\n                this.valueType = exprValue.bool;\n                break;\n            case '=':\n                this.prec = opPrec.equal;\n                this.valueType = exprValue.bool;\n                break;\n            default:\n                console.log(\"Unknown binary operator: '\"+op+\"'.\");\n                break;\n        }\n    }\n\n    toString() {\n        var theStr;\n        var opAStr, opBStr;\n        var isError = false;\n\n        if (typeof this.inputs[0] == 'undefined') {\n            opAStr = '?';\n            isError = true;\n        } else {\n            opAStr = this.inputs[0].toString();\n            if ((this.inputs[0].type >= exprType.unop\n                    && this.inputs[0].prec < this.prec)\n                || (this.inputs[0].type == exprType.number\n                    && opAStr.indexOf(\"/\") >= 0\n                    && opPrec.multdiv <= this.prec)\n                ) \n            {\n                opAStr = '(' + opAStr + ')';\n            }\n        }\n        if (typeof this.inputs[1] == 'undefined') {\n            opBStr = '?';\n            isError = true;\n        } else {\n            opBStr = this.inputs[1].toString();\n            if ((this.inputs[1].type >= exprType.unop\n                    && this.inputs[1].prec <= this.prec)\n                || (this.inputs[1].type == exprType.number\n                    && opBStr.indexOf(\"/\") >= 0\n                    && opPrec.multdiv <= this.prec)\n                ) \n            {\n                opBStr = '(' + opBStr + ')';\n            }\n        }\n\n        var theOp = this.op;\n        if (theOp == '|') {\n            theOp = ' $ ';\n        }\n\n        theStr = opAStr + theOp + opBStr;\n        return(theStr);\n    }\n\n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        var allInputsA = this.inputs[0].allStringEquivs(),\n            allInputsB = this.inputs[1].allStringEquivs();\n\n        var retValue = [];\n\n        var theOp = this.op;\n        if (theOp == '|') {\n            theOp = ' $ ';\n        }\n\n        for (var i in allInputsA) {\n            for (var j in allInputsB) {\n                opAStr = allInputsA[i];\n                if (this.inputs[0].type >= exprType.unop && this.inputs[0].prec < this.prec) {\n                    opAStr = '(' + opAStr + ')';\n                }\n                opBStr = allInputsB[j];\n                if (this.inputs[1].type >= exprType.unop && this.inputs[1].prec <= this.prec) {\n                    opBStr = '(' + opBStr + ')';\n                }\n\n                retValue.push(opAStr + theOp + opBStr);\n\n                if (this.op == '+' || this.op == '*' || this.op == '&' || this.op == '$') {\n                    opBStr = allInputsB[j];\n                    if (this.inputs[1].type >= exprType.unop && this.inputs[1].prec < this.prec) {\n                        opBStr = '(' + opBStr + ')';\n                    }\n                    opAStr = allInputsA[i];\n                    if (this.inputs[0].type >= exprType.unop && this.inputs[0].prec <= this.prec) {\n                        opAStr = '(' + opAStr + ')';\n                    }\n                    retValue.push(opBStr + theOp + opAStr);\n                }\n            }\n        }\n\n        return(retValue);\n    }\n\n    toTeX(showSelect) {\n        var theStr;\n        var theOp;\n        var opAStr, opBStr;\n\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n\n        if (typeof this.inputs[0] == 'undefined') {\n            opAStr = '?';\n        } else {\n            opAStr = this.inputs[0].toTeX(showSelect);\n        }\n        if (typeof this.inputs[1] == 'undefined') {\n            opBStr = '?';\n        } else {\n            opBStr = this.inputs[1].toTeX(showSelect);\n        }\n        theOp = this.op;\n        if (showSelect && this.select) {\n            switch (theOp) {\n                case '*':\n                    theOp = '\\\\cdot ';\n                    break;\n                case '/':\n                    theOp = '\\\\div ';\n                    break;\n                case '^':\n                    theOp = '\\\\wedge ';\n                    break;\n                case '|':\n                    theOp = '\\\\hbox{ or }';\n                    break;\n                case '$':\n                    theOp = '\\\\hbox{ or }';\n                    break;\n                case '&':\n                    theOp = '\\\\hbox{ and }';\n                    break;\n            }\n        } else {\n            switch (theOp) {\n                case '*':\n                    if (this.inputs[1] && this.inputs[1].type == exprType.number) {\n                        theOp = '\\\\cdot ';\n                    } else if (this.inputs[1] && this.inputs[1].type == exprType.binop\n                                && this.inputs[1].op=='^' && this.inputs[1].inputs[0].type==exprType.number) {\n                        theOp = '\\\\cdot ';\n                    } else {\n                        theOp = ' ';\n                    }\n                    break;\n                case '|':\n                    theOp = '\\\\hbox{ or }';\n                    break;\n                case '$':\n                    theOp = '\\\\hbox{ or }';\n                    break;\n                case '&':\n                    theOp = '\\\\hbox{ and }';\n                    break;\n            }\n        }\n        if (theOp == '/') {\n            theStr = '\\\\frac{' + opAStr + '}{' + opBStr + '}';\n        } else if (theOp == '^') {\n            if (this.inputs[0] && this.inputs[0].type >= exprType.fcn) {\n                theStr = '\\\\left(' + opAStr + '\\\\right)';\n            } else {\n                theStr = opAStr;\n            }\n            theStr += theOp + '{' + opBStr + '}';\n        } else {\n            var argStrL='', argStrR='', opStrL='', opStrR='';\n\n            if (showSelect && this.select) {\n                argStrL = '{\\\\color{blue}';\n                argStrR = '}';\n                opStrL = '{\\\\color{red}';\n                opStrR = '}';\n            }\n            if (this.inputs[0] && this.inputs[0].type >= exprType.unop && this.inputs[0].prec < this.prec) {\n                theStr = '\\\\left(' + argStrL + opAStr + argStrR + '\\\\right)';\n            } else {\n                theStr = argStrL + opAStr + argStrR;\n            }\n            theStr += opStrL + theOp + opStrR;\n            if (this.inputs[1] && this.inputs[1].type >= exprType.unop && this.inputs[1].prec <= this.prec) {\n                theStr += '\\\\left(' + argStrL + opBStr + argStrR + '\\\\right)';\n            } else {\n                theStr += argStrL + opBStr + argStrR;\n            }\n        }\n        if (showSelect && this.select) {\n          theStr = \"{\\\\color{red}\\\\boxed{\" + theStr + \"}}\";\n        }\n        theStr = theStr.replace(/\\+-/g, '-');\n        return(theStr);\n    }\n\n    toMathML() {\n        var theStr;\n        var theOp;\n        var opAStr, opBStr;\n\n        if (typeof this.inputs[0] == 'undefined') {\n            opAStr = '?';\n        } else {\n            opAStr = this.inputs[0].toMathML();\n        }\n        if (typeof this.inputs[1] == 'undefined') {\n            opBStr = '?';\n        } else {\n            opBStr = this.inputs[1].toMathML();\n        }\n        switch (this.op) {\n            case '+':\n                theOp = \"<plus/>\"\n                break;\n            case '-':\n                theOp = \"<minus/>\"\n                break;\n            case '*':\n                theOp = \"<times/>\"\n                break;\n            case '/':\n                theOp = \"<divide/>\"\n                break;\n            case '^':\n                theOp = \"<power/>\"\n                break;\n        }\n        theStr = \"<apply>\" + theOp + opAStr + opBStr + \"</apply>\";\n\n        return(theStr);\n    }\n\n    operateToTeX() {\n        var opString = this.op;\n\n        switch (opString) {\n            case '*':\n                opString = '\\\\times ';\n                break;\n            case '/':\n                opString = '\\\\div ';\n                break;\n            case '^':\n                opString = '\\\\wedge ';\n                break;\n            case '|':\n                opString = '\\\\hbox{ or }';\n                break;\n            case '$':\n                opString = '\\\\hbox{ or }';\n                break;\n            case '&':\n                opString = '\\\\hbox{ and }';\n                break;\n        }\n\n        return(opString);\n    }\n\n    isCommutative() {\n        var commutes = false;\n        if (this.op === '+' || this.op === '*') {\n            commutes = true;\n        }\n        return(commutes);\n    }\n\n    evaluate(bindings) {\n        var inputAVal = this.inputs[0].evaluate(bindings);\n        var inputBVal = this.inputs[1].evaluate(bindings);\n\n        if (inputAVal == undefined || inputBVal == undefined) {\n            return(undefined);\n        }\n\n        var retVal = undefined;\n        switch (this.op) {\n            case '+':\n                retVal = inputAVal + inputBVal;\n                break;\n            case '-':\n                retVal = inputAVal - inputBVal;\n                break;\n            case '*':\n                retVal = inputAVal * inputBVal;\n                break;\n            case '/':\n                retVal = inputAVal / inputBVal;\n                break;\n            case '^':\n                if (!this.inputs[1].isConstant()) {\n                    retVal = Math.exp(inputBVal * Math.log(inputAVal));\n                } else {\n                    if (inputAVal >= 0 || (inputBVal % 1 == 0)) {\n                        retVal = Math.pow(inputAVal,inputBVal);\n                    } else {\n                        retVal = Math.exp(inputBVal * Math.log(inputAVal));\n                    }\n                }\n                break;\n            case '=':\n                retVal = (Math.abs(inputAVal - inputBVal) < this.menv.options.absTol);\n                break;\n            case '&':\n                retVal = inputAVal && inputBVal;\n                break;\n            case '|':\n            case '$':\n                retVal = inputAVal || inputBVal;\n                break;\n            default:\n                console.log(\"The binary operator '\" + this.op + \"' is not defined.\");\n                retVal = undefined;\n                break;\n        }\n        return(retVal);\n    }\n\n    // See if this operator is now redundant.\n    // Return the resulting expression.\n    reduce() {\n        var workExpr = super.reduce();\n        var newExpr = workExpr;\n        if (workExpr.type == exprType.binop && workExpr.inputs.length <= 1) {\n            if (workExpr.inputs.length == 0) {\n                // Sum with no elements = 0\n                // Product with no elements = 1\n                newExpr = create_scalar(this.menv, workExpr.op == '+' ? 0 : 1);\n            } else {\n                // Sum or product with one element *is* that element.\n                newExpr = workExpr.inputs[0];\n            }\n            newExpr.parent = this.parent;\n            if (this.parent !== null) {\n                this.parent.inputSubst(this, newExpr);\n            }\n        }\n        return(newExpr);\n    }\n\n    simplifyConstants() {\n        var retVal = this;\n        this.inputs[0] = this.inputs[0].simplifyConstants();\n        this.inputs[0].parent = this;\n        this.inputs[1] = this.inputs[1].simplifyConstants();\n        this.inputs[1].parent = this;\n        if ((this.inputs[0].type == exprType.number\n                || (this.inputs[0].type == exprType.unop && this.inputs[0].inputs[0].type == exprType.number)\n            ) &&\n            (this.inputs[1].type == exprType.number\n                || (this.inputs[1].type == exprType.unop && this.inputs[1].inputs[0].type == exprType.number)\n            ))\n        {\n            var numA, numB, theNumber;\n            if (this.inputs[0].type == exprType.number) {\n                numA = this.inputs[0].number;\n            } else {\n                switch (this.inputs[0].op) {\n                    case '-':\n                        numA = this.inputs[0].inputs[0].number.addInverse();\n                        break;\n                    case '/':\n                        numA = this.inputs[0].inputs[0].number.multInverse();\n                        break;\n                }\n            }\n            if (this.inputs[1].type == exprType.number) {\n                numB = this.inputs[1].number;\n            } else {\n                switch (this.inputs[1].op) {\n                    case '-':\n                        numB = this.inputs[1].inputs[0].number.addInverse();\n                        break;\n                    case '/':\n                        numB = this.inputs[1].inputs[0].number.multInverse();\n                        break;\n                }\n            }\n            switch (this.op) {\n                case '+':\n                    theNumber = numA.add(numB);\n                    break;\n                case '-':\n                    theNumber = numA.subtract(numB);\n                    break;\n                case '*':\n                    theNumber = numA.multiply(numB);\n                    break;\n                case '/':\n                    theNumber = numA.divide(numB);\n                    break;\n                case '^':\n                    // Integer powers of a rational number can be represented exactly.\n                    if (numA instanceof rational_number && numB instanceof rational_number\n                            && numB.q == 1 && numB.p % 1 == 0 && numB.p > 0) {\n                        theNumber = new rational_number(Math.pow(numA.p, numB.p), Math.pow(numA.q, numB.p));\n                    }\n                    break;\n            }\n            if (theNumber !== undefined) {\n                if (!this.menv.options.negativeNumbers && theNumber.p < 0) {\n                    retVal = new unop_expr(this.menv, '-', create_scalar(this.menv, theNumber.multiply(-1)));\n                } else {\n                    retVal = create_scalar(this.menv, theNumber);\n                }\n            }\n        } else {\n            switch (this.op) {\n                case '+':\n                    // Simplify 0+a\n                    if (this.inputs[0].type == exprType.number\n                            && this.inputs[0].number.value()==0) {\n                        retVal = this.inputs[1];\n                    }\n                    // Simplify a+0\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[1].number.value() == 0) {\n                        retVal = this.inputs[0];\n                    }\n                    // Simplify (u+a)+b to u+(a+b)\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[0].type == exprType.binop\n                            && this.inputs[0].op == '+') {\n                        let in0 = this.inputs[0];\n                        if (in0.inputs[0].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '+',\n                                create_scalar(this.menv, in0.inputs[0].number.add(this.inputs[1].number)),\n                                in0.inputs[1].copy()\n                            );\n                        } else if (in0.inputs[1].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '+',\n                                in0.inputs[0].copy(),\n                                create_scalar(this.menv, in0.inputs[1].number.add(this.inputs[1].number)),\n                            );\n                        }\n                    }\n                    // Simplify a+(u+b) to (a+b)+u\n                    else if (this.inputs[0].type == exprType.number\n                            && this.inputs[1].type == exprType.binop\n                            && this.inputs[1].op == '+') {\n                        let in1 = this.inputs[1];\n                        if (in1.inputs[0].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '+',\n                                create_scalar(this.menv, this.inputs[0].number.add(in1.inputs[0].number)),\n                                in1.inputs[1].copy()\n                            );\n                        } else if (in1.inputs[1].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '+',\n                                create_scalar(this.menv, this.inputs[0].number.add(in1.inputs[1].number)),\n                                in1.inputs[0].copy()\n                            );\n                        }\n                    }\n                    break;\n                case '-':\n                    // Simplify 0-a\n                    if (this.inputs[0].type == exprType.number\n                            && this.inputs[0].number.value()==0) {\n                        retVal = new unop_expr(this.menv, \"-\", this.inputs[1]);\n                    }\n                    // Simplify a-0\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[1].number.value() == 0) {\n                        retVal = this.inputs[0];\n                    }\n                    // Simplify u--a\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[1].number.value() < 0) {\n                        retVal = new binop_expr(this.menv, '+',\n                            this.inputs[0].copy(),\n                            create_scalar(this.menv, this.inputs[1].number.addInverse())\n                        );\n                    }\n                    break;\n                case '*':\n                    // Simplify 1*a\n                    if (this.inputs[0].type == exprType.number\n                            && this.inputs[0].number.value()==1) {\n                        retVal = this.inputs[1];\n                    }\n                    // Simplify a*1\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[1].number.value() == 1) {\n                        retVal = this.inputs[0];\n                    }\n                    // Simplify (u*a)*b to (a*b)*u\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[0].type == exprType.binop\n                            && this.inputs[0].op == '*') {\n                        let in0 = this.inputs[0];\n                        if (in0.inputs[0].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '*',\n                                create_scalar(this.menv, in0.inputs[0].number.multiply(this.inputs[1].number)),\n                                in0.inputs[1].copy()\n                            );\n                        } else if (in0.inputs[1].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '*',\n                                create_scalar(this.menv, in0.inputs[1].number.multiply(this.inputs[1].number)),\n                                in0.inputs[0].copy()\n                            );\n                        }\n                    }\n                    // Simplify a*(u*b) to (a*b)*u\n                    else if (this.inputs[0].type == exprType.number\n                            && this.inputs[1].type == exprType.binop\n                            && this.inputs[1].op == '*') {\n                        let in1 = this.inputs[1];\n                        if (in1.inputs[0].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '*',\n                                create_scalar(this.menv, this.inputs[0].number.multiply(in1.inputs[0].number)),\n                                in1.inputs[1].copy()\n                            );\n                        } else if (in1.inputs[1].type == exprType.number) {\n                            retVal = new binop_expr(this.menv, '*',\n                                create_scalar(this.menv, this.inputs[0].number.multiply(in1.inputs[1].number)),\n                                in1.inputs[0].copy()\n                            );\n                        }\n                    }\n                    break;\n                case '/':\n                    // Simplify 1/a to unary operator of multiplicative inverse.\n                    if (this.inputs[0].type == exprType.number\n                            && this.inputs[0].number.value()==1) {\n                        retVal = new unop_expr(this.menv, \"/\", this.inputs[1]);\n                    }\n                    // Simplify a/1\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[1].number.value() == 1) {\n                        retVal = this.inputs[0];\n                    }\n                    break;\n                case '^':\n                    // Simplify 0^p\n                    if (this.inputs[0].type == exprType.number\n                            && this.inputs[0].number.value()==0) {\n                        retVal = create_scalar(this.menv, 0);\n                    }\n                    // Simplify 1^p\n                    else if (this.inputs[0].type == exprType.number\n                            && this.inputs[0].number.value() == 1) {\n                        retVal = create_scalar(this.menv, 1);\n                    }\n                    // Simplify p^1\n                    else if (this.inputs[1].type == exprType.number\n                            && this.inputs[1].number.value() == 1) {\n                        retVal = this.inputs[0];\n                    }\n                    break;\n            }\n        }\n        return(retVal);\n    }\n\n    flatten() {\n        var inA = this.inputs[0].flatten();\n        var inB = this.inputs[1].flatten();\n\n        var retVal;\n        switch (this.op) {\n            case '+':\n            case '-':\n                var inputs = [];\n                if ((inA.type == exprType.multiop || inA.type == exprType.binop)\n                    && (inA.op == '+' || inA.op == '-')) \n                {\n                    var newInput = inA.flatten();\n                    for (var i in newInput.inputs) {\n                        inputs.push(newInput.inputs[i]);\n                    }\n                } else {\n                    inputs.push(inA);\n                }\n                if ((inB.type == exprType.multiop || inB.type == exprType.binop)\n                    && (inB.op == '+' || inB.op == '-')) \n                {\n                    var newInput = inB.flatten();\n                    for (var i in newInput.inputs) {\n                        inputs.push(newInput.inputs[i]);\n                    }\n                } else {\n                    if (this.op == '-') {\n                        if ((inB.type == exprType.multiop || inB.type == exprType.binop)\n                            && (inB.op == '+' || inB.op == '-')) \n                        {\n                            var newInput = inB.flatten();\n                            for (var i in newInput.inputs) {\n                                inputs.push(new unop_expr(this.menv, '-',newInput.inputs[i]));\n                            }\n                        } else {\n                            inputs.push(new unop_expr(this.menv, '-',inB));\n                        }\n                    } else {\n                        inputs.push(inB);\n                    }\n                }\n                retVal = create_multiop(this.menv, '+', inputs);\n                break;\n            case '*':\n            case '/':\n                var inputs = [];\n                if ((inA.type == exprType.multiop || inA.type == exprType.binop)\n                    && (inA.op == '*' || inA.op == '/')) \n                {\n                    var newInput = inA.flatten();\n                    for (var i in newInput.inputs) {\n                        inputs.push(newInput.inputs[i]);\n                    }\n                } else {\n                    inputs.push(inA);\n                }\n                if ((inB.type == exprType.multiop || inB.type == exprType.binop)\n                    && (inB.op == '*' || inB.op == '/'))\n                {\n                    var newInput = inB.flatten();\n                    for (var i in newInput.inputs) {\n                        inputs.push(newInput.inputs[i]);\n                    }\n                } else {\n                    if (this.op == '/') {\n                        if ((inB.type == exprType.multiop || inB.type == exprType.binop)\n                            && (inB.op == '*' || inB.op == '/')) \n                        {\n                            var newInput = inB.flatten();\n                            for (var i in newInput.inputs) {\n                                inputs.push(new unop_expr(this.menv, '/',newInput.inputs[i]));\n                            }\n                        } else {\n                            inputs.push(new unop_expr(this.menv, '/',inB));\n                        }\n                    } else {\n                        inputs.push(inB);\n                    }\n                }\n                retVal = create_multiop(this.menv, '*', inputs);\n                break;\n            default:\n                retVal = new binop_expr(this.menv, this.op, inA, inB);\n        }\n        return(retVal);\n    }\n\n    // This comparison routine needs to deal with two issues.\n    // (1) The passed expression has more inputs than this (in which case we group them)\n    // (2) Possibility of commuting makes the match work.\n    match(expr, bindings) {\n        function copyBindings(bindings)\n        {\n            var retValue = {};\n            for (var key in bindings) {\n                retValue[key] = bindings[key];\n            }\n            return(retValue);\n        }\n\n        var retValue = null;\n        if ((expr.type == exprType.multiop || expr.type == exprType.binop)\n            && this.op == expr.op && 2 <= expr.inputs.length) {\n\n            // Match with group at end.\n            var cmpExpr,\n                cmpInputA, cmpInputB;\n\n            cmpInputA = expr.inputs[0].copy();\n            if (expr.inputs.length > 2) {\n                let newInputs = [];\n                for (let j=0; j<expr.inputs.length-1; j++) {\n                    newInputs[j] = expr.inputs[j+1].copy();\n                }\n                cmpInputB = create_multiop(this.menv, expr.op, newInputs);\n            } else {\n                cmpInputB = expr.inputs[1].copy();\n            }\n            cmpExpr = new binop_expr(this.menv, expr.op, cmpInputA, cmpInputB);\n\n            // Now make the comparison.\n            retValue = copyBindings(bindings);\n            retValue = expression.prototype.match.call(this, cmpExpr, retValue);\n\n            // If still fail to match, try the reverse grouping: match on last n-1 and group beginning.\n            if (retValue == null && 2 < expr.inputs.length) {\n                // Create copies of the inputs\n                var newInputs = [];\n                for (let j=0; j<expr.inputs.length-1; j++) {\n                    newInputs[j] = expr.inputs[j].copy();\n                }\n                cmpInputA = create_multiop(this.menv, expr.op, newInputs);\n                cmpInputB = expr.inputs[expr.inputs.length-1];\n                cmpExpr = new binop_expr(this.menv, expr.op, cmpInputA, cmpInputB);\n\n                // Now make the comparison.\n                retValue = copyBindings(bindings);\n                retValue = expression.prototype.match.call(this, cmpExpr, retValue);\n            }\n        }\n        return(retValue);\n    }\n\n    copy() {\n      var inA = this.inputs[0].copy();\n      var inB = this.inputs[1].copy();\n      return (new binop_expr(this.menv, this.op, inA, inB));\n    }\n\n    compose(bindings) {\n        var inA = this.inputs[0].compose(bindings);\n        var inB = this.inputs[1].compose(bindings);\n\n        var retVal;\n        retVal = new binop_expr(this.menv, this.op, inA, inB);\n        if (inA.type == exprType.number && inB.type == exprType.number) {\n            switch (this.op) {\n                case '+':\n                    retVal = create_scalar(this.menv, inA.number.add(inB.number));\n                    break;\n                case '-':\n                    retVal = create_scalar(this.menv, inA.number.subtract(inB.number));\n                    break;\n                case '*':\n                    retVal = create_scalar(this.menv, inA.number.multiply(inB.number));\n                    break;\n                case '/':\n                    retVal = create_scalar(this.menv, inA.number.divide(inB.number));\n                    break;\n            }\n        }\n        return(retVal);\n    }\n\n    derivative(ivar, varList) {\n        var uConst = this.inputs[0].isConstant();\n        var vConst = this.inputs[1].isConstant();\n\n        var theDeriv;\n        if (uConst && vConst) {\n            theDeriv = create_scalar(this.menv, 0);\n        } else {\n            var dudx, dvdx;\n\n            if (uConst) {\n                dudx = create_scalar(this.menv, 0);\n            } else {\n                dudx = this.inputs[0].derivative(ivar, varList);\n            }\n            if (vConst) {\n                dvdx = create_scalar(this.menv, 0);\n            } else {\n                dvdx = this.inputs[1].derivative(ivar, varList);\n            }\n            switch (this.op) {\n                case '+':\n                    theDeriv = new binop_expr(this.menv, '+', dudx, dvdx);\n                    break;\n                case '-':\n                    theDeriv = new binop_expr(this.menv, '-', dudx, dvdx);\n                    break;\n                case '*':\n                    var udv = new binop_expr(this.menv, '*', this.inputs[0], dvdx)\n                    var vdu = new binop_expr(this.menv, '*', dudx, this.inputs[1])\n                    if (uConst) {\n                        theDeriv = udv;\n                    } else if (vConst) {\n                        theDeriv = vdu;\n                    } else {\n                        theDeriv = new binop_expr(this.menv, '+', vdu, udv);\n                    }\n                    break;\n                case '/':\n                    if (vConst) {\n                        theDeriv = new binop_expr(this.menv, '/', dudx, this.inputs[1]);\n                    } else if (uConst) {\n                        var numer = new unop_expr(this.menv, '-', new binop_expr(this.menv, '*', this.inputs[0], dvdx));\n                        var denom = new binop_expr(this.menv, '^', this.inputs[1], create_scalar(this.menv, 2));\n                        theDeriv = new binop_expr(this.menv, '/', numer, denom);\n                    } else {\n                        var udv = new binop_expr(this.menv, '*', this.inputs[0], dvdx)\n                        var vdu = new binop_expr(this.menv, '*', dudx, this.inputs[1])\n                        var numer = new binop_expr(this.menv, '-', vdu, udv);\n                        var denom = new binop_expr(this.menv, '^', this.inputs[1], create_scalar(this.menv, 2));\n                        theDeriv = new binop_expr(this.menv, '/', numer, denom);\n                    }\n                    break;\n                case '^':\n                    var powDep = this.inputs[1].dependencies();\n                    var ivarName = (typeof ivar == 'string') ? ivar : ivar.name;\n                    // See if the power depends on the variable\n                    if (powDep.length > 0 && powDep.indexOf(ivarName) >= 0) {\n                        var theArg = new binop_expr(this.menv, '*', this.inputs[1], new function_expr(this.menv, 'log', this.inputs[0]));\n                        var theFcn = new function_expr(this.menv, 'exp', theArg);\n                        theDeriv = theFcn.derivative(ivar, varList);\n                    // Otherwise this is a simple application of the power rule\n                    } else if (!uConst) {\n                        var newPow = new binop_expr(this.menv, '-', this.inputs[1], create_scalar(this.menv, 1));\n                        var dydu = new binop_expr(this.menv, '*', this.inputs[1], new binop_expr(this.menv, '^', this.inputs[0], newPow));\n                        if (this.inputs[0].type == exprType.variable\n                                && this.inputs[0].name == ivarName) {\n                            theDeriv = dydu;\n                        } else {\n                            var dudx = this.inputs[0].derivative(ivar, varList);\n                            theDeriv = new binop_expr(this.menv, '*', dydu, dudx);\n                        }\n                    } else {\n                        theDeriv = create_scalar(this.menv, 0);\n                    }\n                    break;\n                default:\n                    console.log(\"The binary operator '\" + this.op + \"' is not defined.\");\n                    theDeriv = undefined;\n                    break;\n            }\n        }\n        if (this.menv.options.doFlatten) {\n            theDeriv = theDeriv.flatten();\n        }\n        return(theDeriv);\n    }\n}\n","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***************************************************\n* Define the Unary Expression -- defined by an operator and an input.\n* *************************************************** */\n\nimport { expression } from \"./expression.js\"\nimport { create_scalar } from \"./scalar_expr.js\"\nimport { binop_expr } from \"./binop_expr.js\"\nimport { exprType, opPrec } from \"./BTM_root.js\"\n\nexport class unop_expr extends expression {\n    constructor(menv, op, input) {\n        super(menv);\n        this.type = exprType.unop;\n        this.op = op;\n        if (typeof input == 'undefined')\n            input = new expression(menv);\n        this.inputs = [input];\n            input.parent = this;\n        switch (op) {\n            case '+':\n                this.prec = opPrec.multdiv;\n                break;\n            case '-':\n                this.prec = opPrec.multdiv;\n                break;\n            case '/':\n                this.prec = opPrec.power;\n                break;\n            default:\n                alert(\"Unknown unary operator: '\"+op+\"'.\");\n                break;\n        }\n    }\n\n    toString() {\n        var theStr;\n        var opStr;\n\n        if (typeof this.inputs[0] == 'undefined') {\n            opStr = '?';\n        } else {\n            opStr = this.inputs[0].toString();\n        }\n        if ((this.inputs[0].type >= exprType.unop\n                && this.inputs[0].prec < this.prec)\n            || (this.inputs[0].type == exprType.number\n                && opStr.indexOf('/') >= 0\n                && opPrec.multdiv <= this.prec)\n            ) \n        {\n            theStr = this.op + '(' + opStr + ')';\n        } else {\n            theStr = this.op + opStr;\n        }\n\n        return(theStr);\n    }\n\n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        var allInputs = this.inputs[0].allStringEquivs();\n        var retValue = [];\n\n        for (var i in allInputs) {\n            if (this.inputs[0].type >= exprType.unop && this.inputs[0].prec <= this.prec) {\n                retValue[i] = this.op + '(' + allInputs[i] + ')';\n            } else {\n                retValue[i] = this.op + allInputs[i];\n            }\n        }\n\n        return(retValue);\n    }\n\n    toTeX(showSelect) {\n        var theStr;\n        var opStr, theOp;\n\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n\n        if (typeof this.inputs[0] == 'undefined') {\n            opStr = '?';\n        } else {\n            opStr = this.inputs[0].toTeX(showSelect);\n        }\n\n        theOp = this.op;\n        if (theOp == '/') {\n            theOp = '\\\\div ';\n            if (showSelect && this.select) {\n                theStr = \"{\\\\color{red}\" + this.op + \"}\"\n                                + '\\\\left({\\\\color{blue}' + opStr + '}\\\\right)';\n            } else {\n                theStr = '\\\\frac{1}{' + opStr + '}';\n            }\n        } else {\n            if (showSelect && this.select) {\n                theStr = \"{\\\\color{red}\" + this.op + \"}\"\n                                + '\\\\left({\\\\color{blue}' + opStr + '}\\\\right)';\n            } else if (this.inputs[0].type >= exprType.unop && this.inputs[0].prec <= this.prec\n                && (this.inputs[0].type != exprType.unop || this.op != '-' || this.inputs[0].op != '/')) {\n                theStr = theOp + '\\\\left(' + opStr + '\\\\right)';\n            } else {\n                theStr = theOp + opStr;\n            }\n        }\n        return(theStr);\n    }\n\n    toMathML() {\n        var theStr;\n        var opStr;\n\n        if (typeof this.inputs[0] == 'undefined') {\n            opStr = '?';\n        } else {\n            opStr = this.inputs[0].toMathML();\n        }\n        switch (this.op) {\n            case '+':\n                theStr = opStr;\n                break;\n            case '-':\n                theStr = \"<apply><minus/>\" + opStr + \"</apply>\";\n                break;\n            case '/':\n                theStr = \"<apply><divide/><cn>1</cn>\" + opStr + \"</apply>\";\n                break;\n        }\n\n        return(theStr);\n    }\n\n    operateToTeX() {\n        var opString = this.op;\n\n        if (opString === '/') {\n            opString = '\\\\div';\n        }\n\n        return(opString);\n    }\n\n    evaluate(bindings) {\n        var inputVal = this.inputs[0].evaluate(bindings);\n\n        var retVal;\n        if (inputVal == undefined) {\n            return(undefined);\n        }\n        switch (this.op) {\n            case '+':\n                retVal = inputVal;\n                break;\n            case '-':\n                retVal = -1*inputVal;\n                break;\n            case '/':\n                // Even when divide by zero, we want to use this, since in the exception\n                // we want the value to be Infinite and not undefined.\n                retVal = 1/inputVal;\n                break;\n            default:\n                alert(\"The unary operator '\" + this.op + \"' is not defined.\");\n                retVal = undefined;\n                break;\n        }\n        return(retVal);\n    }\n\n    reduce() {\n        var workExpr = super.reduce();\n        var newExpr = workExpr;\n        if (workExpr.type == exprType.unop && workExpr.op == '-' \n            && workExpr.inputs[0].isConstant() && workExpr.value()==0) {\n            newExpr = create_scalar(this.menv, 0)\n        }\n        return(newExpr);\n    }\n\n    simplifyConstants() {\n        var retVal;\n\n        this.inputs[0] = this.inputs[0].simplifyConstants();\n        this.inputs[0].parent = this;\n        if (this.inputs[0].type == exprType.number) {\n            var theNumber = this.inputs[0].number;\n            switch (this.op) {\n                case '-':\n                    if (this.menv.options.negativeNumbers) {\n                        retVal = create_scalar(this.menv, theNumber.addInverse());\n                    } else if (theNumber.value() == 0) {\n                        retVal = create_scalar(this.menv, 0);\n                    } else {\n                        retVal = this;\n                    }\n                    break;\n                case '/':\n                    retVal = create_scalar(this.menv, theNumber.multInverse());\n                    break;\n            }\n        } else {\n            retVal = this;\n        }\n        return(retVal);\n    }\n\n    flatten() {\n      return(new unop_expr(this.menv, this.op, this.inputs[0].flatten()));\n    }\n\n    copy() {\n      return(new unop_expr(this.menv, this.op, this.inputs[0].copy()));\n    }\n\n    compose(bindings) {\n        return(new unop_expr(this.menv, this.op, this.inputs[0].compose(bindings)));\n    }\n\n    derivative(ivar, varList) {\n        var theDeriv;\n\n        var uConst = this.inputs[0].isConstant();\n        if (uConst) {\n            theDeriv = create_scalar(this.menv, 0);\n        } else {\n            switch (this.op) {\n                case '+':\n                    theDeriv = this.inputs[0].derivative(ivar, varList);\n                    break;\n                case '-':\n                    theDeriv = new unop_expr(this.menv, '-', this.inputs[0].derivative(ivar, varList));\n                    if (theDeriv.isConstant()) {\n                        theDeriv = theDeriv.simplifyConstants();\n                    }\n                    break;\n                case '/':\n                    var denom = new binop_expr(this.menv, '*', this.inputs[0], this.inputs[0]);\n                    theDeriv = new unop_expr(this.menv, '-', new binop_expr(this.menv, '/', this.inputs[0].derivative(ivar, varList), denom));\n                    break;\n                default:\n                    console.log(\"The derivative of the unary operator '\" + this.op + \"' is not defined.\");\n                    theDeriv = undefined;\n                    break;\n            }\n        }\n        return(theDeriv);\n    }\n\n    match(expr, bindings) {\n        var retValue = null;\n\n        // Special named constants can not match expressions.\n        if (this.isConstant() && expr.isConstant()) {\n            var newExpr = expr.simplifyConstants(),\n                newThis = this.simplifyConstants();\n\n            if (newExpr.toString() === newThis.toString()\n                || newExpr.type == exprType.number && newThis.type == exprType.number\n                    && newThis.number.equal(newExpr.number)) {\n                retValue = bindings;\n            }\n        } else {\n            retValue = expression.prototype.match.call(this, expr, bindings);\n        }\n\n        return(retValue);\n    }\n}\n","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***************************************************\n* Define the Scalar Expression -- a numerical value\n* *************************************************** */\n\nimport { expression } from \"./expression.js\"\nimport { real_number } from \"./real_number.js\"\nimport { rational_number } from \"./rational_number.js\"\nimport { unop_expr } from \"./unop_expr.js\"\nimport { exprType } from \"./BTM_root.js\"\n\nexport function create_scalar(menv, number) {\n    var theNumber;\n    var numObj;\n    if (typeof number === \"number\" || number instanceof Number) {\n        if (Math.floor(number)==number) {\n            theNumber = new rational_number(number, 1);\n        } else {\n            theNumber = new real_number(number);\n        }\n    } else if (number instanceof real_number) {\n        theNumber = number;\n    } else if (number instanceof scalar_expr) {\n        theNumber = number.number;\n    } else {\n        console.log(\"Trying to create a scalar_expr with a non-number object: \" + number);\n    }\n\n    if (menv.options.negativeNumbers || theNumber.value() >=0) {\n        numObj = new scalar_expr(menv, theNumber);\n    } else {\n        numObj = new unop_expr(menv, '-', new scalar_expr(menv, theNumber.multiply(-1)));\n    }\n    return (numObj);\n}\n\nexport class scalar_expr extends expression {\n    constructor(menv, number) {\n        super(menv);\n        this.type = exprType.number;\n        if (typeof number === \"number\" ||\n                number instanceof Number) {\n            if (Math.floor(number)==number) {\n                this.number = new rational_number(number, 1);\n            } else {\n                this.number = new real_number(number);\n            }\n        } else if (number instanceof real_number) {\n                this.number = number;\n        } else if (number instanceof scalar_expr) {\n            this.number = number.number;\n        } else {\n            console.log(\"Trying to instantiate a scalar_expr with a non-number object: \" + number);\n        }\n        this.context = \"number\";\n    }\n\n    // Parsed representation.\n    toString(elementOnly) {\n        if (typeof elementOnly == 'undefined') {\n            elementOnly = false;\n        }\n        return(this.number.toString());\n    }\n    \n    // Display representation.\n    toTeX(showSelect) {\n        if (typeof showSelect == 'undefined') {\n            showSelect = false;\n        }\n        var word = this.number.toTeX();\n        if (showSelect && this.select) {\n            word = \"{\\\\color{red}\" + word + \"}\";\n        }\n        return(word);\n    }\n    \n    // MathML representation.\n    toMathML() {\n        return(\"<cn>\" + this.toString() + \"</cn>\");\n    }\n    \n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        return([this.toString()]);\n    }\n    \n    // Test if represents constant value.\n    isConstant() {\n        /*\n        This could just use expression.prototype.constant, but use this\n        because it ALWAYS is true for scalar_expr and does not need a check\n        */\n        return(true);\n    }\n    \n    // Combine constants where possible\n    simplifyConstants() {\n        var retValue;\n        if (!this.menv.options.negativeNumbers && this.number.value() < 0) {\n            var theNumber = this.number.multiply(-1);\n            retValue = new unop_expr(this.menv, '-', new scalar_expr(this.menv, theNumber));\n        } else {\n            retValue = this;\n        }\n        return(retValue);\n    }\n    \n    value() {\n        return(this.number.value());\n    }\n\n    evaluate(bindings) {\n        return(this.value());\n    }\n    \n    copy() {\n        return(create_scalar(this.menv, this.number));\n    }\n    \n    compose(bindings) {\n        return(create_scalar(this.menv, this.number));\n    }\n    \n    derivative(ivar, varList) {\n        return(create_scalar(this.menv, 0));\n    }\n    \n    /*\n        See expressions.prototype.match for explanation.\n    \n        A scalar might match a constant formula.\n    */\n    match(expr, bindings) {\n        var retValue = null,\n            testExpr = expr;\n    \n        // Special named constants can not match expressions.\n        if (expr.isConstant() && expr.type != exprType.number) {\n            var testExpr = expr.copy().simplifyConstants();\n            if (this.toString() === testExpr.toString()) {\n              retValue = bindings;\n            }\n        }\n        else if (testExpr.type == exprType.number\n                && this.number.equal(testExpr.number)) {\n            retValue = bindings;\n        }\n    \n        return(retValue);\n    }    \n}\n\n","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***************************************************\n* Define the Derivative of an Expression\n* *************************************************** */\n\nimport { expression } from \"./expression.js\"\nimport { variable_expr } from \"./variable_expr.js\"\nimport { exprType } from \"./BTM_root.js\"\n\nexport class deriv_expr extends expression {\n    constructor(menv, formula, variable, atValue) {\n        super(menv);\n        this.type = exprType.operator;\n        this.op = \"D\";\n        if (typeof formula == 'undefined')\n            formula = new expression(menv);\n        if (typeof variable == 'undefined') {\n            variable = new variable_expr(menv, 'x');\n        } else if (typeof variable == 'string') {\n            variable = new variable_expr(menv, variable);\n        }\n        this.ivar = variable;\n        this.ivarValue = atValue;\n        this.inputs = [formula];\n        this.isRate = false;\n        formula.parent = this;\n    }\n\n    toString() {\n        var theStr;\n        var exprStr, varStr, valStr;\n\n        varStr = this.ivar.toString();\n        exprStr = this.inputs[0].toString();\n        if (typeof this.ivarValue != 'undefined') {\n            valStr = this.ivarValue.toString();\n            theStr = \"D(\"+exprStr+\",\"+varStr+\",\"+valStr+\")\";\n        } else {\n            theStr = \"D(\"+exprStr+\",\"+varStr+\")\";\n        }\n        return(theStr);\n    }\n\n    toTeX(showSelect) {\n        var theStr;\n        var opStr, varStr, exprStr, valStr;\n\n        varStr = this.ivar.toTeX();\n        exprStr = this.inputs[0].toTeX();\n        if (this.isRate && this.inputs[0].type == exprType.variable) {\n            if (typeof this.ivarValue != 'undefined') {\n                valStr = this.ivarValue.toTeX();\n                theStr = \"\\\\left. \\\\frac{d\" + exprStr + \"}{d\"+varStr+\"} \\\\right|_{\"\n                    + varStr + \"=\" + valStr + \"}\";\n            } else {\n                theStr = \"\\\\frac{d\" + exprStr +\"}{d\"+varStr+\"}\";\n            }\n        } else {\n            if (typeof this.ivarValue != 'undefined') {\n                valStr = this.ivarValue.toTeX();\n                opStr = \"\\\\left. \\\\frac{d}{d\"+varStr+\"} \\\\right|_{\"\n                    + varStr + \"=\" + valStr + \"}\";\n            } else {\n                opStr = \"\\\\frac{d}{d\"+varStr+\"}\";\n            }\n            theStr = opStr + \"\\\\Big[\" + exprStr + \"\\\\Big]\";\n        }\n        return(theStr);\n    }\n\n    // Return an array containing all tested equivalent strings.\n    allStringEquivs() {\n        var allInputs = this.inputs[0].allStringEquivs();\n        var varStr, valStr;\n        var retValue = [];\n\n        varStr = this.ivar.toString();\n        if (typeof this.ivarValue != 'undefined') {\n            valStr = this.ivarValue.toString();\n        }\n        for (var i in allInputs) {\n            if (typeof this.ivarValue != 'undefined') {\n                retValue[i] = \"D(\"+allInputs[i]+\",\"+varStr+\",\"+valStr+\")\";\n            } else {\n                retValue[i] = \"D(\"+allInputs[i]+\",\"+varStr+\")\";\n            }\n        }\n\n        return(allInputs);\n    }\n\n    toMathML() {\n        var theStr;\n        var exprStr;\n\n        if (typeof this.inputs[0] == 'undefined') {\n            exprStr = '?';\n        } else {\n            exprStr = this.inputs[0].toMathML();\n        }\n        theStr = \"<apply><derivative/>\" + exprStr + \"</apply>\";\n\n        return(theStr);\n    }\n\n    evaluate(bindings) {\n        var retVal;\n        var derivExpr;\n        var dbind = {};\n\n        if (typeof this.ivarValue != 'undefined') {\n            dbind[this.ivar.name] = this.ivarValue;\n        }\n        // Compute the derivative of the expression, then evaluate at binding\n        derivExpr = this.inputs[0].derivative(this.ivar, bindings);\n        derivExpr = derivExpr.compose(dbind);\n        retVal = derivExpr.evaluate(bindings);\n        return(retVal);\n    }\n\n    simplifyConstants() {\n        return(this);\n    }\n\n    flatten() {\n      return (new deriv_expr(this.menv, this.inputs[0].flatten(), this.ivar, this.ivarValue));\n    }\n\n    copy() {\n      return (new deriv_expr(this.menv, this.inputs[0].copy(), this.ivar, this.ivarValue));\n    }\n\n\n    compose(bindings) {\n    }\n\n    derivative(ivar, varList) {\n        var dbind = {};\n\n        if (typeof this.ivarValue != 'undefined') {\n            dbind[this.ivar] = this.ivarValue;\n        }\n        // Evaluate the main expression using original binding\n        var firstDeriv = this.inputs[0].derivative(this.ivar, varList);\n        firstDeriv.compose(dbind);\n\n        // Now differentiate that expression using new binding.\n        return firstDeriv.derivative(ivar, varList);\n    }\n}\n","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\nimport { rational_number } from \"./rational_number.js\"\n\n/* ****************************************************\n*    Routines for dealing with random values\n* **************************************************** */\n\n/* To use a seeded RNG, we rely on an open source project for the underlying mechanics. */\n\n/*////////////////////////////////////////////////////////////////\naleaPRNG 1.1\n//////////////////////////////////////////////////////////////////\nhttps://github.com/macmcmeans/aleaPRNG/blob/master/aleaPRNG-1.1.js\n//////////////////////////////////////////////////////////////////\nOriginal work copyright © 2010 Johannes Baagøe, under MIT license\nThis is a derivative work copyright (c) 2017-2020, W. Mac\" McMeans, under BSD license.\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n////////////////////////////////////////////////////////////////*/\nfunction aleaPRNG() {\n    return( function( args ) {\n        \"use strict\";\n\n        const version = 'aleaPRNG 1.1.0';\n\n        var s0\n            , s1\n            , s2\n            , c\n            , uinta = new Uint32Array( 3 )\n            , initialArgs\n            , mashver = ''\n        ;\n\n        /* private: initializes generator with specified seed */\n        function _initState( _internalSeed ) {\n            var mash = Mash();\n\n            // internal state of generator\n            s0 = mash( ' ' );\n            s1 = mash( ' ' );\n            s2 = mash( ' ' );\n\n            c = 1;\n\n            for( var i = 0; i < _internalSeed.length; i++ ) {\n                s0 -= mash( _internalSeed[ i ] );\n                if( s0 < 0 ) { s0 += 1; }\n\n                s1 -= mash( _internalSeed[ i ] );\n                if( s1 < 0 ) { s1 += 1; }\n                \n                s2 -= mash( _internalSeed[ i ] );\n                if( s2 < 0 ) { s2 += 1; }\n            }\n\n            mashver = mash.version;\n\n            mash = null;\n        };\n\n        /* private: dependent string hash function */\n        function Mash() {\n            var n = 4022871197; // 0xefc8249d\n\n            var mash = function( data ) {\n                data = data.toString();\n                \n                // cache the length\n                for( var i = 0, l = data.length; i < l; i++ ) {\n                    n += data.charCodeAt( i );\n                    \n                    var h = 0.02519603282416938 * n;\n                    \n                    n  = h >>> 0;\n                    h -= n;\n                    h *= n;\n                    n  = h >>> 0;\n                    h -= n;\n                    n += h * 4294967296; // 0x100000000      2^32\n                }\n                return ( n >>> 0 ) * 2.3283064365386963e-10; // 2^-32\n            };\n\n            mash.version = 'Mash 0.9';\n            return mash;\n        };\n\n\n        /* private: check if number is integer */\n        function _isInteger( _int ) { \n            return parseInt( _int, 10 ) === _int; \n        };\n\n        /* public: return a 32-bit fraction in the range [0, 1]\n        This is the main function returned when aleaPRNG is instantiated\n        */\n        var random = function() {\n            var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32\n            \n            s0 = s1;\n            s1 = s2;\n\n            return s2 = t - ( c = t | 0 );\n        };\n\n        /* public: return a 53-bit fraction in the range [0, 1] */\n        random.fract53 = function() {\n            return random() + ( random() * 0x200000  | 0 ) * 1.1102230246251565e-16; // 2^-53\n        };\n\n        /* public: return an unsigned integer in the range [0, 2^32] */\n        random.int32 = function() {\n            return random() * 0x100000000; // 2^32\n        };\n\n        /* public: advance the generator the specified amount of cycles */\n        random.cycle = function( _run ) {\n            _run = typeof _run === 'undefined' ? 1 : +_run;\n            if( _run < 1 ) { _run = 1; }\n            for( var i = 0; i < _run; i++ ) { random(); }\n        };\n\n        /* public: return inclusive range */\n        random.range = function() { \n            var loBound\n                , hiBound\n            ;\n            \n            if( arguments.length === 1 ) {\n                loBound = 0;\n                hiBound = arguments[ 0 ];\n\n            } else {\n                loBound = arguments[ 0 ];\n                hiBound = arguments[ 1 ];\n            }\n\n            if( arguments[ 0 ] > arguments[ 1 ] ) { \n                loBound = arguments[ 1 ];\n                hiBound = arguments[ 0 ];\n            }\n\n            // return integer\n            if( _isInteger( loBound ) && _isInteger( hiBound ) ) { \n                return Math.floor( random() * ( hiBound - loBound + 1 ) ) + loBound; \n\n            // return float\n            } else {\n                return random() * ( hiBound - loBound ) + loBound; \n            }\n        };\n\n        /* public: initialize generator with the seed values used upon instantiation */\n        random.restart = function() {\n            _initState( initialArgs );\n        };\n\n        /* public: seeding function */\n        random.seed = function() { \n            _initState( Array.prototype.slice.call( arguments ) );\n        }; \n\n        /* public: show the version of the RNG */\n        random.version = function() { \n            return version;\n        }; \n\n        /* public: show the version of the RNG and the Mash string hasher */\n        random.versions = function() { \n            return version + ', ' + mashver;\n        }; \n\n        // when no seed is specified, create a random one from Windows Crypto (Monte Carlo application) \n        if( args.length === 0 ) {\n             window.crypto.getRandomValues( uinta );\n             args = [ uinta[ 0 ], uinta[ 1 ], uinta[ 2 ] ];\n        };\n\n        // store the seed used when the RNG was instantiated, if any\n        initialArgs = args;\n\n        // initialize the RNG\n        _initState( args );\n\n        return random;\n\n    })( Array.prototype.slice.call( arguments ) );\n};\n\nexport class RNG {\n    constructor(rngSettings) {\n        if (rngSettings.rand) {\n          this.rand = rngSettings.rand;\n        } else {\n          let seed;\n          if (rngSettings.seed == undefined) {\n            seed = new Date().getTime().toString();\n          } else {\n            seed = rngSettings.seed;\n          }\n          this.rand = aleaPRNG(seed);\n        }\n    }\n\n    setSeed(seed) {\n        this.alea.seed(seed.toString());\n    }\n\n    // Standard uniform generator values in [0,1)\n    random() {\n        return(this.rand());\n    }\n\n    // Randomly choose +1 or -1.\n    randSign() {\n        var a = 2*Math.floor(2*this.random())-1;\n        return(a);\n    }\n\n    // Randomly choose integer uniformly in {min, ..., max}.\n    randInt(min, max) {\n        var a = min+Math.floor( (max-min+1)*this.random() );\n        return(a);\n    }\n    \n    // Randomly choose floating point uniformly in [min,max)\n    randUniform(min, max) {\n        var a = min+(max-min)*this.random();\n        return(a);\n    }\n\n    // Randomly choose floating point uniformly in [min,max)\n    randDiscrete(min, max, by, nonzero) {\n        if (arguments.length < 3 || by == 0) {\n            by = 1;\n        }\n        if (arguments.length < 4) {\n            nonzero=false;\n        }\n        var rndVal;\n        let Nvals = Math.floor((max-min) / by)+1;\n        do {\n            rndVal = min + by * this.randInt(0,Nvals-1);\n        } while (nonzero && Math.abs(rndVal) < 1e-16);\n        return(rndVal);\n    }\n\n    // Randomly a k-length permuted subsequence of {min, ..., max}\n    randChoice(min, max, k) {\n        var a = new Array();\n        var b = new Array();\n        var i,j;\n        for (i=0; i<=max-min; i++) {\n            a[i] = min+i;\n        }\n        for (i=0; i<k; i++) {\n            j = Math.floor( (max-min+1-i)*this.random() );\n            b[i] = a.splice(j,1)[0];\n        }\n\n        return (b);\n    }\n\n    // Generate a random rational number, passing in 2-len arrays for limits.\n    randRational(pLims, qLims) {\n        var p, q;\n\n        // Find the raw rational number\n        p = this.randInt(pLims[0], pLims[1]);\n        q = this.randInt(qLims[0], qLims[1]);\n\n        return (new rational_number(p,q));\n    }\n\n    // Generate a random hex code of desired length.\n    randHexHash(n) {\n      var hash = '';\n      var chars = '0123456789abcdef';\n      for (var i=0; i<n; i++) {\n        hash += chars[this.randInt(0,15)];\n      }\n      return hash;\n    }\n}","/*!\n * BTM JavaScript Library v@VERSION\n * https://github.com/dbrianwalton/BTM\n *\n * Copyright D. Brian Walton\n * Released under the MIT license (https://opensource.org/licenses/MIT)\n *\n * Date: @DATE\n */\n\n/* ***********************\n** Evaluating expressions occurs in the context of a BTM environment.\n************************* */\n\nimport { defaultReductions, defaultSumReductions, defaultProductReductions, disableRule, newRule, findMatchRules } from \"./reductions.js\"\nimport { create_scalar } from \"./scalar_expr.js\";\nimport { variable_expr, index_expr } from \"./variable_expr.js\";\nimport { unop_expr } from \"./unop_expr.js\";\nimport { binop_expr } from \"./binop_expr.js\";\nimport { multiop_expr } from \"./multiop_expr.js\";\nimport { function_expr } from \"./function_expr.js\";\nimport { deriv_expr } from \"./deriv_expr.js\";\nimport { RNG } from \"./random.js\"\nimport { expression, undef_expr } from \"./expression.js\";\n\nexport const opPrec = {\n    disj: 0,\n    conj: 1,\n    equal: 2,\n    addsub: 3,\n    multdiv: 4,\n    power: 5,\n    fcn: 6,\n    fop: 7\n};\n\nexport const exprType = {\n    undef: -1,\n    number: 0,\n    variable: 1,\n    fcn: 2,\n    unop: 3,\n    binop: 4,\n    multiop: 5,\n    operator: 6,\n    array: 7,\n    matrix: 8\n};\n\nexport const exprValue = { undef: -1, bool : 0, numeric : 1 };\n\nexport function toTeX(expr) {\n    return typeof expr.toTeX === \"function\" ? expr.toTeX() : expr;\n}\n\n// Class to define parsing and reduction rules.\nexport class MENV {\n    constructor(settings) {\n        if (settings === undefined) {\n            settings = {};\n            settings.seed = '1234';\n        }\n        // Each instance of BTM environment needs bindings across all expressions.\n        this.randomBindings = {};\n        this.bindings = {};\n        this.functions = {};\n        this.opPrec = opPrec;\n        this.exprType = exprType;\n        this.exprValue = exprValue;\n        this.options = {\n            negativeNumbers: true,\n            absTol: 1e-8,\n            relTol: 1e-4,\n            useRelErr: true,\n            doFlatten: false \n        };\n        this.setReductionRules();\n        this.multiop_expr = multiop_expr;\n        this.binop_expr = binop_expr;\n\n        // Generate a random generator. We might be passed either a pre-seeded `rand` function or a seed for our own.\n        let rngOptions = {};\n        if (typeof settings.rand !== 'undefined') {\n            rngOptions.rand = settings.rand;\n        }\n        if (typeof settings.seed !== 'undefined') {\n            rngOptions.seed = settings.seed;\n        }\n        rngOptions.absTol = this.options.absTol;\n        this.rng = new RNG(rngOptions);\n    }\n\n    // Perform approximate comparison tests using environment settings\n    // a < b: -1\n    // a ~= b: 0\n    // a > b: 1\n    numberCmp(a,b,override) {\n        // Work with actual values.\n        var valA, valB, cmpResult;\n        var useRelErr = this.options.useRelErr,\n            relTol = this.options.relTol,\n            absTol = this.options.absTol;\n\n        if (typeof a === 'number' || typeof a === 'Number') {\n            valA = a;\n        } else {\n            valA = a.value();\n        }\n        if (typeof b === 'number' || typeof b === 'Number') {\n            valB = b;\n        } else {\n            valB = b.value();\n        }\n\n        // Pull out the options.\n        if (typeof override !== 'undefined') {\n            if (typeof override.useRelErr !== 'undefined') {\n                useRelErr = override.useRelErr;\n            }\n            if (typeof override.relTol !== 'undefined') {\n                relTol = override.relTol;\n            }\n            if (typeof override.absTol !== 'undefined') {\n                absTol = override.absTol;\n            }\n        }\n\n        if (!useRelErr || Math.abs(valA) < absTol) {\n            if (Math.abs(valB-valA) < absTol) {\n                cmpResult = 0;\n            } else if (valA < valB) {\n                cmpResult = -1;\n            } else {\n                cmpResult = 1;\n            }\n        } else {\n            if (Math.abs(valB-valA)/Math.abs(valA) < relTol) {\n                cmpResult = 0;\n            } else if (valA < valB) {\n                cmpResult = -1;\n            } else {\n                cmpResult = 1;\n            }\n        }\n        return cmpResult;\n    }\n\n    /* Block of methods to deal with reduction rules in context */\n    setReductionRules() {\n        this.reduceRules = defaultReductions(this);\n    }\n\n    addReductionRule(equation, description, useOneWay) {\n        newRule(this, this.reduceRules, equation, description, true, useOneWay);\n    }\n\n    disableReductionRule(equation) {\n        disableRule(this, this.reduceRules, equation);\n    }\n\n    addRule(ruleList, equation, description, useOneWay){\n        newRule(this, ruleList, equation, description, true, useOneWay);\n    }\n\n    findMatchRules(reductionList, testExpr, doValidate) {\n        return findMatchRules(reductionList, testExpr, doValidate);\n    }\n\n    generateRandom(distr, options) {\n        var rndVal, rndScalar;\n        var min, max, by, nonzero;\n        switch (distr) {\n            case 'uniform':\n                min=options.min;\n                if (typeof min.value === 'function') {\n                    min = min.value();\n                }\n                if (min == undefined) {\n                    min = 0;\n                }\n                max=options.max;\n                if (typeof max.value === 'function') {\n                    max = max.value();\n                }\n                if (max == undefined) {\n                    max = 1;\n                }\n                rndVal = this.rng.randUniform(min,max);\n                break;\n            case 'sign':\n                rndVal = this.rng.randSign();\n                break;\n            case 'integer':\n                min=options.min;\n                if (typeof min.value === 'function') {\n                    min = min.value();\n                }\n                if (min == undefined) {\n                    min = 0;\n                }\n                min = Math.floor(min);\n                max=options.max;\n                if (typeof max.value === 'function') {\n                    max = max.value();\n                }\n                if (max == undefined) {\n                    max = 1;\n                }\n                max = Math.floor(max);\n                rndVal = this.rng.randInt(min,max);\n                break;\n            case 'discrete':\n                min = options.min;\n                if (typeof min.value === 'function') {\n                    min = min.value();\n                }\n                max = options.max;\n                if (typeof max.value === 'function') {\n                    max = max.value();\n                }\n                by = options.by;\n                if (typeof by.value === 'function') {\n                    by = by.value();\n                }\n                nonzero = options.nonzero ? true : false;\n                rndVal = this.rng.randDiscrete(min,max,by,nonzero);\n                break;\n        }\n        rndScalar = create_scalar(this, rndVal);\n        return rndScalar;\n    }\n\n    addFunction(name, input, expression) {\n        if (arguments.length < 2) {\n            input = \"x\";\n        }\n        // No expression? Make it random.\n        if (arguments.length < 3) {\n            var formula = create_scalar(this, this.rng.randRational([-20,20],[1,15]));\n            var newTerm;\n            for (var i=1; i<=6; i++) {\n                if (Array.isArray(input)) {\n                    newTerm = this.parse(\"sin(\"+i+\"*\"+input[0]+\")\", \"formula\");\n                    for (var j=1; j<input.length; j++) {\n                        newTerm = new binop_expr(this, \"*\",\n                            this.parse(\"sin(\"+i+\"*\"+input[j]+\")\", \"formula\"),\n                            newTerm\n                        );\n                    }\n                } else {\n                    newTerm = this.parse(\"sin(\"+i+\"*\"+input+\")\", \"formula\");\n                }\n                newTerm = new binop_expr(this, \"*\",\n                                create_scalar(this, this.rng.randRational([-20,20],[1,10])),\n                                newTerm);\n                formula = new binop_expr(this, \"+\", formula, newTerm);\n            }\n            expression = formula;\n        }\n        var functionEntry = {};\n        functionEntry[\"input\"] = input;\n        functionEntry[\"value\"] = expression;\n        this.functions[name] = functionEntry;\n    }\n\n    compareMathObjects(expr1, expr2) {\n        if (typeof expr1 === 'string') {\n            expr1 = this.parse(expr1, \"formula\")\n        }\n        if (typeof expr2 === 'string') {\n            expr2 = this.parse(expr2, \"formula\")\n        }\n        return (expr1.compare(expr2));\n    }\n\n    getParser(context) {\n        var self=this,\n            parseContext=context;\n        return (function(exprString){ return self.parse(exprString, parseContext); })\n    }\n \n  /* ****************************************\n    parse() is the workhorse.\n\n      Take a string representing a formula, and decompose it into an appropriate\n      tree structure suitable for recursive evaluation of the function.\n      Returns the root element to the tree.\n  ***************************************** */\n  parse(formulaStr, context, bindings, options) {\n    if (arguments.length < 2) {\n        context = \"formula\";\n    }\n    if (arguments.length < 3) {\n      bindings = {};\n    }\n    if (arguments.length < 4) {\n      options = {};\n    }\n\n    const numberMatch = /\\d|(\\.\\d)/;\n    const nameMatch = /[a-zA-Z]/;\n    const unopMatch = /[\\+\\-/]/;\n    const opMatch = /[\\+\\-*/^=\\$&]/;\n\n    var charPos = 0, endPos;\n    var parseError = '';\n\n    // Strip any extraneous white space and parentheses.\n    var workingStr;\n    workingStr = formulaStr.trim();\n\n    // Test if parentheses are all balanced.\n    var hasExtraParens = true;\n    while (hasExtraParens) {\n      hasExtraParens = false;\n      if (workingStr.charAt(0) == '(') {\n        var endExpr = completeParenthesis(workingStr, 0);\n        if (endExpr+1 >= workingStr.length) {\n          hasExtraParens = true;\n          workingStr = workingStr.slice(1,-1);\n        }\n      }\n    }\n\n    // We build the tree as it is parsed. \n    // Two stacks keep track of operands (expressions) and operators\n    // which we will identify as the string is parsed left to right\n    // At the time an operand is parsed, we don't know to which operator \n    // it ultimately belongs, so we push it onto a stack until we know.\n    var operandStack = new Array();\n    var operatorStack = new Array();\n\n    // When an operator is pushed, we want to compare it to the previous operator\n    // and see if we need to apply the operators to some operands.\n    // This is based on operator precedence (order of operations).\n    // An empty newOp means to finish resolve the rest of the stacks.\n    function resolveOperator(menv, operatorStack, operandStack, newOp) {\n      // Test if the operator has lower precedence.\n      var oldOp = 0;\n      while (operatorStack.length > 0) {\n        oldOp = operatorStack.pop();\n        if (newOp && (newOp.type==exprType.unop || oldOp.prec < newOp.prec)) {\n            break;\n        }\n\n        // To get here, the new operator must be *binary*\n        // and the operator to the left has *higher* precedence.\n        // So we need to peel off the operator to the left with its operands\n        // to form an expression as a new compound operand for the new operator.\n        var newExpr;\n        // Unary: Either negative or reciprocal require *one* operand\n        if (oldOp.type == exprType.unop) {\n          if (operandStack.length > 0) {\n            var input = operandStack.pop();\n\n            // Deal with negative numbers separately.\n            if (menv.options.negativeNumbers && input.type == exprType.number && oldOp.op == '-') {\n              newExpr = create_scalar(menv, input.number.multiply(-1));\n            } else {\n              newExpr = new unop_expr(menv, oldOp.op, input);\n            }\n          } else {\n            newExpr = new expression(menv);\n            newExpr.setParsingError(\"Incomplete formula: missing value for \" + oldOp.op);\n          }\n        // Binary: Will be *two* operands.\n        } else {\n          if (operandStack.length > 1) {\n            var inputB = operandStack.pop();\n            var inputA = operandStack.pop();\n            newExpr = new binop_expr(menv, oldOp.op, inputA, inputB);\n          } else {\n            newExpr = new expression(menv);\n            newExpr.setParsingError(\"Incomplete formula: missing value for \" + oldOp.op);\n          }\n        }\n        operandStack.push(newExpr);\n        oldOp = 0;\n      }\n      // The new operator is unary or has higher precedence than the previous op.\n      // We need to push the old operator back on the stack to use later.\n      if (oldOp != 0) {\n        operatorStack.push(oldOp);\n      }\n      // A new operation was added to deal with later.\n      if (newOp) {\n        operatorStack.push(newOp);\n      }\n    }\n\n    // Now we begin to process the string representing the expression.\n    var lastElement = -1, newElement; // 0 for operand, 1 for operator.\n\n    // Read string left to right.\n    // Identify what type of math object starts at this character.\n    // Find the other end of that object by completion.\n    // Interpret that object, possibly through a recursive parsing.\n    for (charPos = 0; charPos<workingStr.length; charPos++) {\n      // Identify the next element in the string.\n      if (workingStr.charAt(charPos) == ' ') {\n        continue;\n\n      // It might be a close parentheses that was not matched on the left.\n      } else if (workingStr.charAt(charPos) == ')') {\n        // Treat this like an implicit open parenthesis on the left.\n        resolveOperator(this, operatorStack, operandStack);\n        newElement = 0;\n        lastElement = -1;\n\n      // It could be an expression surrounded by parentheses -- use recursion\n      } else if (workingStr.charAt(charPos) == '(') {\n        endPos = completeParenthesis(workingStr, charPos);\n        var subExprStr = workingStr.slice(charPos+1,endPos);\n        var subExpr = this.parse(subExprStr, context, bindings);\n        operandStack.push(subExpr);\n        newElement = 0;\n        charPos = endPos;\n\n      // It could be an absolute value\n      } else if (workingStr.charAt(charPos) == '|') {\n        endPos = completeAbsValue(workingStr, charPos);\n        var subExprStr = workingStr.slice(charPos+1,endPos);\n        var subExpr = this.parse(subExprStr, context, bindings);\n        var newExpr = new function_expr(this, 'abs', subExpr);\n        operandStack.push(newExpr);\n        newElement = 0;\n        charPos = endPos;\n\n      // It could be a number. Just read it off\n      } else if (workingStr.substr(charPos).search(numberMatch) == 0) {\n        endPos = completeNumber(workingStr, charPos, options);\n        var newExpr = create_scalar(this, new Number(workingStr.slice(charPos, endPos)));\n        if (options && options.noDecimals && workingStr.charAt(charPos) == '.') {\n          newExpr.setParsingError(\"Whole numbers only. No decimal values are allowed.\")\n        }\n        operandStack.push(newExpr);\n        newElement = 0;\n        charPos = endPos-1;\n\n      // It could be a name, either a function or variable.\n      } else if (workingStr.substr(charPos).search(nameMatch) == 0) {\n        endPos = completeName(workingStr, charPos);\n        var theName = workingStr.slice(charPos,endPos);\n        // If not a known name, break it down using composite if possible.\n        if (bindings[theName]=== undefined) {\n          // Returns the first known name, or theName not composite.\n          var testResults = TestNameIsComposite(theName, bindings);\n          if (testResults.isComposite) {\n            theName = testResults.name;\n            endPos = charPos + theName.length;\n          }\n        }\n        // Test if a function.\n        // Expand this once we allow parsing of user-defined functions.\n        if (workingStr.charAt(endPos) == '(' && \n            (bindings[theName]===undefined)) {\n          var endParen = completeParenthesis(workingStr, endPos);\n\n          var fcnName = theName;\n          var newExpr;\n          // See if this is a derivative\n          if (fcnName == 'D') {\n            var expr, ivar, ivarValue;\n            var entries = workingStr.slice(endPos+1,endParen).split(\",\");\n            expr = this.parse(entries[0], context, bindings);\n            if (entries.length == 1) {\n              newExpr = new deriv_expr(this, expr, 'x');\n            } else {\n              ivar = this.parse(entries[1], context, bindings);\n              // D(f(x),x,c) means f'(c)\n              if (entries.length > 2) {\n                ivarValue = this.parse(entries[2], context, bindings);\n              }\n              newExpr = new deriv_expr(this, expr, ivar, ivarValue);\n            }\n          } else {\n            var subExpr = this.parse(workingStr.slice(endPos+1,endParen), context, bindings);\n            newExpr = new function_expr(this, theName, subExpr);\n          }\n          operandStack.push(newExpr);\n          newElement = 0;\n          charPos = endParen;\n        }\n        // or a variable.\n        else {\n          // Test if needs index\n          if (workingStr.charAt(endPos) == '[') {\n            var endParen, hasError=false;\n            try {\n              endParen = completeBracket(workingStr, endPos, true);\n            } catch (error) {\n              parseError = error;\n              hasError = true;\n              endParen = endPos+1;\n            }\n            var indexExpr = this.parse(workingStr.slice(endPos+1,endParen), context, bindings);\n            var newExpr = new index_expr(this, theName, indexExpr);\n            if (hasError) {\n              newExpr.setParsingError(parseError);\n              parseError = \"\";\n            }\n            operandStack.push(newExpr);\n            newElement = 0;\n            charPos = endParen;\n          } else {\n            var newExpr = new variable_expr(this, theName);\n            operandStack.push(newExpr);\n            newElement = 0;\n            charPos = endPos-1;\n          }\n        }\n\n      // It could be an operator.\n      } else if (workingStr.substr(charPos).search(opMatch) == 0) {\n        newElement = 1;\n        var op = workingStr.charAt(charPos);\n        var newOp = new operator(op);\n\n        // Consecutive operators?    Better be sign change or reciprocal.\n        if (lastElement != 0) {\n          if (op == \"-\" || op == \"/\") {\n            newOp.type = exprType.unop;\n            newOp.prec = opPrec.multdiv;\n          } else {\n            // ERROR!!!\n            parseError = \"Error: consecutive operators\";\n          }\n        }\n        resolveOperator(this, operatorStack, operandStack, newOp);\n      }\n\n      // Two consecutive operands must have an implicit multiplication between them\n      if (lastElement == 0 && newElement == 0) {\n        var holdElement = operandStack.pop();\n\n        // Push a multiplication\n        var newOp = new operator('*');\n        resolveOperator(this, operatorStack, operandStack, newOp);\n\n        // Then restore the operand stack.\n        operandStack.push(holdElement);\n      }\n      lastElement = newElement;\n    }\n\n    // Now finish up the operator stack: nothing new to include\n    resolveOperator(this, operatorStack, operandStack);\n    var finalExpression;\n    if (operandStack.length > 0) {\n        finalExpression = operandStack.pop();\n    } else {\n        finalExpression = new undef_expr(this);\n    }\n    if (parseError.length > 0) {\n        finalExpression.setParsingError(parseError);\n    } else {\n        // Substitute any expressions provided\n        finalExpression = finalExpression.compose(bindings);\n        // Test if context is consistent\n        switch (context) {\n            case 'number':\n                if (!finalExpression.isConstant()) {\n                    throw new TypeError(`The expression ${formulaStr} is expected to be a constant but depends on variables.`);\n                }\n                finalExpression.simplifyConstants();\n                break;\n            case 'formula':\n                break;\n        }\n        finalExpression.setContext(context);\n    }\n    if (options.doFlatten) {\n      finalExpression.flatten();\n    }\n    return finalExpression;\n  }\n}\n\n// Used in parse\nfunction operator(opStr) {\n  this.op = opStr;\n  switch(opStr) {\n    case '+':\n    case '-':\n      this.prec = opPrec.addsub;\n      this.type = exprType.binop;\n      this.valueType = exprValue.numeric;\n      break;\n    case '*':\n    case '/':\n      this.prec = opPrec.multdiv;\n      this.type = exprType.binop;\n      this.valueType = exprValue.numeric;\n      break;\n    case '^':\n      this.prec = opPrec.power;\n      this.type = exprType.binop;\n      this.valueType = exprValue.numeric;\n      break;\n    case '&':\n      this.prec = opPrec.conj;\n      this.type = exprType.binop;\n      this.valueType = exprValue.bool;\n      break;\n    case '$':  // $=or since |=absolute value bar\n//    this.op = '|'\n      this.prec = opPrec.disj;\n      this.type = exprType.binop;\n      this.valueType = exprValue.bool;\n      break;\n    case '=':\n      this.prec = opPrec.equal;\n      this.type = exprType.binop;\n      this.valueType = exprValue.bool;\n      break;\n    case ',':\n      this.prec = opPrec.fop;\n      this.type = exprType.array;\n      this.valueType = exprValue.vector;\n      break;\n    default:\n      this.prec = opPrec.fcn;\n      this.type = exprType.fcn;\n      break;\n  }\n}\n\n\n\n/* An absolute value can be complicated because also a function. \nMay not be clear if nested: |2|x-3|- 5|.\nIs that 2x-15 or abs(2|x-3|-5)?\nResolve by requiring explicit operations: |2*|x-3|-5| or |2|*x-3*|-5|\n*/\nfunction completeAbsValue(formulaStr, startPos) {\n    var pLevel = 1;\n    var charPos = startPos;\n    var wasOp = true; // open absolute value implicitly has previous operation.\n\n    while (pLevel > 0 && charPos < formulaStr.length) {\n        charPos++;\n        // We encounter another absolute value.\n        if (formulaStr.charAt(charPos) == '|') {\n            if (wasOp) { // Must be opening a new absolute value.\n                pLevel++;\n                // wasOp is still true since can't close immediately\n            } else {  // Assume closing absolute value. If not wanted, need operator.\n                pLevel--;\n                // wasOp is still false since just closed a value.\n            }\n        // Keep track of whether just had operator or not.\n        } else if (\"+-*/([\".search(formulaStr.charAt(charPos)) >= 0) {\n            wasOp = true;\n        } else if (formulaStr.charAt(charPos) != ' ') {\n            wasOp = false;\n        }\n    }\n    return(charPos);\n}\n\n// Find the balancing closing parenthesis.\nfunction completeParenthesis(formulaStr, startPos) {\n    var pLevel = 1;\n    var charPos = startPos;\n\n    while (pLevel > 0 && charPos < formulaStr.length) {\n        charPos++;\n        if (formulaStr.charAt(charPos) == ')') {\n            pLevel--;\n        } else if (formulaStr.charAt(charPos) == '(') {\n            pLevel++;\n        }\n    }\n    return(charPos);\n}\n\n// Brackets are used for sequence indexing, not regular grouping.\nfunction completeBracket(formulaStr, startPos, asSubscript) {\n    var pLevel = 1;\n    var charPos = startPos;\n    var fail = false;\n\n    while (pLevel > 0 && charPos < formulaStr.length) {\n        charPos++;\n        if (formulaStr.charAt(charPos) == ']') {\n            pLevel--;\n        } else if (formulaStr.charAt(charPos) == '[') {\n            if (asSubscript) {\n                fail = true;\n            }\n            pLevel++;\n        }\n    }\n    if (asSubscript && fail) {\n        throw \"Nested brackets used for subscripts are not supported.\";\n    }\n    return(charPos);\n}\n\n/* Given a string and a starting position of a name, identify the entire name. */\n/* Require start with letter, then any sequence of *word* character */\n/* Also allow primes for derivatives at the end. */\nfunction completeName(formulaStr, startPos) {\n    var matchRule = /[A-Za-z]\\w*'*/;\n    var match = formulaStr.substr(startPos).match(matchRule);\n    return(startPos + match[0].length);\n}\n\n/* Given a string and a starting position of a number, identify the entire number. */\nfunction completeNumber(formulaStr, startPos, options) {\n    var matchRule;\n    if (options && options.noDecimals) {\n        matchRule = /[0-9]*/;\n    } else {\n        matchRule = /[0-9]*(\\.[0-9]*)?(e-?[0-9]+)?/;\n    }\n    var match = formulaStr.substr(startPos).match(matchRule);\n    return(startPos + match[0].length);\n}\n\n/* Tests a string to see if it can be constructed as a concatentation of known names. */\n/* For example, abc could be a name or could be a*b*c */\n/* Pass in the bindings giving the known names and see if we can build this name */\n/* Return the *first* name that is part of the whole. */\nfunction TestNameIsComposite(text, bindings) {\n    var retStruct = new Object();\n    retStruct.isComposite = false;\n\n    if (bindings !== undefined) {\n        var remain, nextName;\n        if (bindings[text] !== undefined) {\n            retStruct.isComposite = true;\n            retStruct.name = text;\n        } else {\n            // See if the text *starts* with a known name\n            var knownNames = Object.keys(bindings);\n            for (var ikey in knownNames) {\n                nextName = knownNames[ikey];\n                // If *this* name is the start of the text, see if the rest from known names.\n                if (text.search(nextName)==0) {\n                    remain = TestNameIsComposite(text.slice(nextName.length), bindings);\n                    if (remain.isComposite) {\n                        retStruct.isComposite = true;\n                        retStruct.name = nextName;\n                        break;\n                    }\n                }\n            }\n        }\n    }\n    return retStruct;\n}\n  \nexport class BTM {\n    constructor(settings) {\n        this.menv = new MENV(settings);\n\n        // Each instance of BTM environment needs bindings across all expressions.\n        this.data = {};\n        this.data.allValues = {};\n        this.data.params = {};\n        this.data.variables = {};\n        this.data.expressions = {};\n    }\n\n\n    addMathObject(name, context, newObject) {\n        switch(context) {\n            case 'number':\n                if (newObject.isConstant()) {\n                    this.data.params[name] = newObject;\n                    this.data.allValues[name] = newObject;\n                } else {\n                    throw `Attempt to add math object '${name}' with context '${context}' that does not match.`;\n                }\n                break;\n            case 'formula':\n                this.data.allValues[name] = newObject;\n                break;\n        }\n        return newObject;\n    }\n\n    generateRandom(distr, options) {\n       return this.menv.generateRandom(distr,options);\n    }\n\n    addVariable(name, options) {\n        var newVar = new variable_expr(this.menv, name);\n        \n        this.data.variables[name] = newVar;\n        this.data.allValues[name] = newVar;\n\n        return newVar;\n    }\n\n    parseExpression(expression, context) {\n        var newExpr;\n        // Not yet parsed\n        if (typeof expression === 'string') {\n            var formula = this.decodeFormula(expression);\n            newExpr = this.menv.parse(formula, context, this.data.allValues)\n                            .compose(this.data.allValues);\n        // Already parsed\n        } else if (typeof expression === 'object') {\n            newExpr = expression;\n        }\n        return newExpr;\n    }\n\n    evaluateExpression(expression, context, bindings) {\n        var theExpr, newExpr, retValue;\n        // Not yet parsed\n        if (typeof expression === 'string') {\n            var formula = this.decodeFormula(expression);\n            theExpr = this.menv.parse(formula, \"formula\");\n        // Already parsed\n        } else if (typeof expression === 'object') {\n            theExpr = expression;\n        }\n        retValue = theExpr.evaluate(bindings);\n        newExpr = create_scalar(this.menv, retValue);\n        return newExpr;\n    }\n\n    composeExpression(expression, substitution) {\n        var myExpr;\n        // Not yet parsed\n        if (typeof expression === 'string') {\n            var formula = this.decodeFormula(expression);\n            myExpr = this.menv.parse(formula, \"formula\");\n        // Already parsed\n        } else if (typeof expression === 'object') {\n            myExpr = expression;\n        }\n        var mySubs = Object.entries(substitution);\n        var substVar, substExpr;\n        [substVar, substExpr] = mySubs[0];\n        if (typeof substExpr == \"string\") {\n            substExpr = this.menv.parse(substExpr, \"formula\");\n        }\n        var binding = {};\n        binding[substVar] = substExpr;\n        return myExpr.compose(binding);\n    }\n\n    addExpression(name, expression) {\n        var newExpr = this.parseExpression(expression, \"formula\");\n        \n        this.data.expressions[name] = newExpr;\n        this.data.allValues[name] = newExpr;\n\n        return newExpr;\n    }\n\n    addFunction(name, input, expression) {\n        this.menv.addFunction(name, input, expression);\n    }\n\n    // This routine takes the text and looks for strings in mustaches {{name}}\n    // It replaces this element with the corresponding parameter, variable, or expression.\n    // These should have been previously parsed and stored in this.data.\n    decodeFormula(statement, displayMode) {\n        // First find all of the expected substitutions.\n        var substRequestList = {};\n        var matchRE = /\\{\\{[A-Za-z]\\w*\\}\\}/g;\n        var substMatches = statement.match(matchRE);\n        if (substMatches != null) {\n            for (var i=0; i<substMatches.length; i++) {\n                var matchName = substMatches[i];\n                matchName = matchName.substr(2,matchName.length-4);\n                // Now see if the name is in our substitution rules.\n                if (this.data.allValues[matchName] != undefined) {\n                    if (displayMode != undefined && displayMode) {\n                        substRequestList[matchName] = '{'+this.data.allValues[matchName].toTeX()+'}';\n                    } else {\n                        substRequestList[matchName] = '('+this.data.allValues[matchName].toString()+')';\n                    }\n                }\n            }\n        }\n\n        // We are now ready to make the substitutions.\n        var retString = statement;\n        for (var match in substRequestList) {\n            var re = new RegExp(\"{{\" + match + \"}}\", \"g\");\n            var subst = substRequestList[match];\n            retString = retString.replace(re, subst);\n        }\n        return retString;\n    }\n\n    compareExpressions(expr1, expr2) {\n        var myExpr1, myExpr2;\n        // Not yet parsed\n        if (typeof expr1 === 'string') {\n            var formula1 = this.decodeFormula(expr1);\n            myExpr1 = this.menv.parse(formula1, \"formula\");\n        // Already parsed\n        } else if (typeof expr1 === 'object') {\n            myExpr1 = expr1;\n        }\n        if (typeof expr2 === 'string') {\n            var formula2 = this.decodeFormula(expr2);\n            myExpr2 = this.menv.parse(formula2, \"formula\");\n        // Already parsed\n        } else if (typeof expr2 === 'object') {\n            myExpr2 = expr2;\n        }\n\n        return this.menv.compareMathObjects(myExpr1,myExpr2);\n    }\n\n    getParser(context) {\n        return this.menv.getParser(context);\n    }\n}\n"],"names":["Identity","constructor","refExpr","eqExpr","description","isValid","idNum","this","isActive","Match","testRule","bindings","allVars","dependencies","missVars","j","push","subExpr","compose","subTeX","toTeX","subStr","toString","name","type","exprType","binop","valueType","exprValue","bool","equation","numInputs","length","ruleID","newRule","menv","reductionList","useOneWay","constraints","exprFormulas","split","console","log","refID","identity","parse","allRefExpr","uniqueExpr","i","nextExpr","isNew","match","findMatchRules","testExpr","doValidate","matchList","MathObject","select","parent","inputs","undef","context","undefined","value","setContext","setParsingError","errorString","parseError","hasParsingError","retValue","getParsingError","errString","elementOnly","showSelect","toMathML","allStringEquivs","flatten","copy","isConstant","isExpression","expression","super","numeric","evaluate","operateToTeX","treeToTeX","expand","retStruct","current","myCopy","simplifyConstants","forced","inDeps","depArray","Array","master","getInput","whichInput","compare","options","matchInputs","isEqual","knownBindings","Object","keys","unknownBindings","rTol","indexOf","splice","dependA","dependB","x","xOpt","xMin","xMax","dx","n","testPoints","variableList","testPointList","min","max","odometer","matchOp","flatA","flatB","done","y1","y2","isFinite","Math","abs","isNaN","op","inputMatched","matchFound","reduce","matchRules","workExpr","reduceRules","derivative","ivar","varList","create_scalar","expr","inputSubst","origExpr","undef_expr","Number","NaN","real_number","a","number","simplify","equal","other","add","subtract","multiply","divide","addInverse","multInverse","leadSign","str","toFixed","isInt","isInteger","floor","rational_number","p","q","sqrt","b","c","findGCD","valueOf","create_multiop","newInputs","multiop","multiop_expr","prec","opPrec","addsub","multdiv","alert","theStr","opStr","unop","allInputsArrays","indexList","inputPerms","permutations","theOp","buildStringEquivs","leftStr","workInputs","slice","argStrL","argStrR","opStrL","opStrR","minPrec","opString","isCommutative","commutes","retVal","nextInput","tmp","newExpr","constIndex","newConstant","newInput","copyBindings","key","cmpExpr","cmpInputs","prototype","call","diff","dudx","dTerms","dProdTerms","variable_expr","variable","primePos","derivs","isConst","isSpecial","E","PI","Infinity","ivarName","index_expr","index","boundName","k","word","tmpBind","function_expr","inputExpr","restrictDomain","fcn","domain","alternate","builtin","xvar","deriv","binding","getName","repeat","fcnString","retString","argStrings","join","allInputs","inputOptions","generateArgs","left","rightOptions","N","newLeft","texString","argString","inputVal","sin","cos","tan","asin","acos","atan","exp","LOG10E","functionEntry","functions","fBind","forEach","inVar","isArray","varBind","theDeriv","uConst","dydu","unop_expr","theSec","binop_expr","theCot","theTan","theCsc","theCos","theSin","tanSq","theSq","theRad","cotSq","inputA","inputB","power","conj","disj","opAStr","opBStr","allInputsA","allInputsB","replace","inputAVal","inputBVal","pow","absTol","numA","numB","theNumber","negativeNumbers","in0","in1","inA","inB","cmpInputA","cmpInputB","dvdx","vConst","udv","vdu","numer","denom","powDep","theArg","newPow","doFlatten","input","newThis","scalar_expr","deriv_expr","formula","atValue","operator","ivarValue","isRate","exprStr","varStr","valStr","dbind","firstDeriv","RNG","rngSettings","rand","seed","Date","getTime","args","version","s0","s1","s2","initialArgs","uinta","Uint32Array","mashver","_initState","_internalSeed","mash","data","l","h","charCodeAt","Mash","_isInteger","_int","parseInt","random","t","fract53","int32","cycle","_run","range","loBound","hiBound","arguments","restart","versions","window","crypto","getRandomValues","aleaPRNG","setSeed","alea","randSign","randInt","randUniform","randDiscrete","by","nonzero","rndVal","Nvals","randChoice","randRational","pLims","qLims","randHexHash","hash","fop","array","matrix","MENV","settings","randomBindings","relTol","useRelErr","setReductionRules","rngOptions","rng","numberCmp","override","valA","valB","addReductionRule","disableReductionRule","disableRule","addRule","ruleList","generateRandom","distr","addFunction","newTerm","compareMathObjects","expr1","expr2","getParser","self","parseContext","exprString","formulaStr","numberMatch","nameMatch","opMatch","endPos","workingStr","charPos","trim","hasExtraParens","charAt","completeParenthesis","operandStack","operatorStack","resolveOperator","newOp","oldOp","pop","newElement","finalExpression","lastElement","subExprStr","completeAbsValue","substr","search","completeNumber","noDecimals","completeName","theName","testResults","TestNameIsComposite","isComposite","endParen","entries","hasError","completeBracket","error","indexExpr","holdElement","TypeError","vector","startPos","pLevel","wasOp","asSubscript","fail","matchRule","text","nextName","knownNames","ikey","BTM","allValues","params","variables","expressions","addMathObject","newObject","addVariable","newVar","parseExpression","decodeFormula","evaluateExpression","theExpr","composeExpression","substitution","myExpr","substVar","substExpr","mySubs","addExpression","statement","displayMode","substRequestList","substMatches","matchName","re","RegExp","subst","compareExpressions","myExpr1","myExpr2","formula1","formula2"],"sourceRoot":""}