Bisect3_lambda.cpp

Go to the documentation of this file.

//      Bisect3_lambda.cpp
//      Recursive function
//                      Example: Find the point of zero by bisection
 
//      Version 3: func(x) and epsilon as parameters
//    lambda: pass lambda function to Bisect
 
#include <cassert>                // assert()
#include <cmath>
#include <functional>             // function; C++11
#include <iostream>
#include <vector>
using namespace std;
 
double f(const double x)                // declaration and
{
    return sin(x) - 0.5 * x ;    //   definition of function f(x)
}
 
double g(const double x)                // declaration and
{
    return -(x - 1.234567) * (x + 0.987654) ;    //   definition of function g(x)
}
 
// declaration of Bisect3
double Bisect3(const std::function<double(double)>& func,
               const double a, const double b, const double eps = 1e-6);
 
double eval(vector<double> const &a, double x);
 
int main()
{
    //    ...
    const double EPS = 1e-6;            // accuracy constant
 
    cout << endl;
    cout << " Determine point of zero in [a,b] by bisection " << endl;
 
    double a, b;
    cout << "f(a) > 0,  a : ";
    cin >> a;
    cout << "f(b) < 0,  b : ";
    cin >> b;
    cout << endl;
 
    //double x0 = Bisect3(f, a, b, EPS);                // call recursive function with f
    //double x0 = Bisect3(g,a,b,EPS);           // call recursive function with g
    
    // Lamda 1
    //double x0 = Bisect3([](const double x){return 2-x*x;}, 
                //a, b, EPS);
                
    // Lambda 2
    vector<double> koeff{-6.0, 1.0 , 1.0};   //  x^2 + x -6    : {-3,2}
    
    double x0 = Bisect3([&koeff](const double x){return eval(koeff,x);}, 
                a, b, EPS);
    
 
    cout << endl << " point of zero = " << x0 << endl;
    cout << endl;
 
    return 0;
}
 
//      ---------------------------------------------------------------
//      Recursive  function Bisect3
//      ---------------------------------------------------------------
//      definition of Bisect3
 
double Bisect3(const std::function<double(double)>& func, const double a, const double b,
               const double eps)
{
    double x0;
    double c = (a + b) / 2;             // center of interval
    double fc = func(c);                // function value in center
 
    if ( std::abs(fc) < eps ) {             // end of recursion
        x0 = c;
    }
    else if (  fc > 0.0 ) {
        x0 = Bisect3(func, c, b, eps);  // search in the right intervall
    }
    else {              // i.e., fc < 0.0
        x0 = Bisect3(func, a, c, eps);  // search in the left intervall
    }
 
    return x0;                          // return the solution
}
 
 
 
double eval(vector<double> const &a, double x)
{
    assert(!a.empty());
    double p=a[0];
    for (size_t k=1; k<a.size(); ++k)
    {
        p += a[k]*pow(x,k);
    }
    return p;
}