Derivada em c++ - Métodos Numéricos

[Murilo Marchiori]

Bom dia, caros colegas;

venho através do fórum solicitar sua ajuda em um exercício da faculdade. Tenho que elaborar um programa, em c++, que resolva equações pelo método de newton e pelo método da secante. mas para isso, preciso saber a derivada das funções que o usuário digita. Alguém saberia um meio de fazer isso?

Att.

Murilo Marchiori

[duda3005]

Amigo.... poste seu código... até a onde você conseguiu fazer?

o Intuito do fórum é ajudar tirando as dúvidas... e não resolver os exercícios para os outros...

Tente fazer e mesmo se estiver errado poste aqui até onde conseguiu.. ai conseguiremos te ajudar melhor... ver onde está a real dificuldade.

[Murilo Marchiori]

Amigo.... poste seu código... até a onde você conseguiu fazer?

o Intuito do fórum é ajudar tirando as dúvidas... e não resolver os exercícios para os outros...

Tente fazer e mesmo se estiver errado poste aqui até onde conseguiu.. ai conseguiremos te ajudar melhor... ver onde está a real dificuldade.

Ola, duda, boa tarde. Claro que o forum não está aqui para resolver os exercicios para os outros, desculpe se passei essa impressão. Segue o código até onde consegui, e desculpe a falha de não postá-lo anteriormente. (parece que o código tá meio inacabado, mas é assim mesmo... é porque depois eu vou ter que fazer resolvendo através de outros métodos, não só o de newton, mas acredito que conseguindo terminar esse método, consigo fazer os outros)

valeu, abraço

#include <iostream>
#include <math.h>
using namespace std;

int menu();
float calculaFuncaoNewton(float x); 
float calculaDerivadaNewton(float x); 
float metodoNewton(float x);
void calculaNewton();

int main()
{
	int op=0;

	op = menu();

	if(op == 1)
		calculaNewton();
}

int menu()
{
	int op=0;

	cout << "\n\nMenu" << endl << endl;
	cout << "1- Metodo de Newton"  << endl;

	cout << "\nDigite sua opcao: ";
	cin >> op;

	while(op <= 0 || op > 2)
	{
		cout << "\nOpcao invalida. Digite novamente: ";
		cin >> op;
	}

	return op;
}

float calculaFuncao(float x) 
{
   float fx=0;

   fx = pow(x,2) + 2*x - 3;
   return fx;
} 

float calculaDerivada(float x) 
{
   float flinhax=0;

   flinhax = 2*x + 2;
   return flinhax;
} 

float metodoNewton(float x)
{
	float funcao=0, derivada=0, xMaisUm=0;

	funcao = calculaFuncao(x);
	derivada = calculaDerivada(x); 

	xMaisUm = x - (funcao/derivada);

	cout << endl << "xMaisUm: " << xMaisUm << endl;
	cout << "funcao: " << funcao << endl;
	cout << "derivada: " << derivada << endl;

	return xMaisUm;
}

void calculaNewton()
{	
	int cont=0; 
	float limite=0, result =0, i=1;

	result = metodoNewton(i); 

	limite = pow(10,-2);

	cout << "\nresultado: " << ((result - i)/result);

	while(((result-i)/result) > limite)
	{
		cont++;
		i++;
		result = metodoNewton(i);
		cout << "\n\npassei aqui";
	}	

	cout << "\n\nA raiz encontrada é: ";
	cout << result;
	cout << "\n\nForam feitas " << cont << " iteracoes.";
}

[regreth]

Do jeito que você está fazendo fica difícil..

Minha aproximação seria algo como:

class Function
{
    protected:
        vector<Function*> operands;
    public:
        void setOperands(vector<Function*> ops)
        { operands = ops; }

        vector<float> getFloatOps()
        {
            vector<float> ret;
            ret.reserve(operands.size());
            transform(operands.begin(), operands.end(), ret.begin(), mem_fun(&Function::execute));
            return ret;
        }

        virtual float execute() = 0;
        virtual Function * derivative() = 0;
};

Dai você extendia essa classe para criar as operações de soma (e a derivada da soma = soma das derivadas),multiplicação e funções,dentre outras coisas.O jeito para passar um parametro também seria estender para criar as variaveis.

Por exemplo,uma função de um parametro ficaria:

class UnaryFunction : public Function
{
    public:
        UnaryFunction(Function *x)
        {
            vector<Function*> ops;
            ops.push_back(x);
            setOperands(ops);
        }

        virtual Function * myDerivative() = 0;

        Function * derivative()
        {
            //REGRA DA COMPOSTA
            vector<Function*> ops;
            ops.reserve(2);
            Function *m1 = new Mul();
            Function *m2 = new Mul(); //extendendo function
            Function *bridge = new Sum(); //extendendo function
            vector<Function*>::iterator begin = operands.begin();
            ops[0] = (*begin)->derivative();
            ops[1] = this;
            m1->setOperands(ops);
            ops[0] = *begin;
            ops[1] = myDerivative();
            m2->setOperands(ops);
            ops[0] = m1;
            ops[1] = m2;
            bridge->setOperands(ops);
            return bridge;
        }
};

Para a função monomial você extendia essa classe e criava métodos para setar o expoente e o coeficiente por exemplo,ai no execute você retornava um float baseado no valor que foi passado a ela e isso.Para a polinomial você simplesmente criava uma soma de monomiais.

No myDerivative dela você retornava uma nova função monomial com expoente exp-1 e coeficiente coef*exp.

Você usaria técnicas de lexing/parser para transformar o que o usuario disse nisso ai,e vice-versa.Por exemplo,procurava a ultima aspa "(" da string e via o que tinha dentro dela,se encontrasse um número criava um novo objeto extendendo função que simplesmente retorna esse número.Ia pra próxima aspa "(" e repetia o procedimento,checando se existiam erros de sintaxe e setando os operandos.Quando terminasse de transformar,executava uma operação qualquer.

Para transformar isso ai em strings,você se baseava na hierarquia de operandos de uma função.Criava um método retornando uma string chamado repr na classe Function por exemplo,ai nas subclasses você extendia.

O repr da Sum por exemplo poderia ficar:

string repr()
{
    vector<Function*>::iterator it = operands.begin();
    string ret = (*it)->repr();
    for(++it;it != operands.end();++it) {
        ret += " + " + (*it)->repr();
    }
    return ret;
}

Você também pode criar "variaveis sem valores" já que o valor delas só é pego no execute (dai você retornava claro).Criava uma classe VariableProxy por exemplo,extendendo function,que no repr retornava o nome da variavel e no execute procurava a variavel real de algum lugar.

É meio complicado te explicar sem códigos,mas eu me aproximaria assim.Qualquer dúvida é só perguntar.

PS: seria necessario criar as classes que estão faltando e incluir alguns headers da STL para os exemplos funcionarem.Assim como criar um gerenciador de memória para evitar leaks e etc.

PS²: é legal também criar mais funcionalidades na classe.Por exemplo setar quantos parametros uma função espera e checar isso.Ou ainda um método que diga que a função deva ser representada como n-ésima derivada (para o repr por exemplo).

Att. regreth