* @param root
     * @param rootRoundIfNecessary
     * @return The rootRoundIfNecessary of x to decimalPlaces precision
     */
    public static BigDecimal rootNoRounding(
            BigDecimal x,
            BigInteger root) {
        // The current (Java6) limit for n in x.pow(n)
        // for BigDecimal x and int n is
        // -999999999 < n < 999999999
        if (root.compareTo(BigInteger.valueOf(999999999)) != 1) {
            BigDecimal result = rootNoRounding(
                    x,
                    root.intValue());
            return result;
        } else {
            // Deal with special cases
            // x <= 0
            if (x.compareTo(BigDecimal.ZERO) != 1) {
                // Complex roots are not handled!
                throw new IllegalArgumentException(
                        "x <= 0 in " + Generic_BigDecimal.class
                        + ".root(BigDecimal,BigInteger,int,RoundingMode)");
            }
            // x = 1
            if (x.compareTo(BigDecimal.ONE) == 0) {
                return BigDecimal.ONE;
            }
            // rootRoundIfNecessary = 1
            if (root.compareTo(BigInteger.ONE) == 0) {
                BigDecimal result = new BigDecimal(x.toString());
                return result;
            }
            // x < 1
            if (x.compareTo(BigDecimal.ONE) == -1) {
                int xscale = x.scale();
                // Optimisation (untested if it is faster) for a large x.scale()
                int rootLength = root.toString().length();
                if (xscale < 10) {
                    BigDecimal numeratorUnrooted = new BigDecimal(x.unscaledValue());
                    BigDecimal denominatorUnrooted = new BigDecimal(BigInteger.ONE, (-1 * xscale));
                    // numerator will be greater than denominator and both will
                    // be close to a value of 1, a large number of decimal 
                    // places for both numerator and denominator are required!
                    BigDecimal denominator = rootNoRounding(
                            denominatorUnrooted,
                            root);
                    int denominatorScale = denominator.scale();
                    BigDecimal numerator = rootNoRounding(
                            numeratorUnrooted,
                            root);
                    BigDecimal result = Generic_BigDecimal.divideNoRounding(
                            numerator,
                            denominator);
                    return result;
                } else {
                    BigDecimal result = rootLessThanOneNoRounding(
                            x,
                            root);
                    return result;
                }
            }
            BigDecimal result;// = new BigDecimal("1");
            int rootInitialisationMaxIte = 10;
            result = rootInitialisationNoRounding(
                    x,
                    root,
                    rootInitialisationMaxIte);
            // Newton Raphson
            //int newtonRaphsonMaxite = 100;
            result = newtonRaphsonNoRounding(
                    x,
                    result,
                    root);
            return result;
        }
    }