Buongiorno a tutti!
Ho un problema con un programma che trova gli zeri di una funzione. Infatti, usando una parabola del tipo "-x^2/2+1", simmetrica rispetto all'asse y, avente per zeri più e meno radice di 2, il programma mi trova uno solo dei due zeri, quello negativo.
main.c
#include "funzione.h"
#include "zeri.h"
#include <iostream>
using namespace std;
int main () {
parabola* par=new parabola();
Bisezione B(0, 500, 0.0001, par);
cout<<B.Solutore()<<endl;
return 0;
};
zeri.h
#ifndef zeri_h
#define zeri_h
#include <cmath>
#include <iostream>
#include "funzione.h"
class RicercaZeri {
public:
virtual double Solutore ()=0;
};
class Bisezione : public RicercaZeri {
protected:
double _a, _b;
double _prec;
FunzioneBase* _f;
public:
Bisezione (double a, double b, double prec, FunzioneBase* f);
void SetAB (double a, double b);
void SetPrec (double prec);
double GetA () const;
double GetB () const;
double GetPrec () const;
void Esegui ();
virtual double Solutore ();
};
#endif
zeri.c
#include "zeri.h"
Bisezione :: Bisezione (double a, double b, double prec, FunzioneBase* f) {
_a=a;
_b=b;
_prec=prec;
_f=f;
};
void Bisezione :: SetAB (double a, double b) {
_a=a;
_b=b;
};
void Bisezione :: SetPrec (double prec) {
_prec=prec;
};
double Bisezione :: GetA () const {
return _a;
};
double Bisezione :: GetB () const {
return _b;
};
double Bisezione :: GetPrec () const {
return _prec;
};
void Bisezione :: Esegui () {
double x_medio=(_b-_a)/2.;
if (_f->Eval(_a)*_f->Eval(x_medio)<0)
_b=x_medio;
if (_f->Eval(_b)*_f->Eval(x_medio)<0)
_a=x_medio;
};
double Bisezione :: Solutore () {
int counter=0;
while (fabs(_b-_a)>_prec){
counter++;
Esegui();
if (counter>((_b-_a)/_prec)+10000000000000){
std::cout<<"error"<<std::endl;
return 0;
};
};
return _b;
};
funzione.h
#ifndef funzione_h_
#define funzione_h_
class FunzioneBase {
public:
virtual double Eval(double x) const = 0;
};
class parabola:public FunzioneBase{
protected:
double _a, _b, _c;
public:
parabola() {_a=-0.5;_b=0;_c=1;};
virtual double Eval (double x) const {return _a*x*x+_b*x+_c;};
double GetxVertice () const {return double(((-1.)*_b)/(2.*_a));};
};
#endif
Quello che succede è che, per qualche motivo, il programma rimane incastrato nell'algoritmo del Solutore, butta fuori ad libitum gli stessi valori di _a e _b, e per qualche motivo arcano sembra anche ignorare il controllo per il numero di esecuzioni.
Sto impazzendo su sto codice, comunque grazie in anticipo