* @param result0
     * @param rootRoundIfNecessary
     * @param epsilon
     * @param maxite
     * @param decimalPlaces
     * @param a_RoundingMode
     * @return Re-approximation of result0 using Newton Raphson method
     */
    private static BigDecimal newtonRaphsonLessThanOneNoRounding(
            BigDecimal x,
            BigDecimal result0,
            BigInteger root) {
        BigDecimal result = new BigDecimal(result0.toString());
        BigDecimal rootsubtract1 = new BigDecimal(root.subtract(BigInteger.ONE));
        // p = (n-1)xk        
        BigDecimal p;
        BigDecimal resultipowrootsubtract1;
        BigDecimal adivresultipowrootsubtract1;
        BigDecimal inside;
        boolean maxiteReached = true;
        // Newton Raphson
        while (true) {
            result0 = new BigDecimal(result.toString());
            p = result.multiply(rootsubtract1);
            resultipowrootsubtract1 = Generic_BigDecimal.powerNoRounding(
                    result,
                    rootsubtract1);
            adivresultipowrootsubtract1 = divideNoRounding(
                    x,
                    resultipowrootsubtract1);
            inside = p.add(adivresultipowrootsubtract1);
            result = divideNoRounding(
                    inside,
                    root);
            // Test for convergence
            if (result0.compareTo(result) == 1) {
                break;
            }
        }
        return result;
    }

//    /**
//     * @return true if there is a rootRoundIfNecessary in the precision and false otherwise
//     */
//    private boolean isRootInPrecision(
//            BigDecimal x,
//            int rootRoundIfNecessary,
//            BigDecimal epsilon_BigDecimal,
//            int precision,
//            RoundingMode a_RoundingMode){
//        boolean toCompare = true;
//            if (x.compareTo(BigDecimal.ONE) == 1) {
//                BigDecimal check = power(
//                        epsilon_BigDecimal,
//                        rootRoundIfNecessary,
//                        rootRoundIfNecessary,
//                        4,
//                        precision,
//                        a_RoundingMode);
////                BigDecimal check = power( // Too slow...
////                        epsilon_BigDecimal,
////                        rootRoundIfNecessary,
////                        precision,
////                        a_RoundingMode);
//                if (check.compareTo(x) == 1) {
//                    System.out.println("No rootRoundIfNecessary in the precision...");
//                    return BigDecimal.ZERO;
//                }
//            }
//    }
//    private static BigDecimal rootInitialisation(
//            BigDecimal x,
//            int rootRoundIfNecessary,
//            //BigDecimal root_BigDecimal,
//            BigDecimal maxError_BigDecimal,
//            BigDecimal a0,
//            int decimalPlaces,
//            RoundingMode a_RoundingMode) {
//        BigDecimal result;
//        // Initialise toCompare and previousResult_BigDecimal
//        if (x.compareTo(BigDecimal.ONE) == -1) {
//            return rootInitialisationLessThanOne(
//                    x,
//                    rootRoundIfNecessary,
//                    //root_BigDecimal,
//                    maxError_BigDecimal,
//                    a0,
//                    decimalPlaces,
//                    a_RoundingMode);
//        } else {
//            result = BigDecimal.ONE.add(maxError_BigDecimal);
//            BigDecimal a = x.divide(root_BigDecimal, decimalPlaces, a_RoundingMode);
//            if (a.compareTo(BigDecimal.ONE) == 1) {
//                result = BigDecimal.ONE.add(maxError_BigDecimal);
//                // Disect
//                BigDecimal b = a0;
//                BigDecimal c;
//                //BigDecimal cPowerRoot;
//                boolean cPowerRootTest;
//                boolean notInitialised = true;
//                while (notInitialised) {
//                    c = (a.add(b)).divide(root_BigDecimal, decimalPlaces, a_RoundingMode);
//                    cPowerRootTest = powerTestAbove(
//                            x,
//                            c,
//                            rootRoundIfNecessary,
//                            64,
//                            decimalPlaces,
//                            a_RoundingMode);
//                    if (cPowerRootTest) {
////                    cpowerroot = power(
////                            c,
////                            rootRoundIfNecessary,
////                            64,
////                            decimalPlaces,
////                            a_RoundingMode);
////                    if (cpowerroot.compareTo(x) == 1) {
//                        a = c;
//                    } else {
//                        // Bisect
//                        c = (a.add(b)).divide(TWO, decimalPlaces, a_RoundingMode);
//                        cPowerRootTest = powerTestAbove(
//                                x,
//                                c,
//                                rootRoundIfNecessary,
//                                64,
//                                decimalPlaces,
//                                a_RoundingMode);
//                        if (cPowerRootTest) {
////                        cpowerroot = power(
////                            c,
////                            rootRoundIfNecessary,
////                            64,
////                            decimalPlaces,
////                            a_RoundingMode);
////                        if (cpowerroot.compareTo(x) == 1) {
//                            a = c;
//                        } else {
//                            result = c;
//                            notInitialised = false;
//                        }
//                    }
//                }
//            } else {
//                boolean resultpowerroottest = powerTestAbove(
//                        x,
//                        result,
//                        rootRoundIfNecessary,
//                        64,
//                        decimalPlaces,
//                        a_RoundingMode);
//                if (resultpowerroottest) {
//                    // Root cannot be found within current precision...
//                    // return BigDecimal.ZERO or BigDecimal.ONE?
//                    int debug = 1;
//                    return BigDecimal.ONE;
//                }
////                BigDecimal resultpowroot = power(
////                        result,
////                        rootRoundIfNecessary,
////                        64,
////                        decimalPlaces,
////                        a_RoundingMode);
////                if (resultpowroot.compareTo(x) == 1) {
////                    // Root cannot be found within current precision...
////                    // return BigDecimal.ZERO or BigDecimal.ONE?
////                    int debug = 1;
////                }
//                a = x.divide(TWO, decimalPlaces, a_RoundingMode);
//                BigDecimal b = new BigDecimal(result.toString());
//                BigDecimal c;
//                //BigDecimal cPowerRoot;
//                boolean cPowerRootTest;
//                BigDecimal aAddb;
//                boolean notInitialised = true;
//                int maxite = 1000;
//                int i = 0;
//                while (notInitialised) {
//                    if (i == maxite) {
//                        notInitialised = false;
//                    }
//                    // Bisect
//                    aAddb = a.add(b);
//                    c = (aAddb).divide(TWO, decimalPlaces, a_RoundingMode);
//                    cPowerRootTest = powerTestAbove(
//                            x,
//                            c,
//                            rootRoundIfNecessary,
//                            64,
//                            decimalPlaces,
//                            a_RoundingMode);
//                    if (cPowerRootTest) {
////                    cpowerroot = power(
////                            c,
////                            rootRoundIfNecessary,
////                            64,
////                            decimalPlaces,
////                            a_RoundingMode);
////                    if (cpowerroot.compareTo(x) == 1) {
//                        a = c;
//                    } else {
//                        //result = c;
//                        notInitialised = false;
//                    }
//                    result = a;
//                    i++;
//                }