Método de aproximación a PI/4 mediante programación

Cateto x:
N sumas:
Altura incial triangulo :
Altura final triangulo :
Aproximacion PI:
PI exacto : 3.14159265358979323846...

Cálculo con javascript  Descargar javascript 

Método de aproximación al número PI/4  a partir de sumas finitas de hipotenusas cuyos vértices  recorren el perímetro de cuarto de circunferencia, realizadas mediante programación.

El número de hipotenusas en la suma es igual a la longitud del intervalo finito escogido, el cateto del eje x es igual al inverso de la longitud del intervalo.

La aproximación a PI/4 no se comporta como límite, cuando el intervalo se hace muy grande el resultado tiende a hacerse inferior a PI/4. Además algunos intervalos no funcionan como 1/500, 1/50, 1/200 ,1/20 no son válidos;

El resultado más próximo se da según la variable y quede más próxima a 0 en orden de 1^-7

El cateto x está determinado por el intervalo, su resultado de sumas + radio siempre es próximo a 2 del orden de 1.9999999999994458

Si el intervalo es de 8  000 -à Hay una suma de  8 000 hipotenusas las cuales se forman con el cateto horizontal x de una longitud igual a (1/8 000), la longitud del cateto vertical y es variable. En el método el cateto y es la variable para despejar aplicando sucesivamente el teorema de Pitágoras.

Para el intervalo de 8000 como tipo de dato doublé en java da un resultado de PI: 3.141590137127779

X: 1.9999999999994458

Y:  1.052827938357335E-6

Para desarrollar el método empleo el concepto de arco capaz de semicircunferencia, esto es la hipotenusa del triangulo es el diámetro de la circunferencia y el vértice de unión de los dos catetos es sobre un punto de la semicircunferencia, los dos catetos juntan  sus vértices  en un punto del perímetro de la semicircunferencia la cual recorren un cuarto de circunferencia empezado en x = radio,  termina en (x cerca de diámetro), en todo el recorrido los dos catetos forman un ángulo de 90 grados, la altura y empieza en y = radio, termina en (y cerca de 0).

Las hipotenusas se calculan en la diferencia de posición entre dos vértices consecutivos del triángulo rectángulo que recorre el cuarto de circunferencia.

Diámetro = Ø

Diferencia de x = Δx

Hipotenusa = H

Δx = 1/(intervalo)

Diferencia de y = Δy

ρ = (Ø – (x+Δx))

y₀ =  Ø/2

2y²₁ + x² + ρ² = ز

Δy₀ = y₀ – y₁   ,  Δy_n = y_n-1 - y_n

n = intervalo

H² =  Δx² + Δy²

ΣHⁿ₀ ≈ ϖ/4

SOBRE EL CÓDIGO JAVA

Si se pone como intervalo 8000 el inverso es finito y no da problema, en cambio para otro número como 9000  el inverso que calcula el programa da muchas cifras con formato científico, esto luego da errores en el cómputo de las operaciones, por esto para calcular delta de x lo hago con un método que limito el número de decimales para el valor de delta x.

La circunferencia del código es de radio = 1 , luego en el resultado de PI/4 para que sea PI se multiplica por 2, si la circunferencia fuese de radio = 1/2 se multiplicaría por 4.

CÓDIGO JAVA

package pi_cuartos;

public class Pi_cuartos {
   
    public double metodo_dividir(double nn, int t) {
        double    nn2=0;
        String numer =Double.toString(nn);
       
       
        if(t==1) {
        String decimales="1";
       
        for(int y=0; y<numer.length()-2; y++) {
            decimales=decimales+"0";
            }
    nn2 = Double.valueOf(decimales);
        }

                                        if(t==0) {
                                            if(numer.length()>=6) {
                                            numer=numer.substring(0,numer.length()-5);
                                            }else {
                                            numer=numer.substring(0,numer.length());   
                                            }
                                            nn2 = Double.valueOf(numer);
                                        }
        return nn2;
    }

public static void main(String [] args) {
   
                                            Pi_cuartos mi_division =new Pi_cuartos();
    double x=1, y=1, z, delta_x, delta_y=0, ro, arco=0, mi_pi_cuartos=0;
    double  mi_alfa=0;
                                            z = x;
    double particion_intervalo = 88888888;
    double div = mi_division.metodo_dividir(particion_intervalo,1);
    double resto = div/particion_intervalo;
                                            resto = mi_division.metodo_dividir(resto,0);
                                            delta_x=(1/div)*resto;
                                            ro = 2-(z + delta_x);
    int ciclos=(int)particion_intervalo;

                                       for(int i=0; i<ciclos; i++) {
                                          mi_alfa = 4 - (ro*ro) - ((x+delta_x)*(x+delta_x));
                                          mi_alfa=Math.sqrt(mi_alfa/2);
                                          delta_y=y-mi_alfa;
                                          y=mi_alfa;
                                          x=x+delta_x;
                                          arco=Math.sqrt((delta_x*delta_x)+(delta_y*delta_y));
                                          mi_pi_cuartos = mi_pi_cuartos + arco;
                                          z = x  ;
                                          ro = 2-(z + delta_x);
                                       }
     
      System.out.println("  y: "+y);
      System.out.println("  x: "+x);
      System.out.println(" pi:  "+mi_pi_cuartos*2);
             
}       
}