literal.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 LITERAL_H_INCLUDED
#define LITERAL_H_INCLUDED

#include "buildingBlock.h"
#include "variableParent.h"

namespace csl {

class AbstractLiteral: public Complexified{

    protected:

    std::vector<Equation*> props;

    public:

    AbstractLiteral();

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

    size_t memoryOverhead() const override;

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

    const std::vector<Equation*>& getProperties() const override;

    void addProperty(Equation* property) override;

    void removeProperty(Equation* property) override;
};

inline AbstractLiteral::AbstractLiteral()
    :Complexified(),
    props(std::vector<Equation*>(0)){}


class Constant: public AbstractLiteral{

    protected:

    std::shared_ptr<ConstantParent> parent;

    public:

    Constant(const std::shared_ptr<ConstantParent>& t_parent);


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

    std::string const &getName() const override;

    std::string const &getLatexName() const override;

    bool getCommutable() const override;

    csl::PrimaryType getPrimaryType() const override;

    csl::Type getType() const override;

    Parent getParent() const override;

    Parent_info getParent_info() const override;

    csl::ComplexProperty getComplexProperty() const override;

    void setComplexProperty(csl::ComplexProperty prop) override;

    void setName(const std::string& name) override;

    void setCommutable(bool commutable) override;

    bool getValued() const override;

    long double getValue() const override;

    bool dependsOn(Expr_info expr) const override;

    void setValue(long double t_value) override;

    void setValue(Expr const &t_value) 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;

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

    long double evaluateScalar() const override;

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

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

    int getParity(Expr_info t_variable) const override;

    unique_Expr copy_unique() const override;

    void operator=(double t_value) override;

    bool operator==(Expr_info expr) const override;

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

class Variable: public AbstractLiteral{

    protected:

    std::shared_ptr<VariableParent> parent;

    public:

    Variable(const std::shared_ptr<VariableParent>& t_parent);


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

    csl::PrimaryType getPrimaryType() const override;

    csl::Type getType() const override;

    std::string const &getName() const override;
        
    std::string const &getLatexName() const override;

    bool getCommutable() const override;

    csl::ComplexProperty getComplexProperty() const override;

    void setComplexProperty(csl::ComplexProperty prop) override;

    void setName(const std::string& name) override;

    void setCommutable(bool commutable) override;

    Parent getParent() const override;

    Parent_info getParent_info() const override;

    bool getElementary() const override;

    bool getAllDependencies() const override;

    bool getValued() const override;

    long double getValue() const override;

    bool dependsOn(Expr_info expr) const override;

    bool commutesWith(Expr_info expr, int sign=-1) const override;

    void setValue(long double t_value) override;

    void setValue(Expr const &t_value) override;

    void setElementary(bool t_elementary) override;

    void setAllDependencies(bool t_allDependencies) override;

    void addDependency(Expr const& expr) override;

    void removeDependency(Expr const& expr) 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;

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

    long double evaluateScalar() const override;

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

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

    int getParity(Expr_info t_variable) const override;

    unique_Expr copy_unique() const override;


    void operator=(double t_value) override;

    bool operator==(Expr_info expr) const override;

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

class IntFactorial: public AbstractLiteral{

    protected:

    int value; 
    public:

    IntFactorial();

    explicit IntFactorial(int t_value);


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

    long double getValue() const override { return value;}

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

    csl::Type getType() const override { return csl::Type::IntFactorial;};

    void setValue(long double t_value) 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;

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

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

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

class Imaginary: public AbstractLiteral{

    public: 

    Imaginary();


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

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

    csl::Type getType() const override { return csl::Type::Imaginary;}

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

    Expr getImaginaryPart() const override;

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

    csl::ComplexProperty getComplexProperty() const override {
        return csl::ComplexProperty::Imaginary;
    }
    
    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;

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

    bool operator==(Expr_info expr) const override; 

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

/*************************************************/
// Inline functions (non virtual and short)      //
/*************************************************/
inline Variable::Variable(const std::shared_ptr<VariableParent>& t_parent)
    :AbstractLiteral(), parent(t_parent)
{

}

inline Constant::Constant(const std::shared_ptr<ConstantParent>& t_parent)
    :AbstractLiteral(), parent(t_parent)
{

}

inline IntFactorial::IntFactorial()
    :AbstractLiteral(),
    value(0)
{

}

inline IntFactorial::IntFactorial(int t_value)
    :AbstractLiteral(),
    value(t_value)
{

}

inline Imaginary::Imaginary()
    :AbstractLiteral()
{

}

Expr intfactorial_s(int value);

Expr constant_s(std::string          const& name,
               csl::ComplexProperty prop = csl::ComplexProperty::Real);

Expr constant_s(std::string          const& name,
               long double                 value,
               csl::ComplexProperty prop = csl::ComplexProperty::Real);

Expr constant_s(std::string          const& name,
               Expr                 const& value,
               csl::ComplexProperty prop = csl::ComplexProperty::Real);

Expr variable_s(
          std::string          const& name,
          csl::ComplexProperty prop = csl::ComplexProperty::Real);

Expr variable_s(
          std::string          const& name,
          long double                 value,
          csl::ComplexProperty prop = csl::ComplexProperty::Real);

Expr variable_s(
          std::string          const& name,
          Expr                 const& value,
          csl::ComplexProperty prop = csl::ComplexProperty::Real);

/*************************************************/
// Global (useful) variables                     //
// (Numerical or Literal)                        //
/*************************************************/

inline csl::allocator<Constant> alloc_constant;
inline csl::allocator<Variable> alloc_variable;

} // End of namespace csl;

inline const csl::Expr CSL_I = csl::make_shared<csl::Imaginary>();

inline const csl::Expr CSL_PI = csl::constant_s(
        "\\pi",
        M_PI,
        csl::ComplexProperty::Real);

inline const csl::Expr CSL_E = csl::constant_s(
        "e",
        M_E,
        csl::ComplexProperty::Real);


inline const csl::Expr CSL_INF = csl::constant_s(
        "INF",
        csl::ComplexProperty::Real);

inline const csl::Expr CSL_UNDEF = csl::constant_s(
        "CSL_UNDEF",
        csl::ComplexProperty::Real);


#endif