nerdamer 1.1.9 → 1.1.13

package/Calculus.js

@@ -1,79 +1,79 @@
 /* global module */
 
 /*
-* Author : Martin Donk
-* Website : http://www.nerdamer.com
-* Email : martin.r.donk@gmail.com
-* Source : https://github.com/jiggzson/nerdamer
-*/
+ * Author : Martin Donk
+ * Website : http://www.nerdamer.com
+ * Email : martin.r.donk@gmail.com
+ * Source : https://github.com/jiggzson/nerdamer
+ */
 
 if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
     var nerdamer = require('./nerdamer.core.js');
     require('./Algebra.js');
 }
 
-(function() {
+(function () {
     "use strict";
-    
+
     var core = nerdamer.getCore(),
-        _ = core.PARSER,
-        Frac = core.Frac,
-        Settings = core.Settings,
-        isSymbol = core.Utils.isSymbol,
-        FN = core.groups.FN,
-        Symbol = core.Symbol,
-        text = core.Utils.text,
-        inBrackets = core.Utils.inBrackets,
-        isInt = core.Utils.isInt,
-        format = core.Utils.format,
-        even = core.Utils.even,
-        evaluate = core.Utils.evaluate,
-        N = core.groups. N,
-        S = core.groups.S,
-        FN = core.groups.FN,
-        PL = core.groups.PL,
-        CP = core.groups.CP,
-        CB = core.groups.CB,
-        EX = core.groups.EX,
-        P = core.groups.P,
-        LOG = Settings.LOG, 
-        EXP = 'exp', 
-        ABS = 'abs', 
-        SQRT = 'sqrt',
-        SIN = 'sin',  
-        COS = 'cos', 
-        TAN = 'tan',
-        SEC = 'sec', 
-        CSC = 'csc', 
-        COT = 'cot',
-        ASIN = 'asin', 
-        ACOS = 'acos', 
-        ATAN = 'atan',
-        ASEC = 'asec', 
-        ACSC = 'acsc', 
-        ACOT = 'acot',
-        SINH = 'sinh',   
-        COSH = 'cosh',
-        TANH = 'tanh',
-        CSCH = 'csch',
-        SECH = 'sech',
-        COTH = 'coth',
-        ASECH = 'asech',
-        ACSCH = 'acsch',
-        ACOTH = 'acoth';
-        
+            _ = core.PARSER,
+            Frac = core.Frac,
+            Settings = core.Settings,
+            isSymbol = core.Utils.isSymbol,
+            FN = core.groups.FN,
+            Symbol = core.Symbol,
+            text = core.Utils.text,
+            inBrackets = core.Utils.inBrackets,
+            isInt = core.Utils.isInt,
+            format = core.Utils.format,
+            even = core.Utils.even,
+            evaluate = core.Utils.evaluate,
+            N = core.groups.N,
+            S = core.groups.S,
+            FN = core.groups.FN,
+            PL = core.groups.PL,
+            CP = core.groups.CP,
+            CB = core.groups.CB,
+            EX = core.groups.EX,
+            P = core.groups.P,
+            LOG = Settings.LOG,
+            EXP = 'exp',
+            ABS = 'abs',
+            SQRT = 'sqrt',
+            SIN = 'sin',
+            COS = 'cos',
+            TAN = 'tan',
+            SEC = 'sec',
+            CSC = 'csc',
+            COT = 'cot',
+            ASIN = 'asin',
+            ACOS = 'acos',
+            ATAN = 'atan',
+            ASEC = 'asec',
+            ACSC = 'acsc',
+            ACOT = 'acot',
+            SINH = 'sinh',
+            COSH = 'cosh',
+            TANH = 'tanh',
+            CSCH = 'csch',
+            SECH = 'sech',
+            COTH = 'coth',
+            ASECH = 'asech',
+            ACSCH = 'acsch',
+            ACOTH = 'acoth';
+
     //custom errors
-    function NoIntegralFound(msg){
+    function NoIntegralFound(msg) {
         this.message = msg || "";
     }
     NoIntegralFound.prototype = new Error();
-    
+
     //Preparations
-    Symbol.prototype.hasIntegral = function() {
+    Symbol.prototype.hasIntegral = function () {
         return this.containsFunction('integrate');
     };
     //transforms a function
-    Symbol.prototype.fnTransform = function() { 
+    Symbol.prototype.fnTransform = function () {
         if(this.group !== FN)
             return this;
         var retval, a = this.args[0];
@@ -159,26 +159,26 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
         }
         //cos(a*x)^(2*n) or sin(a*x)^(2*n)
         else if((this.fname === COS || this.fname === SIN) && even(this.power)) {
-            var n = this.power/2; 
+            var n = this.power / 2;
             //convert to a double angle
             var double_angle = _.pow(this.clone().toLinear(), _.parse(2)).fnTransform();
             //raise to the n and expand
             var transformed = _.expand(_.pow(double_angle, _.parse(n)));
-            
+
             retval = new Symbol(0);
-            
-            transformed.each(function(s) {
+
+            transformed.each(function (s) {
                 var t = s.fnTransform();
                 retval = _.add(retval, t);
             }, true);
         }
         else
             retval = sym;
-        
+
         return _.multiply(retval, m);
     };
-    
-    Symbol.prototype.hasTrig = function() {
+
+    Symbol.prototype.hasTrig = function () {
         if(this.isConstant(true) || this.group === S)
             return false;
         if(this.fname && (core.Utils.in_trig(this.fname) || core.Utils.in_inverse_trig(this.fname)))
@@ -191,25 +191,25 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
         return false;
     };
 
-    core.Expression.prototype.hasIntegral = function() {
+    core.Expression.prototype.hasIntegral = function () {
         return this.symbol.hasIntegral();
     };
     /**
      * Attempts to rewrite a symbol under one common denominator
      * @param {Symbol} symbol 
      */
-    core.Utils.toCommonDenominator = function(symbol) {
+    core.Utils.toCommonDenominator = function (symbol) {
         //transform x/a+x -> (ax+x)/a
         if(symbol.isComposite() && symbol.isLinear()) {
             var m = new Symbol(symbol.multiplier);
             var denominator = new Symbol(1);
             var numerator = new Symbol(0);
-            symbol.each(function(x) {
+            symbol.each(function (x) {
                 denominator = _.multiply(denominator, x.getDenom());
             }, true);
 
             //remove the denomitor in each term
-            symbol.each(function(x) {
+            symbol.each(function (x) {
                 var num = x.getNum();
                 var den = x.getDenom();
                 var factor = _.multiply(num, _.divide(denominator.clone(), den));
@@ -221,132 +221,170 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
         return symbol;
     };
     //A function to check if a function name is an inverse trig function
-    core.Utils.in_inverse_trig = function(x) {
-        var inv_trig_fns = [ASIN, ACOS, ATAN,   ACSC, ASEC, ACOT];
+    core.Utils.in_inverse_trig = function (x) {
+        var inv_trig_fns = [ASIN, ACOS, ATAN, ACSC, ASEC, ACOT];
         return inv_trig_fns.indexOf(x) !== -1;
     };
     //A function to check if a function name is a trig function
-    core.Utils.in_trig = function(x) {
+    core.Utils.in_trig = function (x) {
         var trig_fns = [COS, SIN, TAN, SEC, CSC, COT];
         return trig_fns.indexOf(x) !== -1;
     };
-    
-    core.Utils.in_htrig = function(x) {
+
+    core.Utils.in_htrig = function (x) {
         var trig_fns = [SINH, COSH, TANH, ACSCH, ASECH, ACOTH];
         return trig_fns.indexOf(x) !== -1;
     };
-    
-    var all_functions = core.Utils.all_functions = function(arr) {
-        for(var i=0, l=arr.length; i<l; i++)
+
+    // Matrix functions
+    core.Matrix.jacobian = function (eqns, vars) {
+        var jacobian = new core.Matrix();
+        //get the variables if not supplied
+        if(!vars) {
+            vars = core.Utils.arrayGetVariables(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 all_functions = core.Utils.all_functions = function (arr) {
+        for(var i = 0, l = arr.length; i < l; i++)
             if(arr[i].group !== FN)
                 return false;
         return true;
     },
-    cosAsinBtransform = core.Utils.cosAsinBtranform = function(symbol1, symbol2) {
-        var a, b;
-        a = symbol1.args[0];
-        b = symbol2.args[0];
-        return _.parse(format('(sin(({0})+({1}))-sin(({0})-({1})))/2', a, b));
-    },
-    cosAsinAtransform = core.Utils.cosAsinAtranform = function(symbol1, symbol2) {
-        //TODO: temporary fix for integrate(e^x*sin(x)*cos(x)^2).
-        //we technically know how to do this transform but more is needed for correct output
-        if(Number(symbol2.power) !== 1)
-            return _.multiply(symbol1, symbol2);
-        var a;
-        a = symbol1.args[0];
-        return _.parse(format('(sin(2*({0})))/2', a));
-    },
-    sinAsinBtransform = core.Utils.cosAsinBtranform = function(symbol1, symbol2) { 
-        var a, b;
-        a = symbol1.args[0];
-        b = symbol2.args[0];
-        return _.parse(format('(cos(({0})+({1}))-cos(({0})-({1})))/2', a, b));
-    },
-    trigTransform = core.Utils.trigTransform = function(arr) { 
-        var map = {}, symbol, t,
-            retval = new Symbol(1);
-        for(var i=0, l=arr.length; i<l; i++) {
-            symbol = arr[i]; 
-
-            if(symbol.group === FN) {
-                var fname = symbol.fname;
-                
-                if(fname === COS && map[SIN]) { 
-                    
-                    if(map[SIN].args[0].toString() !== symbol.args[0].toString()) {
-                        t = cosAsinBtransform(symbol, map[SIN]);
-                    }
-                    else{
-                        t = cosAsinAtransform(symbol, map[SIN]);
-                    }
-                    delete map[SIN];
-                    
-                    retval = _.multiply(retval, t);
-                }
-                else if(fname === SIN && map[COS]) { 
-                    if(map[COS].args[0].toString() !== symbol.args[0].toString()) {
-                        t = cosAsinBtransform(symbol, map[COS]);
-                    }
-                    else {
-                        t = cosAsinAtransform(symbol, map[COS]);
-                    }
-                    delete map[COS];
-                    
-                    retval = _.multiply(retval, t);
-                }
-                else if(fname === SIN && map[SIN]) {
-                    if(map[SIN].args[0].toString() !== symbol.args[0].toString()) {
-                        t = sinAsinBtransform(symbol, map[SIN]);
-                        delete map[SIN];
-                    }
-                    else {
-                        //This should actually be redundant code but let's put just in case
-                        t = _.multiply(symbol, map[SIN]);
-                        delete map[SIN];
+            cosAsinBtransform = core.Utils.cosAsinBtranform = function (symbol1, symbol2) {
+                var a, b;
+                a = symbol1.args[0];
+                b = symbol2.args[0];
+                return _.parse(format('(sin(({0})+({1}))-sin(({0})-({1})))/2', a, b));
+            },
+            cosAsinAtransform = core.Utils.cosAsinAtranform = function (symbol1, symbol2) {
+                //TODO: temporary fix for integrate(e^x*sin(x)*cos(x)^2).
+                //we technically know how to do this transform but more is needed for correct output
+                if(Number(symbol2.power) !== 1)
+                    return _.multiply(symbol1, symbol2);
+                var a;
+                a = symbol1.args[0];
+                return _.parse(format('(sin(2*({0})))/2', a));
+            },
+            sinAsinBtransform = core.Utils.cosAsinBtranform = function (symbol1, symbol2) {
+                var a, b;
+                a = symbol1.args[0];
+                b = symbol2.args[0];
+                return _.parse(format('(cos(({0})+({1}))-cos(({0})-({1})))/2', a, b));
+            },
+            trigTransform = core.Utils.trigTransform = function (arr) {
+                var map = {}, symbol, t,
+                        retval = new Symbol(1);
+                for(var i = 0, l = arr.length; i < l; i++) {
+                    symbol = arr[i];
+
+                    if(symbol.group === FN) {
+                        var fname = symbol.fname;
+
+                        if(fname === COS && map[SIN]) {
+
+                            if(map[SIN].args[0].toString() !== symbol.args[0].toString()) {
+                                t = cosAsinBtransform(symbol, map[SIN]);
+                            }
+                            else {
+                                t = cosAsinAtransform(symbol, map[SIN]);
+                            }
+                            delete map[SIN];
+
+                            retval = _.multiply(retval, t);
+                        }
+                        else if(fname === SIN && map[COS]) {
+                            if(map[COS].args[0].toString() !== symbol.args[0].toString()) {
+                                t = cosAsinBtransform(symbol, map[COS]);
+                            }
+                            else {
+                                t = cosAsinAtransform(symbol, map[COS]);
+                            }
+                            delete map[COS];
+
+                            retval = _.multiply(retval, t);
+                        }
+                        else if(fname === SIN && map[SIN]) {
+                            if(map[SIN].args[0].toString() !== symbol.args[0].toString()) {
+                                t = sinAsinBtransform(symbol, map[SIN]);
+                                delete map[SIN];
+                            }
+                            else {
+                                //This should actually be redundant code but let's put just in case
+                                t = _.multiply(symbol, map[SIN]);
+                                delete map[SIN];
+                            }
+
+                            retval = t;
+                        }
+                        else {
+                            map[fname] = symbol;
+                        }
                     }
-                         
-                    retval = t;
-                }
-                else {
-                    map[fname] = symbol;
+                    else
+                        retval = _.multiply(retval, symbol);
                 }
-            }
-            else
-                retval = _.multiply(retval, symbol);
-        }
-        
-        //put back the remaining functions
-        for(var x in map) 
-            retval = _.multiply(retval, map[x]);
-        
-        return retval;
 
-    };
-    
+                //put back the remaining functions
+                for(var x in map)
+                    retval = _.multiply(retval, map[x]);
+
+                return retval;
+
+            };
+
     core.Settings.integration_depth = 10;
-    
+
     core.Settings.max_lim_depth = 10;
-    
+
     var __ = core.Calculus = {
 
         version: '1.4.6',
 
-        sum: function(fn, index, start, end) {
-            if(!(index.group === core.groups.S)) throw new core.exceptions.NerdamerTypeError('Index must be symbol. '+text(index)+' provided');
+        sum: function (fn, index, start, end) {
+            if(!(index.group === core.groups.S))
+                throw new core.exceptions.NerdamerTypeError('Index must be symbol. ' + text(index) + ' provided');
             index = index.value;
             var retval;
             if(core.Utils.isNumericSymbol(start) && core.Utils.isNumericSymbol(end)) {
                 var modifier = end - start < 200 ? '' : 'PARSE2NUMBER';
                 start = Number(start);
                 end = Number(end);
-                retval = core.Utils.block(modifier, function() {
+                retval = core.Utils.block(modifier, function () {
                     var f = fn.text(),
-                        subs = {'~': true}, //lock subs. Is this even being used?
-                    retval = new core.Symbol(0);
+                            subs = {'~': true}, //lock subs. Is this even being used?
+                            retval = new core.Symbol(0);
 
-                    for(var i=start; i<=end; i++) {
-                        subs[index] = new Symbol(i); 
+                    for(var i = start; i <= end; i++) {
+                        subs[index] = new Symbol(i);
                         var ans = _.parse(f, subs);
                         retval = _.add(retval, ans);
                     }
@@ -354,27 +392,28 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                 });
             }
             else {
-                retval = _.symfunction('sum',arguments);
+                retval = _.symfunction('sum', arguments);
             }
 
             return retval;
         },
-        product: function(fn, index, start, end) {
-            if(!(index.group === core.groups.S)) throw new core.exceptions.NerdamerTypeError('Index must be symbol. '+text(index)+' provided');
+        product: function (fn, index, start, end) {
+            if(!(index.group === core.groups.S))
+                throw new core.exceptions.NerdamerTypeError('Index must be symbol. ' + text(index) + ' provided');
             index = index.value;
             var retval;
             if(core.Utils.isNumericSymbol(start) && core.Utils.isNumericSymbol(end)) {
                 var modifier = end - start < 200 ? '' : 'PARSE2NUMBER';
-                retval = core.Utils.block(modifier, function() {
+                retval = core.Utils.block(modifier, function () {
                     start = Number(start);
                     end = Number(end.multiplier);
 
                     var f = fn.text(),
-                        subs = {},
-                        retval = new core.Symbol(1);
+                            subs = {},
+                            retval = new core.Symbol(1);
 
-                    for(var i=start; i<=end; i++) {
-                        subs[index] = new Symbol(i); 
+                    for(var i = start; i <= end; i++) {
+                        subs[index] = new Symbol(i);
                         retval = _.multiply(retval, _.parse(f, subs));
                     }
                     return retval;
@@ -386,100 +425,102 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
 
             return retval;
         },
-        diff: function(symbol, wrt, nth) { 
+        diff: function (symbol, wrt, nth) {
             if(core.Utils.isVector(symbol)) {
                 var vector = new core.Vector([]);
-                symbol.each(function(x) {
+                symbol.each(function (x) {
                     vector.elements.push(__.diff(x, wrt, nth));
                 });
                 return vector;
             }
             else if(core.Utils.isMatrix(symbol)) {
                 var matrix = new core.Matrix();
-                symbol.each(function(x, i, j) {
+                symbol.each(function (x, i, j) {
                     matrix.set(i, j, __.diff(x, wrt, nth));
                 });
                 return matrix;
             }
 
-            var d = isSymbol(wrt) ? wrt.text() : wrt; 
+            var d = isSymbol(wrt) ? wrt.text() : wrt;
             //the nth derivative
             nth = isSymbol(nth) ? nth.multiplier : nth || 1;
-            
-            if(d === undefined) d = core.Utils.variables(symbol)[0];
-            
+
+            if(d === undefined)
+                d = core.Utils.variables(symbol)[0];
+
             //unwrap sqrt
             if(symbol.group === FN && symbol.fname === SQRT) {
                 var s = symbol.args[0],
-                    sp = symbol.power.clone();
+                        sp = symbol.power.clone();
                 //these groups go to zero anyway so why waste time?
                 if(s.group !== N || s.group !== P) {
-                    s.power = isSymbol(s.power) ? _.multiply(s.power, _.multiply(new Symbol(1/2)), sp) : s.power.multiply(new Frac(0.5)).multiply(sp);
+                    s.power = isSymbol(s.power) ? _.multiply(s.power, _.multiply(new Symbol(1 / 2)), sp) : s.power.multiply(new Frac(0.5)).multiply(sp);
                     s.multiplier = s.multiplier.multiply(symbol.multiplier);
                 }
-                    
+
                 symbol = s;
             }
 
             if(symbol.group === FN && !isSymbol(symbol.power)) {
-                var a = derive(_.parse(symbol)); 
-                var b = __.diff(symbol.args[0].clone(), d); 
+                var a = derive(_.parse(symbol));
+                var b = __.diff(symbol.args[0].clone(), d);
                 symbol = _.multiply(a, b);//chain rule
             }
             else {
                 symbol = derive(symbol);
             }
-            
-            if(nth > 1) { 
+
+            if(nth > 1) {
                 nth--;
                 symbol = __.diff(symbol, wrt, nth);
             }
 
             return symbol;
-  
-             // Equivalent to "derivative of the outside".
+
+            // Equivalent to "derivative of the outside".
             function polydiff(symbol) {
-                if(symbol.value === d || symbol.contains(d, true)) { 
+                if(symbol.value === d || symbol.contains(d, true)) {
                     symbol.multiplier = symbol.multiplier.multiply(symbol.power);
-                    symbol.power = symbol.power.subtract(new Frac(1)); 
+                    symbol.power = symbol.power.subtract(new Frac(1));
                     if(symbol.power.equals(0)) {
                         symbol = Symbol(symbol.multiplier);
                     }
-                } 
-                
+                }
+
                 return symbol;
-            };
-            function derive(symbol) { 
-                var g = symbol.group, a, b, cp; 
+            }
+            
+            function derive(symbol) {
+                var g = symbol.group, a, b, cp;
 
-                if(g === N || g === S && symbol.value !== d || g === P) { 
+                if(g === N || g === S && symbol.value !== d || g === P) {
                     symbol = Symbol(0);
                 }
-                else if(g === S) {  
+                else if(g === S) {
                     symbol = polydiff(symbol);
                 }
-                else if(g === CB) { 
+                else if(g === CB) {
                     var m = symbol.multiplier.clone();
                     symbol.toUnitMultiplier();
-                    var retval =  _.multiply(product_rule(symbol),polydiff(symbol));
+                    var retval = _.multiply(product_rule(symbol), polydiff(symbol));
                     retval.multiplier = retval.multiplier.multiply(m);
                     return retval;
                 }
-                else if(g === FN && symbol.power.equals(1)) { 
+                else if(g === FN && symbol.power.equals(1)) {
                     // Table of known derivatives
                     switch(symbol.fname) {
                         case LOG:
-                            cp = symbol.clone(); 
+                            cp = symbol.clone();
                             symbol = symbol.args[0].clone();//get the arguments
                             symbol.power = symbol.power.negate();
-                            symbol.multiplier = cp.multiplier.divide(symbol.multiplier); 
+                            symbol.multiplier = cp.multiplier.divide(symbol.multiplier);
                             break;
                         case COS:
                             //cos -> -sin
                             symbol.fname = SIN;
                             symbol.multiplier.negate();
                             break;
-                        case SIN: 
+                        case SIN:
                             //sin -> cos
                             symbol.fname = COS;
                             break;
@@ -488,7 +529,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             symbol.fname = SEC;
                             symbol.power = new Frac(2);
                             break;
-                        case SEC: 
+                        case SEC:
                             // Use a clone if this gives errors
                             symbol = qdiff(symbol, TAN);
                             break;
@@ -501,22 +542,22 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             symbol.power = new Frac(2);
                             break;
                         case ASIN:
-                            symbol = _.parse('(sqrt(1-('+text(symbol.args[0])+')^2))^(-1)');
+                            symbol = _.parse('(sqrt(1-(' + text(symbol.args[0]) + ')^2))^(-1)');
                             break;
                         case ACOS:
-                            symbol = _.parse('-(sqrt(1-('+text(symbol.args[0])+')^2))^(-1)');
+                            symbol = _.parse('-(sqrt(1-(' + text(symbol.args[0]) + ')^2))^(-1)');
                             break;
                         case ATAN:
-                            symbol = _.parse('(1+('+text(symbol.args[0])+')^2)^(-1)');
+                            symbol = _.parse('(1+(' + text(symbol.args[0]) + ')^2)^(-1)');
                             break;
-                        case ABS: 
-                            m = symbol.multiplier.clone(); 
+                        case ABS:
+                            m = symbol.multiplier.clone();
                             symbol.toUnitMultiplier();
                             //depending on the complexity of the symbol it's easier to just parse it into a new symbol
                             //this should really be readdressed soon
                             b = symbol.args[0].clone();
                             b.toUnitMultiplier();
-                            symbol = _.parse(inBrackets(text(symbol.args[0]))+'/abs'+inBrackets(text(b)));
+                            symbol = _.parse(inBrackets(text(symbol.args[0])) + '/abs' + inBrackets(text(b)));
                             symbol.multiplier = m;
                             break;
                         case 'parens':
@@ -528,7 +569,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             //cosh -> -sinh
                             symbol.fname = 'sinh';
                             break;
-                        case 'sinh': 
+                        case 'sinh':
                             //sinh -> cosh
                             symbol.fname = 'cosh';
                             break;
@@ -537,88 +578,88 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             symbol.fname = SECH;
                             symbol.power = new Frac(2);
                             break;
-                        case SECH: 
+                        case SECH:
                             // Use a clone if this gives errors
                             symbol = qdiff(symbol, '-tanh');
                             break;
-                        case CSCH: 
+                        case CSCH:
                             var arg = String(symbol.args[0]);
-                            return _.parse('-coth('+arg+')*csch('+arg+')');
+                            return _.parse('-coth(' + arg + ')*csch(' + arg + ')');
                             break;
-                        case COTH: 
+                        case COTH:
                             var arg = String(symbol.args[0]);
-                            return _.parse('-csch('+arg+')^2');
+                            return _.parse('-csch(' + arg + ')^2');
                             break;
                         case 'asinh':
-                            symbol = _.parse('(sqrt(1+('+text(symbol.args[0])+')^2))^(-1)');
+                            symbol = _.parse('(sqrt(1+(' + text(symbol.args[0]) + ')^2))^(-1)');
                             break;
                         case 'acosh':
-                            symbol = _.parse('(sqrt(-1+('+text(symbol.args[0])+')^2))^(-1)');
+                            symbol = _.parse('(sqrt(-1+(' + text(symbol.args[0]) + ')^2))^(-1)');
                             break;
                         case 'atanh':
-                            symbol = _.parse('(1-('+text(symbol.args[0])+')^2)^(-1)');
+                            symbol = _.parse('(1-(' + text(symbol.args[0]) + ')^2)^(-1)');
                             break;
                         case ASECH:
                             var arg = String(symbol.args[0]);
-                            symbol = _.parse('-1/(sqrt(1/('+arg+')^2-1)*('+arg+')^2)');
+                            symbol = _.parse('-1/(sqrt(1/(' + arg + ')^2-1)*(' + arg + ')^2)');
                             break;
                         case ACOTH:
-                            symbol = _.parse('-1/(('+symbol.args[0]+')^2-1)');
+                            symbol = _.parse('-1/((' + symbol.args[0] + ')^2-1)');
                             break;
                         case ACSCH:
                             var arg = String(symbol.args[0]);
-                            symbol = _.parse('-1/(sqrt(1/('+arg+')^2+1)*('+arg+')^2)');
+                            symbol = _.parse('-1/(sqrt(1/(' + arg + ')^2+1)*(' + arg + ')^2)');
                             break;
                         case ASEC:
                             var arg = String(symbol.args[0]);
-                            symbol = _.parse('1/(sqrt(1-1/('+arg+')^2)*('+arg+')^2)');
+                            symbol = _.parse('1/(sqrt(1-1/(' + arg + ')^2)*(' + arg + ')^2)');
                             break;
                         case ACSC:
                             var arg = String(symbol.args[0]);
-                            symbol = _.parse('-1/(sqrt(1-1/('+arg+')^2)*('+arg+')^2)');
+                            symbol = _.parse('-1/(sqrt(1-1/(' + arg + ')^2)*(' + arg + ')^2)');
                             break;
                         case ACOT:
-                            symbol = _.parse('-1/(('+symbol.args[0]+')^2+1)');
+                            symbol = _.parse('-1/((' + symbol.args[0] + ')^2+1)');
                             break;
                         case 'S':
                             var arg = String(symbol.args[0]);
-                            symbol = _.parse('sin((pi*('+arg+')^2)/2)');
+                            symbol = _.parse('sin((pi*(' + arg + ')^2)/2)');
                             break;
                         case 'C':
                             var arg = String(symbol.args[0]);
-                            symbol = _.parse('cos((pi*('+arg+')^2)/2)');
+                            symbol = _.parse('cos((pi*(' + arg + ')^2)/2)');
                             break;
                         case 'Si':
                             var arg = symbol.args[0];
-                            symbol = _.parse('sin('+arg+')/('+arg+')');
+                            symbol = _.parse('sin(' + arg + ')/(' + arg + ')');
                             break;
                         case 'Shi':
                             var arg = symbol.args[0];
-                            symbol = _.parse('sinh('+arg+')/('+arg+')');
+                            symbol = _.parse('sinh(' + arg + ')/(' + arg + ')');
                             break;
                         case 'Ci':
                             var arg = symbol.args[0];
-                            symbol = _.parse('cos('+arg+')/('+arg+')');
+                            symbol = _.parse('cos(' + arg + ')/(' + arg + ')');
                             break;
                         case 'Chi':
                             var arg = symbol.args[0];
-                            symbol = _.parse('cosh('+arg+')/('+arg+')');
+                            symbol = _.parse('cosh(' + arg + ')/(' + arg + ')');
                             break;
                         case 'Ei':
                             var arg = symbol.args[0];
-                            symbol = _.parse('e^('+arg+')/('+arg+')');
+                            symbol = _.parse('e^(' + arg + ')/(' + arg + ')');
                             break;
                         case 'Li':
                             var arg = symbol.args[0];
-                            symbol = _.parse('1/'+Settings.LOG+'('+arg+')');
+                            symbol = _.parse('1/' + Settings.LOG + '(' + arg + ')');
                             break;
                         case 'erf':
-                            symbol = _.parse('(2*e^(-('+symbol.args[0]+')^2))/sqrt(pi)');
+                            symbol = _.parse('(2*e^(-(' + symbol.args[0] + ')^2))/sqrt(pi)');
                             break;
                         case 'atan2':
                             var x_ = String(symbol.args[0]),
-                                y_ = String(symbol.args[1]);
-                            symbol = _.parse('('+y_+')/(('+y_+')^2+('+x_+')^2)');
+                                    y_ = String(symbol.args[1]);
+                            symbol = _.parse('(' + y_ + ')/((' + y_ + ')^2+(' + x_ + ')^2)');
                             break;
                         case 'sign':
                             symbol = new Symbol(0);
@@ -627,35 +668,36 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             symbol = _.parse(format('(({0})*cos({0})-sin({0}))*({0})^(-2)', symbol.args[0]));
                             break;
                         case Settings.LOG10:
-                            symbol = _.parse('1/(('+symbol.args[0]+')*'+Settings.LOG+'(10))');
+                            symbol = _.parse('1/((' + symbol.args[0] + ')*' + Settings.LOG + '(10))');
                             break;
                         default:
                             symbol = _.symfunction('diff', [symbol, wrt]);
                     }
                 }
-                else if(g === EX || g === FN && isSymbol(symbol.power)) { 
+                else if(g === EX || g === FN && isSymbol(symbol.power)) {
                     var value;
                     if(g === EX) {
                         value = symbol.value;
                     }
-                    else if(g === FN && symbol.contains(d)) { 
+                    else if(g === FN && symbol.contains(d)) {
                         value = symbol.fname + inBrackets(text(symbol.args[0]));
                     }
                     else {
                         value = symbol.value + inBrackets(text(symbol.args[0]));
                     }
-                        a = _.multiply(_.parse(LOG+inBrackets(value)), symbol.power.clone()); 
-                        b = __.diff(_.multiply(_.parse(LOG+inBrackets(value)), symbol.power.clone()), d); 
+                    a = _.multiply(_.parse(LOG + inBrackets(value)), symbol.power.clone());
+                    b = __.diff(_.multiply(_.parse(LOG + inBrackets(value)), symbol.power.clone()), d);
                     symbol = _.multiply(symbol, b);
                 }
-                else if(g === FN && !symbol.power.equals(1)) { 
+                else if(g === FN && !symbol.power.equals(1)) {
                     b = symbol.clone();
                     b.toLinear();
                     b.toUnitMultiplier();
-                    symbol = _.multiply(polydiff(symbol.clone()), derive(b));  
+                    symbol = _.multiply(polydiff(symbol.clone()), derive(b));
                 }
-                else if( g === CP || g === PL ) { 
-                    var c = _.parse(symbol);
+                else if(g === CP || g === PL) {
+                    // Note: Do not use `parse` since this puts back the sqrt and causes a bug as in #610. Use clone.
+                    var c = symbol.clone();
                     var result = new Symbol(0);
                     for(var x in symbol.symbols) {
                         result = _.add(result, __.diff(symbol.symbols[x].clone(), d));
@@ -664,23 +706,25 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                 }
 
                 symbol.updateHash();
-                
+
                 return symbol;
-            };
+            }
+            ;
 
             function qdiff(symbol, val, altVal) {
-                return _.multiply(symbol, _.parse(val+inBrackets(altVal || text(symbol.args[0]))));
-            };
+                return _.multiply(symbol, _.parse(val + inBrackets(altVal || text(symbol.args[0]))));
+            }
+            ;
 
-            function product_rule(symbol) { 
+            function product_rule(symbol) {
                 //grab all the symbols within the CB symbol
-                var symbols = symbol.collectSymbols(), 
-                    result = new Symbol(0),
-                    l = symbols.length;
+                var symbols = symbol.collectSymbols(),
+                        result = new Symbol(0),
+                        l = symbols.length;
                 //loop over all the symbols
-                for(var i=0; i<l; i++) {
+                for(var i = 0; i < l; i++) {
                     var df = __.diff(symbols[i].clone(), d);
-                    for(var j=0; j<l; j++) {
+                    for(var j = 0; j < l; j++) {
                         //skip the symbol of which we just pulled the derivative
                         if(i !== j) {
                             //multiply out the remaining symbols
@@ -691,18 +735,19 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     result = _.add(result, df);
                 }
                 return result; //done
-            };
+            }
+            ;
         },
         integration: {
-            u_substitution: function(symbols, dx) { 
+            u_substitution: function (symbols, dx) {
                 function try_combo(a, b, f) {
                     var d = __.diff(b, dx);
                     var q = f ? f(a, b) : _.divide(a.clone(), d);
-                    if(!q.contains(dx, true)) 
+                    if(!q.contains(dx, true))
                         return q;
                     return null;
                 }
-                function do_fn_sub(fname, arg) { 
+                function do_fn_sub(fname, arg) {
                     var subbed = __.integrate(_.symfunction(fname, [new Symbol(u)]), u, 0);
                     subbed = subbed.sub(new Symbol(u), arg);
                     subbed.updateHash();
@@ -710,18 +755,18 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                 }
 
                 var a = symbols[0].clone(),
-                    b = symbols[1].clone(),
-                    g1 = a.group,
-                    g2 = b.group,
-                    //may cause problems if person is using this already. Will need
-                    //to find algorithm for detecting conflict
-                    u = '__u__', 
-                    Q;
+                        b = symbols[1].clone(),
+                        g1 = a.group,
+                        g2 = b.group,
+                        //may cause problems if person is using this already. Will need
+                        //to find algorithm for detecting conflict
+                        u = '__u__',
+                        Q;
                 if(g1 === FN && g2 !== FN) {
                     //e.g. 2*x*cos(x^2)
                     var arg = a.args[0];
                     Q = try_combo(b, arg.clone());
-                    if(Q) 
+                    if(Q)
                         return _.multiply(Q, do_fn_sub(a.fname, arg));
                     Q = try_combo(b, a);
                     if(Q) {
@@ -732,7 +777,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     //e.g. 2*(x+1)*cos((x+1)^2
                     var arg = b.args[0];
                     Q = try_combo(a, arg.clone());
-                    if(Q) 
+                    if(Q)
                         return _.multiply(Q, do_fn_sub(b.fname, arg));
                 }
                 else if(g1 === FN && g2 === FN) {
@@ -743,8 +788,8 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     if(Q)
                         return _.multiply(__.integration.poly_integrate(b), Q);
                 }
-                else if(g1 === EX && g2 !== EX) { 
-                    var p = a.power; 
+                else if(g1 === EX && g2 !== EX) {
+                    var p = a.power;
                     Q = try_combo(b, p.clone());
                     if(!Q) {
                         //one more try
@@ -764,8 +809,8 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     }
                     var integrated = __.integrate(a.sub(p.clone(), new Symbol(u)), u, 0),
                             retval = _.multiply(integrated.sub(new Symbol(u), p), Q);
-                        
-                    
+
+
                     return retval;
                 }
                 else if(g2 === EX && g1 !== EX) {
@@ -774,18 +819,18 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     var integrated = __.integrate(b.sub(p, new Symbol(u)), u, 0);
                     return _.multiply(integrated.sub(new Symbol(u), p), Q);
                 }
-                else if(a.isComposite() || b.isComposite()) { 
-                    var f = function(a, b) {
+                else if(a.isComposite() || b.isComposite()) {
+                    var f = function (a, b) {
                         var d = __.diff(b, dx);
                         var A = core.Algebra.Factor.factor(a),
-                            B = core.Algebra.Factor.factor(d);
+                                B = core.Algebra.Factor.factor(d);
                         var q = _.divide(A, B);
                         return q;
                     };
                     var f1 = a.isComposite() ? a.clone().toLinear() : a.clone(),
-                        f2 = b.isComposite() ? b.clone().toLinear() : b.clone(); 
-                    Q = try_combo(f1.clone(), f2.clone(), f); 
-                    if(Q) 
+                            f2 = b.isComposite() ? b.clone().toLinear() : b.clone();
+                    Q = try_combo(f1.clone(), f2.clone(), f);
+                    if(Q)
                         return _.multiply(__.integration.poly_integrate(b), Q);
                     Q = try_combo(f2.clone(), f1.clone(), f);
                     if(Q)
@@ -793,10 +838,10 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                 }
             },
             //simple integration of a single polynomial x^(n+1)/(n+1)
-            poly_integrate: function(x) { 
+            poly_integrate: function (x) {
                 var p = x.power.toString(),
-                    m = x.multiplier.toDecimal(), 
-                    s = x.toUnitMultiplier().toLinear();
+                        m = x.multiplier.toDecimal(),
+                        s = x.toUnitMultiplier().toLinear();
                 if(Number(p) === -1) {
                     return _.multiply(new Symbol(m), _.symfunction(LOG, [s]));
                 }
@@ -804,27 +849,27 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
             },
             //If we're just spinning wheels we want to stop. This is why we 
             //wrap integration in a try catch block and call this to stop.
-            stop: function(msg) {
+            stop: function (msg) {
                 msg = msg || 'Unable to compute integral!';
                 core.Utils.warn(msg);
                 throw new NoIntegralFound(msg);
             },
-            partial_fraction: function(input, dx, depth, opt) { 
+            partial_fraction: function (input, dx, depth, opt) {
                 //TODO: This whole thing needs to be rolled into one but for now I'll leave it as two separate parts
                 if(!isSymbol(dx))
                     dx = _.parse(dx);
-                
+
                 var result, partial_fractions;
                 result = new Symbol(0);
                 partial_fractions = core.Algebra.PartFrac.partfrac(input, dx);
 
                 if(partial_fractions.group === CB && partial_fractions.isLinear()) {
                     //perform a quick check to make sure that all partial fractions are linear
-                    partial_fractions.each(function(x) {
+                    partial_fractions.each(function (x) {
                         if(!x.isLinear())
                             __.integration.stop();
                     });
-                    partial_fractions.each(function(x) {
+                    partial_fractions.each(function (x) {
                         result = _.add(result, __.integrate(x, dx, depth, opt));
                     });
                 }
@@ -833,11 +878,11 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                 }
                 return result;
             },
-            get_udv: function(symbol) { 
+            get_udv: function (symbol) {
                 var parts = [[/*L*/], [/*I*/], [/*A*/], [/*T*/], [/*E*/]];
                 //first we sort them 
-                var setSymbol = function(x) { 
-                    var g = x.group; 
+                var setSymbol = function (x) {
+                    var g = x.group;
                     if(g === FN) {
                         var fname = x.fname;
                         if(core.Utils.in_trig(fname) || core.Utils.in_htrig(fname))
@@ -846,7 +891,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             parts[1].push(x);
                         else if(fname === LOG)
                             parts[0].push(x);
-                        else { 
+                        else {
                             __.integration.stop();
                         }
                     }
@@ -858,72 +903,73 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     else
                         __.integration.stop();
                 };
-                
-                if(symbol.group === CB) 
-                    symbol.each(function(x) { 
+
+                if(symbol.group === CB)
+                    symbol.each(function (x) {
                         setSymbol(Symbol.unwrapSQRT(x, true));
                     });
-                else 
+                else
                     setSymbol(symbol);
                 var u, dv = new Symbol(1);
                 //compile u and dv
-                for(var i=0; i<5; i++) { 
+                for(var i = 0; i < 5; i++) {
                     var part = parts[i], t,
-                        l = part.length;
+                            l = part.length;
                     if(l > 0) {
                         if(l > 1) {
                             t = new Symbol(1);
-                            for(var j=0; j<l; j++) 
+                            for(var j = 0; j < l; j++)
                                 t = _.multiply(t, part[j].clone());
                         }
                         else
                             t = part[0].clone();
 
-                        if(!u) { 
+                        if(!u) {
                             u = t;//the first u encountered gets chosen
                             u.multiplier = u.multiplier.multiply(symbol.multiplier); //the first one gets the mutliplier
-                        } 
-                        else dv = _.multiply(dv, t); //everything else belongs to dv
-                    }  
+                        }
+                        else
+                            dv = _.multiply(dv, t); //everything else belongs to dv
+                    }
                 }
 
                 return [u, dv];
             },
-            
-            trig_sub: function(symbol, dx, depth, opt, parts, symbols) {  
+
+            trig_sub: function (symbol, dx, depth, opt, parts, symbols) {
                 parts = parts || __.integration.decompose_arg(symbol.clone().toLinear(), dx);
                 var b = parts[3],
-                    ax = parts[2],
-                    a = parts[0],
-                    x = parts[1]; 
+                        ax = parts[2],
+                        a = parts[0],
+                        x = parts[1];
                 if(x.power.equals(2) && a.greaterThan(0)) {
                     //use tan(x)
                     var t = core.Utils.getU(symbol), //get an appropriate u
-                        u = _.parse(TAN+inBrackets(t)), //u
-                        du = _.parse(SEC+inBrackets(t)+'^2'), //du
-                        f = _.multiply(symbol.sub(x, u), du);
+                            u = _.parse(TAN + inBrackets(t)), //u
+                            du = _.parse(SEC + inBrackets(t) + '^2'), //du
+                            f = _.multiply(symbol.sub(x, u), du);
                     var integral = __.integrate(f, t, depth, opt).sub(u, x);
                     core.Utils.clearU(u);
                     return integral;
                 }
             },
-            
-            by_parts: function(symbol, dx, depth, o) { 
+
+            by_parts: function (symbol, dx, depth, o) {
                 o.previous = o.previous || [];
                 var udv, u, dv, du, v, vdu, uv, retval, integral_vdu, m, c, vdu_s;
                 //first LIATE
                 udv = __.integration.get_udv(symbol);
-                u = udv[0]; 
-                dv = udv[1]; 
-                du = Symbol.unwrapSQRT(_.expand(__.diff(u.clone(), dx)), true); 
+                u = udv[0];
+                dv = udv[1];
+                du = Symbol.unwrapSQRT(_.expand(__.diff(u.clone(), dx)), true);
                 c = du.clone().stripVar(dx);
                 //strip any coefficients
                 du = _.divide(du, c.clone());
-                v = __.integrate(dv.clone(), dx, depth || 0); 
-                vdu = _.multiply(v.clone(), du); 
+                v = __.integrate(dv.clone(), dx, depth || 0);
+                vdu = _.multiply(v.clone(), du);
                 vdu_s = vdu.toString();
                 //currently only supports e^x*(some trig)
-                if(o.previous.indexOf(vdu_s) !== -1 && (core.Utils.in_trig(u.fname)) && dv.isE()) { 
+                if(o.previous.indexOf(vdu_s) !== -1 && (core.Utils.in_trig(u.fname)) && dv.isE()) {
                     //We're going to exploit the fact that vdu can never be constant
                     //to work out way out of this cycle. We'll return the length of
                     //the this.previous array until we're back at level one
@@ -934,21 +980,21 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                 else
                     o.previous.push(vdu_s);
 
-                uv = _.multiply(u, v); 
+                uv = _.multiply(u, v);
                 //clear the multiplier so we're dealing with a bare integral
                 m = vdu.multiplier.clone();
                 vdu.toUnitMultiplier();
-                integral_vdu = _.multiply(__.integrate(vdu.clone(), dx, depth, o), c); 
+                integral_vdu = _.multiply(__.integrate(vdu.clone(), dx, depth, o), c);
                 integral_vdu.multiplier = integral_vdu.multiplier.multiply(m);
                 retval = _.subtract(uv, integral_vdu);
                 //we know that there cannot be constants so they're a holdover from a cyclic integral
-                if(o.is_cyclic) { 
+                if(o.is_cyclic) {
                     //start popping the previous stack so we know how deep in we are
                     o.previous.pop();
                     if(o.previous.length === 0) {
                         retval = _.expand(retval);
                         var rem = new Symbol(0);
-                        retval.each(function(x) {
+                        retval.each(function (x) {
                             if(!x.contains(dx))
                                 rem = _.add(rem, x.clone());
                         });
@@ -956,7 +1002,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                         retval = _.divide(_.subtract(retval, rem.clone()), _.subtract(new Symbol(1), rem));
                     }
                 }
-                
+
                 return retval;
             },
             /*
@@ -965,56 +1011,56 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
             decompose_arg: core.Utils.decompose_fn
         },
         //TODO: nerdamer.integrate('-e^(-a*t)*sin(t)', 't') -> gives incorrect output
-        integrate: function(original_symbol, dt, depth, opt) { 
+        integrate: function (original_symbol, dt, depth, opt) {
             //assume integration wrt independent variable if expression only has one variable
             if(!dt) {
                 var vars = core.Utils.variables(original_symbol);
                 if(vars.length === 1)
-                    dt = vars[0]; 
+                    dt = vars[0];
                 //defaults to x
                 dt = dt || 'x';
             }
             //add support for integrating vectors
             if(core.Utils.isVector(original_symbol)) {
                 var vector = new core.Vector([]);
-                original_symbol.each(function(x) {
+                original_symbol.each(function (x) {
                     vector.elements.push(__.integrate(x, dt));
                 });
                 return vector;
             }
             if(!isNaN(dt))
-                _.error('variable expected but received '+dt);
+                _.error('variable expected but received ' + dt);
             //get rid of constants right away
             if(original_symbol.isConstant(true))
                 return _.multiply(original_symbol.clone(), _.parse(dt));
-            
+
             //configurations options for integral. This is needed for tracking extra options
             //e.g. cyclic integrals or additional settings
             opt = opt || {};
-            return core.Utils.block('PARSE2NUMBER', function() {
+            return core.Utils.block('PARSE2NUMBER', function () {
                 //make a note of the original symbol. Set only if undefined
                 depth = depth || 0;
                 var dx = isSymbol(dt) ? dt.toString() : dt,
-                    //we don't want the symbol in sqrt form. x^(1/2) is prefererred
-                    symbol = Symbol.unwrapSQRT(original_symbol.clone(), true), 
-                    g = symbol.group,
-                    retval;
+                        //we don't want the symbol in sqrt form. x^(1/2) is prefererred
+                        symbol = Symbol.unwrapSQRT(original_symbol.clone(), true),
+                        g = symbol.group,
+                        retval;
 
-                try { 
+                try {
                     //We stop integration after x amount of recursive calls
-                    if(++depth > core.Settings.integration_depth) 
+                    if(++depth > core.Settings.integration_depth)
                         __.integration.stop('Maximum depth reached. Exiting!');
 
                     //constants. We first eliminate anything that doesn't have dx. Everything after this has 
                     //to have dx or else it would have been taken care of below
-                    if(!symbol.contains(dx, true)) { 
+                    if(!symbol.contains(dx, true)) {
                         retval = _.multiply(symbol.clone(), _.parse(dx));
                     }
                     //e.g. 2*x
                     else if(g === S) {
                         retval = __.integration.poly_integrate(symbol, dx, depth);
                     }
-                    else if(g === EX) { 
+                    else if(g === EX) {
                         if(symbol.previousGroup === FN && !(symbol.fname === 'sqrt' || symbol.fname === Settings.PARENTHESIS))
                             __.integration.stop();
                         //check the base
@@ -1023,7 +1069,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             //don't know what to do with it e.g. x^x
                             if(symbol.power.contains(dx))
                                 __.integration.stop();
-                            else { 
+                            else {
                                 var t = __.diff(symbol.clone().toLinear(), dx);
                                 if(t.contains(dx))
                                     __.integration.stop();
@@ -1037,7 +1083,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             var a = __.diff(symbol.power.clone(), dx);
                             if(a.contains(dx)) {
                                 var aa = a.stripVar(dx),
-                                    x = _.divide(a.clone(), aa.clone());
+                                        x = _.divide(a.clone(), aa.clone());
                                 if(x.group === S && x.isLinear()) {
                                     aa.multiplier = aa.multiplier.divide(new Frac(2));
                                     return _.parse(format('({2})*(sqrt(pi)*erf(sqrt(-{0})*{1}))/(2*sqrt(-{0}))', aa, dx, symbol.multiplier));
@@ -1045,7 +1091,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                 else
                                     __.integration.stop();
                             }
-                            if(symbol.isE()) { 
+                            if(symbol.isE()) {
                                 if(a.isLinear())
                                     retval = symbol;
                                 else {
@@ -1062,63 +1108,63 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             retval = _.divide(retval, a);
                         }
                     }
-                    else if(symbol.isComposite() && symbol.isLinear()) { 
+                    else if(symbol.isComposite() && symbol.isLinear()) {
                         var m = _.parse(symbol.multiplier);
                         symbol.toUnitMultiplier();
                         retval = new Symbol(0);
-                        symbol.each(function(x) {
+                        symbol.each(function (x) {
                             retval = _.add(retval, __.integrate(x, dx, depth));
                         });
                         retval = _.multiply(m, retval);
                     }
-                    else if(g === CP) { 
+                    else if(g === CP) {
                         if(symbol.power.greaterThan(1))
                             symbol = _.expand(symbol);
                         if(symbol.power.equals(1)) {
                             retval = new Symbol(0);
-                            symbol.each(function(x) {
+                            symbol.each(function (x) {
                                 retval = _.add(retval, __.integrate(x, dx, depth));
                             }, true);
                         }
                         else {
                             var p = Number(symbol.power),
-                                m = symbol.multiplier.clone();//temporarily remove the multiplier
+                                    m = symbol.multiplier.clone();//temporarily remove the multiplier
                             symbol.toUnitMultiplier();
                             var //below we consider the form ax+b
-                                fn = symbol.clone().toLinear(), //get just the pure function without the power
-                                decomp = __.integration.decompose_arg(fn, dx),
-                                //I have no idea why I used bx+a and not ax+b. TODO change this to something that makes sense
-                                b = decomp[3],
-                                ax = decomp[2],
-                                a = decomp[0],
-                                x = decomp[1]; 
-                            if(p === -1 && x.group !== PL && x.power.equals(2)) { 
+                                    fn = symbol.clone().toLinear(), //get just the pure function without the power
+                                    decomp = __.integration.decompose_arg(fn, dx),
+                                    //I have no idea why I used bx+a and not ax+b. TODO change this to something that makes sense
+                                    b = decomp[3],
+                                    ax = decomp[2],
+                                    a = decomp[0],
+                                    x = decomp[1];
+                            if(p === -1 && x.group !== PL && x.power.equals(2)) {
                                 var b_is_positive = isInt(b) ? b > 0 : true;
                                 //we can now check for atan
-                                if(x.group === S && x.power.equals(2) && b_is_positive) { 
+                                if(x.group === S && x.power.equals(2) && b_is_positive) {
                                     ////then we have atan
                                     //abs is redundants since the sign appears in both denom and num.
-                                    var unwrapAbs = function(s) {
+                                    var unwrapAbs = function (s) {
                                         var result = new Symbol(1);
-                                        s.each(function(x) {
+                                        s.each(function (x) {
                                             result = _.multiply(result, x.fname === 'abs' ? x.args[0] : x);
                                         });
                                         return result;
                                     };
                                     var A = a.clone(),
-                                        B = b.clone();
-                                    A = _.pow(A, new Symbol(1/2));
-                                    B = _.pow(B, new Symbol(1/2));
+                                            B = b.clone();
+                                    A = _.pow(A, new Symbol(1 / 2));
+                                    B = _.pow(B, new Symbol(1 / 2));
                                     //unwrap abs
 
                                     var d = _.multiply(unwrapAbs(B), unwrapAbs(A)),
-                                        f = _.symfunction(ATAN, [_.divide(_.multiply(a, x.toLinear()), d.clone())]);
+                                            f = _.symfunction(ATAN, [_.divide(_.multiply(a, x.toLinear()), d.clone())]);
                                     retval = _.divide(f, d);
                                 }
                                 else if(x.group === S && x.isLinear()) {
                                     retval = _.divide(__.integration.poly_integrate(symbol), a);
                                 }
-                                else { 
+                                else {
                                     //1/(x^4+1)
                                     if(x.power.equals(4)) {
                                         //https://www.freemathhelp.com/forum/threads/55678-difficult-integration-int-1-(1-x-4)-dx
@@ -1126,22 +1172,22 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         var br = inBrackets;
                                         //apply rule: ax^4+b = (√ax^2+√2∜a∜bx+√b)(√ax^2-√2∜a∜bx+√b)
                                         //get quadratic factors
-                                        A = _.parse(SQRT+br(a)+'*'+dx+'^2');
-                                        B = _.parse(SQRT+br(2)+'*'+br(a)+'^'+br('1/4')+'*'+br(b)+'^'+br('1/4')+'*'+dx);
-                                        C = _.parse(SQRT+br(b));
+                                        A = _.parse(SQRT + br(a) + '*' + dx + '^2');
+                                        B = _.parse(SQRT + br(2) + '*' + br(a) + '^' + br('1/4') + '*' + br(b) + '^' + br('1/4') + '*' + dx);
+                                        C = _.parse(SQRT + br(b));
                                         f1 = _.add(_.add(A.clone(), B.clone()), C.clone());
                                         f2 = _.add(_.subtract(A, B), C);
                                         //calculate numerators: [D+E, D-E] -> [√2*b^(3/4)+√b∜ax, √2*b^(3/4)-√b∜ax]
-                                        D = _.parse(SQRT+br(2)+'*'+br(b)+'^'+br('3/4'));
-                                        E = _.parse(SQRT+br(b)+'*'+br(b)+'^'+br('1/4')+'*'+dx);
+                                        D = _.parse(SQRT + br(2) + '*' + br(b) + '^' + br('3/4'));
+                                        E = _.parse(SQRT + br(b) + '*' + br(b) + '^' + br('1/4') + '*' + dx);
                                         //let F = 2b√2∜b
-                                        F = _.parse(2+'*'+br(b)+'*'+SQRT+br(2)+'*'+br(b)+'^'+br('1/4'));
+                                        F = _.parse(2 + '*' + br(b) + '*' + SQRT + br(2) + '*' + br(b) + '^' + br('1/4'));
                                         //calculate the factors
                                         L1 = _.divide(_.subtract(D.clone(), E.clone()), _.multiply(F.clone(), f2));
                                         L2 = _.divide(_.add(D, E), _.multiply(F, f1.clone()));
                                         retval = _.add(
-                                                    __.integrate(L1, dx, depth, opt),
-                                                    __.integrate(L2, dx, depth, opt)
+                                                __.integrate(L1, dx, depth, opt),
+                                                __.integrate(L2, dx, depth, opt)
                                                 );
                                     }
                                     else
@@ -1149,7 +1195,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         retval = __.integration.partial_fraction(symbol, dx, depth);
                                 }
                             }
-                            else if(p === -1/2) {
+                            else if(p === -1 / 2) {
                                 //detect asin and atan
                                 if(x.group === S && x.power.equals(2)) {
                                     if(ax.multiplier.lessThan(0) && !b.multiplier.lessThan(0)) {
@@ -1157,13 +1203,13 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         //it's asin
                                         if(b.isConstant() && a.isConstant()) {
                                             var d = _.symfunction(SQRT, [a.clone()]),
-                                                d2 = _.symfunction(SQRT, [_.multiply(a.clone(), b)]);
+                                                    d2 = _.symfunction(SQRT, [_.multiply(a.clone(), b)]);
                                             retval = _.divide(_.symfunction(ASIN, [_.divide(ax.toLinear(), d2)]), d);
                                         }
                                         //I'm not sure about this one. I'm trusting Wolfram Alpha here
                                         else {
                                             var sqrt_a = _.symfunction(SQRT, [a]),
-                                                sqrt_ax = _.multiply(sqrt_a.clone(), x.clone().toLinear());
+                                                    sqrt_ax = _.multiply(sqrt_a.clone(), x.clone().toLinear());
                                             retval = _.divide(_.symfunction(ATAN, [_.divide(sqrt_ax, _.symfunction(SQRT, [fn.clone()]))]), sqrt_a);
                                         }
                                     }
@@ -1177,38 +1223,42 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                     __.integration.stop();
                                 }
                             }
-                            else { 
-                                if(x.isLinear() && x.group !== PL) 
+                            else if(p === 1/2 && x.power.equals(2) && a.greaterThan(0)) {
+                                // TODO: Revisit
+                                __.integration.stop();
+                            }
+                            else {
+                                if(x.isLinear() && x.group !== PL)
                                     retval = _.divide(__.integration.poly_integrate(symbol), a);
-                                else if(x.power.equals(2) && a.greaterThan(0)) { 
+                                else if(x.power.equals(2) && a.greaterThan(0)) {
                                     var sqa, sqb, aob, bsqi, n, integral, u, v, uv;
                                     //1/(a*x^2+b^2)^n
                                     //strip the value of b so b = 1
-                                    sqa = _.parse(SQRT+inBrackets(a)); //strip a so b = 1
-                                    sqb = _.parse(SQRT+inBrackets(b));
+                                    sqa = _.parse(SQRT + inBrackets(a)); //strip a so b = 1
+                                    sqb = _.parse(SQRT + inBrackets(b));
                                     aob = _.multiply(sqa.clone(), sqb.clone()).invert();
                                     bsqi = _.pow(b, new Symbol(symbol.power));
                                     uv = core.Utils.getU(symbol);
                                     u = _.multiply(aob, x.clone().toLinear());
-                                    v = _.parse(ATAN+inBrackets(u));
+                                    v = _.parse(ATAN + inBrackets(u));
                                     //the conversion will be 1+tan(x)^2 -> sec(x)^2
                                     //since the denominator is now (sec(x)^2)^n and the numerator is sec(x)^2 
                                     //then the remaining sec will be (n-1)*2;
-                                    var n = (Math.abs(symbol.power)-1)*2; 
+                                    var n = (Math.abs(symbol.power) - 1) * 2;
                                     //1/sec(x)^n can now be converted to cos(x)^n and we can pull the integral of that
-                                    var integral = __.integrate(_.parse(COS+inBrackets(uv)+'^'+n));
+                                    var integral = __.integrate(_.parse(COS + inBrackets(uv) + '^' + n));
                                     core.Utils.clearU(uv);
                                     return _.multiply(integral.sub(uv, v), bsqi);
                                 }
-                                else { 
+                                else {
                                     if(symbol.group !== CB && !symbol.power.lessThan(0)) {
                                         retval = __.integration.by_parts(symbol, dx, depth, opt);
                                     }
-                                    else { 
+                                    else {
                                         var f = symbol.clone().toLinear();
                                         var factored = core.Algebra.Factor.factor(f);
                                         var was_factored = factored.toString() !== f.toString();
-                                        if(core.Algebra.degree(f, _.parse(dx)).equals(2) && !was_factored) { 
+                                        if(core.Algebra.degree(f, _.parse(dx)).equals(2) && !was_factored) {
                                             try {
                                                 var f1, fx, u, sq;
                                                 sq = core.Algebra.sqComplete(f, dx);
@@ -1229,43 +1279,43 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             retval.multiplier = retval.multiplier.multiply(m);
                         }
                     }
-                    else if(g === FN) { 
+                    else if(g === FN) {
                         var arg = symbol.args[0],
-                            m = symbol.multiplier.clone();
+                                m = symbol.multiplier.clone();
                         symbol.toUnitMultiplier();
                         var decomp = __.integration.decompose_arg(arg, dx);
                         //easies way I can think of to get the coefficient and to make sure
                         //that the symbol is linear wrt dx. I'm not actually trying to get the 
                         //derivative
                         var a = decomp[0],
-                            x = decomp[1],
-                            fname = symbol.fname;
+                                x = decomp[1],
+                                fname = symbol.fname;
                         //log is a special case that can be handled with integration by parts
-                        if(fname === LOG || (fname === ASIN || fname === ACOS || fname === ATAN && x.isLinear())) { 
+                        if(fname === LOG || (fname === ASIN || fname === ACOS || fname === ATAN && x.isLinear())) {
                             /*integration by parts */
-                            var p = symbol.power.toString(); 
+                            var p = symbol.power.toString();
                             if(isInt(p))
                                 depth = depth - p; //it needs more room to find the integral
-                            
+
                             if(!arg.isComposite())
-                                retval = _.multiply(_.parse(m),__.integration.by_parts(symbol, dx, depth, opt)); 
+                                retval = _.multiply(_.parse(m), __.integration.by_parts(symbol, dx, depth, opt));
                             else {
                                 //integral u du
                                 var u = core.Utils.getU(symbol);
-                                var f = _.pow(_.parse(LOG+inBrackets(u)),new Symbol(p));
+                                var f = _.pow(_.parse(LOG + inBrackets(u)), new Symbol(p));
                                 var du = __.diff(arg, dx);
                                 var u_du = _.multiply(f, du);
                                 var integral = __.integrate(u_du, u, depth, opt);
-                                retval = _.multiply(_.parse(m),integral.sub(u, arg));
+                                retval = _.multiply(_.parse(m), integral.sub(u, arg));
                             }
 
                         }
                         else if(fname === TAN && symbol.power.lessThan(0)) {
                             //convert to cotangent
-                            var sym  = symbol.clone();
+                            var sym = symbol.clone();
                             sym.power.negate();
                             sym.fname = COT;
-                            return _.multiply(_.parse(m),__.integrate(sym, dx, depth));
+                            return _.multiply(_.parse(m), __.integrate(sym, dx, depth));
                         }
                         else {
                             if(!a.contains(dx, true) && symbol.isLinear()) { //perform a deep search for safety
@@ -1283,13 +1333,13 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             retval = _.multiply(_.multiply(_.symfunction(ABS, [x.toLinear()]), integrated), a);
                                         }
                                     }
-                                    else 
+                                    else
                                         __.integration.stop();
                                 }
-                                else { 
+                                else {
                                     var ag = symbol.args[0].group,
-                                        decomposed = __.integration.decompose_arg(arg, dx);
-                                    
+                                            decomposed = __.integration.decompose_arg(arg, dx);
+
                                     if(!(ag === CP || ag === S || ag === CB) || !decomposed[1].power.equals(1) || arg.hasFunc())
                                         __.integration.stop();
                                     /**TODO**/ //ASIN, ACOS, ATAN
@@ -1302,16 +1352,16 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             retval.negate();
                                             break;
                                         case TAN:
-                                            retval = _.parse(format(Settings.LOG+'(sec({0}))', arg));
+                                            retval = _.parse(format(Settings.LOG + '(sec({0}))', arg));
                                             break;
                                         case SEC:
-                                            retval = _.parse(format(Settings.LOG+'(tan({0})+sec({0}))', arg));
+                                            retval = _.parse(format(Settings.LOG + '(tan({0})+sec({0}))', arg));
                                             break;
                                         case CSC:
-                                            retval = _.parse(format('-'+Settings.LOG+'(csc({0})+cot({0}))', arg));
+                                            retval = _.parse(format('-' + Settings.LOG + '(csc({0})+cot({0}))', arg));
                                             break;
                                         case COT:
-                                            retval = _.parse(format(Settings.LOG+'(sin({0}))', arg));
+                                            retval = _.parse(format(Settings.LOG + '(sin({0}))', arg));
                                             break;
                                         case SINH:
                                             retval = _.symfunction(COSH, [arg]);
@@ -1320,7 +1370,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             retval = _.symfunction(SINH, [arg]);
                                             break;
                                         case TANH:
-                                            retval = _.parse(format(Settings.LOG+'(cosh({0}))', arg));
+                                            retval = _.parse(format(Settings.LOG + '(cosh({0}))', arg));
                                             break;
                                         case ASEC:
                                             retval = __.integration.by_parts(symbol, dx, depth, opt);
@@ -1331,7 +1381,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         case ACOT:
                                             retval = __.integration.by_parts(symbol, dx, depth, opt);
                                             break;
-                                        //inverse htrig
+                                            //inverse htrig
                                         case ASECH:
                                             retval = __.integration.by_parts(symbol, dx, depth, opt);
                                             break;
@@ -1341,42 +1391,42 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         case ACOTH:
                                             retval = __.integration.by_parts(symbol, dx, depth, opt);
                                             break;
-                                        //end inverse htrig
-                                        //htrigh
+                                            //end inverse htrig
+                                            //htrigh
                                         case SECH:
                                             retval = _.parse(format('atan(sinh({0}))', arg));
                                             break;
                                         case CSCH:
-                                            retval = _.parse(format(Settings.LOG+'(tanh(({0})/2))', arg));
+                                            retval = _.parse(format(Settings.LOG + '(tanh(({0})/2))', arg));
                                             break;
                                         case COTH:
-                                            retval = _.parse(format(Settings.LOG+'(sinh({0}))', arg));
+                                            retval = _.parse(format(Settings.LOG + '(sinh({0}))', arg));
                                             break;
-                                        //end htrig
+                                            //end htrig
                                         case EXP:
                                             retval = __.integrate(_.parse(format('e^({0})', arg)), dx, depth);
                                             break;
                                         case 'S':
                                             var arg = symbol.args[0].clone(),
-                                                dc = __.integration.decompose_arg(arg, dx),
-                                                x_ = dc[1],
-                                                a_ = dc[0];
+                                                    dc = __.integration.decompose_arg(arg, dx),
+                                                    x_ = dc[1],
+                                                    a_ = dc[0];
                                             var b_ = dc[3];
                                             retval = _.parse(format('(cos((1/2)*pi*(({1})+({0})*({2}))^2)+pi*(({1})+({0})*({2}))*S(({1})+({0})*({2})))/(({0})*pi)', a_, b_, x));
                                             break;
                                         case 'C':
                                             var arg = symbol.args[0].clone(),
-                                                dc = __.integration.decompose_arg(arg, dx),
-                                                x_ = dc[1],
-                                                a_ = dc[0];
+                                                    dc = __.integration.decompose_arg(arg, dx),
+                                                    x_ = dc[1],
+                                                    a_ = dc[0];
                                             var b_ = dc[3];
                                             retval = _.parse(format('(pi*(({1})+({0})*({2}))*C(({1})+({0})*({2}))-sin((1/2)*pi*(({1})+({0})*({2}))^2))/(({0})*pi)', a_, b_, x_));
                                             break;
                                         case 'erf':
                                             var arg = symbol.args[0].clone(),
-                                                dc = __.integration.decompose_arg(arg, dx),
-                                                x_ = dc[1],
-                                                a_ = dc[0];
+                                                    dc = __.integration.decompose_arg(arg, dx),
+                                                    x_ = dc[1],
+                                                    a_ = dc[0];
                                             retval = _.parse(format('e^(-(({2}))^2)/(({0})*sqrt(pi))+(1/({0})+({1}))*erf(({2}))', a_, x_, arg));
                                             break;
                                         case 'sign':
@@ -1386,10 +1436,10 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             __.integration.stop();
                                     }
 
-                                    retval = _.divide(retval, a); 
+                                    retval = _.divide(retval, a);
                                 }
                             }
-                            else if(x.isLinear()) { 
+                            else if(x.isLinear()) {
                                 if(fname === COS || fname === SIN) {
                                     var p = Number(symbol.power);
                                     //check to see if it's negative and then just transform it to sec or csc
@@ -1400,44 +1450,45 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                     }
                                     else {
                                         var arg = symbol.args[0],
-                                            rd = symbol.clone(), //cos^(n-1)
-                                            rd2 = symbol.clone(), //cos^(n-2)
-                                            q = new Symbol((p-1)/p), //
-                                            na = _.multiply(a.clone(), new Symbol(p)).invert(); //1/(n*a)
+                                                rd = symbol.clone(), //cos^(n-1)
+                                                rd2 = symbol.clone(), //cos^(n-2)
+                                                q = new Symbol((p - 1) / p), //
+                                                na = _.multiply(a.clone(), new Symbol(p)).invert(); //1/(n*a)
                                         rd.power = rd.power.subtract(new Frac(1));
                                         rd2.power = rd2.power.subtract(new Frac(2));
 
                                         var t = _.symfunction(fname === COS ? SIN : COS, [arg.clone()]);
-                                        if(fname === SIN) t.negate();
+                                        if(fname === SIN)
+                                            t.negate();
                                         retval = _.add(_.multiply(_.multiply(na, rd), t), _.multiply(q, __.integrate(_.parse(rd2), dx, depth)));
                                     }
                                 }
                                 //tan(x)^n or cot(x)^n
-                                else if(fname === TAN || fname === COT) { 
+                                else if(fname === TAN || fname === COT) {
                                     //http://www.sosmath.com/calculus/integration/moretrigpower/moretrigpower.html
                                     if(symbol.args[0].isLinear(dx)) {
                                         var n = symbol.power.subtract(new Frac(1)).toString(),
-                                            r = symbol.clone().toUnitMultiplier(),
-                                            w = _.parse(format((fname === COT ? '-' : '')+'1/({2}*{0})*{3}({1})^({0})', n, arg, a, fname));
+                                                r = symbol.clone().toUnitMultiplier(),
+                                                w = _.parse(format((fname === COT ? '-' : '') + '1/({2}*{0})*{3}({1})^({0})', n, arg, a, fname));
                                         r.power = r.power.subtract(new Frac(2));
                                         if(r.power.equals(0))
                                             r = _.parse(r);
                                         retval = _.subtract(w, __.integrate(r, dx, depth));
-                                    }   
+                                    }
                                 }
                                 //sec(x)^n or csc(x)^n
-                                else if(fname === SEC || fname === CSC) { 
+                                else if(fname === SEC || fname === CSC) {
                                     //http://www.sosmath.com/calculus/integration/moretrigpower/moretrigpower.html
                                     var n1 = symbol.power.subtract(new Frac(1)).toString(),
-                                        n2 = symbol.power.subtract(new Frac(2)).toString(),
-                                        f2 = fname === SEC ? TAN : COT,
-                                        r = symbol.clone().toUnitMultiplier(),
-                                        parse_str = format((fname === CSC ? '-' : '')+'1/({0}*{1})*{4}({3})^({2})*{5}({3})', a, n1, n2, arg, fname, f2),
-                                        w = _.parse(parse_str);
+                                            n2 = symbol.power.subtract(new Frac(2)).toString(),
+                                            f2 = fname === SEC ? TAN : COT,
+                                            r = symbol.clone().toUnitMultiplier(),
+                                            parse_str = format((fname === CSC ? '-' : '') + '1/({0}*{1})*{4}({3})^({2})*{5}({3})', a, n1, n2, arg, fname, f2),
+                                            w = _.parse(parse_str);
                                     r.power = r.power.subtract(new Frac(2));
                                     if(r.power.equals(0))
                                         r = _.parse(r);
-                                    retval = _.add(w, _.multiply(new Symbol(n2/n1), __.integrate(r, dx, depth)));
+                                    retval = _.add(w, _.multiply(new Symbol(n2 / n1), __.integrate(r, dx, depth)));
                                 }
                                 else if((fname === COSH || fname === SINH) && symbol.power.equals(2)) {
                                     retval = __.integrate(symbol.fnTransform(), dx, depth);
@@ -1445,7 +1496,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                 else
                                     __.integration.stop();
                             }
-                            else 
+                            else
                                 __.integration.stop();
 
                             retval.multiplier = retval.multiplier.multiply(m);
@@ -1458,9 +1509,9 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                         var den = symbol.getDenom();
                         if(den.group === S)
                             symbol = _.expand(symbol);
-                        
+
                         //separate the coefficient since all we care about are symbols containing dx
-                        var coeff = symbol.stripVar(dx); 
+                        var coeff = symbol.stripVar(dx);
                         //now get only those that apply
                         var cfsymbol = _.divide(symbol.clone(), coeff.clone()); //a coeff free symbol
                         //peform a correction for stripVar. This is a serious TODO!
@@ -1468,32 +1519,34 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                             cfsymbol = _.multiply(cfsymbol, coeff);
                             coeff = new Symbol(1);
                         }
-                        
+
                         //if we only have one symbol left then let's not waste time. Just pull the integral
                         //and let the chips fall where they may
                         if(cfsymbol.group !== CB) {
-                            if(cfsymbol.equals(1)) { 
+                            if(cfsymbol.equals(1)) {
                                 return __.integrate(_.expand(symbol), dx, depth);
                             }
-                            
+
                             //only factor for multivariate which are polynomials
                             if(cfsymbol.clone().toLinear().isPoly(true) && core.Utils.variables(cfsymbol).length > 1) {
                                 cfsymbol = core.Algebra.Factor.factor(cfsymbol);
                             }
-  
+
                             retval = __.integrate(cfsymbol, dx, depth);
                         }
-                        else { 
+                        else {
                             //we collect the symbols and sort them descending group, descending power, descending alpabethically
-                            var symbols = cfsymbol.collectSymbols().sort(function(a, b) {
-                                if(a.group === b.group)  {
+                            var symbols = cfsymbol.collectSymbols().sort(function (a, b) {
+                                if(a.group === b.group) {
                                     if(Number(a.power) === Number(b.power))
-                                        if(a < b) return 1; //I want sin first
-                                        else return -1;
+                                        if(a < b)
+                                            return 1; //I want sin first
+                                        else
+                                            return -1;
                                     return b.power - a.power; //descending power
                                 }
                                 return b.group - a.group; //descending groups
-                            }).map(function(x) {
+                            }).map(function (x) {
                                 var unwrapped = Symbol.unwrapSQRT(x, true);
                                 if(unwrapped.fname === EXP) {
                                     return _.parse(format('({1})*e^({0})', unwrapped.args[0], unwrapped.multiplier));
@@ -1501,7 +1554,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                 return unwrapped;
                             });
                             var l = symbols.length;
-                            if(symbol.power < 0) { 
+                            if(symbol.power < 0) {
                                 if(l === 2) {
                                     return __.integrate(_.expand(symbol), dx, depth, opt);
                                 }
@@ -1514,25 +1567,27 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                     try {
                                         retval = __.integration.u_substitution(symbols, dx);
                                     }
-                                    catch(e){/* failed :`(*/; }   
+                                    catch(e) {/* failed :`(*/
+                                        ;
+                                    }
 
-                                    if(!retval) { 
+                                    if(!retval) {
                                         //no success with u substitution so let's try known combinations
                                         //are they two functions
                                         var g1 = symbols[0].group,
-                                            g2 = symbols[1].group,
-                                            sym1 = symbols[0],
-                                            sym2 = symbols[1],
-                                            fn1 = sym1.fname,
-                                            fn2 = sym2.fname; 
+                                                g2 = symbols[1].group,
+                                                sym1 = symbols[0],
+                                                sym2 = symbols[1],
+                                                fn1 = sym1.fname,
+                                                fn2 = sym2.fname;
                                         //reset the symbol minus the coeff
                                         symbol = _.multiply(sym1.clone(), sym2.clone());
-                                        if(g1 === FN && g2 === FN) { 
-                                            if(fn1 === LOG || fn2 === LOG) { 
+                                        if(g1 === FN && g2 === FN) {
+                                            if(fn1 === LOG || fn2 === LOG) {
                                                 retval = __.integration.by_parts(symbol.clone(), dx, depth, opt);
                                             }
-                                            else { 
-                                                symbols.sort(function(a, b) {
+                                            else {
+                                                symbols.sort(function (a, b) {
                                                     return b.fname > a.fname;
                                                 });
                                                 var arg1 = sym1.args[0];
@@ -1542,7 +1597,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
 
                                                 var decomp = __.integration.decompose_arg(arg1, dx);
                                                 x = decomp[1],
-                                                a = decomp[0];
+                                                        a = decomp[0];
                                                 if(!x.isLinear()) //again... linear arguments only wrt x
                                                     __.integration.stop();
 
@@ -1550,12 +1605,12 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                 //make sure we can integrate FN & FN
                                                 var arg2 = sym2.args[0];
                                                 //make sure that their argument matches
-                                                if(arg1.equals(arg2)) { 
-                                                    if(fn1 === SIN && fn2 === COS || fn1 === COS && fn2 === SIN) { 
+                                                if(arg1.equals(arg2)) {
+                                                    if(fn1 === SIN && fn2 === COS || fn1 === COS && fn2 === SIN) {
                                                         if(sym1.power.lessThan(0))
                                                             __.integration.stop();//we don't know how to handle, sin(x)^n/cos(x)^m where m > n,  yet
                                                         //if it's in the form sin(x)^n*cos(x)^n then we can just return tan(x)^n which we know how to integrate
-                                                        if(fn1 === SIN && sym1.power.add(sym2.power).equals(0)) { 
+                                                        if(fn1 === SIN && sym1.power.add(sym2.power).equals(0)) {
                                                             sym1.fname = TAN;
                                                             sym1.updateHash();
                                                             retval = __.integrate(sym1, dx, depth);
@@ -1563,64 +1618,66 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                         else {
                                                             if(even(sym1.power) && fn2 === COS && sym2.power.lessThan(0)) {
                                                                 //transform sin^(2*n) to (1-cos^2)^n
-                                                                var n = Number(sym1.power)/2,
-                                                                    new_sym = _.parse(format('(1-cos({0})^2)^({1})', sym1.args[0], n));
+                                                                var n = Number(sym1.power) / 2,
+                                                                        new_sym = _.parse(format('(1-cos({0})^2)^({1})', sym1.args[0], n));
                                                                 retval = __.integrate(_.expand(_.multiply(new_sym, sym2.clone())), dx, depth, opt);
                                                             }
                                                             else if(even(sym1.power) && fn2 === SIN && sym2.power.lessThan(0)) {
                                                                 //transform cos^(2*n) to (1-sin^2)^n
-                                                                var n = Number(sym1.power)/2,
-                                                                    new_sym = _.parse(format('(1-sin({0})^2)^({1})', sym1.args[0], n));
+                                                                var n = Number(sym1.power) / 2,
+                                                                        new_sym = _.parse(format('(1-sin({0})^2)^({1})', sym1.args[0], n));
                                                                 retval = __.integrate(_.expand(_.multiply(new_sym, sym2.clone())), dx, depth, opt);
                                                             }
                                                             else {
                                                                 var p1_even = core.Utils.even(sym1.power),
-                                                                    p2_even = core.Utils.even(sym2.power);
+                                                                        p2_even = core.Utils.even(sym2.power);
                                                                 retval = new Symbol(0);
-                                                                if(!p1_even || !p2_even) { 
+                                                                if(!p1_even || !p2_even) {
                                                                     var u, r, trans;
                                                                     //since cos(x) is odd it carries du. If sin was odd then it would be the other way around
                                                                     //know that p1 satifies the odd portion in this case. If p2 did than it would contain r
                                                                     if(!p1_even) {
                                                                         //u = sin(x)
-                                                                        u = sym2; r = sym1; 
+                                                                        u = sym2;
+                                                                        r = sym1;
                                                                     }
                                                                     else {
-                                                                        u = sym1; r = sym2;
+                                                                        u = sym1;
+                                                                        r = sym2;
                                                                     }
                                                                     //get the sign of du. In this case r carries du as stated before and D(cos(x),x) = -sin(x)
                                                                     var sign = u.fname === COS ? -1 : 1,
-                                                                        n = r.power, 
-                                                                        //remove the du e.g. cos(x)^2*sin(x)^3 dx -> cos(x)^2*sin(x)^2*sin(x). We're left with two 
-                                                                        //even powers afterwards which can be transformed
-                                                                        k = (n - 1)/2, 
-                                                                        //make the transformation cos(x)^2 = 1 - sin(x)^2
-                                                                        trans = _.parse('(1-'+u.fname+core.Utils.inBrackets(arg1)+'^2)^'+k), 
-                                                                        sym = _.expand(_.multiply(new Symbol(sign), _.multiply(u.clone(), trans)));
+                                                                            n = r.power,
+                                                                            //remove the du e.g. cos(x)^2*sin(x)^3 dx -> cos(x)^2*sin(x)^2*sin(x). We're left with two 
+                                                                            //even powers afterwards which can be transformed
+                                                                            k = (n - 1) / 2,
+                                                                            //make the transformation cos(x)^2 = 1 - sin(x)^2
+                                                                            trans = _.parse('(1-' + u.fname + core.Utils.inBrackets(arg1) + '^2)^' + k),
+                                                                            sym = _.expand(_.multiply(new Symbol(sign), _.multiply(u.clone(), trans)));
                                                                     //we can now just loop through and integrate each since it's now just a polynomial with functions
-                                                                    sym.each(function(x) { 
+                                                                    sym.each(function (x) {
                                                                         retval = _.add(retval, __.integration.poly_integrate(x.clone()));
                                                                     });
                                                                 }
-                                                                else { 
+                                                                else {
                                                                     //performs double angle transformation
-                                                                    var double_angle = function(symbol) {
+                                                                    var double_angle = function (symbol) {
                                                                         var p = symbol.power,
-                                                                            k = p/2, e;
+                                                                                k = p / 2, e;
                                                                         if(symbol.fname === COS)
-                                                                            e = '((1/2)+(cos(2*('+symbol.args[0]+'))/2))^'+k;
+                                                                            e = '((1/2)+(cos(2*(' + symbol.args[0] + '))/2))^' + k;
                                                                         else
-                                                                            e = '((1/2)-(cos(2*('+symbol.args[0]+'))/2))^'+k;
+                                                                            e = '((1/2)-(cos(2*(' + symbol.args[0] + '))/2))^' + k;
 
                                                                         return _.parse(e);
                                                                     };
                                                                     //they're both even so transform both using double angle identities and we'll just
                                                                     //be able to integrate by the sum of integrals
                                                                     var a = double_angle(sym1),
-                                                                        b = double_angle(sym2),
-                                                                        t = _.multiply(a, b);
+                                                                            b = double_angle(sym2),
+                                                                            t = _.multiply(a, b);
                                                                     var sym = _.expand(t);
-                                                                    sym.each(function(x) {
+                                                                    sym.each(function (x) {
                                                                         retval = _.add(retval, __.integrate(x, dx, depth));
                                                                     });
                                                                     return _.multiply(retval, coeff);
@@ -1629,16 +1686,16 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                         }
                                                     }
                                                     //tan(x)*sec(x)^n 
-                                                    else if(fn1 === SEC && fn2 === TAN && x.isLinear() && sym2.isLinear()) { 
+                                                    else if(fn1 === SEC && fn2 === TAN && x.isLinear() && sym2.isLinear()) {
                                                         retval = _.parse(format('sec({0})^({1})/({1})', sym1.args[0], sym1.power));
                                                     }
-                                                    else if(fn1 === TAN && fn2 === SEC && x.isLinear()) { 
+                                                    else if(fn1 === TAN && fn2 === SEC && x.isLinear()) {
                                                         //remaining: tan(x)^3*sec(x)^6
                                                         if(sym1.isLinear() && sym2.isLinear()) {
                                                             retval = _.divide(_.symfunction(SEC, [arg1.clone()]), a);
                                                         }
                                                         else if(even(sym1.power)) {
-                                                            var p = Number(sym1.power)/2;
+                                                            var p = Number(sym1.power) / 2;
                                                             //transform tangent
                                                             var t = _.parse(format('(sec({0})^2-1)^({1})', sym1.args[0], p));
                                                             retval = __.integrate(_.expand(_.multiply(t, sym2)), dx, depth);
@@ -1661,14 +1718,14 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                         var t = _.multiply(sym1.fnTransform(), sym2);
                                                         retval = __.integrate(_.expand(t), dx, depth);
                                                     }
-                                                    else { 
+                                                    else {
                                                         var t = _.multiply(sym1.fnTransform(), sym2.fnTransform());
                                                         retval = __.integrate(_.expand(t), dx, depth);
                                                     }
                                                 }
                                                 //TODO: In progress
                                                 else if((fn1 === SIN || fn1 === COS) && (fn2 === SIN || fn2 === COS)) {
-                                                    
+
                                                     if(sym1.isLinear() && sym2.isLinear()) {
                                                         //if in the form cos(a*x)*sin(b*x)
                                                         if(sym1.args[0].isLinear() && sym2.args[0].isLinear()) {
@@ -1682,7 +1739,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                                 bx = sym1.args[0];
                                                                 ax = sym2.args[0];
                                                             }
-                                                            
+
                                                             //make the transformation
                                                             f = _.parse(format('(sin(({1})+({0}))+sin(({1})-({0})))/2', ax.toString(), bx.toString()));
 
@@ -1696,7 +1753,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                     }
                                                     else {
                                                         var transformed = new Symbol(1);
-                                                        symbols.map(function(sym) {
+                                                        symbols.map(function (sym) {
                                                             var s = sym.fnTransform();
                                                             transformed = _.multiply(transformed, s);
                                                         });
@@ -1715,9 +1772,9 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
 
                                             }
                                         }
-                                        else if(g1 === FN && g2 === S) { 
+                                        else if(g1 === FN && g2 === S) {
                                             var sym1_is_linear = sym1.isLinear();
-                                            if(sym1.fname === COS && sym1_is_linear && sym2.power.equals(-1)) 
+                                            if(sym1.fname === COS && sym1_is_linear && sym2.power.equals(-1))
                                                 retval = _.symfunction('Ci', [sym1.args[0]]);
                                             else if(sym1.fname === COS && sym2.power.equals(-1)) {
                                                 retval = __.integrate(_.multiply(sym1.fnTransform(), sym2.clone()), dx, depth);
@@ -1744,18 +1801,18 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             else if(sym1.fname === 'erf') {
                                                 if(sym2.power.equals(1)) {
                                                     var dc = __.integration.decompose_arg(sym1.args[0], dx),
-                                                        a_ = dc[0],
-                                                        x_ = dc[1],
-                                                        arg = sym1.args[0].toString();
+                                                            a_ = dc[0],
+                                                            x_ = dc[1],
+                                                            arg = sym1.args[0].toString();
                                                     retval = _.parse(format('(e^(-(({2}))^2)*(sqrt(pi)*e^((({2}))^2)*(2*({0})^2*({1})^2-3)*erf(({2}))+2*({0})*({1})-2))/(4*sqrt(pi)*({0})^2)', a_, x_, arg))
                                                 }
                                             }
-                                            else { 
+                                            else {
                                                 //since group S is guaranteed convergence we need not worry about tracking depth of integration
                                                 retval = __.integration.by_parts(symbol, dx, depth, opt);
                                             }
                                         }
-                                        else if(g1 === EX && g2 === S) { 
+                                        else if(g1 === EX && g2 === S) {
                                             var x = fn1 === LOG ? __.integration.decompose_arg(sym1.args[0], dx)[1] : null;
                                             if(sym1.isE() && (sym1.power.group === S || sym1.power.group === CB) && sym2.power.equals(-1)) {
                                                 retval = _.symfunction('Ei', [sym1.power.clone()]);
@@ -1778,7 +1835,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                 factor.power = new Frac(pc);
                                                 sym2 = _.divide(sym2, factor.clone()); //reduce the denominator
                                                 var t = new Symbol(0);
-                                                sym1.each(function(x) {
+                                                sym1.each(function (x) {
                                                     t = _.add(t, _.divide(x.clone(), factor.clone()));
                                                 });
                                                 t.multiplier = sym1.multiplier;
@@ -1789,31 +1846,31 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             }
                                             retval = __.integration.partial_fraction(symbol, dx, depth);
                                         }
-                                        else if(g1 === CP && g2 === S) {  
+                                        else if(g1 === CP && g2 === S) {
                                             var f = sym1.clone().toLinear(),
-                                                f_is_linear = core.Algebra.degree(f, _.parse(dx)).equals(1);
+                                                    f_is_linear = core.Algebra.degree(f, _.parse(dx)).equals(1);
                                             //handle cases x^(2*n)/sqrt(1-x^2)
-                                            if(sym1.power.equals(-1/2)) { 
+                                            if(sym1.power.equals(-1 / 2)) {
                                                 var decomp = __.integration.decompose_arg(sym1.clone().toLinear(), dx);
                                                 var a = decomp[0].negate(),
-                                                    x = decomp[1],
-                                                    b = decomp[3],
-                                                    p1 = Number(sym1.power),
-                                                    p2 = Number(sym2.power);
+                                                        x = decomp[1],
+                                                        b = decomp[3],
+                                                        p1 = Number(sym1.power),
+                                                        p2 = Number(sym2.power);
                                                 if(isInt(p2) && core.Utils.even(p2) && x.power.equals(2)) {
                                                     //if the substitution 
-                                                    var c = _.divide(_.multiply(_.pow(b.clone(), new Symbol(2)), 
-                                                        _.symfunction(SQRT, [_.divide(b.clone(), a.clone())])), 
-                                                        _.pow(a.clone(), new Symbol(2)));
+                                                    var c = _.divide(_.multiply(_.pow(b.clone(), new Symbol(2)),
+                                                            _.symfunction(SQRT, [_.divide(b.clone(), a.clone())])),
+                                                            _.pow(a.clone(), new Symbol(2)));
                                                     c = _.multiply(c, _.symfunction(SQRT, [b]).invert());
                                                     var dummy = _.parse('sin(u)');
                                                     dummy.power = dummy.power.multiply(sym2.power);
                                                     var integral = __.integrate(dummy, 'u', depth);
-                                                    var bksub = _.parse(ASIN+'('+SQRT+'('+a+'/'+b+')*'+dx+')');
+                                                    var bksub = _.parse(ASIN + '(' + SQRT + '(' + a + '/' + b + ')*' + dx + ')');
                                                     retval = _.multiply(c, integral.sub(new Symbol('u'), bksub));
-                                                }   
-                                                else if(p1 === -1/2) {
-                                                    var u_transform = function(f, u) {
+                                                }
+                                                else if(p1 === -1 / 2) {
+                                                    var u_transform = function (f, u) {
                                                         var integral = _.parse(__.integrate(f, dx, depth, opt).sub(dx, format(u, dx)));
                                                         if(!integral.hasIntegral())
                                                             return integral;
@@ -1822,58 +1879,58 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                         retval = u_transform(
                                                                 _.expand(_.expand(_.pow(_.multiply(sym1.invert(), sym2.invert()), new Symbol(2)))).invert(),
                                                                 'sqrt(1-1/({0})^2)'
-                                                        );
+                                                                );
                                                     }
                                                     else if(p2 === -2) {
                                                         //apply transformation to see if it matches asin(x)
                                                         retval = u_transform(
                                                                 _.sqrt(_.expand(_.divide(_.pow(symbol, new Symbol(2)).invert(), _.pow(new Symbol(dx), new Symbol(2))).negate())).invert(),
                                                                 'sqrt(1-1/({0})^2)'
-                                                        );
+                                                                );
                                                     }
                                                 }
                                             }
-                                            else if(sym1.power.equals(-1) && sym2.isLinear() && f_is_linear) { 
+                                            else if(sym1.power.equals(-1) && sym2.isLinear() && f_is_linear) {
                                                 retval = __.integration.partial_fraction(symbol, dx, depth);
                                             }
-                                            else if(!sym1.power.lessThan(0) && isInt(sym1.power)) { 
+                                            else if(!sym1.power.lessThan(0) && isInt(sym1.power)) {
                                                 //sum of integrals
                                                 var expanded = _.expand(sym1);
                                                 retval = new Symbol(0);
-                                                expanded.each(function(x) {
+                                                expanded.each(function (x) {
                                                     if(x.group === PL) {
-                                                        x.each(function(y) {
+                                                        x.each(function (y) {
                                                             retval = _.add(retval, __.integrate(_.multiply(sym2.clone(), y), dx, depth));
                                                         });
                                                     }
-                                                    else 
+                                                    else
                                                         retval = _.add(retval, __.integrate(_.multiply(sym2.clone(), x), dx, depth));
                                                 });
                                             }
-                                            else if(sym1.power.lessThan(-2)) { 
+                                            else if(sym1.power.lessThan(-2)) {
                                                 retval = __.integration.by_parts(symbol, dx, depth, opt);
                                             }
-                                            else if(sym1.power.lessThan(0) && sym2.power.greaterThan(1)) { 
+                                            else if(sym1.power.lessThan(0) && sym2.power.greaterThan(1)) {
                                                 var decomp = __.integration.decompose_arg(sym1.clone().toLinear(), dx),
-                                                    a = decomp[0].negate(),
-                                                    x = decomp[1],
-                                                    b = decomp[3],
-                                                    fn = sym1.clone().toLinear();
+                                                        a = decomp[0].negate(),
+                                                        x = decomp[1],
+                                                        b = decomp[3],
+                                                        fn = sym1.clone().toLinear();
 
-                                                if(x.group !== PL && x.isLinear()) { 
+                                                if(x.group !== PL && x.isLinear()) {
                                                     var p = Number(sym2.power),
-                                                        du = '_u_',
-                                                        u = new Symbol(du),
-                                                        //pull the integral with the subsitution
-                                                        U = _.expand(_.divide(_.pow(_.subtract(u.clone(), b.clone()), new Symbol(p)), u.clone())),
-                                                        scope = {};
+                                                            du = '_u_',
+                                                            u = new Symbol(du),
+                                                            //pull the integral with the subsitution
+                                                            U = _.expand(_.divide(_.pow(_.subtract(u.clone(), b.clone()), new Symbol(p)), u.clone())),
+                                                            scope = {};
 
                                                     //generate a scope for resubbing the symbol
                                                     scope[du] = fn;
                                                     var U2 = _.parse(U, scope);
                                                     retval = __.integrate(U2, dx, 0);
                                                 }
-                                                else if(sym2.power.greaterThan(x.power) || sym2.power.equals(x.power)) { 
+                                                else if(sym2.power.greaterThan(x.power) || sym2.power.equals(x.power)) {
 
                                                     //factor out coefficients
                                                     var factors = new core.Algebra.Classes.Factors();
@@ -1882,11 +1939,11 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                     //it assumed that the result will be of group CB
                                                     if(div.group !== CB) {
                                                         retval = new Symbol(0);
-                                                        div.each(function(t) {
+                                                        div.each(function (t) {
                                                             retval = _.add(retval, __.integrate(t, dx, depth));
                                                         });
                                                         //put back the factors
-                                                        factors.each(function(factor) {
+                                                        factors.each(function (factor) {
                                                             retval = _.divide(retval, factor);
                                                         });
 
@@ -1897,16 +1954,16 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                         retval = __.integration.by_parts(symbol, dx, depth, opt);
                                                     }
                                                 }
-                                                else 
+                                                else
                                                     retval = __.integration.partial_fraction(symbol, dx, depth);
                                             }
-                                            else { 
+                                            else {
                                                 //handle cases such as (1-x^2)^(n/2)*x^(m) where n is odd ___ cracking knuckles... This can get a little hairy 
-                                                if(sym1.power.den.equals(2)) { 
+                                                if(sym1.power.den.equals(2)) {
                                                     //assume the function is in the form (a^2-b*x^n)^(m/2)
                                                     var dc = __.integration.decompose_arg(sym1.clone().toLinear(), dx),
-                                                        //using the above definition
-                                                        a = dc[3], x = dc[1], b = dc[0], bx = dc[2];
+                                                            //using the above definition
+                                                            a = dc[3], x = dc[1], b = dc[0], bx = dc[2];
                                                     if(x.power.equals(2) && b.lessThan(0)) { //if n is even && b is negative
                                                         //make a equal 1 so we can do a trig sub
                                                         if(!a.equals(1)) { //divide a out of everything
@@ -1914,14 +1971,14 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                             coeff = _.multiply(coeff, _.pow(a, new Symbol(2)));
                                                         }
                                                         var u = dx;
-                                                        var c = _.divide(_.pow(b.clone().negate(), new Symbol(1/2)), _.pow(a, new Symbol(1/2))),
-                                                            du = _.symfunction(COS, [new Symbol(u)]),
-                                                            cosn = _.pow(_.symfunction(COS, [new Symbol(u)]), new Symbol(sym1.power.num)),
-                                                            X = _.pow(_.symfunction(SIN, [new Symbol(u)]), new Symbol(sym2.power)),
-                                                            val = _.multiply(_.multiply(cosn, du), X),
-                                                            integral = __.integrate(val, u, depth);
-                                                            //but remember that u = asin(sqrt(b)*a*x)
-                                                            retval = integral.sub(u, _.symfunction(ASIN, [_.multiply(new Symbol(dx), c)]));
+                                                        var c = _.divide(_.pow(b.clone().negate(), new Symbol(1 / 2)), _.pow(a, new Symbol(1 / 2))),
+                                                                du = _.symfunction(COS, [new Symbol(u)]),
+                                                                cosn = _.pow(_.symfunction(COS, [new Symbol(u)]), new Symbol(sym1.power.num)),
+                                                                X = _.pow(_.symfunction(SIN, [new Symbol(u)]), new Symbol(sym2.power)),
+                                                                val = _.multiply(_.multiply(cosn, du), X),
+                                                                integral = __.integrate(val, u, depth);
+                                                        //but remember that u = asin(sqrt(b)*a*x)
+                                                        retval = integral.sub(u, _.symfunction(ASIN, [_.multiply(new Symbol(dx), c)]));
                                                     }
                                                     else {
                                                         retval = __.integration.partial_fraction(symbol, dx, depth, opt);
@@ -1933,28 +1990,30 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             }
 
                                         }
-                                        else if(sym1.isComposite() && sym2.isComposite()) { 
+                                        else if(sym1.isComposite() && sym2.isComposite()) {
                                             //sum of integrals
                                             retval = new Symbol(0);
                                             if(sym1.power.greaterThan(0) && sym2.power.greaterThan(0)) {
                                                 //combine and pull the integral of each
                                                 var sym = _.expand(symbol);
-                                                sym.each(function(x) {
+                                                sym.each(function (x) {
                                                     retval = _.add(retval, __.integrate(x, dx, depth));
                                                 }, true);
                                             }
                                             else {
                                                 var p1 = Number(sym1.power),
-                                                    p2 = Number(sym2.power);
+                                                        p2 = Number(sym2.power);
                                                 if(p1 < 0 && p2 > 0) {
                                                     //swap
-                                                    var t = sym1; sym1 = sym2; sym2 = t;
+                                                    var t = sym1;
+                                                    sym1 = sym2;
+                                                    sym2 = t;
                                                 }
                                                 if(p1 === -1 && p2 === -1) {
                                                     retval = __.integration.partial_fraction(symbol, dx);
                                                 }
                                                 else {
-                                                    sym1.each(function(x) {
+                                                    sym1.each(function (x) {
                                                         var k = _.multiply(x, sym2.clone());
                                                         var integral = __.integrate(k, dx, depth);
                                                         retval = _.add(retval, integral);
@@ -1965,7 +2024,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         else if(g1 === CP && symbols[0].power.greaterThan(0)) {
                                             sym1 = _.expand(sym1);
                                             retval = new Symbol(0);
-                                            sym1.each(function(x) {
+                                            sym1.each(function (x) {
                                                 retval = _.add(retval, __.integrate(_.multiply(x, sym2.clone()), dx, depth));
                                             }, true);
                                         }
@@ -1975,12 +2034,14 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         }
                                         else if(g1 === FN && g2 === CP || g2 === FN && g1 === CP) {
                                             if(g2 === FN && g1 === CP) {
-                                                var t = sym1; sym1 = sym2; sym2 = t; //swap
+                                                var t = sym1;
+                                                sym1 = sym2;
+                                                sym2 = t; //swap
                                             }
                                             var du, sym2_clone, p, q, sa, sb;
                                             du = Symbol.unwrapSQRT(__.diff(sym1.clone(), dx), true);
                                             sym2_clone = Symbol.unwrapSQRT(sym2, true);
-                                            if(du.power.equals(sym2_clone.power)) { 
+                                            if(du.power.equals(sym2_clone.power)) {
                                                 p = new Symbol(sym2.power);
                                                 sa = du.clone().toLinear();
                                                 sb = sym2.clone().toLinear();
@@ -1994,58 +2055,58 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                                 retval = __.integration.by_parts(symbol, dx, depth, opt);
                                             }
                                         }
-                                        else { 
+                                        else {
                                             var syma = sym1.clone().toLinear();
                                             var symb = sym2.clone().toLinear();
-                                            if(g1 === EX && g2 === EX && sym1.power.contains(dx) && sym2.power.contains(dx) 
+                                            if(g1 === EX && g2 === EX && sym1.power.contains(dx) && sym2.power.contains(dx)
                                                     && !syma.contains(dx) && !symb.contains(dx)) {
                                                 retval = _.parse(format('(({0})^(({2})*({4}))*({1})^(({3})*({4})))/(log(({0})^({2}))+log(({1})^({3})))',
-                                                    syma.toString(),
-                                                    symb.toString(),
-                                                    sym1.power.multiplier.toString(),
-                                                    sym2.power.multiplier.toString(),
-                                                    dx
-                                                ));
+                                                        syma.toString(),
+                                                        symb.toString(),
+                                                        sym1.power.multiplier.toString(),
+                                                        sym2.power.multiplier.toString(),
+                                                        dx
+                                                        ));
                                             }
-                                            else 
+                                            else
                                                 retval = __.integration.by_parts(symbol, dx, depth, opt);
                                         }
                                     }
                                 }
-                                else if(l === 3 && (symbols[2].group === S && symbols[2].power.lessThan(2) || symbols[0].group === CP)) { 
+                                else if(l === 3 && (symbols[2].group === S && symbols[2].power.lessThan(2) || symbols[0].group === CP)) {
                                     var first = symbols[0];
                                     if(first.group === CP) { //TODO {support higher powers of x in the future}
                                         if(first.power.greaterThan(1))
                                             first = _.expand(first);
                                         var r = _.multiply(symbols[1], symbols[2]);
                                         retval = new Symbol(0);
-                                        first.each(function(x) {
+                                        first.each(function (x) {
                                             var t = _.multiply(x, r.clone());
                                             var intg = __.integrate(t, dx, depth);
                                             retval = _.add(retval, intg);
                                         }, true);
                                     }
-                                    else { 
+                                    else {
                                         //try integration by parts although technically it will never work
                                         retval = __.integration.by_parts(symbol, dx, depth, opt);
                                     }
 
                                 }
-                                else if(all_functions(symbols)) { 
+                                else if(all_functions(symbols)) {
                                     var t = new Symbol(1);
-                                    for(var i=0,l=symbols.length; i<l; i++) {
+                                    for(var i = 0, l = symbols.length; i < l; i++) {
                                         t = _.multiply(t, symbols[i].fnTransform());
                                     }
                                     t = _.expand(t);
                                     retval = __.integrate(t, dx, depth);
                                 }
-                                else { 
+                                else {
                                     //one more go
                                     var transformed = trigTransform(symbols);
                                     retval = __.integrate(_.expand(transformed), dx, depth);
                                 }
                             }
-                                
+
                         }
 
                         retval = _.multiply(retval, coeff);
@@ -2055,19 +2116,19 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                         return retval;
                 }
 
-                catch(error){
+                catch(error) {
                     //do nothing if it's a NoIntegralFound error otherwise let it bubble
-                    if(!(error instanceof NoIntegralFound || error instanceof core.exceptions.DivisionByZero)) 
+                    if(!(error instanceof NoIntegralFound || error instanceof core.exceptions.DivisionByZero))
                         throw error;
-                }  
+                }
 
                 //no symbol found so we return the integral again
                 return _.symfunction('integrate', [original_symbol, dt]);
             }, false);
         },
-        defint: function(symbol, from, to, dx) {
+        defint: function (symbol, from, to, dx) {
             dx = dx || 'x'; //make x the default variable of integration
-            var get_value = function(integral, vars, point) {
+            var get_value = function (integral, vars, point) {
                 try {
                     return _.parse(integral, vars);
                 }
@@ -2077,54 +2138,54 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     return lim;
                 }
             };
-            
+
             var vars = core.Utils.variables(symbol),
-                hasTrig = symbol.hasTrig();
+                    hasTrig = symbol.hasTrig();
             var retval, integral;
-            
+
             // Fix #593 - Only assume the first variable if dx is not defined.
             if(vars.length === 1 && !dx)
                 dx = vars[0];
-            
+
             if(!hasTrig) {
                 integral = __.integrate(symbol, dx);
             }
-            
-            if(!hasTrig && !integral.hasIntegral()) { 
+
+            if(!hasTrig && !integral.hasIntegral()) {
                 var upper = {},
-                    lower = {},
-                    a, b;
+                        lower = {},
+                        a, b;
                 upper[dx] = to;
                 lower[dx] = from;
-                
-                a = get_value(integral, upper, to, dx);  
+
+                a = get_value(integral, upper, to, dx);
                 b = get_value(integral, lower, from, dx);
                 retval = _.subtract(a, b);
             }
             else if(vars.length === 1 && from.isConstant() && to.isConstant()) {
-                
-                var f = core.Utils.build(symbol); 
-                    retval = new Symbol(core.Math2.num_integrate(f, Number(from), Number(to)));
+
+                var f = core.Utils.build(symbol);
+                retval = new Symbol(core.Math2.num_integrate(f, Number(from), Number(to)));
             }
-            else 
-                retval = _.symfunction('defint', [symbol, from , to, dx]);
+            else
+                retval = _.symfunction('defint', [symbol, from, to, dx]);
             return retval;
         },
-            
+
         Limit: {
-            interval: function(start, end) {
+            interval: function (start, end) {
                 return _.parse(format('[{0}, {1}]', start, end));
             },
-            diverges: function() {
+            diverges: function () {
                 return __.Limit.interval('-Infinity', 'Infinity');
             },
-            divide: function(f, g, x, lim, depth) { 
+            divide: function (f, g, x, lim, depth) {
                 if(depth++ > Settings.max_lim_depth) {
                     return;
                 }
 
                 var fin = f.clone(), gin = g.clone();
-                
+
                 //But first a little "cheating". x/|x| ends up in an infinite loop since the d/dx |x| -> x/|x|
                 //To break this loop we simply provide the answer. Keep in mind that currently limit only provides
                 //the two-sided limit.
@@ -2135,29 +2196,29 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
 
                     if(lim.isInfinity)
                         return _.multiply(new Symbol(sign), new Symbol(lim_sign));
-                    
+
                     else if(lim.equals(0)) {
                         var fm = _.parse(f.multiplier);
                         var gm = _.parse(g.multiplier);
-                        return _.divide(_.multiply(fm,__.Limit.interval('-1', '1')), gm);
+                        return _.divide(_.multiply(fm, __.Limit.interval('-1', '1')), gm);
                     }
                     else {
                         //TODO: Support more limits
                         __.Limit.diverges();
                     }
                 }
-                
-                var isInfinity = function(L) {
+
+                var isInfinity = function (L) {
                     if(core.Utils.isVector(L)) {
-                        for(var i=0; i<L.elements.length; i++)
+                        for(var i = 0; i < L.elements.length; i++)
                             if(!L.elements[i].isInfinity)
                                 return false;
                         return true;
                     }
-                    return L.isInfinity;     
+                    return L.isInfinity;
                 };
 
-                var equals = function(L, v) {
+                var equals = function (L, v) {
                     if(core.Utils.isVector(L)) {
                         return false;
                     }
@@ -2179,17 +2240,17 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                         var t_symbol = _.expand(_.divide(ft, gt));
                         f = t_symbol.getNum();
                         g = t_symbol.getDenom();
-                        
+
                     }
                 }
-                while(indeterminate)  
+                while(indeterminate)
 
                 //REMEMBER: 
                 //- 1/cos(x)
                 //n/0 is still possible since we only checked for 0/0
                 var den_is_zero = lim2.equals(0);
                 var p = Number(gin.power);
-                
+
                 if(lim.isConstant(true) && den_is_zero) {
                     retval = Symbol.infinity(core.Utils.even(p) && lim1.lessThan(0) ? -1 : undefined);
                 }
@@ -2199,15 +2260,15 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                 else {
                     retval = _.divide(lim1, lim2);
                 }
-                
+
                 return retval;
             },
-            rewriteToLog: function(symbol) {
+            rewriteToLog: function (symbol) {
                 var p = symbol.power.clone();
                 symbol.toLinear();
-                return _.pow(new Symbol('e'), _.multiply(p, _.symfunction(Settings.LOG+'', [symbol])));
+                return _.pow(new Symbol('e'), _.multiply(p, _.symfunction(Settings.LOG + '', [symbol])));
             },
-            getSubbed: function(f, x, lim) {
+            getSubbed: function (f, x, lim) {
                 var retval;
                 //1. rewrite EX with base e
                 if(f.group === EX) {
@@ -2221,45 +2282,46 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                     //Nope. No go, so just return the unsubbed function so we can test the limit instead.
                     retval = f;
                 }
-                
+
                 return retval;
             },
-            isInterval: function(limit) {
+            isInterval: function (limit) {
                 return core.Utils.isVector(limit);
             },
-            isConvergent: function(limit) {
+            isConvergent: function (limit) {
                 //it's not convergent if it lies on the interval -Infinity to Infinity
-                if(     
-                    //It lies on the interval -Infinity to Infinity
-                    __.Limit.isInterval(limit) && limit.elements[0].isInfinity && limit.elements[1].isInfinity ||
-                    //We weren't able to calculate the limit
-                    limit.containsFunction('limit')
-                ) {
+                if(
+                        //It lies on the interval -Infinity to Infinity
+                        __.Limit.isInterval(limit) && limit.elements[0].isInfinity && limit.elements[1].isInfinity ||
+                        //We weren't able to calculate the limit
+                        limit.containsFunction('limit')
+                        ) {
                     return false; //Then no
                 }
                 return true; //It is
             },
-            limit: function(symbol, x, lim, depth) {
+            limit: function (symbol, x, lim, depth) {
                 //Simplify the symbol
                 if(symbol.isLinear() && symbol.isComposite()) {
-                    
+
                     //Apply sum of limits
                     var limit = new Symbol(0);
-                    symbol.each(function(s) {
+                    symbol.each(function (s) {
                         limit = _.add(limit, __.Limit.limit(s, x, lim, depth));
                     }, true);
-                    
+
                     return limit;
-                };
-                
+                }
+                ;
+
                 symbol = core.Algebra.Simplify.simplify(symbol);
-                
+
                 depth = depth || 1;
-                
+
                 if(depth++ > Settings.max_lim_depth) {
                     return;
                 }
-                
+
                 //store the multiplier
                 var m = _.parse(symbol.multiplier);
                 //strip the multiplier
@@ -2276,18 +2338,20 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                         var point = {};
                         point[x] = lim;
                         //lim x as x->c = c where c
-                        
+
                         try {
-                            
+
                             //evaluate the function at the given limit
                             var t = _.parse(symbol.sub(x, lim), point);
 
                             //a constant or infinity is known so we're done
                             if(t.isConstant(true) || t.isInfinity)
                                 retval = t;
-                            
+
+                        }
+                        catch(e) { /*Nothing. Maybe we tried to divide by zero.*/
                         }
-                        catch(e){ /*Nothing. Maybe we tried to divide by zero.*/};
+                        ;
 
                         if(!retval) {
                             //split the symbol in the numerator and the denominator
@@ -2318,23 +2382,23 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         retval = _.pow(lim_base, lim_pow);
                                     }
                                 }
-                                else if(symbol.group === FN && symbol.args.length === 1 ) {
+                                else if(symbol.group === FN && symbol.args.length === 1) {
                                     var evaluates;
                                     //Squeeze theorem lim f(g(x)) = lim f(lim g))
                                     var arg = __.Limit.limit(symbol.args[0], x, lim, depth);
                                     if(core.Utils.isVector(arg)) {
                                         //get the limit over that interval
-                                        retval = arg.map(function(e) {
+                                        retval = arg.map(function (e) {
                                             var clone = symbol.clone();
                                             clone.args[0] = e;
                                             return __.Limit.limit(_.symfunction(symbol.fname, [e]), x, lim, depth);
                                         });
-                                        
+
                                         return _.multiply(m, retval);
                                     }
                                     //if the argument is constant then we're done
                                     else if(arg.isConstant(true)) {
-                                    
+
                                         //double check that it evaluates
                                         var trial = _.symfunction(symbol.fname, [arg]);
                                         //trial evaluation
@@ -2343,7 +2407,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             evaluates = true;
                                         }
                                         catch(e) {
-                                            
+
                                             evaluates = false;
                                         }
                                     }
@@ -2353,7 +2417,7 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                     else {
                                         //if the limit converges. We'll deal with non-convergent ones later
                                         if(__.Limit.isConvergent(arg)) {
-                                            if(symbol.fname === LOG) { 
+                                            if(symbol.fname === LOG) {
                                                 switch(arg.toString()) {
                                                     //lim -> 0
                                                     case '0':
@@ -2400,16 +2464,16 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         else {
                                             //odd ones don't
                                             retval = __.Limit.diverges();
-                                        }   
+                                        }
                                     }
                                 }
-                                else if(symbol.group === CB) { 
-                                    
+                                else if(symbol.group === CB) {
+
                                     var lim1, lim2;
                                     //loop through all the symbols
                                     //thus => lim f*g*h = lim (f*g)*h = (lim f*g)*(lim h)
                                     //symbols of lower groups are generally easier to differentiatee so get them to the right by first sorting
-                                    var symbols = symbol.collectSymbols().sort(function(a, b) {
+                                    var symbols = symbol.collectSymbols().sort(function (a, b) {
                                         return a.group - b.group;
                                     });
 
@@ -2423,16 +2487,16 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         var g = symbols.pop();
                                         //get the limit of g
                                         lim2 = evaluate(__.Limit.limit(g, x, lim, depth));
-                                        
+
                                         //if the limit is in indeterminate form aplly L'Hospital by inverting g and then f/(1/g)
-                                        if((lim1.isInfinity || !__.Limit.isConvergent(lim1) && lim2.equals(0) || lim1.equals(0) && __.Limit.isConvergent(lim2))) { 
+                                        if((lim1.isInfinity || !__.Limit.isConvergent(lim1) && lim2.equals(0) || lim1.equals(0) && __.Limit.isConvergent(lim2))) {
                                             if(g.containsFunction(LOG)) {
                                                 //swap them
                                                 g = [f, f = g][0];
                                             }
                                             //invert the symbol
                                             g.invert();
-                                            
+
                                             // Product of infinities
                                             if(lim1.isInfinity && lim2.isInfinity) {
                                                 lim1 = Symbol.infinity()
@@ -2452,21 +2516,21 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                     //Done, lim1 is the limit we're looking for     
                                     retval = lim1;
                                 }
-                                else if(symbol.isComposite()) { 
+                                else if(symbol.isComposite()) {
                                     var _lim;
                                     if(!symbol.isLinear())
                                         symbol = _.expand(symbol);
                                     //Apply lim f+g = (lim f)+(lim g)
                                     retval = new Symbol(0);
-                                    
-                                    var symbols = symbol.collectSymbols().sort(function(a, b) {
+
+                                    var symbols = symbol.collectSymbols().sort(function (a, b) {
                                         return b.group - a.group;
                                     });
 
                                     var _symbols = [];
                                     //Analyze the functions first
                                     var fns = new Symbol(0);
-                                    for(var i=0, l=symbols.length; i<l; i++) {
+                                    for(var i = 0, l = symbols.length; i < l; i++) {
                                         var sym = symbols[i].clone();
                                         if(sym.group === FN || sym.group === CB && sym.hasFunc()) {
                                             fns = _.add(fns, sym);
@@ -2475,13 +2539,13 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                             _symbols.push(sym);
                                     }
                                     _symbols.unshift(fns);
-                                    
+
                                     //make sure that we didn't just repackage the exact same symbol
                                     if(_symbols.length !== 1) {
                                         symbols = _symbols;
                                     }
-                                    
-                                    for(var i=0, l=symbols.length; i<l; i++) {
+
+                                    for(var i = 0, l = symbols.length; i < l; i++) {
                                         var sym = symbols[i];
                                         //If the addition of the limits is undefined then the limit diverges so return -infinity to infinity
                                         try {
@@ -2490,46 +2554,47 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                         catch(e) {
                                             _lim = __.Limit.diverges();
                                         }
-                                        
+
                                         try {
                                             retval = _.add(retval, _lim);
                                         }
                                         catch(e) {
                                             if(depth++ > Settings.max_lim_depth) {
                                                 return;
-                                            };
+                                            }
+                                            ;
                                             retval = __.Limit.limit(__.diff(symbol, x), x, lim, depth);
                                         }
                                     }
-                                } 
+                                }
                             }
                             else {
                                 retval = __.Limit.divide(num, den, x, lim, depth);
-                            }    
+                            }
                         }
                     }
 
                     //if we still don't have a solution
                     if(!retval)
                         //return it symbolically
-                        retval = _.symfunction('limit', [symbol, x, lim]); 
+                        retval = _.symfunction('limit', [symbol, x, lim]);
                 }
                 catch(e) {
                     //if all else fails return the symbolic function
-                    retval = _.symfunction('limit', [symbol, x, lim]); 
+                    retval = _.symfunction('limit', [symbol, x, lim]);
                 }
-                
+
                 return _.multiply(m, retval);
             }
         },
         Fresnel: {
-            S: function(x) {
+            S: function (x) {
                 if(x.isConstant(true)) {
                     return __.defint(_.parse('sin(pi*x^2/2)'), Symbol(0), x, 'x');
                 }
                 return _.symfunction('S', arguments);
             },
-            C: function(x) {
+            C: function (x) {
                 if(x.isConstant(true)) {
                     return __.defint(_.parse('cos(pi*x^2/2)'), Symbol(0), x, 'x');
                 }
@@ -2537,58 +2602,74 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
             }
         }
     };
-    
+
     nerdamer.register([
         {
             name: 'diff',
             visible: true,
-            numargs: [1,3],
-            build: function(){ return __.diff; }
+            numargs: [1, 3],
+            build: function () {
+                return __.diff;
+            }
         },
         {
             name: 'sum',
             visible: true,
             numargs: 4,
-            build: function(){ return __.sum; }
+            build: function () {
+                return __.sum;
+            }
         },
         {
             name: 'product',
             visible: true,
             numargs: 4,
-            build: function(){ return __.product; }
+            build: function () {
+                return __.product;
+            }
         },
         {
             name: 'integrate',
             visible: true,
             numargs: [1, 2],
-            build: function() { return __.integrate; }
+            build: function () {
+                return __.integrate;
+            }
         },
         {
             name: 'defint',
             visible: true,
             numargs: [3, 4],
-            build: function() { return __.defint; }
+            build: function () {
+                return __.defint;
+            }
         },
         {
             name: 'S',
             visible: true,
             numargs: 1,
-            build: function() { return __.Fresnel.S; }
+            build: function () {
+                return __.Fresnel.S;
+            }
         },
         {
             name: 'C',
             visible: true,
             numargs: 1,
-            build: function() { return __.Fresnel.C; }
+            build: function () {
+                return __.Fresnel.C;
+            }
         },
         {
             name: 'limit',
             visible: true,
             numargs: [3, 4],
-            build: function() { return __.Limit.limit; }
+            build: function () {
+                return __.Limit.limit;
+            }
         }
     ]);
     //link registered functions externally
-    nerdamer.api();
-   
-})();
+    nerdamer.updateAPI();
+
+})();