Arquivo Discussoes de Programacao e Tecnologia 
To fazendo um programa que faz o seguinte : pega os coeficientes e os expoentes que sao dados como entrada. Depois ele tem que gerar algo do tipo : P(x) = x3 + 3x2 - 7x + 6
x3 = x ao cubo
x2 = x ao quadrado
Depois de gerar essa equacao gostaria de armazenar ela em alguma estrutura de dados de tal forma que quando quissesse o valor de P(5), por exemplo , bastaria passar o valor 5 para essa estruturade dados.
Valeu !!!
double cubo(double i) {
return i * i * i;
}
double quadrado(double i) {
return i * i;
}
como em Java não existe struct vamos substitui-las por classes… segue resolução para o seu problema…
final class Equacao{
static double calcula(int x){
return (Math.pow(x,3) + 3 * Math.pow(x,2) - 7 * x + 6);
}
}
public class Teste{
public static void main(String []arr){
double x;
x = Equacao.calcula(10);
System.out.println(x);
}
}
espero que ajude…
Faz um array de double (ou int, se quiser essa restrição), para guardar os coeficientes de x, onde a posição do coeficiente equivale ao expoente do x.
No seu exemplo, teríamos:
a[0]=6 ; a[1]=-7 ; a[2]=3 ; a[3]=1
Se não quiser limite no grau da sua equação, pode “limitar” bem alto, tipo 20, que na prática não deverá impor limite nenhum.
Daí faz um método:
double P(double x) {
double temp=0;
for (int i=0 ; i<a.length ; i++)
temp += x * (a[i]^i);
return temp;
}
O método ^ não existe apra exponenciação, mas isso vc substitui na hora de codificar direito.
uma forma bastante eficaz de armazenar isso seria em um vetor (array), mas isto se voce souber qual o expoente maximo… uma equaçao
5x4 + 3x2 + 10
poderia ser representada no array V da seguinte forma:
int V = new int[5];
V[0] = 10;
V[1] = 0;
V[2] = 3;
V[3] = 0;
V[4] = 5;
ou seja, V[i] é o coeficiente de x^i.
no caso de vc nao saber o grau maximo do polimio e precisar de uma estrutura mais maleavel quanto a isso, seria legal usar uma Lista Ligada (ou Lista Encadeada, como preferir) de forma análoga.
Só um comentário adicional:
Para manipular polinômios no computador, seu algoritmo fica mais eficiente se, em vez de você implementar algo como:
a[0] + a[1] * x + a[2] * x^2 + a[3] * x^3 + a[4] * x^4,
para um polinômio de grau 4, o fizer como:
a[0] + x * ( a[1] + x * ( a[2] + x * ( a[3] + x * a[4] ) ) ),
ou seja, fatorando em x onde for possível. Agora deixo para os outros generalizar o algoritmo para um polinômio de grau n qualquer.