Calculus.js

/* global module */

/*
 * 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 () {
    "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';

    //custom errors
    function NoIntegralFound(msg) {
        this.message = msg || "";
    }
    NoIntegralFound.prototype = new Error();

    //Preparations
    Symbol.prototype.hasIntegral = function () {
        return this.containsFunction('integrate');
    };
    //transforms a function
    Symbol.prototype.fnTransform = function () {
        if(this.group !== FN)
            return this;
        var retval, a = this.args[0];
        var m = new Symbol(this.multiplier);
        var sym = this.clone().toUnitMultiplier();
        if(this.isLinear()) {
            switch(this.fname) {
                case SINH:
                    retval = _.parse(format('(e^({0})-e^(-({0})))/2', a));
                    break;
                case COSH:
                    retval = _.parse(format('(e^({0})+e^(-({0})))/2', a));
                    break;
                case TANH:
                    retval = _.parse(format('(e^({0})-e^(-({0})))/(e^({0})+e^(-({0})))', a));
                    break;
                case TAN:
                    retval = _.parse(format('sin({0})/cos({0})', a));
                    break;
                case CSC:
                    retval = _.parse(format('1/sin({0})', a));
                    break;
                case SEC:
                    retval = _.parse(format('1/cos({0})', a));
                    break;
                default:
                    retval = sym;
            }
        }
        else if(this.power.equals(2)) {
            switch(this.fname) {
                case SIN:
                    retval = _.parse(format('1/2-cos(2*({0}))/2', a));
                    break;
                case COS:
                    retval = _.parse(format('1/2+cos(2*({0}))/2', a));
                    break;
                case TAN:
                    //retval = _.parse(format('(1-cos(2*({0})))/(1+cos(2*({0})))', a));
                    retval = _.parse(format('sin({0})^2/cos({0})^2', a));
                    break;
                case COSH:
                    retval = _.parse(format('1/2+cosh(2*({0}))/2', a));
                    break;
                case SINH:
                    retval = _.parse(format('-1/2+cosh(2*({0}))/2', a));
                    break;
                case TANH:
                    retval = _.parse(format('(1+cosh(2*({0})))/(-1+cosh(2*({0})))', a));
                    break;
                case SEC:
                    retval = _.parse(format('(1-cos(2*({0})))/(1+cos(2*({0})))+1', a));
                    break;
                default:
                    retval = sym;
            }
        }
        else if(this.fname === SEC) {
            retval = _.parse(format('1/cos({0})^({1})', this.args[0], this.power));
        }
        else if(this.fname === CSC) {
            retval = _.parse(format('1/sin({0})^({1})', this.args[0], this.power));
        }
        else if(this.fname === TAN) {
            if(this.power.lessThan(0)) {
                retval = _.parse(format('cos({0})^(-({1}))/sin({0})^({1})', this.args[0], this.power.negate()));
            }
            else {
                retval = _.parse(format('sin({0})^({1})/cos({0})^({1})', this.args[0], this.power));
            }
        }
        else if(this.fname === SIN && this.power.lessThan(0)) {
            retval = _.parse(format('csc({0})^(-({1}))', this.args[0], this.power.negate()));
        }
        else if(this.fname === COS && this.power.lessThan(0)) {
            retval = _.parse(format('sec({0})^(-({1}))', this.args[0], this.power.negate()));
        }
        else if(this.fname === SIN && this.power.equals(3)) {
            retval = _.parse(format('(3*sin({0})-sin(3*({0})))/4', this.args[0]));
        }
        else if(this.fname === COS && this.power.equals(3)) {
            retval = _.parse(format('(cos(3*({0}))+3*cos({0}))/4', this.args[0]));
        }
        //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;
            //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) {
                var t = s.fnTransform();
                retval = _.add(retval, t);
            }, true);
        }
        else
            retval = sym;

        return _.multiply(retval, m);
    };

    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)))
            return true;
        if(this.symbols) {
            for(var x in this.symbols)
                if(this.symbols[x].hasTrig())
                    return true;
        }
        return false;
    };

    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) {
        //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) {
                denominator = _.multiply(denominator, x.getDenom());
            }, true);

            //remove the denomitor in each term
            symbol.each(function (x) {
                var num = x.getNum();
                var den = x.getDenom();
                var factor = _.multiply(num, _.divide(denominator.clone(), den));
                numerator = _.add(numerator, factor);
            });
            var retval = _.multiply(m, core.Algebra.divide(_.expand(numerator), _.expand(denominator)));
            return retval;
        }
        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];
        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) {
        var trig_fns = [COS, SIN, TAN, SEC, CSC, COT];
        return trig_fns.indexOf(x) !== -1;
    };

    core.Utils.in_htrig = function (x) {
        var trig_fns = [SINH, COSH, TANH, ACSCH, ASECH, ACOTH];
        return trig_fns.indexOf(x) !== -1;
    };

    // 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];
                            }

                            retval = t;
                        }
                        else {
                            map[fname] = symbol;
                        }
                    }
                    else
                        retval = _.multiply(retval, symbol);
                }

                //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');
            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 () {
                    var f = fn.text(),
                            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);
                        var ans = _.parse(f, subs);
                        retval = _.add(retval, ans);
                    }
                    return retval;
                });
            }
            else {
                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');
            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 () {
                    start = Number(start);
                    end = Number(end.multiplier);

                    var f = fn.text(),
                            subs = {},
                            retval = new core.Symbol(1);

                    for(var i = start; i <= end; i++) {
                        subs[index] = new Symbol(i);
                        retval = _.multiply(retval, _.parse(f, subs));
                    }
                    return retval;
                });
            }
            else {
                retval = _.symfunction('product', arguments);
            }

            return retval;
        },
        diff: function (symbol, wrt, nth) {
            if(core.Utils.isVector(symbol)) {
                var vector = new core.Vector([]);
                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) {
                    matrix.set(i, j, __.diff(x, wrt, nth));
                });
                return matrix;
            }

            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];

            //unwrap sqrt
            if(symbol.group === FN && symbol.fname === SQRT) {
                var s = symbol.args[0],
                        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.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);
                symbol = _.multiply(a, b);//chain rule
            }
            else {
                symbol = derive(symbol);
            }

            if(nth > 1) {
                nth--;
                symbol = __.diff(symbol, wrt, nth);
            }

            return symbol;

            // Equivalent to "derivative of the outside".
            function polydiff(symbol) {
                if(symbol.value === d || symbol.contains(d, true)) {
                    symbol.multiplier = symbol.multiplier.multiply(symbol.power);
                    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;

                if(g === N || g === S && symbol.value !== d || g === P) {
                    symbol = Symbol(0);
                }
                else if(g === S) {
                    symbol = polydiff(symbol);
                }
                else if(g === CB) {
                    var m = symbol.multiplier.clone();
                    symbol.toUnitMultiplier();
                    var retval = _.multiply(product_rule(symbol), polydiff(symbol));
                    retval.multiplier = retval.multiplier.multiply(m);
                    return retval;
                }
                else if(g === FN && symbol.power.equals(1)) {
                    // Table of known derivatives
                    switch(symbol.fname) {
                        case LOG:
                            cp = symbol.clone();
                            symbol = symbol.args[0].clone();//get the arguments
                            symbol.power = symbol.power.negate();
                            symbol.multiplier = cp.multiplier.divide(symbol.multiplier);
                            break;
                        case COS:
                            //cos -> -sin
                            symbol.fname = SIN;
                            symbol.multiplier.negate();
                            break;
                        case SIN:
                            //sin -> cos
                            symbol.fname = COS;
                            break;
                        case TAN:
                            //tan -> sec^2
                            symbol.fname = SEC;
                            symbol.power = new Frac(2);
                            break;
                        case SEC:
                            // Use a clone if this gives errors
                            symbol = qdiff(symbol, TAN);
                            break;
                        case CSC:
                            symbol = qdiff(symbol, '-cot');
                            break;
                        case COT:
                            symbol.fname = CSC;
                            symbol.multiplier.negate();
                            symbol.power = new Frac(2);
                            break;
                        case ASIN:
                            symbol = _.parse('(sqrt(1-(' + text(symbol.args[0]) + ')^2))^(-1)');
                            break;
                        case ACOS:
                            symbol = _.parse('-(sqrt(1-(' + text(symbol.args[0]) + ')^2))^(-1)');
                            break;
                        case ATAN:
                            symbol = _.parse('(1+(' + text(symbol.args[0]) + ')^2)^(-1)');
                            break;
                        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.multiplier = m;
                            break;
                        case 'parens':
                            //see product rule: f'.g goes to zero since f' will return zero. This way we only get back
                            //1*g'
                            symbol = Symbol(1);
                            break;
                        case 'cosh':
                            //cosh -> -sinh
                            symbol.fname = 'sinh';
                            break;
                        case 'sinh':
                            //sinh -> cosh
                            symbol.fname = 'cosh';
                            break;
                        case TANH:
                            //tanh -> sech^2
                            symbol.fname = SECH;
                            symbol.power = new Frac(2);
                            break;
                        case SECH:
                            // Use a clone if this gives errors
                            symbol = qdiff(symbol, '-tanh');
                            break;
                        case CSCH:
                            var arg = String(symbol.args[0]);
                            return _.parse('-coth(' + arg + ')*csch(' + arg + ')');
                            break;
                        case COTH:
                            var arg = String(symbol.args[0]);
                            return _.parse('-csch(' + arg + ')^2');
                            break;
                        case 'asinh':
                            symbol = _.parse('(sqrt(1+(' + text(symbol.args[0]) + ')^2))^(-1)');
                            break;
                        case 'acosh':
                            symbol = _.parse('(sqrt(-1+(' + text(symbol.args[0]) + ')^2))^(-1)');
                            break;
                        case 'atanh':
                            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)');
                            break;
                        case ACOTH:
                            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)');
                            break;
                        case ASEC:
                            var arg = String(symbol.args[0]);
                            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)');
                            break;
                        case ACOT:
                            symbol = _.parse('-1/((' + symbol.args[0] + ')^2+1)');
                            break;
                        case 'S':
                            var arg = String(symbol.args[0]);
                            symbol = _.parse('sin((pi*(' + arg + ')^2)/2)');
                            break;
                        case 'C':
                            var arg = String(symbol.args[0]);
                            symbol = _.parse('cos((pi*(' + arg + ')^2)/2)');
                            break;
                        case 'Si':
                            var arg = symbol.args[0];
                            symbol = _.parse('sin(' + arg + ')/(' + arg + ')');
                            break;
                        case 'Shi':
                            var arg = symbol.args[0];
                            symbol = _.parse('sinh(' + arg + ')/(' + arg + ')');
                            break;
                        case 'Ci':
                            var arg = symbol.args[0];
                            symbol = _.parse('cos(' + arg + ')/(' + arg + ')');
                            break;
                        case 'Chi':
                            var arg = symbol.args[0];
                            symbol = _.parse('cosh(' + arg + ')/(' + arg + ')');
                            break;
                        case 'Ei':
                            var arg = symbol.args[0];
                            symbol = _.parse('e^(' + arg + ')/(' + arg + ')');
                            break;
                        case 'Li':
                            var arg = symbol.args[0];
                            symbol = _.parse('1/' + Settings.LOG + '(' + arg + ')');
                            break;
                        case 'erf':
                            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)');
                            break;
                        case 'sign':
                            symbol = new Symbol(0);
                            break;
                        case 'sinc':
                            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))');
                            break;
                        default:
                            symbol = _.symfunction('diff', [symbol, wrt]);
                    }
                }
                else if(g === EX || g === FN && isSymbol(symbol.power)) {
                    var value;
                    if(g === EX) {
                        value = symbol.value;
                    }
                    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);
                    symbol = _.multiply(symbol, b);
                }
                else if(g === FN && !symbol.power.equals(1)) {
                    b = symbol.clone();
                    b.toLinear();
                    b.toUnitMultiplier();
                    symbol = _.multiply(polydiff(symbol.clone()), derive(b));
                }
                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));
                    }
                    symbol = _.multiply(polydiff(c), result);
                }

                symbol.updateHash();

                return symbol;
            }
            ;

            function qdiff(symbol, val, altVal) {
                return _.multiply(symbol, _.parse(val + inBrackets(altVal || text(symbol.args[0]))));
            }
            ;

            function product_rule(symbol) {
                //grab all the symbols within the CB symbol
                var symbols = symbol.collectSymbols(),
                        result = new Symbol(0),
                        l = symbols.length;
                //loop over all the symbols
                for(var i = 0; i < l; i++) {
                    var df = __.diff(symbols[i].clone(), d);
                    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
                            df = _.multiply(df, symbols[j].clone());
                        }
                    }
                    //add the derivative to the result
                    result = _.add(result, df);
                }
                return result; //done
            }
            ;
        },
        integration: {
            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))
                        return q;
                    return null;
                }
                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();
                    return subbed;
                }

                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;
                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)
                        return _.multiply(Q, do_fn_sub(a.fname, arg));
                    Q = try_combo(b, a);
                    if(Q) {
                        return __.integration.poly_integrate(a);
                    }
                }
                else if(g2 === FN && g1 !== FN) {
                    //e.g. 2*(x+1)*cos((x+1)^2
                    var arg = b.args[0];
                    Q = try_combo(a, arg.clone());
                    if(Q)
                        return _.multiply(Q, do_fn_sub(b.fname, arg));
                }
                else if(g1 === FN && g2 === FN) {
                    Q = try_combo(a.clone(), b.clone());
                    if(Q)
                        return _.multiply(__.integration.poly_integrate(b), Q);
                    Q = try_combo(b.clone(), a.clone());
                    if(Q)
                        return _.multiply(__.integration.poly_integrate(b), Q);
                }
                else if(g1 === EX && g2 !== EX) {
                    var p = a.power;
                    Q = try_combo(b, p.clone());
                    if(!Q) {
                        //one more try
                        var dc = __.integration.decompose_arg(p.clone(), dx);
                        //consider the possibility of a^x^(n-1)*x^n dx
                        var xp = __.diff(dc[2].clone(), dx);
                        var dc2 = __.integration.decompose_arg(xp.clone(), dx);
                        //if their powers equal, so if dx*p == b
                        if(_.multiply(dc[1], dc2[1]).power.equals(b.power)) {
                            var m = _.divide(dc[0].clone(), dc2[0].clone());

                            var new_val = _.multiply(m.clone(), _.pow(new Symbol(a.value), _.multiply(dc[0], new Symbol(u))));
                            new_val = _.multiply(new_val, new Symbol(u));
                            return __.integration.by_parts(new_val, u, 0, {}).sub(u, dc[1].clone());
                        }

                    }
                    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) {
                    var p = b.power;
                    Q = try_combo(a, p.clone());
                    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) {
                        var d = __.diff(b, dx);
                        var A = core.Algebra.Factor.factor(a),
                                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)
                        return _.multiply(__.integration.poly_integrate(b), Q);
                    Q = try_combo(f2.clone(), f1.clone(), f);
                    if(Q)
                        return _.multiply(__.integration.poly_integrate(a), Q);
                }
            },
            //simple integration of a single polynomial x^(n+1)/(n+1)
            poly_integrate: function (x) {
                var p = x.power.toString(),
                        m = x.multiplier.toDecimal(),
                        s = x.toUnitMultiplier().toLinear();
                if(Number(p) === -1) {
                    return _.multiply(new Symbol(m), _.symfunction(LOG, [s]));
                }
                return _.parse(format('({0})*({1})^(({2})+1)/(({2})+1)', m, s, p));
            },
            //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) {
                msg = msg || 'Unable to compute integral!';
                core.Utils.warn(msg);
                throw new NoIntegralFound(msg);
            },
            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) {
                        if(!x.isLinear())
                            __.integration.stop();
                    });
                    partial_fractions.each(function (x) {
                        result = _.add(result, __.integrate(x, dx, depth, opt));
                    });
                }
                else {
                    result = _.add(result, __.integrate(partial_fractions, dx, depth, opt));
                }
                return result;
            },
            get_udv: function (symbol) {
                var parts = [[/*L*/], [/*I*/], [/*A*/], [/*T*/], [/*E*/]];
                //first we sort them 
                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))
                            parts[3].push(x);
                        else if(core.Utils.in_inverse_trig(fname))
                            parts[1].push(x);
                        else if(fname === LOG)
                            parts[0].push(x);
                        else {
                            __.integration.stop();
                        }
                    }
                    else if(g === S || x.isComposite() && x.isLinear() || g === CB && x.isLinear()) {
                        parts[2].push(x);
                    }
                    else if(g === EX || x.isComposite() && !x.isLinear())
                        parts[4].push(x);
                    else
                        __.integration.stop();
                };

                if(symbol.group === CB)
                    symbol.each(function (x) {
                        setSymbol(Symbol.unwrapSQRT(x, true));
                    });
                else
                    setSymbol(symbol);
                var u, dv = new Symbol(1);
                //compile u and dv
                for(var i = 0; i < 5; i++) {
                    var part = parts[i], t,
                            l = part.length;
                    if(l > 0) {
                        if(l > 1) {
                            t = new Symbol(1);
                            for(var j = 0; j < l; j++)
                                t = _.multiply(t, part[j].clone());
                        }
                        else
                            t = part[0].clone();

                        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
                    }
                }

                return [u, dv];
            },

            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];
                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);
                    var integral = __.integrate(f, t, depth, opt).sub(u, x);
                    core.Utils.clearU(u);
                    return integral;
                }
            },

            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);
                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);
                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()) {
                    //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
                    o.is_cyclic = true;
                    //return the integral. 
                    return new Symbol(1);
                }
                else
                    o.previous.push(vdu_s);

                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.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) {
                    //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) {
                            if(!x.contains(dx))
                                rem = _.add(rem, x.clone());
                        });
                        //get the actual uv
                        retval = _.divide(_.subtract(retval, rem.clone()), _.subtract(new Symbol(1), rem));
                    }
                }

                return retval;
            },
            /*
             * dependents: [Solve, integrate]
             */
            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) {
            //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];
                //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) {
                    vector.elements.push(__.integrate(x, dt));
                });
                return vector;
            }
            if(!isNaN(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 () {
                //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;

                try {
                    //We stop integration after x amount of recursive calls
                    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)) {
                        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) {
                        if(symbol.previousGroup === FN && !(symbol.fname === 'sqrt' || symbol.fname === Settings.PARENTHESIS))
                            __.integration.stop();
                        //check the base
                        if(symbol.contains(dx) && symbol.previousGroup !== FN) {
                            //if the symbol also contains dx then we stop since we currently 
                            //don't know what to do with it e.g. x^x
                            if(symbol.power.contains(dx))
                                __.integration.stop();
                            else {
                                var t = __.diff(symbol.clone().toLinear(), dx);
                                if(t.contains(dx))
                                    __.integration.stop();
                                //since at this point it's the base only then we do standard single poly integration
                                //e.g. x^y
                                retval = __.integration.poly_integrate(symbol, dx, depth);
                            }
                        }
                        //e.g. a^x or 9^x
                        else {
                            var a = __.diff(symbol.power.clone(), dx);
                            if(a.contains(dx)) {
                                var aa = a.stripVar(dx),
                                        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));
                                }
                                else
                                    __.integration.stop();
                            }
                            if(symbol.isE()) {
                                if(a.isLinear())
                                    retval = symbol;
                                else {
                                    if(a.isE() && a.power.group === S && a.power.power.equals(1))
                                        retval = _.multiply(_.symfunction('Ei', [symbol.power.clone()]), symbol.power);
                                    else
                                        __.integration.stop();
                                }
                            }
                            else {
                                var d = _.symfunction(LOG, [_.parse(symbol.value)]);
                                retval = _.divide(symbol, d);
                            }
                            retval = _.divide(retval, a);
                        }
                    }
                    else if(symbol.isComposite() && symbol.isLinear()) {
                        var m = _.parse(symbol.multiplier);
                        symbol.toUnitMultiplier();
                        retval = new Symbol(0);
                        symbol.each(function (x) {
                            retval = _.add(retval, __.integrate(x, dx, depth));
                        });
                        retval = _.multiply(m, retval);
                    }
                    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) {
                                retval = _.add(retval, __.integrate(x, dx, depth));
                            }, true);
                        }
                        else {
                            var p = Number(symbol.power),
                                    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)) {
                                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) {
                                    ////then we have atan
                                    //abs is redundants since the sign appears in both denom and num.
                                    var unwrapAbs = function (s) {
                                        var result = new Symbol(1);
                                        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));
                                    //unwrap abs

                                    var d = _.multiply(unwrapAbs(B), unwrapAbs(A)),
                                            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 {
                                    //1/(x^4+1)
                                    if(x.power.equals(4)) {
                                        //https://www.freemathhelp.com/forum/threads/55678-difficult-integration-int-1-(1-x-4)-dx
                                        var A, B, C, D, E, F, f1, f2, f3, f4, L1, L2;
                                        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));
                                        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);
                                        //let F = 2b√2∜b
                                        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)
                                                );
                                    }
                                    else
                                        //let's try partial fractions
                                        retval = __.integration.partial_fraction(symbol, dx, depth);
                                }
                            }
                            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)) {
                                        a.negate();
                                        //it's asin
                                        if(b.isConstant() && a.isConstant()) {
                                            var d = _.symfunction(SQRT, [a.clone()]),
                                                    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());
                                            retval = _.divide(_.symfunction(ATAN, [_.divide(sqrt_ax, _.symfunction(SQRT, [fn.clone()]))]), sqrt_a);
                                        }
                                    }
                                    else {
                                        /*WHAT HAPPENS HERE???? e.g. integrate(3/sqrt(-a+b*x^2),x) or integrate(3/sqrt(a+b*x^2),x)*/
                                        __.integration.stop();
                                    }
                                }
                                else {
                                    //This would be a case like 1/(sqrt(1-x^3) or 1/(1-(x+1)^2)
                                    __.integration.stop();
                                }
                            }
                            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)) {
                                    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));
                                    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));
                                    //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;
                                    //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));
                                    core.Utils.clearU(uv);
                                    return _.multiply(integral.sub(uv, v), bsqi);
                                }
                                else {
                                    if(symbol.group !== CB && !symbol.power.lessThan(0)) {
                                        retval = __.integration.by_parts(symbol, dx, depth, opt);
                                    }
                                    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) {
                                            try {
                                                var f1, fx, u, sq;
                                                sq = core.Algebra.sqComplete(f, dx);
                                                u = core.Utils.getU(f);
                                                f1 = sq.f.sub(sq.a, u);
                                                fx = _.pow(f1, _.parse(symbol.power));
                                                retval = __.integrate(fx, u).sub(u, sq.a);
                                            }
                                            catch(e) {
                                                __.integration.stop();
                                            }
                                        }
                                        else
                                            retval = __.integration.partial_fraction(symbol, dx, depth, opt);
                                    }
                                }
                            }
                            retval.multiplier = retval.multiplier.multiply(m);
                        }
                    }
                    else if(g === FN) {
                        var arg = symbol.args[0],
                                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;
                        //log is a special case that can be handled with integration by parts
                        if(fname === LOG || (fname === ASIN || fname === ACOS || fname === ATAN && x.isLinear())) {
                            /*integration by parts */
                            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));
                            else {
                                //integral u du
                                var u = core.Utils.getU(symbol);
                                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));
                            }

                        }
                        else if(fname === TAN && symbol.power.lessThan(0)) {
                            //convert to cotangent
                            var sym = symbol.clone();
                            sym.power.negate();
                            sym.fname = COT;
                            return _.multiply(_.parse(m), __.integrate(sym, dx, depth));
                        }
                        else {
                            if(!a.contains(dx, true) && symbol.isLinear()) { //perform a deep search for safety
                                //first handle the special cases 
                                if(fname === ABS) {
                                    //REVISIT **TODO**
                                    var x = _.divide(arg.clone(), a.clone());
                                    if(x.group === S && !x.power.lessThan(0)) {
                                        if(core.Utils.even(x.power)) {
                                            retval = __.integrate(arg, dx, depth);
                                        }
                                        else {
                                            var integrated = __.integrate(x, dx, depth);
                                            integrated.power = integrated.power.subtract(new Frac(1));
                                            retval = _.multiply(_.multiply(_.symfunction(ABS, [x.toLinear()]), integrated), a);
                                        }
                                    }
                                    else
                                        __.integration.stop();
                                }
                                else {
                                    var ag = symbol.args[0].group,
                                            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
                                    switch(fname) {
                                        case COS:
                                            retval = _.symfunction(SIN, [arg]);
                                            break;
                                        case SIN:
                                            retval = _.symfunction(COS, [arg]);
                                            retval.negate();
                                            break;
                                        case TAN:
                                            retval = _.parse(format(Settings.LOG + '(sec({0}))', arg));
                                            break;
                                        case SEC:
                                            retval = _.parse(format(Settings.LOG + '(tan({0})+sec({0}))', arg));
                                            break;
                                        case CSC:
                                            retval = _.parse(format('-' + Settings.LOG + '(csc({0})+cot({0}))', arg));
                                            break;
                                        case COT:
                                            retval = _.parse(format(Settings.LOG + '(sin({0}))', arg));
                                            break;
                                        case SINH:
                                            retval = _.symfunction(COSH, [arg]);
                                            break;
                                        case COSH:
                                            retval = _.symfunction(SINH, [arg]);
                                            break;
                                        case TANH:
                                            retval = _.parse(format(Settings.LOG + '(cosh({0}))', arg));
                                            break;
                                        case ASEC:
                                            retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            break;
                                        case ACSC:
                                            retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            break;
                                        case ACOT:
                                            retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            break;
                                            //inverse htrig
                                        case ASECH:
                                            retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            break;
                                        case ACSCH:
                                            retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            break;
                                        case ACOTH:
                                            retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            break;
                                            //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));
                                            break;
                                        case COTH:
                                            retval = _.parse(format(Settings.LOG + '(sinh({0}))', arg));
                                            break;
                                            //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];
                                            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];
                                            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];
                                            retval = _.parse(format('e^(-(({2}))^2)/(({0})*sqrt(pi))+(1/({0})+({1}))*erf(({2}))', a_, x_, arg));
                                            break;
                                        case 'sign':
                                            retval = _.multiply(symbol.clone(), arg.clone());
                                            break;
                                        default:
                                            __.integration.stop();
                                    }

                                    retval = _.divide(retval, a);
                                }
                            }
                            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
                                    if(p < 0) {
                                        symbol.fname = fname === SIN ? CSC : SEC;
                                        symbol.invert().updateHash();
                                        retval = __.integrate(symbol, dx, depth);
                                    }
                                    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.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();
                                        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) {
                                    //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.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) {
                                    //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);
                                    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)));
                                }
                                else if((fname === COSH || fname === SINH) && symbol.power.equals(2)) {
                                    retval = __.integrate(symbol.fnTransform(), dx, depth);
                                }
                                else
                                    __.integration.stop();
                            }
                            else
                                __.integration.stop();

                            retval.multiplier = retval.multiplier.multiply(m);
                        }
                    }
                    else if(g === PL) {
                        retval = __.integration.partial_fraction(symbol, dx, depth);
                    }
                    else if(g === CB) {
                        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);
                        //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!
                        if(coeff.contains(dx)) {
                            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)) {
                                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 {
                            //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) {
                                    if(Number(a.power) === Number(b.power))
                                        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) {
                                var unwrapped = Symbol.unwrapSQRT(x, true);
                                if(unwrapped.fname === EXP) {
                                    return _.parse(format('({1})*e^({0})', unwrapped.args[0], unwrapped.multiplier));
                                }
                                return unwrapped;
                            });
                            var l = symbols.length;
                            if(symbol.power < 0) {
                                if(l === 2) {
                                    return __.integrate(_.expand(symbol), dx, depth, opt);
                                }
                            }
                            //otherwise the denominator is one lumped together symbol 
                            else {
                                //generate an image for 
                                if(l === 2) {
                                    //try u substitution
                                    try {
                                        retval = __.integration.u_substitution(symbols, dx);
                                    }
                                    catch(e) {/* failed :`(*/
                                        ;
                                    }

                                    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;
                                        //reset the symbol minus the coeff
                                        symbol = _.multiply(sym1.clone(), sym2.clone());
                                        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) {
                                                    return b.fname > a.fname;
                                                });
                                                var arg1 = sym1.args[0];
                                                //make sure the arguments are suitable. We don't know how to integrate non-linear arguments
                                                if(!arg1.isLinear() || !(arg1.group === CP || arg1.group === CB || arg1.group === S))
                                                    __.integration.stop();

                                                var decomp = __.integration.decompose_arg(arg1, dx);
                                                x = decomp[1],
                                                        a = decomp[0];
                                                if(!x.isLinear()) //again... linear arguments only wrt x
                                                    __.integration.stop();

                                                //they have to have the same arguments and then we have cleared all the check to 
                                                //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(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)) {
                                                            sym1.fname = TAN;
                                                            sym1.updateHash();
                                                            retval = __.integrate(sym1, dx, depth);
                                                        }
                                                        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));
                                                                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));
                                                                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);
                                                                retval = new Symbol(0);
                                                                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;
                                                                    }
                                                                    else {
                                                                        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)));
                                                                    //we can now just loop through and integrate each since it's now just a polynomial with functions
                                                                    sym.each(function (x) {
                                                                        retval = _.add(retval, __.integration.poly_integrate(x.clone()));
                                                                    });
                                                                }
                                                                else {
                                                                    //performs double angle transformation
                                                                    var double_angle = function (symbol) {
                                                                        var p = symbol.power,
                                                                                k = p / 2, e;
                                                                        if(symbol.fname === COS)
                                                                            e = '((1/2)+(cos(2*(' + symbol.args[0] + '))/2))^' + k;
                                                                        else
                                                                            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);
                                                                    var sym = _.expand(t);
                                                                    sym.each(function (x) {
                                                                        retval = _.add(retval, __.integrate(x, dx, depth));
                                                                    });
                                                                    return _.multiply(retval, coeff);
                                                                }
                                                            }
                                                        }
                                                    }
                                                    //tan(x)*sec(x)^n 
                                                    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()) {
                                                        //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;
                                                            //transform tangent
                                                            var t = _.parse(format('(sec({0})^2-1)^({1})', sym1.args[0], p));
                                                            retval = __.integrate(_.expand(_.multiply(t, sym2)), dx, depth);
                                                        }
                                                        else
                                                            __.integration.stop();
                                                    }
                                                    else if(fn1 === SEC && fn2 === COS) {
                                                        sym1.fname = COS;
                                                        sym1.invert().updateHash();
                                                        retval = __.integrate(_.multiply(sym1, sym2), dx, depth);
                                                    }
                                                    else if(fn1 === SIN && fn2 === CSC) {
                                                        sym2.fname = SIN;
                                                        sym2.invert().updateHash();
                                                        retval = __.integrate(_.multiply(sym1, sym2), dx, depth);
                                                    }
                                                    //tan/cos
                                                    else if(fn1 === TAN && (fn2 === COS || fn2 === SIN) && sym2.power.lessThan(0)) {
                                                        var t = _.multiply(sym1.fnTransform(), sym2);
                                                        retval = __.integrate(_.expand(t), dx, depth);
                                                    }
                                                    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()) {
                                                            //use identity (sin(b*x+a*x)+sin(b*x-a*x))/2
                                                            var ax, bx;
                                                            if(fn2 === SIN) {
                                                                ax = sym1.args[0];
                                                                bx = sym2.args[0];
                                                            }
                                                            else {
                                                                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()));

                                                            //integrate it
                                                            retval = __.integrate(f, dx, depth);
                                                        }
                                                        else {
                                                            var transformed = trigTransform(symbols);
                                                            retval = __.integrate(_.expand(transformed), dx, depth);
                                                        }
                                                    }
                                                    else {
                                                        var transformed = new Symbol(1);
                                                        symbols.map(function (sym) {
                                                            var s = sym.fnTransform();
                                                            transformed = _.multiply(transformed, s);
                                                        });
                                                        var t = _.expand(transformed);

                                                        retval = __.integrate(t, dx, depth);

                                                        if(retval.hasIntegral()) {
                                                            retval = __.integrate(trigTransform(transformed.collectSymbols()), dx, depth);
                                                        }
                                                    }
                                                }
                                                else {
                                                    __.integration.stop();
                                                }

                                            }
                                        }
                                        else if(g1 === FN && g2 === S) {
                                            var sym1_is_linear = sym1.isLinear();
                                            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);
                                            }
                                            else if(sym1.fname === COSH && sym1_is_linear && sym2.power.equals(-1))
                                                retval = _.symfunction('Chi', [sym1.args[0]]);
                                            else if(sym1.fname === COSH && sym2.power.equals(-1)) {
                                                retval = __.integrate(_.multiply(sym1.fnTransform(), sym2.clone()), dx, depth);
                                            }
                                            else if(sym1.fname === SIN && sym1_is_linear && sym2.power.equals(-1))
                                                retval = _.symfunction('Si', [sym1.args[0]]);
                                            else if(sym1.fname === SIN && sym2.power.equals(-1)) {
                                                retval = __.integrate(_.multiply(sym1.fnTransform(), sym2.clone()), dx, depth);
                                            }
                                            else if(sym1.fname === SINH && sym1_is_linear && sym2.power.equals(-1))
                                                retval = _.symfunction('Shi', [sym1.args[0]]);
                                            else if(sym1.fname === SINH && sym2.power.equals(-1)) {
                                                retval = __.integrate(_.multiply(sym1.fnTransform(), sym2.clone()), dx, depth);
                                            }
                                            else if(sym1.fname === LOG && sym2.power.equals(-1)) {
                                                //log(x)^n/x = log(x)^(n+1)/(n+1)
                                                retval = __.integration.poly_integrate(sym1, dx, depth);
                                            }
                                            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();
                                                    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 {
                                                //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) {
                                            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()]);
                                            }
                                            else if(fn1 === LOG && x.value === sym2.value) {
                                                retval = __.integration.poly_integrate(sym1, dx, depth);
                                            }
                                            else
                                                retval = __.integration.by_parts(symbol, dx, depth, opt);
                                        }
                                        else if(g1 === PL && g2 === S) {
                                            //first try to reduce the top
                                            if(sym2.value === sym1.value && sym1.power.equals(-1)) {
                                                //find the lowest power in the denominator
                                                var pd = Math.min.apply(null, core.Utils.keys(sym1.symbols));
                                                //get the lowest common value between denominator and numerator
                                                var pc = Math.min(pd, sym2.power);
                                                //reduce both denominator and numerator by that factor
                                                var factor = sym2.clone();
                                                factor.power = new Frac(pc);
                                                sym2 = _.divide(sym2, factor.clone()); //reduce the denominator
                                                var t = new Symbol(0);
                                                sym1.each(function (x) {
                                                    t = _.add(t, _.divide(x.clone(), factor.clone()));
                                                });
                                                t.multiplier = sym1.multiplier;
                                                symbol = _.divide(sym2, t);
                                            }
                                            else {
                                                symbol = _.expand(symbol);
                                            }
                                            retval = __.integration.partial_fraction(symbol, dx, depth);
                                        }
                                        else if(g1 === CP && g2 === S) {
                                            var f = sym1.clone().toLinear(),
                                                    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)) {
                                                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);
                                                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)));
                                                    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 + ')');
                                                    retval = _.multiply(c, integral.sub(new Symbol('u'), bksub));
                                                }
                                                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;
                                                    }
                                                    if(p2 === -1) {
                                                        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) {
                                                retval = __.integration.partial_fraction(symbol, dx, depth);
                                            }
                                            else if(!sym1.power.lessThan(0) && isInt(sym1.power)) {
                                                //sum of integrals
                                                var expanded = _.expand(sym1);
                                                retval = new Symbol(0);
                                                expanded.each(function (x) {
                                                    if(x.group === PL) {
                                                        x.each(function (y) {
                                                            retval = _.add(retval, __.integrate(_.multiply(sym2.clone(), y), dx, depth));
                                                        });
                                                    }
                                                    else
                                                        retval = _.add(retval, __.integrate(_.multiply(sym2.clone(), x), dx, depth));
                                                });
                                            }
                                            else if(sym1.power.lessThan(-2)) {
                                                retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            }
                                            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();

                                                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 = {};

                                                    //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)) {

                                                    //factor out coefficients
                                                    var factors = new core.Algebra.Classes.Factors();
                                                    sym1 = core.Algebra.Factor.coeffFactor(sym1.invert(), factors);
                                                    var div = core.Algebra.divide(sym2, sym1);
                                                    //it assumed that the result will be of group CB
                                                    if(div.group !== CB) {
                                                        retval = new Symbol(0);
                                                        div.each(function (t) {
                                                            retval = _.add(retval, __.integrate(t, dx, depth));
                                                        });
                                                        //put back the factors
                                                        factors.each(function (factor) {
                                                            retval = _.divide(retval, factor);
                                                        });

                                                        retval = _.expand(retval);
                                                    }
                                                    else {
                                                        //try something else
                                                        retval = __.integration.by_parts(symbol, dx, depth, opt);
                                                    }
                                                }
                                                else
                                                    retval = __.integration.partial_fraction(symbol, dx, depth);
                                            }
                                            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)) {
                                                    //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];
                                                    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
                                                            //move a to the coeff
                                                            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)]));
                                                    }
                                                    else {
                                                        retval = __.integration.partial_fraction(symbol, dx, depth, opt);
                                                    }
                                                }
                                                else if(f_is_linear) {
                                                    retval = __.integration.partial_fraction(symbol, dx, depth);
                                                }
                                            }

                                        }
                                        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) {
                                                    retval = _.add(retval, __.integrate(x, dx, depth));
                                                }, true);
                                            }
                                            else {
                                                var p1 = Number(sym1.power),
                                                        p2 = Number(sym2.power);
                                                if(p1 < 0 && p2 > 0) {
                                                    //swap
                                                    var t = sym1;
                                                    sym1 = sym2;
                                                    sym2 = t;
                                                }
                                                if(p1 === -1 && p2 === -1) {
                                                    retval = __.integration.partial_fraction(symbol, dx);
                                                }
                                                else {
                                                    sym1.each(function (x) {
                                                        var k = _.multiply(x, sym2.clone());
                                                        var integral = __.integrate(k, dx, depth);
                                                        retval = _.add(retval, integral);
                                                    });
                                                }
                                            }
                                        }
                                        else if(g1 === CP && symbols[0].power.greaterThan(0)) {
                                            sym1 = _.expand(sym1);
                                            retval = new Symbol(0);
                                            sym1.each(function (x) {
                                                retval = _.add(retval, __.integrate(_.multiply(x, sym2.clone()), dx, depth));
                                            }, true);
                                        }
                                        else if(g1 === FN && g2 === EX && core.Utils.in_htrig(sym1.fname)) {
                                            sym1 = sym1.fnTransform();
                                            retval = __.integrate(_.expand(_.multiply(sym1, sym2)), dx, depth);
                                        }
                                        else if(g1 === FN && g2 === CP || g2 === FN && g1 === CP) {
                                            if(g2 === FN && g1 === CP) {
                                                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)) {
                                                p = new Symbol(sym2.power);
                                                sa = du.clone().toLinear();
                                                sb = sym2.clone().toLinear();
                                                q = core.Algebra.divide(sa.toLinear(), sb);
                                                if(q.isConstant()) {
                                                    var nq = _.pow(q, p.negate());
                                                    retval = _.multiply(nq, __.integration.poly_integrate(sym1.clone()));
                                                }
                                            }
                                            else {
                                                retval = __.integration.by_parts(symbol, dx, depth, opt);
                                            }
                                        }
                                        else {
                                            var syma = sym1.clone().toLinear();
                                            var symb = sym2.clone().toLinear();
                                            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
                                                        ));
                                            }
                                            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)) {
                                    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) {
                                            var t = _.multiply(x, r.clone());
                                            var intg = __.integrate(t, dx, depth);
                                            retval = _.add(retval, intg);
                                        }, true);
                                    }
                                    else {
                                        //try integration by parts although technically it will never work
                                        retval = __.integration.by_parts(symbol, dx, depth, opt);
                                    }

                                }
                                else if(all_functions(symbols)) {
                                    var t = new Symbol(1);
                                    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 {
                                    //one more go
                                    var transformed = trigTransform(symbols);
                                    retval = __.integrate(_.expand(transformed), dx, depth);
                                }
                            }

                        }

                        retval = _.multiply(retval, coeff);
                    }
                    //if an integral was found then we return it
                    if(retval)
                        return retval;
                }

                catch(error) {
                    //do nothing if it's a NoIntegralFound error otherwise let it bubble
                    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) {
            dx = dx || 'x'; //make x the default variable of integration
            var get_value = function (integral, vars, point) {
                try {
                    return _.parse(integral, vars);
                }
                catch(e) {
                    //it failed for some reason so return the limit
                    var lim = __.Limit.limit(integral, dx, point);
                    return lim;
                }
            };

            var vars = core.Utils.variables(symbol),
                    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()) {
                var upper = {},
                        lower = {},
                        a, b;
                upper[dx] = to;
                lower[dx] = from;

                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)));
            }
            else
                retval = _.symfunction('defint', [symbol, from, to, dx]);
            return retval;
        },

        Limit: {
            interval: function (start, end) {
                return _.parse(format('[{0}, {1}]', start, end));
            },
            diverges: function () {
                return __.Limit.interval('-Infinity', 'Infinity');
            },
            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.
                //Known limit
                if(g.fname === ABS) {
                    var sign = f.sign();
                    var lim_sign = lim.sign();

                    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);
                    }
                    else {
                        //TODO: Support more limits
                        __.Limit.diverges();
                    }
                }

                var isInfinity = function (L) {
                    if(core.Utils.isVector(L)) {
                        for(var i = 0; i < L.elements.length; i++)
                            if(!L.elements[i].isInfinity)
                                return false;
                        return true;
                    }
                    return L.isInfinity;
                };

                var equals = function (L, v) {
                    if(core.Utils.isVector(L)) {
                        return false;
                    }
                    return L.equals(v);
                };

                var retval;
                do {
                    var lim1 = evaluate(__.Limit.limit(f.clone(), x, lim, depth));
                    var lim2 = evaluate(__.Limit.limit(g.clone(), x, lim, depth));

                    //if it's in indeterminate form apply L'Hospital's rule
                    var indeterminate = isInfinity(lim1) && isInfinity(lim2) || equals(lim1, 0) && equals(lim2, 0);
                    //pull the derivatives
                    if(indeterminate) {
                        var ft = __.diff(f.clone(), x);
                        var gt = __.diff(g.clone(), x);

                        var t_symbol = _.expand(_.divide(ft, gt));
                        f = t_symbol.getNum();
                        g = t_symbol.getDenom();

                    }
                }
                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);
                }
                else if(den_is_zero) {
                    retval = __.Limit.diverges();
                }
                else {
                    retval = _.divide(lim1, lim2);
                }

                return retval;
            },
            rewriteToLog: function (symbol) {
                var p = symbol.power.clone();
                symbol.toLinear();
                return _.pow(new Symbol('e'), _.multiply(p, _.symfunction(Settings.LOG + '', [symbol])));
            },
            getSubbed: function (f, x, lim) {
                var retval;
                //1. rewrite EX with base e
                if(f.group === EX) {
                    f = __.rewriteToLog(f);
                }
                //2. try simple substitution
                try {
                    retval = f.sub(x, lim);
                }
                catch(e) {
                    //Nope. No go, so just return the unsubbed function so we can test the limit instead.
                    retval = f;
                }

                return retval;
            },
            isInterval: function (limit) {
                return core.Utils.isVector(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')
                        ) {
                    return false; //Then no
                }
                return true; //It is
            },
            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) {
                        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
                symbol.toUnitMultiplier();
                try {
                    //https://en.wikipedia.org/wiki/List_of_limits
                    var retval;
                    //we try the simplest option first where c is some limit
                    //lim a as x->c = a where c 
                    if(symbol.isConstant(true)) {
                        retval = symbol;
                    }
                    else {
                        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.*/
                        }
                        ;

                        if(!retval) {
                            //split the symbol in the numerator and the denominator
                            var num = symbol.getNum();
                            var den = symbol.getDenom();

                            if(den.isConstant(true)) {
                                //We still don't have a limit so we generate tests.
                                if(symbol.group === EX) {
                                    //https://en.wikipedia.org/wiki/List_of_limits
                                    //Speed boost for exponentials by detecting patterns
                                    var f = symbol.clone().toLinear();
                                    var p = symbol.power.clone();
                                    var _num = f.getNum();
                                    var _den = f.getDenom();
                                    var fn = core.Utils.decompose_fn(_den, x, true);
                                    //start detection of pattern (x/(x+1))^x
                                    if(_num.group === S && _num.multiplier.isOne() && fn.ax.group === S && fn.b.isConstant(true) && fn.a.isOne() && fn.b.isConstant(true)) {
                                        retval = _.parse(format('(1/e^({0}))', fn.b));
                                    }
                                    else {
                                        var symbol_ = __.Limit.rewriteToLog(symbol.clone());
                                        //get the base
                                        var pow = symbol_.power.clone();
                                        var base = symbol_.clone().toLinear();
                                        var lim_base = __.Limit.limit(base, x, lim, depth);
                                        var lim_pow = __.Limit.limit(pow, x, lim, depth);
                                        retval = _.pow(lim_base, lim_pow);
                                    }
                                }
                                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) {
                                            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
                                        try {
                                            evaluate(trial);
                                            evaluates = true;
                                        }
                                        catch(e) {

                                            evaluates = false;
                                        }
                                    }
                                    if(evaluates) {
                                        retval = trial;
                                    }
                                    else {
                                        //if the limit converges. We'll deal with non-convergent ones later
                                        if(__.Limit.isConvergent(arg)) {
                                            if(symbol.fname === LOG) {
                                                switch(arg.toString()) {
                                                    //lim -> 0
                                                    case '0':
                                                        retval = Symbol.infinity().negate();
                                                        break;
                                                    case 'Infinity':
                                                        retval = Symbol.infinity();
                                                        break;
                                                    case '-Infinity':
                                                        retval = Symbol.infinity();
                                                        break;
                                                }
                                            }
                                            else if((symbol.fname === COS || symbol.fname === SIN) && lim.isInfinity) {
                                                retval = __.Limit.interval(-1, 1);
                                            }
                                            else if((symbol.fname === TAN)) {
                                                var s_arg = symbol.args[0];
                                                var n = s_arg.getNum();
                                                var d = s_arg.getDenom();
                                                var pi = n.toUnitMultiplier();
                                                if(lim.isInfinity || pi.equals('pi') && d.equals(2)) {
                                                    retval = divergent();
                                                }
                                            }
                                            else if(symbol.fname === Settings.FACTORIAL) {
                                                if(arg.isInfinity)
                                                    return Symbol.infinity();
                                            }
                                        }
                                    }
                                }
                                else if(symbol.group === S) {
                                    if(symbol.power > 0)
                                        //these functions always converge to the limit
                                        return _.parse(symbol, point);
                                    else {
                                        //we're dealing with 1/x^n but remember that infinity has already been dealt
                                        //with by substitution
                                        if(core.Utils.even(symbol.power)) {
                                            //even powers converge to infinity
                                            retval = Symbol.infinity();
                                        }
                                        else {
                                            //odd ones don't
                                            retval = __.Limit.diverges();
                                        }
                                    }
                                }
                                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) {
                                        return a.group - b.group;
                                    });

                                    var f = symbols.pop();
                                    //calculate the first limit so we can keep going down the list
                                    lim1 = evaluate(__.Limit.limit(f, x, lim, depth));

                                    //reduces all the limits one at a time
                                    while(symbols.length) {
                                        //get the second limit
                                        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(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()
                                            }
                                            else {
                                                lim1 = __.Limit.divide(f, g, x, lim, depth);
                                            }
                                        }
                                        else {
                                            //lim f*g = (lim f)*(lim g)
                                            lim1 = _.multiply(lim1, lim2);
                                            //let f*g equal f and h equal g 
                                            f = _.multiply(f, g);
                                        }
                                    }

                                    //Done, lim1 is the limit we're looking for     
                                    retval = lim1;
                                }
                                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) {
                                        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++) {
                                        var sym = symbols[i].clone();
                                        if(sym.group === FN || sym.group === CB && sym.hasFunc()) {
                                            fns = _.add(fns, sym);
                                        }
                                        else
                                            _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++) {
                                        var sym = symbols[i];
                                        //If the addition of the limits is undefined then the limit diverges so return -infinity to infinity
                                        try {
                                            _lim = __.Limit.limit(sym, x, lim, depth);
                                        }
                                        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]);
                }
                catch(e) {
                    //if all else fails return the symbolic function
                    retval = _.symfunction('limit', [symbol, x, lim]);
                }

                return _.multiply(m, retval);
            }
        },
        Fresnel: {
            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) {
                if(x.isConstant(true)) {
                    return __.defint(_.parse('cos(pi*x^2/2)'), Symbol(0), x, 'x');
                }
                return _.symfunction('C', arguments);
            }
        }
    };

    nerdamer.register([
        {
            name: 'diff',
            visible: true,
            numargs: [1, 3],
            build: function () {
                return __.diff;
            }
        },
        {
            name: 'sum',
            visible: true,
            numargs: 4,
            build: function () {
                return __.sum;
            }
        },
        {
            name: 'product',
            visible: true,
            numargs: 4,
            build: function () {
                return __.product;
            }
        },
        {
            name: 'integrate',
            visible: true,
            numargs: [1, 2],
            build: function () {
                return __.integrate;
            }
        },
        {
            name: 'defint',
            visible: true,
            numargs: [3, 4],
            build: function () {
                return __.defint;
            }
        },
        {
            name: 'S',
            visible: true,
            numargs: 1,
            build: function () {
                return __.Fresnel.S;
            }
        },
        {
            name: 'C',
            visible: true,
            numargs: 1,
            build: function () {
                return __.Fresnel.C;
            }
        },
        {
            name: 'limit',
            visible: true,
            numargs: [3, 4],
            build: function () {
                return __.Limit.limit;
            }
        }
    ]);
    //link registered functions externally
    nerdamer.updateAPI();

})();