The name says it all :)
@param {Symbol} symbol
@param {Factor} factors
@returns {Symbol}
962576
function(symbol, factors) {
                if(symbol.isConstant() || symbol.group === S) return symbol;
                var poly = new Polynomial(symbol),
                    cnst = poly.coeffs[0],
                    cfactors = core.Math2.ifactor(cnst),
                    roots = __.proots(symbol);
                for(var i=0; i<roots.length; i++) {
                    var r = roots[i],
                        p = 1;
                    if(!isNaN(r)) { //if it's a number
                        for(var x in cfactors) {
                            //check it's raised to a power
                            var n = core.Utils.round(Math.log(x)/Math.log(Math.abs(r)), 8);
                            if(isInt(n)) {
                                r = x; //x must be the root since n gave us a whole
                                p = n; break;
                            }
                        }
                        var root = new Frac(r),
                            terms = [new Frac(root.num).negate()];
                        terms[p] = new Frac(root.den);
                            //convert to Frac. The den is coeff of LT and the num is coeff of constant
                        var div = Polynomial.fromArray(terms, poly.variable).fill(),
                            t = poly.divide(div);
                        if(t[1].equalsNumber(0)) { //if it's zero we have a root and divide it out
                            poly = t[0];
                            factors.add(div.toSymbol());
                        }
                    }
                }
                if(!poly.equalsNumber(1)) {
                    poly = __.Factor.search(poly, factors);
                }
                return poly.toSymbol();
            }
250552
function polyfillSymbol(name) {

  if (!Symbol[name])
    Object.defineProperty(Symbol, name, { value: Symbol(name) });
}
840471
public static Factor add(List<Factor> factors) {
    Preconditions.checkNotNull(factors);
    Preconditions.checkArgument(!factors.isEmpty());
    return factors.get(0).add(factors.subList(1, factors.size()));
  }
612970
private List<Token> convertFactor(final Token.Factor factor) {
        
        final String item = factor.getValue();
        final int itemLength = item.length();
        
        final List<Token> list = new ArrayList<>();
        
        int idx = 0;
        StringBuilder noTermChar = new StringBuilder(); // フォーマット以外の文字列を積む。
        while(idx < itemLength) {
            
            String matchChars = null;
            for(String chars : SORTED_DATE_CHARS) {
                if(Utils.startsWithIgnoreCase(item, chars, idx)) {
                    matchChars = item.substring(idx, idx + chars.length());
                    break;
                }
            }
            
            if(matchChars == null) {
                // フォーマットでない場合は、文字列としてバッファに追加する。
                noTermChar.append(item.charAt(idx));
                idx++;
            } else {
                if(noTermChar.length() > 0) {
                    // 今まで積んだバッファを、文字列として分割する。
                    list.add(Token.factor(noTermChar.toString()));
                    noTermChar = new StringBuilder();
                }
                
                list.add(Token.formatter(matchChars));
                idx += matchChars.length();
                
            }
        }
        
        if(noTermChar.length() > 0) {
            list.add(Token.factor(noTermChar.toString()));
        }
        
        return list;
    }
74670
public static Module<Factors> getFactorsModule(FactorGraph fg, Algebra s) {
        ForwardOnlyFactorsModule fm = new ForwardOnlyFactorsModule(null, fg, s);
        fm.forward();
        return fm;
    }
894523
def get_factors(n):
    

    def factor(n, i, combi, res):
        """[summary]
        helper function

        Arguments:
            n {[int]} -- [number]
            i {[int]} -- [to tested divisor]
            combi {[list]} -- [catch divisors]
            res {[list]} -- [all factors of the number n]
        
        Returns:
            [list] -- [res]
        """

        while i * i <= n:
            if n % i == 0:
                res += combi + [i, int(n/i)],
                factor(n/i, i, combi+[i], res)
            i += 1
        return res
    return factor(n, 2, [], [])
422610
function(symbol, factors) {  
                if(symbol.group === FN) { 
                    if(symbol.fname === 'sqrt') {
                        var factors2 = new Factors(),
                            arg = __.Factor.common(symbol.args[0].clone(), factors2);
                        arg = __.Factor.coeffFactor(arg, factors2);
                        symbol = _.symfunction('sqrt', [arg]);
                        factors2.each(function(x) {
                            symbol = _.multiply(symbol, _.parse(core.Utils.format('sqrt({0})', x)));
                        });
                    }
                    else
                        factors.add(symbol);
                }
                else { 
                    //symbol = __.Factor.common(symbol, factors);
                    symbol = __.Factor.mSqfrFactor(symbol, factors);
                    
                    var vars = variables(symbol),
                        symbols = symbol.collectSymbols().map(function(x) {
                            return Symbol.unwrapSQRT(x);
                        }),
                        sorted = {},
                        maxes = {},
                        l = vars.length, n = symbols.length;
                    //take all the variables in the symbol and organize by variable name
                    //e.g. a^2+a^2+b*a -> {a: {a^3, a^2, b*a}, b: {b*a}}
                    
                    for(var i=0; i<l; i++) {
                        var v = vars[i];
                        sorted[v] = new Symbol(0);
                        for(var j=0; j<n; j++) {
                            var s = symbols[j];
                            if(s.contains(v)) {
                                var p = s.value === v ? s.power.toDecimal() : s.symbols[v].power.toDecimal();
                                if(!maxes[v] || p < maxes[v]) maxes[v] = p;
                                sorted[v] = _.add(sorted[v], s.clone());
                            }
                        }
                    }
                    
                    for(var x in sorted) {
                        var r = _.parse(x+'^'+maxes[x]); 
                        var div = _.divide(sorted[x], r);
                        var new_factor = _.expand(div); 
                        
                        if(new_factor.equals(1))
                            break; //why divide by one. Just move 
                        var divided = __.div(symbol.clone(), new_factor); 
                        if(divided[0].equals(0)) { 
                            //cant factor anymore
                            break;
                        }
                        
                        var neg_numeric_factor = isInt(new_factor) && new_factor.lessThan(0);
                        
                        if(divided[1].equals(0) && !neg_numeric_factor) { //we found at least one factor
                            //factors.add(new_factor);
                            var d = __.div(symbol.clone(), divided[0].clone());
                            var r = d[0];
                            symbol = d[1];
                            //we don't want to just flip the sign. If the remainder is -1 then we accomplished nothing
                            //and we just return the symbol;
                            //If r equals zero then there's nothing left to do so we're done
                            if(r.equals(-1))
                                return symbol;

                            var factor = divided[0]; 
                            if(symbol.equals(factor)) {
                                var rem = __.Factor.reduce(factor, factors);
                                
                                if(!symbol.equals(rem)) 
                                    return __.Factor.mfactor(rem, factors);
                            }
                            else {
                                factors.add(factor); 
                                //if the remainder of the symbol is zero then we're done. TODO: Rethink this logic a bit.
                                if(symbol.equals(0))
                                    return r;
                            }
                            
                            if(r.isConstant('all')) { 
                                factors.add(r);
                                return r;
                            }
                            
                            return __.Factor.mfactor(r, factors);
                        }
                    }
                    
                }
                
                //difference of squares factorization
                symbol = __.Factor.sqdiff(symbol, factors);
                //factors by fishing for zeroes
                symbol = __.Factor.zeroes(symbol, factors);
                
                return symbol;
            }
788257
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);
                                                                    }
1222643
public PlateFactor getFactorByName(String name) {
    int index = factorNames.indexOf(name);
    if (index == -1) {
      return null;
    } else {
      return plateFactors.get(index);
    }
  }
826842
function getImport(symbol, member) {
  const defaultExport = symbol.name.split('~');
  const namedExport = symbol.name.split('.');
  if (defaultExport.length > 1) {
    const from = defaultExport[0].replace(/^module\:/, './');
    const importName = from.replace(/[.\/]+/g, '$');
    return `import ${importName} from '${from}';`;
  } else if (namedExport.length > 1 && member) {
    const from = namedExport[0].replace(/^module\:/, './');
    const importName = from.replace(/[.\/]+/g, '_');
    return `import {${member} as ${importName}$${member}} from '${from}';`;
  }
}
111780
def singleFactor(factors, chart, factor, obj, aspect=None):
    "
    
    objID = obj if type(obj) == str else obj.id
    res = {
        'factor': factor,
        'objID': objID,
        'aspect': aspect
    }
    
    # For signs (obj as string) return sign element
    if type(obj) == str:
        res['element'] = props.sign.element[obj]
        
    # For Sun return sign and sunseason element
    elif objID == const.SUN:
        sunseason = props.sign.sunseason[obj.sign]
        res['sign'] = obj.sign
        res['sunseason'] = sunseason
        res['element'] = props.base.sunseasonElement[sunseason]
        
    # For Moon return phase and phase element
    elif objID == const.MOON:
        phase = chart.getMoonPhase()
        res['phase'] = phase
        res['element'] = props.base.moonphaseElement[phase]
        
    # For regular planets return element or sign/sign element
    # if there's an aspect involved
    elif objID in const.LIST_SEVEN_PLANETS:
        if aspect:
            res['sign'] = obj.sign
            res['element'] = props.sign.element[obj.sign]
        else:
            res['element'] = obj.element()
            
    try:
        # If there's element, insert into list
        res['element']
        factors.append(res)
    except KeyError:
        pass
    
    return res
147796
function SymbolsCompiler(ns, node, descend) {
    if (node instanceof UglifyJS.AST_SymbolVar || node instanceof UglifyJS.AST_SymbolRef) {
        var name = node.name;
        if (['Class', 'Interface', 'Exception'].indexOf(name) >= 0) {
            return AccessNS('ria.__API.' + name, null, node);
        }
    }
}
1258199
function(func,factor) {
		return function() {

			/* globals setTimeout: false */

			var args = Array.prototype.slice.call(arguments),
				cb;
			while (typeof args.slice(-1)[0] === 'function') {
				cb = args.pop();
			}
			if (factor === false) {
				return cb(func.apply(this._inst,args));
			}
			setTimeout(function() {
				var r = [func.apply(this._inst,args)];
				if (nodeStyle) {
					r.unshift(null);
				}
				cb.apply(this, r);
			}.bind(this),Math.floor(Math.random() * factor) + 1);
		};
	}
369913
def _prodterm(lexer):
    """"""
    factor = _factor(lexer)
    prodterm_prime = _prodterm_prime(lexer)
    if prodterm_prime is None:
        return factor
    else:
        return ('and', factor, prodterm_prime)
614842
public Factor getFactorByName(String name) {
    int index = getFactorIndexByName(name);
    if (index == -1) {
      return null;
    }
    return factors[index];
  }
542361
function(symbol, factors) { 
                try {
                    var remove_square = function(x) {
                        return core.Utils.block('POSITIVE_MULTIPLIERS', function() {
                            return Symbol.unwrapPARENS(math.sqrt(math.abs(x)));
                        }, true);
                    }; 
                    var separated = core.Utils.separate(symbol.clone());
                    var obj_array = [];
                    //get the unique variables
                    for(var x in separated) {
                        if(x !== 'constants') {
                            obj_array.push(separated[x]);
                        }
                    }
                    obj_array.sort(function(a, b) {
                        return b.power - a.power;
                    });

                    //if we have the same number of variables as unique variables then we can apply the difference of squares
                    if(obj_array.length === 2) { 
                        var a, b;
                        a = obj_array.pop();
                        b = obj_array.pop();
                        if(a.isComposite() && b.power.equals(2)) {
                            //remove the square from b
                            b = remove_square(b);
                            var f = __.Factor.factor(_.add(a, separated.constants));
                            if(f.power.equals(2)) {
                                f.toLinear();
                                factors.add(_.subtract(f.clone(), b.clone()));
                                factors.add(_.add(f, b));
                                symbol = new Symbol(1);
                            }
                        }
                        else {
                            a = a.powSimp();
                            b = b.powSimp();
                            
                            if((a.group === S || a.fname === '') && a.power.equals(2) && (b.group === S || b.fname === '') && b.power.equals(2)) {
                                if(a.multiplier.lessThan(0)) {
                                    var t = b; b = a; a = t;
                                }
                                if(a.multiplier.greaterThan(0)) {
                                    a = remove_square(a);
                                    b = remove_square(b);
                                }
                                factors.add(_.subtract(a.clone(), b.clone()));
                                factors.add(_.add(a, b));
                                symbol = new Symbol(1);
                            }
                        }
                    }
                }
                catch(e){;}
                
                return symbol;
            }
1045542
function (symbol) {
  var parentheticals;

  if (symbol === '') return 'M'; // No symbol means major triad

  symbol = symbol.replace(/maj/i, 'M')
                 .replace(/∆/, 'M')
                 .replace(/min/i, 'm')
                 .replace(/^-/, 'm')
                 .replace(/dom/, '')
                 .replace(/^o/, 'dim')
                 .replace(/1\/2dim/, 'ø');

  // Remove parentheses unless they are significant, i.e. they contain an 11, or 13
  parentheticals = symbol.match(/\([^\)]*\)/g);
  _.each(parentheticals, function (parenthetical) {
    if (parenthetical.indexOf('11') === -1 && parenthetical.indexOf('13') === -1) {
      symbol = symbol.replace(parenthetical, parenthetical.slice(1, -1));
    }
  });

  return symbol;
}