*/
    public BigDecimal get_PI() {
        if (_PI == null) {
            init_PI();
        }
        return _PI;
    }

//    /**
//     * Returns _PI rounded to decimalPlaces decimal places. Only supported for
//     * 0 < decimal places < 10001.
//     */
//    public BigDecimal get_PI(
//            int decimalPlaces) {
//        if (decimalPlaces < 10000) {
//            return round(get_PI(), decimalPlaces, get_RoundingMode());
//        } else {
//            throw new UnsupportedOperationException();
//        }
//    }
//    /**
//     * Returns _PI rounded to decimalPlaces decimal places.
//     */
//    @Deprecated
//    private BigDecimal getPI(
//            int decimalPlaces) {
//        if (decimalPlaces < 10000) {
//            return round(get_PI(), decimalPlaces, get_RoundingMode());
//        } else {
//            throw new UnsupportedOperationException();
////        _PI = BigDecimal.ZERO;
////        BigDecimal e = getE(decimalPlaces);
////        int maxite = 10;
////
////        // David Chudnovsky and Gregory Chudnovsky:
////        // Sum for all k > 0 1/(12((-1^k(6k)!(13591409+54514013k))/(3k)!((k!)^3)640320^(3k+3/2)))
////        // Sum for all k > 0 1/(12((-1^k(6k)!d)/(3k!)((k!)^3)640320^(3k+3/2)))
////        if (_Generic_BigInteger == null) {
////            init_Factorial_Generic_BigInteger(maxite);
////        } else {
////            _Generic_BigInteger.factorial(maxite);
////        }
////        BigDecimal Three = new BigDecimal("3");
////        BigDecimal Twelve = new BigDecimal("12");
////        BigInteger a = BigInteger.valueOf(13591409);
////        BigInteger b = BigInteger.valueOf(54514013);
////        BigDecimal c = BigDecimal.valueOf(640320);
////        BigDecimal cToh;
////        BigInteger d;
////
////        BigDecimal onePointFive = new BigDecimal("1.5");
////        BigDecimal h;
////        BigInteger k_BigInteger;
////        BigDecimal k_BigDecimal;
////        BigInteger kfactorial;
////        BigInteger kfactorialcubed;
////        BigInteger sixkfactorial;
////        BigInteger sixkfactoriald;
////        BigInteger threekfactorial;
////        BigDecimal numerator;
////        BigDecimal denominator;
////        BigDecimal divisionTimeTwelve;
////        // Sum for all k > 0 1/(12((-1^k(6k)!d)/(3k)!((k!)^3)640320^h))
////        // Sum for all k > 0 1/(12((-1^k(6k)!d)/(3k)!((k!)^3)c^h))
////        // Sum for all k > 0 1/(12((-1^k(6k)!d)/denominator))
////        boolean negate = false;
////        for (int k_int = 0; k_int < maxite; k_int++) {
////            k_BigInteger = BigInteger.valueOf(k_int);
////            k_BigDecimal = BigDecimal.valueOf(k_int);
////            kfactorial = _Generic_BigInteger.factorial(k_int);
////            sixkfactorial = _Generic_BigInteger.factorial(k_int * 6);
////            threekfactorial = _Generic_BigInteger.factorial(k_int * 3);
////            kfactorialcubed = kfactorial.pow(3);
////            d = a.add(b.multiply(k_BigInteger));
////            h = (Three.multiply(k_BigDecimal)).add(onePointFive);
////            cToh = power(
////                    c,
////                    h,
////                    e,
////                    this,
////                    decimalPlaces,
////                    _RoundingMode);
////            denominator = new BigDecimal(threekfactorial.multiply(kfactorialcubed)).multiply(cToh);
////            numerator = new BigDecimal(sixkfactorial.multiply(d));
////            if (negate) {
////                numerator = numerator.negate();
////                negate = false;
////            } else {
////                negate = true;
////            }
////            divisionTimeTwelve = (numerator.multiply(Twelve)).divide(
////                    denominator, decimalPlaces, _RoundingMode);
////            _PI = _PI.add(divisionTimeTwelve);
////            System.out.println("k_int " + k_int + ", _PI " + _PI);
////        }
////        _PI = new BigDecimal("4");
////        int safeDecimalPlaces = decimalPlaces + 3;
////        // This can be set higher, upto nearly Long.MAX_VALUE before BigInteger
////        // iteration needs to takeover...
////        maxite = Integer.MAX_VALUE;
////        //maxite = decimalPlaces * 2;
////        //maxite = safeDecimalPlaces;
////        BigDecimal tollerance = new BigDecimal(
////                BigInteger.ONE, safeDecimalPlaces);
////        BigDecimal Four = BigDecimal.valueOf(4);
////        BigDecimal fraction;
////        boolean add = false;
//////        for (long denominator_long = 3; denominator_long < maxite; denominator_long+=4) {
//////            fraction = Four.divide(
//////                    BigDecimal.valueOf(denominator_int),
//////                    safeDecimalPlaces,
//////                    _RoundingMode);
//////            if (fraction.compareTo(tollerance) == -1) {
//////                break;
//////            }
//////            _PI = _PI.subtract(fraction);
//////        }
//////        for (long denominator_long = 5; denominator_long < maxite; denominator_long+=4) {
//////            fraction = Four.divide(
//////                    BigDecimal.valueOf(denominator_int),
//////                    safeDecimalPlaces,
//////                    _RoundingMode);
//////            if (fraction.compareTo(tollerance) == -1) {
//////                break;
//////            }
//////                _PI = _PI.add(fraction);
//////        }
////        for (long denominator_long = 3;
////                denominator_long < maxite;
////                denominator_long += 2) {
////            fraction = Four.divide(
////                    BigDecimal.valueOf(denominator_long),
////                    safeDecimalPlaces,
////                    _RoundingMode);
////            if (fraction.compareTo(tollerance) == -1) {
////                break;
////            }
////            if (add) {
////                _PI = _PI.add(fraction);
////                add = false;
////            } else {
////                _PI = _PI.subtract(fraction);
////                add = true;
////            }
////            if (denominator_long % 10000000 == 3) {
////                System.out.println("denominator_long " + denominator_long + ", _PI " + _PI);
////            }
////        }
////        _PI = round(_PI, decimalPlaces, _RoundingMode);
////        return _PI;
//        }
//    }