MATH_Equation.h

Go to the documentation of this file.

#ifndef MATH_Equation_H
#define MATH_Equation_H


#include "UI_Object.h"
#include "UI_Class.h"

#include "MATH_Function.h"


DEFINE_SPTR(MATH_Equation);
DEFINE_SVPTR(MATH_Equation);

class MATH_Equation: public virtual UI_Object {
    SP_OBJECT(MATH_Equation);

    // ATTRIBUTES

public:
    static const tReal EPSILON;
    
    
    /*   - mMaxError : the max error
     *       - type: real
     *       - card: 1
     *   - mMaxIterationsNumber: the max number of iterations 
     *       - type: integer
     *       - card: 1
     *   - mIterationsNumber: the number of iterations  
     *                        for having error les thass mError
     *       - type: integer
     *       - card: 1 
     *   - mX: the value x to solve f(x)=0
     *       - type: tReal
     *       - card: 1
     *
     *   - mError: the error on x
     *       - type: tReal
     *       - card: 1
     *  
     */
    tReal mMaxError;
    int mMaxIterationsNumber;
    
    int mIterationsNumber;
    tReal mX;
    tReal mError;

    tReal mInterval[2];
    
   /* Associations:
    *    - mFunction which is the function f
    *       - type: MATH_Function
    *       - card: 1
    */
    WP::MATH_Function mFunction;
 
private:

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

public:

    // NEW methods
  
  
    
    
    // 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;


    // -----------------
    // function setting
    // -----------------
public:
    virtual void setInterval(const tReal& a,const tReal& b) {
        mInterval[0]=a;
        mInterval[1]=b;
    };
    inline void getInterval(tReal& a,tReal& b) const {
        a=mInterval[0];
        b=mInterval[1];
    };
    
    inline void setMaxIterationsNumber(const int& v) {
        mMaxIterationsNumber=v;
    };
    inline int getMaxIterationsNumber() const {
        return mMaxIterationsNumber;
    };
    inline tReal getSolution() const {
        return mX;
    };
    inline int getIterationsNumber() const {
        return mIterationsNumber;
    };
    inline tReal getError() const {
        return mError;
    };
    inline void setMaxError(const tReal& err)  {
        mMaxError=err;
    };
    inline tReal getMaxError() const {
        return mMaxError;
    };

protected:
    inline void setSolution(const tReal& x)  {
        mX=x;
    };
    inline void setIterationsNumber(const int& n)  {
        mIterationsNumber=n;
    };
    inline void setError(const tReal& err) {
        mError=err;
    };

public:
    
    inline void setFunction(SP::MATH_Function f) {
        mFunction=f;
    };
    inline const MATH_Function* getFunction() const {
        SPC::MATH_Function p=mFunction.lock();
        return p.get();
    }; 
    inline MATH_Function* getFunction() {
        SP::MATH_Function p=mFunction.lock();
        return p.get();
    };
    
    virtual tBoolean hasFunction() const {
        return (getFunction()!=null);
    }
    
    // -----
    // solve
    // -----

    virtual  tReal solve()=0;
    virtual tReal solve(const tReal& x0)=0;

    virtual tBoolean hasSucceeded() const {
        return (mIterationsNumber<mMaxIterationsNumber+1); 
    }
    
    virtual tString toString() const;
    
    //Internal methods
private:
};


#endif