nerdamer 1.1.9 → 1.1.13

package/Solve.js

@@ -6,7 +6,7 @@
  */
 /* global module */
 
-if ((typeof module) !== 'undefined') {
+if((typeof module) !== 'undefined') {
     var nerdamer = require('./nerdamer.core.js');
     require('./Calculus.js');
     require('./Algebra.js');
@@ -23,6 +23,7 @@ if ((typeof module) !== 'undefined') {
             remove = core.Utils.remove,
             format = core.Utils.format,
             build = core.Utils.build,
+            knownVariable = core.Utils.knownVariable,
             Symbol = core.Symbol,
             isSymbol = core.Utils.isSymbol,
             variables = core.Utils.variables,
@@ -34,7 +35,7 @@ if ((typeof module) !== 'undefined') {
             Settings = core.Settings,
             range = core.Utils.range,
             isArray = core.Utils.isArray;
-    
+
 
     // The search radius for the roots
     core.Settings.SOLVE_RADIUS = 1000;
@@ -61,7 +62,7 @@ if ((typeof module) !== 'undefined') {
     //size of the slice
     core.Settings.NEWTON_SLICES = 200;
     //The epsilon used in Newton's iteration
-    core.Settings.NEWTON_EPSILON = Number.EPSILON*2;
+    core.Settings.NEWTON_EPSILON = Number.EPSILON * 2;
     //The distance in which two solutions are deemed the same
     core.Settings.SOLUTION_PROXIMITY = 1e-14;
     //Indicate wheter to filter the solutions are not
@@ -74,34 +75,35 @@ if ((typeof module) !== 'undefined') {
     core.Settings.MAX_BISECTION_ITER = 2000;
     // The tolerance for the bisection method
     core.Settings.BI_SECTION_EPSILON = 1e-12;
-    
-    
+
+
     core.Symbol.prototype.hasTrig = function () {
         return this.containsFunction(['cos', 'sin', 'tan', 'cot', 'csc', 'sec']);
     };
 
     core.Symbol.prototype.hasNegativeTerms = function () {
-        if (this.isComposite()) {
-            for (var x in this.symbols) {
+        if(this.isComposite()) {
+            for(var x in this.symbols) {
                 var sym = this.symbols[x];
-                if (sym.group === PL && sym.hasNegativeTerms() || this.symbols[x].power.lessThan(0))
+                if(sym.group === PL && sym.hasNegativeTerms() || this.symbols[x].power.lessThan(0))
                     return true;
             }
         }
         return false;
     };
-    
+
     /* nerdamer version 0.7.x and up allows us to make better use of operator overloading
      * As such we can have this data type be supported completely outside of the core.
      * This is an equation that has a left hand side and a right hand side
      */
     function Equation(lhs, rhs) {
-        if (rhs.isConstant() && lhs.isConstant() && !lhs.equals(rhs) || lhs.equals(core.Settings.IMAGINARY) || rhs.equals(core.Settings.IMAGINARY))
+        if(rhs.isConstant() && lhs.isConstant() && !lhs.equals(rhs) || lhs.equals(core.Settings.IMAGINARY) && rhs.isConstant(true) || rhs.equals(core.Settings.IMAGINARY) && lhs.isConstant(true))
             throw new core.exceptions.NerdamerValueError(lhs.toString() + ' does not equal ' + rhs.toString());
         this.LHS = lhs; //left hand side
         this.RHS = rhs; //right and side
-    };
-    
+    }
+    ;
+
     //UTILS ##!!
 
     Equation.prototype = {
@@ -122,15 +124,22 @@ if ((typeof module) !== 'undefined') {
             }
             var a = eqn.LHS;
             var b = eqn.RHS;
+            
             if(a.isConstant(true) && !b.isConstant(true)) {
                 // Swap them to avoid confusing parser and cause an infinite loop
                 [a, b] = [b, a];
             }
             var _t = _.subtract(a, b);
             var retval = expand ? _.expand(_t) : _t;
+            
+            // Quick workaround for issue #636
+            // This basically borrows the removeDenom method from the Equation class. 
+            // TODO: Make this function a stand-alone function
+            retval = new Equation(retval, new Symbol(0)).removeDenom().LHS;
+            
             return retval;
         },
-        removeDenom: function () { 
+        removeDenom: function () {
             var a = this.LHS.clone();
             var b = this.RHS.clone();
             //remove the denominator on both sides
@@ -138,18 +147,18 @@ if ((typeof module) !== 'undefined') {
             a = _.expand(_.multiply(a, den.clone()));
             b = _.expand(_.multiply(b, den));
             //swap the groups
-            if (b.group === CP && b.group !== CP) {
+            if(b.group === CP && b.group !== CP) {
                 var t = a;
                 a = b;
                 b = t; //swap
             }
 
             //scan to eliminate denominators
-            if (a.group === CB) {
+            if(a.group === CB) {
                 var t = new Symbol(a.multiplier),
                         newRHS = b.clone();
                 a.each(function (y) {
-                    if (y.power.lessThan(0))
+                    if(y.power.lessThan(0))
                         newRHS = _.divide(newRHS, y);
                     else
                         t = _.multiply(t, y);
@@ -158,15 +167,15 @@ if ((typeof module) !== 'undefined') {
                 b = newRHS;
 
             }
-            else if (a.group === CP) {
+            else if(a.group === CP) {
                 //the logic: loop through each and if it has a denominator then multiply it out on both ends
                 //and then start over
-                for (var x in a.symbols) {
+                for(var x in a.symbols) {
                     var sym = a.symbols[x];
-                    if (sym.group === CB) {
-                        for (var y in sym.symbols) {
+                    if(sym.group === CB) {
+                        for(var y in sym.symbols) {
                             var sym2 = sym.symbols[y];
-                            if (sym2.power.lessThan(0)) {
+                            if(sym2.power.lessThan(0)) {
                                 return new Equation(
                                         _.expand(_.multiply(sym2.clone().toLinear(), a)),
                                         _.expand(_.multiply(sym2.clone().toLinear(), b))
@@ -176,7 +185,7 @@ if ((typeof module) !== 'undefined') {
                     }
                 }
             }
-            
+
             return new Equation(a, b);
         },
         clone: function () {
@@ -199,19 +208,33 @@ if ((typeof module) !== 'undefined') {
     _.equals = function (a, b) {
         return new Equation(a, b);
     };
-    
+
+    // Extend simplify
+    (function () {
+        var simplify = _.functions.simplify[0];
+        _.functions.simplify[0] = function (symbol) {
+            if(symbol instanceof Equation) {
+                symbol.LHS = simplify(symbol.LHS);
+                symbol.RHS = simplify(symbol.RHS);
+                return symbol;
+            }
+            // Just call the original simplify
+            return simplify(symbol);
+        };
+    })();
+
     /**
      * Sets two expressions equal
      * @param {Symbol} symbol
      * @returns {Expression}
      */
-    core.Expression.prototype.equals = function(symbol) {
+    core.Expression.prototype.equals = function (symbol) {
         if(symbol instanceof core.Expression)
             symbol = symbol.symbol; //grab the symbol if it's an expression
         var eq = new Equation(this.symbol, symbol);
         return eq;
     };
-    
+
     core.Expression.prototype.solveFor = function (x) {
         var symbol;
         if(this.symbol instanceof Equation) {
@@ -219,15 +242,15 @@ if ((typeof module) !== 'undefined') {
             //check the LHS
             if(this.symbol.LHS.isConstant() && this.symbol.RHS.equals(x))
                 return new core.Expression(this.symbol.LHS);
-            
+
             //check the RHS
             if(this.symbol.RHS.isConstant() && this.symbol.LHS.equals(x))
                 return new core.Expression(this.symbol.RHS);
-            
+
             //otherwise just bring it to LHS
             symbol = this.symbol.toLHS();
         }
-        else  {
+        else {
             symbol = this.symbol;
         }
 
@@ -237,7 +260,7 @@ if ((typeof module) !== 'undefined') {
     };
 
     core.Expression.prototype.expand = function () {
-        if (this.symbol instanceof Equation) {
+        if(this.symbol instanceof Equation) {
             var clone = this.symbol.clone();
             clone.RHS = _.expand(clone.RHS);
             clone.LHS = _.expand(clone.LHS);
@@ -247,46 +270,12 @@ if ((typeof module) !== 'undefined') {
     };
 
     core.Expression.prototype.variables = function () {
-        if (this.symbol instanceof Equation)
+        if(this.symbol instanceof Equation)
             return core.Utils.arrayUnique(variables(this.symbol.LHS).concat(variables(this.symbol.RHS)));
         return variables(this.symbol);
     };
-    
-    core.Matrix.jacobian = function(eqns, vars) {
-        var jacobian = new core.Matrix();
-        //get the variables if not supplied
-        if(!vars) {
-            vars = __.getSystemVariables(eqns);
-        }
-        
-        vars.forEach(function(v, i) {
-            eqns.forEach(function(eq, j) {
-                var e = core.Calculus.diff(eq.clone(), v);
-                jacobian.set(j, i, e);
-            });
-        });
-        
-        return jacobian;
-    };
-    
-    core.Matrix.prototype.max = function() {
-        var max = new Symbol(0);
-        this.each(function(x) {
-            var e = x.abs();
-            if(e.gt(max))
-                max = e;
-        });
-        return max;
-    };
-    
-    core.Matrix.cMatrix = function(value, vars) {
-        var m = new core.Matrix();
-        //make an initial guess
-        vars.forEach(function(v, i) {
-            m.set(i, 0, _.parse(value));
-        });
-        return m;
-    };
+
+
 
     var setEq = function (a, b) {
         return _.equals(a, b);
@@ -294,15 +283,15 @@ if ((typeof module) !== 'undefined') {
 
     //link the Equation class back to the core
     core.Equation = Equation;
-    
+
     //Loops through an array and attempts to fails a test. Stops if manages to fail.
     var checkAll = core.Utils.checkAll = function (args, test) {
-        for (var i = 0; i < args.length; i++)
-            if (test(args[i]))
+        for(var i = 0; i < args.length; i++)
+            if(test(args[i]))
                 return false;
         return true;
     };
-    
+
     //version solve
     var __ = core.Solve = {
         version: '2.0.3',
@@ -317,11 +306,11 @@ if ((typeof module) !== 'undefined') {
          * @param {Equation|String} eqn
          * @returns {Symbol}
          */
-        toLHS: function (eqn, expand) {            
+        toLHS: function (eqn, expand) {
             if(isSymbol(eqn))
                 return eqn;
             //If it's an equation then call its toLHS function instead
-            if (!(eqn instanceof Equation)) {
+            if(!(eqn instanceof Equation)) {
                 var es = eqn.split('=');
                 //convert falsey values to zero
                 es[1] = es[1] || '0';
@@ -329,73 +318,148 @@ if ((typeof module) !== 'undefined') {
             }
             return eqn.toLHS(expand);
         },
-        getSystemVariables: function(eqns) {
-            vars = variables(eqns[0], null, null, true);
-
-            //get all variables
-            for (var i = 1, l=eqns.length; i < l; i++)
-                vars = vars.concat(variables(eqns[i]));
-            //remove duplicates
-            vars = core.Utils.arrayUnique(vars).sort();
-            
-            //done
-            return vars;
+//        getSystemVariables: function(eqns) {
+//            vars = variables(eqns[0], null, null, true);
+//
+//            //get all variables
+//            for (var i = 1, l=eqns.length; i < l; i++)
+//                vars = vars.concat(variables(eqns[i]));
+//            //remove duplicates
+//            vars = core.Utils.arrayUnique(vars).sort();
+//            
+//            //done
+//            return vars;
+//        },
+        /**
+         * Solve a set of circle equations. 
+         * @param {Symbol[]} eqns
+         * @returns {Array}
+         */
+        solveCircle: function (eqns, vars) {
+            // Convert the variables to symbols
+            var svars = vars.map(function (x) {
+                return _.parse(x)
+            });
+
+            var deg = [];
+
+            var solutions = [];
+
+            // Get the degree for the equations
+            for(var i = 0; i < eqns.length; i++) {
+                var d = [];
+                for(var j = 0; j < svars.length; j++) {
+                    d.push(Number(core.Algebra.degree(eqns[i], svars[j])));
+                }
+                // Store the total degree
+                d.push(core.Utils.arraySum(d, true));
+                deg.push(d);
+            }
+
+            var a = eqns[0];
+            var b = eqns[1];
+
+            if(deg[0][2] > deg[1][2]) {
+                [b, a] = [a, b];
+                [deg[1], deg[0]] = [deg[0], deg[1]];
+            }
+
+            // Only solve it's truly a circle
+            if(deg[0][0] === 1 && deg[0][2] === 2 && deg[1][0] === 2 && deg[1][2] === 4) {
+                // For clarity we'll refer to the variables as x and y
+                var x = vars[0];
+                var y = vars[1];
+
+                // We can now get the two points for y
+                var y_points = solve(_.parse(b, knownVariable(x, solve(_.parse(a), x)[0])), y).map(function (x) {
+                    return x.toString();
+                });
+
+                // Since we now know y we can get the two x points from the first equation
+                var x_points = [
+                    solve(_.parse(a, knownVariable(y, y_points[0])))[0].toString()
+                ];
+
+                if(y_points[1]) {
+                    x_points.push(solve(_.parse(a, knownVariable(y, y_points[1])))[0].toString());
+                }
+
+                if(Settings.SOLUTIONS_AS_OBJECT) {
+                    var solutions = {};
+                    solutions[x] = x_points;
+                    solutions[y] = y_points;
+                }
+                else {
+                    y_points.unshift(y);
+                    x_points.unshift(x);
+                    solutions = [x_points, y_points];
+                }
+            }
+
+            return solutions;
         },
-        solveNonLinearSystem: function(eqns, tries, start) {
+        /**
+         * Solve a system of nonlinear equations
+         * @param {Symbol[]} eqns The array of equations
+         * @param {number} tries The maximum number of tries
+         * @param {number} start The starting point where to start looking for solutions
+         * @returns {Array}
+         */
+        solveNonLinearSystem: function (eqns, tries, start) {
             if(tries < 0) {
                 return [];//can't find a solution
             }
-            
+
             start = typeof start === 'undefined' ? core.Settings.NON_LINEAR_START : start;
 
             //the maximum number of times to jump
             var max_tries = core.Settings.MAX_NON_LINEAR_TRIES;
-            
+
             //halfway through the tries
-            var halfway = Math.floor(max_tries/2);
-            
+            var halfway = Math.floor(max_tries / 2);
+
             //initialize the number of tries to 10 if not specified
             tries = typeof tries === 'undefined' ? max_tries : tries;
-            
+
             //a point at which we check to see if we're converging. By inspection it seems that we can
             //use around 20 iterations to see if we're converging. If not then we retry a jump of x
-            var jump_at = core.Settings.NON_LINEAR_JUMP_AT; 
-            
+            var jump_at = core.Settings.NON_LINEAR_JUMP_AT;
+
             //we jump by this many points at each pivot point
             var jump = core.Settings.NON_LINEAR_JUMP_SIZE;
-            
+
             //used to check if we actually found a solution or if we gave up. Assume we will find a solution.
             var found = true;
-            
-            var create_subs = function(vars, matrix) {
-                return vars.map(function(x, i) {
+
+            var create_subs = function (vars, matrix) {
+                return vars.map(function (x, i) {
                     return Number(matrix.get(i, 0));
                 });
             };
-            
-            var vars = __.getSystemVariables(eqns);
-            var jacobian = core.Matrix.jacobian(eqns, vars, function(x) {
+
+            var vars = core.Utils.arrayGetVariables(eqns);
+            var jacobian = core.Matrix.jacobian(eqns, vars, function (x) {
                 return build(x, vars);
             }, true);
-            
+
             var max_iter = core.Settings.MAX_NEWTON_ITERATIONS;
             var o, y, iters, xn1, norm, lnorm, xn, d;
-            
-            var f_eqns = eqns.map(function(eq) {
+
+            var f_eqns = eqns.map(function (eq) {
                 return build(eq, vars);
             });
-            
-            var J = jacobian.map(function(e) {
+
+            var J = jacobian.map(function (e) {
                 return build(e, vars);
             }, true);
             //initial values
             xn1 = core.Matrix.cMatrix(0, vars);
-            
+
             //initialize the c matrix with something close to 0. 
             var c = core.Matrix.cMatrix(start, vars);
-            
+
             iters = 0;
-            
+
             //start of algorithm
             do {
                 //if we've reached the max iterations then exit
@@ -403,41 +467,45 @@ if ((typeof module) !== 'undefined') {
                     break;
                     found = false;
                 }
-                
+
                 //set the substitution object
                 o = create_subs(vars, c);
-                
+
                 //set xn
                 xn = c.clone();
-                
+
                 //make all the substitutions for each of the equations
-                f_eqns.forEach(function(f, i) {
+                f_eqns.forEach(function (f, i) {
                     c.set(i, 0, f.apply(null, o));
                 });
-               
+
                 var m = new core.Matrix();
-                J.each(function(fn, i, j) {
+                J.each(function (fn, i, j) {
                     var ans = fn.apply(null, o);
                     m.set(i, j, ans);
                 });
 
                 m = m.invert();
-                
+
                 //preform the elimination
                 y = _.multiply(m, c).negate();
-                
+
                 //the callback is to avoid overflow in the coeffient denonimator
                 //it converts it to a decimal and then back to a fraction. Some precision
                 //is lost be it's better than overflow. 
-                d = y.subtract(xn1, function(x) { return _.parse(Number(x)); });
+                d = y.subtract(xn1, function (x) {
+                    return _.parse(Number(x));
+                });
 
-                xn1 = xn.add(y, function(x) { return _.parse(Number(x)); });
+                xn1 = xn.add(y, function (x) {
+                    return _.parse(Number(x));
+                });
 
                 //move c is now xn1
                 c = xn1;
-                
+
                 //get the norm
-                
+
                 //the expectation is that we're converging to some answer as this point regardless of where we start
                 //this may have to be adjusted at some point because of erroneous assumptions
                 if(iters >= jump_at) {
@@ -448,9 +516,9 @@ if ((typeof module) !== 'undefined') {
                             start = 0;
                         var sign = tries > halfway ? 1 : -1; //which side are we incrementing
                         //we increment +n at one side and -n at the other. 
-                        n = (tries % Math.floor(halfway))+1;
+                        n = (tries % Math.floor(halfway)) + 1;
                         //adjust the start point
-                        start += (sign*n*jump);
+                        start += (sign * n * jump);
                         //call restart
                         return __.solveNonLinearSystem(eqns, --tries, start);
                     }
@@ -458,32 +526,32 @@ if ((typeof module) !== 'undefined') {
                 lnorm = norm;
                 iters++;
                 norm = d.max();
-                
+
                 //exit early. Revisit if we get bugs
                 if(Number(norm) === Number(lnorm)) {
                     break;
                 }
             }
             while(Number(norm) >= Number.EPSILON)
-            
+
             //return a blank set if nothing was found;
-            if(!found) 
+            if(!found)
                 return [];
-            
+
             //return c since that's the answer
-            return __.systemSolutions(c, vars, true, function(x) {
+            return __.systemSolutions(c, vars, true, function (x) {
                 return core.Utils.round(Number(x), 14);
             });
         },
-        systemSolutions: function(result, vars, expand_result, callback) {
+        systemSolutions: function (result, vars, expand_result, callback) {
             var solutions = core.Settings.SOLUTIONS_AS_OBJECT ? {} : [];
-            
+
             result.each(function (e, idx) {
                 var solution = (expand_result ? _.expand(e) : e).valueOf();
                 if(callback)
                     solution = callback.call(e, solution);
                 var variable = vars[idx];
-                if (core.Settings.SOLUTIONS_AS_OBJECT) {
+                if(core.Settings.SOLUTIONS_AS_OBJECT) {
                     solutions[variable] = solution;
                 }
                 else
@@ -496,12 +564,20 @@ if ((typeof module) !== 'undefined') {
          * Solves a system of equations by substitution. This is useful when
          * no distinct solution exists. e.g. a line, plane, etc.
          * @param {Array} eqns
-         * @param {Array} var_array
-         * @returns {Array|object}
+         * @returns {Array}
          */
-        solveSystemBySubstitution: function(eqns, var_array, m, c) {
-            
+        solveSystemBySubstitution: function (eqns) {
+            // Assume at least 2 equations. The function variables will just return an empty array if undefined is provided
+            var vars_a = variables(eqns[0]);
+            var vars_b = variables(eqns[1]);
+            // Check if it's a circle equation
+            if(eqns.length === 2 && vars_a.length === 2 && core.Utils.arrayEqual(vars_a, vars_b)) {
+                return __.solveCircle(eqns, vars_a);
+            }
+
+            return []; // return an empty set
         },
+
         //https://www.lakeheadu.ca/sites/default/files/uploads/77/docs/RemaniFinal.pdf
         /**
          * Solves a systems of equations
@@ -513,22 +589,65 @@ if ((typeof module) !== 'undefined') {
             //check if a var_array was specified
             //nerdamer.clearVars();// this deleted ALL variables: not what we want
             //parse all the equations to LHS. Remember that they come in as strings
-            for (var i = 0; i < eqns.length; i++)
+            for(var i = 0; i < eqns.length; i++)
                 eqns[i] = __.toLHS(eqns[i]);
 
             var l = eqns.length,
-                m = new core.Matrix(),
-                c = new core.Matrix(),
-                expand_result = false,
-                vars;
+                    m = new core.Matrix(),
+                    c = new core.Matrix(),
+                    expand_result = false,
+                    vars;
 
-            if (typeof var_array === 'undefined') {
+            if(typeof var_array === 'undefined') {
                 //check to make sure that all the equations are linear
-                if (!_A.allLinear(eqns))
-                    return __.solveNonLinearSystem(eqns);
-                    //core.err('System must contain all linear equations!');
+                if(!_A.allLinear(eqns)) {
+                    try {
+                        return __.solveNonLinearSystem(eqns);
+                    }
+                    catch(e) {
+                        if(e instanceof core.exceptions.DivisionByZero) {
+                            return __.solveSystemBySubstitution(eqns);
+                        }
+                    }
+                }
+
+                vars = core.Utils.arrayGetVariables(eqns);
                 
-                vars = __.getSystemVariables(eqns);
+                // If the system only has one variable then we solve for the first one and 
+                // then test the remaining equations with that solution. If any of the remaining
+                // equation fails then the system has no solution
+                if(vars.length === 1) {
+                    var n = 0,
+                        sol, e;
+                    do {
+                        var e = eqns[n].clone();
+                        
+                        if(n > 0) {
+                            e = e.sub(vars[0], sol[0]);
+                        }
+
+                        sol = solve(e, vars[0]);
+                        // Skip the first one
+                        if(n === 0) 
+                            continue;
+                    }
+                    while(++n < eqns.length)
+                        
+                    // Format the output
+                    var solutions;
+                    if(Settings.SOLUTIONS_AS_OBJECT) {
+                        solutions = {};
+                        solutions[vars[0]] = sol;
+                    }
+                    else if(sol.length === 0) {
+                        solutions = sol; // No solutions
+                    }
+                    else {
+                        solutions = [vars[0], sol];
+                    }
+                        
+                    return solutions;
+                }
                 
                 // Deal with redundant equations as expressed in #562
                 // The fix is to remove all but the number of equations equal to the number
@@ -538,15 +657,15 @@ if ((typeof module) !== 'undefined') {
                 if(vars.length < eqns.length) {
                     var reduced = [];
                     var n = eqns.length;
-                    for(var i=0; i<n-1; i++) {
+                    for(var i = 0; i < n - 1; i++) {
                         reduced.push(_.parse(eqns[i]));
                     }
-                    
+
                     var knowns = {};
                     var solutions = __.solveSystem(reduced, vars);
                     // The solutions may have come back as an array
                     if(Array.isArray(solutions)) {
-                        solutions.forEach(function(sol) {
+                        solutions.forEach(function (sol) {
                             knowns[sol[0]] = sol[1];
                         });
                     }
@@ -558,30 +677,30 @@ if ((typeof module) !== 'undefined') {
                     // then all zero will be false
                     var all_zero = true;
                     // Check if the last solution evalutes to zero given these solutions
-                    for(var i=n-1; i<n; i++) {
+                    for(var i = n - 1; i < n; i++) {
                         if(!_.parse(eqns[i], knowns).equals(0)) {
                             all_zero = false;
                         }
                     }
-                    
+
                     if(all_zero) {
                         return solutions;
                     }
                 }
-                
+
                 // deletes only the variables of the linear equations in the nerdamer namespace
-                for (var i = 0; i < vars.length; i++) {
+                for(var i = 0; i < vars.length; i++) {
                     nerdamer.setVar(vars[i], "delete");
                 }
                 // TODO: move this to cMatrix or something similar
                 // populate the matrix
-                for (var i = 0; i < l; i++) {
+                for(var i = 0; i < l; i++) {
                     var e = eqns[i]; //store the expression
                     // Iterate over the columns
-                    for (var j = 0; j < vars.length; j++) {
+                    for(var j = 0; j < vars.length; j++) {
                         var v = vars[j];
                         var coeffs = [];
-                        e.each(function(x) {
+                        e.each(function (x) {
                             if(x.contains(v)) {
                                 coeffs = coeffs.concat(x.coeffs());
                             }
@@ -594,7 +713,7 @@ if ((typeof module) !== 'undefined') {
                     //strip the variables from the symbol so we're left with only the zeroth coefficient
                     //start with the symbol and remove each variable and its coefficient
                     var num = e.clone();
-                    vars.map(function(e) {
+                    vars.map(function (e) {
                         num = num.stripVar(e, true);
                     });
                     c.set(i, 0, num.negate());
@@ -609,54 +728,54 @@ if ((typeof module) !== 'undefined') {
                  */
                 vars = var_array;
                 expand_result = true;
-                for (i = 0; i < l; i++) {
+                for(i = 0; i < l; i++) {
                     //prefill
                     c.set(i, 0, new Symbol(0));
                     var e = _.expand(eqns[i]).collectSymbols(); //expand and store
                     //go trough each of the variables
-                    for (var j = 0; j < var_array.length; j++) {
+                    for(var j = 0; j < var_array.length; j++) {
                         m.set(i, j, new Symbol(0));
                         var v = var_array[j];
                         //go through the terms and sort the variables
-                        for (var k = 0; k < e.length; k++) {
+                        for(var k = 0; k < e.length; k++) {
                             var term = e[k],
                                     check = false;
-                            for (var z = 0; z < var_array.length; z++) {
+                            for(var z = 0; z < var_array.length; z++) {
                                 //check to see if terms contain multiple variables
-                                if (term.contains(var_array[z])) {
-                                    if (check)
+                                if(term.contains(var_array[z])) {
+                                    if(check)
                                         core.err('Multiple variables found for term ' + term);
                                     check = true;
                                 }
                             }
                             //we made sure that every term contains one variable so it's safe to assume that if the
                             //variable is found then the remainder is the coefficient.
-                            if (term.contains(v)) {
+                            if(term.contains(v)) {
                                 var tparts = explode(remove(e, k), v);
                                 m.set(i, j, _.add(m.get(i, j), tparts[0]));
                             }
                         }
                     }
                     //all the remaining terms go to the c matrix
-                    for (k = 0; k < e.length; k++) {
+                    for(k = 0; k < e.length; k++) {
                         c.set(i, 0, _.add(c.get(i, 0), e[k]));
                     }
                 }
                 //consider case (a+b)*I+u
             }
-            
+
             //check if the system has a distinct solution
             if(vars.length !== eqns.length || m.determinant().equals(0)) {
                 // solve the system by hand
                 //return __.solveSystemBySubstitution(eqns, vars, m, c);
                 throw new core.exceptions.SolveError('System does not have a distinct solution');
             }
-            
+
             // Use M^-1*c to solve system
             m = m.invert();
             var result = m.multiply(c);
             //correct the sign as per issue #410
-            if (core.Utils.isArray(var_array))
+            if(core.Utils.isArray(var_array))
                 result.each(function (x) {
                     return x.negate();
                 });
@@ -672,6 +791,8 @@ if ((typeof module) !== 'undefined') {
          */
         quad: function (c, b, a) {
             var discriminant = _.subtract(_.pow(b.clone(), Symbol(2)), _.multiply(_.multiply(a.clone(), c.clone()), Symbol(4)))/*b^2 - 4ac*/;
+            // Fix for #608
+            discriminant = _.expand(discriminant);
             var det = _.pow(discriminant, Symbol(0.5));
             var den = _.parse(_.multiply(new Symbol(2), a.clone()));
             var retval = [
@@ -690,19 +811,18 @@ if ((typeof module) !== 'undefined') {
          * @param {Symbol} a_o
          * @returns {Array}
          */
-        cubic:function (d_o, c_o, b_o, a_o) {
+        cubic: function (d_o, c_o, b_o, a_o) {
             //convert everything to text
             var a = a_o.text(), b = b_o.text(), c = c_o.text(), d = d_o.text();
 
             var t = `(-(${b})^3/(27*(${a})^3)+(${b})*(${c})/(6*(${a})^2)-(${d})/(2*(${a})))`;
             var u = `((${c})/(3*(${a}))-(${b})^2/(9*(${a})^2))`;
             var v = `(${b})/(3*(${a}))`;
-            var x = `((${t})+sqrt((${t})^2)+(${u})^3)^(1/3)+((${t})-sqrt((${t})^2)+(${u})^3)^(1/3)-(${v})`;
-            var x = `(((-((${b}))^3/(27*((${a}))^3)+((${b}))*((${c}))/(6*((${a}))^2)-((${d}))/(2*((${a})))))+sqrt(((-((${b}))^3/(27*((${a}))^3)+((${b}))*((${c}))/(6*((${a}))^2)-((${d}))/(2*((${a})))))^2)+((((${c}))/(3*((${a})))-((${b}))^2/(9*((${a}))^2)))^(3/2))^(1/3)+(((-((${b}))^3/(27*((${a}))^3)+((${b}))*((${c}))/(6*((${a}))^2)-((${d}))/(2*((${a})))))-sqrt(((-((${b}))^3/(27*((${a}))^3)+((${b}))*((${c}))/(6*((${a}))^2)-((${d}))/(2*((${a})))))^2)+((((${c}))/(3*((${a})))-((${b}))^2/(9*((${a}))^2)))^(3/2))^(1/3)-(((${b}))/(3*((${a}))))`
-            
+            var x = `((${t})+sqrt((${t})^2+(${u})^3))^(1/3)+((${t})-sqrt((${t})^2+(${u})^3))^(1/3)-(${v})`;
+
             // Convert a to one
             var w = '1/2+sqrt(3)/2*i'; // Cube root of unity
-            
+
             return [
                 _.parse(x),
                 _.parse(`(${x})(${w})`),
@@ -760,7 +880,7 @@ if ((typeof module) !== 'undefined') {
             var sols = [];
             //see if we can solve the factors
             var factors = core.Algebra.Factor.factor(symbol);
-            if (factors.group === CB) {
+            if(factors.group === CB) {
                 factors.each(function (x) {
                     x = Symbol.unwrapPARENS(x);
                     sols = sols.concat(solve(x, solve_for));
@@ -779,7 +899,7 @@ if ((typeof module) !== 'undefined') {
                 var f, p, pn, n, pf, r, theta, sr, sp, roots;
                 roots = [];
                 f = core.Utils.decompose_fn(eq, solve_for, true);
-                if (f.x.group === S) {
+                if(f.x.group === S) {
                     p = _.parse(f.x.power);
                     pn = Number(p);
                     n = _.pow(_.divide(f.b.negate(), f.a), p.invert());
@@ -789,7 +909,7 @@ if ((typeof module) !== 'undefined') {
                     sr = r.toString();
                     sp = p.toString();
                     var k, root, str;
-                    for (var i = 0; i < pn; i++) {
+                    for(var i = 0; i < pn; i++) {
                         k = i;
                         str = format('({0})*e^(2*{1}*pi*{2}*{3})', sr, k, p, core.Settings.IMAGINARY);
                         root = _.parse(str);
@@ -814,7 +934,7 @@ if ((typeof module) !== 'undefined') {
             points = points || [];
             var f = build(symbol);
             var x0 = 0;
-                
+
             var start = Math.round(x0),
                     last = f(start),
                     last_sign = last / Math.abs(last),
@@ -826,27 +946,27 @@ if ((typeof module) !== 'undefined') {
             points.push(start);//|f(0)| could be a good start
             //adjust for log. A good starting point to include for log is 0.1
             symbol.each(function (x) {
-                if (x.containsFunction(core.Settings.LOG))
+                if(x.containsFunction(core.Settings.LOG))
                     points.push(0.1);
             });
-            
+
             var left = range(-core.Settings.SOLVE_RADIUS, start, step),
-                right = range(start, core.Settings.SOLVE_RADIUS, step);
-            
-            var test_side = function(side, num_roots) {
+                    right = range(start, core.Settings.SOLVE_RADIUS, step);
+
+            var test_side = function (side, num_roots) {
                 var xi, val, sign;
                 var hits = [];
-                for(var i=0, l=side.length; i<l; i++) {
+                for(var i = 0, l = side.length; i < l; i++) {
                     xi = side[i]; //the point being evaluated
                     val = f(xi);
                     sign = val / Math.abs(val);
                     //Don't add non-numeric values
-                    if (isNaN(val) || !isFinite(val) || hits.length > num_roots) { 
+                    if(isNaN(val) || !isFinite(val) || hits.length > num_roots) {
                         continue;
                     }
 
                     //compare the signs. The have to be different if they cross a zero
-                    if (sign !== last_sign) {
+                    if(sign !== last_sign) {
                         hits.push(xi); //take note of the possible zero location
                     }
                     last_sign = sign;
@@ -854,10 +974,10 @@ if ((typeof module) !== 'undefined') {
 
                 points = points.concat(hits);
             };
-            
+
             test_side(left, lside);
             test_side(right, rside);
-            
+
             return points;
         },
         /**
@@ -873,7 +993,7 @@ if ((typeof module) !== 'undefined') {
             // be crossing the x axis so the signs should be different
             if(Math.sign(f(left)) !== Math.sign(f(right))) {
                 var safety = 0;
-           
+
                 var epsilon, middle;
 
                 do {
@@ -895,10 +1015,10 @@ if ((typeof module) !== 'undefined') {
                 while(epsilon >= Settings.EPSILON);
 
                 var solution = (left + right) / 2;
-                
+
                 // Test the solution to make sure that it's within tolerance
                 var x_point = f(solution);
-                
+
                 if(!isNaN(x_point) && Math.abs(x_point) <= core.Settings.BI_SECTION_EPSILON) {
                     // Returns too many junk solutions if not rounded at 13th place.
                     return core.Utils.round(solution, 13);
@@ -920,21 +1040,21 @@ if ((typeof module) !== 'undefined') {
             do {
                 var fx0 = f(x0); //store the result of the function
                 //if the value is zero then we're done because 0 - (0/d f(x0)) = 0
-                if (x0 === 0 && fx0 === 0) {
+                if(x0 === 0 && fx0 === 0) {
                     x = 0;
                     break;
                 }
-                
+
                 iter++;
-                if (iter > maxiter)
+                if(iter > maxiter)
                     return; //naximum iterations reached
 
                 x = x0 - fx0 / fp(x0);
                 var e = Math.abs(x - x0);
                 x0 = x;
             }
-            while (e > Settings.NEWTON_EPSILON)
-            
+            while(e > Settings.NEWTON_EPSILON)
+
             //check if the number is indeed zero. 1e-13 seems to give the most accurate results
             if(Math.abs(f(x)) <= Settings.EPSILON)
                 return x;
@@ -947,7 +1067,7 @@ if ((typeof module) !== 'undefined') {
                 var sqrts = [];
                 //all else
                 var rem = [];
-                rhs.each(function(x) {
+                rhs.each(function (x) {
                     x = x.clone();
                     if(x.fname === 'sqrt' && x.contains(for_variable)) {
                         sqrts.push(x);
@@ -967,16 +1087,16 @@ if ((typeof module) !== 'undefined') {
             else {
                 rhs = Symbol.unwrapSQRT(_.expand(rhs)); //expand the term expression go get rid of quotients when possible
             }
-            
+
             var c = 0, //a counter to see if we have all terms with the variable
                     l = rhs.length;
             //try to rewrite the whole thing
-            if (rhs.group === CP && rhs.contains(for_variable) && rhs.isLinear()) {
+            if(rhs.group === CP && rhs.contains(for_variable) && rhs.isLinear()) {
                 rhs.distributeMultiplier();
                 var t = new Symbol(0);
                 //first bring all the terms containing the variable to the lhs
                 rhs.each(function (x) {
-                    if (x.contains(for_variable)) {
+                    if(x.contains(for_variable)) {
                         c++;
                         t = _.add(t, x.clone());
                     }
@@ -987,24 +1107,24 @@ if ((typeof module) !== 'undefined') {
 
                 //if not all the terms contain the variable so it's in the form
                 //a*x^2+x
-                if (c !== l) {
+                if(c !== l) {
                     return __.rewrite(rhs, lhs, for_variable);
                 }
                 else {
                     return [rhs, lhs];
                 }
             }
-            else if (rhs.group === CB && rhs.contains(for_variable) && rhs.isLinear()) {
-                if (rhs.multiplier.lessThan(0)) {
+            else if(rhs.group === CB && rhs.contains(for_variable) && rhs.isLinear()) {
+                if(rhs.multiplier.lessThan(0)) {
                     rhs.multiplier = rhs.multiplier.multiply(new core.Frac(-1));
                     lhs.multiplier = lhs.multiplier.multiply(new core.Frac(-1));
                 }
-                if (lhs.equals(0))
+                if(lhs.equals(0))
                     return new Symbol(0);
                 else {
                     var t = new Symbol(1);
                     rhs.each(function (x) {
-                        if (x.contains(for_variable))
+                        if(x.contains(for_variable))
                             t = _.multiply(t, x.clone());
                         else
                             lhs = _.divide(lhs, x.clone());
@@ -1014,21 +1134,21 @@ if ((typeof module) !== 'undefined') {
 
                 }
             }
-            else if (!rhs.isLinear() && rhs.contains(for_variable)) {
+            else if(!rhs.isLinear() && rhs.contains(for_variable)) {
                 var p = _.parse(rhs.power.clone().invert());
                 rhs = _.pow(rhs, p.clone());
                 lhs = _.pow(_.expand(lhs), p.clone());
                 return __.rewrite(rhs, lhs, for_variable);
             }
-            else if (rhs.group === FN || rhs.group === S || rhs.group === PL) {
+            else if(rhs.group === FN || rhs.group === S || rhs.group === PL) {
                 return [rhs, lhs];
             }
         },
-        sqrtSolve: function(symbol, v) {
+        sqrtSolve: function (symbol, v) {
             var sqrts = new Symbol(0);
             var rem = new Symbol(0);
             if(symbol.isComposite()) {
-                symbol.each(function(x) {
+                symbol.each(function (x) {
                     if(x.fname === 'sqrt' && x.contains(v)) {
                         sqrts = _.add(sqrts, x.clone());
                     }
@@ -1042,7 +1162,7 @@ if ((typeof module) !== 'undefined') {
                     //square both sides
                     var solutions = solve(t, v);
                     //test the points. The dumb way of getting the answers
-                    solutions = solutions.filter(function(e) {
+                    solutions = solutions.filter(function (e) {
                         if(e.isImaginary())
                             return e;
                         var subs = {};
@@ -1060,46 +1180,50 @@ if ((typeof module) !== 'undefined') {
     /*
      * 
      * @param {String[]|String|Equation} eqns
-     * @param {type} solve_for
+     * @param {String} solve_for
+     * @param {Array} solutions
+     * @param {Number} depth
+     * @param {String|Equation} fn
      * @returns {Array}
      */
-    var solve = function (eqns, solve_for, solutions, depth) {
+    var solve = function (eqns, solve_for, solutions, depth, fn) {
         depth = depth || 0;
-        
+
         if(depth++ > Settings.MAX_SOLVE_DEPTH) {
             return solutions;
         }
-        
+
         //make preparations if it's an Equation
-        if (eqns instanceof Equation) {
+        if(eqns instanceof Equation) {
             //if it's zero then we're done
-            if (eqns.isZero())
+            if(eqns.isZero()) {
                 return [new Symbol(0)];
+            }
             //if the lhs = x then we're done
-            if (eqns.LHS.equals(solve_for) && !eqns.RHS.contains(solve_for)) {
+            if(eqns.LHS.equals(solve_for) && !eqns.RHS.contains(solve_for)) {
                 return [eqns.RHS];
             }
             //if the rhs = x then we're done
-            if (eqns.RHS.equals(solve_for) && !eqns.LHS.contains(solve_for)) {
+            if(eqns.RHS.equals(solve_for) && !eqns.LHS.contains(solve_for)) {
                 return [eqns.LHS];
             }
         }
 
         //unwrap the vector since what we want are the elements
-        if (eqns instanceof core.Vector)
+        if(eqns instanceof core.Vector)
             eqns = eqns.elements;
         solve_for = solve_for || 'x'; //assumes x by default
         //If it's an array then solve it as a system of equations
-        if (isArray(eqns)) {
+        if(isArray(eqns)) {
             return __.solveSystem.apply(undefined, arguments);
         }
-        
-        //parse out functions. Fix for issue #300
-        //eqns = core.Utils.evaluate(eqns);
+
+        // Parse out functions. Fix for issue #300
+        // eqns = core.Utils.evaluate(eqns);
         solutions = solutions || [];
         //mark existing solutions as not to have duplicates
-        var existing = {}; 
-        
+        var existing = {};
+
         // Easy fail. If it's a rational function and the denominator is zero
         // the we're done. Issue #555
         var known = {};
@@ -1107,66 +1231,83 @@ if ((typeof module) !== 'undefined') {
         if(isSymbol(eqns) && evaluate(eqns.getDenom(), known).equals(0) === true) {
             return solutions;
         }
-        
-        //Is usued to add solutions to set. 
-        //TODO: Set is now implemented and should be utilized
+
+        // Is usued to add solutions to set. 
+        // TODO: Set is now implemented and should be utilized
         var add_to_result = function (r, has_trig) {
             var r_is_symbol = isSymbol(r);
-            if (r === undefined || typeof r === 'number' && isNaN(r))
+            if(r === undefined || typeof r === 'number' && isNaN(r))
                 return;
-            if (isArray(r)) {
-                r.forEach(function(sol) {
+            if(isArray(r)) {
+                r.forEach(function (sol) {
                     add_to_result(sol);
                 });
             }
             else {
-                if (r.valueOf() !== 'null') {
+                if(r.valueOf() !== 'null') {
                     // Call the pre-add function if defined. This could be useful for rounding
                     if(typeof core.Settings.PRE_ADD_SOLUTION === 'function') {
                         r = core.Settings.PRE_ADD_SOLUTION(r);
                     }
-                    
-                    if (!r_is_symbol) {
+
+                    if(!r_is_symbol) {
                         r = _.parse(r);
                     }
                     // try to convert the number to multiples of pi
-                    if (core.Settings.make_pi_conversions && has_trig) {
+                    if(core.Settings.make_pi_conversions && has_trig) {
                         var temp = _.divide(r.clone(), new Symbol(Math.PI)),
                                 m = temp.multiplier,
                                 a = Math.abs(m.num),
                                 b = Math.abs(m.den);
-                        if (a < 10 && b < 10)
+                        if(a < 10 && b < 10)
                             r = _.multiply(temp, new Symbol('pi'));
                     }
 
                     // And check if we get a number otherwise we might be throwing out symbolic solutions.
                     var r_str = r.toString();
-                    
-                    if (!existing[r_str]) {
-                        solutions.push(r); 
+
+                    if(!existing[r_str]) {
+                        solutions.push(r);
                     }
                     // Mark the answer as seen
                     existing[r_str] = true;
                 }
             }
         };
-        
-        // Maybe we get lucky
-        if (eqns.group === S && eqns.contains(solve_for)) {
-            add_to_result(new Symbol(0));
+
+        // Maybe we get lucky. Try the point at the function. If it works we have a point
+        // If not it failed
+        if(eqns.group === S && eqns.contains(solve_for)) {
+            try {
+                var o = {};
+                o[solve_for] = 0;
+                evaluate(fn, o, 'numer');
+                add_to_result(new Symbol(0));
+            }
+            catch(e) {
+                // Do nothing;
+            }
+
             return solutions;
         }
-        if (eqns.group === CB) {
-            var sf = String(solve_for); //everything else belongs to the coeff
-            //get the denominator and make sure it doesn't have x since we don't know how to solve for those
-            eqns.each(function (x) {
-                if (x.contains(sf))
-                    solve(x, solve_for, solutions);
-            });
+        if(eqns.group === CB) {
+            // It suffices to solve for the numerator
+            var num = eqns.getNum();
 
-            return solutions;
+            if(num.group === CB) {
+                var sf = String(solve_for); //everything else belongs to the coeff
+                //get the denominator and make sure it doesn't have x since we don't know how to solve for those
+                num.each(function (x) {
+                    if(x.contains(sf))
+                        solve(x, solve_for, solutions, depth, eqns);
+                });
+
+                return solutions;
+            }
+
+            return solve(num, solve_for, solutions, depth, fn);
         }
-        
+
         if(eqns.group === FN && eqns.fname === 'sqrt') {
             eqns = _.pow(Symbol.unwrapSQRT(eqns), new Symbol(2));
         }
@@ -1175,55 +1316,56 @@ if ((typeof module) !== 'undefined') {
         var eq = (core.Utils.isSymbol(eqns) ? eqns : __.toLHS(eqns, false)).getNum(),
                 vars = core.Utils.variables(eq), //get a list of all the variables
                 numvars = vars.length;//how many variables are we dealing with
-        
+
         //it sufficient to solve (x+y) if eq is (x+y)^n since 0^n
         if(core.Utils.isInt(eq.power) && eq.power > 0) {
             eq = _.parse(eq).toLinear();
         }
-       
+
         //if we're dealing with a single variable then we first check if it's a 
         //polynomial (including rationals).If it is then we use the Jenkins-Traubb algorithm.     
         //Don't waste time
-        if (eq.group === S || eq.group === CB && eq.contains(solve_for))
+        if(eq.group === S || eq.group === CB && eq.contains(solve_for)) {
             return [new Symbol(0)];
+        }
         //force to polynomial. We go through each and then we look at what it would 
         //take for its power to be an integer
         //if the power is a fractional we divide by the fractional power
         var fractionals = {},
                 cfact;
-        
+
         var correct_denom = function (symbol) {
             symbol = _.expand(symbol, {
-                expand_denominator: true, 
+                expand_denominator: true,
                 expand_functions: true
             });
             var original = symbol.clone(); //preserve the original
-            
-            if (symbol.symbols) {
-                for (var x in symbol.symbols) {
+
+            if(symbol.symbols) {
+                for(var x in symbol.symbols) {
                     var sym = symbol.symbols[x];
-                    
+
                     //get the denominator of the sub-symbol
                     var den = sym.getDenom();
-                    
+
                     if(!den.isConstant(true) && symbol.isComposite()) {
                         var t = new Symbol(0);
-                        symbol.each(function(e) {
+                        symbol.each(function (e) {
                             t = _.add(t, _.multiply(e, den.clone()));
                         });
 
                         return correct_denom(_.multiply(_.parse(symbol.multiplier), t));
                     }
-                    
+
                     var parts = explode(sym, solve_for);
                     var is_sqrt = parts[1].fname === core.Settings.SQRT;
                     var v = Symbol.unwrapSQRT(parts[1]);
                     var p = v.power.clone();
                     //circular logic with sqrt. Since sqrt(x) becomes x^(1/2) which then becomes sqrt(x), this continues forever
                     //this needs to be terminated if p = 1/2
-                    if (!isSymbol(p) && !p.equals(1 / 2)) {
-                        if (p.den.gt(1)) {
-                            if (is_sqrt) {
+                    if(!isSymbol(p) && !p.equals(1 / 2)) {
+                        if(p.den.gt(1)) {
+                            if(is_sqrt) {
                                 symbol = _.subtract(symbol, sym.clone());
                                 symbol = _.add(symbol, _.multiply(parts[0].clone(), v));
                                 return correct_denom(symbol);
@@ -1231,20 +1373,20 @@ if ((typeof module) !== 'undefined') {
                             var c = fractionals[p.den];
                             fractionals[p.den] = c ? c++ : 1;
                         }
-                        else if (p.sign() === -1) {
+                        else if(p.sign() === -1) {
                             var factor = _.parse(solve_for + '^' + Math.abs(p)); //this
                             //unwrap the symbol's denoniator
                             symbol.each(function (y, index) {
-                                if (y.contains(solve_for)) {
+                                if(y.contains(solve_for)) {
                                     symbol.symbols[index] = _.multiply(y, factor.clone());
                                 }
                             });
                             fractionals = {};
                             return correct_denom(_.parse(symbol));
                         }
-                        else if (sym.group === PL) {
+                        else if(sym.group === PL) {
                             var min_p = core.Utils.arrayMin(core.Utils.keys(sym.symbols));
-                            if (min_p < 0) {
+                            if(min_p < 0) {
                                 var factor = _.parse(solve_for + '^' + Math.abs(min_p));
                                 var corrected = new Symbol(0);
                                 original.each(function (x) {
@@ -1256,16 +1398,17 @@ if ((typeof module) !== 'undefined') {
                     }
                 }
             }
-            
+
             return symbol;
         };
 
+
         //separate the equation
         var separate = function (eq) {
             var lhs = new Symbol(0),
                     rhs = new Symbol(0);
             eq.each(function (x) {
-                if (x.contains(solve_for, true))
+                if(x.contains(solve_for, true))
                     lhs = _.add(lhs, x.clone());
                 else
                     rhs = _.subtract(rhs, x.clone());
@@ -1273,7 +1416,7 @@ if ((typeof module) !== 'undefined') {
             return [lhs, rhs];
         };
 
-        __.inverseFunctionSolve = function(name, lhs, rhs) {
+        __.inverseFunctionSolve = function (name, lhs, rhs) {
             //ax+b comes back as [a, x, ax, b];
             var parts = explode(lhs.args[0], solve_for);
             //check if x is by itself
@@ -1281,25 +1424,25 @@ if ((typeof module) !== 'undefined') {
             if(x.group === S) {
                 return _.divide(_.symfunction(name, [_.divide(rhs, _.parse(lhs.multiplier))]), parts[0]);
             }
-            
+
         };
-        
+
         //first remove any denominators
         eq = correct_denom(eq);
 
-        if (eq.equals(0))
+        if(eq.equals(0))
             return [eq];
         //correct fractionals. I can only handle one type right now
         var fkeys = core.Utils.keys(fractionals);
-        if (fkeys.length === 1) {
+        if(fkeys.length === 1) {
             //make a note of the factor
             cfact = fkeys[0];
             eq.each(function (x, index) {
-                if (x.contains(solve_for)) {
+                if(x.contains(solve_for)) {
                     var parts = explode(x, solve_for);
                     var v = parts[1];
                     var p = v.power;
-                    if (p.den.gt(1)) {
+                    if(p.den.gt(1)) {
                         v.power = p.multiply(new core.Frac(cfact));
                         eq.symbols[index] = _.multiply(v, parts[0]);
                     }
@@ -1307,13 +1450,13 @@ if ((typeof module) !== 'undefined') {
             });
             eq = _.parse(eq);
         }
-        
+
         //try for nested sqrts as per issue #486
         add_to_result(__.sqrtSolve(eq, solve_for));
 
         //polynomial single variable
-        if (numvars === 1) {
-            if (eq.isPoly(true)) {
+        if(numvars === 1) {
+            if(eq.isPoly(true)) {
                 //try to factor and solve
                 var factors = new core.Algebra.Classes.Factors();
 
@@ -1328,14 +1471,14 @@ if ((typeof module) !== 'undefined') {
                     var coeffs = core.Utils.getCoeffs(eq, solve_for),
                             deg = coeffs.length - 1,
                             was_calculated = false;
-                    if (vars[0] === solve_for) {
+                    if(vars[0] === solve_for) {
                         //check to see if all the coefficients are constant
-                        if (checkAll(coeffs, function (x) {
+                        if(checkAll(coeffs, function (x) {
                             return x.group !== core.groups.N;
                         })) {
                             var roots = core.Algebra.proots(eq);
                             //if all the roots are integers then return those
-                            if (checkAll(roots, function (x) {
+                            if(checkAll(roots, function (x) {
                                 return !core.Utils.isInt(x);
                             })) {
                                 //roots have been calculates
@@ -1346,30 +1489,31 @@ if ((typeof module) !== 'undefined') {
                             }
                         }
 
-                        if (!was_calculated) {
+                        if(!was_calculated) {
                             eqns = _.parse(eqns);
                             if(eqns instanceof core.Equation)
                                 eqns = eqns.toLHS();
-                            
+
                             //we can solve algebraically for degrees 1, 2, 3. The remainder we switch to Jenkins-
-                            if (deg === 1)
+                            if(deg === 1)
                                 add_to_result(_.divide(coeffs[0], coeffs[1].negate()));
-                            else if (deg === 2) {
+                            else if(deg === 2) {
                                 add_to_result(_.expand(__.quad.apply(undefined, coeffs)));
                             }
-                            /*
-                            else if (deg === 3) {
+
+                            else if(deg === 3) {
                                 var solutions = []; //set to blank
                                 //first try to factor and solve
                                 var factored = core.Algebra.Factor.factor(eqns);
+
                                 //if it was successfully factored
-                                var solutions = !factored.equals(eqns) ? solve(factored, solve_for) : [];
+                                var solutions = [];
                                 if(solutions.length > 0)
                                     add_to_result(solutions);
                                 else
                                     add_to_result(__.cubic.apply(undefined, coeffs));
                             }
-                            */
+
                             else {
                                 /*
                                  var sym_roots = csolve(eq, solve_for); 
@@ -1394,57 +1538,59 @@ if ((typeof module) !== 'undefined') {
                     var points1 = __.getPoints(eq, 0.1);
                     var points2 = __.getPoints(eq, 0.05);
                     var points3 = __.getPoints(eq, 0.01);
-                    var points = core.Utils.arrayUnique(points1.concat(points2).concat(points3)).sort(function(a, b) { return a-b});
+                    var points = core.Utils.arrayUnique(points1.concat(points2).concat(points3)).sort(function (a, b) {
+                        return a - b;
+                    });
                     var i, point, solution;
 
                     // Compile the function
                     var f = build(eq.clone());
-                    
+
                     // First try to eliminate some points using bisection
                     var t_points = [];
-                    for(i=0; i<points.length; i++) {
+                    for(i = 0; i < points.length; i++) {
                         point = points[i];
-                        
+
                         // See if there's a solution at this point
                         solution = __.bisection(point, f);
-                        
+
                         // If there's no solution then add it to the array for further investigation
                         if(typeof solution === 'undefined') {
                             t_points.push(point);
                             continue;
                         }
-                        
+
                         // Add the solution to the solution set
                         add_to_result(solution, has_trig);
                     }
 
                     // Reset the points to the remaining points
                     points = t_points;
-                    
+
                     // Build the derivative and compile a function
                     var d = _C.diff(eq.clone());
                     var fp = build(d);
-                    for (i = 0; i < points.length; i++) {
+                    for(i = 0; i < points.length; i++) {
                         point = points[i];
-                        
+
                         add_to_result(__.Newton(point, f, fp), has_trig);
                     }
                     solutions.sort();
                 }
                 catch(e) {
                     console.log(e);
-                }   
+                }
             }
         }
         else {
             //The idea here is to go through the equation and collect the coefficients
             //place them in an array and call the quad or cubic function to get the results
-            if (!eq.hasFunc(solve_for) && eq.isComposite()) {
+            if(!eq.hasFunc(solve_for) && eq.isComposite()) {
                 try {
                     var factored = core.Algebra.Factor.factor(eq.clone());
-                    
+
                     if(factored.group === CB) {
-                        factored.each(function(x) {
+                        factored.each(function (x) {
                             add_to_result(solve(x, solve_for));
                         });
                     }
@@ -1456,13 +1602,16 @@ if ((typeof module) !== 'undefined') {
                         //get the denominator and make sure it doesn't have x
 
                         //handle the problem based on the degree
-                        switch (deg) {
+                        switch(deg) {
                             case 0:
                                 var separated = separate(eq);
                                 var lhs = separated[0],
                                         rhs = separated[1];
-                                if (lhs.group === core.groups.EX) {
-                                    add_to_result(_.parse(core.Utils.format(core.Settings.LOG+'(({0})/({2}))/'+core.Settings.LOG+'({1})', rhs, lhs.value, lhs.multiplier)));
+                                
+                                if(lhs.group === core.groups.EX) {
+                                    var log = core.Settings.LOG;
+                                    var expr_str = `${log}((${rhs})/(${lhs.multiplier}))/${log}(${lhs.value})/${lhs.power.multiplier}`;
+                                    add_to_result(_.parse(expr_str));
                                 }
                                 break;
                             case 1:
@@ -1481,28 +1630,28 @@ if ((typeof module) !== 'undefined') {
                                 break;
                             default:
                                 add_to_result(__.csolve(eq, solve_for));
-                                if (solutions.length === 0)
+                                if(solutions.length === 0)
                                     add_to_result(__.divideAndConquer(eq, solve_for));
                         }
-                        
+
                         if(solutions.length === 0) {
                             //try factoring
                             add_to_result(solve(factored, solve_for, solutions, depth));
                         }
-                    }  
-                    
+                    }
+
                 }
-                catch (e) { /*something went wrong. EXITING*/
+                catch(e) { /*something went wrong. EXITING*/
                     ;
                 }
             }
             else {
                 try {
-                    var rw = __.rewrite(eq, null, solve_for); 
+                    var rw = __.rewrite(eq, null, solve_for);
                     var lhs = rw[0];
                     var rhs = rw[1];
-                    if (lhs.group === FN) {
-                        if (lhs.fname === 'abs') {
+                    if(lhs.group === FN) {
+                        if(lhs.fname === 'abs') {
                             add_to_result([rhs.clone(), rhs.negate()]);
                         }
                         else if(lhs.fname === 'sin') {
@@ -1539,47 +1688,48 @@ if ((typeof module) !== 'undefined') {
                         add_to_result(solve(neq, solve_for));
                     }
                 }
-                catch (error) {
+                catch(error) {
                     //Let's try this another way
                     try {
                         //1. if the symbol is in the form a*b*c*... then the solution is zero if 
                         //either a or b or c is zero.
-                        if (eq.group === CB)
+                        if(eq.group === CB)
                             add_to_result(0);
-                        else if (eq.group === CP) {
+                        else if(eq.group === CP) {
                             var separated = separate(eq);
                             var lhs = separated[0],
                                     rhs = separated[1];
 
                             //reduce the equation
-                            if (lhs.group === core.groups.EX && lhs.value === solve_for) {
+                            if(lhs.group === core.groups.EX && lhs.value === solve_for) {
                                 //change the base of both sides
                                 var p = lhs.power.clone().invert();
                                 add_to_result(_.pow(rhs, p));
                             }
                         }
                     }
-                    catch (error) {
+                    catch(error) {
                         ;
                     }
                 }
             }
         }
-        
-        if (cfact) {
+
+        if(cfact) {
             solutions = solutions.map(function (x) {
                 return _.pow(x, new Symbol(cfact));
             });
         }
-        
+
         // Perform some cleanup but don't do it agains arrays, etc
         // Check it actually evaluates to zero
         if(isSymbol(eqns)) {
             var knowns = {};
-            solutions = solutions.filter(function(x) {
+            solutions = solutions.filter(function (x) {
                 try {
                     knowns[solve_for] = x;
                     var zero = Number(evaluate(eqns, knowns));
+
                     // Allow symbolic answers
                     if(isNaN(zero)) {
                         return true;
@@ -1591,10 +1741,10 @@ if ((typeof module) !== 'undefined') {
                 }
             });
         }
-        
+
         return solutions;
     };
-    
+
     //Register the functions for external use
     nerdamer.register([
         {
@@ -1629,11 +1779,5 @@ if ((typeof module) !== 'undefined') {
             }
         }
     ]);
-    nerdamer.api();
-})();
-
-//var sol = nerdamer('solve(a*x^3+b*x^2+c*x+d=0,x)').evaluate();
-//console.log(sol.text())
-
-var sol = nerdamer('solve(x^3+2x^2+3x-4=0,x)').evaluate();
-console.log(sol.text())
+    nerdamer.updateAPI();
+})();