{"version":3,"sources":["jsdelivr-header.js","/npm/nerdamer@1.1.13/Algebra.js"],"names":[],"mappings":"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","file":"/npm/nerdamer@1.1.13/Algebra.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/nerdamer@1.1.13/Algebra.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*\r\n * Author : Martin Donk\r\n * Website : http://www.nerdamer.com\r\n * Email : martin.r.donk@gmail.com\r\n * License : MIT\r\n * Source : https://github.com/jiggzson/nerdamer\r\n */\r\n\r\n/* global module, Function */\r\n\r\nif((typeof module) !== 'undefined') {\r\n    var nerdamer = require('./nerdamer.core.js');\r\n    require('./Calculus.js');\r\n}\r\n\r\n(function () {\r\n    \"use strict\";\r\n\r\n    /*shortcuts*/\r\n    var core = nerdamer.getCore(),\r\n            _ = core.PARSER,\r\n            N = core.groups.N,\r\n            P = core.groups.P,\r\n            S = core.groups.S,\r\n            EX = core.groups.EX,\r\n            FN = core.groups.FN,\r\n            PL = core.groups.PL,\r\n            CP = core.groups.CP,\r\n            CB = core.groups.CB,\r\n            keys = core.Utils.keys,\r\n            even = core.Utils.even,\r\n            variables = core.Utils.variables,\r\n            format = core.Utils.format,\r\n            round = core.Utils.round,\r\n            Frac = core.Frac,\r\n            isInt = core.Utils.isInt,\r\n            Symbol = core.Symbol,\r\n            CONST_HASH = core.Settings.CONST_HASH,\r\n            math = core.Utils.importFunctions(),\r\n            evaluate = core.Utils.evaluate;\r\n    //*************** CLASSES ***************//\r\n    /**\r\n     * Converts a symbol into an equivalent polynomial arrays of \r\n     * the form [[coefficient_1, power_1],[coefficient_2, power_2], ... ]\r\n     * Univariate polymials only. \r\n     * @param {Symbol|Number} symbol\r\n     * @param {String} variable The variable name of the polynomial\r\n     * @param {int} order\r\n     */\r\n    function Polynomial(symbol, variable, order) {\r\n        if(core.Utils.isSymbol(symbol)) {\r\n            this.parse(symbol);\r\n            this.variable = this.variable || variable;\r\n        }\r\n        else if(!isNaN(symbol)) {\r\n            order = order || 0;\r\n            if(variable === undefined)\r\n                throw new core.exceptions.InvalidVariableNameError('Polynomial expects a variable name when creating using order');\r\n            this.coeffs = [];\r\n            this.coeffs[order] = symbol;\r\n            this.fill(symbol);\r\n        }\r\n        else if(typeof symbol === 'string') {\r\n            this.parse(_.parse(symbol));\r\n        }\r\n    }\r\n    /**\r\n     * Creates a Polynomial given an array of coefficients\r\n     * @param {int[]} arr\r\n     * @param {String} variable\r\n     * @returns {Polynomial}\r\n     */\r\n    Polynomial.fromArray = function (arr, variable) {\r\n        if(typeof variable === 'undefined')\r\n            throw new core.exceptions.InvalidVariableNameError('A variable name must be specified when creating polynomial from array');\r\n        var p = new Polynomial();\r\n        p.coeffs = arr;\r\n        p.variable = variable;\r\n        return p;\r\n    };\r\n\r\n    Polynomial.fit = function (c1, c2, n, base, p, variable) {\r\n        //after having looped through and mod 10 the number to get the matching factor\r\n        var terms = new Array(p + 1),\r\n                t = n - c2;\r\n        terms[0] = c2; //the constants is assumed to be correct\r\n        //constant for x^p is also assumed know so add\r\n        terms[p] = c1;\r\n        t -= c1 * Math.pow(base, p);\r\n        //start fitting\r\n        for(var i = p - 1; i > 0; i--) {\r\n            var b = Math.pow(base, i), //we want as many wholes as possible\r\n                    q = t / b,\r\n                    sign = Math.sign(q);\r\n            var c = sign * Math.floor(Math.abs(q));\r\n            t -= c * b;\r\n            terms[i] = c;\r\n        }\r\n        if(t !== 0)\r\n            return null;\r\n        for(var i = 0; i < terms.length; i++)\r\n            terms[i] = new Frac(terms[i]);\r\n\r\n        return Polynomial.fromArray(terms, variable);\r\n    };\r\n\r\n    Polynomial.prototype = {\r\n        /**\r\n         * Converts Symbol to Polynomial\r\n         * @param {Symbol} symbol\r\n         * @param {Array} c - a collector array\r\n         * @returns {Polynomial}\r\n         */\r\n        parse: function (symbol, c) {\r\n            this.variable = variables(symbol)[0];\r\n            if(!symbol.isPoly())\r\n                throw core.exceptions.NerdamerTypeError('Polynomial Expected! Received ' + core.Utils.text(symbol));\r\n            c = c || [];\r\n            if(!symbol.power.absEquals(1))\r\n                symbol = _.expand(symbol);\r\n\r\n            if(symbol.group === core.groups.N) {\r\n                c[0] = symbol.multiplier;\r\n            }\r\n            else if(symbol.group === core.groups.S) {\r\n                c[symbol.power.toDecimal()] = symbol.multiplier;\r\n            }\r\n            else {\r\n                for(var x in symbol.symbols) {\r\n                    var sub = symbol.symbols[x],\r\n                            p = sub.power;\r\n                    if(core.Utils.isSymbol(p))\r\n                        throw new core.exceptions.NerdamerTypeError('power cannot be a Symbol');\r\n\r\n                    p = sub.group === N ? 0 : p.toDecimal();\r\n                    if(sub.symbols) {\r\n                        this.parse(sub, c);\r\n                    }\r\n                    else {\r\n                        c[p] = sub.multiplier;\r\n                    }\r\n                }\r\n            }\r\n\r\n            this.coeffs = c;\r\n\r\n            this.fill();\r\n        },\r\n        /**\r\n         * Fills in the holes in a polynomial with zeroes\r\n         * @param {Number} x - The number to fill the holes with\r\n         */\r\n        fill: function (x) {\r\n            x = Number(x) || 0;\r\n            var l = this.coeffs.length;\r\n            for(var i = 0; i < l; i++) {\r\n                if(this.coeffs[i] === undefined) {\r\n                    this.coeffs[i] = new Frac(x);\r\n                }\r\n            }\r\n            return this;\r\n        },\r\n        /**\r\n         * Removes higher order zeros or a specific coefficient\r\n         * @returns {Array}\r\n         */\r\n        trim: function () {\r\n            var l = this.coeffs.length;\r\n            while(l--) {\r\n                var c = this.coeffs[l];\r\n                var equalsZero = c.equals(0);\r\n                if(c && equalsZero) {\r\n                    if(l === 0)\r\n                        break;\r\n                    this.coeffs.pop();\r\n                }\r\n                else\r\n                    break;\r\n            }\r\n\r\n            return this;\r\n        },\r\n        /*\r\n         * Returns polynomial mod p **currently fails**\r\n         * @param {Number} p\r\n         * @returns {Polynomial}\r\n         */\r\n        modP: function (p) {\r\n            var l = this.coeffs.length;\r\n            for(var i = 0; i < l; i++) {\r\n                var c = this.coeffs[i];\r\n                if(c < 0) { //go borrow\r\n                    var b; //a coefficient > 0\r\n                    for(var j = i; j < l; j++) {//starting from where we left off\r\n                        if(this.coeffs[j] > 0) {\r\n                            b = this.coeffs[j];\r\n                            break;\r\n                        }\r\n                    }\r\n\r\n                    if(b) { //if such a coefficient exists\r\n                        for(j; j > i; j--) { //go down the line and adjust using p\r\n                            this.coeffs[j] = this.coeffs[j].subtract(new Frac(1));\r\n                            this.coeffs[j - 1] = this.coeffs[j - 1].add(new Frac(p));\r\n                        }\r\n                        c = this.coeffs[i]; //reset c\r\n                    }\r\n                }\r\n\r\n                var d = c.mod(p);\r\n                var w = c.subtract(d).divide(p);\r\n                if(!w.equals(0)) {\r\n                    var up_one = i + 1;\r\n                    var next = this.coeffs[up_one] || new Frac(0);\r\n                    next = next.add(w);\r\n                    this.coeffs[up_one] = new Frac(next);\r\n                    this.coeffs[i] = new Frac(d);\r\n                }\r\n            }\r\n\r\n            return this;\r\n        },\r\n        /**\r\n         * Adds together 2 polynomials\r\n         * @param {Polynomial} poly\r\n         */\r\n        add: function (poly) {\r\n            var l = Math.max(this.coeffs.length, poly.coeffs.length);\r\n            for(var i = 0; i < l; i++) {\r\n                var a = (this.coeffs[i] || new Frac(0)),\r\n                        b = (poly.coeffs[i] || new Frac(0));\r\n                this.coeffs[i] = a.add(b);\r\n            }\r\n            return this;\r\n        },\r\n        /**\r\n         * Adds together 2 polynomials\r\n         * @param {Polynomial} poly\r\n         */\r\n        subtract: function (poly) {\r\n            var l = Math.max(this.coeffs.length, poly.coeffs.length);\r\n            for(var i = 0; i < l; i++) {\r\n                var a = (this.coeffs[i] || new Frac(0)),\r\n                        b = (poly.coeffs[i] || new Frac(0));\r\n                this.coeffs[i] = a.subtract(b);\r\n            }\r\n            return this;\r\n        },\r\n        divide: function (poly) {\r\n            var variable = this.variable,\r\n                    dividend = core.Utils.arrayClone(this.coeffs),\r\n                    divisor = core.Utils.arrayClone(poly.coeffs),\r\n                    n = dividend.length,\r\n                    mp = divisor.length - 1,\r\n                    quotient = [];\r\n\r\n            //loop through the dividend\r\n            for(var i = 0; i < n; i++) {\r\n                var p = n - (i + 1);\r\n                //get the difference of the powers\r\n                var d = p - mp;\r\n                //get the quotient of the coefficients\r\n                var q = dividend[p].divide(divisor[mp]);\r\n\r\n                if(d < 0)\r\n                    break;//the divisor is not greater than the dividend\r\n                //place it in the quotient\r\n                quotient[d] = q;\r\n\r\n                for(var j = 0; j <= mp; j++) {\r\n                    //reduce the dividend\r\n                    dividend[j + d] = dividend[j + d].subtract((divisor[j].multiply(q)));\r\n                }\r\n            }\r\n\r\n            //clean up\r\n            var p1 = Polynomial.fromArray(dividend, variable || 'x').trim(), //pass in x for safety\r\n                    p2 = Polynomial.fromArray(quotient, variable || 'x');\r\n            return [p2, p1];\r\n        },\r\n        multiply: function (poly) {\r\n            var l1 = this.coeffs.length, l2 = poly.coeffs.length,\r\n                    c = []; //array to be returned\r\n            for(var i = 0; i < l1; i++) {\r\n                var x1 = this.coeffs[i];\r\n                for(var j = 0; j < l2; j++) {\r\n                    var k = i + j, //add the powers together\r\n                            x2 = poly.coeffs[j],\r\n                            e = c[k] || new Frac(0); //get the existing term from the new array\r\n                    c[k] = e.add(x1.multiply(x2)); //multiply the coefficients and add to new polynomial array\r\n                }\r\n            }\r\n            this.coeffs = c;\r\n            return this;\r\n        },\r\n        /**\r\n         * Checks if a polynomial is zero\r\n         * @returns {Boolean}\r\n         */\r\n        isZero: function () {\r\n            var l = this.coeffs.length;\r\n            for(var i = 0; i < l; i++) {\r\n                var e = this.coeffs[i];\r\n                if(!e.equals(0))\r\n                    return false;\r\n            }\r\n            return true;\r\n        },\r\n        /** \r\n         * Substitutes in a number n into the polynomial p(n)\r\n         * @param {Number} n\r\n         * @returns {Frac}\r\n         */\r\n        sub: function (n) {\r\n            var sum = new Frac(0), l = this.coeffs.length;\r\n            for(var i = 0; i < l; i++) {\r\n                var t = this.coeffs[i];\r\n                if(!t.equals(0))\r\n                    sum = sum.add(t.multiply(new Frac(Math.pow(n, i))));\r\n            }\r\n            return sum;\r\n        },\r\n        /**\r\n         * Returns a clone of the polynomial\r\n         * @returns {Polynomial}\r\n         */\r\n        clone: function () {\r\n            var p = new Polynomial();\r\n            p.coeffs = this.coeffs;\r\n            p.variable = this.variable;\r\n            return p;\r\n        },\r\n        /**\r\n         * Gets the degree of the polynomial\r\n         * @returns {Number}\r\n         */\r\n        deg: function () {\r\n            this.trim();\r\n            return this.coeffs.length - 1;\r\n        },\r\n        /**\r\n         * Returns a lead coefficient\r\n         * @returns {Frac}\r\n         */\r\n        lc: function () {\r\n            return this.coeffs[this.deg()].clone();\r\n        },\r\n        /**\r\n         * Converts polynomial into a monic polynomial\r\n         * @returns {Polynomial}\r\n         */\r\n        monic: function () {\r\n            var lc = this.lc(), l = this.coeffs.length;\r\n            for(var i = 0; i < l; i++)\r\n                this.coeffs[i] = this.coeffs[i].divide(lc);\r\n            return this;\r\n        },\r\n        /**\r\n         * Returns the GCD of two polynomials\r\n         * @param {Polynomial} poly\r\n         * @returns {Polynomial}\r\n         */\r\n        gcd: function (poly) {\r\n            //get the maximum power of each\r\n            var mp1 = this.coeffs.length - 1,\r\n                    mp2 = poly.coeffs.length - 1,\r\n                    T;\r\n            //swap so we always have the greater power first\r\n            if(mp1 < mp2) {\r\n                return poly.gcd(this);\r\n            }\r\n            var a = this;\r\n\r\n            while(!poly.isZero()) {\r\n                var t = poly.clone();\r\n                a = a.clone();\r\n                T = a.divide(t);\r\n                poly = T[1];\r\n                a = t;\r\n            }\r\n\r\n            var gcd = core.Math2.QGCD.apply(null, a.coeffs);\r\n            if(!gcd.equals(1)) {\r\n                var l = a.coeffs.length;\r\n                for(var i = 0; i < l; i++) {\r\n                    a.coeffs[i] = a.coeffs[i].divide(gcd);\r\n                }\r\n            }\r\n            return a;\r\n        },\r\n        /**\r\n         * Differentiates the polynomial\r\n         * @returns {Polynomial}\r\n         */\r\n        diff: function () {\r\n            var new_array = [], l = this.coeffs.length;\r\n            for(var i = 1; i < l; i++)\r\n                new_array.push(this.coeffs[i].multiply(new Frac(i)));\r\n            this.coeffs = new_array;\r\n            return this;\r\n        },\r\n        /**\r\n         * Integrates the polynomial\r\n         * @returns {Polynomial} \r\n         */\r\n        integrate: function () {\r\n            var new_array = [0], l = this.coeffs.length;\r\n            for(var i = 0; i < l; i++) {\r\n                var c = new Frac(i + 1);\r\n                new_array[c] = this.coeffs[i].divide(c);\r\n            }\r\n            this.coeffs = new_array;\r\n            return this;\r\n        },\r\n        /**\r\n         * Returns the Greatest common factor of the polynomial\r\n         * @param {bool} toPolynomial - true if a polynomial is wanted\r\n         * @returns {Frac|Polynomial}\r\n         */\r\n        gcf: function (toPolynomial) {\r\n            //get the first nozero coefficient and returns its power\r\n            var fnz = function (a) {\r\n                for(var i = 0; i < a.length; i++)\r\n                    if(!a[i].equals(0))\r\n                        return i;\r\n            },\r\n                    ca = [];\r\n            for(var i = 0; i < this.coeffs.length; i++) {\r\n                var c = this.coeffs[i];\r\n                if(!c.equals(0) && ca.indexOf(c) === -1)\r\n                    ca.push(c);\r\n            }\r\n            var p = [core.Math2.QGCD.apply(undefined, ca), fnz(this.coeffs)].toDecimal();\r\n\r\n            if(toPolynomial) {\r\n                var parr = [];\r\n                parr[p[1] - 1] = p[0];\r\n                p = Polynomial.fromArray(parr, this.variable).fill();\r\n            }\r\n\r\n            return p;\r\n        },\r\n        /**\r\n         * Raises a polynomial P to a power p -> P^p. e.g. (x+1)^2\r\n         * @param {bool} incl_img - Include imaginary numbers \r\n         */\r\n        quad: function (incl_img) {\r\n            var roots = [];\r\n            if(this.coeffs.length > 3)\r\n                throw new Error('Cannot calculate quadratic order of ' + (this.coeffs.length - 1));\r\n            if(this.coeffs.length === 0)\r\n                throw new Error('Polynomial array has no terms');\r\n            var a = this.coeffs[2] || 0, b = this.coeffs[1] || 0, c = this.coeffs[0];\r\n            var dsc = b * b - 4 * a * c;\r\n            if(dsc < 0 && !incl_img)\r\n                return roots;\r\n            else {\r\n                roots[0] = (-b + Math.sqrt(dsc)) / (2 * a);\r\n                roots[1] = (-b - Math.sqrt(dsc)) / (2 * a);\r\n            }\r\n            return roots;\r\n        },\r\n        /**\r\n         * Makes polynomial square free\r\n         * @returns {Array}\r\n         */\r\n        squareFree: function () {\r\n\r\n            var a = this.clone(),\r\n                    i = 1,\r\n                    b = a.clone().diff(),\r\n                    c = a.clone().gcd(b),\r\n                    w = a.divide(c)[0];\r\n            var output = Polynomial.fromArray([new Frac(1)], a.variable);\r\n            while(!c.equalsNumber(1)) {\r\n                var y = w.gcd(c);\r\n                var z = w.divide(y)[0];\r\n                //one of the factors may have shown up since it's square but smaller than the \r\n                //one where finding\r\n                if(!z.equalsNumber(1) && i > 1) {\r\n                    var t = z.clone();\r\n                    for(var j = 1; j < i; j++)\r\n                        t.multiply(z.clone());\r\n                    z = t;\r\n                }\r\n                output = output.multiply(z);\r\n                i++;\r\n                w = y;\r\n                c = c.divide(y)[0];\r\n            }\r\n\r\n            return [output, w, i];\r\n        },\r\n        /**\r\n         * Converts polynomial to Symbol\r\n         * @returns {Symbol}\r\n         */\r\n        toSymbol: function () {\r\n            var l = this.coeffs.length,\r\n                    variable = this.variable;\r\n            if(l === 0)\r\n                return new core.Symbol(0);\r\n            var end = l - 1, str = '';\r\n\r\n            for(var i = 0; i < l; i++) {\r\n                //place the plus sign for all but the last one\r\n                var plus = i === end ? '' : '+',\r\n                        e = this.coeffs[i];\r\n                if(!e.equals(0))\r\n                    str += (e + '*' + variable + '^' + i + plus);\r\n            }\r\n            return _.parse(str);\r\n        },\r\n        /**\r\n         * Checks if polynomial is equal to a number\r\n         * @param {Number} x\r\n         * @returns {Boolean}\r\n         */\r\n        equalsNumber: function (x) {\r\n            this.trim();\r\n            return this.coeffs.length === 1 && this.coeffs[0].toDecimal() === String(x);\r\n        },\r\n        toString: function () {\r\n            return this.toSymbol().toString();\r\n        }\r\n    };\r\n\r\n    /**\r\n     * TODO\r\n     * ===================================================================================\r\n     * THIS METHOD HAS A NASTY HIDDEN BUG. IT HAS INCONSISTENT RETURN TYPES PRIMARILY DUE TO \r\n     * WRONG ASSUMPTIONS AT THE BEGINNING. THE ASSUMPTION WAS THAT COEFFS WERE ALWAYS GOING BE NUMBERS\r\n     * NOT TAKING INTO ACCOUNT THAT IMAGINARY NUMBERS. FIXING THIS BREAKS WAY TOO MANY TESTS \r\n     * AT THEM MOMENT WHICH I DON'T HAVE TO FIX\r\n     * ===================================================================================\r\n     * If the symbols is of group PL or CP it will return the multipliers of each symbol\r\n     * as these are polynomial coefficients. CB symbols are glued together by multiplication\r\n     * so the symbol multiplier carries the coefficients for all contained symbols.\r\n     * For S it just returns it's own multiplier. This function doesn't care if it's a polynomial or not\r\n     * @param {Array} c The coefficient array\r\n     * @param {boolean} with_order \r\n     * @return {Array}\r\n     */\r\n    Symbol.prototype.coeffs = function (c, with_order) {\r\n        if(with_order && !this.isPoly(true))\r\n            _.error('Polynomial expected when requesting coefficients with order');\r\n        c = c || [];\r\n        var s = this.clone().distributeMultiplier();\r\n        if(s.isComposite()) {\r\n            for(var x in s.symbols) {\r\n                var sub = s.symbols[x];\r\n                if(sub.isComposite()) {\r\n                    sub.clone().distributeMultiplier().coeffs(c, with_order);\r\n                }\r\n                else {\r\n                    if(with_order)\r\n                        c[sub.isConstant() ? 0 : sub.power.toDecimal()] = sub.multiplier;\r\n                    else {\r\n                        c.push(sub.multiplier);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            if(with_order)\r\n                c[s.isConstant(true) ? 0 : s.power.toDecimal()] = s.multiplier;\r\n            else {\r\n                if(s.group === CB && s.isImaginary()) {\r\n                    var m = new Symbol(s.multiplier);\r\n                    s.each(function (x) {\r\n                        //add the imaginary part\r\n                        if(x.isConstant(true) || x.imaginary)\r\n                            m = _.multiply(m, x);\r\n                    });\r\n                    c.push(m);\r\n                }\r\n                else\r\n                    c.push(s.multiplier);\r\n            }\r\n        }\r\n        //fill the holes\r\n        if(with_order) {\r\n            for(var i = 0; i < c.length; i++)\r\n                if(c[i] === undefined)\r\n                    c[i] = new Symbol(0);\r\n        }\r\n        return c;\r\n    };\r\n    Symbol.prototype.tBase = function (map) {\r\n        if(typeof map === 'undefined')\r\n            throw new Error('Symbol.tBase requires a map object!');\r\n        var terms = [];\r\n        var symbols = this.collectSymbols(null, null, null, true),\r\n                l = symbols.length;\r\n        for(var i = 0; i < l; i++) {\r\n            var symbol = symbols[i],\r\n                    g = symbol.group,\r\n                    nterm = new MVTerm(symbol.multiplier, [], map);\r\n            if(g === CB) {\r\n                for(var x in symbol.symbols) {\r\n                    var sym = symbol.symbols[x];\r\n                    nterm.terms[map[x]] = sym.power;\r\n                }\r\n            }\r\n            else {\r\n                nterm.terms[map[symbol.value]] = symbol.power;\r\n            }\r\n\r\n            terms.push(nterm.fill());\r\n            nterm.updateCount();\r\n        }\r\n        return terms;\r\n    };\r\n    Symbol.prototype.altVar = function (x) {\r\n        var m = this.multiplier.toString(), p = this.power.toString();\r\n        return (m === '1' ? '' : m + '*') + x + (p === '1' ? '' : '^' + p);\r\n    };\r\n    /**\r\n     * Checks to see if the symbols contain the same variables\r\n     * @param {Symbol} symbol\r\n     * @returns {Boolean}\r\n     */\r\n    Symbol.prototype.sameVars = function (symbol) {\r\n        if(!(this.symbols || this.group === symbol.group))\r\n            return false;\r\n        for(var x in this.symbols) {\r\n            var a = this.symbols[x], b = symbol.symbols[x];\r\n            if(!b)\r\n                return false;\r\n            if(a.value !== b.value)\r\n                return false;\r\n        }\r\n        return true;\r\n    };\r\n    /**\r\n     * Groups the terms in a symbol with respect to a variable\r\n     * For instance the symbol {a*b^2*x^2+a*b*x^2+x+6} returns [6,1,a*b+a*b^2]\r\n     * @returns {Factors}\r\n     */\r\n    Symbol.prototype.groupTerms = function (x) {\r\n        x = String(x);\r\n        var f, p, egrouped;\r\n        var grouped = [];\r\n        this.each(function (e) {\r\n            if(e.group === PL) {\r\n                egrouped = e.groupTerms(x);\r\n                for(var i = 0; i < egrouped.length; i++) {\r\n                    var el = egrouped[i];\r\n                    if(el)\r\n                        grouped[i] = el;\r\n                }\r\n            }\r\n            else {\r\n                f = core.Utils.decompose_fn(e, x, true);\r\n                p = f.x.value === x ? Number(f.x.power) : 0;\r\n                //check if there's an existing value\r\n                grouped[p] = _.add(grouped[p] || new Symbol(0), f.a);\r\n            }\r\n        });\r\n        return grouped;\r\n    };\r\n    /**\r\n     * Use this to collect Factors\r\n     * @returns {Symbol[]}\r\n     */\r\n    Symbol.prototype.collectFactors = function () {\r\n        var factors = [];\r\n        if(this.group === CB)\r\n            this.each(function (x) {\r\n                factors.push(x.clone());\r\n            });\r\n        else\r\n            factors.push(this.clone());\r\n        return factors;\r\n    };\r\n    /**\r\n     * A container class for factors\r\n     * @returns {Factors}\r\n     */\r\n    function Factors() {\r\n        this.factors = {};\r\n        this.length = 0;\r\n    }\r\n    ;\r\n    Factors.prototype.getNumberSymbolics = function () {\r\n        var n = 0;\r\n        this.each(function (x) {\r\n            if(!x.isConstant(true))\r\n                n++;\r\n        });\r\n        return n;\r\n    };\r\n    /**\r\n     * Adds the factors to the factor object\r\n     * @param {Symbo} s\r\n     * @returns {Factors}\r\n     */\r\n    Factors.prototype.add = function (s) {\r\n        if(s.equals(0))\r\n            return this; //nothing to add\r\n\r\n        //we don't want to carry -1 as a factor. If a factor already exists,\r\n        //then add the minus one to that factor and return.\r\n        if(s.equals(-1) && this.length > 0) {\r\n            var fo = core.Utils.firstObject(this.factors, null, true);\r\n            this.add(_.symfunction(core.Settings.PARENTHESIS, [fo.obj]).negate());\r\n            delete this.factors[fo.key];\r\n            this.length--;\r\n            return this;\r\n        }\r\n\r\n        if(s.group === CB) {\r\n            var factors = this;\r\n            if(!s.multiplier.equals(1))\r\n                factors.add(new Symbol(s.multiplier));\r\n            s.each(function (x) {\r\n                factors.add(x);\r\n            });\r\n        }\r\n        else {\r\n            if(this.preAdd) //if a preAdd function was defined call it to do prep\r\n                s = this.preAdd(s);\r\n            if(this.pFactor) //if the symbol isn't linear add back the power\r\n                s = _.pow(s, new Symbol(this.pFactor));\r\n\r\n            var is_constant = s.isConstant();\r\n            if(is_constant && s.equals(1))\r\n                return this; //don't add 1\r\n            var v = is_constant ? s.value : s.text();\r\n            if(v in this.factors) {\r\n                this.factors[v] = _.multiply(this.factors[v], s);\r\n                //did the addition cancel out the existing factor? If so remove it and decrement the length\r\n                if(this.factors[v].equals(1)) {\r\n                    delete this.factors[v];\r\n                    this.length--;\r\n                }\r\n            }\r\n            else {\r\n                this.factors[v] = s;\r\n                this.length++;\r\n            }\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Converts the factor object to a Symbol\r\n     * @returns {Symbol}\r\n     */\r\n    Factors.prototype.toSymbol = function () {\r\n        var factored = new Symbol(1);\r\n        var factors = Object.values(this.factors).sort(function (a, b) {\r\n            return a.group > b.group;\r\n        });\r\n\r\n        for(var i = 0, l = factors.length; i < l; i++) {\r\n            var f = factors[i];\r\n\r\n            //don't wrap group S or FN\r\n            var factor = f.power.equals(1) && f.fname !== '' /* don't wrap it twice */ ?\r\n                    _.symfunction(core.PARENTHESIS, [f]) : f;\r\n\r\n            factored = _.multiply(factored, factor);\r\n        }\r\n        if(factored.fname === '')\r\n            factored = Symbol.unwrapPARENS(factored);\r\n        return factored;\r\n    };\r\n    /**\r\n     * Merges 2 factor objects into one\r\n     * @param {Factor} o\r\n     * @returns {Factors}\r\n     */\r\n    Factors.prototype.merge = function (o) {\r\n        for(var x in o) {\r\n            if(x in this.factors)\r\n                this.factors[x] = _.multiply(this.factors[x], o[x]);\r\n            else\r\n                this.factors[x] = o[x];\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * The iterator for the factor object\r\n     * @param {Function} f - callback\r\n     * @returns {Factor}\r\n     */\r\n    Factors.prototype.each = function (f) {\r\n        for(var x in this.factors) {\r\n            var factor = this.factors[x];\r\n            if(factor.fname === core.PARENTHESIS && factor.isLinear())\r\n                factor = factor.args[0];\r\n            f.call(this, factor, x);\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Return the number of factors contained in the factor object\r\n     * @returns {int}\r\n     */\r\n    Factors.prototype.count = function () {\r\n        return keys(this.factors).length;\r\n    };\r\n    /**\r\n     * Cleans up factors from -1\r\n     * @returns {undefined}\r\n     */\r\n    Factors.prototype.clean = function () {\r\n        try {\r\n            var h = core.Settings.CONST_HASH;\r\n            if(this.factors[h].lessThan(0)) {\r\n                if(this.factors[h].equals(-1))\r\n                    delete this.factors[h];\r\n                else\r\n                    this.factors[h].negate();\r\n                this.each(function (x) {\r\n                    x.negate();\r\n                });\r\n            }\r\n        }\r\n        catch(e) {\r\n        }\r\n        ;\r\n    };\r\n    Factors.prototype.toString = function () {\r\n        return this.toSymbol().toString();\r\n    };\r\n\r\n    //a wrapper for performing multivariate division\r\n    function MVTerm(coeff, terms, map) {\r\n        this.terms = terms || [];\r\n        this.coeff = coeff;\r\n        this.map = map; //careful! all maps are the same object\r\n        this.sum = new core.Frac(0);\r\n        this.image = undefined;\r\n    }\r\n    ;\r\n    MVTerm.prototype.updateCount = function () {\r\n        this.count = this.count || 0;\r\n        for(var i = 0; i < this.terms.length; i++) {\r\n            if(!this.terms[i].equals(0))\r\n                this.count++;\r\n        }\r\n        return this;\r\n    };\r\n    MVTerm.prototype.getVars = function () {\r\n        var vars = [];\r\n        for(var i = 0; i < this.terms.length; i++) {\r\n            var term = this.terms[i],\r\n                    rev_map = this.getRevMap();\r\n            if(!term.equals(0))\r\n                vars.push(this.rev_map[i]);\r\n        }\r\n        return vars.join(' ');\r\n    };\r\n    MVTerm.prototype.len = function () {\r\n        if(typeof this.count === 'undefined') {\r\n            this.updateCount();\r\n        }\r\n        return this.count;\r\n    };\r\n    MVTerm.prototype.toSymbol = function (rev_map) {\r\n        rev_map = rev_map || this.getRevMap();\r\n        var symbol = new Symbol(this.coeff);\r\n        for(var i = 0; i < this.terms.length; i++) {\r\n            var v = rev_map[i],\r\n                    t = this.terms[i];\r\n            if(t.equals(0) || v === CONST_HASH)\r\n                continue;\r\n            var mapped = new Symbol(v);\r\n            mapped.power = t;\r\n            symbol = _.multiply(symbol, mapped);\r\n        }\r\n        return symbol;\r\n    };\r\n    MVTerm.prototype.getRevMap = function () {\r\n        if(this.rev_map)\r\n            return this.rev_map;\r\n        var o = {};\r\n        for(var x in this.map)\r\n            o[this.map[x]] = x;\r\n        this.rev_map = o;\r\n        return o;\r\n    };\r\n    MVTerm.prototype.generateImage = function () {\r\n        this.image = this.terms.join(' ');\r\n        return this;\r\n    },\r\n            MVTerm.prototype.getImg = function () {\r\n                if(!this.image)\r\n                    this.generateImage();\r\n                return this.image;\r\n            },\r\n            MVTerm.prototype.fill = function () {\r\n                var l = this.map.length;\r\n                for(var i = 0; i < l; i++) {\r\n                    if(typeof this.terms[i] === 'undefined')\r\n                        this.terms[i] = new core.Frac(0);\r\n                    else {\r\n                        this.sum = this.sum.add(this.terms[i]);\r\n                    }\r\n                }\r\n                return this;\r\n            };\r\n    MVTerm.prototype.divide = function (mvterm) {\r\n        var c = this.coeff.divide(mvterm.coeff),\r\n                l = this.terms.length,\r\n                new_mvterm = new MVTerm(c, [], this.map);\r\n        for(var i = 0; i < l; i++) {\r\n            new_mvterm.terms[i] = this.terms[i].subtract(mvterm.terms[i]);\r\n            new_mvterm.sum = new_mvterm.sum.add(new_mvterm.terms[i]);\r\n        }\r\n        return new_mvterm;\r\n    };\r\n    MVTerm.prototype.multiply = function (mvterm) {\r\n        var c = this.coeff.multiply(mvterm.coeff),\r\n                l = this.terms.length,\r\n                new_mvterm = new MVTerm(c, [], this.map);\r\n        for(var i = 0; i < l; i++) {\r\n            new_mvterm.terms[i] = this.terms[i].add(mvterm.terms[i]);\r\n            new_mvterm.sum = new_mvterm.sum.add(new_mvterm.terms[i]);\r\n        }\r\n        return new_mvterm;\r\n    };\r\n    MVTerm.prototype.isZero = function () {\r\n        return this.coeff.equals(0);\r\n    };\r\n    MVTerm.prototype.toString = function () {\r\n        return '{ coeff: ' + this.coeff.toString() + ', terms: [' +\r\n                this.terms.join(',') + ']: sum: ' + this.sum.toString() + ', count: ' + this.count + '}';\r\n    };\r\n\r\n    core.Utils.toMapObj = function (arr) {\r\n        var c = 0, o = {};\r\n        for(var i = 0; i < arr.length; i++) {\r\n            var v = arr[i];\r\n            if(typeof o[v] === 'undefined') {\r\n                o[v] = c;\r\n                c++;\r\n            }\r\n        }\r\n        o.length = c;\r\n        return o;\r\n    };\r\n    core.Utils.filledArray = function (v, n, clss) {\r\n        var a = [];\r\n        while(n--) {\r\n            a[n] = clss ? new clss(v) : v;\r\n        }\r\n        return a;\r\n    };\r\n    core.Utils.arrSum = function (arr) {\r\n        var sum = 0, l = arr.length;\r\n        for(var i = 0; i < l; i++)\r\n            sum += arr[i];\r\n        return sum;\r\n    };\r\n    /**\r\n     * Determines if 2 arrays have intersecting elements.\r\n     * @param {Array} a\r\n     * @param {Array} b\r\n     * @returns {Boolean} True if a and b have intersecting elements.\r\n     */\r\n    core.Utils.haveIntersection = function (a, b) {\r\n        var t;\r\n        if(b.length > a.length)\r\n            t = b, b = a, a = t; // indexOf to loop over shorter\r\n        return a.some(function (e) {\r\n            return b.indexOf(e) > -1;\r\n        });\r\n    };\r\n    /**\r\n     * Substitutes out functions as variables so they can be used in regular algorithms\r\n     * @param {Symbol} symbol\r\n     * @param {Object} map\r\n     * @returns {String} The expression string\r\n     */\r\n    core.Utils.subFunctions = function (symbol, map) {\r\n        map = map || {};\r\n        var subbed = [];\r\n        symbol.each(function (x) {\r\n            if(x.group === FN || x.previousGroup === FN) {\r\n                //we need a new variable name so why not use one of the existing\r\n                var val = core.Utils.text(x, 'hash'), tvar = map[val];\r\n                if(!tvar) {\r\n                    //generate a unique enough name\r\n                    var t = x.fname + keys(map).length;\r\n                    map[val] = t;\r\n                    subbed.push(x.altVar(t));\r\n                }\r\n                else\r\n                    subbed.push(x.altVar(tvar));\r\n            }\r\n            else if(x.group === CB || x.group === PL || x.group === CP) {\r\n                subbed.push(core.Utils.subFunctions(x, map));\r\n            }\r\n            else\r\n                subbed.push(x.text());\r\n        });\r\n        if(symbol.group === CP || symbol.group === PL)\r\n            return symbol.altVar(core.Utils.inBrackets(subbed.join('+')));\r\n        ;\r\n        if(symbol.group === CB)\r\n            return symbol.altVar(core.Utils.inBrackets(subbed.join('*')));\r\n        return symbol.text();\r\n    };\r\n    core.Utils.getFunctionsSubs = function (map) {\r\n        var subs = {};\r\n        //prepare substitutions\r\n        for(var x in map)\r\n            subs[map[x]] = _.parse(x);\r\n        return subs;\r\n    };\r\n\r\n    var __ = core.Algebra = {\r\n        version: '1.4.6',\r\n        proots: function (symbol, decp) {\r\n            //the roots will be rounded up to 7 decimal places.\r\n            //if this causes trouble you can explicitly pass in a different number of places\r\n            //rarr for polynomial of power n is of format [n, coeff x^n, coeff x^(n-1), ..., coeff x^0]\r\n            decp = decp || 7;\r\n            var zeros = 0;\r\n            var known_roots = [];\r\n            var get_roots = function (rarr, powers, max) {\r\n                var roots = calcroots(rarr, powers, max).concat(known_roots);\r\n                for(var i = 0; i < zeros; i++)\r\n                    roots.unshift(0);\r\n                return roots;\r\n            };\r\n\r\n            if(symbol instanceof Symbol && symbol.isPoly()) {\r\n                symbol.distributeMultiplier();\r\n                //make it so the symbol has a constants as the lowest term\r\n                if(symbol.group === PL) {\r\n                    var lowest_pow = core.Utils.arrayMin(keys(symbol.symbols));\r\n                    var lowest_symbol = symbol.symbols[lowest_pow].clone().toUnitMultiplier();\r\n                    symbol = _.expand(_.divide(symbol, lowest_symbol));\r\n                    known_roots.push(0); //add zero since this is a known root\r\n                }\r\n                if(symbol.group === core.groups.S) {\r\n                    return [0];\r\n                }\r\n                else if(symbol.group === core.groups.PL) {\r\n                    var powers = keys(symbol.symbols),\r\n                            minpower = core.Utils.arrayMin(powers),\r\n                            symbol = core.PARSER.divide(symbol, core.PARSER.parse(symbol.value + '^' + minpower));\r\n                }\r\n\r\n                var variable = keys(symbol.symbols).sort().pop(),\r\n                        sym = symbol.group === core.groups.PL ? symbol.symbols : symbol.symbols[variable],\r\n                        g = sym.group,\r\n                        powers = g === S ? [sym.power.toDecimal()] : keys(sym.symbols),\r\n                        rarr = [],\r\n                        max = core.Utils.arrayMax(powers); //maximum power and degree of polynomial to be solved\r\n\r\n                // Prepare the data\r\n                for(var i = 1; i <= max; i++) {\r\n                    var c = 0; //if there is no power then the hole must be filled with a zero\r\n                    if(powers.indexOf(i + '') !== -1) {\r\n                        if(g === S) {\r\n                            c = sym.multiplier;\r\n                        }\r\n                        else {\r\n                            c = sym.symbols[i].multiplier;\r\n                        }\r\n                    }\r\n                    // Insert the coeffient but from the front\r\n                    rarr.unshift(c);\r\n                }\r\n\r\n                rarr.push(symbol.symbols[CONST_HASH].multiplier);\r\n\r\n                if(sym.group === S)\r\n                    rarr[0] = sym.multiplier;//the symbol maybe of group CP with one variable\r\n\r\n                return get_roots(rarr, powers, max);\r\n            }\r\n            else if(core.Utils.isArray(symbol)) {\r\n                var parr = symbol;\r\n                var rarr = [],\r\n                        powers = [],\r\n                        last_power = 0;\r\n                for(var i = 0; i < parr.length; i++) {\r\n\r\n                    var coeff = parr[i][0],\r\n                            pow = parr[i][1],\r\n                            d = pow - last_power - 1;\r\n                    //insert the zeros\r\n                    for(var j = 0; j < d; j++)\r\n                        rarr.unshift(0);\r\n\r\n                    rarr.unshift(coeff);\r\n                    if(pow !== 0)\r\n                        powers.push(pow);\r\n                    last_power = pow;\r\n                }\r\n                var max = Math.max.apply(undefined, powers);\r\n\r\n                return get_roots(rarr, powers, max);\r\n            }\r\n            else {\r\n                throw new core.exceptions.NerdamerTypeError('Cannot calculate roots. Symbol must be a polynomial!');\r\n            }\r\n\r\n            function calcroots(rarr, powers, max) {\r\n                var MAXDEGREE = 100; // Degree of largest polynomial accepted by this script.\r\n\r\n                // Make a clone of the coefficients before appending the max power\r\n                var p = rarr.slice(0);\r\n\r\n                // Divide the string up into its individual entries, which--presumably--are separated by whitespace\r\n                rarr.unshift(max);\r\n\r\n                if(max > MAXDEGREE) {\r\n                    throw new core.exceptions.ValueLimitExceededError(\"This utility accepts polynomials of degree up to \" + MAXDEGREE + \". \");\r\n                }\r\n\r\n                var zeroi = [], // Vector of imaginary components of roots\r\n                        degreePar = {};    // degreePar is a dummy variable for passing the parameter POLYDEGREE by reference\r\n                degreePar.Degree = max;\r\n\r\n                for(i = 0; i < max; i++) {\r\n                    zeroi.push(0);\r\n                }\r\n                var zeror = zeroi.slice(0); // Vector of real components of roots\r\n\r\n                // Find the roots\r\n                //--> Begin Jenkins-Traub\r\n\r\n                /*\r\n                 * A verbatim copy of Mr. David Binner's Jenkins-Traub port\r\n                 */\r\n                function QuadSD_ak1(NN, u, v, p, q, iPar) {\r\n                    // Divides p by the quadratic 1, u, v placing the quotient in q and the remainder in a, b\r\n                    // iPar is a dummy variable for passing in the two parameters--a and b--by reference\r\n                    q[0] = iPar.b = p[0];\r\n                    q[1] = iPar.a = -(u * iPar.b) + p[1];\r\n\r\n                    for(var i = 2; i < NN; i++) {\r\n                        q[i] = -(u * iPar.a + v * iPar.b) + p[i];\r\n                        iPar.b = iPar.a;\r\n                        iPar.a = q[i];\r\n                    }\r\n                    return;\r\n                }\r\n\r\n                function calcSC_ak1(DBL_EPSILON, N, a, b, iPar, K, u, v, qk) {\r\n                    // This routine calculates scalar quantities used to compute the next K polynomial and\r\n                    // new estimates of the quadratic coefficients.\r\n                    // calcSC -\tinteger variable set here indicating how the calculations are normalized\r\n                    // to avoid overflow.\r\n                    // iPar is a dummy variable for passing in the nine parameters--a1, a3, a7, c, d, e, f, g, and h --by reference\r\n\r\n                    // sdPar is a dummy variable for passing the two parameters--c and d--into QuadSD_ak1 by reference\r\n                    var sdPar = new Object(),\r\n                            // TYPE = 3 indicates the quadratic is almost a factor of K\r\n                            dumFlag = 3;\r\n\r\n                    // Synthetic division of K by the quadratic 1, u, v\r\n                    sdPar.b = sdPar.a = 0.0;\r\n                    QuadSD_ak1(N, u, v, K, qk, sdPar);\r\n                    iPar.c = sdPar.a;\r\n                    iPar.d = sdPar.b;\r\n\r\n                    if(Math.abs(iPar.c) <= (100.0 * DBL_EPSILON * Math.abs(K[N - 1]))) {\r\n                        if(Math.abs(iPar.d) <= (100.0 * DBL_EPSILON * Math.abs(K[N - 2])))\r\n                            return dumFlag;\r\n                    }\r\n\r\n                    iPar.h = v * b;\r\n                    if(Math.abs(iPar.d) >= Math.abs(iPar.c)) {\r\n                        // TYPE = 2 indicates that all formulas are divided by d\r\n                        dumFlag = 2;\r\n                        iPar.e = a / (iPar.d);\r\n                        iPar.f = (iPar.c) / (iPar.d);\r\n                        iPar.g = u * b;\r\n                        iPar.a3 = (iPar.e) * ((iPar.g) + a) + (iPar.h) * (b / (iPar.d));\r\n                        iPar.a1 = -a + (iPar.f) * b;\r\n                        iPar.a7 = (iPar.h) + ((iPar.f) + u) * a;\r\n                    }\r\n                    else {\r\n                        // TYPE = 1 indicates that all formulas are divided by c;\r\n                        dumFlag = 1;\r\n                        iPar.e = a / (iPar.c);\r\n                        iPar.f = (iPar.d) / (iPar.c);\r\n                        iPar.g = (iPar.e) * u;\r\n                        iPar.a3 = (iPar.e) * a + ((iPar.g) + (iPar.h) / (iPar.c)) * b;\r\n                        iPar.a1 = -(a * ((iPar.d) / (iPar.c))) + b;\r\n                        iPar.a7 = (iPar.g) * (iPar.d) + (iPar.h) * (iPar.f) + a;\r\n                    }\r\n                    return dumFlag;\r\n                }\r\n\r\n                function nextK_ak1(DBL_EPSILON, N, tFlag, a, b, iPar, K, qk, qp) {\r\n                    // Computes the next K polynomials using the scalars computed in calcSC_ak1\r\n                    // iPar is a dummy variable for passing in three parameters--a1, a3, and a7\r\n                    var temp;\r\n                    if(tFlag == 3) {\t// Use unscaled form of the recurrence\r\n                        K[1] = K[0] = 0.0;\r\n                        for(var i = 2; i < N; i++) {\r\n                            K[i] = qk[i - 2];\r\n                        }\r\n                        return;\r\n                    }\r\n\r\n                    temp = ((tFlag == 1) ? b : a);\r\n                    if(Math.abs(iPar.a1) > (10.0 * DBL_EPSILON * Math.abs(temp))) {\r\n                        // Use scaled form of the recurrence\r\n                        iPar.a7 /= iPar.a1;\r\n                        iPar.a3 /= iPar.a1;\r\n                        K[0] = qp[0];\r\n                        K[1] = -(qp[0] * iPar.a7) + qp[1];\r\n                        for(var i = 2; i < N; i++)\r\n                            K[i] = -(qp[i - 1] * iPar.a7) + qk[i - 2] * iPar.a3 + qp[i];\r\n                    }\r\n                    else {\r\n                        // If a1 is nearly zero, then use a special form of the recurrence\r\n                        K[0] = 0.0;\r\n                        K[1] = -(qp[0] * iPar.a7);\r\n                        for(var i = 2; i < N; i++) {\r\n                            K[i] = -(qp[i - 1] * iPar.a7) + qk[i - 2] * iPar.a3;\r\n                        }\r\n                    }\r\n                    return;\r\n                }\r\n\r\n                function newest_ak1(tFlag, iPar, a, a1, a3, a7, b, c, d, f, g, h, u, v, K, N, p) {\r\n                    // Compute new estimates of the quadratic coefficients using the scalars computed in calcSC_ak1\r\n                    // iPar is a dummy variable for passing in the two parameters--uu and vv--by reference\r\n                    // iPar.a = uu, iPar.b = vv\r\n\r\n                    var a4, a5, b1, b2, c1, c2, c3, c4, temp;\r\n                    iPar.b = iPar.a = 0.0;// The quadratic is zeroed\r\n\r\n                    if(tFlag != 3) {\r\n                        if(tFlag != 2) {\r\n                            a4 = a + u * b + h * f;\r\n                            a5 = c + (u + v * f) * d;\r\n                        }\r\n                        else {\r\n                            a4 = (a + g) * f + h;\r\n                            a5 = (f + u) * c + v * d;\r\n                        }\r\n\r\n                        // Evaluate new quadratic coefficients\r\n                        b1 = -(K[N - 1] / p[N]);\r\n                        b2 = -(K[N - 2] + b1 * p[N - 1]) / p[N];\r\n                        c1 = v * b2 * a1;\r\n                        c2 = b1 * a7;\r\n                        c3 = b1 * b1 * a3;\r\n                        c4 = -(c2 + c3) + c1;\r\n                        temp = -c4 + a5 + b1 * a4;\r\n                        if(temp != 0.0) {\r\n                            iPar.a = -((u * (c3 + c2) + v * (b1 * a1 + b2 * a7)) / temp) + u;\r\n                            iPar.b = v * (1.0 + c4 / temp);\r\n                        }\r\n                    }\r\n                    return;\r\n                }\r\n\r\n                function Quad_ak1(a, b1, c, iPar) {\r\n                    // Calculates the zeros of the quadratic a*Z^2 + b1*Z + c\r\n                    // The quadratic formula, modified to avoid overflow, is used to find the larger zero if the\r\n                    // zeros are real and both zeros are complex. The smaller real zero is found directly from\r\n                    // the product of the zeros c/a.\r\n\r\n                    // iPar is a dummy variable for passing in the four parameters--sr, si, lr, and li--by reference\r\n\r\n                    var b, d, e;\r\n                    iPar.sr = iPar.si = iPar.lr = iPar.li = 0.0;\r\n\r\n                    if(a == 0) {\r\n                        iPar.sr = ((b1 != 0) ? -(c / b1) : iPar.sr);\r\n                        return;\r\n                    }\r\n                    if(c == 0) {\r\n                        iPar.lr = -(b1 / a);\r\n                        return;\r\n                    }\r\n\r\n                    // Compute discriminant avoiding overflow\r\n                    b = b1 / 2.0;\r\n                    if(Math.abs(b) < Math.abs(c)) {\r\n                        e = ((c >= 0) ? a : -a);\r\n                        e = -e + b * (b / Math.abs(c));\r\n                        d = Math.sqrt(Math.abs(e)) * Math.sqrt(Math.abs(c));\r\n                    }\r\n                    else {\r\n                        e = -((a / b) * (c / b)) + 1.0;\r\n                        d = Math.sqrt(Math.abs(e)) * (Math.abs(b));\r\n                    }\r\n\r\n                    if(e >= 0) {\r\n                        // Real zeros\r\n                        d = ((b >= 0) ? -d : d);\r\n                        iPar.lr = (-b + d) / a;\r\n                        iPar.sr = ((iPar.lr != 0) ? (c / (iPar.lr)) / a : iPar.sr);\r\n                    }\r\n                    else {\r\n                        // Complex conjugate zeros\r\n                        iPar.lr = iPar.sr = -(b / a);\r\n                        iPar.si = Math.abs(d / a);\r\n                        iPar.li = -(iPar.si);\r\n                    }\r\n                    return;\r\n                }\r\n\r\n                function QuadIT_ak1(DBL_EPSILON, N, iPar, uu, vv, qp, NN, sdPar, p, qk, calcPar, K) {\r\n                    // Variable-shift K-polynomial iteration for a quadratic factor converges only if the\r\n                    // zeros are equimodular or nearly so.\r\n                    // iPar is a dummy variable for passing in the five parameters--NZ, lzi, lzr, szi, and szr--by reference\r\n                    // sdPar is a dummy variable for passing the two parameters--a and b--in by reference\r\n                    // calcPar is a dummy variable for passing the nine parameters--a1, a3, a7, c, d, e, f, g, and h --in by reference\r\n\r\n                    // qPar is a dummy variable for passing the four parameters--szr, szi, lzr, and lzi--into Quad_ak1 by reference\r\n                    var qPar = new Object(),\r\n                            ee, mp, omp, relstp, t, u, ui, v, vi, zm,\r\n                            i, j = 0, tFlag, triedFlag = 0;   // Integer variables\r\n\r\n                    iPar.NZ = 0;// Number of zeros found\r\n                    u = uu; // uu and vv are coefficients of the starting quadratic\r\n                    v = vv;\r\n\r\n                    do {\r\n                        qPar.li = qPar.lr = qPar.si = qPar.sr = 0.0;\r\n                        Quad_ak1(1.0, u, v, qPar);\r\n                        iPar.szr = qPar.sr;\r\n                        iPar.szi = qPar.si;\r\n                        iPar.lzr = qPar.lr;\r\n                        iPar.lzi = qPar.li;\r\n\r\n                        // Return if roots of the quadratic are real and not close to multiple or nearly\r\n                        // equal and of opposite sign.\r\n                        if(Math.abs(Math.abs(iPar.szr) - Math.abs(iPar.lzr)) > 0.01 * Math.abs(iPar.lzr))\r\n                            break;\r\n\r\n                        // Evaluate polynomial by quadratic synthetic division\r\n\r\n                        QuadSD_ak1(NN, u, v, p, qp, sdPar);\r\n\r\n                        mp = Math.abs(-((iPar.szr) * (sdPar.b)) + (sdPar.a)) + Math.abs((iPar.szi) * (sdPar.b));\r\n\r\n                        // Compute a rigorous bound on the rounding error in evaluating p\r\n\r\n                        zm = Math.sqrt(Math.abs(v));\r\n                        ee = 2.0 * Math.abs(qp[0]);\r\n                        t = -((iPar.szr) * (sdPar.b));\r\n\r\n                        for(i = 1; i < N; i++) {\r\n                            ee = ee * zm + Math.abs(qp[i]);\r\n                        }\r\n\r\n                        ee = ee * zm + Math.abs(t + sdPar.a);\r\n                        ee = (9.0 * ee + 2.0 * Math.abs(t) - 7.0 * (Math.abs((sdPar.a) + t) + zm * Math.abs((sdPar.b)))) * DBL_EPSILON;\r\n\r\n                        // Iteration has converged sufficiently if the polynomial value is less than 20 times this bound\r\n                        if(mp <= 20.0 * ee) {\r\n                            iPar.NZ = 2;\r\n                            break;\r\n                        }\r\n\r\n                        j++;\r\n                        // Stop iteration after 20 steps\r\n                        if(j > 20)\r\n                            break;\r\n                        if(j >= 2) {\r\n                            if((relstp <= 0.01) && (mp >= omp) && (!triedFlag)) {\r\n                                // A cluster appears to be stalling the convergence. Five fixed shift\r\n                                // steps are taken with a u, v close to the cluster.\r\n                                relstp = ((relstp < DBL_EPSILON) ? Math.sqrt(DBL_EPSILON) : Math.sqrt(relstp));\r\n                                u -= u * relstp;\r\n                                v += v * relstp;\r\n\r\n                                QuadSD_ak1(NN, u, v, p, qp, sdPar);\r\n                                for(i = 0; i < 5; i++) {\r\n                                    tFlag = calcSC_ak1(DBL_EPSILON, N, sdPar.a, sdPar.b, calcPar, K, u, v, qk);\r\n                                    nextK_ak1(DBL_EPSILON, N, tFlag, sdPar.a, sdPar.b, calcPar, K, qk, qp);\r\n                                }\r\n\r\n                                triedFlag = 1;\r\n                                j = 0;\r\n\r\n                            }\r\n                        }\r\n                        omp = mp;\r\n\r\n                        // Calculate next K polynomial and new u and v\r\n                        tFlag = calcSC_ak1(DBL_EPSILON, N, sdPar.a, sdPar.b, calcPar, K, u, v, qk);\r\n                        nextK_ak1(DBL_EPSILON, N, tFlag, sdPar.a, sdPar.b, calcPar, K, qk, qp);\r\n                        tFlag = calcSC_ak1(DBL_EPSILON, N, sdPar.a, sdPar.b, calcPar, K, u, v, qk);\r\n                        newest_ak1(tFlag, sdPar, sdPar.a, calcPar.a1, calcPar.a3, calcPar.a7, sdPar.b, calcPar.c, calcPar.d, calcPar.f, calcPar.g, calcPar.h, u, v, K, N, p);\r\n                        ui = sdPar.a;\r\n                        vi = sdPar.b;\r\n\r\n                        // If vi is zero, the iteration is not converging\r\n                        if(vi != 0) {\r\n                            relstp = Math.abs((-v + vi) / vi);\r\n                            u = ui;\r\n                            v = vi;\r\n                        }\r\n                    }\r\n                    while(vi != 0);\r\n                    return;\r\n                }\r\n\r\n                function RealIT_ak1(DBL_EPSILON, iPar, sdPar, N, p, NN, qp, K, qk) {\r\n                    // Variable-shift H-polynomial iteration for a real zero\r\n                    // sss\t- starting iterate = sdPar.a\r\n                    // NZ\t\t- number of zeros found = iPar.NZ\r\n                    // dumFlag\t- flag to indicate a pair of zeros near real axis, returned to iFlag\r\n\r\n                    var ee, kv, mp, ms, omp, pv, s, t,\r\n                            dumFlag, i, j, nm1 = N - 1;   // Integer variables\r\n\r\n                    iPar.NZ = j = dumFlag = 0;\r\n                    s = sdPar.a;\r\n\r\n                    for(; ; ) {\r\n                        pv = p[0];\r\n\r\n                        // Evaluate p at s\r\n                        qp[0] = pv;\r\n                        for(i = 1; i < NN; i++) {\r\n                            qp[i] = pv = pv * s + p[i];\r\n                        }\r\n                        mp = Math.abs(pv);\r\n\r\n                        // Compute a rigorous bound on the error in evaluating p\r\n                        ms = Math.abs(s);\r\n                        ee = 0.5 * Math.abs(qp[0]);\r\n                        for(i = 1; i < NN; i++) {\r\n                            ee = ee * ms + Math.abs(qp[i]);\r\n                        }\r\n\r\n                        // Iteration has converged sufficiently if the polynomial value is less than\r\n                        // 20 times this bound\r\n                        if(mp <= 20.0 * DBL_EPSILON * (2.0 * ee - mp)) {\r\n                            iPar.NZ = 1;\r\n                            iPar.szr = s;\r\n                            iPar.szi = 0.0;\r\n                            break;\r\n                        }\r\n                        j++;\r\n                        // Stop iteration after 10 steps\r\n                        if(j > 10)\r\n                            break;\r\n\r\n                        if(j >= 2) {\r\n                            if((Math.abs(t) <= 0.001 * Math.abs(-t + s)) && (mp > omp)) {\r\n                                // A cluster of zeros near the real axis has been encountered.\r\n                                // Return with iFlag set to initiate a quadratic iteration.\r\n                                dumFlag = 1;\r\n                                iPar.a = s;\r\n                                break;\r\n                            } // End if ((fabs(t) <= 0.001*fabs(s - t)) && (mp > omp))\r\n                        } //End if (j >= 2)\r\n\r\n                        // Return if the polynomial value has increased significantly\r\n                        omp = mp;\r\n\r\n                        // Compute t, the next polynomial and the new iterate\r\n                        qk[0] = kv = K[0];\r\n                        for(i = 1; i < N; i++) {\r\n                            qk[i] = kv = kv * s + K[i];\r\n                        }\r\n\r\n                        if(Math.abs(kv) > Math.abs(K[nm1]) * 10.0 * DBL_EPSILON) {\r\n                            // Use the scaled form of the recurrence if the value of K at s is non-zero\r\n                            t = -(pv / kv);\r\n                            K[0] = qp[0];\r\n                            for(i = 1; i < N; i++) {\r\n                                K[i] = t * qk[i - 1] + qp[i];\r\n                            }\r\n                        }\r\n                        else {\r\n                            // Use unscaled form\r\n                            K[0] = 0.0;\r\n                            for(i = 1; i < N; i++)\r\n                                K[i] = qk[i - 1];\r\n                        }\r\n\r\n                        kv = K[0];\r\n                        for(i = 1; i < N; i++) {\r\n                            kv = kv * s + K[i];\r\n                        }\r\n                        t = ((Math.abs(kv) > (Math.abs(K[nm1]) * 10.0 * DBL_EPSILON)) ? -(pv / kv) : 0.0);\r\n                        s += t;\r\n                    }\r\n                    return dumFlag;\r\n                }\r\n\r\n                function Fxshfr_ak1(DBL_EPSILON, MDP1, L2, sr, v, K, N, p, NN, qp, u, iPar) {\r\n\r\n                    // Computes up to L2 fixed shift K-polynomials, testing for convergence in the linear or\r\n                    // quadratic case. Initiates one of the variable shift iterations and returns with the\r\n                    // number of zeros found.\r\n                    // L2\tlimit of fixed shift steps\r\n                    // iPar is a dummy variable for passing in the five parameters--NZ, lzi, lzr, szi, and szr--by reference\r\n                    // NZ\tnumber of zeros found\r\n                    var sdPar = new Object(), // sdPar is a dummy variable for passing the two parameters--a and b--into QuadSD_ak1 by reference\r\n                            calcPar = new Object(),\r\n                            // calcPar is a dummy variable for passing the nine parameters--a1, a3, a7, c, d, e, f, g, and h --into calcSC_ak1 by reference\r\n\r\n                            qk = new Array(MDP1),\r\n                            svk = new Array(MDP1),\r\n                            a, b, betas, betav, oss, ots, otv, ovv, s, ss, ts, tss, tv, tvv, ui, vi, vv,\r\n                            fflag, i, iFlag = 1, j, spass, stry, tFlag, vpass, vtry;     // Integer variables\r\n\r\n                    iPar.NZ = 0;\r\n                    betav = betas = 0.25;\r\n                    oss = sr;\r\n                    ovv = v;\r\n\r\n                    //Evaluate polynomial by synthetic division\r\n                    sdPar.b = sdPar.a = 0.0;\r\n                    QuadSD_ak1(NN, u, v, p, qp, sdPar);\r\n                    a = sdPar.a;\r\n                    b = sdPar.b;\r\n                    calcPar.h = calcPar.g = calcPar.f = calcPar.e = calcPar.d = calcPar.c = calcPar.a7 = calcPar.a3 = calcPar.a1 = 0.0;\r\n                    tFlag = calcSC_ak1(DBL_EPSILON, N, a, b, calcPar, K, u, v, qk);\r\n\r\n                    for(j = 0; j < L2; j++) {\r\n                        fflag = 1;\r\n\r\n                        // Calculate next K polynomial and estimate v\r\n                        nextK_ak1(DBL_EPSILON, N, tFlag, a, b, calcPar, K, qk, qp);\r\n                        tFlag = calcSC_ak1(DBL_EPSILON, N, a, b, calcPar, K, u, v, qk);\r\n\r\n                        // Use sdPar for passing in uu and vv instead of defining a brand-new variable.\r\n                        // sdPar.a = ui, sdPar.b = vi\r\n                        newest_ak1(tFlag, sdPar, a, calcPar.a1, calcPar.a3, calcPar.a7, b, calcPar.c, calcPar.d, calcPar.f, calcPar.g, calcPar.h, u, v, K, N, p);\r\n                        ui = sdPar.a;\r\n                        vv = vi = sdPar.b;\r\n\r\n                        // Estimate s\r\n                        ss = ((K[N - 1] != 0.0) ? -(p[N] / K[N - 1]) : 0.0);\r\n                        ts = tv = 1.0;\r\n\r\n                        if((j != 0) && (tFlag != 3)) {\r\n                            // Compute relative measures of convergence of s and v sequences\r\n                            tv = ((vv != 0.0) ? Math.abs((vv - ovv) / vv) : tv);\r\n                            ts = ((ss != 0.0) ? Math.abs((ss - oss) / ss) : ts);\r\n\r\n                            // If decreasing, multiply the two most recent convergence measures\r\n                            tvv = ((tv < otv) ? tv * otv : 1.0);\r\n                            tss = ((ts < ots) ? ts * ots : 1.0);\r\n\r\n                            // Compare with convergence criteria\r\n                            vpass = ((tvv < betav) ? 1 : 0);\r\n                            spass = ((tss < betas) ? 1 : 0);\r\n\r\n                            if((spass) || (vpass)) {\r\n\r\n                                // At least one sequence has passed the convergence test.\r\n                                // Store variables before iterating\r\n\r\n                                for(i = 0; i < N; i++) {\r\n                                    svk[i] = K[i];\r\n                                }\r\n                                s = ss;\r\n\r\n                                // Choose iteration according to the fastest converging sequence\r\n\r\n                                stry = vtry = 0;\r\n\r\n                                for(; ; ) {\r\n                                    if((fflag && ((fflag = 0) == 0)) && ((spass) && (!vpass || (tss < tvv)))) {\r\n                                        ;// Do nothing. Provides a quick \"short circuit\".\r\n                                    }\r\n                                    else {\r\n                                        QuadIT_ak1(DBL_EPSILON, N, iPar, ui, vi, qp, NN, sdPar, p, qk, calcPar, K);\r\n                                        a = sdPar.a;\r\n                                        b = sdPar.b;\r\n\r\n                                        if((iPar.NZ) > 0)\r\n                                            return;\r\n\r\n                                        // Quadratic iteration has failed. Flag that it has been tried and decrease the\r\n                                        // convergence criterion\r\n                                        iFlag = vtry = 1;\r\n                                        betav *= 0.25;\r\n\r\n                                        // Try linear iteration if it has not been tried and the s sequence is converging\r\n                                        if(stry || (!spass)) {\r\n                                            iFlag = 0;\r\n                                        }\r\n                                        else {\r\n                                            for(i = 0; i < N; i++)\r\n                                                K[i] = svk[i];\r\n                                        }\r\n                                    }\r\n                                    //fflag = 0;\r\n                                    if(iFlag != 0) {\r\n                                        // Use sdPar for passing in s instead of defining a brand-new variable.\r\n                                        // sdPar.a = s\r\n                                        sdPar.a = s;\r\n                                        iFlag = RealIT_ak1(DBL_EPSILON, iPar, sdPar, N, p, NN, qp, K, qk);\r\n                                        s = sdPar.a;\r\n\r\n                                        if((iPar.NZ) > 0)\r\n                                            return;\r\n\r\n                                        // Linear iteration has failed. Flag that it has been tried and decrease the\r\n                                        // convergence criterion\r\n                                        stry = 1;\r\n                                        betas *= 0.25;\r\n\r\n                                        if(iFlag != 0) {\r\n                                            // If linear iteration signals an almost double real zero, attempt quadratic iteration\r\n                                            ui = -(s + s);\r\n                                            vi = s * s;\r\n                                            continue;\r\n\r\n                                        }\r\n                                    }\r\n\r\n                                    // Restore variables\r\n                                    for(i = 0; i < N; i++)\r\n                                        K[i] = svk[i];\r\n\r\n                                    // Try quadratic iteration if it has not been tried and the v sequence is converging\r\n                                    if(!vpass || vtry)\r\n                                        break;\t\t// Break out of infinite for loop\r\n\r\n                                }\r\n\r\n                                // Re-compute qp and scalar values to continue the second stage\r\n\r\n                                QuadSD_ak1(NN, u, v, p, qp, sdPar);\r\n                                a = sdPar.a;\r\n                                b = sdPar.b;\r\n\r\n                                tFlag = calcSC_ak1(DBL_EPSILON, N, a, b, calcPar, K, u, v, qk);\r\n                            }\r\n                        }\r\n                        ovv = vv;\r\n                        oss = ss;\r\n                        otv = tv;\r\n                        ots = ts;\r\n                    }\r\n                    return;\r\n                }\r\n\r\n                function rpSolve(degPar, p, zeror, zeroi) {\r\n                    var N = degPar.Degree,\r\n                            RADFAC = 3.14159265358979323846 / 180, // Degrees-to-radians conversion factor = PI/180\r\n                            LB2 = Math.LN2, // Dummy variable to avoid re-calculating this value in loop below\r\n                            MDP1 = degPar.Degree + 1,\r\n                            K = new Array(MDP1),\r\n                            pt = new Array(MDP1),\r\n                            qp = new Array(MDP1),\r\n                            temp = new Array(MDP1),\r\n                            // qPar is a dummy variable for passing the four parameters--sr, si, lr, and li--by reference\r\n                            qPar = new Object(),\r\n                            // Fxshfr_Par is a dummy variable for passing parameters by reference : NZ, lzi, lzr, szi, szr);\r\n                            Fxshfr_Par = new Object(),\r\n                            bnd, DBL_EPSILON, df, dx, factor, ff, moduli_max, moduli_min, sc, x, xm,\r\n                            aa, bb, cc, sr, t, u, xxx,\r\n                            j, jj, l, NM1, NN, zerok;// Integer variables\r\n\r\n                    // Calculate the machine epsilon and store in the variable DBL_EPSILON.\r\n                    // To calculate this value, just use existing variables rather than create new ones that will be used only for this code block\r\n                    aa = 1.0;\r\n                    do {\r\n                        DBL_EPSILON = aa;\r\n                        aa /= 2;\r\n                        bb = 1.0 + aa;\r\n                    }\r\n                    while(bb > 1.0);\r\n\r\n                    var LO = Number.MIN_VALUE / DBL_EPSILON,\r\n                            cosr = Math.cos(94.0 * RADFAC), // = -0.069756474\r\n                            sinr = Math.sin(94.0 * RADFAC), // = 0.99756405\r\n                            xx = Math.sqrt(0.5), // = 0.70710678\r\n                            yy = -xx;\r\n\r\n                    Fxshfr_Par.NZ = j = 0;\r\n                    Fxshfr_Par.szr = Fxshfr_Par.szi = Fxshfr_Par.lzr = Fxshfr_Par.lzi = 0.0;\r\n\r\n                    // Remove zeros at the origin, if any\r\n                    while(p[N] == 0) {\r\n                        zeror[j] = zeroi[j] = 0;\r\n                        N--;\r\n                        j++;\r\n                    }\r\n                    NN = N + 1;\r\n\r\n                    // >>>>> Begin Main Loop <<<<<\r\n                    while(N >= 1) { // Main loop\r\n                        // Start the algorithm for one zero\r\n                        if(N <= 2) {\r\n                            // Calculate the final zero or pair of zeros\r\n                            if(N < 2) {\r\n                                zeror[degPar.Degree - 1] = -(p[1] / p[0]);\r\n                                zeroi[degPar.Degree - 1] = 0;\r\n                            }\r\n                            else {\r\n                                qPar.li = qPar.lr = qPar.si = qPar.sr = 0.0;\r\n                                Quad_ak1(p[0], p[1], p[2], qPar);\r\n                                zeror[degPar.Degree - 2] = qPar.sr;\r\n                                zeroi[degPar.Degree - 2] = qPar.si;\r\n                                zeror[degPar.Degree - 1] = qPar.lr;\r\n                                zeroi[degPar.Degree - 1] = qPar.li;\r\n                            }\r\n                            break;\r\n                        }\r\n\r\n                        // Find the largest and smallest moduli of the coefficients\r\n                        moduli_max = 0.0;\r\n                        moduli_min = Number.MAX_VALUE;\r\n\r\n                        for(i = 0; i < NN; i++) {\r\n                            x = Math.abs(p[i]);\r\n                            if(x > moduli_max)\r\n                                moduli_max = x;\r\n                            if((x != 0) && (x < moduli_min))\r\n                                moduli_min = x;\r\n                        }\r\n\r\n                        // Scale if there are large or very small coefficients\r\n                        // Computes a scale factor to multiply the coefficients of the polynomial. The scaling\r\n                        // is done to avoid overflow and to avoid undetected underflow interfering with the\r\n                        // convergence criterion.\r\n                        // The factor is a power of the base.\r\n                        sc = LO / moduli_min;\r\n\r\n                        if(((sc <= 1.0) && (moduli_max >= 10)) || ((sc > 1.0) && (Number.MAX_VALUE / sc >= moduli_max))) {\r\n                            sc = ((sc == 0) ? Number.MIN_VALUE : sc);\r\n                            l = Math.floor(Math.log(sc) / LB2 + 0.5);\r\n                            factor = Math.pow(2.0, l);\r\n                            if(factor != 1.0) {\r\n                                for(i = 0; i < NN; i++)\r\n                                    p[i] *= factor;\r\n                            }\r\n                        }\r\n\r\n                        // Compute lower bound on moduli of zeros\r\n                        for(var i = 0; i < NN; i++)\r\n                            pt[i] = Math.abs(p[i]);\r\n                        pt[N] = -(pt[N]);\r\n                        NM1 = N - 1;\r\n\r\n                        // Compute upper estimate of bound\r\n                        x = Math.exp((Math.log(-pt[N]) - Math.log(pt[0])) / N);\r\n\r\n                        if(pt[NM1] != 0) {\r\n                            // If Newton step at the origin is better, use it\r\n                            xm = -pt[N] / pt[NM1];\r\n                            x = ((xm < x) ? xm : x);\r\n                        }\r\n\r\n                        // Chop the interval (0, x) until ff <= 0\r\n                        xm = x;\r\n                        do {\r\n                            x = xm;\r\n                            xm = 0.1 * x;\r\n                            ff = pt[0];\r\n                            for(var i = 1; i < NN; i++) {\r\n                                ff = ff * xm + pt[i];\r\n                            }\r\n                        }\r\n                        while(ff > 0); // End do-while loop\r\n\r\n                        dx = x;\r\n                        // Do Newton iteration until x converges to two decimal places\r\n\r\n                        do {\r\n                            df = ff = pt[0];\r\n                            for(var i = 1; i < N; i++) {\r\n                                ff = x * ff + pt[i];\r\n                                df = x * df + ff;\r\n                            } // End for i\r\n                            ff = x * ff + pt[N];\r\n                            dx = ff / df;\r\n                            x -= dx;\r\n                        }\r\n                        while(Math.abs(dx / x) > 0.005); // End do-while loop\r\n\r\n                        bnd = x;\r\n\r\n                        // Compute the derivative as the initial K polynomial and do 5 steps with no shift\r\n                        for(var i = 1; i < N; i++)\r\n                            K[i] = (N - i) * p[i] / N;\r\n                        K[0] = p[0];\r\n                        aa = p[N];\r\n                        bb = p[NM1];\r\n                        zerok = ((K[NM1] == 0) ? 1 : 0);\r\n\r\n                        for(jj = 0; jj < 5; jj++) {\r\n                            cc = K[NM1];\r\n                            if(zerok) {\r\n                                // Use unscaled form of recurrence\r\n                                for(var i = 0; i < NM1; i++) {\r\n                                    j = NM1 - i;\r\n                                    K[j] = K[j - 1];\r\n                                } // End for i\r\n                                K[0] = 0;\r\n                                zerok = ((K[NM1] == 0) ? 1 : 0);\r\n                            }\r\n                            else {\r\n                                // Used scaled form of recurrence if value of K at 0 is nonzero\r\n                                t = -aa / cc;\r\n                                for(var i = 0; i < NM1; i++) {\r\n                                    j = NM1 - i;\r\n                                    K[j] = t * K[j - 1] + p[j];\r\n                                } // End for i\r\n                                K[0] = p[0];\r\n                                zerok = ((Math.abs(K[NM1]) <= Math.abs(bb) * DBL_EPSILON * 10.0) ? 1 : 0);\r\n                            }\r\n                        }\r\n\r\n                        // Save K for restarts with new shifts\r\n                        for(var i = 0; i < N; i++)\r\n                            temp[i] = K[i];\r\n\r\n                        // Loop to select the quadratic corresponding to each new shift\r\n                        for(jj = 1; jj <= 20; jj++) {\r\n\r\n                            // Quadratic corresponds to a double shift to a non-real point and its\r\n                            // complex conjugate. The point has modulus BND and amplitude rotated\r\n                            // by 94 degrees from the previous shift.\r\n\r\n                            xxx = -(sinr * yy) + cosr * xx;\r\n                            yy = sinr * xx + cosr * yy;\r\n                            xx = xxx;\r\n                            sr = bnd * xx;\r\n                            u = -(2.0 * sr);\r\n\r\n                            // Second stage calculation, fixed quadratic\r\n                            Fxshfr_ak1(DBL_EPSILON, MDP1, 20 * jj, sr, bnd, K, N, p, NN, qp, u, Fxshfr_Par);\r\n\r\n                            if(Fxshfr_Par.NZ != 0) {\r\n                                // The second stage jumps directly to one of the third stage iterations and\r\n                                // returns here if successful. Deflate the polynomial, store the zero or\r\n                                // zeros, and return to the main algorithm.\r\n                                j = degPar.Degree - N;\r\n                                zeror[j] = Fxshfr_Par.szr;\r\n                                zeroi[j] = Fxshfr_Par.szi;\r\n                                NN = NN - Fxshfr_Par.NZ;\r\n                                N = NN - 1;\r\n                                for(var i = 0; i < NN; i++)\r\n                                    p[i] = qp[i];\r\n                                if(Fxshfr_Par.NZ != 1) {\r\n                                    zeror[j + 1] = Fxshfr_Par.lzr;\r\n                                    zeroi[j + 1] = Fxshfr_Par.lzi;\r\n                                }\r\n                                break;\r\n                            }\r\n                            else {\r\n                                // If the iteration is unsuccessful, another quadratic is chosen after restoring K\r\n                                for(var i = 0; i < N; i++) {\r\n                                    K[i] = temp[i];\r\n                                }\r\n                            }\r\n                        }\r\n                        // Return with failure if no convergence with 20 shifts\r\n                        if(jj > 20) {\r\n                            degPar.Degree -= N;\r\n                            break;\r\n                        }\r\n                    }\r\n                    // >>>>> End Main Loop <<<<<\r\n                    return;\r\n                }\r\n                //--> End Jenkins-Traub\r\n                rpSolve(degreePar, p, zeror, zeroi);\r\n\r\n                var l = zeroi.length;\r\n                //format the output\r\n                for(i = 0; i < l; i++) {\r\n                    // We round the imaginary part to avoid having something crazy like 5.67e-16.\r\n                    var img = round(zeroi[i], decp + 8),\r\n                            real = round(zeror[i], decp + 8);\r\n                    // Did the rounding pay off? If the rounding did nothing more than chop off a few digits then no.\r\n                    // If the rounding results in a a number at least 3 digits shorter we'll keep it else we'll keep \r\n                    // the original otherwise the rounding was worth it.\r\n                    real = decp - String(real).length > 2 ? real : zeror[i];\r\n                    var sign = img < 0 ? '-' : '';\r\n\r\n                    // Remove the zeroes\r\n                    if(real === 0) {\r\n                        real = '';\r\n                    }\r\n                    if(img === 0) {\r\n                        img = '';\r\n                    }\r\n\r\n                    // Remove 1 as the multiplier and discard imaginary part if there isn't one.\r\n                    img = Math.abs(img) === 1 ? sign + 'i' : (img ? img + '*i' : '');\r\n\r\n                    var num = (real && img) ? real + '+' + img : real + img;\r\n                    zeror[i] = num.replace(/\\+\\-/g, '-');\r\n                }\r\n                return zeror;\r\n            }\r\n        },\r\n        roots: function (symbol) {\r\n\r\n            if(symbol.isConstant(true, true)) {\r\n                return core.Utils.nroots(symbol);\r\n            }\r\n            var roots = __.proots(symbol).map(function (x) {\r\n                return _.parse(x);\r\n            });\r\n            return core.Vector.fromArray(roots);\r\n        },\r\n        froot: function (f, guess, dx) {\r\n            var newtonraph = function (xn) {\r\n                var mesh = 1e-12,\r\n                        // If the derivative was already provided then don't recalculate.\r\n                        df = dx ? dx : core.Utils.build(core.Calculus.diff(f.clone())),\r\n                        // If the function was passed in as a function then don't recalculate.\r\n                        fn = f instanceof Function ? f : core.Utils.build(f),\r\n                        max = 10000,\r\n                        done = false,\r\n                        safety = 0;\r\n                while(!done) {\r\n                    var x = xn - (fn(xn) / df(xn));\r\n                    //absolute values for both x & xn ensures that we indeed have the radius    \r\n                    var r = Math.abs(x) - Math.abs(xn),\r\n                            delta = Math.abs(r);\r\n                    xn = x;\r\n\r\n                    if(delta < mesh)\r\n                        done = true;\r\n                    else if(safety > max) {\r\n                        xn = null;\r\n                        done = true;\r\n                    }\r\n\r\n                    safety++;\r\n                }\r\n                return xn;\r\n            };\r\n            return newtonraph(Number(guess));\r\n        },\r\n        quad: function (a, b, c) {\r\n            var q = function (a, b, c, sign) {\r\n                return _.parse('-(' + b + '+' + sign + '*sqrt((' + b + ')^2-4*(' + a + ')*(' + c + ')))/(2*' + a + ')');\r\n            };\r\n            return [q(a, b, c, 1), q(a, b, c, -1)];\r\n        },\r\n        sumProd: function (a, b) {\r\n            return __.quad(-b, a, -1).map(function (x) {\r\n                return x.invert();\r\n            });\r\n        },\r\n        coeffs: function (symbol, wrt, coeffs) {\r\n            wrt = String(wrt);\r\n            symbol = _.expand(symbol);\r\n            coeffs = coeffs || [new Symbol(0)];\r\n            //we cannot get coeffs for group EX\r\n            if(symbol.group === EX && symbol.contains(wrt, true))\r\n                _.error('Unable to get coefficients using expression ' + symbol.toString());\r\n            var vars = variables(symbol);\r\n            if(vars.length === 1 && vars[0] === wrt && !symbol.isImaginary()) {\r\n                var a = new Polynomial(symbol).coeffs.map(function (x) {\r\n                    return new Symbol(x);\r\n                });\r\n\r\n                for(var i = 0, l = a.length; i < l; i++) {\r\n                    var coeff = a[i],\r\n                            e = coeffs[i];\r\n                    if(e)\r\n                        coeff = _.add(e, coeff);\r\n                    coeffs[i] = coeff; //transfer it all over\r\n                }\r\n            }\r\n            else {\r\n                if(!wrt)\r\n                    _.error('Polynomial contains more than one variable. Please specify which variable is to be used!');\r\n                //if the variable isn't part of this polynomial then we're looking at x^0\r\n\r\n                if(vars.indexOf(wrt) === -1) {\r\n                    coeffs[0] = _.add(symbol, coeffs[0]);\r\n                }\r\n                else {\r\n                    coeffs = coeffs || [new Symbol(0)];\r\n                    if(symbol.group === CB) {\r\n                        var s = symbol.symbols[wrt];\r\n                        if(!s)\r\n                            _.error('Expression is not a polynomial!');\r\n                        var p = Number(s.power);\r\n                        coeff = _.divide(symbol.clone(), s.clone());\r\n                        if(coeff.contains(wrt, true) || p < 0 || !isInt(p))\r\n                            _.error('Expression is not a polynomial!');\r\n                        var e = coeffs[p];\r\n                        if(e)\r\n                            coeff = _.add(e, coeff);\r\n                        coeffs[p] = coeff;\r\n                    }\r\n                    else if(symbol.group === CP) {\r\n                        symbol.each(function (x) {\r\n                            __.coeffs(x.clone(), wrt, coeffs);\r\n                        }, true);\r\n                    }\r\n                }\r\n            }\r\n            //fill holes\r\n            for(var i = 0, l = coeffs.length; i < l; i++)\r\n                if(typeof coeffs[i] === 'undefined')\r\n                    coeffs[i] = new Symbol(0);\r\n\r\n            return coeffs;\r\n        },\r\n        /**\r\n         * Get's all the powers of a particular polynomial including the denominators. The denominators powers\r\n         * are returned as negative. All remaining polynomials are returned as zero order polynomials.\r\n         * for example polyPowers(x^2+1/x+y+t) will return [ '-1', 0, '2' ]\r\n         * @param {Symbol} e\r\n         * @param {String} for_variable\r\n         * @param {Array} powers\r\n         * @returns {Array} An array of the powers\r\n         */\r\n        //assumes you've already verified that it's a polynomial\r\n        polyPowers: function (e, for_variable, powers) {\r\n            powers = powers || [];\r\n            var g = g = e.group;\r\n            if(g === PL && for_variable === e.value) {\r\n                powers = powers.concat(keys(e.symbols));\r\n            }\r\n            else if(g === CP) {\r\n                for(var s in e.symbols) {\r\n                    var symbol = e.symbols[s];\r\n                    var g = symbol.group, v = symbol.value;\r\n                    if(g === S && for_variable === v)\r\n                        powers.push(symbol.power);\r\n                    else if(g === PL || g === CP)\r\n                        powers = __.polyPowers(symbol, for_variable, powers);\r\n                    else if(g === CB && symbol.contains(for_variable)) {\r\n                        var t = symbol.symbols[for_variable];\r\n                        if(t)\r\n                            powers.push((t.power));\r\n                    }\r\n                    else if(g === N || for_variable !== v)\r\n                        powers.push(0);\r\n                }\r\n            }\r\n            else if(g === CB && e.contains(for_variable)) {\r\n                powers.push(core.Utils.decompose_fn(e, for_variable, true).x.power);\r\n            }\r\n            return core.Utils.arrayUnique(powers).sort();\r\n        },\r\n        //The factor object\r\n        Factor: {\r\n            //splits the symbol in symbol and constant\r\n            split: function (symbol) {\r\n                var c = new Symbol(1); //the constants part\r\n                var s = new Symbol(1); //the symbolic part\r\n                __.Factor.factor(symbol, new Factors()).each(function (x) {\r\n                    var t = _.parse(x);\r\n                    if(x.isConstant(true)) {\r\n                        c = _.multiply(c, t);\r\n                    }\r\n                    else {\r\n                        s = _.multiply(s, t);\r\n                    }\r\n                });\r\n                return [c, s];\r\n            },\r\n            mix: function (o, include_negatives) {\r\n                var factors = keys(o);\r\n                var l = factors.length;\r\n                var m = [];//create a row which we'r going to be mixing\r\n                for(var i = 0; i < l; i++) {\r\n                    var factor = factors[i],\r\n                            p = o[factor];\r\n                    var ll = m.length;\r\n                    for(var j = 0; j < ll; j++) {\r\n                        var t = m[j] * factor;\r\n                        m.push(t);\r\n                        if(include_negatives)\r\n                            m.push(-t);\r\n                    }\r\n\r\n                    for(var j = 1; j <= p; j++)\r\n                        m.push(Math.pow(factor, j));\r\n                }\r\n                return m;\r\n            },\r\n            //TODO: this method is to replace common factoring\r\n            common: function (symbol, factors) {\r\n                try {\r\n                    if(symbol.group === CP) {\r\n                        //this may have the unfortunate side effect of expanding and factoring again\r\n                        //to only end up with the same result. \r\n                        //TODO: try to avoid this\r\n                        //collect the symbols and sort to have the longest first. Thinking is that the longest terms \r\n                        //has to contain the variable in order for it to be factorable\r\n                        var symbols = _.expand(symbol.clone(), true).collectSymbols(null, null, function (a, b) {\r\n                            return (b.length || 1) - (a.length || 1);\r\n                        });\r\n\r\n                        var map = {}; //create a map of common factors\r\n                        var coeffs = [];\r\n                        for(var i = 0; i < symbols.length; i++) {\r\n                            var sym = symbols[i];\r\n                            coeffs.push(sym.multiplier.clone());\r\n                            sym.each(function (x) {\r\n                                var p = Number(x.power);\r\n                                //This check exits since we have a symbolic power.\r\n                                //For the future... think about removing this check and modify for symbolic powers\r\n                                if(isNaN(p))\r\n                                    throw new Error('exiting');\r\n                                //loop through the symbols and lump together common terms\r\n                                if(x.value in map) {\r\n                                    if(p < map[x.value][0])\r\n                                        map[x.value][0] = p;\r\n                                    map[x.value][1].push(x);\r\n                                }\r\n                                else\r\n                                    map[x.value] = [p, [x]];\r\n                            });\r\n                        }\r\n                        //the factor\r\n                        var factor = new Symbol(1);\r\n                        for(var x in map) {\r\n                            //if this factor is found in all terms since the length of \r\n                            //matching variable terms matches the number of original terms\r\n                            if(map[x][1].length === symbols.length) {\r\n                                //generate a symbol and multiply into the factor\r\n                                factor = _.multiply(factor, _.pow(new Symbol(x), new Symbol(map[x][0])));\r\n                            }\r\n                        }\r\n                        //get coefficient factor\r\n                        var c = core.Math2.QGCD.apply(null, coeffs);\r\n\r\n                        if(!c.equals(1)) {\r\n                            factors.add(new Symbol(c));\r\n                            for(var i = 0; i < symbols.length; i++) {\r\n                                symbols[i].multiplier = symbols[i].multiplier.divide(c);\r\n                            }\r\n                        }\r\n\r\n                        //if we actuall found any factors\r\n                        if(!factor.equals(1)) {\r\n                            factors.add(factor);\r\n                            symbol = new Symbol(0);\r\n                            for(var i = 0; i < symbols.length; i++) {\r\n                                symbol = _.add(symbol, _.divide(symbols[i], factor.clone()));\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                catch(e) {\r\n                    ;\r\n                }\r\n\r\n                return symbol;\r\n            },\r\n            zeroes: function (symbol, factors) {\r\n                var exit = function () {\r\n                    throw new core.exceptions.ValueLimitExceededError('Exiting');\r\n                };\r\n                try {\r\n                    var vars, term, sum, p, e;\r\n                    symbol = _.expand(symbol.clone());\r\n                    e = symbol.toString();\r\n                    vars = variables(symbol);\r\n\r\n                    sum = new Symbol(0);\r\n\r\n                    var terms = [];\r\n                    var powers = [];\r\n\r\n                    //start setting each variable to zero\r\n                    for(var i = 0, l = vars.length; i < vars.length; i++) {\r\n                        var subs = {};\r\n                        //we want to create a subs object with all but the current variable set to zero\r\n                        for(var j = 0; j < l; j++)\r\n                            if(i !== j) //make sure we're not looking at the same variable\r\n                                subs[vars[j]] = 0;\r\n                        term = _.parse(e, subs);\r\n                        var tp = term.power;\r\n                        //the temporary power has to be an integer as well\r\n                        if(!isInt(tp))\r\n                            exit();\r\n                        terms.push(term);\r\n                        powers.push(term.power);\r\n                    }\r\n\r\n                    //get the gcd. This will be the p in (a^n+b^m)^p\r\n                    //if the gcd equals 1 meaning n = m then we need a tie breakder\r\n                    if(core.Utils.allSame(powers)) {\r\n                        //get p given x number of terms\r\n                        var n_terms = symbol.length;\r\n                        //the number of zeroes determines\r\n                        var n_zeroes = terms.length;\r\n                        if(n_zeroes === 2) {\r\n                            p = new Frac(powers[0] / (n_terms - 1));\r\n                        }\r\n                        if(n_zeroes === 3) {\r\n                            p = new Frac(powers[0] / Math.round((Math.sqrt(8 * n_terms - 1) - 3) / 2));\r\n                        }\r\n                        /*\r\n                         //get the lowest possible power\r\n                         //e.g. given b^4+2*a^2*b^2+a^4, the power we're looking for would be 2\r\n                         symbol.each(function(x) {\r\n                         if(x.group === CB)\r\n                         x.each(function(y) {\r\n                         if(!p || y.power.lessThan(p))\r\n                         //p = Number(y.power);\r\n                         p = y.power;\r\n                         });\r\n                         else if(!p || x.power.lessThan(p))\r\n                         //p = Number(x.power);\r\n                         p = x.power;\r\n                         });\r\n                         */\r\n                    }\r\n                    else\r\n                        //p is just the gcd of the powers\r\n                        p = core.Math2.QGCD.apply(null, powers);\r\n\r\n                    //if we don't have an integer then exit\r\n                    if(!isInt(p))\r\n                        exit();\r\n\r\n                    //build the factor\r\n                    for(var i = 0; i < terms.length; i++) {\r\n                        var t = terms[i];\r\n                        var n = t.power.clone().divide(p);\r\n                        t.multiplier = new Frac(Math.pow(t.multiplier, 1 / n));\r\n                        t.power = p.clone();\r\n                        sum = _.add(sum, t);\r\n                    }\r\n\r\n                    //by now we have the factor of zeroes. We'll know if we got it right because \r\n                    //we'll get a remainder of zero each time we divide by it\r\n                    if(sum.group !== CP)\r\n                        return symbol; //nothing to do\r\n\r\n                    while(true) {\r\n                        var d = __.div(symbol.clone(), sum.clone());\r\n                        if(d[1].equals(0)) {\r\n                            symbol = d[0];\r\n                            factors.add(sum.clone());\r\n                            if(symbol.equals(1)) //we've reached 1 so done.\r\n                                break;\r\n                        }\r\n                        else\r\n                            break;\r\n                    }\r\n                }\r\n                catch(e) {\r\n                }\r\n                ;\r\n\r\n                return symbol;\r\n            },\r\n            factor: function (symbol, factors) {\r\n                // Don't try to factor constants\r\n                if(symbol.isConstant()) {\r\n                    return core.Math2.factor(symbol);\r\n                }\r\n\r\n                var _symbol = _.parse(symbol);\r\n                var retval = __.Factor._factor(_symbol, factors);\r\n                if(retval.equals(symbol)) {\r\n                    return retval;\r\n                }\r\n\r\n                if(retval.group === CB) {\r\n                    var t = new Symbol(1);\r\n                    var p = _.parse(retval.power);\r\n                    //store the multiplier and strip it\r\n                    var m = _.parse(retval.multiplier);\r\n\r\n                    retval.toUnitMultiplier();\r\n\r\n                    /* \r\n                     * NOTE: for sign issues with factor START DEBUGGING HERE\r\n                     */\r\n                    //move the sign to t\r\n                    if(retval.multiplier.lessThan(0)) {\r\n                        t.negate();\r\n                        retval.negate();\r\n                    }\r\n\r\n                    retval.each(function (x) {\r\n                        // Related to #566. Since the symbol's group may not have been properly\r\n                        // updated, it's easier to just parse the symbol and have the parser \r\n                        // do the update for us.\r\n                        var factored = _.parse(__.Factor._factor(x));\r\n\r\n                        if(factored.group === CB) {\r\n                            // Include the multiplier\r\n                            m = _.multiply(m, Symbol.create(factored.multiplier));\r\n                            factored.each(function (y) {\r\n                                var _factored = _.parse(__.Factor._factor(y));\r\n                                t = _.multiply(t, _factored);\r\n                                if(_factored.group === CB) {\r\n                                    m = _.multiply(m, Symbol.create(_factored.multiplier));\r\n                                }\r\n                            });\r\n                        }\r\n                        else {\r\n                            t = _.multiply(t, factored);\r\n                        }\r\n                    });\r\n\r\n                    //put back the multiplier and power\r\n                    retval = _.pow(_.multiply(m, t), p);\r\n                }\r\n\r\n                return retval;\r\n            },\r\n            quadFactor: function (symbol, factors) {\r\n                if(symbol.isPoly() && __.degree(symbol.equals(2))) {\r\n                    //We've  already checked that we're dealing with a polynomial\r\n                    var v = core.Utils.variables(symbol)[0]; //get the variable\r\n                    var coeffs = __.coeffs(symbol, v);\r\n                    //factor the lead coefficient\r\n                    var cf = __.Factor._factor(coeffs[2].clone());\r\n                    //check if we have factors\r\n                    if(cf.group === CB) {\r\n                        var symbols = cf.collectSymbols();\r\n                        //if the factors are greater than 2 we're done so exit\r\n                        if(symbols.length > 2)\r\n                            return symbol;\r\n                        //if we have two factors then attempt to factor the polynomial\r\n                        //let the factors be f1 and f1\r\n                        //let the factors be (ax+b)(cx+d)\r\n                        //let the coefficients be c1x^2+c2x+c3\r\n                        //then a(x1)+c(x2)=c2 and x1*x2=c3\r\n                        //we can solve for x1 and x2\r\n                        var c = _.multiply(_.parse(coeffs[0]), _.parse(symbols[0]));\r\n                        var b = _.parse(coeffs[1]).negate();\r\n                        var a = _.parse(symbols[1]);\r\n                        //solve the system\r\n                        var root = __.quad(a, b, c).filter(function (x) {\r\n                            if(core.Utils.isInt(x))\r\n                                return x;\r\n                        });\r\n                        //if we have one root then find the other one by dividing the constant\r\n                        if(root.length === 1) {\r\n                            var root1 = root[0];\r\n                            var root2 = _.divide(coeffs[0], _.parse(root1));\r\n                            if(core.Utils.isInt(root2)) {\r\n                                //we found them both\r\n                                factors.add(_.parse(format('({0})*({1})+({2})', symbols[1], v, root2)));\r\n                                factors.add(_.parse(format('({0})*({1})+({2})', symbols[0], v, root1)));\r\n                                symbol = new Symbol(1);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                return symbol;\r\n            },\r\n            cubeFactor: function (symbol, factors) {\r\n                if(symbol.isComposite()) {\r\n                    var symbols = symbol.collectSymbols();\r\n                    // The symbol should be in the form of a^3+-b^3. The length\r\n                    // should therefore only be two. If it's any different from this\r\n                    // then we're done\r\n                    if(symbols.length === 2) {\r\n                        // Store the signs and then strip them from the symbols\r\n                        var sign_a = symbols[0].sign();\r\n                        var a = symbols[0].clone().abs();\r\n                        var sign_b = symbols[1].sign();\r\n                        var b = symbols[1].clone().abs();\r\n                        // Check if they're cube\r\n                        if(a.isCube() && b.isCube()) {\r\n                            // Keep the negative sign on the right, meaning b is always negative.\r\n                            if(sign_a < sign_b) {\r\n                                // Swap the signs and then the values\r\n                                [sign_a, sign_b] = [sign_b, sign_a];\r\n                                [a, b] = [b, a];\r\n                            }\r\n\r\n                            // Get teh roots\r\n                            var m_root_a = _.parse(a.getNth(3));\r\n                            var m_root_b = _.parse(b.getNth(3));\r\n\r\n                            // Remove the cube for both\r\n                            var x = _.multiply(_.expand(_.pow(a.clone().toUnitMultiplier(), _.parse('1/3'))), m_root_a);\r\n                            var y = _.multiply(_.expand(_.pow(b.clone().toUnitMultiplier(), _.parse('1/3'))), m_root_b);\r\n\r\n                            if(sign_a === 1 && sign_b === -1) {\r\n                                // Apply difference of cubes rule\r\n                                factors.add(_.parse(format('(({0})-({1}))', x, y)));\r\n                                factors.add(_.parse(format('(({0})^2+({0})*({1})+({1})^2)', x, y)));\r\n                                symbol = Symbol(1);\r\n                            }\r\n                            else if(sign_a === 1 && sign_b === 1) {\r\n                                // Apply sum of cubes rule\r\n                                factors.add(_.parse(format('(({0})+({1}))', x, y)));\r\n                                factors.add(_.parse(format('(({0})^2-({0})*({1})+({1})^2)', x, y)));\r\n                                symbol = Symbol(1);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n\r\n                return symbol;\r\n            },\r\n            _factor: function (symbol, factors) {\r\n                var g = symbol.group;\r\n                //some items cannot be factored any further so return those right away\r\n                if(symbol.group === FN) {\r\n                    var arg = symbol.args[0];\r\n                    if(arg.group === S && arg.isSimple()) {\r\n                        return symbol;\r\n                    }\r\n                }\r\n                else if(symbol.group === S && symbol.isSimple()) {\r\n                    return symbol;\r\n                }\r\n\r\n                // Expand the symbol to get it in a predictable form. If this step\r\n                // is skipped some factors are missed.\r\n                //if(symbol.group === CP && !(even(symbol.power) && symbol.multiplier.lessThan(0))) {\r\n                if(symbol.group === CP) {\r\n                    symbol.distributeMultiplier(true);\r\n                    var t = new Symbol(0);\r\n                    symbol.each(function (x) {\r\n                        if((x.group === CP && x.power.greaterThan(1) || x.group === CB))\r\n                            x = _.expand(x);\r\n                        t = _.add(t, x);\r\n                    });\r\n                    t.power = symbol.power;\r\n\r\n                    symbol = t;\r\n                }\r\n\r\n                if(symbol.group === FN && symbol.fname !== 'sqrt') {\r\n                    symbol = core.Utils.evaluate(symbol);\r\n                }\r\n\r\n                //make a copy of the symbol to return if something goes wrong\r\n                var untouched = symbol.clone();\r\n                try {\r\n                    if(symbol.group === CB) {\r\n                        var p = _.parse(symbol.power);\r\n\r\n                        var den_array, num_array, den, num, dfact, nfact;\r\n                        //grab the denominator and strip the multiplier and power. Store them in an array\r\n                        den_array = __.Simplify.strip(symbol.getDenom());\r\n                        num_array = __.Simplify.strip(symbol.getNum());\r\n\r\n                        den = den_array.pop();\r\n                        num = num_array.pop();\r\n\r\n                        //if the numerator equals the symbol then we've hit the simplest form and then we're done\r\n                        if(num.equals(symbol)) {\r\n                            return symbol;\r\n                        }\r\n                        nfact = __.Factor.factor(num);\r\n                        dfact = __.Factor.factor(den);\r\n\r\n                        var n = __.Simplify.unstrip(num_array, nfact);\r\n                        var d = __.Simplify.unstrip(den_array, dfact);\r\n\r\n                        var retval = _.divide(n, d);\r\n\r\n                        return retval;\r\n                    }\r\n                    if(symbol.group === S) {\r\n                        return symbol; //absolutely nothing to do\r\n                    }\r\n\r\n                    if(symbol.isConstant()) {\r\n                        if(symbol.equals(1))\r\n                            return symbol.clone();\r\n                        var ret = core.Math2.factor(symbol);\r\n                        return ret;\r\n                    }\r\n\r\n                    var p = symbol.power.clone();\r\n\r\n                    if(isInt(p) && !(p.lessThan(0) && symbol.group === FN)) {\r\n                        var sign = p.sign();\r\n                        symbol.toLinear();\r\n                        factors = factors || new Factors();\r\n                        var map = {};\r\n                        symbol = _.parse(core.Utils.subFunctions(symbol, map));\r\n                        if(keys(map).length > 0) { //it might have functions\r\n                            factors.preAdd = function (factor) {\r\n                                var ret = _.parse(factor, core.Utils.getFunctionsSubs(map));\r\n                                return ret;\r\n                            };\r\n                        }\r\n\r\n                        //strip the power\r\n                        if(!symbol.isLinear()) {\r\n                            factors.pFactor = symbol.power.toString();\r\n                            symbol.toLinear();\r\n                        }\r\n\r\n                        var vars = variables(symbol);\r\n                        //bypass for imaginary. TODO: find a better solution\r\n                        if(symbol.isImaginary()) {\r\n                            vars.push(core.Settings.IMAGINARY);\r\n                        }\r\n                        var multiVar = vars.length > 1;\r\n\r\n                        //minor optimization. Seems to cut factor time by half in some cases.\r\n                        if(multiVar) {\r\n                            var all_S = true, all_unit = true;\r\n                            symbol.each(function (x) {\r\n                                if(x.group !== S)\r\n                                    all_S = false;\r\n                                if(!x.multiplier.equals(1))\r\n                                    all_unit = false;\r\n                            });\r\n\r\n                            if(all_S && all_unit) {\r\n                                return _.pow(_.parse(symbol, core.Utils.getFunctionsSubs(map)), _.parse(p));\r\n                            }\r\n                        }\r\n\r\n                        //factor the coefficients\r\n                        var coeff_factors = new Factors();\r\n\r\n                        symbol = __.Factor.coeffFactor(symbol, coeff_factors);\r\n\r\n                        coeff_factors.each(function (x) {\r\n                            // If the factor was negative but was within a square then it becomes positive\r\n                            if(even(p) && x.lessThan(0)) {\r\n                                x.negate();\r\n                            }\r\n\r\n                            if(sign < 0)\r\n                                x.invert();\r\n                            factors.add(x);\r\n                        });\r\n\r\n                        //factor the power\r\n                        var power_factors = new Factors();\r\n                        symbol = __.Factor.powerFactor(symbol, power_factors);\r\n                        power_factors.each(function (x) {\r\n                            if(sign < 0)\r\n                                x.invert();\r\n                            factors.add(x);\r\n                        });\r\n\r\n                        if(!multiVar) {\r\n                            //pass in vars[0] for safety\r\n                            var v = vars[0];\r\n\r\n                            symbol = __.Factor.squareFree(symbol, factors, v);\r\n\r\n                            var t_factors = new Factors();\r\n\r\n                            symbol = __.Factor.trialAndError(symbol, t_factors, v);\r\n\r\n                            //generate a symbol based off the last factors\r\n                            var tf_symbol = t_factors.toSymbol();\r\n                            //if nothing was factored then return the factors\r\n                            if(tf_symbol.equals(untouched)) {\r\n                                return tf_symbol;\r\n                            }\r\n\r\n                            for(var x in t_factors.factors) {\r\n                                //store the current factor in t_factor\r\n                                var t_factor = t_factors.factors[x];\r\n                                factors.add(_.pow(t_factor, _.parse(p)));\r\n                            }\r\n                            //if we still don't have a factor and it's quadratic then let's just do a quad factor\r\n                            if(symbol.equals(untouched)) {\r\n                                symbol = __.Factor.quadFactor(symbol, factors);\r\n                            }\r\n\r\n                        }\r\n                        else {\r\n                            // Try sum and difference of cubes\r\n                            symbol = __.Factor.cubeFactor(symbol, factors);\r\n\r\n                            symbol = __.Factor.mfactor(symbol, factors);\r\n\r\n                            //put back the sign of power\r\n                            factors.each(function (x) {\r\n                                if(sign < 0)\r\n                                    x.power.negate();\r\n                            });\r\n                        }\r\n\r\n                        //last minute clean up\r\n                        symbol = _.parse(symbol, core.Utils.getFunctionsSubs(map));\r\n                        \r\n                        var addPower = factors.length === 1;\r\n                        \r\n                        factors.add(_.pow(symbol, _.parse(p)));\r\n\r\n                        var retval = factors.toSymbol();\r\n                        \r\n                        // We may have only factored out the symbol itself so we end up with a factor of one \r\n                        // where the power needs to be placed back\r\n                        // e.g. factor((2*y+p)^2). Here we end up having a factor of 1 remaining and a p of 2.\r\n                        if(addPower && symbol.equals(1) && retval.isLinear()) {\r\n                            retval = _.pow(retval, _.parse(p));\r\n                        }\r\n                        \r\n                        return retval;\r\n                    }\r\n\r\n                    return symbol;\r\n                }\r\n                catch(e) {\r\n                    //no need to stop the show because something went wrong :). Just return the unfactored.\r\n                    return untouched;\r\n                }\r\n            },\r\n            reduce: function (symbol, factors) {\r\n                if(symbol.group === CP && symbol.length === 2) {\r\n                    var symbols = symbol.collectSymbols().sort(function (a, b) {\r\n                        return b.multiplier - a.multiplier;\r\n                    });\r\n                    if(symbols[0].power.equals(symbols[1].power)) {\r\n                        //x^n-a^n\r\n                        var n = _.parse(symbols[0].power),\r\n                                a = symbols[0].clone().toLinear(),\r\n                                b = symbols[1].clone().toLinear();\r\n\r\n                        //apply rule: (a-b)*sum(a^(n-i)*b^(i-1),1,n)\r\n                        factors.add(_.add(a.clone(), b.clone()));\r\n                        //flip the sign\r\n                        b.negate();\r\n                        //turn n into a number\r\n                        var nn = Number(n);\r\n                        //the remainder\r\n                        var result = new Symbol(0);\r\n                        for(var i = 1; i <= nn; i++) {\r\n                            var aa = _.pow(a.clone(), _.subtract(n.clone(), new Symbol(i))),\r\n                                    bb = _.pow(b.clone(), _.subtract(new Symbol(i), new Symbol(1)));\r\n                            result = _.add(result, _.multiply(aa, bb));\r\n                        }\r\n                        return result;\r\n                    }\r\n                }\r\n                return symbol;\r\n            },\r\n            /**\r\n             * Makes Symbol square free\r\n             * @param {Symbol} symbol\r\n             * @param {Factors} factors\r\n             * @@param {String} variable The variable which is being factored \r\n             * @returns {[Symbol, Factor]}\r\n             */\r\n            squareFree: function (symbol, factors, variable) {\r\n                if(symbol.isConstant() || symbol.group === S)\r\n                    return symbol;\r\n\r\n                var poly = new Polynomial(symbol, variable);\r\n                var sqfr = poly.squareFree();\r\n                var p = sqfr[2];\r\n                //if we found a square then the p entry in the array will be non-unit\r\n                if(p !== 1) {\r\n                    //make sure the remainder doesn't have factors\r\n                    var t = sqfr[1].toSymbol();\r\n                    t.power = t.power.multiply(new Frac(p));\r\n                    //send the factor to be fatored to be sure it's completely factored\r\n                    factors.add(__.Factor.factor(t));\r\n\r\n                    var retval = __.Factor.squareFree(sqfr[0].toSymbol(), factors);\r\n\r\n                    return retval;\r\n                }\r\n\r\n                return symbol;\r\n            },\r\n            /**\r\n             * Factors the powers such that the lowest power is a constant\r\n             * @param {Symbol} symbol\r\n             * @param {Factors} factors\r\n             * @returns {[Symbol, Factor]}\r\n             */\r\n            powerFactor: function (symbol, factors) {\r\n                //only PL need apply\r\n                if(symbol.group !== PL || symbol.previousGroup === EX)\r\n                    return symbol;\r\n                var k = keys(symbol.symbols);\r\n                //we expect only numeric powers so return all else\r\n                if(!core.Utils.allNumeric(k))\r\n                    return symbol;\r\n\r\n                var d = core.Utils.arrayMin(k);\r\n                var retval = new Symbol(0);\r\n                var q = _.parse(symbol.value + '^' + d);\r\n                symbol.each(function (x) {\r\n                    x = _.divide(x, q.clone());\r\n                    retval = _.add(retval, x);\r\n                });\r\n\r\n                factors.add(q);\r\n                return retval;\r\n            },\r\n            /**\r\n             * Removes GCD from coefficients\r\n             * @param {Symbol} symbol\r\n             * @param {Factor} factors\r\n             * @returns {Symbol}\r\n             */\r\n            coeffFactor: function (symbol, factors) {\r\n                if(symbol.isComposite()) {\r\n                    var gcd = core.Math2.QGCD.apply(null, symbol.coeffs());\r\n\r\n                    if(!gcd.equals(1)) {\r\n                        symbol.each(function (x) {\r\n                            if(x.isComposite()) {\r\n                                x.each(function (y) {\r\n                                    y.multiplier = y.multiplier.divide(gcd);\r\n                                });\r\n                            }\r\n                            else\r\n                                x.multiplier = x.multiplier.divide(gcd);\r\n                        });\r\n                        symbol.updateHash();\r\n                    }\r\n                    else {\r\n                        // TODO: This should probably go to the prototype\r\n                        var power = function (symbol) {\r\n                            var p;\r\n                            if(symbol.group === CB) {\r\n                                p = 0;\r\n                                symbol.each(function (x) {\r\n                                    p += x.power;\r\n                                });\r\n                            }\r\n                            else {\r\n                                p = Number(symbol.power);\r\n                            }\r\n                            return p;\r\n                        };\r\n                        // Factor out negatives from the lead term\r\n                        var terms = symbol.collectSymbols(null, null, null, true).sort(function (a, b) {\r\n                            // Push constants to the back\r\n                            if(a.isConstant(true))\r\n                                return 1;\r\n                            return b.power - a.power;\r\n                        });\r\n\r\n                        var LT = terms[0];\r\n\r\n                        // Check if the LT is indeed the greatest\r\n                        if(power(LT) > power(terms[1]) || terms[1].isConstant(true)) {\r\n                            if(LT.multiplier.lessThan(0)) {\r\n                                // Although the symbol should always be linear at this point, remove the negative for squares\r\n                                // to be safe.\r\n                                factors.add(new Symbol(-1));\r\n\r\n                                symbol.each(function (x) {\r\n                                    x.negate();\r\n                                }, true);\r\n                            }\r\n                        }\r\n\r\n                    }\r\n\r\n                    if(factors) {\r\n                        factors.add(new Symbol(gcd));\r\n                    }\r\n                }\r\n\r\n                return symbol;\r\n            },\r\n            /**\r\n             * The name says it all :)\r\n             * @param {Symbol} symbol\r\n             * @param {Factor} factors\r\n             * @@param {String} variable \r\n             * @returns {Symbol}\r\n             */\r\n            trialAndError: function (symbol, factors, variable) {\r\n                var untouched = symbol.clone();\r\n                try {\r\n                    // At temp holder for the factors. If all goes well then\r\n                    // they'll be moved to the actual factors.\r\n                    var factor_array = [];\r\n\r\n                    if(symbol.isConstant() || symbol.group === S)\r\n                        return symbol;\r\n                    var poly = new Polynomial(symbol, variable),\r\n                            cnst = poly.coeffs[0],\r\n                            cfactors = core.Math2.ifactor(cnst),\r\n                            roots = __.proots(symbol);\r\n                    for(var i = 0; i < roots.length; i++) {\r\n                        var r = roots[i],\r\n                                p = 1;\r\n                        if(!isNaN(r)) { //if it's a number\r\n                            for(var x in cfactors) {\r\n                                //check it's raised to a power\r\n                                var n = core.Utils.round(Math.log(x) / Math.log(Math.abs(r)), 8);\r\n                                if(isInt(n)) {\r\n                                    r = x; //x must be the root since n gave us a whole\r\n                                    p = n;\r\n                                    break;\r\n                                }\r\n                            }\r\n                            var root = new Frac(r),\r\n                                    terms = [new Frac(root.num).negate()];\r\n                            terms[p] = new Frac(root.den);\r\n                            //convert to Frac. The den is coeff of LT and the num is coeff of constant\r\n                            var div = Polynomial.fromArray(terms, poly.variable).fill(),\r\n                                    t = poly.divide(div);\r\n                            if(t[1].equalsNumber(0)) { //if it's zero we have a root and divide it out\r\n                                poly = t[0];\r\n                                // factors.add(div.toSymbol());\r\n                                factor_array.push(div.toSymbol());\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    if(!poly.equalsNumber(1)) {\r\n                        poly = __.Factor.search(poly, factors);\r\n                    }\r\n\r\n                    // Move the factors over since all went well.\r\n                    factor_array.forEach(function (x) {\r\n                        factors.add(x);\r\n                    });\r\n\r\n                    return poly.toSymbol();\r\n                }\r\n                catch(e) {\r\n                    return untouched;\r\n                }\r\n            },\r\n            search: function (poly, factors, base) {\r\n                base = base || 10; //I like 10 because numbers exhibit similar behaviours at 10\r\n                var v = poly.variable; //the polynmial variable name\r\n                /**\r\n                 * Attempt to remove a root by division given a number by first creating\r\n                 * a polynomial fromt he given information\r\n                 * @param {int} c1 - coeffient for the constant\r\n                 * @param {int} c2 - coefficient for the LT\r\n                 * @param {int} n - the number to be used to construct the polynomial\r\n                 * @param {int} p - the power at which to create the polynomial\r\n                 * @returns {null|Polynomial} - returns polynomial if successful otherwise null\r\n                 */\r\n                var check = function (c1, c2, n, p) {\r\n                    var candidate = Polynomial.fit(c1, c2, n, base, p, v);\r\n                    if(candidate && candidate.coeffs.length > 1) {\r\n                        var t = poly.divide(candidate);\r\n                        if(t[1].equalsNumber(0)) {\r\n                            factors.add(candidate.toSymbol());\r\n                            return [t[0], candidate];\r\n                        }\r\n                    }\r\n                    return null;\r\n                };\r\n                var cnst = poly.coeffs[0];\r\n                var cfactors = core.Math2.ifactor(cnst);\r\n                var lc = poly.lc();\r\n                var ltfactors = core.Math2.ifactor(lc);\r\n                var subbed = poly.sub(base);\r\n                var isubbed = core.Math2.ifactor(subbed);\r\n                var nfactors = __.Factor.mix(isubbed, subbed < 0);\r\n                var cp = Math.ceil(poly.coeffs.length / 2);\r\n                var lc_is_neg = lc.lessThan(0);\r\n                var cnst_is_neg = cnst.lessThan(0);\r\n                ltfactors['1'] = 1;\r\n                cfactors['1'] = 1;\r\n                while(cp--) {\r\n                    for(var x in ltfactors) {\r\n                        for(var y in cfactors) {\r\n                            for(var i = 0; i < nfactors.length; i++) {\r\n                                var factor_found = check(x, y, nfactors[i], cp);\r\n                                if(factor_found) {\r\n                                    poly = factor_found[0];\r\n                                    if(!core.Utils.isPrime(poly.sub(base)))\r\n                                        poly = __.Factor.search(poly, factors);\r\n                                    return poly;\r\n                                }\r\n                                else if(!factor_found) {\r\n                                    if(lc_is_neg && cnst_is_neg)\r\n                                        factor_found = check(-x, -y, nfactors[i], cp);\r\n                                    else if(lc_is_neg)\r\n                                        factor_found = check(-x, y, nfactors[i], cp); //check a negative lc\r\n                                    else if(cnst_is_neg)\r\n                                        factor_found = check(x, -y, nfactors[i], cp); //check a negative constant\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                return poly;\r\n            },\r\n            /**\r\n             * Equivalent of square free factor for multivariate polynomials\r\n             * @param {type} symbol\r\n             * @param {type} factors\r\n             * @returns {AlgebraL#18.Factor.mSqfrFactor.symbol|Array|AlgebraL#18.__.Factor.mSqfrFactor.d}\r\n             */\r\n            mSqfrFactor: function (symbol, factors) {\r\n                if(symbol.group !== FN) {\r\n                    var vars = variables(symbol).reverse();\r\n\r\n                    // Loop through all the variable and remove the partial derivatives\r\n                    for(var i = 0; i < vars.length; i++) {\r\n                        do {\r\n                            if(vars[i] === symbol.value) {\r\n                                //the derivative tells us nothing since this symbol is already the factor\r\n                                factors.add(symbol);\r\n                                symbol = new Symbol(1);\r\n                                continue;\r\n                            }\r\n\r\n                            var diff = core.Calculus.diff(symbol, vars[i]);\r\n\r\n                            var d = __.Factor.coeffFactor(diff);\r\n\r\n                            if(d.equals(0))\r\n                                break;\r\n\r\n                            //trial division to see if factors have whole numbers. \r\n                            //This can be optimized by stopping as soon as can_divide is false\r\n                            //this will also need utilize big number at some point\r\n                            var can_divide = true;\r\n                            if(d.isConstant() && symbol.isComposite()) {\r\n                                //check the coefficients\r\n\r\n                                symbol.each(function (x) {\r\n                                    if(x.multiplier % d !== 0)\r\n                                        can_divide = false;\r\n                                }, true);\r\n                            }\r\n\r\n                            //if we can divide then do so\r\n                            if(can_divide) {\r\n\r\n                                var div = __.div(symbol, d.clone()),\r\n                                        is_factor = div[1].equals(0);\r\n                                \r\n                                // Break infinite loop for factoring e^t*x-1\r\n                                if((symbol.equals(div[0]) && div[1].equals(0))) {\r\n                                    break;\r\n                                }\r\n                                \r\n                                if(div[0].isConstant()) {\r\n                                    factors.add(div[0]);\r\n                                    break;\r\n                                }\r\n                                \r\n                            }\r\n                            else\r\n                                is_factor = false;\r\n\r\n                            if(is_factor) {\r\n                                factors.add(div[0]);\r\n                                symbol = d;\r\n                            }\r\n                        }\r\n                        while(is_factor)\r\n                    }\r\n                }\r\n\r\n                return symbol;\r\n            },\r\n            //difference of squares factorization\r\n            sqdiff: function (symbol, factors) {\r\n                if(symbol.isConstant('all')) {\r\n                    // Nothing to do\r\n                    return symbol;\r\n                }\r\n\r\n                try {\r\n                    var remove_square = function (x) {\r\n                        return core.Utils.block('POSITIVE_MULTIPLIERS', function () {\r\n                            return Symbol.unwrapPARENS(math.sqrt(math.abs(x)));\r\n                        }, true);\r\n                    };\r\n                    var separated = core.Utils.separate(symbol.clone());\r\n\r\n                    var obj_array = [];\r\n\r\n                    //get the unique variables\r\n                    for(var x in separated) {\r\n                        if(x !== 'constants') {\r\n                            obj_array.push(separated[x]);\r\n                        }\r\n                    }\r\n                    obj_array.sort(function (a, b) {\r\n                        return b.power - a.power;\r\n                    });\r\n\r\n                    //if we have the same number of variables as unique variables then we can apply the difference of squares\r\n                    if(obj_array.length === 2) {\r\n                        var a, b;\r\n                        a = obj_array.pop();\r\n                        b = obj_array.pop();\r\n\r\n                        if(even(a.power) && even(b.power)\r\n                                && a.sign() === b.sign()\r\n                                && a.group === S && b.group === S) {\r\n                            throw new Error('Unable to factor');\r\n                        }\r\n                        ;\r\n\r\n                        if(a.isComposite() && b.power.equals(2)) {\r\n                            //remove the square from b\r\n                            b = remove_square(b);\r\n                            var f = __.Factor.factor(_.add(a, separated.constants));\r\n                            if(f.power.equals(2)) {\r\n                                f.toLinear();\r\n                                factors.add(_.subtract(f.clone(), b.clone()));\r\n                                factors.add(_.add(f, b));\r\n                                symbol = new Symbol(1);\r\n                            }\r\n                        }\r\n                        else {\r\n                            a = a.powSimp();\r\n                            b = b.powSimp();\r\n\r\n                            if((a.group === S || a.fname === '') && a.power.equals(2) && (b.group === S || b.fname === '') && b.power.equals(2) && !separated.constants) {\r\n                                if(a.multiplier.lessThan(0)) {\r\n                                    var t = b;\r\n                                    b = a;\r\n                                    a = t;\r\n                                }\r\n                                if(a.multiplier.greaterThan(0)) {\r\n                                    a = remove_square(a);\r\n                                    b = remove_square(b);\r\n                                }\r\n\r\n                                factors.add(_.subtract(a.clone(), b.clone()));\r\n                                factors.add(_.add(a, b));\r\n                                symbol = new Symbol(1);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                catch(e) {\r\n                    ;\r\n                }\r\n\r\n                return symbol;\r\n            },\r\n            //factoring for multivariate\r\n            mfactor: function (symbol, factors) {\r\n\r\n                if(symbol.group === FN) {\r\n                    if(symbol.fname === 'sqrt') {\r\n                        var factors2 = new Factors(),\r\n                                arg = __.Factor.common(symbol.args[0].clone(), factors2);\r\n                        arg = __.Factor.coeffFactor(arg, factors2);\r\n                        symbol = _.multiply(_.symfunction('sqrt', [arg]), _.parse(symbol.multiplier));\r\n                        factors2.each(function (x) {\r\n                            symbol = _.multiply(symbol, _.parse(core.Utils.format('sqrt({0})', x)));\r\n                        });\r\n                    }\r\n                    else\r\n                        factors.add(symbol);\r\n                }\r\n                else {\r\n\r\n                    //square free factorization\r\n                    symbol = __.Factor.mSqfrFactor(symbol, factors);\r\n\r\n                    //try factor out common factors\r\n                    //symbol = __.Factor.common(symbol, factors);\r\n\r\n                    var vars = variables(symbol),\r\n                            symbols = symbol.collectSymbols().map(function (x) {\r\n                        return Symbol.unwrapSQRT(x);\r\n                    }),\r\n                            sorted = {},\r\n                            maxes = {},\r\n                            l = vars.length, n = symbols.length;\r\n                    //take all the variables in the symbol and organize by variable name\r\n                    //e.g. a^2+a^2+b*a -> {a: {a^3, a^2, b*a}, b: {b*a}}\r\n\r\n                    for(var i = 0; i < l; i++) {\r\n                        var v = vars[i];\r\n                        sorted[v] = new Symbol(0);\r\n                        for(var j = 0; j < n; j++) {\r\n                            var s = symbols[j];\r\n                            if(s.contains(v)) {\r\n                                var p = s.value === v ? s.power.toDecimal() : s.symbols[v].power.toDecimal();\r\n                                if(!maxes[v] || p < maxes[v])\r\n                                    maxes[v] = p;\r\n                                sorted[v] = _.add(sorted[v], s.clone());\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    for(var x in sorted) {\r\n                        var r = _.parse(x + '^' + maxes[x]);\r\n                        var div = _.divide(sorted[x], r);\r\n                        var new_factor = _.expand(div);\r\n\r\n                        if(new_factor.equals(1))\r\n                            break; //why divide by one. Just move \r\n                        var divided = __.div(symbol.clone(), new_factor);\r\n\r\n                        if(divided[0].equals(0)) {\r\n                            //cant factor anymore\r\n                            break;\r\n                        }\r\n\r\n                        // We potentially ended up with fractional coefficients when the\r\n                        // trial division was performed. We need to remove \r\n                        // This check will more then likely become superfluous with improvements\r\n                        // to polynomial division\r\n                        if(divided[1].equals(0)) {\r\n                            var has_fractions = false;\r\n\r\n                            divided[0].each(function (x) {\r\n                                if(!isInt(x.multiplier)) {\r\n                                    has_fractions = true;\r\n                                }\r\n                            });\r\n\r\n                            // The factor isn't really a factor and needs to be put back\r\n                            if(has_fractions) {\r\n                                divided[1] = _.expand(_.multiply(divided[1], new_factor));\r\n                                // Since the new factor is not just one, we exit.\r\n                                break;\r\n                            }\r\n                        }\r\n\r\n                        var neg_numeric_factor = isInt(new_factor) && new_factor.lessThan(0);\r\n\r\n                        if(divided[1].equals(0) && !neg_numeric_factor) { //we found at least one factor\r\n\r\n                            //factors.add(new_factor);\r\n                            var d = __.div(symbol.clone(), divided[0].clone());\r\n                            var r = d[0];\r\n\r\n                            // Nothing left to do since we didn't get a reduction\r\n                            if(r.equals(0)) {\r\n                                return symbol;\r\n                            }\r\n\r\n                            symbol = d[1];\r\n                            //we don't want to just flip the sign. If the remainder is -1 then we accomplished nothing\r\n                            //and we just return the symbol;\r\n                            //If r equals zero then there's nothing left to do so we're done\r\n\r\n                            if(r.equals(-1) && !symbol.equals(0))\r\n                                return symbol;\r\n\r\n                            var factor = divided[0];\r\n\r\n                            if(symbol.equals(factor)) {\r\n                                var rem = __.Factor.reduce(factor, factors);\r\n\r\n                                if(!symbol.equals(rem))\r\n                                    return __.Factor.mfactor(rem, factors);\r\n\r\n                                return rem;\r\n                            }\r\n                            else {\r\n                                factors.add(factor);\r\n                                //if the remainder of the symbol is zero then we're done. TODO: Rethink this logic a bit.\r\n                                if(symbol.equals(0))\r\n                                    return r;\r\n                            }\r\n\r\n                            if(r.isConstant('all')) {\r\n                                factors.add(r);\r\n                                return r;\r\n                            }\r\n\r\n                            return __.Factor.mfactor(r, factors);\r\n                        }\r\n                    }\r\n\r\n                }\r\n\r\n                //difference of squares factorization\r\n                symbol = __.Factor.sqdiff(symbol, factors);\r\n\r\n                //factors by fishing for zeroes\r\n                symbol = __.Factor.zeroes(symbol, factors);\r\n\r\n                return symbol;\r\n            }\r\n        },\r\n        /**\r\n         * Checks to see if a set of \"equations\" is linear. \r\n         * @param {type} set\r\n         * @returns {Boolean}\r\n         */\r\n        allLinear: function (set) {\r\n            var l = set.length;\r\n            for(var i = 0; i < l; i++) {\r\n                if(!__.isLinear(set[i]))\r\n                    return false;\r\n            }\r\n            return true;\r\n        },\r\n        /*\r\n         * Checks to see if the \"equation\" is linear\r\n         * @param {Symbol} e\r\n         * @returns {boolean}\r\n         */\r\n        isLinear: function (e) {\r\n            var status = false, g = e.group;\r\n            if(g === PL || g === CP) {\r\n                status = true;\r\n                for(var s in e.symbols) {\r\n                    var symbol = e.symbols[s], sg = symbol.group;\r\n                    if(sg === FN || sg === EX) {\r\n                        status = false;\r\n                    }\r\n                    if(sg === CB) {\r\n                        //needs further checking since it might be imaginary\r\n                        status = variables(symbol).length === 1;\r\n                    }\r\n                    else {\r\n                        if(sg === PL || sg === CP)\r\n                            status = __.isLinear(symbol);\r\n                        else {\r\n                            if(symbol.group !== N && symbol.power.toString() !== '1') {\r\n                                status = false;\r\n                                break;\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            else if(g === S && e.power === 1)\r\n                status = true;\r\n            return status;\r\n        },\r\n        gcd: function () {\r\n            var args;\r\n            if(arguments.length === 1 && arguments[0] instanceof core.Vector)\r\n                args = arguments[0].elements;\r\n            else\r\n                args = core.Utils.arguments2Array(arguments);\r\n\r\n            //short-circuit early\r\n            if(args.length === 0)\r\n                return new Symbol(1);\r\n            else if(args.length === 1)\r\n                return args[0];\r\n\r\n            var appeared = [], evaluate = false;\r\n            for(var i = 0; i < args.length; i++) {\r\n                if(args[i].group === FN && args[i].fname === 'gcd')\r\n                {\r\n                    //compress gcd(a,gcd(b,c)) into gcd(a,b,c)\r\n                    args = args.concat(arguments[i].args);\r\n                    //do not keep gcd in args\r\n                    args.splice(i, 1);\r\n                }\r\n                else\r\n                {\r\n                    //Look if there are any common variables such that\r\n                    //gcd(a,b) => gcd(a,b); gcd(a,a) => a\r\n                    var vars = variables(args[i]);\r\n                    if(core.Utils.haveIntersection(vars, appeared))\r\n                    {\r\n                        //Ok, there are common variables\r\n                        evaluate = true;\r\n                        break;\r\n                    }\r\n                    else\r\n                        appeared = appeared.concat(vars);\r\n                }\r\n            }\r\n\r\n            //appeared.length is 0 when all arguments are group N\r\n            if(evaluate || appeared.length === 0) {\r\n                //TODO: distribute exponent so that (a^-1*b^-1)^-1 => a*b\r\n                if(args.every(function (symbol) {\r\n                    return symbol.getDenom().equals(1)\r\n                })) {\r\n                    var aggregate = args[0];\r\n\r\n                    for(var i = 1; i < args.length; i++) {\r\n                        aggregate = __.gcd_(args[i], aggregate);\r\n                    }\r\n                    return aggregate;\r\n                }\r\n                else {\r\n                    //gcd_ cannot handle denominators correctly\r\n                    return _.divide(__.gcd.apply(null, args.map(function (symbol) {\r\n                        return symbol.getNum();\r\n                    })),\r\n                            __.lcm.apply(null, args.map(function (symbol) {\r\n                                return symbol.getDenom();\r\n                            })));\r\n                }\r\n            }\r\n            else\r\n                return _.symfunction('gcd', args);\r\n        },\r\n        gcd_: function (a, b) {\r\n            if(a.group === FN || a.group === P)\r\n                a = core.Utils.block('PARSE2NUMBER', function () {\r\n                    return _.parse(a);\r\n                });\r\n\r\n            if(b.group === FN)\r\n                b = core.Utils.block('PARSE2NUMBER', function () {\r\n                    return _.parse(b);\r\n                });\r\n\r\n            if(a.isConstant() && b.isConstant()) {\r\n                // return core.Math2.QGCD(new Frac(+a), new Frac(+b));\r\n                return new Symbol(core.Math2.QGCD(new Frac(+a), new Frac(+b)));\r\n            }\r\n\r\n            var den = _.multiply(a.getDenom() || new Symbol(1), b.getDenom() || new Symbol(1)).invert();\r\n            a = _.multiply(a.clone(), den.clone());\r\n            b = _.multiply(b.clone(), den.clone());\r\n\r\n            //feels counter intuitive but it works. Issue #123 (nerdamer(\"gcd(x+y,(x+y)^2)\"))\r\n            a = _.expand(a);\r\n            b = _.expand(b);\r\n\r\n            if(a.group === CB || b.group === CB) {\r\n                var q = _.divide(a.clone(), b.clone()); //get the quotient\r\n                var t = _.multiply(b.clone(), q.getDenom().invert());//multiply by the denominator\r\n                //if they have a common factor then the result will not equal one \r\n                if(!t.equals(1))\r\n                    return t;\r\n            }\r\n\r\n            //just take the gcd of each component when either of them is in group EX\r\n            if(a.group === EX || b.group === EX)\r\n            {\r\n                var gcd_m = new Symbol(core.Math2.GCD(a.multiplier, b.multiplier));\r\n                var gcd_v = __.gcd_(a.value === CONST_HASH ? new Symbol(1) : _.parse(a.value), b.value === CONST_HASH ? new Symbol(1) : _.parse(b.value));\r\n                var gcd_p = __.gcd_(_.parse(a.power), _.parse(b.power));\r\n                return _.multiply(gcd_m, _.pow(gcd_v, gcd_p));\r\n            }\r\n\r\n            if(a.length < b.length) { //swap'm\r\n                var t = a;\r\n                a = b;\r\n                b = t;\r\n            }\r\n            var vars_a = variables(a), vars_b = variables(b);\r\n            if((vars_a.length === vars_b.length && vars_a.length === 1 && vars_a[0] === vars_b[0])\r\n                    || vars_a.length === 1 && vars_b.length === 0\r\n                    || vars_a.length === 0 && vars_b.length === 1) {\r\n                a = new Polynomial(a);\r\n                b = new Polynomial(b);\r\n                return _.divide(a.gcd(b).toSymbol(), den);\r\n            }\r\n            else {\r\n                //get the gcd of the multipiers\r\n                //get rid of gcd in coeffs\r\n                var multipliers = [];\r\n                a.each(function (x) {\r\n                    multipliers.push(x.multiplier);\r\n                });\r\n                b.each(function (x) {\r\n                    multipliers.push(x.multiplier);\r\n                });\r\n\r\n                var T;\r\n                while(!b.equals(0)) {\r\n                    var t = b.clone();\r\n                    a = a.clone();\r\n                    T = __.div(a, t);\r\n\r\n                    b = T[1];\r\n                    if(T[0].equals(0)) {\r\n                        //return _.multiply(new Symbol(core.Math2.QGCD(a.multiplier, b.multiplier)), b);\r\n                        return _.divide(new Symbol(core.Math2.QGCD(a.multiplier, b.multiplier)), den);\r\n                    }\r\n                    a = t;\r\n                }\r\n\r\n                var gcd = core.Math2.QGCD.apply(undefined, multipliers);\r\n\r\n                if(!gcd.equals(1)) {\r\n                    a.each(function (x) {\r\n                        x.multiplier = x.multiplier.divide(gcd);\r\n                    });\r\n                }\r\n\r\n                //return symbolic function for gcd in indeterminate form\r\n                if(a.equals(1) && !a.isConstant() && !b.isConstant())\r\n                    return _.divide(_.symfunction('gcd', arguments), den);\r\n\r\n                return _.divide(a, den);\r\n            }\r\n        },\r\n        lcm: function () {\r\n            //https://math.stackexchange.com/a/319310\r\n            //generalization of the 2-variable formula of lcm\r\n\r\n            var args;\r\n            if(arguments.length === 1)\r\n                if(arguments[0] instanceof core.Vector)\r\n                    args = arguments[0].elements;\r\n                else\r\n                    _.error('lcm expects either 1 vector or 2 or more arguments');\r\n            else\r\n                args = core.Utils.arguments2Array(arguments);\r\n\r\n            //product of all arguments\r\n            //start with new Symbol(1) so that prev.clone() which makes unnessesary clones can be avoided\r\n            var numer = args.reduce(function (prev, curr) {\r\n                return _.multiply(prev, curr.clone())\r\n            }, new Symbol(1));\r\n\r\n            //gcd of complementary terms\r\n            var denom_args =\r\n                    //https://stackoverflow.com/a/18223072\r\n                //take all complementary terms, e.g.\r\n                //[a,b,c] => [a*b, b*c, a*c]\r\n                //[a,b,c,d] => [a*b*c, a*b*d, a*c*d, b*c*d]\r\n                (function (input, size) {\r\n                        size = Number(size);\r\n                        var results = [], result, mask, i, total = Math.pow(2, input.length);\r\n                        for(mask = size; mask < total; mask++) {\r\n                            result = [];\r\n                            i = input.length - 1;\r\n\r\n                            do {\r\n                                if((mask & (1 << i)) !== 0) {\r\n                                    result.push(input[i]);\r\n                                }\r\n                            }\r\n                            while(i--);\r\n\r\n                            if(result.length === size) {\r\n                                results.push(result);\r\n                            }\r\n                        }\r\n                        return results;\r\n                        //start with new Symbol(1) so that prev.clone() which makes unnessesary clones can be avoided\r\n                    })(arguments, arguments.length - 1).map(function (x) {\r\n                return x.reduce(function (prev, curr) {\r\n                    return _.multiply(prev, curr.clone())\r\n                }, new Symbol(1))\r\n            });\r\n\r\n            var denom;\r\n            //don't eat the gcd term if all arguments are symbols\r\n            if(args.every(function (x) {\r\n                return core.Utils.isVariableSymbol(x)\r\n            }))\r\n                denom = _.symfunction('gcd', core.Utils.arrayUnique(denom_args));\r\n            else\r\n                denom = __.gcd.apply(null, denom_args);\r\n            //divide product of all arguments by gcd of complementary terms\r\n            var div = _.divide(numer, denom);\r\n            return div;\r\n        },\r\n        /**\r\n         * Divides one expression by another\r\n         * @param {Symbol} symbol1\r\n         * @param {Symbol} symbol2\r\n         * @returns {Array}\r\n         */\r\n        divide: function (symbol1, symbol2) {\r\n            var result, remainder, factored, den;\r\n            factored = core.Algebra.Factor.factor(symbol1.clone());\r\n            den = factored.getDenom();\r\n            if(!den.isConstant('all')) {\r\n                symbol1 = _.expand(Symbol.unwrapPARENS(_.multiply(factored, den.clone())));\r\n            }\r\n            else\r\n                //reset the denominator since we're not dividing by it anymore\r\n                den = new Symbol(1);\r\n            result = __.div(symbol1, symbol2);\r\n            remainder = _.divide(result[1], symbol2);\r\n            return _.divide(_.add(result[0], remainder), den);\r\n        },\r\n        div: function (symbol1, symbol2) {\r\n            // If all else fails then assume that division failed with\r\n            // a remainder of zero and the original quotient\r\n            var fail = [new Symbol(0), symbol1.clone()];\r\n\r\n            try {\r\n\r\n                // Division by constants\r\n                if(symbol2.isConstant('all')) {\r\n                    symbol1.each(function (x) {\r\n                        x.multiplier = x.multiplier.divide(symbol2.multiplier);\r\n                    });\r\n                    return [symbol1, new Symbol(0)];\r\n                }\r\n                // So that factorized symbols don't affect the result\r\n                symbol1 = _.expand(symbol1);\r\n                symbol2 = _.expand(symbol2);\r\n                // Special case. May need revisiting\r\n                if(symbol1.group === S && symbol2.group === CP) {\r\n                    var x = symbol1.value;\r\n                    var f = core.Utils.decompose_fn(symbol2.clone(), x, true);\r\n                    if(symbol1.isLinear() && f.x && f.x.isLinear() && symbol2.isLinear()) {\r\n                        var k = Symbol.create(symbol1.multiplier);\r\n                        return [_.divide(k.clone(), f.a.clone()), _.divide(_.multiply(k, f.b), f.a).negate()];\r\n                    }\r\n                }\r\n                if(symbol1.group === S && symbol2.group === S) {\r\n                    var r = _.divide(symbol1.clone(), symbol2.clone());\r\n                    if(r.isConstant()) //we have a whole\r\n                        return [r, new Symbol(0)];\r\n                    return [new Symbol(0), symbol1.clone()];\r\n                }\r\n                var symbol1_has_func = symbol1.hasFunc(),\r\n                        symbol2_has_func = symbol2.hasFunc(),\r\n                        parse_funcs = false;\r\n\r\n                //substitute out functions so we can treat them as regular variables\r\n                if(symbol1_has_func || symbol2_has_func) {\r\n                    parse_funcs = true;\r\n                    var map = {},\r\n                            symbol1 = _.parse(core.Utils.subFunctions(symbol1, map)),\r\n                            symbol2 = _.parse(core.Utils.subFunctions(symbol2, map)),\r\n                            subs = core.Utils.getFunctionsSubs(map);\r\n                }\r\n                //get a list of the variables\r\n                var vars = core.Utils.arrayUnique(variables(symbol1).concat(variables(symbol2))),\r\n                        quot, rem;\r\n\r\n                //treat imaginary numbers as variables\r\n                if(symbol1.isImaginary() || symbol2.isImaginary()) {\r\n                    vars.push(core.Settings.IMAGINARY);\r\n                }\r\n\r\n                if(vars.length === 1) {\r\n                    var q = new Polynomial(symbol1).divide(new Polynomial(symbol2));\r\n                    quot = q[0].toSymbol();\r\n                    rem = q[1].toSymbol();\r\n                }\r\n                else {\r\n                    vars.push(CONST_HASH); //this is for the numbers\r\n                    var reconvert = function (arr) {\r\n                        var symbol = new Symbol(0);\r\n                        for(var i = 0; i < arr.length; i++) {\r\n                            var x = arr[i].toSymbol();\r\n                            symbol = _.add(symbol, x);\r\n                        }\r\n                        return symbol;\r\n                    };\r\n\r\n                    // Silly Martin. This is why you document. I don't remember now\r\n                    var get_unique_max = function (term, any) {\r\n                        var max = Math.max.apply(null, term.terms),\r\n                                count = 0, idx;\r\n\r\n                        if(!any) {\r\n                            for(var i = 0; i < term.terms.length; i++) {\r\n                                if(term.terms[i].equals(max)) {\r\n                                    idx = i;\r\n                                    count++;\r\n                                }\r\n                                if(count > 1)\r\n                                    return;\r\n                            }\r\n                        }\r\n                        if(any) {\r\n                            for(i = 0; i < term.terms.length; i++)\r\n                                if(term.terms[i].equals(max)) {\r\n                                    idx = i;\r\n                                    break;\r\n                                }\r\n                        }\r\n                        return [max, idx, term];\r\n                    };\r\n\r\n                    // Tries to find an LT in the dividend that will satisfy division\r\n                    var get_det = function (s, lookat) {\r\n                        lookat = lookat || 0;\r\n                        var det = s[lookat], l = s.length;\r\n                        if(!det)\r\n                            return;\r\n                        //eliminate the first term if it doesn't apply\r\n                        var umax = get_unique_max(det);\r\n                        for(var i = lookat + 1; i < l; i++) {\r\n                            var term = s[i],\r\n                                    is_equal = det.sum.equals(term.sum);\r\n                            if(!is_equal && umax) {\r\n                                break;\r\n                            }\r\n                            if(is_equal) {\r\n                                // Check the differences of their maxes. The one with the biggest difference governs\r\n                                // e.g. x^2*y^3 vs x^2*y^3 is unclear but this isn't the case in x*y and x^2\r\n                                var max1, max2, idx1, idx2, l2 = det.terms.length;\r\n                                for(var j = 0; j < l2; j++) {\r\n                                    var item1 = det.terms[j], item2 = term.terms[j];\r\n                                    if(typeof max1 === 'undefined' || item1.greaterThan(max1)) {\r\n                                        max1 = item1;\r\n                                        idx1 = j;\r\n                                    }\r\n                                    if(typeof max2 === 'undefined' || item2.greaterThan(max2)) {\r\n                                        max2 = item2;\r\n                                        idx2 = j;\r\n                                    }\r\n                                }\r\n                                //check their differences\r\n                                var d1 = max1.subtract(term.terms[idx1]),\r\n                                        d2 = max2.subtract(det.terms[idx2]);\r\n                                if(d2 > d1) {\r\n                                    umax = [max2, idx2, term];\r\n                                    break;\r\n                                }\r\n                                if(d1 > d2) {\r\n                                    umax = [max1, idx1, det];\r\n                                    break;\r\n                                }\r\n                            }\r\n                            else {\r\n                                //check if it's a suitable pick to determine the order\r\n                                umax = get_unique_max(term);\r\n                                //if(umax) return umax;\r\n                                if(umax)\r\n                                    break;\r\n                            }\r\n                            umax = get_unique_max(term); //calculate a new unique max\r\n                        }\r\n\r\n                        //if still no umax then any will do since we have a tie\r\n                        if(!umax)\r\n                            return get_unique_max(s[0], true);\r\n                        var e, idx;\r\n                        for(var i = 0; i < s2.length; i++) {\r\n                            var cterm = s2[i].terms;\r\n                            //confirm that this is a good match for the denominator\r\n                            idx = umax[1];\r\n                            if(idx === cterm.length - 1)\r\n                                return;\r\n                            e = cterm[idx];\r\n                            if(!e.equals(0))\r\n                                break;\r\n                        }\r\n                        if(e.equals(0))\r\n                            return get_det(s, ++lookat); //look at the next term\r\n\r\n                        return umax;\r\n                    };\r\n\r\n                    var t_map = core.Utils.toMapObj(vars);\r\n                    var init_sort = function (a, b) {\r\n                        return b.sum.subtract(a.sum);\r\n                    };\r\n                    var is_larger = function (a, b) {\r\n                        if(!a || !b)\r\n                            return false; //it's empty so...\r\n                        for(var i = 0; i < a.terms.length; i++) {\r\n                            if(a.terms[i].lessThan(b.terms[i]))\r\n                                return false;\r\n                        }\r\n                        return true;\r\n                    };\r\n\r\n                    var s1 = symbol1.tBase(t_map).sort(init_sort),\r\n                            s2 = symbol2.tBase(t_map).sort(init_sort);\r\n                    var target = is_larger(s1[0], s2[0]) && s1[0].count > s2[0].count ? s2 : s1; //since the num is already larger than we can get the det from denom\r\n                    var det = get_det(target);//we'll begin by assuming that this will let us know which term \r\n                    var quotient = [];\r\n                    if(det) {\r\n                        var lead_var = det[1];\r\n                        var can_divide = function (a, b) {\r\n                            if(a[0].sum.equals(b[0].sum))\r\n                                return a.length >= b.length;\r\n                            return true;\r\n                        };\r\n\r\n                        var try_better_lead_var = function (s1, s2, lead_var) {\r\n                            var checked = [];\r\n                            for(var i = 0; i < s1.length; i++) {\r\n                                var t = s1[i];\r\n                                for(var j = 0; j < t.terms.length; j++) {\r\n                                    var cf = checked[j], tt = t.terms[j];\r\n                                    if(i === 0)\r\n                                        checked[j] = tt; //add the terms for the first one\r\n                                    else if(cf && !cf.equals(tt))\r\n                                        checked[j] = undefined;\r\n                                }\r\n                            }\r\n                            for(var i = 0; i < checked.length; i++) {\r\n                                var t = checked[i];\r\n                                if(t && !t.equals(0))\r\n                                    return i;\r\n                            }\r\n                            return lead_var;\r\n                        };\r\n                        var sf = function (a, b) {\r\n                            var l1 = a.len(), l2 = b.len();\r\n                            var blv = b.terms[lead_var], alv = a.terms[lead_var];\r\n                            if(l2 > l1 && blv.greaterThan(alv))\r\n                                return l2 - l1;\r\n                            return blv.subtract(alv);\r\n                        };\r\n\r\n                        //check to see if there's a better lead_var\r\n                        lead_var = try_better_lead_var(s1, s2, lead_var);\r\n                        //reorder both according to the max power\r\n                        s1.sort(sf); //sort them both according to the leading variable power\r\n                        s2.sort(sf);\r\n\r\n                        //try to adjust if den is larger\r\n                        var fdt = s2[0], fnt = s1[0];\r\n\r\n                        var den = new MVTerm(new Frac(1), [], fnt.map);\r\n                        if(fdt.sum.greaterThan(fnt.sum) && fnt.len() > 1) {\r\n                            for(var i = 0; i < fnt.terms.length; i++) {\r\n                                var d = fdt.terms[i].subtract(fnt.terms[i]);\r\n                                if(!d.equals(0)) {\r\n                                    var nd = d.add(new Frac(1));\r\n                                    den.terms[i] = d;\r\n                                    for(var j = 0; j < s1.length; j++) {\r\n                                        s1[j].terms[i] = s1[j].terms[i].add(nd);\r\n                                    }\r\n                                }\r\n                                else\r\n                                    den.terms[i] = new Frac(0);\r\n                            }\r\n                        }\r\n\r\n                        var dividend_larger = is_larger(s1[0], s2[0]);\r\n\r\n                        var safety = 0;\r\n                        var max = 200;\r\n\r\n                        while(dividend_larger && can_divide(s1, s2)) {\r\n                            if(safety++ > max) {\r\n                                throw new core.exceptions.InfiniteLoopError('Unable to compute!');\r\n                            }\r\n\r\n                            var q = s1[0].divide(s2[0]);\r\n\r\n                            quotient.push(q); //add what's divided to the quotient\r\n                            s1.shift();//the first one is guaranteed to be gone so remove from dividend\r\n                            for(var i = 1; i < s2.length; i++) { //loop through the denominator\r\n                                var t = s2[i].multiply(q).generateImage(),\r\n                                        l2 = s1.length;\r\n                                //if we're subtracting from 0\r\n                                if(l2 === 0) {\r\n                                    t.coeff = t.coeff.neg();\r\n                                    s1.push(t);\r\n                                    s1.sort(sf);\r\n                                }\r\n\r\n                                for(var j = 0; j < l2; j++) {\r\n                                    var cur = s1[j];\r\n                                    if(cur.getImg() === t.getImg()) {\r\n                                        cur.coeff = cur.coeff.subtract(t.coeff);\r\n                                        if(cur.coeff.equals(0)) {\r\n                                            core.Utils.remove(s1, j);\r\n                                            j--; //adjust the iterator\r\n                                        }\r\n                                        break;\r\n                                    }\r\n                                    if(j === l2 - 1) {\r\n                                        t.coeff = t.coeff.neg();\r\n                                        s1.push(t);\r\n                                        s1.sort(sf);\r\n                                    }\r\n                                }\r\n                            }\r\n                            dividend_larger = is_larger(s1[0], s2[0]);\r\n\r\n                            if(!dividend_larger && s1.length >= s2.length) {\r\n                                //One more try since there might be a terms that is larger than the LT of the divisor\r\n                                for(var i = 1; i < s1.length; i++) {\r\n                                    dividend_larger = is_larger(s1[i], s2[0]);\r\n                                    if(dividend_larger) {\r\n                                        //take it from its current position and move it to the front\r\n                                        s1.unshift(core.Utils.remove(s1, i));\r\n                                        break;\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    quot = reconvert(quotient);\r\n                    rem = reconvert(s1);\r\n\r\n                    if(typeof den !== 'undefined') {\r\n                        den = den.toSymbol();\r\n                        quot = _.divide(quot, den.clone());\r\n                        rem = _.divide(rem, den);\r\n                    }\r\n                }\r\n\r\n                //put back the functions\r\n                if(parse_funcs) {\r\n                    quot = _.parse(quot.text(), subs);\r\n                    rem = _.parse(rem.text(), subs);\r\n                }\r\n\r\n                return [quot, rem];\r\n            }\r\n            catch(e) {\r\n                return fail;\r\n            }\r\n\r\n        },\r\n        line: function (v1, v2, x) {\r\n            if(core.Utils.isArray(v1))\r\n                v1 = core.Utils.convertToVector(v1);\r\n            if(core.Utils.isArray(v2))\r\n                v2 = core.Utils.convertToVector(v2);\r\n            x = _.parse(x || 'x');\r\n            if(!core.Utils.isVector(v1) || !core.Utils.isVector(v2))\r\n                _.error('Line expects a vector! Received \"' + v1 + '\" & \"' + v2 + '\"');\r\n            var dx = _.subtract(v2.e(1).clone(), v1.e(1).clone()),\r\n                    dy = _.subtract(v2.e(2).clone(), v1.e(2).clone()),\r\n                    m = _.divide(dy, dx),\r\n                    a = _.multiply(x, m.clone()),\r\n                    b = _.multiply(v1.e(1).clone(), m);\r\n            return _.add(_.subtract(a, b), v1.e(2).clone());\r\n        },\r\n        PartFrac: {\r\n            createTemplate: function (den, denom_factors, f_array, v) {\r\n                //clean up the denominator function by factors so it reduces nicely\r\n                den = __.Factor.factor(den);\r\n\r\n                //clean up factors. This is so inefficient but factors are wrapped in parens for safety\r\n                den.each(function (x, key) {\r\n                    if(x.group === FN && x.fname === '' && x.args[0].group === S) {\r\n                        var y = x.args[0];\r\n                        if(this.symbols) {\r\n                            delete this.symbols[key];\r\n                            this.symbols[y.value] = y;\r\n                        }\r\n                        else {\r\n                            den = x.args[0];\r\n                        }\r\n                    }\r\n                });\r\n\r\n                var factors, factors_vec, f, p, deg, degrees, m;\r\n                factors = denom_factors.collectFactors();\r\n                factors_vec = []; //a vector for the template\r\n                degrees = [];\r\n                m = new Symbol(1);\r\n\r\n                for(var i = 0; i < factors.length; i++) { //loop through the factors\r\n                    var factor = Symbol.unwrapPARENS(factors[i]);\r\n                    //if in he for P^n where P is polynomial and n = integer\r\n                    if(factor.power.greaterThan(1)) {\r\n                        p = Number(factor.power);\r\n                        f = factor.clone().toLinear(); //remove the power so we have only the function\r\n                        deg = Number(__.degree(f, v)); //get the degree of f\r\n                        //expand the factor\r\n                        for(var j = 0; j < p; j++) {\r\n                            var efactor = _.pow(f.clone(), new Symbol(j + 1));\r\n                            f_array.push(efactor.clone());\r\n                            var d = _.divide(den.clone(), efactor.clone());\r\n                            degrees.push(deg);\r\n                            factors_vec.push(d);\r\n                        }\r\n                    }\r\n                    /*\r\n                     Possible bug.\r\n                     Removed: causes 1/(20+24*x+4*x^2) to result in (-1/64)*(5+x)^(-1)+(1/64)*(1+x)^(-1)\r\n                     else if(factor.isConstant('all')) {\r\n                     m = _.multiply(m, factor);\r\n                     }\r\n                     */\r\n                    else {\r\n                        //get the degree of the factor so we tack it on tot he factor. This should probably be an array\r\n                        //but for now we note it on the symbol\r\n                        deg = Number(__.degree(factor, v));\r\n                        f_array.push(factor);\r\n                        var d = _.divide(den.clone(), factor.clone());\r\n                        d = _.expand(Symbol.unwrapPARENS(d));\r\n                        degrees.push(deg);\r\n                        factors_vec.push(d);\r\n                    }\r\n                }\r\n                //put back the constant\r\n                f_array = f_array.map(function (x) {\r\n                    return _.multiply(x, m.clone());\r\n                });\r\n                return [f_array, factors_vec, degrees];\r\n            },\r\n            partfrac: function (symbol, v, as_array) {\r\n\r\n                var vars = variables(symbol);\r\n\r\n                v = v || _.parse(vars[0]); //make wrt optional and assume first variable\r\n                try {\r\n                    var num, den, factors, tfactors, ofactors, nterms, degrees,\r\n                            dterms, max, M, c, powers, div, r, factors_vec, ks,\r\n                            template, tfactors;\r\n                    num = _.expand(symbol.getNum());\r\n                    den = _.expand(symbol.getDenom().toUnitMultiplier());\r\n                    //move the entire multipier to the numerator\r\n                    num.multiplier = symbol.multiplier;\r\n                    //we only have a meaningful change if n factors > 1. This means that\r\n                    //the returned group will be a CB\r\n                    //collect the terms wrt the x\r\n                    nterms = num.groupTerms(v);\r\n                    //divide out wholes if top is larger\r\n                    if(Number(__.degree(num, v)) >= Number(__.degree(den, v))) {\r\n                        div = __.div(num.clone(), _.expand(den.clone()));\r\n                        r = div[0]; //remove the wholes\r\n                        num = div[1]; //work with the remainder\r\n                        nterms = num.groupTerms(v); //recalculate the nterms\r\n                    }\r\n                    else\r\n                        r = new Symbol(0);\r\n\r\n                    if(Number(__.degree(den, v)) === 1) {\r\n                        var q = _.divide(num, den);\r\n                        if(as_array)\r\n                            return [r, q];\r\n                        return _.add(r, q);\r\n                    }\r\n                    //first factor the denominator. This means that the strength of this\r\n                    //algorithm depends on how well we can factor the denominator. \r\n                    ofactors = __.Factor.factor(den);\r\n                    //create the template. This method will create the template for solving \r\n                    //the partial fractions. So given x/(x-1)^2 the template creates A/(x-1)+B/(x-1)^2\r\n                    template = __.PartFrac.createTemplate(den.clone(), ofactors, [], v);\r\n                    tfactors = template[0]; //grab the factors\r\n                    factors_vec = template[1]; //grab the factor vectors\r\n                    degrees = template[2]; //grab the degrees\r\n                    //make note of the powers of each term\r\n                    powers = [nterms.length];\r\n                    //create the dterms vector\r\n                    dterms = [];\r\n                    factors = [];\r\n                    ks = [];\r\n                    var factor, deg;\r\n                    factors_vec.map(function (x, idx) {\r\n                        factor = tfactors[idx];\r\n                        deg = degrees[idx];\r\n                        for(var i = 0; i < deg; i++) {\r\n                            factors.push(factor.clone());\r\n                            var k = Symbol.create(v, i);\r\n                            var t = _.expand(_.multiply(x, k.clone())).groupTerms(v);\r\n                            //make a note of the power which corresponds to the length of the array\r\n                            var p = t.length;\r\n                            powers.push(p);\r\n                            dterms.push(t);\r\n                            ks.push(k.clone());\r\n                        }\r\n                    });\r\n                    //get the max power\r\n                    max = core.Utils.arrayMax(powers);\r\n\r\n                    //fill the holes and create a matrix\r\n                    c = new core.Matrix(core.Utils.fillHoles(nterms, max)).transpose();\r\n                    //for each of the factors we do the same\r\n                    M = new core.Matrix();\r\n                    for(var i = 0; i < dterms.length; i++) {\r\n                        M.elements.push(core.Utils.fillHoles(dterms[i], max));\r\n                    }\r\n\r\n                    //solve the system of equations\r\n                    var partials = _.multiply(M.transpose().invert(), c);\r\n                    //the results are backwards to reverse it\r\n                    //partials.elements.reverse();\r\n                    //convert it all back\r\n                    var retval = as_array ? [r] : r;\r\n                    partials.each(function (e, i) {\r\n                        var term = _.multiply(ks[i], _.divide(e, factors[i]));\r\n                        if(as_array)\r\n                            retval.push(term);\r\n                        else\r\n                            retval = _.add(retval, term);\r\n                    });\r\n\r\n                    //done\r\n                    return retval;\r\n                }\r\n                catch(e) {\r\n                    //try to group symbols\r\n                    try {\r\n                        if(symbol.isComposite()) {\r\n                            //group denominators\r\n                            var denominators = {};\r\n\r\n                            symbol.each(function (x) {\r\n                                var d = x.getDenom();\r\n                                var n = x.getNum();\r\n                                var e = denominators[d];\r\n                                denominators[d] = e ? _.add(e, n) : n;\r\n                            });\r\n\r\n                            var t = new Symbol(0);\r\n\r\n                            for(var x in denominators) {\r\n                                t = _.add(t, _.divide(denominators[x], _.parse(x)));\r\n                            }\r\n\r\n                            symbol = t;\r\n                        }\r\n                    }\r\n                    catch(e2) {\r\n                    }\r\n                    ;\r\n                }\r\n                ;\r\n\r\n                return symbol;\r\n            }\r\n        },\r\n        degree: function (symbol, v, o) {\r\n            o = o || {\r\n                nd: [], //numeric\r\n                sd: [], //symbolic\r\n                depth: 0 //call depth\r\n            };\r\n\r\n            if(!v) {\r\n                var vars = variables(symbol);\r\n                //The user must specify the variable for multivariate\r\n                if(vars.length > 1)\r\n                    throw new Error('You must specify the variable for multivariate polynomials!');\r\n                //if it's empty then we're dealing with a constant\r\n                if(vars.length === 0)\r\n                    return new Symbol(0);\r\n                //assume the variable for univariate\r\n                v = _.parse(vars[0]);\r\n            }\r\n\r\n            //store the group\r\n            var g = symbol.group;\r\n            //we're going to trust the user and assume no EX. Calling isPoly \r\n            //would eliminate this but no sense in checking twice. \r\n            if(symbol.isComposite()) {\r\n                symbol = symbol.clone();\r\n                symbol.distributeExponent();\r\n                symbol.each(function (x) {\r\n                    o.depth++; //mark a depth increase\r\n                    __.degree(x, v, o);\r\n                    o.depth--; //we're back\r\n                });\r\n            }\r\n            else if(symbol.group === CB) {\r\n                symbol.each(function (x) {\r\n                    o.depth++;\r\n                    __.degree(x, v, o);\r\n                    o.depth++;\r\n                });\r\n            }\r\n            else if(g === EX && symbol.value === v.value) {\r\n                o.sd.push(symbol.power.clone());\r\n            }\r\n            else if(g === S && symbol.value === v.value) {\r\n                o.nd.push(_.parse(symbol.power));\r\n            }\r\n            else\r\n                o.nd.push(new Symbol(0));\r\n\r\n            //get the max out of the array\r\n            var deg = o.nd.length > 0 ? core.Utils.arrayMax(o.nd) : undefined;\r\n\r\n            if(o.depth === 0 && o.sd.length > 0) {\r\n                if(deg !== undefined)\r\n                    o.sd.unshift(deg);\r\n                return _.symfunction('max', o.sd);\r\n            }\r\n            if(!core.Utils.isSymbol(deg))\r\n                deg = _.parse(deg);\r\n            //return the degree\r\n            return deg;\r\n        },\r\n        /**\r\n         * Attempts to complete the square of a polynomial\r\n         * @param {type} symbol\r\n         * @param {type} v\r\n         * @param {type} raw\r\n         * @throws {Error} \r\n         * @returns {Object|Symbol[]}\r\n         */\r\n        sqComplete: function (symbol, v, raw) {\r\n            if(!core.Utils.isSymbol(v))\r\n                v = _.parse(v);\r\n            var stop = function (msg) {\r\n                msg = msg || 'Stopping';\r\n                throw new core.exceptions.ValueLimitExceededError(msg);\r\n            };\r\n            //if not CP then nothing to do\r\n            if(!symbol.isPoly(true))\r\n                stop('Must be a polynomial!');\r\n\r\n            //declare vars\r\n            var deg, a, b, c, d, e, coeffs, sign, br, sym, sqrt_a;\r\n\r\n            br = core.Utils.inBrackets;\r\n            //make a copy\r\n            symbol = symbol.clone();\r\n            deg = core.Algebra.degree(symbol, v); //get the degree of polynomial\r\n            //must be in form ax^2 +/- bx +/- c\r\n            if(!deg.equals(2))\r\n                stop('Cannot complete square for degree ' + deg);\r\n            //get the coeffs\r\n            coeffs = core.Algebra.coeffs(symbol, v);\r\n            a = coeffs[2];\r\n            //store the sign\r\n            sign = coeffs[1].sign();\r\n            //divide the linear term by two and square it\r\n            b = _.divide(coeffs[1], new Symbol(2));\r\n            //add the difference to the constant\r\n            c = _.pow(b.clone(), new Symbol(2));\r\n            if(raw)\r\n                return [a, b, d];\r\n            sqrt_a = math.sqrt(a);\r\n            e = _.divide(math.sqrt(c), sqrt_a.clone());\r\n            //calculate d which is the constant\r\n            d = _.subtract(coeffs[0], _.pow(e.clone(), new Symbol(2)));\r\n            //compute the square part\r\n            sym = _.parse(br(sqrt_a.clone() + '*' + v + (sign < 0 ? '-' : '+') + e));\r\n            return {\r\n                a: sym,\r\n                c: d,\r\n                f: _.add(_.pow(sym.clone(), new Symbol(2)), d.clone())\r\n            };\r\n        },\r\n        Simplify: {\r\n            strip: function (symbol) {\r\n                var c = _.parse(symbol.multiplier);\r\n                symbol.toUnitMultiplier();\r\n                var p = _.parse(symbol.power);\r\n                symbol.toLinear();\r\n                return [c, p, symbol];\r\n            },\r\n            unstrip: function (cp, symbol) {\r\n                var c = cp[0];\r\n                var p = cp[1];\r\n                return _.multiply(c, _.pow(symbol, p));\r\n            },\r\n            complexSimp: function (num, den) {\r\n                var ac, bd, bc, ad, cd, r1, r2, i1, i2;\r\n                r1 = num.realpart();\r\n                i1 = num.imagpart();\r\n                r2 = den.realpart();\r\n                i2 = den.imagpart();\r\n                //apply complex arithmatic rule\r\n                ac = _.multiply(r1.clone(), r2.clone());\r\n                bd = _.multiply(i1.clone(), i2.clone());\r\n                bc = _.multiply(r2.clone(), i1);\r\n                ad = _.multiply(r1, i2.clone());\r\n                cd = _.add(_.pow(r2, new Symbol(2)), _.pow(i2, new Symbol(2)));\r\n\r\n                return _.divide(_.add(_.add(ac, bd), _.multiply(_.subtract(bc, ad), Symbol.imaginary())), cd);\r\n            },\r\n            trigSimp: function (symbol) {\r\n                if(symbol.containsFunction(['cos', 'sin', 'tan'])) {\r\n                    symbol = symbol.clone();\r\n                    //remove power and multiplier\r\n                    var sym_array = __.Simplify.strip(symbol);\r\n                    symbol = sym_array.pop();\r\n                    //the default return value is the symbol\r\n                    var retval = symbol.clone();\r\n\r\n                    //rewrite the symbol\r\n                    if(symbol.group === CP) {\r\n                        var sym = new Symbol(0);\r\n                        symbol.each(function (x) {\r\n                            //rewrite the function\r\n                            var tr = __.Simplify.trigSimp(x.fnTransform());\r\n                            sym = _.add(sym, tr);\r\n                        }, true);\r\n\r\n                        //put back the power and multiplier and return\r\n                        retval = _.pow(_.multiply(new Symbol(symbol.multiplier), sym), new Symbol(symbol.power));\r\n                    }\r\n                    else if(symbol.group === CB) {\r\n\r\n                        var n = symbol.getNum();\r\n                        var d = symbol.getDenom();\r\n\r\n                        //try for tangent\r\n                        if(n.fname === 'sin' && d.fname === 'cos' && n.args[0].equals(d.args[0]) && n.power.equals(d.power)) {\r\n                            retval = _.parse(core.Utils.format('({0})*({1})*tan({2})^({3})', d.multiplier, n.multiplier, n.args[0], n.power));\r\n                        }\r\n                        if(retval.group === CB) {\r\n                            var t = new Symbol(1);\r\n                            retval.each(function (x) {\r\n                                if(x.fname === 'tan') {\r\n                                    x = _.parse(core.Utils.format('({0})*sin({1})^({2})/cos({1})^({2})', x.multiplier, __.Simplify.simplify(x.args[0]), x.power));\r\n                                }\r\n                                t = _.multiply(t, x);\r\n                            });\r\n                            retval = t;\r\n                        }\r\n                    }\r\n\r\n\r\n                    retval = __.Simplify.unstrip(sym_array, retval).distributeMultiplier();\r\n\r\n                    symbol = retval;\r\n                }\r\n\r\n                return symbol;\r\n            },\r\n            fracSimp: function (symbol) {\r\n                //try a quick simplify of imaginary numbers\r\n                var den = symbol.getDenom();\r\n                var num = symbol.getNum();\r\n\r\n                if(num.isImaginary() && den.isImaginary())\r\n                    symbol = __.Simplify.complexSimp(num, den);\r\n\r\n                if(symbol.isComposite()) {\r\n                    if(symbol.power > 1) {\r\n                        symbol = _.expand(symbol);\r\n                    }\r\n\r\n                    var symbols = symbol.collectSymbols();\r\n                    //assumption 1.\r\n                    //since it's a composite, it has a length of at least 1\r\n                    var retval, a, b, d1, d2, n1, n2, s, x, y, c, den, num;\r\n                    a = symbols.pop(); //grab the first symbol\r\n                    //loop through each term and make denominator common\r\n                    while(symbols.length) {\r\n                        b = symbols.pop(); //grab the second symbol\r\n                        d1 = _.parse(a.getDenom());\r\n                        d2 = _.parse(b.getDenom());\r\n                        n1 = a.getNum();\r\n                        n2 = b.getNum();\r\n                        c = _.multiply(d1.clone(), d2.clone());\r\n                        x = _.multiply(n1, d2);\r\n                        y = _.multiply(n2, d1);\r\n                        s = _.add(x, y);\r\n                        a = _.divide(s, c);\r\n                    }\r\n                    den = _.expand(a.getDenom());\r\n                    num = _.expand(a.getNum());\r\n                    //simplify imaginary\r\n                    if(num.isImaginary() && den.isImaginary()) {\r\n                        retval = __.Simplify.complexSimp(num, den);\r\n                    }\r\n                    else {\r\n                        retval = _.divide(num, den);\r\n                    }\r\n\r\n                    //we've already hit the simplest form so return that\r\n                    if(retval.equals(symbol)) {\r\n                        return symbol;\r\n                    }\r\n\r\n                    //otherwise simplify it some more\r\n                    return __.Simplify.simplify(retval);\r\n                }\r\n                return symbol;\r\n            },\r\n            ratSimp: function (symbol) {\r\n                if(symbol.group === CB) {\r\n                    var den = symbol.getDenom();\r\n                    var num = symbol.getNum().distributeMultiplier();\r\n                    var d = __.Simplify.fracSimp(den);\r\n                    var n = __.Simplify.fracSimp(num);\r\n                    symbol = _.divide(n, d);\r\n                }\r\n                return symbol;\r\n            },\r\n            sqrtSimp: function (symbol, sym_array) {\r\n                var retval;\r\n                if(symbol.isSQRT()) {\r\n                    var factored = __.Factor.factor(symbol.args[0].clone());\r\n                    var m = _.parse(factored.multiplier);\r\n                    var sign = m.sign();\r\n\r\n                    var retval = _.sqrt(m.abs());\r\n                    var arg;\r\n\r\n                    if(isInt(retval)) {\r\n\r\n                        if(factored.group === CB) {\r\n                            var rem = new Symbol(1);\r\n\r\n                            factored.each(function (x) {\r\n                                if(x.group === N) {\r\n                                    var trial = _.sqrt(x.clone());\r\n\r\n                                    // Multiply back sqrt if it's an integer otherwise just put back the number\r\n                                    if(isInt(trial)) {\r\n                                        retval = _.multiply(retval, trial);\r\n                                    }\r\n                                    else {\r\n                                        rem = _.multiply(rem, x);\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    rem = _.multiply(rem, x);\r\n                                }\r\n\r\n                            });\r\n                            var t = _.multiply(rem, _.parse(sign));\r\n                            arg = _.sqrt(t.clone());\r\n\r\n                            // Expand if it's imaginary\r\n                            if(arg.isImaginary) {\r\n                                arg = _.sqrt(_.expand(t.clone()));\r\n                            }\r\n                        }\r\n                        else {\r\n                            // Strip the multiplier\r\n                            arg = _.sqrt(factored.clone().toUnitMultiplier());\r\n                        }\r\n                        return _.multiply(retval, arg);\r\n\r\n                    }\r\n\r\n                }\r\n                else if(symbol.isComposite() && symbol.isLinear()) {\r\n                    retval = new Symbol(0);\r\n                    symbol.each(function (x) {\r\n                        retval = _.add(retval, __.Simplify.sqrtSimp(x));\r\n                    }, true);\r\n                    // Put back the multiplier\r\n                    retval = _.multiply(retval, _.parse(symbol.multiplier));\r\n                }\r\n                else if(symbol.group === CB) {\r\n                    retval = _.parse(symbol.multiplier);\r\n                    symbol.each(function (x) {\r\n                        var simp = __.Simplify.sqrtSimp(x);\r\n                        retval = _.multiply(retval, simp);\r\n\r\n                    }, true);\r\n                    // Put back the power\r\n                    retval = _.pow(retval, _.parse(symbol.power));\r\n                }\r\n\r\n                return retval ? retval : _.parse(symbol);\r\n            },\r\n            /**\r\n             * Unused. The goal is to substitute out patterns but it currently doesn't work.\r\n             * @param {Symbol} symbol\r\n             * @return {Array} The symbol and the matched patterns\r\n             */\r\n            patternSub: function (symbol) {\r\n                var patterns = {};\r\n\r\n                var has_CP = function (symbol) {\r\n                    var found = false;\r\n                    symbol.each(function (x) {\r\n                        if(x.group === CP) {\r\n                            found = true;\r\n                        }\r\n                        else if(x.symbols) {\r\n                            found = has_CP(x);\r\n                        }\r\n                    });\r\n\r\n                    return found;\r\n                };\r\n\r\n                var collect = function (sym) {\r\n                    // We loop through each symbol looking for anything in the simplest\r\n                    // form of ax+byz+...\r\n                    sym.each(function (x) {\r\n                        // Items of group N,P,S, need to apply\r\n                        if(!x.symbols && x.group !== FN) {\r\n                            return;\r\n                        }\r\n\r\n                        // Check to see if it has any symbols of group CP\r\n                        // Get the patterns in that symbol instead if it has anything of group CP\r\n                        if(has_CP(x)) {\r\n                            collect(x);\r\n                        }\r\n                        else {\r\n                            if(!patterns[x.value]) {\r\n                                var u = core.Utils.getU(symbol);\r\n                                // Get a u value and mark it for subsitution\r\n                                patterns[x.value] = u;\r\n                                symbol = symbol.sub(x.value, u);\r\n                            }\r\n                        }\r\n                    }, true);\r\n                };\r\n\r\n                // Collect a list of patterns\r\n                collect(symbol);\r\n\r\n                return [symbol, patterns];\r\n            },\r\n            simplify: function (symbol) {\r\n                //remove the multiplier to make calculation easier;\r\n                var sym_array = __.Simplify.strip(symbol);\r\n                symbol = sym_array.pop();\r\n                //remove gcd from denominator\r\n                symbol = __.Simplify.fracSimp(symbol);\r\n                //nothing more to do\r\n                if(symbol.isConstant() || symbol.group === core.groups.S) {\r\n                    sym_array.push(symbol);\r\n                    var ret = __.Simplify.unstrip(sym_array, symbol);\r\n                    return ret;\r\n                }\r\n\r\n                //var patterns;\r\n\r\n                var simplified = symbol.clone(); //make a copy\r\n\r\n                //[simplified, patterns] = __.Simplify.patternSub(symbol);\r\n\r\n                // Simplify sqrt within the symbol\r\n//                simplified = __.Simplify.sqrtSimp(simplified, sym_array);\r\n\r\n                // Try trig simplificatons e.g. cos(x)^2+sin(x)^2\r\n                simplified = __.Simplify.trigSimp(simplified);\r\n\r\n                // Simplify common denominators\r\n                simplified = __.Simplify.ratSimp(simplified);\r\n\r\n                // First go for the \"cheapest\" simplification which may eliminate \r\n                // your problems right away. factor -> evaluate. Remember\r\n                // that there's no need to expand since factor already does that\r\n\r\n                simplified = __.Factor.factor(simplified);\r\n\r\n                //If the simplfied is a sum then we can make a few more simplifications\r\n                //e.g. simplify(1/(x-1)+1/(1-x)) as per issue #431\r\n                if(simplified.group === core.groups.CP && simplified.isLinear()) {\r\n                    var m = simplified.multiplier.clone();\r\n                    simplified.toUnitMultiplier(); //strip the multiplier\r\n                    var r = new Symbol(0);\r\n                    //return the sum of simplifications\r\n                    simplified.each(function (x) {\r\n                        var s = __.Simplify.simplify(x);\r\n                        r = _.add(r, s);\r\n                    });\r\n                    simplified = r;\r\n                    //put back the multiplier\r\n                    r.multiplier = r.multiplier.multiply(m);\r\n                }\r\n\r\n                //place back multiplier and return\r\n                var retval = __.Simplify.unstrip(sym_array, simplified);\r\n\r\n                // Back substitute\r\n                /*\r\n                 for(var x in patterns) {\r\n                 retval = retval.sub(patterns[x], x);\r\n                 }\r\n                 */\r\n\r\n                return retval;\r\n            }\r\n        },\r\n\r\n        Classes: {\r\n            Polynomial: Polynomial,\r\n            Factors: Factors,\r\n            MVTerm: MVTerm\r\n        }\r\n    };\r\n\r\n    // Add a link to simplify\r\n    core.Expression.prototype.simplify = function () {\r\n        return __.Simplify.simplify(this.symbol);\r\n    };\r\n\r\n    nerdamer.useAlgebraDiv = function () {\r\n        var divide = __.divideFn = _.divide;\r\n        var calls = 0; //keep track of how many calls were made\r\n        _.divide = function (a, b) {\r\n            calls++;\r\n            var ans;\r\n            if(calls === 1) //check if this is the first call. If it is use algebra divide\r\n                ans = core.Algebra.divide(a, b);\r\n            else //otherwise use parser divide\r\n                ans = divide(a, b);\r\n            calls = 0; //reset the number of calls back to none\r\n            return ans;\r\n        };\r\n    };\r\n\r\n    nerdamer.useParserDiv = function () {\r\n        if(__.divideFn)\r\n            _.divide = __.divideFn;\r\n        delete __.divideFn;\r\n    };\r\n\r\n    nerdamer.register([\r\n        {\r\n            name: 'factor',\r\n            visible: true,\r\n            numargs: 1,\r\n            build: function () {\r\n                return __.Factor.factor;\r\n            }\r\n        },\r\n        {\r\n            name: 'simplify',\r\n            visible: true,\r\n            numargs: 1,\r\n            build: function () {\r\n                return __.Simplify.simplify;\r\n            }\r\n        },\r\n        {\r\n            name: 'gcd',\r\n            visible: true,\r\n            numargs: [1, ],\r\n            build: function () {\r\n                return __.gcd;\r\n            }\r\n        },\r\n        {\r\n            name: 'lcm',\r\n            visible: true,\r\n            numargs: [1, ],\r\n            build: function () {\r\n                return __.lcm;\r\n            }\r\n        },\r\n        {\r\n            name: 'roots',\r\n            visible: true,\r\n            numargs: -1,\r\n            build: function () {\r\n                return __.roots;\r\n            }\r\n        },\r\n        {\r\n            name: 'divide',\r\n            visible: true,\r\n            numargs: 2,\r\n            build: function () {\r\n                return __.divide;\r\n            }\r\n        },\r\n        {\r\n            name: 'div',\r\n            visible: true,\r\n            numargs: 2,\r\n            build: function () {\r\n                return __.div;\r\n            }\r\n        },\r\n        {\r\n            name: 'partfrac',\r\n            visible: true,\r\n            numargs: [1, 2],\r\n            build: function () {\r\n                return __.PartFrac.partfrac;\r\n            }\r\n        },\r\n        {\r\n            name: 'deg',\r\n            visible: true,\r\n            numargs: [1, 2],\r\n            build: function () {\r\n                return __.degree;\r\n            }\r\n        },\r\n        {\r\n            name: 'coeffs',\r\n            visible: true,\r\n            numargs: [1, 2],\r\n            build: function () {\r\n                var f = function () {\r\n                    var coeffs = __.coeffs.apply(__, arguments);\r\n                    return new core.Vector(coeffs);\r\n                };\r\n                return f;\r\n            }\r\n        },\r\n        {\r\n            name: 'line',\r\n            visible: true,\r\n            numargs: [2, 3],\r\n            build: function () {\r\n                return __.line;\r\n            }\r\n        },\r\n        {\r\n            name: 'sqcomp',\r\n            visible: true,\r\n            numargs: [1, 2],\r\n            build: function () {\r\n                var f = function (x, v) {\r\n                    try {\r\n                        v = v || variables(x)[0];\r\n                        var sq = __.sqComplete(x.clone(), v);\r\n                        return sq.f;\r\n                    }\r\n                    catch(e) {\r\n                        return x;\r\n                    }\r\n                };\r\n                return f;\r\n            }\r\n        }\r\n    ]);\r\n    nerdamer.updateAPI();\r\n})();"]}