MATH_NewtonEquation.h

Go to the documentation of this file.

#ifndef MATH_NewtonEquation_H
#define MATH_NewtonEquation_H

#include "CORE_Array.h"

#include "MATH_Equation.h"

#include "MATH_C1Function.h"

DEFINE_SPTR(MATH_NewtonEquation);
DEFINE_SVPTR(MATH_NewtonEquation);

class MATH_NewtonEquation: public MATH_Equation {
    SP_OBJECT(MATH_NewtonEquation);

    // ATTRIBUTES

public:
private:
  
   
    tReal mdx;
    tReal mXMin;
    tReal mXMax;
  
 
private:

    // ASSOCIATIONS
  
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MATH_NewtonEquation(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~MATH_NewtonEquation(void);   
  

public:

    // NEW methods
  
    static SP::MATH_NewtonEquation New() {
        SP::MATH_NewtonEquation p(new MATH_NewtonEquation(),
                                MATH_NewtonEquation::Delete());
        p->setThis(p);
        return p;
    };
    
    
    // COPY methods
    
    virtual void copy(const MATH_Equation* m);
   
     
    //-------------------------
    // SAVER & LOADER methods
    // ------------------------

public:
    virtual void loadFromUIClass(const UI_Class& mclass);
    
    virtual void saveToUIClass(UI_Class& mclass) const;
    
    
    
    // SET methods 
    
public:
    virtual void setInterval(const tReal& a,const tReal& b) {
        MATH_Equation::setInterval(a,b);
        setConstraints(a,b);
    };
  
    inline void setConstraints(const tReal& minX,const tReal& maxX) {
        mXMin=minX;
        mXMax=maxX;
    };
    inline void getConstraints(tReal& minX,tReal& maxX) const{
        minX=mXMin;
        maxX=mXMax;
    };
    
    inline void setStep(const tReal& dx) {
        mdx=dx;
    }
  
  


   
  

    // GET methods 

public:

 
  


    // OTHERS methdos
    virtual tReal solve();
    virtual tReal solve(const tReal& x0) {
        tReal error=0;
        int iter=0;
        tReal x=solveNewton(x0,error,iter);
        setSolution(x);
        setError(error);
        setIterationsNumber(iter);
        return x;
    }
    
    virtual tString toString() const;
    
    virtual tBoolean hasFunction() const {
        const MATH_C1Function *f=dynamic_cast<const MATH_C1Function*>(getFunction());
        return (f!=null);
    }
    virtual tBoolean hasSucceeded() const {
        tBoolean succeeds=MATH_Equation::hasSucceeded();
        succeeds = succeeds && (getError()<getMaxError());
        return succeeds;
    }

private:
    tReal solveNewton(const tReal& x0,tReal& error,int& iter);
    


};


#endif