Bueno he de hacer un ejercicio con java, del cual lo que no entiendo es el enunciado, nunca se me han dado bien las matematicas, asique no pido que me deis el problema resuelto, quiero que me digais que significa el enunciado y que camino seguir. Gracias al que me ayude.
El enunciado del problema al tener formulas no queda bien escrito, asique os lo cuelgo aqui:
Una cosa es ayudarte y otra hacer el ejercicio ¬¬ xD.
No es mas que un bucle sin mas y admite como parametros de entrada el numero y la cota de error epsilon.
Si no he entendido mal, eso se puede hacer una función pasandole el valor X sub i la qual te devolverá un valor X sub i+1 ese valor lo volverás a pasar a la misma función, y así hasta que los dos últimos valores tengan una diferencia muy pequeña (epsilon)
epsilon = 0.2;
x = newton(7);
x1 = newton(x)
while (x-x1 > epsilon)
{
x = newton(x1);
x1 = newton(x);
}
supongo que más o menos sera así, o a lo mejor lo que quieren es q lo hagáis de manera recursiva xD
#2 No, no quiero el problema resuelto, porque controlo el como programar, lo que no se es en que consiste el enunciado del problema, como va lo de newton y eso, ya dije, las matematicas no son mi amigo...
He encontrado en c el programa, alguien me ayuda a pasarlo a java?
#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<iomanip.h>
void main()
{
int n,A,aprox,neww;
float aproxnueva,error,prec,pdeceada,apant;
A:
cout<<endl;
cout<<\" ************************************************************************\"<<endl;
cout<<\" INGRESE EL NUMERO PARA CALCULAR SU APROXIMACION A SU RAIZ CUADRADA:\";
cin>>n;
cout<<\" INGRESE PRESICION DECEADA:\" <<endl;
cout<<\" ************************************************************************\"<<endl;
gotoxy(31,4);
cin>>pdeceada;
cout<<endl<<endl;
while(n<=0)//ciclo de validacion de el numero dado por el usuario para realizar los calculos
{ cout<<\" ERROR en el numero a evaluar:INGRESE SOLO NUMEROS POSITIVOS,INGRESELO DE NUEVO:\";
cin>>n;
cout<<endl;
}
while(pdeceada<0)//ciclo de validacion de el numero dado por el usuario para realizar los calculos
{ cout<<\" ERROR en la aproximacion:INGRESE SOLO NUMEROS POSITIVOS,INGRESE LA PRESICION:\";
cin>>pdeceada;
cout<<endl;
}
apant=n;//apant es la aproximacion anterior.
aproxnueva=n/2.0; //aproxnueva es la primer aproximacion a la raiz del numero dado por el usuario.
cout<<\" \"<<\"1 \"<<\"LA APROXIMACION ES: \";
printf(\"%10.9f\",aproxnueva);cout<<endl;
aprox=2; //aprox es un contador que almacena el numero de aproximaciones calculadas.
do //este ciclo controla el numero de aproximaciones que se realizaran cuyo valor debe de ser
{
error=0;
apant=aproxnueva; //diferente a la precision deceada para que continue, haste que sea igual.
aproxnueva=(0.5(apant+n/apant));
cout<<\" \"<<aprox<<\" \"<<\"LA APROXIMACION ES: \";
printf(\"%10.9f\",aproxnueva);cout<<endl;// imprime la aproximacion con 7 dijitos despues del punto.
aprox++;
error=aproxnueva-apant;
if (error<0)
error=-1error;
}while(error>=pdeceada); //el error de aproximacion debe de ser mayor o
cout<<endl; //igual a la precision deceada para que continue con el ciclo
cout<<\" ************************************************************************\"<<endl;
cout<<\"SI DECEA CALCULAR LA APROXIMACION DE OTRO NUMERO INGRESE (1) DE LO CONTRARIO (0)\";
cin>>neww;
if (neww==1){
clrscr();
goto A;
}
getch();
}
#5, ¿pero no dices que controlas el como programar?
PD: Un código fuente en hoygan, la madre del amor hermoso xD.
PPD: Básicamente es que tienes que aplicar la fórmula de abajo tantas veces hasta que la diferencia entre dos iteraciones seguidas sea menor que el epsilon. En cada iteración debes usar el valor obtenido en la anterior, empezando con A/2.
Por cierto, si no sabes leer ecuaciones tan sencillas como estás vas a tener un problema en el futuro.
#7 claro, c y java son totalmente diferentes
PD: véase ironia
edit: un apunte... es c++ y encima no utiliza iostream sino iostream.h ... vivimos anclados en el pasado! Bueno ahora que me paro a leer el codigo... vaya mierda has encontrado dios santo, usando printf? hola? en fin... la gente hace las cosas de la peor manera posible
Osea que debo ir calculando terminos segun la formula dada hasta que la diferencia entre el termino anterior calculado y el nuevo sea menor. ¿Que lo hago con un while y un sumador?
package Main;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) {
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));double A, X, Y, Z;
A = Integer.parseInt(entrada.readLine());
X = A / 2;
Y = 0.5 * ( X + (A/X));
do {
if ((Y-X) < 0.1) {
System.out.println (+ Y);} else {
Z = 0.5 * ( Y + (A/Y));}
if ((Z-Y) < 0.1) {
System.out.println (+ Z);}
} while (Z==Y);
}
}
Esto es, no se si esta bien
Dios ,en el codigo de C hay un goto !!!!!!!!!!!!! para simular un bucle, madre del amor hermoso !
Xj = A / 2;
Xj_1 = 0.5 * ( Xj + (A/Xj));
// Xj e Xj_1 son aproximaciones contiguas.
while ( (Xj_1 -Xj ) > Epsilon ) { // mq la diferencia sea mayor que el error minimo desado.
Xj = Xj_1;
Xj_1 = 0.5 * ( Xj_1 + (A/Xj_1));
}
System.out.println ("Solucion" + Xj + " Error : " + (Xj_1 - Xj) + "\n");