An object oriented approach (Newton-Raphson method)

[Lane]

#include <cstdlib>
#include <iostream>

//Where do I go from here?
//Given that f(x)= exp(x)-sin(2x). Use a Newton object to find the minimum of //the function from the class declarations bellow:-

using namespace std;

class Newton{
protected:
double precision;
public:
Newton(double p):precision(p){};
virtual ~Newton(){};
double Find(Function& f, double start){};//Does the actual
//iteration for a particular function f starting from a value start f is //declared as(a reference to) an object of the abstract Function class.

};

class Function{
public:
Function(){}
return f;
}
virtual ~Function(){};
virtual double operator()(double x)=0;//operator() does the function //evaluation for a particular value x and dfdx evaluates its derivative

virtual double dfdx(double x)=0;
};

virtual double operator()(double x){
return exp(x)-sin(2*x);
}
virtual double dfdx(double x){
return (exp(x)-cos(2*x)*2.0;
}


int main()
{



system("PAUSE");
return EXIT_SUCCESS;
}

[hamsterman]

http://en.wikipedia.org/wiki/Newton's_method
This says that Newton's method is for finding roots, not minimums.

The algorithm would be, I suppose

while(abs( f(start) ) > precision){
   start = start - f(start)/f.dfdx(start);
}

[Lane]

It also says that the minimum or maximum can be found when f2 = f1 - f'(x)/f"(x).
So where does

while(abs( f(start) ) > precision){
   start = start - f(start)/f.dfdx(start);
}

go in the class. Should the function have a return type?

This is how i have gone so far:-

#include <cstdlib>
#include <iostream>

using namespace std;

class Newton{
      protected:
                
      double precision;
      
      public:
      Newton(double p):precision(p){};
      virtual ~Newton(){};
      double Find(Function& f, double start){}
      
};

class Function{
      public:
      Function(){}
      return f;
      }
      virtual ~Function(){};
      virtual double operator()(double x)=0;
      virtual double dfdx(double x)=0;
};

double Newton::Find( Fuction& f, double start){
       while(abs( f(start) ) > precision){
       start = start - f(start)/f.dfdx(start);
       }
       }
virtual double operator()(double x){
      return exp(x)-sin(2x);
      }
virtual double dfdx(double x){
      dfdx = (exp(x)-cos(2*x)*2.0;
      d2fdx2 = exp(x) + sin(2x)*4.0;
      return d2fdx2;
      }
      

int main()
{
    
// In the main fuction, I need a Newton object 
// to find the minimum of the function
// I was suggesting

   double precision = 5; 
   Newton(precision);
   double minimum = precesion-df(precision-1)/dfdx(precesion-1);
   cout<<minimum<<endl;
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

[Browni3141]

@hamsterman:
Newton's method can be used to approximate the local min/max of a function by finding the zeros of the derivative function.
@Lane:
You spelled your variable wrong twice on line 52. Also, you need to include cmath to get some of the functions you're using like sin() and cos().

[hamsterman]

yes. minimum (or a maximum or inflection point) of f is the root of f'. you don't have f'' though.
my code is for Find.

[Lane]

So to initialize find we have:-

double Newton::Find( Fuction& f, double start){
       while(abs( f(start) ) > precision){
       start = start - f(start)/f.dfdx(start);
       }
       }

do we need a return type here?

what about virtual double operator()(double x)

Here is my implementation for the main to find the minimum. Does it make sense?

int main()
{
    
// In the main fuction, we need a Newton object 
// to find the minimum of the function
// I was suggesting

       double precision; 
       Newton(5.5);
       double minimum = precision-df(precision-1)/dfdx(precision-1);
       cout<<minimum<<endl;

[hamsterman]

double in double Newton::Find( Fuction& f, double start){ says that Find should return a double. I hope you can figure out what it is..

Your operator() is ok. Your dfdx, not so much. line 37 doesn't do anything at all. both line 37 and 38 use undeclared variables. there is no reason not to write what you had in the first post: return exp(x)-cos(2*x)*2.0;

your main is not right. it was said that Find() is supposed to do all the work, so maybe call it?

[Lane]

Does it mean that

double Newton::Find( Fuction& f, double start){
       while(abs( f(start) ) > precision){
       start = start - f(start)/f.dfdx(start);
       }
       }

returns f or f()?

Is it right when I say that

       double f; 
       Find( 0.5, 0.2);
       double minimum = precision- dfdx(precision-1)/dfdx*dfdx(precision-1);
       cout<<minimum<<endl;

in the main?

[Lane]

This doesn't make sense does it?

double f; 
       Find( 0.5, 0.2);
       double minimum = precision- dfdx(precision-1)/dfdx*dfdx(precision-1);
       cout<<minimum<<endl;

[Lane]

Who remembers Newton-Raphson method?

[hamsterman]

do you really understand the method itself?
after repeating x = x-f(x)/f'(x) several times, what variable is the root? well, Find has to return it.

your main doesn't make much sense. Find was said to do the whole thing, so why line 3? also it returns a variable, which is the actual root. maybe you should print that?

[Lane]

hamsterman this class is confusing. i understand Newton-Raphson method mathematically but not c++ly (if you understand what i mean). fist of all i want to understand what to put in the main so i can get the minimum.

[hamsterman]

in the main you put cout << Find(/*arguments*/); and nothing else.

[Lane]

then double Find(Function& f, double start); and virtual double dfdx(double x)will be overloaded

[hamsterman]

Whoops. Ignore my previous post..

Firstly you have to declare a class derived from Function and implement operator() and dfdx()

struct F : Function{
    double operator(double x){
        return exp(x)-sin(2*x);
    }
    double dfdx(double x){
        return exp(x)-cos(2*x)*2.0;
    }
}

Then in main,

F func;//create function object
Newton n(/*precision goes here*/);//create newton object
cout << n.Find(func, /*start goes here*/);

You almost have Newton::Find, you just have to figure out, what to return.

Though, seriously, have you been to any lectures at all? This task uses inheritance and polymorphism, while you're having difficulties with more simple things..

Anyway, sorry about the last post.

[Lane]

thats fine what about this one?

#include <cstdlib>
#include <iostream>
#include <cmath>

using namespace std;

class Newton{
      
      protected:
      double precision;
      
      public:
      Newton(double p):precision(p){};
      virtual ~Newton(){};
      double Find(Function& f, double start);
      
};

class Function: public Newton{
      public:
      Function(){};
      virtual ~Function(){};
      virtual double operator()(double x)=0;
      virtual double dfdx(double x)=0;

double Newton::Find( Fuction& f, double start){
       while(abs( f(start) ) > precision){
       start = start - f(start)/f.dfdx(start);
       }
       return Find();
       }

      virtual double operator()(double x){
      return exp(x)-sin(2*x);
      }
      virtual double dfdx(double x){
      return exp(x)-cos(2*x)*2.0;

      }

};


int main()
{
      F func;
      Newton n(5.0);
      cout << n.Find(func, 2.0)<<endl;

    
    system("PAUSE");
    return EXIT_SUCCESS;
}

[Lane]

My problem is with the function double Find(Function& f, double start);

if i call it

double Newton::Find(Function& f, double start){
      while(abs( f(start) ) > precision){
      start = start - f(start)/f.dfdx(start);
      }
      return start;
      }

The comipler does not recognise it as a member function when it is indeed

[ne555]

Why are you defining Newton::Find inside the Function class ?

[Lane]

i was told to define it that way.

[Lane]

Guys can we trouble shoot this? its now my third day on it. This is what i have so far with your help. However if I compile it, the compiler says "Find" is not a member function even though it is. I totally don't understand why

class Newton{
      
      protected:
      double precision;
      
      public:
      Newton(double p):precision(p){};
      virtual ~Newton(){};
      double Find(Function& f, double start);
};

class Function{
      public:
      Functionf(){};
      virtual ~Function(){};
      virtual double operator()(double x)=0;
      virtual double dfdx(double x)=0;
};
      
class f : public Function{
      double operator()(double x){
      return (exp(x)-sin(2*x));
      }
      double dfdx(double x){
      return (-exp(x)-cos(2*x)*2.0);
      }

};

int main()
{
      f Functionf;
      Newton n(5.0);
      cout << n.Find(Function, 2.0)<<endl;

    
      system("PAUSE");
      return EXIT_SUCCESS;
}

      
double Newton:: Find(Function& f, double start){
      while(fabs( f(start) ) > precision){
      start = start - f(start)/f.dfdx(start);
      }
      return start;
      }