Help!Bisection method in C++

I am working on bisection method to calculate interest rate in C++,but there is some problems with my codes:the root is always 7.62939E-06.Please help me figure out why my program always fails.

The header file: (hasRoot is a class which has only one member function f:fv+pv*pow(1+rate,nPer)+pmt/rate*(pow(1+rate,nPer)-1)).

Code:

#include "hasRoot.h"class rootFinder{
private:
double tol; 
/*the allowed difference between the calculated root and the actual root.*/
int MaxIter; //the maximum iteration times
public:
rootFinder(double a=0.00001,int b=20000){
tol=a;
MaxIter=b;
}
double functionsolver(hasRoot&);
};

The implementation part:

Code:

#include "rootFinder.h"
#include <cmath>

double rootFinder::functionsolver(hasRoot& objecttobesolved){
int counter=1; //Counts the iteration times.
double left=0;
double right=1;
for (;counter<=MaxIter;counter++){
     double mid=(left+right)/2.0;
     if( fabs(objecttobesolved.f(mid))<=tol || (right-left)<tol){
     return mid;
     break;
     }
    if( objecttobesolved.f(mid)*objecttobesolved.f(right)>0)
          right=mid;
    if( objecttobesolved.f(mid)*objecttobesolved.f(right)<0)
          left=mid;
  }
}

Everytime I run it,no matter what are the values of pv(present value),fv(future value),pmt(payment) and nPer(number of Periods),I always get the same result 7.62939E-06.

A few things:
There isn't any point in having a break after a return as it can never get to the break. The compiler should be warning you about unreachable code. Just delete the break.

This expression is written twice:

Code:

objecttobesolved.f(mid)*objecttobesolved.f(right)

Although compilers can often perform common subexpression elimination, in this case that most probably cannot occur. The compiler cant prove that the function f has no side effects. In fact, you didn't even provide the function f here so we can't even see what it does! Summarising what it does is not the same thing.
Furthermore, I can't understand why you are multiplying the result of f(mid) and f(right) to begin with. It most certainly doesn't perform bisection properly. Also note that multiplying two negatives results in a positive, thus why it appears to be going left every time.

At the moment is that if the above expression happened to evaluate to exactly 0, then if would neither alter right, nor left. What you should do to fix that is to turn the last if into a plain old else. This also means that you don't need to calculate the expression above twice.

Your MaxIter variable is redundant. You don't need to stop either when the right-left < tol and when counter > MaxIter. Well that is once you fix the bug I just mentioned by using an else. At the moment it's the only thing stopping an infinite loop.

Thank you very much for offering me suggestions.But after I fixed the codes according to your suggestions,I still got 7.62939E-06.
As to "why multiply f(mid) by f(right)",I think it is the principle of bisection method because my professor told me to do so.Maybe you could check it by yourself.
Finally I show the function f:

Code:

double f(double exprate) const{
     double trialvalue;
     trialvalue=fv+pv*pow(1+exprate,nPer)+pmt/exprate*(pow(1+exprate,nPer)-1);
     return trialvalue;
}

After looking into it further, yes the multiplication probably will do what you want, but it's certainly not the clearest way of doing it.

Do you even know if the function you're providing has a root between 0 and 1? If it doesn't then that would explain the output.
Can you modify the code to output the values of f as it goes so we can see what's going on?

Because the root I am looking for is actually interest rate,I am sure the root is between 0 and 1.
Could you clarify the meaning of your last sentence?Do you mean that I should try to modify the codes of f?

It would probably be better to modify the code inside functionsolver

Code:

    cout << "mid=";
    cout << mid;
    cout << ", f(mid)=";
    cout << objecttobesolved.f(mid);
    cout << " right=";
    cout << right;
    cout << ", f(right)=";
    cout << objecttobesolved.f(right) << endl;

Oh yeah!Thanks to those output codes,I figured out the reason!It involves the overwriting of virtual functions.
Thank you very much!Happy new year!

Awesome. Same to you!