style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

programa que calcula PI a partir de una serie infinita

//ejercicio 5.16 calculo de pi,autor ernesto ortega vásquez

import javax.swing.*;

public class Pi{

        public static void main(String args[]){

                double pi;
                double negativo = 0.0;
                double positivo = 0.0;
                double d = 3.0;
                double d1 = 5.0;

                int contador = 1;
                int contador2 = 1;

                JTextArea areaSalida = new JTextArea(20,20);

                JScrollPane desplazador = new JScrollPane(areaSalida);

                areaSalida.setText("Termino\t" + "Aproximación\n");

                while(contador2 != -1){

                switch(contador){

                        case 1:

                                negativo += 4/d;

                                d += 4.0;

                                contador += 1;

                                break;

                        case 2:

                                positivo += 4/d1;

                                d1 += 4.0;

                                contador -= 1;

                                break;

                        default:

                        JOptionPane.showMessageDialog(null,"Numero incorrecto","error",JOptionPane.INFORMATION_MESSAGE);

                }//fin del switch

                pi = 4.0 - negativo + positivo;

                areaSalida.append(contador2 + "\t" + pi + "\n");

                JOptionPane.showMessageDialog(null,desplazador,"Resultados",JOptionPane.PLAIN_MESSAGE);

                contador2 += 1;

        }//fin del while

        System.exit(0);

}//fin del método main

}//fin de la clase Pi

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

Otra version

Estoy un poco ocioso y me llamó la atención tu programa porque yo lo hice en C hace mucho tiempo... es la manera más lenta que existe de calcular PI, pero interesante. Me tomé la libertad de modificar tu código original para que simplemente se ponga a calcular, sin necesidad de darle OK en cada término. Así puedes ver cómo aumenta la precisión, la cual no siempre es en el orden de los decimales.

import javax.swing.*;

<code>public class Pi {

<code>public static class Calcula implements Runnable {

<code>  private JTextArea text;

<code>  public Calcula(JTextArea area) {
<code>          text = area;
<code>  }

<code>  public void run() {
<code>          double pi;
<code>          double negativo = 0.0;
<code>          double positivo = 0.0;
<code>          double d = 3.0;
<code>          double d1 = 5.0;
<code>          boolean flag = false;
<code>          int term = 1;
<code>          while (true) {

<code>                  if (flag) {
<code>                          negativo += 4/d;
<code>                          d += 4.0;
<code>                  } else {
<code>                          positivo += 4/d1;
<code>                          d1 += 4.0;
<code>                  }
<code>                  flag = !flag;
<code>                  term++;
<code>                  pi = 4.0 - negativo + positivo;
<code>                  //Esto es para evitar que se acabe la memoria
<code>                  if (term % 100000 == 0) {
<code>                          text.setText("Termino\tAproximacion\n");
<code>                  }
<code>                  text.append(String.format("%d\t%.10f\n", term, pi));
<code>          }//fin del while
<code>  }

<code>}

<code>public static void main(String args[]) {

<code>  JTextArea areaSalida = new JTextArea(20, 20);

<code>  JScrollPane desplazador = new JScrollPane(areaSalida);

<code>  areaSalida.setText("Termino\tAproximacion\n");
<code>  areaSalida.setEditable(false);
<code>  areaSalida.setAutoscrolls(true);

<code>  JFrame ventana = new JFrame("PI por aproximaciones sucesivas");
<code>  ventana.getContentPane().add(desplazador);
<code>  ventana.setVisible(true);
<code>  ventana.pack();
<code>  new Thread(new Calcula(areaSalida), "calc").start();

<code>}//fin del método main

<code>}//fin de la clase Pi

Como puedes ver, los cálculos se hacen en un Thread separado, para que el texto se vaya actualizando y puedas interactuar con la ventana. También simplifiqué algunas variables (como contador2 que realmente puede ser un simple boolean).

Given the choice of dancing pigs and security, users will choose dancing pigs, every single time. - Steve Riley

gracias

te agradezco el comentario apenas me estoy iniciando en java, y todos los comentarios son bienvenidos te lo agradezco saludos

otra forma

public static void main(String args[])
{
double termino1;
double termino2;
double suma = 4;
int suma1 = 1;
int i = 3;
int j = 5;

System.out.println("\tTérmino\tValor\n");

System.out.printf("\t1\t%f\n",suma);

System.out.println();

for(int k = 1; k <= 100; k++)
{

termino1 = (double) 4/i;
termino2 = (double) 4/j;

if(termino2 < termino1)
{
suma = suma - termino1;

System.out.println("\t"+(suma1+=1)+"\t"+suma+"\n");

i+=4;

if(suma > termino1)
{
suma = suma + termino2;

System.out.println("\t"+(suma1+=1)+"\t"+suma+"\n");

j+=4;
}
}

}
}//Estoy empezando el tema de la programación en java y me llamo la atención este foro ya que precisamente estoy aprendiendo de la septima edición del libro JAVA Como programar de Deitel y en uno de los ejercicios estaba precisamente este... aquí le dejo el código que implemente para resolverlo

Imagen de benek

El código se ve mejor si lo

El código se ve mejor si lo encierras entre las etiquetas <code> y </code>

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">