Função cosseno retornando valores errados!

Vc deve passar o angulo em radianos.
java.lang.Math.html#cos

flw

Hum…
Eu mudei o código, ficou assim:

(float)Math.cos(Math.toRadians(90));

Mas agora a resposta é:
6.123224E-17

Novamente, diferente de 0!

Pra mim isso é um zero

Mas falando sério, float é um numero do tipo ponto flutuante, que é uma soma de frações. Isso acontece em qualquer linguagem, é comum. Na pratica, quando for imprimir o resultado vc vai ter que formatar, daí a diferença some.

Pois é… Você tem toda razão, o computador não consegue calcular corretamente o coseno de PI/2.
Isto ocorre por 2 motivos:

1. Ele não consegue representar PI/2. O que consegue é uma aproximação de PI/2.
2. O cálculo de Coseno é o resultado de uma série infinita. E eu acho mais prático ele, em algum momento, desistir da conta e devolver um valor aproximado do que somar números ad infinitum.

Ok, mas como posso fazer isso???
usando typecast?

Exato.

As funções trigonométricas, exponenciais, logaritmicas, raiz quadrada e potências são geralmente calculadas numericamente. Seu resultado é aproximado e geralmente é suficientemente bom para tarefas cotidianas.

O calculo pode ser feito pela série numérica infinita de uma função, quando a série converge, os termos de ordem mais alta são de valor cada vez menor e em um dado momento vc não tem precisão (ou nem quer) para lidar com eles, então “simplesmente trunca” (pode ter um termo de correção).

Se vc quer lidar com funções de forma analítica, onde o cos(pi/2) é 0, tens que lidar com algoritmos ou programas especiais. Programas como Mathematica, Maple, etc… acho que existem bibliotecas para java para lidar de problemas matemáticos dessa forma mas eu desconheço.

Se você estiver usando java 1.5 pode fazer algo assim:

Formatter format = new Formatter();
String cosseno = format.format("%+2.4f", Math.cos(Math.toRadians(90));

ou se for direto no console:

System.out.printf(("%+2.4f", Math.cos(Math.toRadians(90));

Isso vai imprimir com 2 digitos antes e 4 digitos depois da virgula.

Mais informações no javadoc da classe Formatter.

Deve ter algum artigo sobre isso em algum lugar, quem souber posta aí…

import java.text.DecimalFormat;
import java.text.NumberFormat;

public class Teste {
	
	public static void main(String args[]) {
		
		NumberFormat n = new DecimalFormat();
		System.out.println(n.format(Math.cos(Math.toRadians(90))));
	}
}

Aqui

Formatter format = new Formatter();
 String cosseno = format.format("%+2.4f", Math.cos(Math.toRadians(90));

fala que não pode converter de Formater to String

e Aqui

System.out.printf(("%+2.4f", Math.cos(Math.toRadians(90));

tb da erro eu não consegui fazer rodar no java 5 mesmo completando o ) que esta faltando

O certo seria

System.out.format("%.2f", Math.cos(Math.toRadians(90)));

Isso deve resolver:

System.out.printf("%2.4f\n", Math.cos(Math.toRadians(90)));

ciczan, testei o que você propôs, mas continua imprimindo 6.123234E-17…
Alguma outra maneira???

Usando Java 1.4

NumberFormat format = new DecimalFormat("#.######");
		System.out.println(format.format(Math.cos(Math.toRadians(90))));

http://javaalmanac.com/egs/java.text/FormatNum.html

6.123234E-17 que eu saiba é zero, para muitos dos efeitos. (É claro que 1/0.0 == +Infinity e 1/6.123234E-17 == 1.633124E+16, mas para o que você quer é zero.

O java 5.0 compila System.out.println(Object args, Oject… args1) ou é System.out.format ? Eu testei e naum funfou

Javadoc nele!

System.out.printf (formato, argumentos…) - imprime uma string formatada, como printf

String.format (formato, argumentos…) - retorna uma string formatada, como sprintf

Valeu pessoal!
Consegui resolver tudo formatando o numero com o:

NumberFormat format = new DecimalFormat("#.######");

Valeu rodrigousp pela ajuda!!!
Estava acostumado com a linguagem C que tem uma função mais simples mas que não apresenta essa precisão cirúrgica que nem a da função cosseno no Java… :lol:
Mas agora está tudo ok, meu cosseno de 90 graus voltou a ser 0!

Abraço!

Este é um código C. Achei esquisito você falar que imprime “0.00000”, mas é porque você deve estar usando “%f” para imprimir suas coisas em C.

O “default” do Java é algo parecido com “%g”.

#define _USE_MATH_DEFINES
#include <math.h>

#define convert_to_radians(x) \
    (x) * (M_PI / 180.0)

main () {
    double d = cos (convert_to_radians (90.0));
    printf ("%f\n", d); // ponto fixo => imprime "0.000000"
    printf ("%e\n", d); // notação científica => imprime "6.123234e-017"
    printf ("%g\n", d); // ponto fixo ou notação científica - depende do número
                        // neste caso, imprime "6.12323e-017"
    // Java usa algo parecido com "%g" em vez de "%f" quando imprime 
    // números de ponto flutuante, sem formatação.                        
}

Detalhe,

Java faz chamadas nativas para as funções do Math.

O thingol, parabéns. Suas respostas estão muito boas!

Se usar o Mustang (Java 6.0) e uma máquina Intel (cujo processador tem algumas instruções que já calculam funções transcendentais, como FSIN, FCOS etc.) então o Sun JIT gera um código semelhante ao seguinte:

if (x está em um intervalo onde o processador é preciso) {
    FCOS;
} else {
    chamar uma biblioteca que efetua o cálculo preciso do coseno;
}

É que o processador é menos preciso que o Java se x estiver fora de um determinado intervalo.