GUJ Discussões   :   últimos tópicos   |   categorias   |   GUJ Respostas

Parabola

tnho este metodo para calcular as raizes de uma parabola e devolver-me um vector com eles la dentro organizados em ordem decrescente…

Infelizmente para certos imputs nao me retorna o valor correcto…
O tipo double é assim tao manhoso???

	public double[] zeros() {

		double[] xpto = new double[2];

		// assert (delta >= 0);
		double x1;
		double x2;

		double delta = b * b - 4 * a * c;
		if (delta == 0) {
			xpto[0] = x1 = -b / 2 * a;
			xpto[1] = x2 = -b / 2 * a;

		} 
		else if (delta > 0) {
			x1 = (-b + Math.sqrt(delta)) / 2 * a;
			x2 = (-b - Math.sqrt(delta)) / 2 * a;

			if (x1 > x2) {
				xpto[0] = x2;
				xpto[1] = x1;

			} else if (x1 < x2) {
				xpto[1] = x2;
				xpto[0] = x1;

			}

		}
		else if (delta < 0) {
			xpto = null;
		}
		return xpto;
	}

a main dela é:

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
	
		Scanner in = new Scanner(System.in);
		String aux;
		String[] xp;
		double[] xpcabra;

		double a, b, c;
		while (in.hasNextLine()) {
			if (!in.hasNextLine())
				break;
			aux = in.nextLine();
			xp = aux.split(" ");
			a = Double.parseDouble(xp[0]);
			b = Double.parseDouble(xp[1]);
			c = Double.parseDouble(xp[2]);
			Parabola p = new Parabola(a, b, c);
			xpcabra = p.zeros();
			if (xpcabra == null) {
				System.out.println("Nao tem zeros");
			} else {
				for (int i = 0; i < xpcabra.length; i++) {
					System.out.printf("%.4f ", toZero(xpcabra[i]));
				}

			}

		}
	}

para uns valores da certo…
mas para uma parabola com os coeficientes

3 -100 423

ou

-2 100 14

prega-me partida…

Tente colocar parênteses entre os (2 * a).

Geralmente, as operações de divisão geram imprecisão.
Então é melhor fazê-las antes de multiplicar, não depois (para não multiplicar a imprecisão).

valeu vini…

era ai onde estava o problema…Obrigado…

Já parou para pensar pq os números de ponto flutuante são imprecisos em potências diferentes de 2?

Um número é impreciso pq, depois da vírgula, cada bit ligado representa 2^-n, onde n é o número da casa contada da direita pra esquerda, a partir do 1. Assim, o número 2,5 seria representado em binário por:

2 = 10
0,5 = 0.1
2,5 = 10.1

Agora, considere o esforço de escrever uma fração que não é mútipla de 2, como 0,3, usando potências de 2:

A primeira potência que usaríamos poderia ser 1/4, que é 0,25.
Para melhorar a precisão, podemos somar 1/32, que é 0,03125.
Obteríamos então, 0,28125. E se quiséssemos aumentar ainda mais a precisão?
Daria para somar 1/64, que é 0,015625, e obteríamos 0,296875…

Nosso número já está assim:
0,3 = 0,010011

Poderíamos continuar somando com divisores multiplos de 2 cada vez maiores, mas difícilmente chegaríamos em 0,3. Esse comportamento assintótico é extremamente inconveniente e, para uma base como 2, extremamente frequente.

Com isso, vemos que o sistema de base 2 é muitíssimo pobre para representar números que não podem ser obtidos por frações de 2. E daí que vem essa imprecisão toda. O que o hardware faz é aumentar (muito) o número de bits quando contas envolvendo floats são feitas. Isso atenua o problema, mas não o resolve. Pequenas dicas de programação (como multiplicar antes de dividir, quando possível) também ajudam.

impressionante…k meu professor nunca falou nisso… :shock:

[quote=ViniGodoy]
Com isso, vemos que o sistema de base 2 é muitíssimo pobre para representar números que não podem ser obtidos por frações de 2. E daí que vem essa imprecisão toda. O que o hardware faz é aumentar (muito) o número de bits quando contas envolvendo floats são feitas. Isso atenua o problema, mas não o resolve. Pequenas dicas de programação (como multiplicar antes de dividir, quando possível) também ajudam. E foi isso que resolveu seu caso. :)[/quote]

Como dizia meu professor, não teríamos problemas com a base 2 se tivéssemos 4 dedos nas mãos e nos pés, como é o caso daqueles personagens de desenhos animados da Disney (Mickey, Pateta etc.). É que aí provavelmente iríamos usar base 4, 8 (duas mãos) ou 16 (mãos e pés). A base 16 seria particularmente interessante.

A humanidade já trabalhou com base 16. No passado, os babilônicos usavam os nós dos dedos (e as pontas) para fazer contagem de ovelhas e o polegar servia para saber onde a contagem estava. Alguns matemáticos usavam até mesmo uma notação com 16 símbolos, sendo o primeiro símbolo o número 1 e o último o 16.

//