numerical.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// MARTY is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef NUMERICAL_H_INCLUDED
#define NUMERICAL_H_INCLUDED

#include "buildingBlock.h"

namespace csl {

class AbstractNumerical: public AbstractBuildingBlock{
    public:

    AbstractNumerical();

    csl::PrimaryType getPrimaryType() const override {
        return csl::PrimaryType::Numerical;
    }

    void printCode(
            int mode = 0,
            std::ostream &out = std::cout
            ) const override;

    std::vector<Parent> getSubSymbols() const override;

    Expr getNumericalFactor() const override;
    std::optional<Expr> getTerm() const override;

    bool dependsOn(Expr_info) const override {
        return false;
    }
    bool dependsOn(Parent_info) const override {
        return false;
    }
    bool dependsExplicitlyOn(Expr_info) const override {
        return false;
    }
    bool dependsExplicitlyOn(Parent_info) const override {
        return false;
    }
};

inline AbstractNumerical::AbstractNumerical(): AbstractBuildingBlock(){}


/*************************************************/
// Numerical classes                             //
/*************************************************/

class Integer: public AbstractNumerical{

    protected:

    long long int value; 
    public:

    Integer();

    explicit Integer(long long int t_value);

#ifdef DEBUG
    ~Integer(){ __record_data_alloc(static_cast<int>(getType())); }
#endif

    csl::Type getType() const override;

    bool isInteger() const override { return true;}

    void setValue(long double t_value) override;

    void print(int mode=0,
               std::ostream& out=std::cout,
               bool lib = false) const override;

    std::string printLaTeX(int mode=0) const override;

    long double evaluateScalar() const override;

    std::optional<Expr> evaluate(
            csl::eval::mode user_mode = csl::eval::base
            ) const override;

    unique_Expr copy_unique() const override;

    Expr multiplication_own(const Expr& expr, bool side=1) const override;

    Expr addition_own(const Expr& expr) const override;

    Expr division_own(const Expr& expr) const override;

    Expr exponentiation_own(const Expr& expr) const override;

    std::optional<Expr> derive(Expr_info expr) const override;

    void operator=(long long int t_value);
   
    bool operator==(Expr_info expr) const override;

    bool operator<(const Abstract* expr) const override;
};


class Float: public AbstractNumerical{

    protected:

    long double value; 
    public:

    Float();

    explicit Float(long double t_value);

#ifdef DEBUG
    ~Float(){ __record_data_alloc(static_cast<int>(getType())); }
#endif


    csl::Type getType() const override;

    bool isInteger() const override;

    void setValue(long double t_value) override;

    void print(int mode=0,
               std::ostream& out=std::cout,
               bool lib = false) const override;

    std::string printLaTeX(int mode=0) const override;

    long double evaluateScalar() const override;

    std::optional<Expr> evaluate(
            csl::eval::mode user_mode = csl::eval::base
            ) const override;

    unique_Expr copy_unique() const override;

    Expr refresh() const override;

    Expr multiplication_own(const Expr& expr, bool side=1) const override;

    Expr addition_own(const Expr& expr) const override;

    Expr division_own(const Expr& expr) const override;

    Expr exponentiation_own(const Expr& expr) const override;

    std::optional<Expr> derive(Expr_info expr) const override;

    void operator=(int t_value);
   
    void operator=(double t_value) override;

    bool operator==(Expr_info expr) const override;

    bool operator<(const Abstract* expr) const override;
};

class IntFraction: public AbstractNumerical{

    protected:

    long long int num; 
    long long int denom; 
    public:

    IntFraction();

    explicit IntFraction(long long int t_num);

    IntFraction(long long int t_num, long long int t_denom);

    IntFraction(IntFraction const&) = default;

#ifdef DEBUG
    ~IntFraction(){ __record_data_alloc(static_cast<int>(getType())); }
#endif

    csl::Type getType() const override;

    long long int getNum() const override;

    long long int getDenom() const override;

    void print(int mode=0,
               std::ostream& out=std::cout,
               bool lib = false) const override;

    void printCode(
            int mode = 0,
            std::ostream &out = std::cout
            ) const override;

    std::string printLaTeX(int mode=0) const override;

    long double evaluateScalar() const override;

    std::optional<Expr> evaluate(
            csl::eval::mode user_mode = csl::eval::base
            ) const override;

    unique_Expr copy_unique() const override;

    Expr refresh() const override;

    Expr multiplication_own(const Expr& expr, bool side=1) const override;

    Expr addition_own(const Expr& expr) const override;

    Expr division_own(const Expr& expr) const override;

    Expr exponentiation_own(const Expr& expr) const override;

    std::optional<Expr> derive(Expr_info expr) const override;

    void operator=(long long int t_value);

    void operator=(double t_value) override;

    bool operator==(Expr_info expr) const override;

    bool operator<(const Abstract* expr) const override;
};

/*************************************************/
// Inline functions (non virtual and short)      //
/*************************************************/
inline Integer::Integer(): AbstractNumerical(), value(0){}
inline Integer::Integer(long long int t_value)
    :AbstractNumerical(), value(t_value)
{}

inline Float::Float(): AbstractNumerical(), value(0){}
inline Float::Float(long double t_value): AbstractNumerical(), value(t_value){}

//The IntFraction constructor with t_num and t_denom is in the .cpp file (more complex).
inline IntFraction::IntFraction(): AbstractNumerical(), num(0), denom(1){}
inline IntFraction::IntFraction(long long int t_num)
    :AbstractNumerical(), num(t_num), denom(1){}

class Complex : public AbstractNumerical {

    protected:

    Expr real; 
    Expr imag; 
    public:

    Complex();

    explicit Complex(Expr t_real);

    Complex(Expr t_real,
            Expr t_imag);

#ifdef DEBUG
    ~Complex(){ __record_data_alloc(static_cast<int>(getType())); }
#endif

    csl::Type getType() const override;

    void print(int mode=0,
               std::ostream& out=std::cout,
               bool lib = false) const override;

    void printCode(
            int mode=0,
            std::ostream& out=std::cout
            ) const override;

    std::string printLaTeX(int mode=0) const override;

    long double evaluateScalar() const override;

    std::optional<Expr> evaluate(
            csl::eval::mode user_mode = csl::eval::base
            ) const override;

    bool isReal() const override;

    bool isPurelyImaginary() const override;

    std::optional<Expr> getRealPart() const override;

    Expr getImaginaryPart() const override;

    std::optional<Expr> getComplexArgument() const override;

    std::optional<Expr> getComplexModulus() const override;

    std::optional<Expr> getComplexConjugate() const override;

    unique_Expr copy_unique() const override;

    Expr refresh() const override;

    Expr multiplication_own(const Expr& expr, bool side=1) const override;

    Expr addition_own(const Expr& expr) const override;

    Expr division_own(const Expr& expr) const override;

    Expr exponentiation_own(const Expr& expr) const override;

    std::optional<Expr> derive(Expr_info expr) const override;

    bool operator==(Expr_info expr) const override;

    bool operator<(const Abstract* expr) const override;

    private:

    void checkNumerical(Expr const& expr) const;
};


Expr float_s(long double value);

Expr int_s(long long int value);

Expr autonumber_s(long double value);

Expr intfraction_s(long long int num, long long int denom);

Expr complex_s(Expr const& real, Expr const& imag);

inline csl::allocator<Integer>     alloc_integer;
inline csl::allocator<Float>       alloc_float;
inline csl::allocator<IntFraction> alloc_intfraction;
inline csl::allocator<Complex>     alloc_complex;

} // End of namespace csl

inline const csl::Expr CSL_0 = csl::make_shared<csl::Integer>(0);

inline const csl::Expr CSL_1 = csl::make_shared<csl::Integer>(1);

inline const csl::Expr CSL_2 = csl::make_shared<csl::Integer>(2);

inline const csl::Expr CSL_M_1 = csl::make_shared<csl::Integer>(-1);

inline const csl::Expr CSL_M_2 = csl::make_shared<csl::Integer>(-2);

inline const csl::Expr CSL_HALF    = csl::make_shared<csl::IntFraction>(1, 2);

inline const csl::Expr CSL_THIRD   = csl::make_shared<csl::IntFraction>(1, 3);

inline const csl::Expr CSL_M_HALF  = csl::make_shared<csl::IntFraction>(-1, 2);

inline const csl::Expr CSL_M_THIRD = csl::make_shared<csl::IntFraction>(-1, 3);

#endif