Boa tarde pessoal!
vim pedir a ajuda de vcs… tenho um exercício da faculdade para estudo… segue abaixo o enunciado:
[quote]Criar um conjunto de códigos: Geral e Teste (contendo main), portanto 2 códigos, para entrada de dados via teclado ou JOption, e cálculo dos valores de seno, cosseno, exponencial e logaritmo de 4 números, separados do menor para o maior e os ímpares do pares.
Roteiro para a elaboração:
1- Escrever 2 códigos, um com classe pública contendo os métodos de leitura, manipulação e publicação dos resultados, outro contendo a classe teste com o método de acesso main.
2- A entrada deve ser feita para 4 valores de números, inteiro ou real, duas bases para a exponencial e loratitmo e a precisão do cálculo, a qual vai definir a parada do laço.
3- Estes valores devem ser calculados via série de potências, por ex. na base natural a exponencial de x é:
e[color=blue]x[/color]=1 + x /(1)+ x[color=blue]2[/color] /(1x2)+ x[color=blue]3[/color] /(1x2x3)+…
PS: o que está em azul e negrito significa elevado, ou seja, (e[color=blue]x[/color], significa q é: e elevado a x
4- A saída deve ser dada na área de trabalho como:
“seno de 3,141516… é 0,0001”
“o log de 32 na base 2 é 5”.[/quote]
Bom pessoal é isso aí… alguem sabe como fazer isso? nem sei como começar…
peço a ajuda de vcs… ja deixo meu muito obrigado…
Parece que o professor não quer que você use Math.sin, Math.cos, Math.exp ou Math.log.
(A propósito, é bom saber que essas funções existem para você poder conferir se está calculando as séries corretamente.)
Para calcular o logaritmo natural, veja em
Exemplo:
/**
* Esta classe calcula o logaritmo natural usando a série
* ln(z) = 2 * somatória (n=0 -> infinito) de 1/(2n+1) * ((z-1)/(z+1)) elevado a 2n+1.
* Veja http://en.wikipedia.org/wiki/Logarithm#Series_for_calculating_the_natural_logarithm
* (a segunda série dada).
* Este programa requer Java 6.0 devido ao uso de getExponent e scalb.
*/
class LogaritmoNatural {
// Esta função normaliza para um número entre 1 e 2.
private static double normalize (double z) {
int exp = Math.getExponent (z);
return Math.scalb (z, -exp);
}
/**
* Note que este cálculo é um pouco menos preciso que o definido pelo Java,
* principalmente porque estamos somando os termos maiores primeiro, em vez de somar
* os termos menores primeiro.
* Fica como exercício somar os termos menores primeiro.
* (Dica: note que normalmente não é necessário somar mais que 16 termos, portanto
* seria possível usar um array de 16 posições para armazenar os termos menores).
*/
public static double log (double z) {
// Primeiramente iremos efetuar uma normalização do número
// de modo que ele fique entre 1 e 2.
double Z = normalize (z);
double x = (Z - 1) / (Z + 1);
double x_2n1 = x;
double sum = 0;
double previousSum = 0;
int _2n_1 = 1;
do {
previousSum = sum;
sum += x_2n1 / _2n_1;
x_2n1 = x * x * x_2n1;
_2n_1 += 2;
} while (Math.abs ((sum - previousSum ) / sum) > 1E-16);
// Agora vamos corrigir de acordo com o logaritmo natural de 2 do número original.
return Math.getExponent (z) * 0.69314718055994530941723212145818 + (2 * sum);
}
public static void main(String[] args) {
System.out.println (log (1.2e+23));
System.out.println (log (1/1.2e+23));
for (int i = 1; i <= 100; ++i) {
System.out.println (i + ":" + Math.abs (log(i) - Math.log(i)));
}
}
}