scalarFunc.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 SCALARFUNC_H_INCLUDED
#define SCALARFUNC_H_INCLUDED
#include "literal.h"
#include "numerical.h"
#include "std_vector_implementation.h"

namespace csl {

class Tensor;

class AbstractFunc: public Abstract{

    protected:

    Expr argument; 
    public:

    AbstractFunc();

    explicit AbstractFunc(const Expr& t_argument);

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

    bool getCommutable() const override;

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

    bool isIndexed() const override;

    size_t size() const override;

    bool compareWithDummy(Expr_info expr,
                          std::map<Index, Index>& constraints,
                          bool keepAllCosntraints = false) const override;

    IndexStructure getIndexStructure() const override;

    Tensor getPoint() const override;

    int getNArgs(int axis=0) const override;

    Expr const &getArgument(int iArg=0) const override;

    Expr& getArgument(int iArg=0) override;

    bool isReal() const override;

    bool isPurelyImaginary() const override;

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

    Expr getImaginaryPart() const override;

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

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

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

    std::optional<Expr> findSubExpression(
            Expr_info   subExpression,
            const Expr& newExpression) const override;

    void setArgument(const Expr& t_argument, int iArg=0) override;

    virtual std::optional<Expr> replaceIndex(
            const Index& indexToReplace,
            const Index& newIndex,
            bool         refresh = true) const override;

    virtual std::optional<Expr> replaceIndices(
            std::vector<csl::Index> const &oldIndices,
            std::vector<csl::Index> const &newIndices,
            bool         refresh = true,
            bool         flipped = false) const override;

    virtual std::optional<Expr> factor(bool full=false) const override;

    virtual std::optional<Expr> factor(
            Expr_info expr,
            bool      full=false) const override;

    virtual std::optional<Expr> collect(
            std::vector<Expr> const &factors,
            bool                     full = false
            ) const override;

    std::optional<Expr> expand(bool full=false,
                               bool inPlace=false) const override;

    virtual std::optional<Expr> expand_if(
            std::function<bool(Expr const&)> const& f,
            bool full=false,
            bool inPlace=false) const override;

    bool dependsOn(Expr_info expr) const override;

    bool dependsOn(const AbstractParent* parent) const override;

    bool dependsExplicitlyOn(Expr_info expr) const override;

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

    int isPolynomial(Expr_info expr) const override;

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

    Expr const &operator[](int i) const override;

    Expr& operator[](int i) override;

    bool operator==(Expr_info expr) const override;

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

    protected:

    Expr evalNumerical(Expr const& argument) const;
};


class AbstractDuoFunc: public Abstract{

    protected:

    std::array<Expr,2> argument; 
    public:

    AbstractDuoFunc();

    AbstractDuoFunc(const Expr& left,
                    const Expr& right);

    csl::Type getType() const override {
        return csl::Type::StandardDuo;
    }
    csl::PrimaryType getPrimaryType() const override{
        return csl::PrimaryType::MultiFunction;
    }

    bool getCommutable() const override;

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

    bool isIndexed() const override;

    IndexStructure getIndexStructure() const override;

    Tensor getPoint() const override;

    int getNArgs(int axis=0) const override;

    size_t size() const override {
        return 2;
    }

    Expr const &getArgument(int iArg=0) const override;

    Expr& getArgument(int iArg=0) override;

    std::optional<Expr> findSubExpression(
            Expr_info   subExpression,
            const Expr& newExpression) const override;

    void setArgument(const Expr& t_argument, int iArg=0) override;

    bool isReal() const override;

    bool isPurelyImaginary() const override;

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

    Expr getImaginaryPart() const override;

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

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

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

    virtual std::optional<Expr> replaceIndex(
            const Index& indexToReplace,
            const Index& newIndex,
            bool         refresh = true) const override;

    virtual std::optional<Expr> replaceIndices(
            std::vector<csl::Index> const &oldIndices,
            std::vector<csl::Index> const &newIndices,
            bool         refresh = true,
            bool         flipped = false) const override;

    virtual std::optional<Expr> factor(bool full=false) const override;

    virtual std::optional<Expr> factor(
            Expr_info expr,
            bool      full=false) const override;

    virtual std::optional<Expr> collect(
            std::vector<Expr> const &factors,
            bool                     full = false
            ) const override;

    virtual std::optional<Expr> expand(bool full=false,
                                       bool inPlace=false) const override;

    virtual std::optional<Expr> expand_if(
            std::function<bool(Expr const&)> const& f,
            bool full=false,
            bool inPlace=false) const override;

    bool dependsOn(Expr_info expr) const override;

    bool dependsOn(Parent_info parent) const override;

    bool dependsExplicitlyOn(Expr_info expr) const override;

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

    int isPolynomial(Expr_info expr) const override;

    Expr const &operator[](int i) const override;

    Expr& operator[](int i) override;

    bool operator<(Expr_info other) const override;
};


class AbstractMultiFunc: public Abstract{

    protected:

    csl::vector_expr argument; 
    public:

    AbstractMultiFunc();

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

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

    bool getCommutable() const override;

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

    virtual bool isIndexed() const override;

    int getNArgs(int axis=0) const override;

    const csl::vector_expr& getVectorArgument() const override;

    Expr const &getArgument(int iArg=0) const override;

    Expr& getArgument(int iArg=0) override;

    std::optional<Expr> findSubExpression(
            Expr_info   subExpression,
            const Expr& newExpression) const override;

    size_t size() const override;

    bool empty() const override;

    csl::vector_expr::iterator begin() override;

    csl::vector_expr::iterator end() override;

    csl::vector_expr::const_iterator begin() const override;

    csl::vector_expr::const_iterator end() const override;

    void setArgument(const Expr& t_argument, int iArg=0) override;

    void setVectorArgument(const csl::vector_expr& t_argument) override;

    bool isReal() const override;

    bool isPurelyImaginary() const override;

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

    Expr getImaginaryPart() const override;

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

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

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

    virtual std::optional<Expr> replaceIndex(
            const Index& indexToReplace,
            const Index& newIndex,
            bool         refresh = true) const override;

    virtual std::optional<Expr> replaceIndices(
            std::vector<csl::Index> const &oldIndices,
            std::vector<csl::Index> const &newIndices,
            bool         refresh = true,
            bool         flipped = false) const override;

    Tensor getPoint() const override;

    virtual std::optional<Expr> factor(bool full=false) const override;

    virtual std::optional<Expr> factor(Expr_info expr,
                                       bool      full=false) const override;

    virtual std::optional<Expr> collect(
            std::vector<Expr> const &factors,
            bool                     full = false
            ) const override;

    virtual std::optional<Expr> expand(bool full=false,
                                       bool inPlace=false) const override;

    virtual std::optional<Expr> expand_if(
            std::function<bool(Expr const&)> const& f,
            bool full=false,
            bool inPlace=false) const override;

    bool dependsOn(Expr_info expr) const override;

    bool dependsOn(const AbstractParent* parent) const override;

    bool dependsExplicitlyOn(Expr_info expr) const override;

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

    int isPolynomial(Expr_info expr) const override;

    bool operator<(Expr_info other) const override;

    Expr const &operator[](int i) const override;

    Expr& operator[](int i) override;
};

/*************************************************/
// Inline functions                              //
/*************************************************/
inline AbstractFunc::AbstractFunc(): Abstract(), argument(CSL_0){}
inline AbstractFunc::AbstractFunc(const Expr& t_argument)
    :Abstract(), argument(t_argument)
{}

inline AbstractDuoFunc::AbstractDuoFunc(): Abstract(){
    argument[0] = CSL_0;
    argument[1] = CSL_0;
}

inline AbstractDuoFunc::AbstractDuoFunc(
        const Expr& left,
        const Expr& right
        ): Abstract(){
    argument[0] = left;
    argument[1] = right;
}

inline AbstractMultiFunc::AbstractMultiFunc()
    :Abstract(), argument(csl::vector_expr(alloc_expr))
{

}

} // End of namespace csl

#endif