* @param decimalPlaces
     * @param a_RoundingMode
     * @return The rootRoundIfNecessary rootRoundIfNecessary of x to
     * decimalPlaces precision.
     */
    private static BigDecimal rootLessThanOne(
            BigDecimal x,
            BigInteger root,
            //Generic_BigDecimal a_Generic_BigDecimal,
            int decimalPlaces,
            RoundingMode a_RoundingMode) {
        BigDecimal epsilon_BigDecimal =
                new BigDecimal(BigInteger.ONE, decimalPlaces);
        //BigDecimal comparator = BigDecimal.ONE.subtract(epsilon_BigDecimal);
//        // Check there is a rootRoundIfNecessary in the precision and return 1 if not
//        boolean powerTest = powerTestBelow(
//                epsilon_BigDecimal,//comparator,
//                x,
//                rootRoundIfNecessary,
//                256,
//                decimalPlaces,
//                a_RoundingMode);
//        if (powerTest) {
//            System.out.println("No rootRoundIfNecessary in the precision... ");
//            return BigDecimal.ONE;
//        }

        BigDecimal result;// = BigDecimal.ONE;
        if (x.scale() - x.precision() > decimalPlaces) {
            result = BigDecimal.ONE.subtract(epsilon_BigDecimal);
        } else {
            int rootInitialisationMaxite = 10;
            //int rootInitialisationMaxite = x.scale();
            result = rootInitialisationLessThanOne(
                    x,
                    root,
                    epsilon_BigDecimal,
                    rootInitialisationMaxite,
                    decimalPlaces,
                    a_RoundingMode);
        }
        //result = new BigDecimal(x.add(epsilon_BigDecimal).toString());
        int newtonRaphsonMaxite = decimalPlaces + x.scale();
        return newtonRaphsonLessThanOne(
                x,
                result,
                root,
                epsilon_BigDecimal,
                newtonRaphsonMaxite,
                //a_Generic_BigDecimal,
                decimalPlaces,
                a_RoundingMode);

// For rootRoundIfNecessary is large this takes too long 
//        BigDecimal tenPowerRoot = power(
//                BigDecimal.TEN,
//                rootRoundIfNecessary,
//                256,
//                0,
//                RoundingMode.UNNECESSARY);
//        BigDecimal xunscaled = multiply(
//                x,
//                tenPowerRoot,
//                0,
//                RoundingMode.UNNECESSARY);
//        BigDecimal result0 = rootRoundIfNecessary(
//                xunscaled,
//                rootRoundIfNecessary,
//                decimalPlaces + 1,
//                a_RoundingMode);
//        BigDecimal result = divide(
//                result0,
//                BigDecimal.TEN,
//                decimalPlaces + 1,
//                a_RoundingMode);
//        return result;
    }