Para hoy día de π, una calculadora de decimales de este trascendente e irracional número del que dependemos yo diría que para todo con el fantástico lenguaje Kotlin. 

El método utilizado será el método de Gauss-Legendre. Comenzamos con unos datos iniciales, se realizan una serie de operaciones y con los datos obtenidos efectuamos el cálculo. El que quiera profundizar, os dejo este enlace de Gaussianos.

Datos iniciales

operaciones por iteración

Aproximación de π

Lo que si tendremos en cuenta para obtener muchos, muchos decimales es usar la clase BigDecimal de java.math y el uso de una función recursiva. El código…

class  PiGaussLegendre(val decimals:Int){

    val ZERO = BigDecimal(0)
    val ONE = BigDecimal(1)
    val TWO = BigDecimal(2)
    val FOUR = BigDecimal(4)
    val PRECISION = BigDecimal("1E-10000")

    var an: BigDecimal = ONE;
    var bn: BigDecimal = ONE.divide(sqrt(TWO,decimals),decimals,RoundingMode.HALF_UP)
    var tn:BigDecimal = ONE.divide(FOUR)
    var pn:BigDecimal = ONE

    init{
        println(calc(an, bn, tn, pn))
    }

    fun calc(_an:BigDecimal, _bn:BigDecimal, _tn:BigDecimal, _pn:BigDecimal):BigDecimal{

        val diff=_an.subtract(_bn).abs()

        while (_an.subtract(_bn).abs().compareTo(PRECISION)>0 ){

            an= _an.add (_bn).divide(TWO,decimals, RoundingMode.HALF_UP)
            bn = sqrt(_an.multiply(_bn),decimals)
            tn = _tn.subtract(_pn.multiply(_an.subtract(an).pow(2)))
            pn = TWO.multiply(_pn)
            return calc(an, bn,tn,pn)
        }
        return an.add(bn).pow(2).divide(FOUR.multiply(tn),decimals,RoundingMode.HALF_UP)
    }

    override fun toString() = calc(an,bn,tn,pn).toString()


    fun sqrt(value: BigDecimal, scale: Int): BigDecimal {
        var x0 = BigDecimal("0")
        var x1 = BigDecimal(Math.sqrt(value.toDouble()))
        while (x0 != x1) {
            x0 = x1
            x1 = value.divide(x0, scale, RoundingMode.HALF_UP)
            x1 = x1.add(x0)
            x1 = x1.divide(TWO, scale, RoundingMode.HALF_UP)
        }
        return x1
    }

    fun BigDecimal.pow (exp:Int){
        return (0..exp).forEach { _ -> this.multiply(this) }
    }

y con un simple

PiGaussLegendre(1000)

obtenemos una aproximación (muy aproximada) de 1000 decimales ya que este método obtiene en cada iteración el doble de dígitos exactos que en la iteración anterior.

Feliz día de π!!