Quero fazer um algoritmo q calcule derivadas e integrais em C++!&#

[sauron_rj 0]

Galera, preciso fazer um algoritmo que calcule derivadas e outro que calcule integrais de polinomios! será q alguem aki pode me ajudar?? Ah, em C++! ou se alguem ja viu esse problema em outro lugar......manda o link....preciso mtoooooo dessa ajuda!valeu_\|/_

[Palc 0]

beleza sauron_rj,

 

Vou passar a idéia depois você implementa em C++ ;)

 

Como é para polinômios fica fácil, relembrando a derivada e integral de alguns polinômios mais simples, só para fixar as idéias:

 

1) Polinômio: Ax + B

1.1) Derivada: A

1.2) Integral: (A/2).x^2 + Bx + C

 

2) Polinômio: Ax^2 + Bx + C

2.1) Derivada: 2A.x + B

2.2) Integral: (A/3).x^3 + (B/2).x^2 + Cx + D

 

Generalizando,

3) Polinômio: A[n].x^n + A[n-1].x^(n-1) + A[n-2].x^(n-2) + ... + A[2].x^2 + A[1].x + A[0]

3.1) Derivada: A[n].n.x^(n-1) + A[n-1].(n-1).x^(n-2) + A[n-2].(n-2).x^(n-3) + ... + A[2].2.x + A[1].x + 0

3.2) Integral: A[n]/(n+1).x^(n+1) + A[n-1]/n.x^n + A[n-2]/(n-1).x^(n-1) + ... + A[2]/3.x^3 + A[1]/2.x^2 + A[0].x + K (K=qualquer valor)

 

onde

A[ ] é o vetor de entrada

n é o grau do polinômio

A é o valor do coeficiente do polinômio na potência de x^i

 

 

Observe que você deve criar vetores (POLI, DERI e INTE) contendo os coeficientes dos polinômios de entrada, derivada e integral, respectivamente. Onde cada posição no vetor corresponde ao expoente em 'x', os polinômios para os exemplos acima ficam assim:

1) Polinômio: Ax + B .... Vetor: POLI[1] = A ; POLI[0] = B

1.1) Derivada: A .... Vetor: DERI[1] = 1.A = A ; DERI[0] = 0.B = 0

1.2) Integral: (A/2).x^2 + Bx + C .... Vetor: INTE[2] = A/2 ; INTE[1] = B ; INTE[0] = C (qualquer valor)

 

2) Polinômio: Ax^2 + Bx + C .... Vetor: POLI[2] = A ; POLI[1] = B ; POLI[0] = C

2.1) Derivada: 2A.x + B .... Vetor: DERI[1]= 2.A ; DERI[0] = B

2.2) Integral: (A/3).x^3 + (B/2).x^2 + Cx + D .... Vetor: INTE[3]=A/3 ; INTE[2]=B/2 ; INTE[1]=C ; INTE[0] = D (qualquer valor)

 

Fica fácil ver que dado o vetor POLI basta calcular os vetores DERI e INTE fazendo multiplicações entre o índice do vetor e o valor do vetor POLI. Isto pode ser facilmente executado dentro de um laço FOR-NEXT.

 

E a seqüência lógica fica assim:

1) Leia o grau do polinômio 'n'

2) Leia todos os coeficientes do polinômio de entrada POLI de 0 a 'n'

3) Calcule os coeficientes da derivada

4) Calcule os coeficientes da integral

5) Imprima ou mostre na tela os coeficientes da derivada (mostre todo o vetor DERI de 0 a 'n'-1)

6) Imprima ou mostre na tela os coeficientes da integral (mostre todo o vetor INTE de 0 a 'n'+1)

 

O item 3, Calcule os coeficientes da derivada, pode ser implementado num laço FOR-NEXT:

3.1) Para i de 0 a 'n'-1

3.2) Calcule DERI=POLI[i+1]*(i+1)

3.3) Próximo i

 

O item 4, Calcule os coeficientes da integral, pode ser implementado num laço FOR-NEXT também:

4.1) INTE[0] = qualquer valor

4.2) Para i de 1 a 'n'+1

4.3) Calcule INTE=POLI[i-1]/i

4.4) Próximo i

 

Espero ter ajudado.

 

{}

Palc

[ricci ottadnot 4]

Mais uma dica para começar..você pode analizar caractere por caractere de uma string de uma maneira simples e mto eficiente..a expressao para efetuar o calculo d derivada, integral eh do tipo string, certo?!você sabe q uma string eh, a grosso modo, um vetor de caracteres..entao você pode acessar cada caractere pelo seu indice..dai eh soh analizar caractere por caractere..

[renatoerp 0]

O algorítmo é bem mais simples do que parece.

 

Eu desenvolví em Java, mas ainda não terminei. Mas em C++ é bem mais fácil, só que eu fiz em Java para poder rodar no celular.

 

Você pode usar a forma mais genérica e simples do mundo (Usando recursividade e árvore binária). Ex.:

 

string s = "10*x*cos(x)" => 10*(x*-sin(x) + cos(x))

 

Transforme em uma árvore binária:

 

*

* cos

10 x x

 

Aí para derivar percorra a árvore por nível.

 

 

*

10 +

* cos

x * x

-1 sin

x

 

Parece que pelo método da recursão é feio, mas a recursão é ótimo porque as expressões são pequenas normalmente, mesmo que o cálculo seja muito complexo a profundidade da recursão não é fundo o suficiente para dar StackOverflow, rs.

 

 

 

 

Se você é estudante de ciência da computação e estiver estudando estrutura de dados e ainda por cima quiser fazer um mestrado em ciência da computação então eu aconselho seriamente você mesmo fazer o seu algorítmo, mas caso contrário você pode estar pegando algumas bibliotecas.

 

Em Java eu sei que tem a JScience e a JEP que na sua próxima versão haverá Calculus implementado. Mas em c++ também tem um monte e melhores. C++ é a melhor linguagem para se trabalhar com estrutura de dados que devem ser eficientes.

 

Bom, se você quiser poderá usar mesmo Árvores binárias para derivar e integrar. Ex.:

 

 

Expressão: derivada(2*x+x)

 

Menor procedência é o '+' na posição 3 então pegue esta posição 3 e divida a string em duas.

 

string1 = 2*x string2 = x operador = +

 

Como o operador é '+' então devese aplica a regra da soma => string1' + string2' = (2*x)' + x'. Ou seja

 

return derivada(string1) + derivada(string2).

 

 

 

Bom, se você quiser eu posse te passar a fórmula recorrente para chegar na derivada, aí eu aproveito e te explico direito isso tudo que eu falei, deve estar meio bagunçado, rs, mas está certo, rs.

[Gruger 0]

Gostei da sua idéia, acima.. Trabalhando com as strings das funções.

Desta maneira o usuário poderia digitar a sua função, seja ela do tipo que se quiser.. log, exp, sin, cos, tan.. etc..

 

Mas não entendo muito de árvore binária.. Nunca tinha ouvido falar disso.

Como funciona? Pode ser usada em VB.NET ou em C++.NET?